Java的JDK动态代理与CGLib动态代理

Java的JDK动态代理

当需要调用一个目标对象执行一个方法做某件事时，这时不方便直接用目标对象，或没有目标对象，则可以通过代理对象间接的调用目标对象的方法。
代理作用：对目标对象进行控制或功能增强

静态代理

静态代理：代理类是提前创建好的，只要直接通过代理对象调用目标对象即可（静态代理类似于装饰者模式，不过装饰者模式作用主要在于对 被装饰者的功能增强，而代理作用主要在于对目标对象（被代理对象）进行控制，装饰者模式是静态代理的一种体现）

• Singer（歌手）：代理类（Agent）与被代理的类（ZhangSan）共同实现的接口

//代理对象需要有被代理对象全部的方法，代理对象与被代理对象要实现共同的接口
public interface Singer {
    //唱歌
    void sing(String song);
    //跳舞
    void dance(String danceName);
}

• ZhangSan（张三）：被代理类

//被代理的类
public class ZhangSan implements Singer {
    @Override
    public void sing(String song) {
        System.out.println("被代理对象唱："+song);
    }
    @Override
    public void dance(String danceName) {
        System.out.println("被代理对象跳："+danceName);
    }
}

• Agent（经纪人）：代理类

//代理类
public class Agent implements Singer {
    private ZhangSan zhangSan;
    
    public Agent(ZhangSan zhangSan) {
        this.zhangSan = zhangSan;
    }

    @Override
    public void sing(String song) {
        /*
        代理对象要做的事情（对被代理对象的控制与功能增强）：
        调用被代理对象同名方法之前可做一些其他操作， 调用被代理对象同名方法之后还再可做一些其他操作
		*/
		
        //调用被代理对象同名方法之前做一些其他操作
        System.out.println("代理对象——>把《怒放的生命》换成《凉凉》");
        song="凉凉";

        //调用被代理对象同名方法
        zhangSan.sing(song);

        //调用被代理对象同名方法之后还再可做一些其他操作
        System.out.println("代理对象——>唱完了,收场");
    }
    
    @Override
    public void dance(String danceName) {
        System.out.println("跳："+danceName);
    }

}

• ProxyTest：测试

public class ProxyTest {
    public static void main(String[] arg){
        ZhangSan zhangSan = new ZhangSan();
        Agent agent = new Agent(zhangSan);
        agent.sing("怒放的生命");

    }
}

运行输出：直观的体现出对被代理对象的控制与功能增强

动态代理，基于接口的动态代理

动态代理：代理类不存在，在代码运行过程中，动态生成的代理类，再通过代理类对象调用目标对象。

注：JDK官方的Proxy类创建代理对象，被代理类最少要实现一个接口。

思考：生成代理对象有什么要求？

• 代理类应该与目标对象有相同方法—>需要提供代理类要实现的接口，即被代理类最少实现一个接口。
• 使用代理是要对目标对象进行控制或功能增强—>需要提供代理类要做的事情
• 在代码运行过程中，动态生成的代理类，加载到内存中，并创建代理类对象—>需要提供类加载器

动态代理分两种情况：

1. 有接口，有目标对象，生成代理对象
   

• Singer（接口）

//代理对象需要有目标对象(被代理对象)全部的方法，代理对象与目标对象要实现共同的接口
public interface Singer {
    //唱歌
    String sing(String song);
    //跳舞
    void dance(String danceName);
}

• Zhangsan（目标类，被代理的类）

//被代理的类
public class ZhangSan implements Singer {
    @Override
    public String sing(String song) {
        System.out.println("被代理对象唱："+song);
        return song;
    }

    @Override
    public void dance(String danceName) {
        System.out.println("被代理对象跳："+danceName);
    }
}

• ProxyTest（通过Proxy生成代理对象,让代理对象调用目标对象的方法）

