spring AOP之代理模式

 先说java中的面向对象（oop），在面向对象中一些公共的行为，像日志记录，权限验证等如果都使用面向对象来做，会在每个业务方法中都写上重复的代码，纵向抽取机制解决，造成代码的冗余。而AOP指的是面向切面编程，扩展功能而不需修改源码实现，采用横向抽取机制。定义一个切面，用切面去切相应的方法，就可以织入相关的逻辑。而AOP底层用动态代理模式。

一、代理模式

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

二、静态代理

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

package com.bsoft.proxy2;
/**
 * 公共接口
 */
public interface IUserDao {

    void save();

    void find();
}

被代理类(代理目标类)：

package com.bsoft.proxy2.impl;

import com.bsoft.proxy2.IUserDao;
/**
 * 被代理类或者叫代理目标类
 */
public class UserDaoImpl implements IUserDao {
    @Override
    public void save() {
        System.out.println("模拟保存用户");
    }

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

其次是代理类

package com.bsoft.proxy2.impl;

import com.bsoft.proxy2.IUserDao;

/**
 * 代理类
 */
public class UserDaoProxy implements IUserDao {

    private UserDaoImpl ud = new UserDaoImpl();

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

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

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

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

package com.bsoft.proxy2;

import com.bsoft.proxy2.impl.UserDaoImpl;
import com.bsoft.proxy2.impl.UserDaoProxy;
import org.junit.Test;

public class Test2 {

    /**
     * 未使用代理，直接使用被代理类
     */
    public  void test1() {
        System.out.println("------未使用代理模式----------");
        IUserDao iUserDao=new UserDaoImpl();
        iUserDao.save();
        System.out.println("----------------");
        iUserDao.find();
    }

    /**
     * 静态代理
     * 使用静态代理和不使用静态代理，可以发现使用了代理之后，可以在被代理方法的执行前或后加入别的代码，实现诸如权限及日志的操作
     */
    @Test
    public void test2(){
        System.out.println("-------静态代理模式--------");
        IUserDao iUserDao=new UserDaoProxy();
        iUserDao.save();
        System.out.println("--------------------");
        iUserDao.find();
    }
}

测试test1返回的执行结果如下：

------未使用代理模式----------
模拟保存用户
----------------
模拟查询用户

测试test2返回的执行结果如下：

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

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

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

三、JDK动态代理

JDK提供了动态代理的方式，可以生成代理类，被代理类和接口沿用静态代理中的IUserDao和UserDaoImpl下面看代理类：

package com.bsoft.proxy3;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * jdk动态代理类
 */
public class DynamicProxy implements InvocationHandler {

    //被代理的实例
    private IUserDao iUserDao;

    //构造方法
    public DynamicProxy(IUserDao iUserDao){
        this.iUserDao=iUserDao;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result=null;
        System.out.println("开始jdk动态代理");
       result= method.invoke(iUserDao,args);
        System.out.println("结束jdk动态代理");
        System.out.println("result===="+result);
        return result;
    }
}

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

package com.bsoft.proxy3;

import com.bsoft.proxy2.impl.UserDaoImpl;

import java.lang.reflect.Proxy;

public class Test3 {

    /**
     * jdk动态代理测试
     */
    public static void main(String[] args) {

        UserDaoImpl userDao=new UserDaoImpl();
        DynamicProxy dynamicProxy=new DynamicProxy(userDao);

        //生成代理对象 第一个为被代理类的类加载器，第二个为被代理类实现的接口，第三个则为invocationHandler的实现类，这样就生成了代理对象
        IUserDao iUserDao= (IUserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),userDao.getClass().getInterfaces(),dynamicProxy);
        iUserDao.save();
        System.out.println("------------------");
        iUserDao.find();
    }
}

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

开始jdk动态代理
模拟保存用户
结束jdk动态代理
result====null
------------------
开始jdk动态代理
模拟查询用户
结束jdk动态代理
result====null

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

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

四、CGLib动态代理

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

要使用CGLib必须要引入第三方类库。asm-3.2.jar,cglib-2.22.jar。

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

package com.bsoft.proxy4;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * cglib动态代理
 */
public class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始CGLib动态代理");
        Object object=proxy.invokeSuper(obj, args);
        System.out.println("结束CGLib动态代理");
        return object;
    }
}

被代理类：

package com.bsoft.proxy4;

public class TeacherDao {

    public void save() {
        System.out.println("模拟保存老师");
    }

    public void find() {
        System.out.println("模拟查询老师");
    }
}

其，测试代码如下：

package com.bsoft.proxy4;

import net.sf.cglib.proxy.Enhancer;

public class Test4 {

    /**
     * cglib动态代理测试
     * @param args
     */
    public static void main(String[] args) {
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(TeacherDao.class);
        enhancer.setCallback(new MyMethodInterceptor());
        //生成代理类
        TeacherDao teacherDao=(TeacherDao) enhancer.create();
        teacherDao.save();
        System.out.println("----------------");
        teacherDao.find();
    }
}

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

开始CGLib动态代理
模拟保存老师
结束CGLib动态代理
----------------
开始CGLib动态代理
模拟查询老师
结束CGLib动态代理

在设置回调enhancer.setCallback的时候需要传入MethodInterceptor的实例，这里可以使用匿名内部类的方式。

五、总结

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