前言：应用的 jdk 是 1.7，须要理解反射机制 泛型 字节码登概念！
一、代理模式
代理模式是罕用的 java 设计模式，他的特色是代理类与委托类有同样的接口，代理类次要负责为委托类预处理音讯、过滤音讯、把音讯转发给委托类，以及预先解决音讯等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象自身并不真正实现服务，而是通过调用委托类的对象的相干办法，来提供特定的服务。
二、编写一个 java 动静代理
1. 筹备两个接口
别离是 ProductService（生产接口）和 FactoryService（工厂接口）
代码如下：
package test.myproxy;
/**
* <ul>
* <li>Title: FactoryService</li>
* </ul>
*
* @author ken
* @date 2021/4/13 0013 上午 10:05
*/
public interface FactoryService {void addProduce(int num);
}
package test.myproxy;
/**
* <ul>
* <li>Title: ProductService</li>
* </ul>
*
* @author ken
* @date 2021/4/12 0012 下午 17:46
*/
public interface ProductService {
/**
* 增加产品
* @param productName
*/
void addProduct(String productName);
}
2. MyServiceImpl 类实现上述两个接口
package test.myproxy;
/**
* <ul>
* <li>Title: MyServiceImpl</li>
* <li>Description: TODO </li>
* </ul>
*
* @author ken
* @date 2021/4/12 0012 下午 17:47
*/
public class MyServiceImpl implements ProductService,FactoryService {
@Override
public void addProduct(String productName) {System.out.println("正在增加"+productName);
}
@Override
public void addProduce(int num) {System.out.println("筹备生成"+num+"件商品");
}
}
3. 实现动静代理的性能
3.1 jdk 中须要实现 InvocationHandler 这个接口，重写 invoke 办法
3.2 很多文章中为了便于了解，长把上面代码中的 target 和 getInstance 的参数写成理论的接口，如下面的 ProductService，这边不想这么写，是为了让大家能了解泛型，getInstance 的接口外面我也明确指出参数是与代理对象是继承关系 / 实现接口的关系。
代码如下：
package test.myproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* <ul>
* <li>Title: JdkInvocationHandler</li>
* <li>Description: TODO </li>
* </ul>
*
* @author ken
* @date 2021/4/12 0012 下午 17:45
*/
public class JdkInvocationHandler<T> implements InvocationHandler {
// 代理对象
private T target;
public <B extends T> T getInstance(B target){
this.target = target;
Class clazz = this.target.getClass();
// 参数 1：被代理类的类加载器 参数 2: 被代理类的接口 参数 3
return (T)Proxy.newProxyInstance(clazz.getClassLoader(),
clazz.getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String currentDate = simpleDateFormat.format(new Date());
System.out.println("日期【"+currentDate + "】增加了一款产品");
return method.invoke(target,args);
}
}
3.3 测试
这里的示例，用了泛型和强转两种形式：
public static void main(String[] args) throws Exception {ProductService proxy = new JdkInvocationHandler<ProductService>().getInstance(new MyServiceImpl());
proxy.addProduct("iphone");
FactoryService proxyFactory = (FactoryService) new JdkInvocationHandler().getInstance(new MyServiceImpl());
proxyFactory.addProduce(500);
// 这里咱们将 jdk 生成的代理类输入了进去，不便前面剖析应用
/* byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{productService.getClass()});
FileOutputStream os = new FileOutputStream("Proxy0.class");
os.write(bytes);
os.close();*/}
4. 剖析如何生成动静代理
在下面的 JdkInvocationHandler 类 实现了 InvocationHandler 接口，在 getInstance 办法中最要害的一行代码是 Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(), this)；
上面追随这个代码进一步分析内容：
上面给大家介绍是
地位: java.lang.reflect
类：Proxy
在这个类外面有一些成员属性，先理解一下前面有些会用到。
4.1 newProxyInstance 办法的内容
（为了看起来简洁 我把一些正文删掉了）
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)
throws IllegalArgumentException
{if (h == null) {throw new NullPointerException();
}
/*
* 查找或生成指定的代理类。* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, interfaces); // stack walk magic: do not refactor
/*
* Invoke its constructor with the designated invocation handler.
*/
try {final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
SecurityManager sm = System.getSecurityManager();
if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
// create proxy instance with doPrivilege as the proxy class may
// implement non-public interfaces that requires a special permission
return AccessController.doPrivileged(new PrivilegedAction<Object>() {public Object run() {return newInstance(cons, ih);
}
});
} else {return newInstance(cons, ih);
}
} catch (NoSuchMethodException e) {throw new InternalError(e.toString());
}
}
这段代码是通过 c1 这个 Class 类信息，依据结构函数参数，动静生成反射类。这里很重要的在 getProxyClass0 这行代码，正文上的英文的意思是 运行在堆上，且这部分代码不要重构。由此也可晓得这部分很重要。上面我把外面的代码展现进去：
4.2 getProxyClass0 办法的内容
（这个是 getProxyClass0 办法上的正文）
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {SecurityManager sm = System.getSecurityManager();
if (sm != null) {
final int CALLER_FRAME = 3; // 0: Reflection, 1: getProxyClass0 2: Proxy 3: caller
final Class<?> caller = Reflection.getCallerClass(CALLER_FRAME);
final ClassLoader ccl = caller.getClassLoader();
checkProxyLoader(ccl, loader);
ReflectUtil.checkProxyPackageAccess(ccl, interfaces);
}
if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");
}
Class<?> proxyClass = null;
String[] interfaceNames = new String[interfaces.length];
// for detecting duplicates
Set<Class<?>> interfaceSet = new HashSet<>();
for (int i = 0; i < interfaces.length; i++) {String interfaceName = interfaces[i].getName();
Class<?> interfaceClass = null;
try {interfaceClass = Class.forName(interfaceName, false, loader);
} catch (ClassNotFoundException e) { }
if (interfaceClass != interfaces[i]) {
throw new IllegalArgumentException(interfaces[i] + "is not visible from class loader");
}
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(interfaceClass.getName() + "is not an interface");
}
if (interfaceSet.contains(interfaceClass)) {
throw new IllegalArgumentException("repeated interface:" + interfaceClass.getName());
}
interfaceSet.add(interfaceClass);
interfaceNames[i] = interfaceName;
}
List<String> key = Arrays.asList(interfaceNames);
/*
* Find or create the proxy class cache for the class loader.
*/
Map<List<String>, Object> cache;
synchronized (loaderToCache) {cache = loaderToCache.get(loader);
if (cache == null) {cache = new HashMap<>();
loaderToCache.put(loader, cache);
}
}
synchronized (cache) {
do {Object value = cache.get(key);
if (value instanceof Reference) {proxyClass = (Class<?>) ((Reference) value).get();}
if (proxyClass != null) {
// proxy class already generated: return it
return proxyClass;
} else if (value == pendingGenerationMarker) {
// proxy class being generated: wait for it
try {cache.wait();
} catch (InterruptedException e) { }
continue;
} else {cache.put(key, pendingGenerationMarker);
break;
}
} while (true);
}
try {
String proxyPkg = null; // package to define proxy class in
for (int i = 0; i < interfaces.length; i++) {int flags = interfaces[i].getModifiers();
if (!Modifier.isPublic(flags)) {String name = interfaces[i].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 + ".";
}
{
long num;
synchronized (nextUniqueNumberLock) {num = nextUniqueNumber++;}
String proxyName = proxyPkg + proxyClassNamePrefix + num;
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
try {
proxyClass = defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {throw new IllegalArgumentException(e.toString());
}
}
// add to set of all generated proxy classes, for isProxyClass
proxyClasses.put(proxyClass, null);
} finally {synchronized (cache) {if (proxyClass != null) {cache.put(key, new WeakReference<Class<?>>(proxyClass));
} else {cache.remove(key);
}
cache.notifyAll();}
}
return proxyClass;
}
上面剖析这段代码：
这部代码的意义
4.2.1. 如果类实现的接口超过 65535，间接抛出“interface limit exceeded”的异样，这部分应该是为了性能，个别状况下 咱们的实现的接口 大多在 200 个以下，这部分能够疏忽
4.2.2 类的所有接口实例化，并放入汇合中 , 而后查找或创立类加载器的代理类缓存(loaderToCache 就是寄存类加载器的缓存，key 为类加载器，value 为 Map<List<String>,Object>, 该 map 的 key 则为 类实现的接口汇合)，前面是设置代理类的包名 如果有 non-public 的接口[即接口包名应用这个类的包名，否则默认包名是 com.sun.proxy, 类名通常是类名前缀 +num，类名前缀为 $Proxy, 这部分前面会提到], 最终返回的是生成代理类[留神主动生成代理类名]，前面凭借“这个类名”能够调用办法
4.2.3 类的所有接口实例化
Class <?> interfaceClass = Class.forName(interfaceName, false, loader);4.2.4 类所有实现的接口 放入汇合中，这个局部前面
List<String> key = Arrays.asList(interfaceNames);4.2.5 查找或创立类加载器的代理类缓存。
Map<List<String>, Object> cache;
synchronized (loaderToCache) {cache = loaderToCache.get(loader);
if (cache == null) {cache = new HashMap<>();
loaderToCache.put(loader, cache);
}
/*
* This mapping will remain valid for the duration of this
* method, without further synchronization, because the mapping
* will only be removed if the class loader becomes unreachable.
*/
}4.2.6 这部分是记录 以后创立代理的个数，避免生成的代理类的”类名”反复
long num;
synchronized (nextUniqueNumberLock) {num = nextUniqueNumber++;}
String proxyName = proxyPkg + proxyClassNamePrefix + num;4.2.7 其中这一块就是创立 代理类的 字节码，defineClass0 是通过类加载器、代理类名、字节码生成代理类。
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);【这块调用的 c 语言的本地办法】
ps: 在很多文章外面都用了 ProxyGenerator.generateProxyClass 的办法，而后用文件输入流把字节码内容写入文件外面，看到这里预计你应该晓得为什么会如此写了吧。
上面简略看下 输入的内容
该类所有的办法都被“反射”创立了，理论调用时就是调用这个针对的办法。
看到最初，咱们能够晓得一个反射 无非把 本身的“所有办法”赋予了另一个“凭空产生的”对象，让他应用本人的“权力”而已。
本文来源于：程序员 ken，专属平台有 csdn、思否(SegmentFault)、简书、开源中国(oschina)、掘金，转载请注明出处。