AOP底层实现原理

实现原理

AOP底层实现原理：动态代理。

• 基于接口的代理，使用JDK动态代理。
• 基于类的代理，使用CGLIB动态代理。

JDK动态代理

简单实现JDK动态代理：

创建一个接口：

public interface UserService {
    /**
     * 添加方法
     */
    void add();
}

创建实现类：

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("添加了一个用户");
    }
}

JDK动态代理工厂类：

public class JdkProxyFactory implements InvocationHandler {

    private Object target;

    public JdkProxyFactory(Object target){
        this.target = target;
    }

    /**
     * 使用newProxyInstance获取代理对象
     * @return
     */
    public Object getProxyObject(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader()
        ,target.getClass().getInterfaces(),this
        );
    }

    /**
     * 实现增强代码
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("增强功能");
        return method.invoke(target,args);
    }

测试代码：

public class AopTest {
    @Test
    public void test(){
    	//创建目标对象
        UserServiceImpl userService = new UserServiceImpl();
        //创建代理工厂对象
        JdkProxyFactory factory = new JdkProxyFactory(userService);
        UserService proxy = (UserService)factory.getProxyObject();
        proxy.add();
    }
}

JDK动态代理总结：InvocationHandler +Proxy.newProxyInstance()。

• InvocationHandler 是一个接口，通过实现该接口定义横切逻辑，并通过反射机制调用目标类的方法，动态的将横切逻辑和业务逻辑编制在一起。
• JDK动态代理要求被代理对象（接口实现类）通过反射注入到中间对象（JdkProxyFactory），且中间对象实现InvocationHandler 接口。重写invoke方法，invoke方法中编写增强代码。
• Proxy.newProxyInstance()能利用中间对象（JdkProxyFactory）来生产代理对象。代理对象利用InvocationHandler接口动态创建一个符合某一接口的实例。
• 被代理的对象必须实现接口，而且只有接口中的方法才能被代理。

CGLIB动态代理

创建一个类：

public class BookService {
    public void add(){
        System.out.println("添加一本书");
    }
}

创建代理对象工厂类：

public class GcLibProxyFactory implements MethodInterceptor {
    private Object target;

    public GcLibProxyFactory(Object target){
         this.target = target;
    }

    public Object getProxyObject(){
        Enhancer enhancer = new Enhancer();
        //设置生成代理类的目标对象（代理类对象是目标对象的子类）
        enhancer.setSuperclass(target.getClass());
        //设置回调方法
        enhancer.setCallback(this);
        return enhancer.create();
    }


    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("增强方法");
        return method.invoke(target,objects);
    }
}

测试方法：

  @Test
    public void test2(){
        //创建对象
        BookService bookService = new BookService();
        //创建代理工厂
        GcLibProxyFactory proxyFactory = new GcLibProxyFactory(bookService);
        //创建代理对象
        BookService proxy= (BookService)proxyFactory.getProxyObject();
        proxy.add();
    }

GCLIB动态代理总结：

• 实现 MethodInterceptor接口，重写其 interceptor()方法 。
• CGLib采用非常底层的字节码文件，可以为一个类创建子类，并在子类采用方法拦截的技术拦截所有父类方法的调用，并顺势植入横切逻辑。
• 继承被代理对象，然后重写被代理的方法，再覆盖该方法时，插入自己的代码，通过CglibMethodInvocation来启动配置的通知。
• enhaner.create创建代理对象。
• 因为需要重写被代理对象的方法，所以被代理的方法不能使final方法，因为final方法不能被覆盖。