Java 动态代理的底层原理
【摘要】
点击下方“Java编程鸭”关注并标星
更多精彩 第一时间直达
1. 代理模式
代理模式是常用的设计模式之一，其特征是代理类与被代理类有相同的接口，代理类可以为被代理类方法执行进行前置后置处理，增强被代理类方法
代理模式的类结构通常如上图所示，代理类与被代理类之间会存在关联关系，一个代理类的对象持有一个被代理类的对象。代...
点击下方“Java编程鸭”关注并标星
更多精彩 第一时间直达
1. 代理模式
代理模式是常用的设计模式之一，其特征是代理类与被代理类有相同的接口，代理类可以为被代理类方法执行进行前置后置处理，增强被代理类方法
代理模式的类结构通常如上图所示，代理类与被代理类之间会存在关联关系，一个代理类的对象持有一个被代理类的对象。代理类的对象本身并不真正实现服务，而是通过调用被代理类对象的相关方法来提供特定的服务
2. 动态代理使用
代理类并不是在 Java 代码中定义，而是在运行时根据在 Java 代码中的“指示”动态生成(字节码由JVM在运行时动态生成而非预存在任何一个 .class 文件中)， 这种在程序运行时创建代理类的代理方式被称为动态代理，它的优势在于可以方便地对代理类的函数进行统一处理。
这是因为所有被代理执行的方法，都是通过InvocationHandler#invoke()方法调用，相当于给被代理类所有方法套了一层壳，所以只要在这个方法中统一处理，就可以对所有被代理的方法进行相同的操作了
以下代码展示了动态代理的简单使用，其基本步骤如下：
定义一个公共接口，本例中为
IHello，接口中有一个抽象方法定义一个实现了公共接口的实体类作为被代理类，本例中被代理类
Hello实现了IHello接口，重写了接口中的抽象方法定义一个实现了
InvocationHandler接口的方法拦截类，重写invoke()方法实现拦截到被代理类方法执行时候的处理逻辑通过
Proxy.newProxyInstance()方法生成代理对象，持有代理对象之后执行接口方法即可
-
public class ServiceProxy {
-
-
public interface IHello {
-
String sayHi();
-
}
-
-
public static class Hello implements IHello {
-
@Override
-
public String sayHi() {
-
return "Hello";
-
}
-
}
-
-
// 动态代理类
-
public static class ProxyHandler<T> implements InvocationHandler {
-
private T origin;
-
-
public ProxyHandler(T origin) {
-
this.origin = origin;
-
}
-
-
/**
-
* @param o 代理对象引用
-
* @param method 正在执行目标的方法
-
* @param objects 目标方法执行时的入参
-
*/
-
@Override
-
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
-
String s = "proxy";
-
s += method.invoke(origin, objects);
-
return s;
-
}
-
}
-
-
public static void main(String[] args) {
-
IHello IHello = (IHello) getInstance(IHello.class, new ProxyHandler<>(new Hello()));
-
-
System.out.println(IHello.toString());
-
-
generateProxyClass();
-
}
-
-
// 创建代理对象
-
public static <T> Object getInstance(Class<T> clazz, ProxyHandler<T> handler) {
-
return Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, handler);
-
}
-
-
private static void generateProxyClass() {
-
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Hello.class.getInterfaces());
-
String path = "/Users/nathan.yang/workspace/algorithm_Java/out/StuProxy.class";
-
try (FileOutputStream fos = new FileOutputStream(path)) {
-
fos.write(classFile);
-
fos.flush();
-
System.out.println("代理类文件写入成功");
-
} catch (Exception e) {
-
System.out.println("写文件错误");
-
}
-
}
-
}
3. 动态代理原理
1.Proxy#newProxyInstance() 方法是动态代理的入口，其生成动态代理对象主要有以下几个步骤：
getProxyClass0()方法生成代理类获取到代理类后将
InvocationHandler对象入参，反射调用构造方法生成动态代理对象
-
public static Object newProxyInstance(ClassLoader loader,
-
Class<?>[] interfaces,
-
InvocationHandler h)
-
throws IllegalArgumentException
-
{
-
Objects.requireNonNull(h);
-
-
final Class<?>[] intfs = interfaces.clone();
-
final SecurityManager sm = System.getSecurityManager();
-
if (sm != null) {
-
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
-
}
-
-
/*
-
* Look up or generate the designated proxy class.
-
*/
-
Class<?> cl = getProxyClass0(loader, intfs);
-
-
/*
-
* Invoke its constructor with the designated invocation handler.
-
*/
-
try {
-
if (sm != null) {
-
checkNewProxyPermission(Reflection.getCallerClass(), cl);
-
}
-
-
final Constructor<?> cons = cl.getConstructor(constructorParams);
-
final InvocationHandler ih = h;
-
if (!Modifier.isPublic(cl.getModifiers())) {
-
AccessController.doPrivileged(new PrivilegedAction<Void>() {
-
public Void run() {
-
cons.setAccessible(true);
-
return null;
-
}
-
});
-
}
-
return cons.newInstance(new Object[]{h});
-
} catch (IllegalAccessException|InstantiationException e) {
-
throw new InternalError(e.toString(), e);
-
} catch (InvocationTargetException e) {
-
Throwable t = e.getCause();
-
if (t instanceof RuntimeException) {
-
throw (RuntimeException) t;
-
} else {
-
throw new InternalError(t.toString(), t);
-
}
-
} catch (NoSuchMethodException e) {
-
throw new InternalError(e.toString(), e);
-
}
-
}
2.Proxy#getProxyClass0() 方法其实是从一个 WeakCache 中去获取代理类，其获取逻辑是如果缓存类中没有代理类的话就调用ProxyClassFactory#apply()，通过代理类工厂去即时生成一个代理类，其步骤如下：
首先通过指定的类加载器去验证目标接口是否可被其加载
通过接口所在包等条件决定代理类所在包及代理类的全限定名称，代理类名称是
包名+$Proxy+id通过
ProxyGenerator.generateProxyClass()生成字节码数组，然后调用native方法defineClass0()将其动态生成的代理类字节码加载到内存中
-
private static Class<?> getProxyClass0(ClassLoader loader,
-
Class<?>... interfaces) {
-
if (interfaces.length > 65535) {
-
throw new IllegalArgumentException("interface limit exceeded");
-
}
-
-
// If the proxy class defined by the given loader implementing
-
// the given interfaces exists, this will simply return the cached copy;
-
// otherwise, it will create the proxy class via the ProxyClassFactory
-
return proxyClassCache.get(loader, interfaces);
-
}
-
-
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
-
-
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
-
for (Class<?> intf : interfaces) {
-
/*
-
* Verify that the class loader resolves the name of this
-
* interface to the same Class object.
-
*/
-
Class<?> interfaceClass = null;
-
try {
-
interfaceClass = Class.forName(intf.getName(), false, loader);
-
} catch (ClassNotFoundException e) {
-
}
-
if (interfaceClass != intf) {
-
throw new IllegalArgumentException(
-
intf + " is not visible from class loader");
-
}
-
/*
-
* Verify that the Class object actually represents an
-
* interface.
-
*/
-
if (!interfaceClass.isInterface()) {
-
throw new IllegalArgumentException(
-
interfaceClass.getName() + " is not an interface");
-
}
-
/*
-
* Verify that this interface is not a duplicate.
-
*/
-
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
-
throw new IllegalArgumentException(
-
"repeated interface: " + interfaceClass.getName());
-
}
-
}
-
-
String proxyPkg = null; // package to define proxy class in
-
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
-
-
/*
-
* Record the package of a non-public proxy interface so that the
-
* proxy class will be defined in the same package. Verify that
-
* all non-public proxy interfaces are in the same package.
-
*/
-
for (Class<?> intf : interfaces) {
-
int flags = intf.getModifiers();
-
if (!Modifier.isPublic(flags)) {
-
accessFlags = Modifier.FINAL;
-
String name = intf.getName();
-
int n = name.lastIndexOf('.');
-
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
-
if (proxyPkg == null) {
-
proxyPkg = pkg;
-
} else if (!pkg.equals(proxyPkg)) {
-
throw new IllegalArgumentException(
-
"non-public interfaces from different packages");
-
}
-
}
-
}
-
-
if (proxyPkg == null) {
-
// if no non-public proxy interfaces, use com.sun.proxy package
-
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
-
}
-
-
/*
-
* Choose a name for the proxy class to generate.
-
*/
-
long num = nextUniqueNumber.getAndIncrement();
-
String proxyName = proxyPkg + proxyClassNamePrefix + num;
-
-
/*
-
* Generate the specified proxy class.
-
*/
-
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
-
proxyName, interfaces, accessFlags);
-
try {
-
return defineClass0(loader, proxyName,
-
proxyClassFile, 0, proxyClassFile.length);
-
} catch (ClassFormatError e) {
-
/*
-
* A ClassFormatError here means that (barring bugs in the
-
* proxy class generation code) there was some other
-
* invalid aspect of the arguments supplied to the proxy
-
* class creation (such as virtual machine limitations
-
* exceeded).
-
*/
-
throw new IllegalArgumentException(e.toString());
-
}
-
}
3.反射获取到代理类参数为 InvocationHandler.class 的构造器，其实也就是 Proxy 的带参构造器，调用构造器cons.newInstance(new Object[]{h})生成代理对象
-
protected Proxy(InvocationHandler h) {
-
Objects.requireNonNull(h);
-
this.h = h;
-
}
4.通过以下代码可以将 JVM 中加载的代理类输出成 class 文件，之后就可以使用反编译工具查看代理类的源码
-
private static void generateProxyClass() {
-
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Hello.class.getInterfaces());
-
String path = "/Users/nathan/workspace/algorithm_Java/out/StuProxy.class";
-
try (FileOutputStream fos = new FileOutputStream(path)) {
-
fos.write(classFile);
-
fos.flush();
-
System.out.println("代理类文件写入成功");
-
} catch (Exception e) {
-
System.out.println("写文件错误");
-
}
-
}
5.生成的代理类源码如下，很明显可以看到该类实现动态代理的原理：
通过
static代码块将被代理类中每一个方法封装为Method对象，生成方法表代理类对象执行被代理类同名方法时，通过其父类
Proxy保留的指向InvocationHandler对象的引用调用InvocationHandler#invoke()方法，完成动态代理
-
public final class $Proxy0 extends Proxy implements IHello {
-
private static Method m1;
-
private static Method m3;
-
private static Method m2;
-
private static Method m0;
-
-
public $Proxy0(InvocationHandler var1) throws {
-
super(var1);
-
}
-
-
public final String sayHi() throws {
-
try {
-
// 父类 Proxy 保留的指向 InvocationHandler 对象的引用调用 invoke() 方法
-
return (String)super.h.invoke(this, m3, (Object[])null);
-
} catch (RuntimeException | Error var2) {
-
throw var2;
-
} catch (Throwable var3) {
-
throw new UndeclaredThrowableException(var3);
-
}
-
}
-
-
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);
-
}
-
}
-
-
......
-
-
// 方法表
-
static {
-
try {
-
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
-
m3 = Class.forName("ServiceProxy$IHello").getMethod("sayHi");
-
m2 = Class.forName("java.lang.Object").getMethod("toString");
-
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
-
} catch (NoSuchMethodException var2) {
-
throw new NoSuchMethodError(var2.getMessage());
-
} catch (ClassNotFoundException var3) {
-
throw new NoClassDefFoundError(var3.getMessage());
-
}
-
}
-
}
来源：https://blog.csdn.net/weixin_45505313
END
-
看完本文有收获？请转发分享给更多人
-
关注「Java编程鸭」，提升Java技能
-
关注Java编程鸭微信公众号，后台回复：码农大礼包 可以获取最新整理的技术资料一份。涵盖Java 框架学习、架构师学习等！
-
-
-
文章有帮助的话，在看，转发吧。
-
谢谢支持哟 (*^__^*）
文章来源: mingongge.blog.csdn.net，作者：民工哥，版权归原作者所有，如需转载，请联系作者。
原文链接：mingongge.blog.csdn.net/article/details/126046792
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）