Java使用Proxy代理模式之动态代理，演示中间代理商售卖电脑案例

今天药忘吃喽~ 2022-12-30 04:59 21阅读 0赞

设计模式的概念：用来解决固定问的通用方式。[百度百科][Link 1]

今天主要来演示其中的一种——Proxy代理模式。代理模式又分为静态代理和动态代理，两者的区别在于：

*  静态代理使用了一个真实的类文件来描述代理模式；
 *  动态代理反之，不需要创建真实的类文件，直接在内存中创建类来进行代理；（动态代理在日常工作中使用较多）

**代理模式中有被代理对象和代理对象：真实对象被代理对象所代理，真实对象就是被代理对象**

*  被代理对象：真实对象
 *  代理对象：代理真实对象的对象

**代理模式的实现步骤：**

1.  被代理对象和代理对象实现相同的接口；
2.  获取代理对象；代理对象 = Proxy.newProxyInstance();
3.  使用代理对象调用方法；

--------------------

### **实际案例** ###

举个生活中的例子，我在一个小县城，需要买一台联想电脑，联想公司在北京售卖电脑，那我购买的渠道有两种：①坐车去北京购买；②在本地代理商处购买；这就需要用到代理模式。

**售卖电脑的接口**

package cn.gpxxg.proxy;
    
    public interface SaleComputer {
        /**
         * 卖电脑
         * @param money
         * @return
         */
        String sale(double money);
    
        /**
         * 维修电脑
         * @return
         */
        void repair();
    }

**联想公司实现接口**

package cn.gpxxg.proxy;
    
    public class Lenovo implements SaleComputer {
        @Override
        public String sale(double money) {
            System.out.println("花" + money + "元买了一台联想电脑");
            return "买联想电脑";
        }
    
        @Override
        public void repair()
        {
            System.out.println("维修电脑一律500元！");
        }
    }

**代理商代理销售，这里使用动态代理**

package cn.gpxxg.proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class ProxyTest {
        public static void main(String[] args)
        {
            // 创建真实对象
            Lenovo lenovo = new Lenovo();
    
            /*
                创建代理对象
                java.lang.reflect包下的Proxy对象提供了一个静态方法newProxyInstance，用于返回代理对象，newProxyInstance的参数，是一个固定写法
                参数1：真实对象.getClass().getClassLoader()
                参数2：真实对象.getClass().getInterfaces()。说明：表明代理对象和被代理对象实现的是同一个接口
                参数3：new InvocationHandler函数式接口
            */
            SaleComputer proxyLenovo = (SaleComputer) Proxy.newProxyInstance(lenovo.getClass().getClassLoader(), lenovo.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    // 为所欲为吧
                    /*
                     这其中的代码用来对代理逻辑进行编写，需要注意的是，代理对象调用的所有方法，都会执行下列代码
                     参数proxy：代理对象
                     参数method：代理对象调用的方法，被封装为Method对象
                     参数args：代理对象调用方法时，传递的实际参数
    
                     增强方式
                     1、增强参数列表
                     2、增强返回值类型
                     3、增强方法体逻辑
                     */
                    if ("sale".equals(method.getName()))
                    {
                        // 如果是sale方式，打折进货销售
    
                        // 增强参数
                        Double money = (Double) args[0] * 0.8;
                        String sale = (String) method.invoke(lenovo, money);
    
                        // 增强方法体
                        System.out.println("送货上门");
    
                        // 增强返回值
                        return sale + "_送鼠标垫";
                    }
                    else
                    {
                        // 不是sale方法，正常执行
                        Object obj = method.invoke(lenovo, args);
                        return obj;
                    }
                }
            });
    
            // 使用代理对象买电脑
            String sale = proxyLenovo.sale(5500);
            System.out.println(sale);
            /*
            执行结果为：
            花4400.0元买了一台联想电脑
            送货上门
            买联想电脑_送鼠标垫
            */
    
            // 使用代理对象维修电脑(代理商无利可图，直接让联想公司去维修)
            proxyLenovo.repair(); // 执行结果为：维修电脑一律500元！
        }
    }

**总结：**

*  使用代理模式可以为所欲为的对真实对象的参数、方法体、返回值进行修改；
 *  代理对象中的代码逻辑，不论调用接口中的哪个方法，都会被执行，所以可以使用if判断调用的是哪个方法，针对不同方法进行不同逻辑修改；
 *  创建代理对象时的参数，是固定写法，可以先死记硬背住，在今后的实践中慢慢理解记忆。

[Link 1]: https://baike.baidu.com/item/%E8%BD%AF%E4%BB%B6%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/2117635?fr=aladdin#4_1