动态代理是Java语言中的一个重要特性，在Android开发中有着广泛的应用。通过动态代理，我们可以在不修改原始代码的情况下，为对象添加额外的功能或行为。以下是Android中动态代理的几个主要使用场景：
1. 网络请求框架 - Retrofit
Retrofit是Android开发中最流行的网络请求框架之一，其核心就是利用动态代理机制实现的。
public interface ApiService {
@GET("users/{user}")
Call<User> getUser(@Path("user") String userId);
}
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.example.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();
ApiService service = retrofit.create(ApiService.class);
|
Retrofit通过动态代理自动实现接口中定义的网络请求方法，开发者只需定义接口并添加注解，而无需编写具体实现代码。在调用接口方法时，动态代理会拦截调用，生成对应的网络请求，并返回响应结果。腾讯云
2. AOP（面向切面编程）
在Android开发中，动态代理常用于实现AOP，可以在方法调用前后添加通用逻辑，如日志记录、性能监控、权限检查等。
public class PerformanceMonitorProxy implements InvocationHandler {
private Object target;
public PerformanceMonitorProxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long startTime = System.currentTimeMillis();
Object result = method.invoke(target, args);
long endTime = System.currentTimeMillis();
Log.d("Performance", method.getName() + " 执行耗时: " + (endTime - startTime) + "ms");
return result;
}
}
MyInterface original = new MyImplementation();
MyInterface proxied = (MyInterface) Proxy.newProxyInstance(
MyInterface.class.getClassLoader(),
new Class<?>[] { MyInterface.class },
new PerformanceMonitorProxy(original)
);
|
这种方式可以统一处理性能监控、日志记录等横切关注点，避免在每个方法中重复编写相同的代码。
3. 插件化开发中的Hook机制
在Android插件化开发中，通常需要Hook系统API来实现未注册Activity的启动等功能。动态代理是实现Hook的常用技术之一。
例如，Hook系统的ActivityManagerService来启动未在Manifest中注册的Activity：
public static void hookAMS() throws Exception {
Class<?> activityManagerClass;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
activityManagerClass = Class.forName("android.app.ActivityManager");
} else {
activityManagerClass = Class.forName("android.app.ActivityManagerNative");
}
Field gDefaultField = activityManagerClass.getDeclaredField("IActivityManagerSingleton");
gDefaultField.setAccessible(true);
Object gDefault = gDefaultField.get(null);
Class<?> singletonClass = Class.forName("android.util.Singleton");
Field mInstanceField = singletonClass.getDeclaredField("mInstance");
mInstanceField.setAccessible(true);
Object IActivityManagerObj = mInstanceField.get(gDefault);
Class<?> IActivityManagerClass = Class.forName("android.app.IActivityManager");
Object proxy = Proxy.newProxyInstance(
Thread.currentThread().getContextClassLoader(),
new Class<?>[] { IActivityManagerClass },
new AMSInvocationHandler(IActivityManagerObj)
);
mInstanceField.set(gDefault, proxy);
}
private static class AMSInvocationHandler implements InvocationHandler {
private Object mBase;
public AMSInvocationHandler(Object base) {
mBase = base;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("startActivity".equals(method.getName())) {
Intent intent = null;
int index = 0;
for (int i = 0; i < args.length; i++) {
if (args[i] instanceof Intent) {
index = i;
intent = (Intent) args[i];
break;
}
}
Intent newIntent = new Intent();
newIntent.setComponent(new ComponentName("com.example.app", "com.example.app.StubActivity"));
newIntent.putExtra("originalIntent", intent);
args[index] = newIntent;
}
return method.invoke(mBase, args);
}
}
|
这种技术在各大插件化框架如DroidPlugin、VirtualAPK等中被广泛使用。GitHub - DroidPluginTeam
4. 登录拦截和权限检查
在App中，某些功能需要用户登录或特定权限才能访问。使用动态代理可以统一处理这些检查逻辑：
public class LoginCheckProxy implements InvocationHandler {
private Object target;
private Context context;
public LoginCheckProxy(Object target, Context context) {
this.target = target;
this.context = context;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.isAnnotationPresent(RequiresLogin.class)) {
if (!UserManager.isLoggedIn()) {
context.startActivity(new Intent(context, LoginActivity.class));
return null;
}
}
return method.invoke(target, args);
}
}
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresLogin {}
|
使用这种方式，可以在接口方法上添加@RequiresLogin注解，当调用这些方法时，动态代理会自动检查用户登录状态，未登录时自动跳转到登录页面。
5. 事件处理和UI交互
在Android中，可以使用动态代理简化事件处理代码：
public class ClickHandlerProxy implements InvocationHandler {
private View.OnClickListener original;
public ClickHandlerProxy(View.OnClickListener original) {
this.original = original;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("onClick".equals(method.getName())) {
long currentTime = System.currentTimeMillis();
if (currentTime - lastClickTime < 500) {
return null;
}
lastClickTime = currentTime;
}
return method.invoke(original, args);
}
private static long lastClickTime = 0;
}
|
这种方式可以为所有点击事件添加防抖动处理，避免短时间内重复点击造成的问题。
6. 数据缓存和懒加载
使用动态代理可以实现数据的懒加载和缓存：
public class CacheProxy implements InvocationHandler {
private Object target;
private Map<String, Object> cache = new HashMap<>();
public CacheProxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getName().startsWith("get") && method.isAnnotationPresent(Cacheable.class)) {
String key = method.getName() + Arrays.toString(args);
if (!cache.containsKey(key)) {
Object result = method.invoke(target, args);
cache.put(key, result);
return result;
}
return cache.get(key);
}
return method.invoke(target, args);
}
}
@Retention(RetentionPolicy.RUNTIME)
public @interface Cacheable {}
|
通过这种方式，可以对标记了@Cacheable注解的getter方法自动启用缓存，提高应用性能。
总结
Android中动态代理的使用场景非常广泛，主要包括：
- 网络请求框架：如Retrofit，通过接口定义和动态代理简化网络请求代码
- AOP编程：实现横切关注点如日志、性能监控、权限检查等
- 插件化开发：通过Hook系统API实现插件化功能
- 登录拦截和权限检查：统一处理需要登录或特定权限的功能
- 事件处理和UI交互：简化事件处理代码，添加通用逻辑
- 数据缓存和懒加载：自动为方法添加缓存功能
动态代理的优势在于能够在不修改原始代码的情况下，为对象添加额外的功能，使代码更加模块化、可维护，同时减少重复代码。然而，动态代理也有一定的性能开销，不适合在对性能要求极高的场景中频繁使用。