public class ProxyTest {
    public static void main(String[] arg){
        ZhangSan zhangSan = new ZhangSan();

        /*java.lang.reflect.Proxy创建代理对象的方法：newProxyInstance
          方法的参数：
              ClassLoader：类加载器。被代理的对象(目标对象)的类加载器,主要作用是将字节码对象载入到内存中，并对数据类型的校验。
              Class[]：字节码数组。被代理对象所实现的所有接口的字节码集合,主要作用是让生成的代理对象和被代理的对象拥有相同方法。(本质是给被代理对象的接口生成一个实现类)
                     写法：new Class[]{Singer.class}    ZhangSan.class.getInterfaces()
              InvocationHanlder：写要增强的方法，实现一个接口InvoationHandler,需要提供它的实现类,通常写的是匿名内部类。
         */
        Singer singerProxy  = (Singer) Proxy.newProxyInstance(
                ZhangSan.class.getClassLoader(),
                ZhangSan.class.getInterfaces(),
                new InvocationHandler() {

            /**
              执行 被代理对象的任何方法都都会经过该方法，该方法有拦截的作用
              方法的参数:
              	    Object proxy：代理对象的引用。
                    Method method：当前执行的方法  (被代理对象的方法)
                    Object[] args：当前方法所需的参数
             返回值：
             	    和 被代理对象的方法有相同的返回值
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //定义一个对象，存储返回结果
                String invoke = null;
                //获取方法名字
                String name = method.getName();


                if ("sing".equals(name)) {
                    //方法参数
                    String parameter = (String) args[0];

                    //调用目标对象的方法之前做一些其他操作(对目标对象进行控制或功能增强)
                    System.out.println("代理对象——>把《怒放的生命》换成《凉凉》");
                    parameter = "凉凉";

                    //反射调用目标对象的同名方法
                         /*方法的参数:
                                object：调用哪个对象的方法
                                parameterValues：调用方法时传递的实参
                         */
                    invoke = (String) method.invoke(zhangSan, parameter);

                    //调用目标对象的方法之后再一些其他操作(对目标对象进行控制或功能增强)
                    System.out.println("代理对象——>唱完了,收场");

                } else if ("dance".equals(name)) {
                    //方法参数
                    String parameter = (String) args[0];
                    System.out.println("代理对象——>把《卡路里》换成《小苹果》");
                    parameter = "小苹果";

                    method.invoke(zhangSan, parameter);
                }
                //  返回值的含义   和 被代理对象的方法有相同的返回值
                return invoke;
            }
        });
        
		/*
		代理对象调用目标对象(被代理对象)的方法
		执行的方法会经过invoke方法(invoke方法有拦截的作用)
		执行我们功能增强的代码，在通过反射调用目标对象(被代理对象)的同名方法
		调用目标对象(被代理对象)的方法后，再执行调用目标对象(被代理对象)的方法后写的功能增强的代码
		*/
        String song = singerProxy.sing("怒放的生命");
        System.out.println("返回值:"+song);
	    System.out.println("---------------------------");
        singerProxy.dance("卡路里");

    }
}

2. 有接口，没有目标对象，生成代理对象
   

• Singer（接口）

//代理对象需要有目标对象(被代理对象)全部的方法，代理对象与目标对象要实现共同的接口
public interface Singer {
    //唱歌
    String sing(String song);
    //跳舞
    void dance(String danceName);
}

• ProxyTest（通过Proxy生成代理对象，由代理对象完成所有工作）

