java动态代理

最新推荐文章于 2022-08-13 10:30:31 发布

AIT袁

最新推荐文章于 2022-08-13 10:30:31 发布

阅读量225

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_44313315/article/details/105509808

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1 实现方式

Java 代理模式实现方式，主要有如下五种方法

1.静态代理，工程师编辑代理类代码，实现代理模式；在编译期就生成了代理类。
2.基于 JDK 实现动态代理，通过jdk提供的工具方法Proxy.newProxyInstance动态构建全新的代理类(继承Proxy类，并持有InvocationHandler接口引用 )字节码文件并实例化对象返回。(jdk动态代理是由java内部的反射机制来实例化代理对象，并代理的调用委托类方法)
3.基于CGlib 动态代理模式基于继承被代理类生成代理子类，不用实现接口。只需要被代理类是非final 类即可。(cglib动态代理底层是借助asm字节码技术
4.基于 Aspectj 实现动态代理（修改目标类的字节，织入代理的字节，在程序编译的时候插入动态代理的字节码，不会生成全新的Class ）
5.基于 instrumentation 实现动态代理（修改目标类的字节码、类装载的时候动态拦截去修改，基于javaagent） -javaagent:spring-instrument-4.3.8.RELEASE.jar （类装载的时候插入动态代理的字节码，不会生成全新的Class ）

委托类即指的是代理模式中的被代理对象
代理类指的是生成的代表委托类的一个角色

2 静态代理实现

静态代理是代理类在编译期间就创建好了，不是编译器生成的代理类，而是手动创建的类。在编译时就已经将接口，被代理类，代理类等确定下来。软件设计中所指的代理一般是指静态代理，也就是在代码中显式指定的代理。

实现步骤
委托类和代理类之间的约束接口Dog
约束接口实现类Wolf，实现 Dog 接口，委托角色
代理类实现 FeederProxy，实现Dog接口，并含有一个Dog接口引用属性。代理角色，代理Dog接口属性引用实例的行为并可以新增公共逻辑

Dog Interface

@Description: 静态代理类接口, 委托类和代理类都需要实现的接口规范。* 定义了一个犬科动物的两个行为接口，吃东西，奔跑。
作为代理类和委托类之间的约束接口

public interface Cat {
public String eatFood(String foodName);
public boolean running();
}
委托类 Lion

@Description: 狮子实现了猫科动物接口Cat，并实现了具体的行为。作为委托类实现
/public class Lion implements Cat { private String name; private int runningSpeed; public String getName() { return name;
} public void setName(String name) { this.name = name;
} public int getRunningSpeed() { return runningSpeed;
} public void setRunningSpeed(int runningSpeed) { this.runningSpeed = runningSpeed;
} public Lion() {
} @Override
public String eatFood(String foodName) {
String eat = this.name + " Lion eat food. foodName = " + foodName;
System.out.println(eat); return eat;
} @Override
public boolean running() {
System.out.println(this.name + " Lion is running . Speed :" + this.runningSpeed); return false;
}
}
代理类角色(FeederProxy)
package org.vincent.proxy.staticproxy;/*
@author PengRong
@package org.vincent.proxy.staticproxy
@date 2018/12/15 - 17:19
@ProjectName JavaAopLearning
@Description: 饲养员实现Cat接口，作为静态代理类实现。代理狮子的行为。
代理类中可以新增一些其他行为，在实践中主要做的是参数校验的功能。
/public class FeederProxy implements Cat { private Cat cat; public FeederProxy(){} public FeederProxy(Cat cat) { if (cat instanceof Cat) { this.cat = cat;
}
} public void setCat(Cat cat) { if (cat instanceof Cat) { this.cat = cat;
}
} @Override
public String eatFood(String foodName) {
System.out.println("proxy Lion exec eatFood "); return cat.eatFood(foodName);
} @Override
public boolean running() {
System.out.println(“proxy Lion exec running.”); return cat.running();
}
}
静态代理类测试
package org.vincent.proxy;import org.vincent.proxy.staticproxy.Cat;import org.vincent.proxy.staticproxy.FeederProxy;import org.vincent.proxy.staticproxy.Lion;/*
@author PengRong
@package org.vincent.proxy
@date 2018/12/15 - 18:31
@ProjectName JavaAopLearning
@Description: 静态代理类测试
/public class staticProxyTest { public static void main(String[] args) {
Lion lion = new Lion();
lion.setName(“狮子小王”);
lion.setRunningSpeed(100); /*
* new 静态代理类，静态代理类在编译前已经创建好了，和动态代理的最大区别点
*/
Cat proxy = new FeederProxy(lion); System.out.println(Thread.currentThread().getName()+" – " + proxy.eatFood(“水牛”));
proxy.running();
}
}
静态代理很好的诠释了代理设计模式，代理模式最主要的就是有一个公共接口（Cat），一个委托类（Lion），一个代理类（FeederProxy）,代理类持有委托类的实例，代为执行具体类实例方法。上面说到，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。这里的间接性就是指客户端不直接调用实际对象的方法，客户端依赖公共接口并使用代理类。那么我们在代理过程中就可以加上一些其他用途。就这个例子来说在 eatFood方法调用中，代理类在调用具体实现类之前添加System.out.println("proxy Lion exec eatFood ");语句就是添加间接性带来的收益。代理类存在的意义是为了增加一些公共的逻辑代码。

