Spring - AOP（个人总结，仅供参考）

什么是AOP?

AOP（Aspect Oriented Programming）又叫面向切面编程。它是一种编程思想，它会对业务逻辑的各个部分进行隔离，实现业务逻辑各个部分的松耦合，提高了程序的可重用性，已经开发效率。

为什么需要AOP？

我们知道如今OOP正在主宰着软件行业，OOP它将需求抽象出来，封装成一个个独立的类，每个类中拥有自己的字段和行为（方法），让类与类之间来相互依赖，相互协作。
- 但这其实是有点问题的，这样做会出现一种情况，那就是很多不同业务的类中，存在大量的功能相同或相似的行为。这其实是一个代码的坏味道——重复代码（Duplicated Code）。
- 还可能面临的一个问题就是大量行为在细微程度上的变化。
如果只是相同的行为我们只需要将它独立并提取出来即可，但对于相似的行为和易变化的行为处理起来就很困难。虽然GoF给我们提供了装饰模式这个解决方案，但对于细粒的模块大面积的采用装饰模式，势必会提升系统的复杂性，不利于维护。
这时候AOP的作用就发挥出来了。它是将业务逻辑的各个部分（方法）进行了隔离，在执行业务逻辑的时候，只需要将这各个部分进行组装即可。
- 这样做就能减少重复代码，使得一旦代码需要进行修改，只需要更改一处的代码。
- 对于易变化的行为，只需要在配置中更改它的切面即可。
这就提高了代码的维护性、可重用性以及灵活性。

AOP是如何做的？

AOP是根据反射和动态代理来运转的。以AOP来编写的代码，在调用方法的时候，不会直接调用真实对象的具体方法。它会根据真实对象的信息，动态生成一个它的接口的代理对象。在调用的时候，它去调这个代理对象中的方法，从而根据多态间接的调用到真实对象的方法。

这就让代码变的灵活了起来。因为我们可以在外部，通过配置等方式来控制这个代理对象的生成，从而可以为它在真实调用的这个切入点周围进行切面（方法）织入，来对这个切入点进行增强。一旦需求发生变化，只需要调整配置文件，修改织入的切面即可。

并且通过这种方式，就可以将不同业务逻辑中相似的代码全都独立出来，分割成更为细小的单元。再利用切面织入的方式就能组装成满足业务需求部分。

参考代码如下：

动态代理实现方式

public interface ITest {
    void Fun();
    void Fun1();
}

public class Test implements ITest{
    public void Fun(){
        System.out.println("Test类的Fun方法被执行！");
    }

    @Override
    public void Fun1() {
        System.out.println("Test类的Fun1方法被执行！");
    }
}

public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    //动态生成并得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(
                this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    //处理代理类的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("========方法开始执行========");
        Object result = method.invoke(target, args);
        System.out.println("========方法执行结束========");
        return result;
    }
}

public class Program {
    public static void main(String[] args) {
        ProxyInvocationHandler proxyInvocationHandler =
                new ProxyInvocationHandler();
        Test test = new Test();

        proxyInvocationHandler.setTarget(test);
        //代理的是接口，而不是类
        ITest proxy = (ITest) proxyInvocationHandler.getProxy();
        proxy.Fun();
        System.out.println();
        proxy.Fun1();
        
/*     运行结果：
 *     ========方法开始执行========
 *     Test类的Fun方法被执行！
 *     ========方法执行结束========
 * 
 *     ========方法开始执行========
 *     Test类的Fun1方法被执行！
 *     ========方法执行结束========
 */
    }
}

Spring使用AOP

<!-- pom.xml AOP的依赖包 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.1.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.2.1.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.2</version>
</dependency>

<?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/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="Test" class="com.XiaoJie.Test"/>
    <bean id="AdvisorBefore" class="com.XiaoJie.AdvisorBefore"/>
    <bean id="AdvisorAfter" class="com.XiaoJie.AdvisorAfter"/>
    <bean id="Program" class="com.XiaoJie.Program"/>

    <aop:config>
        <aop:pointcut id="TestCut" expression="execution(* com.XiaoJie.Test.*(..))"/>

        <aop:advisor advice-ref="AdvisorBefore" pointcut-ref="TestCut"/>
        <aop:advisor advice-ref="AdvisorAfter" pointcut-ref="TestCut"/>
    </aop:config>
</beans>

public class AdvisorAfter implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("========方法执行结束========");
    }
}

public class AdvisorBefore implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("========方法开始执行========");
    }
}

public interface ITest {
    void Fun();
    void Fun1();
}

public class Test implements ITest{
    @Override
    public void Fun(){
        System.out.println("Test类的Fun方法被执行！");
    }
    @Override
    public void Fun1() {
        System.out.println("Test类的Fun1方法被执行！");
    }
}

public class Program {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("Beans.xml");
        //AOP代理的是接口，所以这里的类型不能是类
        ITest test = context.getBean("Test",ITest.class);
        test.Fun();
        System.out.println();
        test.Fun1();
        
/*      运行结果：
 *      ========方法开始执行========
 *      Test类的Fun方法被执行！
 *      ========方法执行结束========
 *      
 *      ========方法开始执行========
 *      Test类的Fun1方法被执行！
 *      ========方法执行结束========
 */
    }
}