Java及Spring框架中的AOP技术汇总--原理篇

Spring框架目前是Java中主流的web开发框架，其两大技术基石是: Ioc容器以及AOP
本系列关注AOP相关内容

1. 什么是AOP:

AOP: (Aspect Oriented Programming) 面向切面编程。是目前软件开发中的一个热点，也是Spring框架中重点。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。

2. AOP的本质是Hook（方法的拦截）

在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程

在c/c++中，拦截方法的二进制代码，就是传说中的外挂破解技术。

3. 利用虚函数动态绑定来模拟AOP：

• 先定义一个IGreet的接口:

package blf_aop_demo;
/*
1. 从java语言的角度来演示aop的两种实现(基于接口实现和基于类实现)
2. spring
*/
public interface IGreet {
    void sayHello(String name);

    void sayGoodBye(String name);
}

• 实现该接口:

package blf_aop_demo;

public class GreetImp implements IGreet {
    public void sayHello(String name) {
        System.out.println("Hello " + name);
    }

    public void sayGoodBye(String name) {
        System.out.println("GoodBye " + name);
    }
}

• 实现一个代理类，并且实现IGreet接口，在代理类中引用GreetImp:

package blf_aop_demo;

//1. GreetProxy: 实现了IGreet接口
public class GreetProxy implements IGreet {

    //2. 又引用了一个IGreet接口
    private IGreet target = null;
    
    //3. 通过构造函数让target指向实现者
    public GreetProxy(IGreet target){
        this.target = target;
    }
    
    //4. 重写了基类的sayHello函数
    public void sayHello(String name) {
        //4.1 在调用所代理的目标的sayHello前，先做一些你想做的事情
        System.out.println("--before method sayHello");
        
        //4.2 调用被代理的目标的sayHello函数
        target.sayHello(name);
        
        //4.3 完成后，做一些你想做的事情
        System.out.println("--after method sayHello");
        
        //由此可见，这是经典的代理设计模式的实现
    }
    
    //5. 同上原理
    public void sayGoodBye(String name) {
        System.out.println("--before method goodBye");
        target.sayGoodBye(name);
        System.out.println("--after method goodBye");
    }

}

• 测试代码:

public class AopDemo {
    
    public static void testGreet(){
        //给GreetImp分配内存，注意返回的是IGreet接口
        IGreet real = new GreetImp();
        
        //代理也是返回IGreet，同时构造函数也传入一个来自GreetImp的接口(real真实对象)
        IGreet greet = new GreetProxy(real);
        
        //利用虚函数动态绑定机制(多态)，此时调用的是GreetProxy中的sayHello和sayGoodBye
        greet.sayHello("jacky");
        greet.sayGoodBye("jacky");
    }

       public static void main(String[] args) {
              System.out.println("blf_aop_demo_test");
              testGreet();
      }
}

• 输出结果:

blf_aop_demo_test
--before method sayHello
Hello jacky
--after method sayHello
--before method goodBye
GoodBye jacky
--after method goodBye

由此可见，aop最基础的实现原理就是:proxy设计模式，利用虚函数动态绑定机制

但是，很麻烦，需要声明接口，然后生成一个实现类，以及一个代理类，在代理类中又要实现接口，并且调用实现类的方法。这些都是很通用，一成不变的操作。通过使用java反射机制，很容易的变成一套固定的框架.这个在jdk中已经帮你弄好了，下一篇我们来看一下JDKProxy方式的使用！