本文介绍了Java代理模式的原理与应用，包括静态代理和动态代理。动态代理通过Proxy类和InvocationHandler接口实现，允许在运行时生成代理类，以增强原有业务逻辑。动态代理适用于需要对多个对象进行相同增强的情况，但效率相对较低，且仅能针对接口创建代理。
代理模式
代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。
举个例子来说明：张三想买某种用品，虽然他可以自己去找，但是这确实太浪费时间和精力了，或者不好意思去买。于是张三就通过中介Mark来买，Mark来帮张三，张三只是负责选择自己喜欢的的size，然后付钱就可以了。
目的：
（1）通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性； （2）通过代理对象对原有的业务增强；
代理模式一般会有三个角色：
抽象角色：指代理角色和真实角色对外提供的公共方法，一般为一个接口
真实角色：需要实现抽象角色接口，定义了真实角色所要实现的业务逻辑，以便供代理角色调用。也就是真正的业务逻辑在此。
代理角色：需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制都放到代理角色中处理！
而访问者不再访问真实角色，而是去访问代理角色。
静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。一般来说，被代理对象和代理对象是一对一的关系，当然一个代理对象对应多个被代理对象也是可以的。
静态代理
下面先简单示例一下静态代理模式的使用方法：
抽象角色（接口）：
public interface Person {
void saveMoney();
}
真实角色：
public class Student implements Person {
@Override
public void saveMoney() {
System.out.println("saveMoney: this is called!");
}
}
代理角色：
public class PeopleProxy implements Person {
private Person mPeople;
public PeopleProxy(Person person) {
this.mPeople = person;
}
@Override
public void saveMoney() {
before();
mPeople.saveMoney();
end();
}
private void before() {
//Log.d("TAG_123", "before: ");
System.out.println("before: ");
}
private void end() {
System.out.println("end: ");
//Log.d("TAG_123", "end: ");
}
}
示例调用代码如下：
//创建真实的对象
Student student = new Student();
//创建代理类，并将真实对象传入
PeopleProxy peopleProxy = new PeopleProxy(student);
//通过代理对象调用真实对象的逻辑实现
peopleProxy.saveMoney();
日志打印如下:
before:
saveMoney: this is called!
end:
动态代理
是指在使用的时候在生成代理类和代理类的实例。
优点：
- 只需要1个动态代理类就可以解决创建多个静态代理的问题，避免重复、多余代码
- 更强的灵活性
缺点
- 效率低，相比静态代理中 直接调用目标对象方法，动态代理则需要先通过Java反射机制 从而 间接调用目标对象方法。
- 应用场景局限，因为 Java 的单继承特性（每个代理类都继承了 Proxy 类），即只能针对接口 创建 代理类，不能针对类创建代理类。
在java的动态代理机制中，有两个重要的类或接口，一个是InvocationHandler接口、另一个则是 Proxy类，这个类和接口是实现我们动态代理所必须用到的。
InvocationHandler接口是给动态代理类实现的，负责处理被代理对象的操作的，而Proxy是用来创建动态代理类实例对象的，因为只有得到了这个对象我们才能调用那些需要代理的方法
简单使用方法如下：
接口类：
public interface IDynTest {
void buySomething();
}
实现类：
public class DynamicImpl implements IDynTest {
private static final String TAG = "DynamicImpl";
@Override
public void buySomething() {
Log.d(TAG, "buySomething: ");
}
}
自定义的InvocationHandler:
public class MyInvacationHandler implements InvocationHandler {
private static final String TAG = "MyInvacationHandler";
private Object impl;
public MyInvacationHandler(Object o){
this.impl = o;
}
public void setImpl(Object impl){
this.impl = impl;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Log.d(TAG, "before:"+method.getName());
Object o = method.invoke(impl,args);
Log.d(TAG, "end:"+method.getName());
return o;
}
}
示例调用方法：
//创建真实实现类
DynamicImpl dynamic = new DynamicImpl();
//创建动态代理类
IDynTest dynTest = (IDynTest)
Proxy.newProxyInstance(IDynTest.class.getClassLoader(),new Class<?>[]{IDynTest.class},new MyInvacationHandler(dynamic));
//通过动态代理类调用方法（在代理类里面做了简单处理，方法执行前后打印了before和end）
dynTest.buySomething();
打印结果如下：
10-15 10:14:52.045 25350-25350/com.test D/MyInvacationHandler: before:buySomething
10-15 10:14:52.045 25350-25350/com.test D/DynamicImpl: buySomething:
10-15 10:14:52.045 25350-25350/com.test D/MyInvacationHandler: end:buySomething
下面我们根据调用方法，分析动态代理的实现原理：
-
DynamicImpl dynamic = new DynamicImpl()创建被代理对象的实例，实际开发中我们可以通过读取配置文件或者其他方式获取；
-
IDynTest dynTest = (IDynTest) Proxy.newProxyInstance(IDynTest.class.getClassLoader(),new Class<?>[]{IDynTest.class},new MyInvacationHandler(dynamic)):创建代理类，我们看一下代理类是怎生成的？首先看一下Proxy.newProxyInstance方法，需要传入三个参数：
第一个参数Classloader:被代理类的ClassLoader，可以通过XXInterface.class.getClassLoader()获取。
第二个参数Class<?>[]:就是具体实现类实现的接口。
第三个参数：InvocationHandler:作为创建代理类传入的参数，当调用代理类的接口时，通过此对象反射调用。
我们看一下newProxyInstance是怎么生成代理类的?
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
//此处创建动态代理类的Class对象
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
// Android-removed: SecurityManager / permission checks.
/*
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
*/
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
// BEGIN Android-removed: Excluded AccessController.doPrivileged call.
/*
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
*/
cons.setAccessible(true);
// END Android-removed: Excluded AccessController.doPrivileged call.
}
//根据 生成的代理类的class对象，生成代理类的实例
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);
}
}
通过调用getProxyClass0(loader, intfs)获取代理类的Class对象，在通过cons.newInstance(new Object[]{h})获取代理类实例，我们写的java文件都会编译成class文件，然后编译成dex字节码才能正常运行，那么getProxyClass0(loader, intfs)是怎么根据我们传入的CLassLoader和接口类自动生成class对象的呢？
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
}
可以看到是从cache缓存里面获取的，如果还没有加载过，则会通过ProxyClassFactory创建（根据注释翻译）
private ProxyClassFactory() {
}
public Class<?> apply(ClassLoader var1, Class<?>[] var2) {
IdentityHashMap var3 = new IdentityHashMap(var2.length);
Class[] var4 = var2;
int var5 = var2.length;
for(int var6 = 0; var6 < var5; ++var6) {
Class var7 = var4[var6];
Class var8 = null;
try {
var8 = Class.forName(var7.getName(), false, var1);
} catch (ClassNotFoundException var15) {
}
if (var8 != var7) {
throw new IllegalArgumentException(var7 + " is not visible from class loader");
}
if (!var8.isInterface()) {
throw new IllegalArgumentException(var8.getName() + " is not an interface");
}
if (var3.put(var8, Boolean.TRUE) != null) {
throw new IllegalArgumentException("repeated interface: " + var8.getName());
}
}
String var16 = null;
byte var17 = 17;
Class[] var18 = var2;
int var20 = var2.length;
for(int var21 = 0; var21 < var20; ++var21) {
Class var9 = var18[var21];
int var10 = var9.getModifiers();
if (!Modifier.isPublic(var10)) {
var17 = 16;
String var11 = var9.getName();
int var12 = var11.lastIndexOf(46);
String var13 = var12 == -1 ? "" : var11.substring(0, var12 + 1);
if (var16 == null) {
var16 = var13;
} else if (!var13.equals(var16)) {
throw new IllegalArgumentException("non-public interfaces from different packages");
}
}
}
if (var16 == null) {
var16 = "com.sun.proxy.";
}
long var19 = nextUniqueNumber.getAndIncrement();
//生成代理类的类名命名规则
String var23 = var16 + "$Proxy" + var19;
//此处生成byte数组
byte[] var22 = ProxyGenerator.generateProxyClass(var23, var2, var17);
try {
//根据生成的byte数组创建Class对象
return Proxy.defineClass0(var1, var23, var22, 0, var22.length);
} catch (ClassFormatError var14) {
throw new IllegalArgumentException(var14.toString());
}
}
}
从上面的代码主要关注两处，一处是生成代理类的二进制数据：byte[] var22 = ProxyGenerator.generateProxyClass(var23, var2, var17)；第二处是根据生成的二进制字节码生成对应的Class对象：Proxy.defineClass0(var1, var23, var22, 0, var22.length)；defineClass0方法是native方法，我们不去深究，只要知道是系统底层帮助我们做好了，那生成的代理类是怎样的呢，可以通过如下代码将生成的代理类保存成文件，然后再使用javap -v -p xxx.class，反编译后看源码：
读取字节码的测试代码如下：
byte[] classFile = new byte[0];
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
classFile = ProxyGenerator.generateProxyClass("$Proxy0", DynamicImpl.class.getInterfaces());
}
String path = "/sdcard/student.class";
try(FileOutputStream fos = new FileOutputStream(path)) {
fos.write(classFile);
fos.flush();
Log.e("TAG_123", "onClick: 代理类class文件写入成功");
} catch (Exception e) {
Log.e("TAG_123", "onClick: 写文件错误:"+e.toString());
}
将读取后的字节码反编译后的源码如下：
public final class $Proxy0 extends Proxy implements IDynTest {
private static Method m1;
private static Method m2;
private static Method m3;
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});
} 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 buySomething() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.iflytek.phonetest.dynamicproxy.IDynTest").getMethod("buySomething");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
当我们代理类低昂用接口：
dynTest.buySomething()
的时候，就会调用上面生成代理类的buySomething()接口，buySomething()的实现如下：
public final void buySomething() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
会调用super.h.invoke(this, m3, (Object[])null);那h和m3分别是什么呢？我们生成的动态代理类是继承Proxy的，上面在创建代理类的时候将InvocationHandler传入了：
return cons.newInstance(new Object[]{h});
所以此处的h就是我们调用Proxy.newProxyInstance传入的InvocationHandler；
那么m3呢？看下上面生成的代理类，有如下一段代码：
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.iflytek.phonetest.dynamicproxy.IDynTest").getMethod("buySomething");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
可以看到最终会调用我们自定义的MyInvacationHandler的invoke方法，然后通过反射调用实际的实现逻辑，以上就是java 动态代理模式的使用和原理分析。
总结
- 代理分为静态代理和动态代理两种。
- 静态代理，代理类需要自己编写代码写成。
- 动态代理，代理类通过 Proxy.newInstance() 方法生成。
- 不管是静态代理还是动态代理，代理与被代理者都要实现两样接口，它们的实质是面向接口编程。
- 静态代理和动态代理的区别是在于要不要开发者自己定义 Proxy 类。
- 动态代理通过 Proxy 动态生成 proxy class，但是它也指定了一个 InvocationHandler 的实现类。
- 代理模式本质上的目的是为了增强现有代码的功能。
扫一扫
6524
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
