atomiclong 初始化_深度剖析java中JDK动态代理机制

摘要

相比于静态代理，动态代理避免了开发人员编写各个繁锁的静态代理类，只需简单地指定一组接口及目标类对象就能动态的获得代理对象。

代理模式

使用代理模式必须要让代理类和目标类实现相同的接口，客户端通过代理类来调用目标方法，代理类会将所有的方法调用分派到目标对象上反射执行，还可以在分派过程中添加"前置通知"和后置处理(如在调用目标方法前校验权限，在调用完目标方法后打印日志等)等功能。

使用动态代理的五大步骤

1.通过实现InvocationHandler接口来自定义自己的InvocationHandler;

2.通过Proxy.getProxyClass获得动态代理类

3.通过反射机制获得代理类的构造方法，方法签名为getConstructor(InvocationHandler.class)

4.通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入

5.通过代理对象调用目标方法

动态代理的使用

例1(方式一)

public class MyProxy {

public interface IHello{

void sayHello();

}

static class Hello implements IHello{

public void sayHello() {

System.out.println("Hello world!!");

}

}

//自定义InvocationHandler

static class HWInvocationHandler implements InvocationHandler{

//目标对象

private Object target;

public HWInvocationHandler(Object target){

this.target = target;

}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println("------插入前置通知代码-------------");

//执行相应的目标方法

Object rs = method.invoke(target,args);

System.out.println("------插入后置处理代码-------------");

return rs;

}

}

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetExc eption, InstantiationException {

//生成$Proxy0的class文件

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

//获取动态代理类

Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);

//获得代理类的构造函数，并传入参数类型InvocationHandler.class

Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);

//通过构造函数来创建动态代理对象，将自定义的InvocationHandler实例传入

IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));

//通过代理对象调用目标方法

iHello.sayHello();

}

}

输出：

------插入前置通知代码-------------

Hello world!!

------插入后置处理代码-------------

Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象，其方法签名为：newProxyInstance(ClassLoader loader,Class>[] instance, InvocationHandler h)，如下例：

(方式二)

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

//生成$Proxy0的class文件

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

IHello ihello = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), //加载接口的类加载器

new Class[]{IHello.class}, //一组接口

new HWInvocationHandler(new Hello())); //自定义的InvocationHandler

ihello.sayHello();

}

输出结果一样.

下面以newProxyInstance方法为切入点来剖析代理类的生成及代理方法的调用

(为了篇幅整洁去掉了次要的代码)

public static Object newProxyInstance(ClassLoader loader,

Class[] interfaces,

InvocationHandler h)

throws IllegalArgumentException

{

if (h == null) { //如果h为空直接抛出异常，所以InvocationHandler实例对象是必须的

throw new NullPointerException();

}

//对象的拷贝,暂不知道这里拷贝下的意义是啥？

final Class[] intfs = interfaces.clone();

//一些安全的权限检查

final SecurityManager sm = System.getSecurityManager();

if (sm != null) {

checkProxyAccess(Reflection.getCallerClass(), loader, intfs);

}

//产生代理类

Class cl = getProxyClass0(loader, intfs);

//获取代理类的构造函数对象

//参数constructorParames为常量值：private static final Class[] constructorParams = { InvocationHandler.class };

final Constructor cons = cl.getConstructor(constructorParames);

final InvocationHandler ih = h;

//根据代理类的构造函数对象来创建代理类对象

return newInstance(cons, ih);

}

这段代码就是对代理类对象的创建，就是对例1中34~38行封装，其中getProxyClass0就是生成代理类的方法

getProxyClass0方法剖析

private static Class getProxyClass0(ClassLoader loader,

Class... interfaces) {

//接口数不得超过65535个

if (interfaces.length > 65535) {

throw new IllegalArgumentException("interface limit exceeded");

}

//代理类缓存，如果缓存中有代理类了直接返回，否则将由ProxyClassFactory创建代理类

return proxyClassCache.get(loader, interfaces);

}

看看ProxyClassFactory是怎样生成代理类的?

private static final class ProxyClassFactory

implements BiFunction[], Class>

{

//统一代理类的前缀名都以$Proxy开关

private static final String proxyClassNamePrefix = "$Proxy";

//使用唯一的编号给作为代理类名的一部分，如$Proxy0,$Proxy1等

private static final AtomicLong nextUniqueNumber = new AtomicLong();

@Override

public Class apply(ClassLoader loader, Class[] interfaces) {

Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);

for (Class intf : interfaces) {

//验证指定的类加载器(loader)加载接口所得到的Class对象(interfaceClass)是否与intf对象相同

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");

}

//验证该Class对象是不是接口

if (!interfaceClass.isInterface()) {

throw new IllegalArgumentException(

interfaceClass.getName() + " is not an interface");

}

// 验证该接口是否重复了

if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {

throw new IllegalArgumentException(

"repeated interface: " + interfaceClass.getName());

}

}

//声明代理类所在包

String proxyPkg = null;

