Android代理模式基础，android性能优化和内存优化

rBo1koI8criHQ

于 2024-03-27 21:59:34 发布

阅读量560

点赞数 27

分类专栏： 2024年程序员学习文章标签： android 代理模式

本文链接：https://blog.csdn.net/rBo1koI8criHQ/article/details/137091108

版权

2024年程序员学习专栏收录该内容

243 篇文章 0 订阅

订阅专栏

文章探讨了Android中AIDL的静态代理实现，以及如何通过动态代理扩展接口。作者对比了两者在扩展性和灵活性上的差异，并展示了动态代理的典型用法和源码分析。

摘要由CSDN通过智能技术生成

@Override
public android.os.IBinder asBinder() {
return null;
}
}
/** Local-side IPC implementation stub class. /
public static abstract class Stub extends android.os.Binder implements com.bc.sample.IMyAidlInterface {
private static final java.lang.String DESCRIPTOR = “com.bc.sample.IMyAidlInterface”;
/* Construct the stub at attach it to the interface. /
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/*

Cast an IBinder object into an com.bc.sample.IMyAidlInterface interface,
generating a proxy if needed.
*/
public static com.bc.sample.IMyAidlInterface asInterface(android.os.IBinder obj) {
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.bc.sample.IMyAidlInterface))) {
return ((com.bc.sample.IMyAidlInterface)iin);
}
return new com.bc.sample.IMyAidlInterface.Stub.Proxy(obj);
}
@Override public android.os.IBinder asBinder() {
return this;
}
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
java.lang.String descriptor = DESCRIPTOR;
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(descriptor);
return true;
}
case TRANSACTION_testFun:
{
data.enforceInterface(descriptor);
this.testFun();
reply.writeNoException();
return true;
}
default:
{
return super.onTransact(code, data, reply, flags);
}
}
}

// 主要关注代理模式的实现;可以看到AIDL的Proxy是通过静态代理模式实现
private static class Proxy implements com.bc.sample.IMyAidlInterface {
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
@Override public android.os.IBinder asBinder() {
return mRemote;
}
public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}
@Override public void testFun() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
boolean _status = mRemote.transact(Stub.TRANSACTION_testFun, _data, _reply, 0);
if (!_status && getDefaultImpl() != null) {
getDefaultImpl().testFun();
return;
}
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
public static com.bc.sample.IMyAidlInterface sDefaultImpl;
}
static final int TRANSACTION_testFun = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
public static boolean setDefaultImpl(com.bc.sample.IMyAidlInterface impl) {
// Only one user of this interface can use this function
// at a time. This is a heuristic to detect if two different
// users in the same process use this function.
if (Stub.Proxy.sDefaultImpl != null) {
throw new IllegalStateException(“setDefaultImpl() called twice”);
}
if (impl != null) {
Stub.Proxy.sDefaultImpl = impl;
return true;
}
return false;
}
public static com.bc.sample.IMyAidlInterface getDefaultImpl() {
return Stub.Proxy.sDefaultImpl;
}
}
public void testFun() throws android.os.RemoteException;
}

三、动态代理

在2.1的静态代理代码中，如果现在需要扩展一个新的接口，那就需要分别在接口层、实际处理类、代理类中分别改动，如下所示：

// 1.首先定义接口层
interface ILogSender {
public void sendLog(String log);
}

// 2.定义实现类
public class MainLogSender implements ILogSender {

@Override
public void sendLog(String log) {
Log.d(“LogSender”, “MainLogSender send” + log);
}
}

// 3.定义代理类
public class LogSenderProxy implements ILogSender {
// 代理类持有被代理类的引用
private ILogSender mainLogSender = new MainLogSender();

@Override
public void sendLog(String log) {
// 代理类需要完成的一些额外处理
Log.d(“LogSender”, “ProxyLogSender” + log);
String finalLog = Thread.currentThread() + log;
mainLogSender.sendLog(finalLog);
}
}

当代理一个新的接口时可见，新的代理类与其他代理类代码是高度相似的，因此可以采用动态代理的方式来完成类似的功能。

3.1 基础用法

与静态代理不同，动态代理类的class是在运行过程中动态生成的。

3.1.1 基础用法

首先定义接口层：

// 定义接口层
interface ILogProcessor {
public void printLog(String log);
}

然后使用Proxy.newProxyInstance完成动态代理如下：

private void main() {
ILogProcessor proxy = (ILogProcessor) Proxy.newProxyInstance(this.getClassLoader(), new Class<?>[] {ILogPrinter.class}, new InvocationHandler() {

/**

@param proxy 代理对象
@param method 被调用的方法
@param args 被调用的方法的参数列表
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) {
String log = (String)args[0];
Log.d(“LogProcessor”, “ProxyLogProcessor” + log);
String finalLog = Thread.currentThread() + log;
Log.d(“LogProcessor”, “printLog” + finalLog);
return null;
}
});

proxy.printLog(“”);
}

其中，InvocationHandler就是将静态代理中需要实现的部分抽离了出来，即动态生成的Proxy代理了InvocationHandler。

3.1.2 动态生成的class

动态生成的代理类的方法实际调用都到了InvocationHandler的invoke方法，动态生成的代理类class伪代码如下：

public final class $Proxy0 extends Proxy implements ILogProcessor {
static {
m3 = Class.forName(“com.bc.sample.ILogProcessor”).getMethod(“printLog”);
}
private static Method m3;
public void printLog(String log) {
// 实际调用到了InvocationHandler的invoke方法
super.h.invoke(this, m3, (Object[])log);
}
}