动态代理的一些简单的总结

什么是代理模式？

代理模式是指在不修改原目标代码的前提下，给其增加或扩展功能。也就是给一个类添加一个代理类，通常我们称被代理类为目标类，当我们访问实际对象时，事实上访问的是代理类，代理类相当于一个中间件，它能在目标类的基础上增加或扩展功能。

动态代理分为两种：JDK动态代理和CGLIB动态代理。

在Spring框架中，大量运用了动态代理模式。

JDK动态代理

JDK动态代理是JDK自带的功能，主要使用到InvocationHandler接口和Proxy对象的静态方法newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)方法。

例如，随便编写一个带有一个功能的接口：

public interface Animal {
    String dog();
}

创建一个类，实现它，我们称之为目标类，也就是被代理类：

public class AnimalImpl implements Animal {

    
    @Override
    public String dog() {
        System.out.println("this is a dog");
        return "this is return value";
    }

}

下面我们通过JDK动态代理来对目标类进行动态代理，步骤：

proxy：代理对象，也就是newProxyInstance方法生成的对象；method：当前调度的方法，也就是目标类中需要增强的方法；args：调度方法的参数，没有则为null；

loader：目标类的类加载器；InvocationHandler：目标类所实现的接口；h：实现InvocationHandler的类；

public class MyInvocationHandler implements InvocationHandler {

    //目标类对象
    private Object target;

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

    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("what type of this animals??");
        Object returnVal = method.invoke(target, args);
        System.out.println("dog have 4 legs");
        return returnVal;
    }

    
    public Object getProxy() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

运行测试：

    @Test
    public void jdKProxy() {
        MyInvocationHandler myIH = new MyInvocationHandler(new AnimalImpl());
        Animal animalProxy = (Animal) myIH.getProxy();
        String returnVal = animalProxy.dog();

        //该方法的返回值
        System.out.println(returnVal);
    }

如上，通过(Animal) myIH.getProxy()得到的Animal对象animalProxy，再执行animalProxy.dog()方法，其实际上就是执行的invoke()方法。

output：

what type of this animals??
this is a dog
dog have 4 legs
this is return value

CGLIB动态代理

CGLIB动态代理和JDK动态代理的主要区别：

CGLIB动态代理是第三方所提供的技术，而JDK动态代理是JDK自带的功能；JDK动态代理，目标类必须实现接口，而CGLIB动态代理不需要，所以使用CGLIB会更简单一些；

它们的理念和实现的方法都是相似的，所以当你学会了JDK动态代理之后，很容易就能掌握CGLIB。

主要使用到MethodInterceptor接口和Enhancer对象。

因为是由第三方提供，所以我们在使用之前要导入它的Maven依赖：


    cglib
    cglib
    3.1

编写一个目标类，它不需要实现任何接口：

public class Person {
    public String student(){
        System.out.println("name:Jack");
        return "this is return value";
    }
}

o：代理对象，也就是newProxyInstance方法生成的对象；method：目标类中需要被增强的方法；objects：需要被增强方法的参数，没有为null；methodProxy：用来调用目标类中被增强的方法；

public class MyMethodInterceptor implements MethodInterceptor {

    //目标类
    private Object target;

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

    
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("执行方法：" + method.getName());
        Object returnValue = methodProxy.invokeSuper(o, objects);
        System.out.println("age:19");
        return returnValue;
    }

    
    public Object getProxy() {
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(target.getClass().getClassLoader());
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
}

运行测试：

    @Test
    public void cglibProxy() {
        MyMethodInterceptor myMI = new MyMethodInterceptor(new Person());
        Person personProxy = (Person)myMI.getProxy();
        String returnValue = personProxy.student();

        //该方法的返回值
        System.out.println(returnValue);
    }

output：

执行方法：student
name:Jack
age:19
this is return value

动态代理的一些简单的总结

Java相关栏目本月热门文章