社区微信群开通啦，扫一扫抢先加入社区官方微信群
社区微信群
代理模式是常用的Java设计模式，其主要作用是为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不想或者不能直接引用另一个对象，而代理对象可以在调用对象和被调用对象起到中介的作用，代理模式的思想是为了提供额外的处理或者不同的操作。
代理模式中，基本上有Subject角色，RealSubject角色，Proxy角色。其中：Subject角色负责定义RealSubject和Proxy角色应该实现的接口；RealSubject角色用来完成业务服务功能；Proxy角色负责调用RealSubject对应的方法完成业务功能。
按照代理的创建时期，代理可以分为两种：
<span style="font-size:14px;">public interface Count {
public void count();
}</span>
<span style="font-size:14px;">public class CountImpl implements Count{
@Override
public void count() {
System.out.println("计算当前账户余额。。。。");
}
}</span><span style="font-size:14px;">/**
* <pre>
* 项目名： java-proxy-statics
* 类名： CountProxy.java
* 类描述： 静态代理实现：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了
* 备注： 每个代理类只能为一个接口服务，这样就会导致代理类太多，代理类和实际类除了类名不一致，其他的都一致，重复代码太多，过于臃肿
* 创建日期：2015-6-26
* 创建时间：上午9:21:00
* </pre>
*/
public class CountProxy implements Count{
private Count count;
public CountProxy(Count count){
this.count = count;
}
@Override
public void count() {
System.out.println("开启事务。。。。");
count.count();
System.out.println("结束事务。。。。");
}
}</span><span style="font-size:14px;">public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException </span><span style="font-size:14px;"> public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;</span>
<span style="font-size:14px;">public interface Count {
public void count();
}</span><span style="font-size:14px;">public interface Money {
public void update();
}</span><span style="font-size:14px;">public class CountImpl implements Count, Money{
@Override
public void count(){
System.out.println("计算账户余额。。。");
}
@Override
public void update() {
System.out.println("更新账户余额。。。");
}
}</span><span style="font-size:14px;">public class MyInvocationHandler implements InvocationHandler{
private Object target;
public MyInvocationHandler(Object target){
this.target = target;
}
/**
* @param proxy：代理类的实例
* @param method：要调用的被代理类的方法
* @param args：被调用方法的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("开始记录日志。。。");
//反射调用目标对象的方法
method.invoke(target, args);
System.out.println("结束记录日志。。。");
return null;
}
}</span><span style="font-size:14px;">public class ProxyFactory {
public static Object getProxy(Object object){
MyInvocationHandler invocationHandler = new MyInvocationHandler(object);
return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), invocationHandler);
}
}</span><span style="font-size:14px;">public class CountProxyTest {
public static void main(String[] args) {
Count count = new CountImpl();
Count proxy = (Count) ProxyFactory.getProxy(count);
proxy.count();
}
}</span>开始记录日志。。。
计算账户余额。。。
结束记录日志。。。<span style="font-size:14px;">/**
* loader:类加载器
* interfaces:目标对象实现的接口
* h:InvocationHandler的实现类
*/
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 = getProxyClass(loader, interfaces);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
// 调用代理对象的构造方法（也就是$Proxy0(InvocationHandler h)）
Constructor cons = cl.getConstructor(constructorParams);
// 生成代理类的实例并把MyInvocationHandler的实例传给它的构造方法
return (Object) cons.newInstance(new Object[] { h });
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
} catch (IllegalAccessException e) {
throw new InternalError(e.toString());
} catch (InstantiationException e) {
throw new InternalError(e.toString());
} catch (InvocationTargetException e) {
throw new InternalError(e.toString());
}
} </span><span style="font-size:14px;">public static Class<?> getProxyClass(ClassLoader loader,
Class<?>... interfaces)
throws IllegalArgumentException
{
// 如果目标类实现的接口数大于65535个则抛出异常
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 声明代理对象所代表的Class对象（有点拗口）
Class proxyClass = null;
String[] interfaceNames = new String[interfaces.length];
Set interfaceSet = new HashSet(); // for detecting duplicates
// 遍历目标类所实现的接口
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");
}
// 中间省略了一些无关紧要的代码 .......
// 把目标类实现的接口代表的Class对象放到Set中
interfaceSet.add(interfaceClass);
interfaceNames[i] = interfaceName;
}
// 把目标类实现的接口名称作为缓存（Map）中的key
Object key = Arrays.asList(interfaceNames);
Map cache;
synchronized (loaderToCache) {
// 从缓存中获取cache
cache = (Map) loaderToCache.get(loader);
if (cache == null) {
// 如果获取不到，则新建地个HashMap实例
cache = new HashMap();
// 把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) {
// 如果代理对象的Class实例已经存在，则直接返回
return proxyClass;
} else if (value == pendingGenerationMarker) {
try {
cache.wait();
} catch (InterruptedException e) {
}
continue;
} else {
cache.put(key, pendingGenerationMarker);
break;
}
} while (true);
}
try {
// 中间省略了一些代码 .......
// 这里就是动态生成代理对象的最关键的地方
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);
}
// 中间省略了一些代码 .......
return proxyClass;
} </span><span style="font-size:14px;">public static byte[] generateProxyClass(final String name,
Class[] interfaces)
{
ProxyGenerator gen = new ProxyGenerator(name, interfaces);
// 这里动态生成代理类的字节码
final byte[] classFile = gen.generateClassFile();
// 如果saveGeneratedFiles的值为true，则会把所生成的代理类的字节码保存到硬盘上
if (saveGeneratedFiles) {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
try {
FileOutputStream file =
new FileOutputStream(dotToSlash(name) + ".class");
file.write(classFile);
file.close();
return null;
} catch (IOException e) {
throw new InternalError(
"I/O exception saving generated file: " + e);
}
}
});
}
// 返回代理类的字节码
return classFile;
} </span><span style="font-size:14px;">public class ProxyGeneratorUtils {
/**
* 把代理类的字节码写到硬盘上
* @param path 保存路径
*/
public static void writeProxyClassToHardDisk(String path) {
// 第一种方法，这种方式在刚才分析ProxyGenerator时已经知道了
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", true);
// 第二种方法
// 获取代理类的字节码
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy11", CountImpl.class.getInterfaces());
FileOutputStream out = null;
try {
out = new FileOutputStream(path);
out.write(classFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void test(){
writeProxyClassToHardDisk("D:/proxy/$Proxy11.class");
}
}</span><span style="font-size:14px;">/**
* 代理类实现了与目标类Count相同的接口，并继承了Proxy
*
*/
public final class $Proxy11 extends Proxy implements Count, Money {
private static Method m1;
private static Method m3;
private static Method m0;
private static Method m4;
private static Method m2;
/**
* 代理类的构造方法需要一个InvocationHanlder作为参数
*
* @param paramInvocationHandler
*/
public $Proxy11(InvocationHandler paramInvocationHandler) {
super(paramInvocationHandler);
}
/**
* 实现了目标类Count的equals方法
*/
public final boolean equals(Object paramObject) {
try {
// 实际上是通过调用InvaocationHandler.invoke(proxy, equals, args)来调用目标类Count的equals方法
return ((Boolean) this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
/**
* 实现了目标类Count的count方法
*/
public final void count() {
try {
// 实际上是通过调用InvaocationHandler.invoke(this, count, args)来调用目标类Count的count方法
this.h.invoke(this, m3, null);
return;
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
/**
* 实现了目标类Count的hashCode方法
*/
public final int hashCode() {
try {
// 实际上是通过调用InvaocationHandler.invoke(this, hashCode, args)来调用目标类Count的count方法
return ((Integer) this.h.invoke(this, m0, null)).intValue();
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
/**
* 实现了目标类Count的update方法
*/
public final void update() {
try {
// 实际上是通过调用InvaocationHandler.invoke(this, update, args)来调用目标类Count的count方法
this.h.invoke(this, m4, null);
return;
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
/**
* 实现了目标类Count的toString方法
*/
public final String toString() {
try {
// 实际上是通过调用InvaocationHandler.invoke(this, toString, args)来调用目标类Count的count方法
return (String) this.h.invoke(this, m2, null);
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
/**
* 代理类需要代理目标类的方法，包括父类，接口，目标类自己的所有公共方法
*/
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m3 = Class.forName("cn.test.proxy.Count").getMethod("count", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m4 = Class.forName("cn.test.proxy.Money").getMethod("update", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
return;
} catch (NoSuchMethodException localNoSuchMethodException) {
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
} catch (ClassNotFoundException localClassNotFoundException) {
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
}</span>
<span style="font-size:14px;">public class CountImpl {
public void count(){
System.out.println("计算账户余额。。。");
}
}</span>
<span style="font-size:14px;">public class MyMethodIntercaptor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("开始记录日志。。。");
proxy.invokeSuper(obj, args);
System.out.println("结束记录日志。。。");
return null;
}
}</span><span style="font-size:14px;">public class ProxyFactory {
public static Object getProxy(Object target){
MethodInterceptor methodInterceptor = new MyMethodIntercaptor();
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(methodInterceptor);
return enhancer.create();
}
}</span><span style="font-size:14px;">public class CountProxyTest {
public static void main(String[] args){
CountImpl countImpl = new CountImpl();
CountImpl countProxy = (CountImpl) ProxyFactory.getProxy(countImpl);
countProxy.count();
}
}</span><span style="font-size:14px;">开始记录日志。。。
计算账户余额。。。
结束记录日志。。。</span>
<span style="font-size:14px;">public interface Count {
public void count();
public void sayHello();
}</span><span style="font-size:14px;">public class CountImpl implements Count{
@Override
public void count() {
System.out.println("计算账户余额。。。");
}
@Override
public void sayHello(){
System.out.println("你好。。。。");
}
}</span><span style="font-size:14px;">public interface Interceptor {
public int intercept(Object proxy, Method method, Object[] Args);
}</span><span style="font-size:14px;">/**
* 基于Javassist动态生成字节码实现简单的动态代理
**/
public class Proxy {
/**
* 动态生成的代理类名前缀
* */
private static final String PACKAGE_NAME = Proxy.class.getPackage().getName();
/**
* 代理类名索引 用于标示一个唯一的代理类（具体的代理类名为PACKAGE_NAME$n）
* class
* */
private static final AtomicLong PROXY_CLASS_COUNTER = new AtomicLong(0);
/**
* 代理拦截器(利用继承减少动态构造的字节码)
* */
protected Interceptor interceptor;
protected Proxy(Interceptor interceptor) {
this.interceptor = interceptor;
}
/**
* 创建动态代理的工厂方法 static factory method for create proxy
*
* @param targetClass：被代理的类型
* @param interceptor：拦截器实例
* @return 返回动态代理实例 它实现了targerClass的所有接口。 因此可以向上转型为这些之中的任意接口
* */
@SuppressWarnings("unchecked")
public static Object createProxy(Class<?> targetClass, Interceptor interceptor) {
int index = 0;
/* 获得运行时类的上下文 */
ClassPool pool = ClassPool.getDefault();
/* 动态创建代理类 */
CtClass ctClass = pool.makeClass(PACKAGE_NAME + ".$proxy" + PROXY_CLASS_COUNTER.getAndIncrement());
try {
/* 获得Proxy类作为代理类的父类 */
CtClass superclass = pool.get(Proxy.class.getName());
ctClass.setSuperclass(superclass);
/* 获得被代理类的所有接口 */
CtClass[] interfaces = pool.get(targetClass.getName()).getInterfaces();
for (CtClass i : interfaces) {
/* 动态代理实现这些接口 */
ctClass.addInterface(i);
/* 获得结构中的所有方法 */
CtMethod[] methods = i.getDeclaredMethods();
for (int n = 0; n < methods.length; n++) {
CtMethod m = methods[n];
/* 构造这些Method参数 以便传递给拦截器的interceptor方法 */
StringBuilder fields = new StringBuilder();
fields.append("private static java.lang.reflect.Method method"+ index);
fields.append("=Class.forName("");
fields.append(i.getName());
fields.append("").getDeclaredMethods()[");
fields.append(n);
fields.append("];");
/* 动态编译之 */
CtField cf = CtField.make(fields.toString(), ctClass);
ctClass.addField(cf);
GenerateMethods(pool, ctClass, m, index);
index++;
}
}
/* 创建构造方法以便注入拦截器 */
CtConstructor cc = new CtConstructor(new CtClass[] { pool.get(Interceptor.class.getName()) }, ctClass);
cc.setBody("{super($1);}");
ctClass.addConstructor(cc);
ctClass.writeFile("d:/proxy/"+ctClass.getSimpleName());
return ctClass.toClass().getConstructor(Interceptor.class).newInstance(interceptor);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 动态生成生成方法实现（内部调用）
* */
private static void GenerateMethods(ClassPool pool, CtClass proxy,
CtMethod method, int index) {
try {
CtMethod cm = new CtMethod(method.getReturnType(),method.getName(), method.getParameterTypes(), proxy);
/* 构造方法体 */
StringBuilder mbody = new StringBuilder();
mbody.append("{super.interceptor.intercept(this,method");
mbody.append(index);
mbody.append(",$args);}");
cm.setBody(mbody.toString());
proxy.addMethod(cm);
} catch (CannotCompileException e) {
e.printStackTrace();
} catch (NotFoundException e) {
e.printStackTrace();
}
}
}</span><span style="font-size:14px;">public class CountProxyTest {
public static void main(String[] args) {
Count count = new CountImpl();
Count countProxy = (Count) Proxy.createProxy(count.getClass(), new MyInterceptor(count));
countProxy.count();
countProxy.sayHello();
}
}</span><span style="font-size:14px;">开始记录日志。。。。
计算账户余额。。。
结束记录日志。。。。
开始记录日志。。。。
你好。。。。
结束记录日志。。。。</span>
<span style="font-size:14px;">public class $proxy0 extends Proxy implements Count
{
private static Method method0 = java.lang.Class.forName("cn.test.proxy.Count").getDeclaredMethods()[0];
private static Method method1 = java.lang.Class.forName("cn.test.proxy.Count").getDeclaredMethods()[1];
public void count()
{
this.interceptor.intercept(this, method0, new Object[0]);
}
public void sayHello()
{
this.interceptor.intercept(this, method1, new Object[0]);
}
public $proxy0(Interceptor paramInterceptor)
{
super(paramInterceptor);
}
}</span>
如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！