动态代理类(基于接口实现)
静态代理是代理类在代码运行前已经创建好，并生成class文件；动态代理类是代理类在程序运行时创建的代理模式。

动态代理类的代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。想想你有100个静态代理类，现在有一个需求，每个代理类都需要新增一个处理逻辑，你需要打开100个代理类在每个代理方法里面新增处理逻辑吗？有或者代理类有5个方法，每个方法都需要新增一个处理逻辑，你需要在每个方法都手动新增处理逻辑吗？想想就挺无趣的。动态代理类帮你一键搞定。

动态代理类涉及角色
委托类和代理类实现的公共接口(Person.java)
实现公共接口的具体委托类(SoftwareEngineer.java)
InvocationHandler接口被Proxy类回调处理，一般实现 InvocationHandler 接口的类具有委托类引用，接口方法 invoke 中添加公共代码并调用委托类的接口方法。(PersonInvocationHandler.java)
JDK提供生成动态代理类的核心类Proxy ( JDK 提供的Proxy.java)
基于JDK技术动态代理类技术核心 Proxy类和一个 InvocationHandler 接口
java的java.lang.reflect包下提供了Proxy类和一个 InvocationHandler 接口，这个类Proxy定义了生成JDK动态代理类的方法 getProxyClass(ClassLoader loader,Class<?>… interfaces)生成动态代理类,返回class实例代表一个class文件。可以保存该 class 文件查看jdk生成的代理类文件长什么样

该生成的动态代理类继承Proxy类，(重要特性) ，并实现公共接口。

InvocationHandler这个接口是被动态代理类回调的接口，我们所有需要增加的针对委托类的统一处理逻辑都增加到invoke 方法里面在调用委托类接口方法之前或之后结束战斗。

