Java中的动态代理

前言

    学编程离不开设计模式，设计模式中有一个代理模式，最开始学代理模式并不知道它在Java的学习中，占据这么重要的地位，只觉得它是一个设计模式，没有想过它到底怎么用。后来才发现，代理模式是AOP实现的重要原理。

JDK的动态代理

    JDK的动态代理是对使用接口的类进行代理，它需要真实角色和代理角色。JDK动态代理涉及到java.lang.reflect包中的两个类：Proxy和InvocationHandler。其中InvocationHandler是一个接口，AOP通过实现该接口来定义横切逻辑，并通过反射机制调用目标类，动态的将横切代码切入业务逻辑。Proxy通过InvocationHandler来动态创建一个符合某个接口的实例，生成目标类的代理对象。

    JDK的动态代理类要实现InvocationHandler接口，在这个类里面有两个方法一个对象。这个对象是类私有的，表示调用的目标类对象；一个方法新建代理实例，这个方法是Proxy类来创建的，然后把这个目标实例赋给目标类对象，最后这个对象调用invoke方法；另一个方法就是invoke方法，这个方法就是代理类的逻辑，也就是代理类要做的事情。

public class SecurityHandler implements InvocationHandler {
//定义调用的目标类对象
private Object targetObject;
//创建一个代理实例
public Object createProxyInstance(Object targetObject) {
this.targetObject = targetObject;
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(),
this);
}
//代理类的执行过程
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
checkSecurity();

//调用目标方法，代理模式思想的体现
Object ret = method.invoke(targetObject, args);

return ret;
}
//代理类要执行的内容
private void checkSecurity() {
System.out.println("-------checkSecurity-------");
}
}

            在Proxy类创建代理实例时，需要传入三个参数，一个是被代理的类，一个是被代理类实现的接口，一个是创建的实例对象。从传入参数即可看出，JDK的动态代理只能对实现接口的类创建代理类。

//被代理类实现的接口
public interface UserManager {

public void addUser(String username, String password);

public void delUser(int userId);

public String findUserById(int userId);

public void modifyUser(int userId, String username, String password);
}

//被代理类
public class UserManagerImpl implements UserManager {

public void addUser(String username, String password) {
System.out.println("---------UserManagerImpl.add()--------");
}

public void delUser(int userId) {
System.out.println("---------UserManagerImpl.delUser()--------");
}

public String findUserById(int userId) {
System.out.println("---------UserManagerImpl.findUserById()--------");
return "张三";
}

public void modifyUser(int userId, String username, String password) {
System.out.println("---------UserManagerImpl.modifyUser()--------");
}
}

CGLIB的动态代理

    JDK的动态代理只能对实现接口的类创建代理类，那么不实现接口的类呢？这时就需要CGLIB来创建代理类了。CGLIB是对没有实现接口的类创建代理类，同时也能对实现接口的类强制使用CGLIB动态代理。

    CGLIB采用底层的字节码技术，可以为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，实现横切。

public class CglibProxy implements MethodInterceptor {
//创建子类的对象
private Enhancer enhancer = new Enhancer();
//创建子类
public Object getProxy(Class class) {
enhancer.setSuperclass(class); //设置需要创建子类的类
enhancer.setCallback(this);
return enhancer.create(); //通过字节码技术动态创建子类实例
}

//拦截父类所有方法的调用
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
PerformanceMonitor.begin(obj.getClass().getName()+"."+method. getName());
Object result=proxy.invokeSuper(obj, args);
PerformanceMonitor.end();//通过代理类调用父类中的方法
return result;
}
}

     通过getProxy方法，传入要需要创建子类的类，然后通过代理对象enhancer的create方法创建子类实例。这个过程不需要被代理类的接口，所以CGLIB可以为不实现接口的类创建代理类。intercept方法则是拦截父类所有方法，加入相应代理类需要执行的内容，然后通过代理类调用父类中的方法。

总结

    JDK动态代理，不需要另外引入jar包，但是CGLIB实现动态代理，需要引入CGLIB的jar包。一般来说，使用接口编程更为灵活，所以多数会使用JDK实现的动态代理。动态代理是AOP实现的原理，通过动态代理可以实现安全性检查、日志记录、事务处理等等，这些其实也是AOP实现的实例。接触到一个知识点，并不是要局限的看它现在能做什么，而是要用发散性思维来思考，它将来还能做什么，多做这样的训练，才能更好的给知识织网。