设计模式之动态代理

动态代理

1. 动态代理概述

1. 代理：代理对象代理真实对象，达到增强真实对象功能的目的。
	* 具体表现在对实际对象的方法的三个方面进行增强
		1. 方法参数
		2. 方法返回值
		3. 方法体
2. 静态代理与动态代理区别：
	1. 静态代理：有一个类文件描述代理模式（用的不多）
 	2. 动态代理：在内存中形成代理类（实现机理是反射技术）
3. 动态代理：
	1. 特点：字节码随用随创建，随用随加载
	2. 作用：不修改源码的基础啥关对方法增强。（类似于python中的装饰器）
	3. 分类：
		1. 基于接口的动态代理
		2. 基于子类的动态代理

下面一张图帮助理解：

2. 基于接口的动态代理

2.1 实现步骤

1. 要求：被代理对象至少继承一个接口
2. 涉及的类：Proxy
3. 提供者：JDK官方
4. 实现步骤：
	1. 定义接口		
	2. 定义实际处理类
	3. 动态代理设置：
			1. 代理对象和真实对象实现相同的接口
					* 类型的强转，使得他们继承了相同的接口
			2. 代理对象 = Proxy.newProxyInstance();
					* 处理器的三个参数说明：
						1. 类加载器：真实对象.getClass().getClassLoader()
						2. 接口数组：真实对象.getClass().getInterfaces()
						3. 处理器：new InvocationHandler()
					* 注意：Proxy导包是：java.lang.reflect.Proxy
					* 举例：
					  SaleComputer proxy_lenovo = (SaleComputer)Proxy.newProxyInstance(lenovo.getClass().getClassLoader(), lenovo.getClass().getInterfaces(), new InvocationHandler({
						/**
						* proxy:代理对象
						* method：调用的方法，被封装成一个方法对象
						* args：调用方法时的实际参数
						*/
						@Override
						public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
							return null;
						}
					  }));
			3. 使用代理对象调用方法。
			4. 增强方法

2.2 动态代理的实现案例

用上图的卖电脑的例子举例，采用动态代理模拟这个过程：
要求：用户拿8000块去代理商处卖联想电脑，代理商赚两层，也就是用用户所给钱的80%去找厂家拿货。代理商给予用户优惠政策，派车接用户过来，并免费送货，最后还送一个鼠标。

文件目录：

第一步：定义卖电脑的接口：SaleComputer.java

package cn.wanghao.demo;

public interface SaleComputer {
    /**
     * 给钱，进行卖电脑
     * @param money 钱
     * @return 卖了一台什么电脑
     */
    public String sale(double money);
}

第二步：定义实际处理类：Lonovo.java

package cn.wanghao.demo;

public class Lonovo implements SaleComputer {
    @Override
    public String sale(double money) {
        System.out.println("到厂家处花费了"+money+"钱，卖了一台联想电脑！");
        return "得到联想电脑";
    }
}

第三步：动态代理设置：Demo.java

（1）基础代码（模板），没有增强实际对象的代码如下：

package cn.wanghao.demo;

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

public class Demo {
    public static void main(String[] args) {
        //1. 创建实际对象
        Lonovo lonovo = new Lonovo();

        //2. 创建代理对象
        /*
            1. 类加载器：真实对象.getClass().getClassLoader()
            2. 接口数组：真实对象.getClass().getInterfaces()
            3. 处理器：new InvocationHandler()
            * 类型强转是为了让他们继承相同的接口-SaleComputer
         */
        SaleComputer proxy = (SaleComputer) Proxy.newProxyInstance(lonovo.getClass().getClassLoader(), lonovo.getClass().getInterfaces(), new InvocationHandler() {
            /**
			* proxy:代理对象
			* method：调用的方法，被封装成一个方法对象
			* args：调用方法时的实际参数
			*/
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            	if ("sale".equals(method.getName())) {
	                String result = (String) method.invoke(lonovo, args);
	                return result;
	            } else {
					String result = (String) method.invoke(lonovo, args);
                    return result;
				}
            }
        });

        //3. 调用方法
        System.out.println("用户花8000元去代理商处卖联想电脑...");
        String result = proxy.sale(8000);
        System.out.println(result);
    }
}

（2）对实际对象的参数增强

（2）增强返回值

（3）增强方法体：

最终代码：

package cn.wanghao.demo;

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

public class Demo {
    public static void main(String[] args) {
        //1. 创建实际对象
        Lonovo lonovo = new Lonovo();

        //2. 创建代理对象
        /*
            1. 类加载器：真实对象.getClass().getClassLoader()
            2. 接口数组：真实对象.getClass().getInterfaces()
            3. 处理器：new InvocationHandler()
            * 类型强转是为了让他们继承相同的接口-SaleComputer
         */
        SaleComputer proxy = (SaleComputer) Proxy.newProxyInstance(lonovo.getClass().getClassLoader(), lonovo.getClass().getInterfaces(), new InvocationHandler() {
            /**
             * proxy:代理对象
             * method：调用的方法，被封装成一个方法对象
             * args：调用方法时的实际参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if ("sale".equals(method.getName())) {
                    //增强参数
                    double price = (double) args[0];
                    price *= 0.8;
                    //增强方法体
                    System.out.println("专车接用户...");
                    String result = (String) method.invoke(lonovo, price); //使用真实对象调用该方法
                    System.out.println("免费送货...");
                    //增强返回值
                    return result + "_外加一个鼠标。";
                } else {
                    String result = (String) method.invoke(lonovo, args);
                    return result;
                }
            }
        });

        //3. 调用方法
        System.out.println("用户花8000元去代理商处卖联想电脑...");
        String result = proxy.sale(8000);
        System.out.println(result);
    }
}

运行结果：

3. 基于子类的动态代理

3.1 实现步骤

1. 要求：被代理对象不能是最终类，也就是不能被final修饰。基于接口的动态代理只能代理接口或者集成接口的类，并且代理对象的类型是
		其接口类型，而不是被代理对象的类型。而基于子类的动态代理可以直接代理没有继承接口的类，并且代理对象的类型就是被代理对象的类型。
3. 涉及的类：Enhancer
4. 提供者：第三方cglib库
5. 实现步骤：
	1. 导入cglib的jar包或坐标
	2. 定义实际处理类
	3. 动态代理设置：
			1. 代理对象 = Enhancer.create();
					* 处理器的两个参数说明：
						1. 字节码：真实对象.getClass()
						2. 处理器：new MethodIntercepter()
					* 举例：
					  SaleComputer proxy_lenovo = (SaleComputer)Enhancer.create(lenovo.getClass(), new MethodIntercepter({
						/**
						* proxy:代理对象
						* method：调用的方法，被封装成一个方法对象
						* args：调用方法时的实际参数
						* methodProxy: 当前执行方法的代理对象
						*/
						@Override
						public Object intercept(Object proxy, Method method, Object[] args,  MethodProxy methodProxy) throws Throwable {
							return null;
						}
					  }));
			2. 使用代理对象调用方法。
			3. 增强方法

基于接口和基于出子类的动态代理，在处理器中编写的代码是一样的，也是proxy()和intercept()方法内的代码是一样的。所以，我就不重复举例子了。