Spring AOP 代理模式解析

什么是代理模式

代理模式是一种设计模式，它的核心作用是通过代理对象，控制对目标对象的访问。用户从直接访问目标对象，变成访问代理对象。

代理模式的设计思想：

定义一个抽象角色：一般就是一个接口，该接口必须被代理对象和目标对象所实施。
　
编写目标对象：实现了抽象角色，该对象被代理对象调用。它只关注业务代理。
　
编写代理类：实现抽象的角色（接口），在实现的方法中添加增强的代码，同时调用目标对象的方法。

代理模式分类

静态代理：接口、目标类、静态代理类、工厂类、实现类
　
动态代理：又可分为CGLIB、JDK

CGLib动态代理和JDK动态代理的区别

增强的时机不同，调用代理对象执行代理方法时候，JDK方式是在执行的时候增强的，而CGLib方法是在字节码进行编译的时候就进行了增强。
对公共接口的依赖不同，JDK方法，必须由公共的公共的接口，也就是需要由抽象对象。而CGLib可以没有接口。

静态代理项目演示

//接口
public interface UserDao {
    boolean findInfo();
}

以下代码并非在同一类下，请按注释区分

//目标类
public class MySqlUserDao implements UserDao {
    @Override
    public boolean findInfo() {
        System.out.println("MySQl");
        return true;
    }
}
//静态代理类
public class StaticUserProxy implements UserDao {
    private UserDao targetObject;
    public StaticUserProxy(UserDao targetObject) {
        this.targetObject = targetObject;
    }
}
//工厂类
public class userDaoFactory {
    public static UserDao newInstance(UserDao userdao){
        StaticUserProxy proxy=new StaticUserProxy(userdao);
        return proxy;
    }
 }
//测试类
@Test
public void test4(){
    UserDao userDao = new MySqlUserDao();
    UserDao proxy=new StaticUserProxy(userDao);
    proxy.findInfo();
}       

我们不想为每个需要增强的目标类编写代理类，因为不如此，代理类会很多不是很方便。所以JDK给我们提供了一个接口InvocationHandler， 我们只要在工厂中实现给接口就可以获得代理对象。

JDK动态代理实现演示

（1）目标类实现接口（同上）
（2）动态代理不需要代理类（去除）
（3）创建动态工厂类（如下） （4）测试（如下）

public class userDaoProxFactory implements InvocationHandler {
    private UserDao targetObject;
    //传入目标对象
    public userDaoProxFactory(UserDao targetObject) {
        this.targetObject = targetObject;
    }
    //返回代理对象
    public UserDao getInstance(){
        UserDao ud= (UserDao) Proxy.newProxyInstance(
        //反射对象的类装载器
                targetObject.getClass().getClassLoader(),
        //反射对象接口的反射集合
                targetObject.getClass().getInterfaces(),
                this);
        return ud;
    }
    //填写增强方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置增强");
        Object obj=method.invoke(targetObject,args);
        System.out.println("后置增强");
        return obj;
    }
}
//-----测试-----
//JDK动态代理
@Test
public void test5(){
    UserDao ud = new MySqlUserDao();
    userDaoProxFactory udpf = new userDaoProxFactory(ud);
    UserDao proxy = udpf.getInstance();
    proxy.findInfo();
}

CGlib动态代理是基于MethodInterceptor接口实现

CGlib实现动态代理演示

（1）目标类（同上） （2）工厂类（如下） （3）测试类（如下）

public class userDaoCGlibF implements MethodInterceptor {
    private UserDao targetObject;
    //传入目标对象
    public userDaoCGlibF(UserDao targetObject) {
        this.targetObject = targetObject;
    }

    public UserDao getInstance(){
        //字节码增强器，对目标类进行扩展
        Enhancer enhancer = new Enhancer();
        //将目标类进行增强，并设为f父类
        enhancer.setSuperclass(this.targetObject.getClass());
        //回调方法，设置拦截
        enhancer.setCallback(this);
        //创建代理对象
        UserDao ud = (UserDao) enhancer.create();
        return ud;
    }

    /**
     * 就是对目标对象的方法进行增强的方法
     * @param o 代理对象
     * @param method  目标对象的方法的反射对象
     * @param objects 方法的参数
     * @param methodProxy 方法的代理
     * @return 代理方法执行的返回值
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("前值增强");
        Object obj = method.invoke(targetObject, objects);
        System.out.println("后置增强");
        return obj;
    }
}

//--------------测试类-----------------------------
//CGlib动态代理
@Test
public void test6(){
    UserDao ud = new MySqlUserDao();
    userDaoCGlibF udcg = new userDaoCGlibF(ud);
    UserDao proxy = udcg.getInstance();
    proxy.findInfo();
}