动态代理

增强对象的功能（动态代理）：

基于接口的动态代理

• 设计模式：一些通用的解决固定问题的方式
•  代理模式

概念：

         1. 真实对象：被代理的对象
                2. 代理对象：
                3. 代理模式：代理对象代理真实对象，达到增强真实对象功能的目

 实现方式：（基于接口）

         1. 静态代理：有一个类文件描述代理模式
                2. 动态代理：在内存中形成代理类
                 : 实现步骤：
                           1. 代理对象和真实对象实现相同的接口
                           2. 代理对象 = Proxy.newProxyInstance();
                           3. 使用代理对象调用方法。
                           4. 增强方法

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

• 动态代理 代码

    
    SaleComputer    接口

    package com.long123.test;
    
    /**
     * 卖电脑的接口
     */
    public interface SaleComputer {
        public String sale(double money);
        public void show();
    }

    Lenvo.class 真实代理类

    package com.long123.test;
    
    /**
     * 真实类实现 SaleComputer接口
     */
    public class Lenvo implements SaleComputer {
        @Override
        public String sale(double money) {
            System.out.println("花了"+money+"元买了一台联想电脑...");
            return "联想电脑";
        }
        @Override
        public void show() {
            System.out.println("展示电脑");
        }
    }

    ProxyTest.class
 

    package com.long123.test;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class ProxyTest {
        public static void main(String[] args) {
            // 1. 创建真实对象
            Lenvo lenvo = new Lenvo();
    
            // 2. 动态代理增强lenov对象
              /*
                三个参数：
                    1. 类加载器：真实对象.getClass().getClassLoader()
                    2. 接口数组(真实对象实现的接口)：真实对象.getClass().getInterfaces() 保证代理对象和真实对象实现相同的接口
                    3. 处理器：new InvocationHandler()
             */
    
            // 返回代理对象
            SaleComputer  proxy_lenvo = (SaleComputer) Proxy.newProxyInstance(lenvo.getClass().getClassLoader(), lenvo.getClass().getInterfaces(), new InvocationHandler() {
    
                /*
                   代理逻辑编写方法：代理对象调用的所有方法都会触发该方法执行
                     参数：
                             1. proxy:代理对象
                             2. method：代理对象调用的方法，被封装为的对象
                             3. args:代理对象调用的方法时，传递的实际参数
                * */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    // 判断是否是sale方法
                    if(method.getName().equals("sale")){
                        // 1. 增强参数
                        double money = (double) args[0];
                        money = money * 0.85;
                        // 使用真实对象调用该方法
                        Object obj = method.invoke(lenvo,money);
                        // 2. 增强返回值
                        return obj+"_鼠标垫";
                    }else {
                        // 使用真实对象调用该方法
                        Object obj = method.invoke(lenvo,args);
                        return obj;
                    }
                }
            });
            // 3.代理对象调用方法
            String computer = proxy_lenvo.sale(2000);
            System.out.println(computer);
        }
    }

 基于子类的动态代理

•  导入依赖jar包

        <dependency>
            <groupId>org.sonatype.sisu.inject</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.1-v20090111</version>
        </dependency>

• 代码实习

Lenovo.java (真实类)

public class Lenovo {

    public String sale(double money) {
        System.out.println("花了"+money+"元买了一台联想电脑...");
        return "联想电脑";
    }

    public void show() {
        System.out.println("展示电脑");
    }
}

ProxyTest.java (代理类)

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class ProxyTest {
    public static void main(String[] args) {
        /**
         * 动态代理：
         *  特点：字节码随用随创建，随用随加载
         *  作用：不修改源码的基础上对方法增强
         *  分类：
         *      基于接口的动态代理
         *      基于子类的动态代理
         *  基于子类的动态代理：
         *      涉及的类：Enhancer
         *      提供者：第三方cglib库
         *  如何创建代理对象：
         *      使用Enhancer类中的create方法
         *  创建代理对象的要求：
         *      被代理类不能是最终类
         *  create方法的参数：
         *      Class：字节码
         *          它是用于指定被代理对象的字节码。
         *
         *      Callback：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。
         *          我们一般写的都是该接口的子接口实现类：MethodInterceptor
         */
        final Lenovo lenovo = new Lenovo(); // 创建真实对象

        // 返回代理对象
        Lenovo lenovoProxy = (Lenovo) Enhancer.create(lenovo.getClass(), new MethodInterceptor() {
            /**
             * 执行对象的任何方法都会经过该方法
             * @param proxy
             * @param method
             * @param args
             *    以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
             * @param methodProxy ：当前执行方法的代理对象
             * @return
             * @throws Throwable
             */
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
               // 判断是否是sale方法
                if (method.getName().equals("sale")){
                    // 1. 增强参数
                    double money = (Double) args[0];
                    money = money * 0.9;
                    // 使用真实对象调用该方法
                    Object obj = method.invoke(lenovo, money);
                    // 增强返回值
                    return obj+"电脑包";
                }else {
                    Object obj = method.invoke(lenovo, args);
                    // 增强返回值
                    return obj;
                }
            }
        });
        lenovoProxy.sale(1000.0);
    }
}