动态代理【详解】

1. 什么是代理

动态代理是一种技术手段，而AOP(面向切面编程)是一种编程范式。动态代理可以用于实现AOP，通过将横切关注点与核心业务逻辑进行解耦，提供更灵活和可维护的代码结构

1.日常生活中的代理

张三.租房() --->房东.租房();

张三.租房() --->中介.租房() --->房东.租房();

张三.演唱()--->明星.演唱()

张三.演唱()--->经纪人.演唱()--->明星.演唱()

2.代理技术

代理：当不能、不方便直接调用目标对象时，可以通过代理对象，间接调用目标对象

有两种代理模式：

• 静态代理（装饰者模式）：代理类是提前创建好的。 我们直接创建代理对象，通过代理对象调用目标对象

• 动态代理：代理类不存在，在程序运行过程，动态生成的代理类、代理类对象。我们再通过代理对象调用目标对象

2. Java动态代理技术

注意：

• Java的动态代理Proxy.newProxyInstance方法，是基于接口的动态代理

• cglib动态代理，是基于子类的

1.动态代理原理

动态代理是一种在运行时动态创建代理类及其实例的机制，无需事先编写代理类的源代码，而是在程序运行时根据需要动态生成代理类。动态代理通常用于实现 AOP（面向切面编程）等功能，可以在不修改原始类代码的情况下，对方法的调用进行额外的控制和处理。

在 Java 中，动态代理主要通过 Java 反射机制实现，其原理如下：

1. 定义接口：首先需要定义一个接口，该接口包含了需要被代理的方法。

2. 实现 InvocationHandler 接口：创建一个实现 InvocationHandler 接口的类，该类中包含了对方法调用的处理逻辑。

3. 使用 Proxy 类创建代理对象：通过 Proxy.newProxyInstance() 方法动态生成代理类的实例，传入 ClassLoader、接口数组和 InvocationHandler 对象。

4. 调用代理对象方法：当调用代理对象的方法时，实际上会触发 InvocationHandler 中的 invoke() 方法，从而实现对原始方法的拦截和处理。

5. 在 invoke() 方法中可以实现诸如添加日志、权限检查、性能监控等功能，从而实现横切关注点的处理。

总的来说，动态代理的原理是通过反射机制在运行时动态生成代理类，实现对原始类方法的拦截和增强，从而实现额外的功能，而不改变原始类的代码。

2.API说明

java.lang.reflect.Proxy提供了动态代理的API

Object proxyObject = Proxy.newProxyInstance(
						ClassLoader loader,
    					Class[] interfaces,
    					InvocationHandler h
					);

参数：

• ClassLoader loader：类加载器

• Class[] interfaces：代理类要实现的接口，注意参数的类型是Class[]

• InvocationHandler h：当代理对象被调用时，要执行的代码

  • InvocationHandler是个接口，通常创建一个匿名内部类

new InvocationHandler(){
    public Object invoke(Object proxy, Method method, Object[] args){
        //proxy：代理对象
        //method：我们调用的方法Method对象
        //args：我们调用方法时，传递的实参
        
        //写代码：增强目标对象，控制目标对象
        //调用之前，可以增加一些代码
        //调用目标对象的method方法
        //调用之后，可以增加一些代码
        
        //我们调用代理对象时，得到的返回值结果
        return 返回值;
    }
}

返回值：

• 是 接口的实现类对象

3.使用示例

有明星接口“Star"，有实现类“SuperStar”。要求在不修改以上两个源码的情况下，对“SuperStar”进行功能增强：

• 唱歌前彩排；唱歌后收钱

• 跳舞前彩排；跳舞后收钱

/**
接口
*/
public interface Star {
    void sing(String song);

    String dance(String dance);
}


------------------------------
/**
实现类
*/
public class SuperStar implements Star {
    @Override
    public void sing(String song) {
        System.out.println("明星唱：" + song);
    }

    @Override
    public String dance(String dance) {
        System.out.println("明星跳：" + dance);
        return "跳过了";
    }
}


-------------------------------
/**
代理对象测试类
*/
public class ProxyTest {
    @Test
    public void test1(){
        //1.直接调用目标对象
        Star superStar = new SuperStar();
        //superStar.sing("只因你太美");
        //String dance = superStar.dance("霹雳舞");
        //System.out.println(dance);

        //2.通过代理对象，间接调用目标对象
        /**
         * 要求1：在代理对象里，对目标对象进行功能增强
         *      唱歌“sing”方法执行之前，彩排
         *      唱歌“sing”方法执行之后，收钱
         * 要求2：在代理对象里，对目标对象进行控制
         *      无论调用者要让目标对象跳什么舞，代理对象都控制目标对象，只跳“肚皮舞”
         *
         * 要求有：在代理对象里，对目标对象进行控制
         *      无论目标对象dance做了什么，都给调用者返回“送你一首 鸡你太美”
         *
         */
        //2.1 得到一个代理对象（不让提前创建，要使用API动态生成）
        Star proxyInstance = (Star) Proxy.newProxyInstance(
                superStar.getClass().getClassLoader(),
                new Class[]{Star.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        //目标方法执行之前，彩排
                        System.out.println("======彩排======");

                        //代理对象调用目标对象
                        Object result = method.invoke(superStar, args);

                        //目标方法执行之后，收钱
                        System.out.println("======收钱======");

                        //我们调用代理对象，得到的返回值
                        return result;
                    }
                }
        );

        //2.2 调用代理对象的方法
        proxyInstance.sing("只因你太美");
        String dance = proxyInstance.dance("霹雳舞");
        System.out.println(dance);
    }

    /**
     * 在没有目标对象的时候，生成得到一个代理对象（本质是指定接口的一个实现类对象）
     */
    @Test
    public void test2(){
        Star proxyInstance = (Star) Proxy.newProxyInstance(
                Star.class.getClassLoader(),
                new Class[]{Star.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object result = null;

                        //如果调用者，调用了sing方法，就需要由代理对象完成sing方法
                        if ("sing".equals(method.getName())) {
                            System.out.println("唱歌了，但是是代理对象唱的");
                        }

                        //如果调用者调用了dance方法，就需要由代理对象完成dance方法
                        if ("dance".equals(method.getName())) {
                            System.out.println("跳舞了，但是是代理对象跳的");
                            result = "跳过舞了";
                        }

                        return result;
                    }
                }
        );
        proxyInstance.sing("");
        String dance = proxyInstance.dance("");
        System.out.println(dance);
    }
}

先执行判断的，在执行实现类的数据