案例
公共接口
package org.vincent.proxy.dynamicproxy;/**

Created by PengRong on 2018/12/25.
创建Person 接口用于定义委托类和代理类之间的约束行为
/public interface Person{ /*
*
- @param name 人名
- @param dst 工作目的地
  /
  void goWorking(String name, String dst); /*
- 获取名称
- @return
  /
  String getName( ); /*
- 设置名称
- @param name
  /
  void setName(String name);
  }
  具体实现类，等下被委托，被代理的类 SoftwareEngineer.java
  package org.vincent.proxy.dynamicproxy;/*
Created by PengRong on 2018/12/25.
动态代理委托类实现，实现接口 Person。被动态生成的代理类代理
/public class SoftwareEngineer implements Person{ public SoftwareEngineer(){} public SoftwareEngineer(String name){ this.name=name;
} private String name; public String getName() { return name;
} public void setName(String name) { this.name = name;
} @Override
public void goWorking(String name, String dst) {
System.out.println(“name =”+name+" ，去 “+dst +” 工作");
}
}
InvocationHandler 接口实现 PersonInvocationHandler.java
package org.vincent.proxy.dynamicproxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.util.Arrays;/*
Created by PengRong on 2018/12/25.
PersonInvocationHandler 类实现InvocationHandler接口，这个类中持有一个被代理对象(委托类)的实例target。该类别JDK Proxy类回调
InvocationHandler 接口中有一个invoke方法，当一个代理实例的方法被调用时，代理方法将被编码并分发到 InvocationHandler接口的invoke方法执行。
/public class PersonInvocationHandler implements InvocationHandler { /*
- 被代理对象引用，invoke 方法里面method 需要使用这个被代理对象
  /
  T target; public PersonInvocationHandler(T target) { this.target = target;
  } /*
- 在
- @param proxy 代表动态生成的动态代理对象实例
- @param method 代表被调用委托类的接口方法，和生成的代理类实例调用的接口方法是一致的，它对应的Method 实例
- @param args 代表调用接口方法对应的Object参数数组，如果接口是无参，则为null；对于原始数据类型返回的他的包装类型。
- @return
- @throws Throwable
  /
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { /*
  - 在转调具体目标对象之前，可以执行一些功能处理
    /
    System.out.println(“被动态代理类回调执行, 代理类 proxyClass =”+proxy.getClass()+" 方法名: " + method.getName() + “方法. 方法返回类型：”+method.getReturnType()
    +" 接口方法入参数组: "+(args ==null ? “null” : Arrays.toString(args))); /*
  - 代理过程中插入监测方法,计算该方法耗时
    /
    MonitorUtil.start();
    Thread.sleep(1); /* 调用呗代理对象的真实方法，*/
    Object result = method.invoke(target, args);
    MonitorUtil.finish(method.getName()); return result;
    }
    }
    PersonInvocationHandler invoke 方法中添加的公共代码，这里简单以统计方法执行时间为逻辑
    package org.vincent.proxy.dynamicproxy;/**
Created by PengRong on 2018/12/25.
方法用时监控类
/public class MonitorUtil { private static ThreadLocal tl = new ThreadLocal<>(); public static void start() {
tl.set(System.currentTimeMillis());
} /*
- 结束时打印耗时
- @param methodName 方法名
  /
  public static void finish(String methodName) { long finishTime = System.currentTimeMillis();
  System.out.println(methodName + “方法执行耗时” + (finishTime - tl.get()) + “ms”);
  }
  }
  最后的是怎么创建代理类
  package org.vincent.proxy.jdkdynamicProxy;import org.vincent.proxy.dynamicproxy.Person;import org.vincent.proxy.dynamicproxy.PersonInvocationHandler;import org.vincent.proxy.dynamicproxy.SoftwareEngineer;import sun.misc.ProxyGenerator;import java.io.FileOutputStream;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;import java.nio.file.Path;import java.nio.file.Paths;import java.util.Arrays;import java.util.Properties;/*
动态代理类测试
Created by PengRong on 2018/12/25.
/public class JdkDynamicProxyTest { public static void main(String[] args) throws Exception { // 打开保存JDK动态代理生成的类文件
saveGeneratedJdkProxyFiles(); /*
* 第一种方法: 通过 Proxy.newProxyInstance 方法获取代理对象
/
System.out.println("-------------------第一种创建代理类方法--------------"); //创建一个实例对象，这个对象是被代理的对象，委托类
Person person = new SoftwareEngineer(“Vincent”); //创建一个与代理类相关联的InvocationHandler,每一个代理类都有一个关联的 InvocationHandler，并将代理类引用传递进去
InvocationHandler Handler = new PersonInvocationHandler<>(person); //创建一个代理对象 personProxy 来代理 person，创建的代理对象的每个执行方法都会被替换执行Invocation接口中的invoke方法
Person personProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, Handler); /* 代理类信息 /
System.out.println(“package = " + personProxy.getClass().getPackage() + " SimpleName = " + personProxy.getClass().getSimpleName() + " name =” + personProxy.getClass().getName() + " CanonicalName = " + “” + personProxy.getClass().getCanonicalName() + " 实现的接口 Interfaces = " + Arrays.toString(personProxy.getClass().getInterfaces()) + " superClass = " + personProxy.getClass().getSuperclass() + " methods =" + Arrays.toString(personProxy.getClass().getMethods())); // 通过代理类执行委托类的代码逻辑
personProxy.goWorking(personProxy.getName(), “深圳”); System.out.println("-------------------第二种创建代理类方法--------------"); /*
* 动态代理对象步骤
* 1、创建一个与代理对象相关联的 InvocationHandler，以及真实的委托类实例
* 2、Proxy类的getProxyClass静态方法生成一个动态代理类stuProxyClass，该类继承Proxy类，实现 Person.java接口；JDK动态代理的特点是代理类必须继承Proxy类
* 3、通过代理类 proxyClass 获得他的带InvocationHandler 接口的构造函数 ProxyConstructor
* 4、通过构造函数实例 ProxyConstructor 实例化一个代理对象，并将 InvocationHandler 接口实例传递给代理类。
/
// 1、创建 InvocationHandler 实例并设置代理的目标类对象
Person persontwo = new SoftwareEngineer(“Vincent”);
InvocationHandler Handlertwo = new PersonInvocationHandler<>(persontwo); // 2 创建代理类,是一个字节码文件, 把 proxyClass 保存起来就能看到他继承Proxy 类，实现Person接口
Class<?> proxyClass = Proxy.getProxyClass(Person.class.getClassLoader(), new Class<?>[]{Person.class}); /* 代理类信息 /
System.out.println(“package = " + proxyClass.getPackage() + " SimpleName = " + proxyClass.getSimpleName() + " name =” + proxyClass.getName() + " CanonicalName = " + “” + proxyClass.getCanonicalName() + " 实现的接口 Interfaces = " + Arrays.toString(proxyClass.getInterfaces()) + " superClass = " + proxyClass.getSuperclass() + " methods =" + Arrays.toString(proxyClass.getMethods())); // 3、通过 proxyClass 获得一个带有InvocationHandler参数的构造器constructor
Constructor<?> ProxyConstructor = proxyClass.getConstructor(InvocationHandler.class); // 4、通过构造器创建一个动态代理类实例
Person stuProxy = (Person) ProxyConstructor.newInstance(Handlertwo); /* 检测生成的类是否是代理类 /
System.out.println("stuProxy isProxy "+Proxy.isProxyClass(stuProxy.getClass())); /* 获取代理类关联的 InvocationHandler 是哪个*/
InvocationHandler handlerObject = Proxy.getInvocationHandler(stuProxy);
System.out.println(handlerObject.getClass().getName());
stuProxy.goWorking(stuProxy.getName(), “广州”); // 保存代理類
saveClass("$PersonProxy0", proxyClass.getInterfaces(), “D:/123/”);
} /**
- 生成代理类 class 并保持到文件中
- @param className 生成的代理类名称
- @param interfaces 代理类需要实现的接口
- @param pathdir 代理类保存的目录路径,以目录分隔符结尾
  /
  public static void saveClass(String className, Class<?>[] interfaces, String pathdir) { /*
  - 第一个参数是代理类名。
  - 第二个参数是代理类需要实现的接口
    /
    byte[] classFile = ProxyGenerator.generateProxyClass(className, interfaces); /*
  - 如果目录不存在就新建所有子目录
    /
    Path path1 = Paths.get(pathdir); if (!path1.toFile().exists()){
    path1.toFile().mkdirs();
    }
    String path = pathdir + className + “.class”; try (FileOutputStream fos = new FileOutputStream(path)) {
    fos.write(classFile);
    fos.flush();
    System.out.println(“代理类class文件写入成功”);
    } catch (Exception e) {
    System.out.println(“写文件错误”);
    }
    } /*
- 设置保存Java动态代理生成的类文件。
- @throws Exception
  */
  public static void saveGeneratedJdkProxyFiles() throws Exception {
  Field field = System.class.getDeclaredField(“props”);
  field.setAccessible(true);
  Properties props = (Properties) field.get(null);
  props.put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”);
  }}