java代理
1.代理模式基本概念
目的：为其他对象提供一种代理以控制对这个对象的访问。
使用场景：
- 远程代理：远程对象的本地代表。
- 远程对象：活在不同的java虚拟机堆中，在不同的地址空间运行的对象
- 本地代表：可以由本地方法调用的对象，其行为会转发到远程对象中
- 虚拟代理：代理创建开销很大的对象，只有在真正需要该对象时才创建
- 保护代理：根据不同的访问权限，使原始对象产生不同的行为。
- 智能引用：访问对象时执行一些附加操作。
- 对原始对象的引用计数
代理模式类图：
- Subject：ReadlSubject和ProxySubject的共用接口，在任何使用RealSubject的地方都可以使用ProxySubject
- RealSubject：被代理的真实类
- ProxySubject：代理类
- 保存一个引用使得代理可以访问实体，使用共同的接口Subject引用
- 实现与被代理类的相同接口，根据实际场景完成代理逻辑
代理模式带来的好处：
- 远程代理：隐藏一个对象存在于不同地址空间的事实。
- 虚拟代理: 优化性能，惰性加载
- 保护代理和智能引用代理：附加额外的业务处理功能。
- 写时复制：需要拷贝某个大对象时，只对实体进行引用计数。当对象被修改时，才进行拷贝，同时减少引用计数。
相关模式：
- Adapter：适配器为它所适配的对象提供了不同的接口。相反，代理提供了与实体相同的接口。保护代理可能会限制某些接口的访问，从而接口实际上只是实体接口的一个子集。
- Decorator：decorator的实现部分与代理相似，但两者有不同的目的，Decorator为对象添加额外的功能，而代理则控制对对象的访问。远程代理不包含对实体对象的直接引用，只是一个间接引用。虚拟代理开始使用一个间接引用，但最终将获取并使用一个直接引用。
2.几种实现方式
2.1 静态代理
/**
* 代理类和被代理类共同实现的接口
*/
public interface Subject {
void sayHello(String param);
void sayHi(String param);
}
/**
* 被代理类,真实的业务逻辑操作
*/
public class RealSubject implements Subject{
public void sayHello(String param) {
System.out.println(param + " say hello.");
}
public void sayHi(String param) {
System.out.println(param + " say Hi.");
}
}
/**
* 代理类,转发实际的业务请求到Subject子类,同时增强相对应的方法
*/
public class ProxySubject implements Subject {
private Subject subject;
public ProxySubject(Subject subject) {
this.subject = subject;
}
//可使用工厂模式封装,实现客户端和实际代理对象的解耦合
public static Subject newInstance() {
Subject subject = new ProxySubject(new RealSubject());
return subject;
}
public void sayHello(String param) {
System.out.println("TestProxy start...");
subject.sayHello(param);
System.out.println("TestProxy end...");
}
public void sayHi(String param) {
System.out.println("TestProxy start...");
subject.sayHi(param);
System.out.println("TestProxy end...");
}
}
/**
* 代理测试类，使用需要代理的Subject子类创建代理类，并调用
*/
public class TestProxy {
public static void main(String[] args) {
Subject subject = ProxySubject.newInstance();
subject.sayHello("long");
subject.sayHello("long");
}
}
输出结果：
TestProxy start...
long say hello.
TestProxy end...
TestProxy start...
long say hello.
TestProxy end...
- 优点：
- 客户端（TestProxy）针对接口编程，可用工厂模式去获取实例，与真实的对象解耦合
- 针对被代理的类，增加额外的操作（可用来实现AOP）
- 缺点：
- 代理类和被代理类需要实现相同的接口。
- 每个被代理的类都需要一个对应的代理类。
- 需要为共用接口中每一个方法提供代理实现，当接口比较多时，代码冗杂。
- 当需要代理的类比较多时，类的规模增加，难以维护。
2.2 动态代理
2.2.1 简单实现
静态代理在编译期就已经完成了代理类，当需要对多个类进行代理时，需要创建多个代理类，导致类规模变大，难以维护。动态代理生成代理类发生在程序运行期，针对同一种需求可使用同一个动态代理类，完成代理功能。
/**
* 代理类和被代理类共同实现的接口
*/
public interface Subject {
void sayHello(String param);
void sayHi(String param);
}
/**
* 被代理类,真实的业务逻辑操作
*/
public class RealSubject implements Subject{
public void sayHello(String param) {
System.out.println(param + " say hello.");
}
public void sayHi(String param) {
System.out.println(param + " say Hi.");
}
}
/**
* 动态代理helper类,可用增加一批相应的类
* real : 被代理类
*/
public class DynamicProxySubject implements InvocationHandler {
private Subject real;
public DynamicProxySubject(Subject real) {
this.real = real;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("TestDynamicProxy start...");
Object result = null;
// 由于Proxy会代理hashCode,equals,toString等方法
if (method.getDeclaringClass() != Object.class) {
result = method.invoke(real, args);
} else {
System.out.println(method.getDeclaringClass() + "." + method.getName());
}
System.out.println("TestDynamicProxy end...");
return result;
}
}
/**
* 动态代理测试类
*/
public class TestDynamicProxy {
public static void main(String[] args) {
//保存运行期生成的代理类
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
Subject proxyClass = newInstance();
proxyClass.sayHello("long");
proxyClass.sayHello("long");
proxyClass.toString();
}
//可单独抽出一个工厂类
public static Subject newInstance() {
Subject subject = new RealSubject();
DynamicProxySubject proxyHelper = new DynamicProxySubject(subject);
Subject proxy = (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(), proxyHelper);
return proxy;
}
}
输出结果：
TestDynamicProxy start...
long say hello.
TestDynamicProxy end...
TestDynamicProxy start...
long say hello.
TestDynamicProxy end...
TestDynamicProxy start...
class java.lang.Object.toString
TestDynamicProxy end...
- 优点
- 简单的实现InvocationHandler接口，使用Proxy即可生成代理类
- 完成一种类型的增强代理功能，优化了代理类和方法庞大的问题
- 缺点
- 被代理的类中的方法必须实现某个接口
- 不能针对继承类中的方法实现代理,除了equals,hashCode,toString等
- 需要实现指定的接口InvocationHandler
2.2.2 java动态代理解读
关系类图
保存动态生成的代理类源码及其ProxyGenerator源码
- 动态生成代理类字节码的类：sun.misc.ProxyGenerator，该类源码
- 保存生成的代理类字节码到本地磁盘
1. 测试类中增加如下一行代码：
//如执行后，在该项目中没有看到生成类，可使用debug模式执行
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
2. ProxyGenerator类保存生成的字节码的相关代码：
/** debugging flag for saving generated class files */
private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();
/**
* Generate a proxy class given a name and a list of proxy interfaces.
*/
public static byte[] generateProxyClass(final String name,
Class[] interfaces)
{
ProxyGenerator gen = new ProxyGenerator(name, interfaces);
final byte[] classFile = gen.generateClassFile();
if (saveGeneratedFiles) {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction() {
public Object 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;
}
由此可见，当设置sun.misc.ProxyGenerator.saveGeneratedFiles为true后，开启类执行保存byte[] classFile，使用FileOutputStream写到磁盘中。
解读生成的代理类源码
当执行第一步后，动态代理生成的源码类保存在工程根目录下com/sun/proxy,类名$Proxy0.class
由于生成的是.class，因此需要反编译，使用Idea自带自动解析.class文件，代码如下：
package com.sun.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxy.Subject;
public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m4;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
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 void sayHello(String var1) throws {
try {
super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
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);
}
}
public final void sayHi(String var1) throws {
try {
super.h.invoke(this, m4, new Object[]{var1});
} 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);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m3 = Class.forName("proxy.Subject").getMethod("sayHello", new Class[]{Class.forName("java.lang.String")});
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m4 = Class.forName("proxy.Subject").getMethod("sayHi", new Class[]{Class.forName("java.lang.String")});
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
- 首先$Proxy0继承自类Proxy,实现了需要代理的类相同的接口（Subject），符合代理类与被代理类实现相同的接口原则；由于动态生成的代码是针对实现的接口做代理，因此不支持对继承自类的方法做代理模式。
- 由 Proxy0.sayHello方法实现，调用委托给父类（Proxy）中InvocationHandlerh域，当使用Proxy.newProxyInstance(real.getClass().getClassLoader(),real.getClass().getInterfaces(),this)生成代理类时，把我们实现的代理类（DynamicProxy）传递给了Proxy类中的InvocationHandlerh域名，调用最终回调到我们实现的代理类( Proxy0)上
动态代理总结：
- 我们实现的代理类（DynamicProxySubject）需要实现InvocationHandler接口
- 需要增强的方法需要实现自定义的接口（Subject）
- 使用实际的类（RealSuject）构造我们的代理类（DynamicProxySubject）
- 使用Proxy类在运行期生成真实的代理类代码（$Proxy0）
- 动态代理类（$Proxy0）的类加载器与被代理类相同，实现的接口与被代理类相同。]
- 动态代理类可以实现AOP
2.3 cglib
使用第三方类库cglib可以实现对类的代理。cglib被用在很多常用框架中。
1. 导入cglib相关类库
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.0</version>
</dependency>
2. 需要被代理的类
public class SampleClass {
public void sayHello() {
System.out.println("SampleClass say hello for you");
}
}
3. cglib生成代理类。
/**
* 代理类, 使用被代理的对象创建,getProxy返回生成的被代理对象的子类
*/
public class CglibProxy {
private Object proxy;
public CglibProxy(final Object target) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("cglib start...");
Object result = method.invoke(target, args);
System.out.println("cglib end...");
return result;
}
});
proxy = enhancer.create();
}
public Object getProxy() {
return proxy;
}
}
4. 测试cglib代理功能类
public class CglibProxyTest {
public static void main(String[] args) {
SampleClass proxy = newSampleProxy();
proxy.sayHello();
}
public static SampleClass newSampleProxy() {
SampleClass sampleClass = new SampleClass();
SampleClass proxy = (SampleClass) new CglibProxy(sampleClass).getProxy();
return proxy;
}
}
由于cglib使用继承的方式，代理类是被代理类的子类，对被代理的类使用Callback的方式进行增强。因此，需要设置生成的代理类的父类，以及相应的callback，接着使用create创建代理类。不在需要实现相同的接口。
参考资料：
设计模式－可复用面向对象软件的基础
Head Frist 设计模式
Java RMI
Cglib Tutorial
8035
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
