SpringAOP代理模式(静态、动态)

SpringAOP的代理模式

代理模式作为23种经典设计模式之一，其比较官方的定义为“为其他对象提供一种代理以控制对这个对象的访问”，简单点说就是，之前A类自己做一件事，在使用代理之后，A类不直接去做，而是由A类的代理类B来去做。代理类其实是在之前类的基础上做了一层封装。java中有静态代理、JDK动态代理、CGLib动态代理的方式。静态代理指的是代理类是在编译期就存在的，相反动态代理则是在程序运行期动态生成的

一、静态代理

静态代理的特点是, 为每一个业务增强都提供一个代理类, 由代理类来创建代理对象

静态代理，简单点来说就是在程序运行之前，代理类和被代理类的关系已经确定。静态代理的实现方式一般有以下几个步骤，首先要定义一个公共的接口，供代理类和被代理类实现，如下

公共接口

/**
 * 这是一个公共的接口
 */

public interface publicInterface {

    void save();
    void find();
}

被代理类

/**
 * 被代理类
 */
public class UserDao implements publicInterface {

    @Override
    public void save() {
        System.out.println("模拟保存用户");
    }

    @Override
    public void find() {
        System.out.println("模拟查询用户");
    }
}

从被代理类上可以看到，被代理类要做的就是save和find操作，如果不使用代理模式，那么我们的使用方式则是直接使用，如下

public class test {
    public static void main(String[] args) {
        //不使用代理类
        UserDao userDao = new UserDao();
        userDao.save();
        System.out.println("---------------");
        userDao.find();
        System.out.println("*****************");
        //使用代理类
        publicInterface proxyUserDao = new proxyUserDao();
        proxyUserDao.save();
        System.out.println("----------------");
        proxyUserDao.find();
    }
}

通过测试方法，可以得出执行方法的结果如下，

模拟保存用户
---------------
模拟查询用户

代理类

/**
 * 这是一个代理类
 */
public class proxyUserDao implements publicInterface{

   private UserDao userDao=new UserDao();

    @Override
    public void save() {
        System.out.println("代理操作，开启事务");
        userDao.save();
        System.out.println("代理操作，关闭事务");
    }

    @Override
    public void find() {
        System.out.println("代理操作，开启事务");
        userDao.find();
        System.out.println("代理操作，关闭事务");
    }
}

可以看到代理类的实现逻辑是在代理类中持有一个被代理类的实例，通过被代理类实例调用被代理对象的方法，另外在方法之前前后均可加入其它的方法处理逻辑，

最后，看使用代理类的测试方法：

public class test {
    public static void main(String[] args) {
        //使用代理类
        publicInterface proxyUserDao = new proxyUserDao();
        proxyUserDao.save();
        System.out.println("----------------");
        proxyUserDao.find();
    }
}

返回的执行结果如下：

代理操作，开启事务
模拟保存用户
代理操作，关闭事务
----------------
代理操作，开启事务
模拟查询用户
代理操作，关闭事务

对比，使用静态代理和不使用静态代理，可以发现使用了代理之后，可以在被代理方法的执行前或后加入别的代码，实现诸如权限及日志的操作。

但是，静态代理也存在一定的问题，如果被代理方法很多，就要为每个方法进行代理，增加了代码维护的成本。有没有其他的方式可以减少代码的维护，那就是动态代理。

二、动态代理

静态代理会为每一个业务增强都提供一个代理类, 由代理类来创建代理对象, 而动态代理并不存在代理类, 代理对象直接由代理生成工具动态生成

1、JDK动态代理

JDK提供了动态代理的方式，可以生成代理类

动态代理类，如下：

/**
 * 这是一个动态代理
 */
public class DynamicProxy implements InvocationHandler {

    private UserDao userDao=null; //被代理对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("开始JDK动态代理");
        method.invoke(userDao,args);
        System.out.println("结束JDK动态代理");
        return null;
    }

    //构造方法
    public  DynamicProxy(UserDao userDao){
        this.userDao=userDao;
    }

}

需要实现JDK中的InvocationHandler接口，实现其中的invoke方法，在此方法中通过反射的方式调用被代理类的方法，可以在方法执行前或后进行别的处理，下面看测试代码

/**
 * JDK动态代理
 */
public class DynamicProxyTest {

