Android進階必學：自定義註解之動態代理
阿新 • • 發佈：2019-01-28
自定義註解是Android進階的必學知識，從現在起我講為大家帶來四篇文章，讓大家徹底學會自定義註解
靜態代理大家都明白，就是相當於包裝了一次，在包裝這一次的時候可以加一些業務邏輯。同樣靜態代理的特點是一個介面對應一個代理類，當然委託類可以多個。
靜態代理
/**
* 定義Demo介面
*/
public interface Demo {
public void save();
}/**
* DemoImpl實現Demo介面並覆寫save()方法
* 真實主題，執行具體業務
*/
public class DemoImpl implements /**
* DemoImplProxy 也實現了Demo介面，並覆寫了save()方法，增加了自己的業務
* 代理主題，負責其他業務的處理
*/
public class DemoImplProxy implements Demo {
Demo demoImpl = new DemoImpl();
public void save() {
System.out.println("開始記錄日誌" 靜態代理的特點就是：一個蘿蔔一個坑，但是這樣會產生大量的代理類
動態代理
動態代理的特點
動態代理是指在執行時動態生成代理類。即，代理類的位元組碼將在執行時生成並載入當前代理的 ClassLoader。
與靜態處理類相比，動態類有諸多好處。
- 首先，不需要為真實主題寫一個形式上完全一樣的封裝類，假如主題介面中的方法很多，為每一個介面寫一個代理方法也很麻煩。如果介面有變動，則真實主題和代理類都要修改，不利於系統維護；
- 其次，使用一些動態代理的生成方法甚至可以在執行時制定代理類的執行邏輯，從而大大提升系統的靈活性。
實現步驟
- 新建代理類和委託類共同的介面以及委託類
- 實現InvocationHandler介面，這是負責連線代理類和委託類的中間類必須實現的介面
- 通過Proxy類新建代理類物件第一步新建代理類和委託類共同的介面以及委託類
public interface IOperate {
public void operateMethod1();
public void operateMethod2();
public void operateMethod3();
}public class OperateImpl implements IOperate {
@Override
public void operateMethod1() {
System.out.println("Invoke operateMethod1");
}
@Override
public void operateMethod2() {
System.out.println("Invoke operateMethod2");
}
@Override
public void operateMethod3() {
System.out.println("Invoke operateMethod3");
}
}第二步：實現InvocationHandler介面
這一步提供了代理類應該怎麼進行處理，重點在於處理
定義
/**
* Object proxy:被代理的物件
* Method method:要呼叫的方法
* Object[] args:方法呼叫時所需要引數
*/
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}實現
public class InvocationHandlerImpl implements java.lang.reflect.InvocationHandler {
private Object target;
public InvocationHandlerImpl(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long start = System.currentTimeMillis();
Object obj = method.invoke(target, args);
System.out.println(method.getName() + " cost time is:" + (System.currentTimeMillis() - start));
return obj;
}
}
第三步：通過Proxy類新建代理類物件
介面
/**
*CLassLoader loader:類的載入器
*Class<?> interfaces:得到全部的介面
*InvocationHandler h:得到InvocationHandler介面的子類的例項
*/
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException 實現
public class ExampleTest {
@Test
public void testDumpClassInfo() throws Exception {
InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(new OperateImpl());
IOperate iOperate = (IOperate) Proxy.newProxyInstance(IOperate.class.getClassLoader(),new Class[] {IOperate.class},invocationHandler);
iOperate.operateMethod1();
iOperate.operateMethod2();
iOperate.operateMethod3();
}
}總結動態代理的使用
- 包裝需要被代理類的實現
InvocationHandler handler = new InvocationHandlerImpl(..);
- 通過Proxy類生成代理類
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 原理
Proxy.newProxyInstance(...)
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler invocationHandler) throws IllegalArgumentException {
if (invocationHandler == null) {
throw new NullPointerException("invocationHandler == null");
}
Exception cause;
try {
return getProxyClass(loader, interfaces)//得到代理的Class物件
.getConstructor(InvocationHandler.class)//最終呼叫Class.getDeclaredConstructorInternal()
.newInstance(invocationHandler);//生成例項物件並返回
} catch (Exception e) {
cause = e;
}
AssertionError error = new AssertionError();
error.initCause(cause);
throw error;
}傳遞進來的是：
- 類載入器
- 委託類實現的所有介面
public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException {
if (loader == null) {
loader = ClassLoader.getSystemClassLoader();
}
...
//給委託類實現的介面排序新增到interfaceList中
final List<Class<?>> interfaceList = new ArrayList<Class<?>>(interfaces.length);
Collections.addAll(interfaceList, interfaces);
//去重
final Set<Class<?>> interfaceSet = new HashSet<Class<?>>(interfaceList);
if (interfaceSet.contains(null)) {
throw new NullPointerException("interface list contains null: " + interfaceList);
}
//有重複則丟擲異常
if (interfaceSet.size() != interfaces.length) {
throw new IllegalArgumentException("duplicate interface in list: " + interfaceList);
}
//如果在類載入器中有這些代理快取，則直接返回，注意的是多個介面對應一個類
synchronized (loader.proxyCache) {
Class<?> proxy = loader.proxyCache.get(interfaceList);
if (proxy != null) {
return proxy;
}
}
String commonPackageName = null;
//拿到每一個介面Class物件
for (Class<?> c : interfaces) {
...
if (!Modifier.isPublic(c.getModifiers())) {
String packageName = c.getPackageName$();
if (packageName == null) {
packageName = "";
}
//這些介面必須在同一個包下
if (commonPackageName != null && !commonPackageName.equals(packageName)) {
throw new IllegalArgumentException(
"non-public interfaces must be in the same package");
}
commonPackageName = packageName;
}
}
//得到介面的Methods集合
List<Method> methods = getMethods(interfaces);
Collections.sort(methods, ORDER_BY_SIGNATURE_AND_SUBTYPE);
validateReturnTypes(methods);
List<Class<?>[]> exceptions = deduplicateAndGetExceptions(methods);
Method[] methodsArray = methods.toArray(new Method[methods.size()]);
Class<?>[][] exceptionsArray = exceptions.toArray(new Class<?>[exceptions.size()][]);
String baseName = commonPackageName != null && !commonPackageName.isEmpty()
? commonPackageName + ".$Proxy"
: "$Proxy";
Class<?> result;
synchronized (loader.proxyCache) {
result = loader.proxyCache.get(interfaceList);
if (result == null) {
String name = baseName + nextClassNameIndex++;
//得到代理物件
result = generateProxy(name, interfaces, loader, methodsArray, exceptionsArray);
loader.proxyCache.put(interfaceList, result);//新增到快取
}
}
return result;
}