java动态代理（jdk动态代理和CGLIB动态代理）

1.什么是代理

根据原有对象生成一个占位（代理对象），然后由代理对象来代理真实对象，控制对真实对象的访问的操作就叫做代理。

2.代理的必要步骤

1）让代理对象和真实对象建立联系（建立关系的过程会生成代理对象，基于java反射）

2）实现代理对象的代理逻辑方法

3.代理的作用（好处）

4.常用的代理技术有哪些

1）JDK动态代理

2）CGLIB动态代理

5.JDK动态代理

1）代理功能由java.lang.reflect提供。实现一个简单的动态代理，需要原料有：

1.接口一个（被代理对象对应的接口）

2.普通类一个（被代理对象）

3.代理类一个（用于生成代理对象，并完成代理逻辑方法的实现），该类必须实现InvocationHandler接口，如下所示：

public class JdkProxyExample implements InvocationHandler {

    private Object target;//被代理的类对象

    public Object bind(Object target){

        this.target = target;

        //根据传入的对象（被代理对象）生成代理对象，newProxyInstance方法的三个参数分别为（被代理类的类加载器，被代理类的接口类型，InvocationHandler类型的对象）

        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);

    }

 

    /**

     * 代理逻辑的实现方法

     * @param proxy 代理对象

     * @param method 被代理的方法对象，类似于切面中被通知的方法

     * @param args 被代理方法传参

     * @return

     * @throws Throwable

     */

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("现在已经进入代理方法");

        System.out.println("先走一波代理逻辑，走完调用被代理对象的方法");

        //invoke方法传入了对象的引用已经方法的参数，具体调用哪个方法由method对象自己记录（自己知道自己是谁）

        Object object = method.invoke(target,args);

        System.out.println("成功完成被代理对象方法的调用");

        return object;

    }

}

类中，bind(代理类对象)方法用于实现代理类和真实对象之间建立联系，并生成代理类返回（代理类同样实现了真实对象实现的接口）。

invoke（代理对象，调用的方法对象，方法参数）方法为代理逻辑实现方法，当调用代理类方法时，就会进入invoke方法。也能在invoke方法中利用反射来调用真实对象（被代理对象）的方法。

接下来书写一个测试类进行测试

Public static void main(String[] arg){

JdkProxyExample jdkProxyExample = new JdkProxyExample();

//建立连接，返回代理对象

ProxyInterface proxy = (ProxyInterface)jdkProxyExample.bind(new ProxyTestImpl());

//调用代理逻辑

proxy.sayHello();

}

测试结果为：

可以代理对象在调用真实对象方法时，会主动调用代理类里面的代理逻辑。

 

需要注意的是jdk动态代理必须基于接口才能使用，如果类不存在接口，则类不能使用jdk动态代理进行代理。

 

 

6.CGLIB动态代理

同样是动态代理，不过和jdk动态代理不同之处在于，jdk需要接口（代理对象的类型是真实对象实现的所有的接口），而CGLIB却不需要接口，代理对象类型就是真实对象类本身。

首先，还是先定义代理对象类，CGLIB的代理类必须实现MethodInterceptor接口：

/**

 * CGLIB代理类

 */

public class CglibProxyExample implements MethodInterceptor {

    /**

     * 生成代理对象

     * @param cla 被代理的类

     * @return 代理对象

     */

    public Object bind(Class cla){

        //获取CGLIB增强类对象

        Enhancer enhancer = new Enhancer();

        //设置对哪个类进行增强

        enhancer.setSuperclass(cla);

        //设置哪个类为代理类，代理类必须实现MethodInterceptor接口

        enhancer.setCallback(this);

        //生成代理对象并返回(根据之前的设置来生成代理对象)

        return enhancer.create();

    }

    /**

     * 代理类逻辑方法

     * @param proxy 被代理对象

     * @param method 代理类执行的方法对象

     * @param args 方法传参

     * @param methodProxy 方法代理对象

     * @return 方法执行结果

     * @throws Throwable

     */

    @Override

    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

        System.out.println("开始执行代理类逻辑");

        System.out.println("执行完代理类逻辑，准备执行真实对象方法");

        //调用真实对象的方法

        Object result = methodProxy.invokeSuper(proxy,args);

        System.out.println("真实对象方法执行完毕");

        return null;

    }

}

bind方法同样为创建代理对象和真实对象之前的关联关系，并返回代理对象。

intercept为代理逻辑方法，代理类执行的所有方法都会执行该方法。

接着搞个简单的被代理类

Public class CglibTest{

Public void justSayHello(){

System.out.println("我打印啦！");

}

}

最后搞个测试类：

由于环境是spring boot的，所以搞的是spring boot test，

@RunWith(SpringRunner.class)

@SpringBootTest

public class JavaReflectTest {

    @Test

    public void cglibTest(){

        try{

            //创建代理类对象

            CglibProxyExample cglibProxyExample = new CglibProxyExample();

            //通过代理类获取CglibTest类的代理对象

            CglibTest cglibTest =(CglibTest)cglibProxyExample.bind(CglibTest.class);//绑定管理，确定代理哪个类

            //由代理类执行真实对象方法

            cglibTest.justSayHello();

        }catch(Exception e){

            e.printStackTrace();

        }

    }

}

最后启动程序，走一波：

 

可见，和jdk动态代理一样，用代理类执行方法时，触发的是代理类中的实现逻辑，从而实现了对类原方法的扩展（比如spring AOP）。

 

注：针对生成对象，new是静态编译，而反射是动态编译。静态编译会在一开始就把对象写入内存，而动态编译是在具体用到对象的时候才会在内存中创建对象。这样就能做到一个代理类去代理多个对象。