    public static void main(String[] args) {

        UserDao userDao = new UserDao();

        DynamicProxy dynamicProxy = new DynamicProxy(userDao);
        //生成代理对象
        /**
         * 三个参数
         * 1.被代理类的类加载器
         * 2.被代理类实现的接口
         * 3.invocationHandler的实现类
         */
        publicInterface proxyInstance =
                (publicInterface) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
                userDao.getClass().getInterfaces(),
                dynamicProxy);
        proxyInstance.save();
        System.out.println("-------------");
        proxyInstance.find();


    }
}

在测试代码中通过Proxy类的newProxyInstance方法，生成代理类的proxyInstance，需要三个参数，第一个为被代理类的类加载器，第二个为被代理类实现的接口，第三个则为invocationHandler的实现类，这样就生成了代理对象，然后通过代理对象调用方法执行结果如下，

开始JDK动态代理
模拟保存用户
结束JDK动态代理
-------------
开始JDK动态代理
模拟查询用户
结束JDK动态代理

从上面可以看出代理类是由Proxy这个类通过newProxyInstance方法动态生成的，生成对象后使用“实例调用方法”的方式进行方法调用，那么代理类的被代理类的关系只有在执行这行代码的时候才会生成，因此成为动态代理。

JDK的动态代理也存在不足，即被代理类必须要有实现的接口，如没有接口则无法使用JDK动态代理（从newProxyInstance方法的第二个参数可得知，必须传入被代理类的实现接口），那么需要使用CGLib动态代理。

2、CGLib动态代理

CGLib动态代理是一个第三方实现的动态代理类库，不要求被代理类必须实现接口，它采用的是继承被代理类，使用其子类的方式，弥补了被代理类没有接口的不足，

要使用CGLib必须要引入第三方类库，我这里使用的类库加入依赖

        <!--CGLib动态代理-->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>

        <dependency>
            <groupId>org.ow2.asm</groupId>
            <artifactId>asm</artifactId>
            <version>9.1</version>
        </dependency>
    </dependencies>

定义一个没有实现接口的类

/**
 * 这是一个没有实现接口的一个类
 */
public class CGLibProxy {

    public CGLibProxy(){
        System.out.println("CGLibProxy构造方法");
    }

    public void hello() {
        System.out.println("你已经进入CGLib动态代理!");
    }

    /**
     * 该方法不能被子类覆盖,Cglib是无法代理final修饰的方法的
     */
    final public String sayOthers(String name) {
        System.out.println("CGLibProxy:hello>>" + name);
        return null;
    }

}

要使用CGLib代理需要实现其MethodInterceptor接口:

/**
 * 自定义一个MethodInterceptor
 */
public class MyMethodInterceptor implements MethodInterceptor {

    /**
     *
     * @param obj :cglib生成的代理对象
     * @param method :被代理对象方法
     * @param args :方法入参
     * @param methodProxy :代理方法
     * @return
     * @throws Throwable
     */
 @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

     System.out.println("CGLib动态代理开始");
//     Object object = methodProxy.invoke(obj, args);
     Object object = methodProxy.invokeSuper(obj, args);
     System.out.println("CGLib动态代理结束");

     return object;
    }
}

生成CGLIB代理对象调用目标方法测试类

public class CGLibProxyTest {
    public static void main(String[] args) {
        // 通过CGLIB动态代理获取代理对象的过程
        Enhancer enhancer = new Enhancer();
        // 设置enhancer对象的父类
        enhancer.setSuperclass(CGLibProxy.class);
        // 设置enhancer的回调对象
        enhancer.setCallback(new MyMethodInterceptor());
        // 创建代理对象
        CGLibProxy cgLibProxy = (CGLibProxy) enhancer.create();

        // 通过代理对象调用目标方法
        cgLibProxy.hello();
        cgLibProxy.sayOthers("final修饰的方法");
    }
}

可以看出使用Enhancer生成代理类，需要设置被代理类，也就是父类（从这里可以看出是使用继承，生成的子类），设置回调方法。

CGLibProxy构造方法
CGLib动态代理开始
你已经进入CGLib动态代理!
CGLib动态代理结束
CGLibProxy:hello>>final修饰的方法

在设置回调enhancer.setCallback的时候需要传入MethodInterceptor的实例

并且final类无法进行代理

五、总结

对静态代理、JDK动态代理、CGLib动态代理做一个总结，静态代理的维护成本比较高，有一个被代理类就需要创建一个代理类，而且需要实现相同的接口。JDK动态代理模式和CGLib动态代理的区别是JDK动态代理需要被代理类实现接口，而CGLib则是生成被代理类的子类，要求被代理类不能是final的，因为final类无法被继承。