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

    org.springframework
    spring-context
    5.2.1.RELEASE



    org.springframework
    spring-core
    5.2.1.RELEASE



    org.aspectj
    aspectjweaver
    1.9.2

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方法被执行！
 *      ========方法执行结束========
 */
    }
}