/*验证你传入的接口中是否有非public接口，只要有一个接口是非public的，那么这些接口都必须在同一包中

这里的接口修饰符直接影响到System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")所生成

的代理类的路径，往下看！！*/

for (Class intf : interfaces) {

int flags = intf.getModifiers();

if (!Modifier.isPublic(flags)) {

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) {

/*如果都是public接口，那么生成的代理类就在com.sun.proxy包下如果报java.io.FileNotFoundException: com\sun\proxy\$Proxy0.c lass (系统找不到指定的路径。)的错误，就先在你项目中创建com.sun.proxy路径*/

proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";

}

//将当前nextUniqueNumber的值以原子的方式的加1，所以第一次生成代理类的名字为$Proxy0.class

long num = nextUniqueNumber.getAndIncrement();

//代理类的完全限定名，如com.sun.proxy.$Proxy0.calss,

String proxyName = proxyPkg + proxyClassNamePrefix + num;

//生成代理类字节码文件

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(

proxyName, interfaces);

try {

return defineClass0(loader, proxyName,

proxyClassFile, 0, proxyClassFile.length);

} catch (ClassFormatError e) {

throw new IllegalArgumentException(e.toString());

}

}

}

而生成代理类字节码文件又主要通过ProxyGenerate的generateProxyClass(proxyName，interfaces)

public static byte[] generateProxyClass(final String var0, Class[] var1) {

ProxyGenerator var2 = new ProxyGenerator(var0, var1);

//生成代理类字节码文件的真正方法

final byte[] var3 = var2.generateClassFile();

//保存文件

if(saveGeneratedFiles) {

AccessController.doPrivileged(new PrivilegedAction() {

public Void run() {

try {

FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");

var1.write(var3);

var1.close();

return null;

} catch (IOException var2) {

throw new InternalError("I/O exception saving generated file: " + var2);

}

}

});

}

return var3;

}

层层调用后，最终generateClassFile才是真正生成代理类字节码文件的方法，注意开头的三个addProxyMethod方法是只将Object的hashcode,equals,toString方法添加到代理方法容器中，代理类除此之外并没有重写其他Object的方法，所以除这三个方法外，代理类调用其他方法的行为与Object调用这些方法的行为一样不通过Invoke

private byte[] generateClassFile() {

/addProxyMethod系列方法就是将接口的方法和Object的hashCode,equals,toString方法添加到代理方法容器(proxyMethods),

其中方法签名作为key,proxyMethod作为value*/

/*hashCodeMethod方法位于静态代码块中通过Object对象获得，hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]),

相当于从Object中继承过来了这三个方法equalsMethod,toStringMethod*/

this.addProxyMethod(hashCodeMethod, Object.class); -->

this.addProxyMethod(equalsMethod, Object.class);

this.addProxyMethod(toStringMethod, Object.class);

int var1;

int var3;

//获得所有接口中的所有方法，并将方法添加到代理方法中

for(var1 = 0; var1 < this.interfaces.length; ++var1) {

Method[] var2 = this.interfaces[var1].getMethods();

for(var3 = 0; var3 < var2.length; ++var3) {

this.addProxyMethod(var2[var3], this.interfaces[var1]);

}

}

Iterator var7 = this.proxyMethods.values().iterator();

List var8;

while(var7.hasNext()) {

var8 = (List)var7.next();

checkReturnTypes(var8); //验证具有相同方法签名的的方法的返回值类型是否一致，因为不可能有两个方法名相同,参数相同，而返回值却不同的方法

};

//接下来就是写代理类文件的步骤了

Iterator var11

try {

//生成代理类的构造函数

this.methods.add(this.generateConstructor());

var7 = this.proxyMethods.values().iterator();

while(var7.hasNext()) {

var8 = (List)var7.next();

var11 = var8.iterator();

while(var11.hasNext()) {

ProxyGenerator.ProxyMethod var4 = (ProxyGenerator.ProxyMethod)var11.next();

/将代理字段声明为Method，10为ACC_PRIVATE和ACC_STATAIC的与运算，表示该字段的修饰符为private static

所以代理类的字段都是private static Method XXX*/

this.fields.add(new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;", 10));

//生成代理类的代理方法

this.methods.add(var4.generateMethod());

}

}

//为代理类生成静态代码块，对一些字段进行初始化

this.methods.add(this.generateStaticInitializer());

} catch (IOException var6) {

throw new InternalError("unexpected I/O Exception");

}

if(this.methods.size() > '\uffff') { //代理方法超过65535将抛出异常

throw new IllegalArgumentException("method limit exceeded");

} else if(this.fields.size() > '\uffff') { //代理类的字段超过65535将抛出异常

throw new IllegalArgumentException("field limit exceeded");

} else {

//这里开始就是一些代理类文件的过程，此过程略过

this.cp.getClass(dotToSlash(this.className));

this.cp.getClass("java/lang/reflect/Proxy");

for(var1 = 0; var1 < this.interfaces.length; ++var1) {

this.cp.getClass(dotToSlash(this.interfaces[var1].getName()));

}

this.cp.setReadOnly();

ByteArrayOutputStream var9 = new ByteArrayOutputStream();

DataOutputStream var10 = new DataOutputStream(var9);

try {

var10.writeInt(-889275714);

var10.writeShort(0);

var10.writeShort(49);

this.cp.write(var10);

var10.writeShort(49);

var10.writeShort(this.cp.getClass(dotToSlash(this.className)));

var10.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));

var10.writeShort(this.interfaces.length);

for(var3 = 0; var3 < this.interfaces.length; ++var3) {

var10.writeShort(this.cp.getClass(dotToSlash(this.interfaces[var3].getName())));

}

var10.writeShort(this.fields.size());

var11 = this.fields.iterator();

while(var11.hasNext()) {

ProxyGenerator.FieldInfo var12 = (ProxyGenerator.FieldInfo)var11.next();

var12.write(var10);

}

var10.writeShort(this.methods.size());

var11 = this.methods.iterator();

while(var11.hasNext()) {

ProxyGenerator.MethodInfo var13 = (ProxyGenerator.MethodInfo)var11.next();

var13.write(var10);

}

var10.writeShort(0);

return var9.toByteArray();

} catch (IOException var5) {

throw new InternalError("unexpected I/O Exception");

}

}

}

