参考文档: https://www.cnblogs.com/whirly/p/10154887.html
本文将介绍的Java动态代理与设计模式中的代理模式有关,什么是代理模式呢?
代理模式:给某一个对象提供一个代理,并由代理对象来控制对真实对象的访问。代理模式是一种结构型设计模式。
代理模式角色分为 3 种:
Subject(抽象主题角色):定义代理类和真实主题的公共对外方法,也是代理类代理真实主题的方法;
RealSubject(真实主题角色):真正实现业务逻辑的类;
Proxy(代理主题角色):用来代理和封装真实主题;
代理模式的结构比较简单,其核心是代理类,为了让客户端能够一致性地对待真实对象和代理对象,在代理模式中引入了抽象层
代理模式类图
代理模式按照职责(使用场景)来分类,至少可以分为以下几类:1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。 4、保护(Protect or Access)代理。 5、Cache代理。 6、防火墙(Firewall)代理。 7、同步化(Synchronization)代理。 8、智能引用(Smart Reference)代理等等。
如果根据字节码的创建时机来分类,可以分为静态代理和动态代理:
所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和真实主题角色的关系在运行前就确定了。
而动态代理的源码是在程序运行期间由JVM根据反射等机制动态的生成,所以在运行前并不存在代理类的字节码文件
接下来我们使用代码实现动态代理
被代理类接口
public interface Client {
void getUp();
void sleep();
}
被代理类实现类
public class ClientImpl implements Client{
private String name;
public ClientImpl(String name) {
this.name = name;
}
@Override
public void sleep() {
System.out.println(name+"睡觉了");
}
public void getUp(){
System.out.println(name+"起床了");
}
}
逻辑控制器
/**
* 逻辑处理器
*/
import java.lang.reflect.*;
public class ClientProxy implements InvocationHandler {
//被代理类
private Object target;
//代理类
private Object proxy;
//被代理类属性
private String name;
public Object getProxy() {
return proxy;
}
//改造方法
public ClientProxy(Object _target) throws NoSuchFieldException, IllegalAccessException {
target=_target;
Class<?> c = _target.getClass();
//被代理类加载器
ClassLoader classLoader = c.getClassLoader();
//被代理类实现接口
Class<?>[] interfaces = c.getInterfaces();
//创建代理类
this.proxy = Proxy.newProxyInstance(classLoader, interfaces, this);
//获取被代理类的属性
Field _name = c.getDeclaredField("name");
_name.setAccessible(true);
this.name = (String)_name.get(target);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
xl();
//通过反射执行方法
Object invoke = method.invoke(target, args);
xz();
//返回结果集
return invoke;
}
public void xl() throws NoSuchFieldException, IllegalAccessException {
System.out.println(name+"洗脸刷牙");
}
public void xz(){
System.out.println(name+"洗脸刷牙洗澡");
}
}
main方法
public class Test {
public static void main(String[] args) {
//被代理对象
ClientImpl target=new ClientImpl("李四");
ClientProxy clientProxy= null;
try {
//创建逻辑控制器 其内部生成代理类
clientProxy = new ClientProxy(target);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
//获取代理对象 对其类型强制转换
Client proxy=(Client) clientProxy.getProxy();
//调用方法
proxy.getUp();
//将代理类io流写到磁盘
ProxyUtils.generateClassFile(clientProxy.getClass(), "ClientImplProxy");
}
}
ProxyUtils
public class ProxyUtils {
/**
* 将根据类信息动态生成的二进制字节码保存到硬盘中,默认的是clazz目录下
* params: clazz 需要生成动态代理类的类
* proxyName: 为动态生成的代理类的名称
*/
public static void generateClassFile(Class clazz, String proxyName) {
// 根据类信息和提供的代理类名称,生成字节码
byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
//获取路径
String paths = clazz.getResource(".").getPath();
System.out.println(paths);
FileOutputStream out = null;
try {
//保留到硬盘中
out = new FileOutputStream(paths + proxyName + ".class");
out.write(classFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
反编译后的代理类
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class ClientImplProxy extends Proxy implements InvocationHandler {
//每一个方法
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public ClientImplProxy(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final Object invoke(Object var1, Method var2, Object[] var3) throws Throwable {
//调用其逻辑控制器的invoke方法
return (Object)super.h.invoke(this, m3, new Object[]{var1, var2, var3});
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("java.lang.reflect.InvocationHandler").getMethod("invoke", Class.forName("java.lang.Object"), Class.forName("java.lang.reflect.Method"), Class.forName("[Ljava.lang.Object;"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}