public class Test {
public class ProxyTest {
    public static void main(String[] arg){

        /*java.lang.reflect.Proxy创建代理对象的方法：newProxyInstance
          方法的参数：
              ClassLoader：类加载器。被代理的对象(目标对象)的类加载器,主要作用是将字节码对象载入到内存中，并对数据类型的校验。
              Class[]：字节码数组。被代理对象所实现的所有接口的字节码集合,主要作用是让生成的代理对象和被代理的对象拥有相同方法。(本质是给被代理对象的接口生成一个实现类)
                     写法：new Class[]{Singer.class}    ZhangSan.class.getInterfaces()
              InvocationHanlder：写要增强的方法，实现一个接口InvoationHandler,需要提供它的实现类,通常写的是匿名内部类。
         */
        Singer singerProxy  = (Singer) Proxy.newProxyInstance(
                ProxyTest.class.getClassLoader(),
                new Class[]{Singer.class},
                new InvocationHandler() {

            /**
              执行 被代理对象的任何方法都都会经过该方法，该方法有拦截的作用
              方法的参数:
              	    Object proxy：代理对象的引用。
                    Method method：当前执行的方法  (被代理对象的方法)
                    Object[] args：当前方法所需的参数
             返回值：
             	    和 被代理对象的方法有相同的返回值
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                //获取方法名字
                String name = method.getName();
                if ("sing".equals(name)) {
                    //方法参数
                    String parameter = (String) args[0];

                    System.out.println("代理对象——>把《怒放的生命》换成《凉凉》");
                    parameter = "凉凉";

                    System.out.println("代理对象唱："+parameter);

                    System.out.println("代理对象——>唱完了,收场");

                } else if ("dance".equals(name)) {
                    //方法参数
                    String parameter = (String) args[0];
                    System.out.println("代理对象——>把《卡路里》换成《小苹果》");
                    parameter = "小苹果";

                    System.out.println("代理对象跳："+parameter);
                }
                return null;
            }
        });

        //通过Proxy生成代理对象，由代理对象完成所有工作
        singerProxy.sing("怒放的生命");
        System.out.println("----------------------------");
        singerProxy.dance("卡路里");
    }
}

CGLib动态代理，基于普通类的动态代理

CGLib动态代理可以给一个普通类生成一个代理对象，JDK提供的动态代理则要求被代理类最少要实现一个接口，才能生成代理对象。

注：使用CGLib的Enhancer类创建代理对象，被代理类不能用final修饰的类。

• 通过maven创建项目引入依赖

    <dependencies>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>
    </dependencies>

• ZhangSan（张三）：被代理类

//被代理的类
public class ZhangSan implements Singer {
    @Override
    public void sing(String song) {
        System.out.println("被代理对象唱："+song);
    }
    @Override
    public void dance(String danceName) {
        System.out.println("被代理对象跳："+danceName);
    }
}

• ProxyTest（使用CGLib的Enhancer类创建代理对象）

public class ProxyTest {
    public static void main(String[] arg){
        final ZhangSan zhangSan = new ZhangSan();
        /*Enhancer创建代理对象的方法：create
            方法的参数：
          			Class：写 指定对象生成代理 的字节码，即被代理对象的字节码。
         			Callback：写 增强的代码,通常写匿名内部类,一般使用Callback接口的子接口：MethodInterceptor
         */
        ZhangSan zhangSanProxy = (ZhangSan) Enhancer.create(
                zhangSan.getClass(),
                new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

                //定义一个对象，存储返回结果
                String invoke = null;
                //获取方法名字
                String name = method.getName();

                if ("sing".equals(name)) {
                    //方法参数
                    String parameter = (String) objects[0];

                    //调用目标对象的方法之前做一些其他操作(对目标对象进行控制或功能增强)
                    System.out.println("代理对象——>把《怒放的生命》换成《凉凉》");
                    parameter = "凉凉";

                    //反射调用目标对象的同名方法
                         /*方法的参数:
                                object：调用哪个对象的方法
                                parameterValues：调用方法时传递的实参
                         */
                    invoke = (String) method.invoke(zhangSan, parameter);

                    //调用目标对象的方法之后再一些其他操作(对目标对象进行控制或功能增强)
                    System.out.println("代理对象——>唱完了,收场");

                } else if ("dance".equals(name)) {
                    //方法参数
                    String parameter = (String) objects[0];
                    System.out.println("代理对象——>把《卡路里》换成《小苹果》");
                    parameter = "小苹果";

                    method.invoke(zhangSan, parameter);
                }
                //  返回值的含义   和 被代理对象的方法有相同的返回值
                return invoke;
            }
        });
        String song = zhangSanProxy.sing("怒放的生命");
        System.out.println("返回值:"+song);

        System.out.println("---------------------------");

        zhangSanProxy.dance("卡路里");
    }
}