JDK动态代理的使用示例：
JDK中的动态代理是面向接口实现的，所以要使用JDK的动态代理，必须要创建接口。
1、创建代理接口ProxyService:
package cn.zsm.proxy.service;
public interface ProxyService {
void proxyMethod();
}2、创建接口实现类ProxyServiceImpl
package cn.zsm.proxy.service.impl;
import cn.zsm.proxy.service.ProxyService;
public class ProxyServiceImpl implements ProxyService {
@Override
public void proxyMethod() {
System.out.println("ProxyService.proxyMethod() running");
}
}
3、创建InvocationHandler接口的实现类
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target){
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("MyInvocationHandler.invoke 方法开始");
method.invoke(target, args);
System.out.println("MyInvocationHandler.invoke 方法结束");
return null;
}
}4、测试动态代理
public class JavaProxyTest {
public static void main(String[] args) {
MyInvocationHandler handler = new MyInvocationHandler(new ProxyServiceImpl());
ProxyService proxyService = (ProxyService) Proxy.newProxyInstance(JavaProxyTest.class.getClassLoader(), new Class[] { ProxyService.class }, handler);
proxyService.proxyMethod();
}
}输出结果：
动态代理测试代码的执行过程：
- 创建InvocationHandler接口实例
- 获取动态代理对象Proxy.newProxyInstance(...)
- 执行代理对象的方法：会进入InvocationHandler实例的invoke方法。对代理对象的所有接口方法调用都会转发到
InvocationHandler.invoke()方法
JDK对动态代理的实现原理--Proxy：
Proxy类中定义的一些静态变量：
// 代理类构造函数的参数类型
private static final Class<?>[] constructorParams =
{ InvocationHandler.class };
//proxy代理类的缓存
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
//此代理实例的调用处理程序。
protected InvocationHandler h;
Proxy的构造方法:
private Proxy() { } //私有构造，不能外部被调用
// Proxy 内部从不直接调用构造函数 ， 所以只能被子类调用
protected Proxy(InvocationHandler h) {
Objects.requireNonNull(h);
this.h = h;
}Proxy创建代理对象的核心方法：newProxyInstance
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h); //代理的处理程序不能为null
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) { //权限校验
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//查找或生成指定的代理类。(动态代理实现的关键)
Class<?> cl = getProxyClass0(loader, intfs);
//使用指定的调用处理程序调用其构造函数。
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);
}
}
newProxyInstance刚发的工作流程：
- 检查此代理实例的调用处理程序不为空；
- 获取系统权限并进行校验；
- 查找或生成指定的代理类： Class<?> cl = getProxyClass0(loader, intfs) ****这一步是创建代理对象的关键****；
- 使用指定的调用处理程序调用其构造函数。
下面来看一下getProxyClass0方法如何创建代理对象：
getProxyClass0：
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) { //代理接口的最大数量
throw new IllegalArgumentException("interface limit exceeded");
}
// 如果指定代理类存在，则返回缓存的副本;否则，通过ProxyClassFactory创建代理类
return proxyClassCache.get(loader, interfaces);
}getProxyClass0方法，调用proxyClassCache.get(loader, interfaces);获取或创建代理类，而proxyClassCache是Proxy类的静态变量 ： private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
到这里，代理类的创建工作似乎又转移到了WeakCache类的get方法中去了，下面就来看看WeakCache类的有参构造和get方法：
WeakCache：
new WeakCache<>(new KeyFactory(), new ProxyClassFactory())构造和初始化的两个参数：
private final BiFunction<K, P, ?> subKeyFactory;
private final BiFunction<K, P, V> valueFactory;
public WeakCache(BiFunction<K, P, ?> subKeyFactory,
BiFunction<K, P, V> valueFactory) {
this.subKeyFactory = Objects.requireNonNull(subKeyFactory); //校验变量不能为空，否则抛异常
this.valueFactory = Objects.requireNonNull(valueFactory);
}get方法：
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
expungeStaleEntries(); //删除过期的条目
Object cacheKey = CacheKey.valueOf(key, refQueue);
// 懒加载模式安装特定cacheKey的第2级valuesMap
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
//如果键存在则返回对应值，否则添加一个键值对
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
//创建子密钥并从valuesMap检索由该子密钥存储的可能的Supplier<V>
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) { //死循环
if (supplier != null) {// supplier可能是Factory或CacheValue<V>实例
V value = supplier.get();
if (value != null)
return value;
}
if (factory == null) {//缓存中没有Supplier或返回空的Supplier，则创建一个Factory
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {//安装工厂
supplier = factory;
}
} else {
if (valuesMap.replace(subKey, supplier, factory)) {
//用我们的工厂替换了已清除的CacheEntry或未成功的工厂
supplier = factory;
} else {//重新获取supplier
supplier = valuesMap.get(subKey);
}
}
}
}
从get方法中似乎不那么容易看出，代理类在何时、哪里被创建，而整个方法有返回值的地方却只有一处，也就是这一处返回了代理类。先整体看一下get方法的工作流程：
- 删除过期的条目，即ReferenceQueue中的数据
- 尝试从缓存中获取目标代理类
- 加密目标代理类的缓存键，这里要注意subKeyFactory.apply(key, parameter)方法的调用，他实际是调用Proxy的内部类KeyFactory的apply方法。
- 进入死循环，保证创建目标代理类：进入循环后先尝试从缓存中获取目标代理类；没有获取到，则创建一个factory工厂；将工厂实例赋值给supplier，这时supplier部位null，可以执行get方法获取目标代理类。
到这里，可以看出目标代理类的创建工作，又转移了，这次转移到了Factory的get方法中：Factory类是WeakCache的内部类，并且实现了Supplier接口。
Factory.get方法：
public synchronized V get() {
Supplier<V> supplier = valuesMap.get(subKey); //重新检查
if (supplier != this) {//如果等待过程中发生了变化，返回null
return null;
}
V value = null; //创建一个新的value
try {
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
assert value != null;
// 使用CacheValue包装值(WeakReference)
CacheValue<V> cacheValue = new CacheValue<>(value);
//将值存放进 reverseMap
reverseMap.put(cacheValue, Boolean.TRUE);
//尝试用cacheValue 替换this(一般都会成功)
if (!valuesMap.replace(subKey, this, cacheValue)) {
throw new AssertionError("Should not reach here");
}
return value;
}Factory的get方法的工作流程：
- 检查目标对象是否发生变化
- 创建目标代理类valueFactory.apply(key, parameter)
- 将目标代理类包装在CacheValue中，再讲CacheValue放入缓存中
- 用cacheValue替换valueMap中的factory，替换成功，则返回目标代理类
到这里可以看到调用valueFactory.apply(key, parameter)方法，目标代理类被创建。valueFactory变量的类型信息，从WeakCache的有参构造可Proxy类中proxyClassCache属性的初始化可以看出，valueFactory是ProxyClassFactory类的实例，而ProxyClassFactory是Proxy的内部类，也实现了Supplier接口。
ProxyClassFactory.apply方法：
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
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");
}
//验证类对象是否实际表示接口 (面向接口的代理)
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; //代理类信息所在的包
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
//记录非公共代理接口的包，以便在同一包中定义代理类。
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) { //没有非公共代理类，使用com.sun.proxy包
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
//为要生成的代理类选择一个名称。
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//生成代理类
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}ProxyClassFactory.apply方法的工作流程：
- 验证类加载器是否将此接口的名称解析为同一个类对象。
- 接口校验：验证类对象是否实际表示接口、验证接口是否重复。由此可以看出JDK的动态代理是面向接口实现的。
- 设置代理类接口所在的包：com.sun.proxy；设置代理类的名字：ProsyName
- 生成代理类：byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags);
到这里代理类的字节码信息已经获取到了：byte[] prosyClassFile。而ProxyGenerator.generateProxyClass方法在sun.misc包中，未提供源码，我们通过反编译可以看到：
ProxyGenerator.generateProxyClass：
public static byte[] generateProxyClass(String arg, Class<?>[] arg0, int arg1) {
ProxyGenerator arg2 = new ProxyGenerator(arg, arg0, arg1);
byte[] arg3 = arg2.generateClassFile(); //生成代理类
if(saveGeneratedFiles) {
AccessController.doPrivileged(new 1(arg, arg3));
}
return arg3;
}
//私有构造
private ProxyGenerator(String arg0, Class<?>[] arg1, int arg2) {
this.className = arg0;
this.interfaces = arg1;
this.accessFlags = arg2;
} ProxyGenerator.generateClassFile：
private byte[] generateClassFile() {
//添加从 Object基类中继承的方法
this.addProxyMethod(hashCodeMethod, Object.class);
this.addProxyMethod(equalsMethod, Object.class);
this.addProxyMethod(toStringMethod, Object.class);
//添加接口中的方法实现
Class[] arg0 = this.interfaces;
int arg1 = arg0.length;
int arg2;
Class arg3;
for (arg2 = 0; arg2 < arg1; ++arg2) {
arg3 = arg0[arg2];
Method[] arg4 = arg3.getMethods();
int arg5 = arg4.length;
for (int arg6 = 0; arg6 < arg5; ++arg6) {
Method arg7 = arg4[arg6];
this.addProxyMethod(arg7, arg3);
}
}
Iterator arg10 = this.proxyMethods.values().iterator();
List arg11;
while (arg10.hasNext()) {
arg11 = (List) arg10.next();
checkReturnTypes(arg11);
}
Iterator arg14;
try {
//构造方法
this.methods.add(this.generateConstructor());
arg10 = this.proxyMethods.values().iterator();
while (arg10.hasNext()) {
arg11 = (List) arg10.next();
arg14 = arg11.iterator();
while (arg14.hasNext()) {
ProxyMethod arg15 = (ProxyMethod) arg14.next();
this.fields.add(new FieldInfo(this, arg15.methodFieldName, "Ljava/lang/reflect/Method;", 10));
this.methods.add(ProxyMethod.access$100(arg15));
}
}
this.methods.add(this.generateStaticInitializer());
} catch (IOException arg9) {
throw new InternalError("unexpected I/O Exception", arg9);
}
if (this.methods.size() > '') {
throw new IllegalArgumentException("method limit exceeded");
} else if (this.fields.size() > '') {
throw new IllegalArgumentException("field limit exceeded");
} else {
this.cp.getClass(dotToSlash(this.className));
this.cp.getClass("java/lang/reflect/Proxy");
arg0 = this.interfaces;
arg1 = arg0.length;
for (arg2 = 0; arg2 < arg1; ++arg2) {
arg3 = arg0[arg2];
this.cp.getClass(dotToSlash(arg3.getName()));
}
this.cp.setReadOnly();
//生成文件
ByteArrayOutputStream arg12 = new ByteArrayOutputStream();
DataOutputStream arg13 = new DataOutputStream(arg12);
try {
arg13.writeInt(-889275714);
arg13.writeShort(0);
arg13.writeShort(49);
this.cp.write(arg13);
arg13.writeShort(this.accessFlags);
arg13.writeShort(this.cp.getClass(dotToSlash(this.className)));
arg13.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
arg13.writeShort(this.interfaces.length);
Class[] arg16 = this.interfaces;
int arg17 = arg16.length;
for (int arg18 = 0; arg18 < arg17; ++arg18) {
Class arg21 = arg16[arg18];
arg13.writeShort(this.cp.getClass(dotToSlash(arg21.getName())));
}
arg13.writeShort(this.fields.size());
arg14 = this.fields.iterator();
while (arg14.hasNext()) {
FieldInfo arg19 = (FieldInfo) arg14.next();
arg19.write(arg13);
}
arg13.writeShort(this.methods.size());
arg14 = this.methods.iterator();
while (arg14.hasNext()) {
MethodInfo arg20 = (MethodInfo) arg14.next();
arg20.write(arg13);
}
arg13.writeShort(0);
//返回字节流
return arg12.toByteArray();
} catch (IOException arg8) {
throw new InternalError("unexpected I/O Exception", arg8);
}
}
}这段代码基本都是关于流的编写，这里就不在详细介绍。
到这里代理类的信息创建完成，获取代理类后，利用反射调用他的构造方法创建代理对象。
Jdk动态代理和Cglib动态代理区别
jdk的动态代理，技术上是通过反射来生成代理的类。cglib也是在运行时动态生成代理类，和jdk动态代理区别在于cglib是利用asm开源框架直接操作class字节码文件来生成代理类
| Jdk动态代理 | Cglib |
|---|---|
| 代理目标是接口 | 可代理普通类，生成普通类的子类当作代理类 |
| 使用反射生成代理类 | 使用asm开源框架操作字节码 |
| Java 语言自带的功能 | 需要导入cglib包 |
| 反射性能较低 | 直接修改字节码性能好 |
333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