addProxyMethod方法剖析

private void addProxyMethod(Method var1, Class var2) {

String var3 = var1.getName(); //方法名

Class[] var4 = var1.getParameterTypes(); //方法参数类型数组

Class var5 = var1.getReturnType(); //返回值类型

Class[] var6 = var1.getExceptionTypes(); //异常类型

String var7 = var3 + getParameterDescriptors(var4); //方法签名

Object var8 = (List)this.proxyMethods.get(var7); //根据方法签名却获得proxyMethods的Value

if(var8 != null) { //处理多个代理接口中重复的方法的情况

Iterator var9 = ((List)var8).iterator();

while(var9.hasNext()) {

ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();

if(var5 == var10.returnType) {

/*归约异常类型以至于让重写的方法抛出合适的异常类型，我认为这里可能是多个接口中有相同的方法，而这些相同的方法抛出的异常类 型又不同，所以对这些相同方法抛出的异常进行了归约*/

ArrayList var11 = new ArrayList();

collectCompatibleTypes(var6, var10.exceptionTypes, var11);

collectCompatibleTypes(var10.exceptionTypes, var6, var11);

var10.exceptionTypes = new Class[var11.size()];

//将ArrayList转换为Class对象数组

var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);

return;

}

}

} else {

var8 = new ArrayList(3);

this.proxyMethods.put(var7, var8);

}

((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null));

/*24~27行的意思就是如果var8为空，就创建一个数组，并以方法签名为key,proxymethod对象数组为value添加到proxyMethods*/

}

InvocationHandler的作用

在动态代理中InvocationHandler是核心，每个代理实例都具有一个关联的调用处理程序(InvocationHandler)。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序(InvocationHandler)的 invoke 方法。所以对代理方法的调用都是通InvocationHadler的invoke来实现中，而invoke方法根据传入的代理对象，方法和参数来决定调用代理的哪个方法

invoke方法签名：invoke(Object Proxy，Method method，Object[] args)

$Proxy0.class

来看看例1(MyProxy)的代理类是怎样的？

public final class $Proxy0 extends Proxy implements IHello { //继承了Proxy类和实现IHello接口

//变量，都是private static Method XXX

private static Method m3;

private static Method m1;

private static Method m0;

private static Method m2;

//代理类的构造函数，其参数正是是InvocationHandler实例，Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的

public $Proxy0(InvocationHandler var1) throws {

super(var1);

}

//接口代理方法

public final void sayHello() throws {

try {

super.h.invoke(this, m3, (Object[])null);

} catch (RuntimeException | Error var2) {

throw var2;

} catch (Throwable var3) {

throw new UndeclaredThrowableException(var3);

}

}

//以下Object中的三个方法

public final boolean equals(Object var1) throws {

try {

return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();

} catch (RuntimeException | Error var3) {

throw var3;

} catch (Throwable var4) {

throw new UndeclaredThrowableException(var4);

}

}

public final int hashCode() throws {

try {

return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();

} 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 {

m3 = Class.forName("com.mobin.proxy.IHello").getMethod("sayHello", new Class[0]);

m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});

m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);

m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);

} catch (NoSuchMethodException var2) {

throw new NoSuchMethodError(var2.getMessage());

} catch (ClassNotFoundException var3) {

throw new NoClassDefFoundError(var3.getMessage());

}

}

}

以上就是对代理类如何生成，代理类方法如何被调用的分析！在很多框架都使用了动态代理如Spring,HDFS的RPC调用等等，分析过程中收获很多，如果想深入的了解JDK动态代理机制一定要深入到源码去剖析！！希望对大家的学习有所帮助，也希望大家多多支持脚本之家。