设计模式-代理模式

设计模式-代理模式

---

* 增强对象的功能：
			* 设计模式：一些通用的解决固定问题的方式
			1. 装饰模式
			2. 代理模式
				* 概念：
					1. 真实对象：被代理的对象
					2. 代理对象：
					3. 代理模式：代理对象代理真实对象，达到增强真实对象功能的目的
			 	* 实现方式：
				 	1. 静态代理：有一个类文件描述代理模式
				 	2. 动态代理：在内存中形成代理类
						* 实现步骤：
							1. 代理对象和真实对象实现相同的接口
							2. 代理对象 = Proxy.newProxyInstance();
							3. 使用代理对象调用方法。
							4. 增强方法

						* 增强方式：
							1. 增强参数列表
							2. 增强返回值类型
							3. 增强方法体执行逻辑	

具体案例：
购买笔记本案例

1. 定义接口SaleComputer类，用于实现方法
	public interface SaleComputer {
    public String sale(double money);

    public void show();
}
2. 定义一个实体Lenovo类实现方法，为真实类

	package cn.itcast.proxy;
	/*
	真实类
	* */
	public class Lenovo implements SaleComputer {
	    @Override
	    public String sale(double money) {
	        System.out.println("花了" +
	                money + "买联想电脑");
	        return "联想电脑";
	    }
	
	    @Override
	    public void show() {
	        System.out.println("show展示电脑..");
	    }
	}
3. 开始反向代理具体代码如下

	public class ProxyTest {
    public static void main(String[] args) {
        //1,创建真实对象
        Lenovo lenovo = new Lenovo();
        //2.动态代理：增强Lenovo对象
        /*
         * 三个参数，
         *   1.类加载器：真是对象.getClass().getClassLoader()
         *   2. 接口数组：真实对象.getClass().getInterfaces()
         *   3. 处理器：new InvocationHandler()
         * */
        SaleComputer proxy_lenovo = (SaleComputer) Proxy.newProxyInstance(lenovo.getClass().getClassLoader(), lenovo.getClass().getInterfaces(), new InvocationHandler() {
            /*
             * 代理逻辑编写的方法：代理对象调用的所有方法都会触发 该方法执行
             * 参数：
             *   1.proxy：代理对象
             *   2.Method对象：代理对象调用的方法，被封装为的对象
             *   3.args:代理方法调用方法是，传递的实际参数
             * */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /*System.out.println("该方法执行了");
                System.out.println(method.getName());
                System.out.println(args[0]);*/

                //判断是否是sale方法
                if (method.getName().equals("sale")) {
                    //1,增强参数
                    double money = (double) args[0];
                    money = money * 0.8;
                    System.out.println("专车接");
                    //使用真实对象调用该方法
                    String obj = (String) method.invoke(lenovo, money);
                    System.out.println("免费送货---");
                    //2增强返回值

                    return obj + "_鼠标垫";
                } else {
                    Object obj = method.invoke(lenovo, args);
                    return obj;
                }


            }
        });

        //3.调用方法
        /*String sale = proxy_lenovo.sale(2000);
        System.out.println(sale);*/
        proxy_lenovo.show();
    }
}
实现过程：
	1. 创建真实对象
	Lenovo lenovo = new Lenovo();
	2. 动态代理用于增强对象（创建某一接口的代理）：
		需要用到Proxy.newProxyInstance：jdk文档有如下解释：

	里面需要传入三个参数：
		
     *   1.类加载器：真实对象(Lenovo).getClass().getClassLoader()
     *   2. 接口数组：真实对象(Lenovo).getClass().getInterfaces()
     *   3. 处理器：new InvocationHandler()
         *   在InvocationHandler中编写处理逻辑的方法：代理对象调用的所有方法都会触发 该方法执行
         *   需要重写invoke方法实现代理
	         *   其中invoke函数需要三个参数
		         *   1.proxy：代理对象
        		 *   2.Method对象：代理对象调用的方法，被封装为的对象
         		 *   3.args:代理方法调用方法是，传递的实际参数

	3. 增强方法：判断方法名称是否是类中的方法：
		 //判断是否是sale方法然后进行打折活动
                if (method.getName().equals("sale")) {
                    //1,增强参数
                    double money = (double) args[0];
                    money = money * 0.8;
                    System.out.println("专车接");
                    //使用真实对象调用该方法
                    String obj = (String) method.invoke(lenovo, money);
                    System.out.println("免费送货---");
                    //2增强返回值

                    return obj + "_鼠标垫";
                } else {
                    Object obj = method.invoke(lenovo, args);
                    return obj;
                }

执行结果：

GitHub->代理模式