动态代理

1. 动态代理和静态代理的角色一样
2. 动态代理的代理类是动态生成的，不是我们直接写好的
3. 动态代理可以分为两大类，基于接口的动态代理，基于类的动态代理
   • 基于接口---JDK动态代理[我们在这里使用]
   • 基于类---cglib
   • Java字节码实现：Javassist

需要了解两个类 Proxy：代理，invocationHandler：调用代理程序

在此之前，我们要思考class和interface的区别和关系：

• 可以实例化class(非abstract)
• 不可以实例化interface

所有的interface类型的变量都是通过向上转型并指向某个实例的

CharSequence charSequence=new StringBuffer();

有没有可能不编写实现类，自动生成接口所指向的实例呢？

答案是可以的，Java标准库提供了对应的机制：可以在运行期间动态的创建某个interface的实例，什么叫做动态的创建呢？我们先看一下静态情况下是怎样的。

1.编写接口

package com.dreamcold.aop.demo02;

public interface Hello {
    void sayHello();
}

2. 编写具体实现类

package com.dreamcold.aop.demo02;

public class HelloWorld implements Hello {
    public void sayHello(){
        System.out.println("Hello World");
    }
}

3.测试

package com.dreamcold.aop.demo02;

public class Demo01 {
    public static void main(String[] args) {
        Hello hello=new HelloWorld();
        hello.sayHello();
    }
}

4. 输出

还有另外一种方式是动态代码，过程如下：

• 我们仍然先定义接口Hello
• 但是我们不编写实现类
• 实现类是通过JDK提供的一个Proxy.newProxyInstance()创建了一个Hello接口对象
• 这种没有实现类，但是在运行期间创建一个接口对象的方式称为动态代码
• JDK提供的动态创建接口对象的方式，叫做动态代理。

1.先定义接口

package com.dreamcold.aop.demo03;

public interface Hello {
    void sayGoodMorning(String name);
}

2.实现动态代理

package com.dreamcold.aop.demo03;

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

public class HelloWorld  {
    public static void main(String[] args) {
        //invocationHandler负责接口的方法调用
        InvocationHandler handler=new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //打印方法
                System.out.println(method);
                if(method.getName().equals("sayGoodMorning")){
                    System.out.println("Good Morning "+args[0]);
                }

                return null;
            }
        };
        //负责创建interface实例
        Hello hello=(Hello) Proxy.newProxyInstance(
                Hello.class.getClassLoader(),
                new Class[]{Hello.class},
                handler
        );
        hello.sayGoodMorning("dreamcold");
    }
}

在运行的时候创建一个interface实例的方法如下：

1. 定义一个InvocationHandler实例，它负责实现接口方法的调用
2. 通过Proxy.newInstance()创建interface实录，它需要三个参数
   • 使用ClassLoader，通常就是接口类的ClassLoader
   • 需要实现的接口数据，至少需要传入一个接口进去
   • 用来处理接口方法调用的Invocationhandler实例
3. 将返回的Object强制转换为接口

实质：动态代理实际上就是JDK在运行期间创建class字节码并加载的过程，它并没有什么黑魔法，把上面的静态实现类：

public class HelloDynamicProxy implements Hello {
    InvocationHandler handler;
    public HelloDynamicProxy(InvocationHandler handler) {
        this.handler = handler;
    }
    public void morning(String name) {
        handler.invoke(
           this,
           Hello.class.getMethod("morning", String.class),
           new Object[] { name });
    }
}

其实就是JDK帮助我们自动编写了一个上述类(不需要源代码，可以直接生成字节码)，并不存在直接可以直接实例化接口的黑魔法。

总结

• Java标准库提供类动态代理的功能，允许在运行期间动态的创建一个接口实例
• 动态代理是通过Proxy创建代理对象，然后将接口代理给InvocationHandler完成的

学习自链接：狂神说

Spring入门系列-动态代理

原文：https://www.cnblogs.com/mengxiaoleng/p/14940385.html