假如我们的系统的很多模块都需要实现一些相同的功能，这些相同的功能被称为横切关注点，在切面出现之前，我们可以使用继承或委托来实现这些相同的功能，但是这种做法会增加系统不同模块之间的耦合，关于AOP的术语，有下面一些

1、通知，定义了切面是什么以及何时使用，通知的类型包括前置通知、后置通知、返回通知、异常通知和环绕通知
2、连接点，是指应用在执行过程中能够插入的一个点
3、切点，定义了切面的工作范围
4、切面，是通知和切点的结合
5、引入，引入允许我们向现有的类添加新的方法或属性
6、织入，把切面应用到目标对象并创建新的代理对象的过程时，在目标对象的多个生命周期内，有多个点可以织入，包括编译期、类加载期和运行期,Spring是在运行期采取织入这种方法的

Spring对AOP的支持
Spring提供了4中类型的AOP支持

1、基于代理的经典Spring AOP
2、纯POJO切面
3、@AspectJ注解驱动的切面
4、注入式AspectJ切面

在Spring中使用AspectJ进行制造切点时，我们使用AspectJ的切点表达式语言来定义Spring切面，Spring AOP只支持下面的几种AspectJ指示器

切面的编写格式如下

execution(* com.fan.aop.Performance.perform(..))

具体的解释如下

1、*，返回值部分，在这里表示任意的返回值
2、com.fan.aop.Performance.perform，表示织入切面的方法
3、(..)，参数部分，在这里参数为任意参数
4、execution，表示触发的时机，execution表示在执行的时候触发

切面的实例

首先我们创建一个接口

public interface Performance {
    public void perform();
}

实现该接口为Dancer

@Component
public class Dancer implements Performance {
    @Override
    public void perform() {
        System.out.println("Dancing Liking a Swan");
    }
}

创建一个切面的POJO

@Aspect
public class Audience {
    @Before("execution(* com.fan.aop.Performance.perform(..))")
    public void silenceCellPhone(){
        System.out.println("Silence cell phone");
    }

    @Before("execution(* com.fan.aop.Performance.perform(..))")
    public void takeSeats(){
        System.out.println("Take seats");
    }

    @AfterReturning("execution(* com.fan.aop.Performance.perform(..))")
    public void applause(){
        System.out.println("Applause!");
    }

    @AfterThrowing("execution(* com.fan.aop.Performance.perform(..))")
    public void demandRefund(){
        System.out.println("Demand refund");
    }
}

使用JavaConfig来进行配置

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class ConcertConfig {
    @Bean
    public Audience audience(){
        return new Audience();
    }
}

测试并查看结果

public class Main {
    public static void main(String[] args){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConcertConfig.class);
//        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("AOPConfig.xml");
        Performance dancer = context.getBean(Performance.class);
        dancer.perform();
        context.close();
    }
}

看上面，我们发现Audience 的实现中有一些是重复的，因此我们可以使用@Ponitcut注解来进行管理，重写如下

@Aspect
public class AudienceBeta {
    @Pointcut("execution(* com.fan.aop.Performance.perform(..))")
    public void performance(){}

    @Before("performance()")
    public void silenceCellPhone(){
        System.out.println("Silence cell phone");
    }

    @Before("performance()")
    public void takeSeats(){
        System.out.println("Take seats");
    }

    @AfterReturning("performance()")
    public void applause(){
        System.out.println("Applause!");
    }

    @AfterThrowing("performance()")
    public void demandRefund(){
        System.out.println("Demand refund");
    }
}

除了使用JavaConfig的方式来配置切面，我们也可以使用XML文件的方法来进行配置，如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
                     http://www.springframework.org/schema/aop
                     http://www.springframework.org/schema/aop/spring-aop.xsd
                     http://www.springframework.org/schema/beans
                     http://www.springframework.org/schema/beans/spring-beans.xsd">

       <aop:aspectj-autoproxy/>
       <bean class="com.fan.aop.Audience"/>
       <bean class="com.fan.aop.Dancer"/>
</beans>

测试的地方只需要修改获取bean的方式就可以了，在这里是将

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConcertConfig.class);

替换为

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("AOPConfig.xml");

在切面方法中，我们注意有使用多个AspectJ的注解，它们的意义如下

通知中包含参数的写法

@Pointcut("execution(* com.fan.soundsystem.CompactDisc.playTrack(int)) && args(trackNumber)")
    public void trackPlayed(int trackNumber){}

使用XML进行配置

创建无注解的类

public class AudienceGama {
    public void silenceCellPhone(){
        System.out.println("Silencing cell phone");
    }

    public void takeSeats(){
        System.out.println("Taking seats");
    }

    public void applause(){
        System.out.println("CLAP CLAP CLAP!!!");
    }

    public void demandRefund(){
        System.out.println("Demanding a refund");
    }
}

创建对应的XML文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

       <bean id="audienceGama" class="com.fan.aop.AudienceGama"/>
       <bean id="Dancer" class="com.fan.aop.Dancer"/>

       <aop:config>
              <aop:aspect ref="audienceGama">
                     <aop:before pointcut="execution(* com.fan.aop.Performance.perform(..))"
                                 method="silenceCellPhone"/>
                     <aop:before pointcut="execution(* com.fan.aop.Performance.perform(..))"
                                 method="takeSeats"/>
                     <aop:after-returning pointcut="execution(* com.fan.aop.Performance.perform(..))"
                                 method="applause"/>
                     <aop:after-throwing pointcut="execution(* com.fan.aop.Performance.perform(..))"
                                 method="demandRefund"/>
              </aop:aspect>
       </aop:config>
</beans>

创建测试代码

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("XmlAopConfig.xml");
Performance performance = context.getBean(Performance.class);
performance.perform();
context.close();

运行并查看结果