成果总结:

动态代理实现代码(utils包):

  1. import java.lang.reflect.*;
  3. public class ProxyUtils {
  4.     /*
  5.     参数是需要被代理的对象,返回结果是创建好的代理对象.
  6.     */
  7.     public static Object getProxy(Object target)  {
  8.         Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
  10.             //这个方法内的注释提示处可以写代理时要额外执行的代理操作
  11.             @Override
  12.             public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
  13.                 Object result = method.invoke(target,objects);
  14.                 System.out.println("经过了动态代理.");    //这里可以更换为代理真正需要执行的方法或步骤.
  15.                 return result;    //返回被代理的对象所执行的方法的结果
  16.             }
  17.         });
  18.         return proxy;    //返回代理对象
  19.     }
  21.     /*
  22.     参数是被代理对象和调用处理器(书写 <代理对象所额外执行的方法> 的类),返回值是创建好的代理对象
  23.     */
  24.     public static Object getProxy(Object target,InvocationHandler handler){
  25.         return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),handler);
  26.     }
  27. }

动态代理实现代码(proxy包):

  1. import java.lang.reflect.InvocationHandler;
  2. import java.lang.reflect.Method;
  4. /*
  5. 这是一个专门书写代理对象所执行的方法的类
  6. */
  7. public class Proxy implements InvocationHandler {
  8.     private Object target;
  9.     //构造器的参数是 被代理的对象
  10.     public Proxy(Object target){
  11.         this.target=target;
  12.     }
  14.     //这个方法内的注释提示处可以写代理时要额外执行的代理操作
  15.     @Override
  16.     public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
  17.         Object result = method.invoke(target,objects);
  18.         System.out.println("经过了动态代理");    //这里可以更换为代理真正需要执行的方法或步骤.
  19.         return result;
  20.     }
  21. }

成果如何使用?
根据注释,读者稍加思考即可.

**

(以下内容晦涩难懂,选择阅读)

笔记总结正文:

jdk动态代理的三个类：

InvocationHandler接口类：
Object invoke(Object var1, Method var2, Object[] var3);
var1是jdk自动创建的代理对象
var2目标类中的方法，由jdk自动提供
var3目标方法的参数，jdk自动提供
如何使用：
1.创建类，实现接口InvocationHandler
2.重写invoke方法

Method类：
作用:不需知道方法名,根据参数和返回值类型,就能正确执行
method.invoke(拥有此方法的对象,方法参数)

Proxy类:
静态方法:newProxyInstance(),作用是创建目标对象的代理对象
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {
Objects.requireNonNull(h);
Class<?> caller = System.getSecurityManager() == null ? null : Reflection.getCallerClass();
Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);
return newProxyInstance(caller, cons, h);
}
loader:类加载器,反射获得,使用目标对象的类加载器
interfaces:接口目标对象实现的接口,通过反射获取
h:我们自己写的

动态代理本质.jpg

实现动态代理的步骤:

1.创建接口,定义目标类需要完成的功能
2.创建目标类实现接口
3.创建InvocationHandler接口的实现类,在invoke方法中完成代理的功能
1>调用目标方法
2>其他
4.使用Proxy类的静态方法,创建代理对象,并把返回值转化为接口类型

实质上是:
第三步中,构建真正的代理过程,创造出代理模板,其内部需要的参数有:
1>被代理的对象
2>需要执行的被代理对象的方法
3>需要执行的被代理对象的方法的参数
直接创建一个被代理对象,以给handler提高第1>个参数;
由第4步多态创建一个代理对象的接口,这个接口再执行需要被代理的对象的方法,执行的过程中,也就自动给
handler传入了第2>个和第3>个参数了
实际上第4步创建出来的代理对象,其实内部是一个被代理对象,他拥有被代理对象的所有方法,并有一个额外
的invoke方法(来源于handler),在执行他的任何方法前,他都会先执行invoke方法.(此为我的臆想过程)