[关闭]
@puke3615 2016-08-20T08:52:57.000000Z 字数 8517 阅读 1135

动态代理

一、 动态代理实现方式

Java中的动态代理给我们提供一种动态生成类的方式，有很好的灵活性，这种技术一般会出现在一些第三方框架中，来降低接入方的使用成本。以下为常用的实现动态代理的几种方式：

  1. JDK自带的Proxy方式

    ​优点：JDK亲儿子；无依赖；使用简单

    缺点：代理类必须继承至少一个接口；无法继承已有父类

  2. asm方式，基于class字节码的操作

    ​优点：很底层到操作，性能高，对性能要求苛刻的建议使用

    缺点：使用成本高，要熟悉JVM汇编指令

  3. javassist方式，基于class字节码的操作

    优点：Api简单，通熟易懂，使用成本低

    缺点：性能相对偏低

  4. cglib方式，这个是基于ASM的

    ​优点：Api简单；高性能；高灵活性；支持继承父类；可以不用实现接口

    缺点：这个真的很强大，个人感觉比JDK自带的要强大很多，一定要说的话只能说使用这个需要加jar包依赖

二、业务开发的尴尬

开门见山，我们直接来看一个业务场景：

  1. package com.puke.net;
  3. /**
  4.  * @author zijiao
  5.  * @version 16/8/19
  6.  */
  7. public class User {
  9.     public String username;
  10.     public String uId;
  11.     public String sex;
  12.     public String address;
  14.     @Override
  15.     public String toString() {
  16.         return "User{" +
  17.                 "username='" + username + '\'' +
  18.                 ", uId='" + uId + '\'' +
  19.                 ", sex='" + sex + '\'' +
  20.                 ", address='" + address + '\'' +
  21.                 '}';
  22.     }
  23. }

这里就是一个用户信息的Entity类，不解释了。

  1. package com.puke.net;
  3. import com.google.gson.Gson;
  5. import java.util.Map;
  7. /**
  8.  * @author zijiao
  9.  * @version 16/8/19
  10.  */
  11. public class VirtualHelper {
  13.     private static final Gson sGson = new Gson();
  15.     public static String request(String url, Map<String, Object> params) {
  16.         if (params != null) {
  17.             if ("123".equals(params.get("username"))
  18.                     && "456".equals(params.get("password"))) {
  19.                 User user = new User();
  20.                 user.address = "杭州";
  21.                 user.sex = "男";
  22.                 user.uId = "Id";
  23.                 user.username = "啊啊";
  24.                 return sGson.toJson(user);
  25.             }
  26.         }
  27.         return null;
  28.     }
  30. }

这里我们模拟一个简单的网络请求。

当我们业务场景需要调用网络请求执行登录操作的时候，会这样写：

  1. package com.puke.net;
  3. import com.google.gson.Gson;
  5. import java.util.HashMap;
  6. import java.util.Map;
  8. /**
  9.  * @author zijiao
  10.  * @version 16/8/19
  11.  */
  12. public class UserApi {
  14.     private static final String API_LOGIN = "http://***.***.***";
  15.     private static final Gson sGson = new Gson();
  17.     public static User login(String username, String password) {
  18.         Map<String, Object> params = new HashMap<>();
  19.         params.put("username", username);
  20.         params.put("password", password);
  21.         String response = VirtualHelper.request(API_LOGIN, params);
  22.         //注，这里只是为了举例说明一下，就假设此时的数据结构就是跟User一致的
  23.         return sGson.fromJson(response, User.class);
  24.     }
  26. }

那么，有什么问题呢。其实如果只是一个单单的login方法很难直观的反馈出来问题所在，很多时候我们为了去验证一个事物的合理性我们不妨去开始极端遐想一下这种情况：现在UserApi中又多了register方法，query方法，getToken方法，validate方法......甚至接下来一个UserApi已经满足不了我们了，我们开始有GoodsApi，OrderApi，MessageApi等等等等，试想一下N个Api的类，每个Api类都有N个类似于上面login的这种方法，而实际情况下我们request的入参还远远不止username，password两个这么简单。当我们业务场景扩大的时候，这些都是我们势必要面对的。这是一个问题，那能不能去以一种更优雅的方式去解决从而简化业务方的代码量并且降低使用成本呢。这里便引入了我们的动态代理~

三、 动态代理的方式去解决

我们的目标是状态是这样的：让业务方写写接口，加加注解配置，就可以直接使用

1. 先定义两个支持配置的注解
  1. package com.puke.net.proxy;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Inherited;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  9. /**
  10.  * @author zijiao
  11.  * @version 16/8/19
  12.  */
  13. @Inherited
  14. @Target({ElementType.METHOD, ElementType.TYPE})
  15. @Retention(RetentionPolicy.RUNTIME)
  16. public @interface URL {
  17.     String value();
  18. }
  1. package com.puke.net.proxy;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Inherited;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  9. /**
  10.  * @author zijiao
  11.  * @version 16/8/19
  12.  */
  13. @Inherited
  14. @Target(ElementType.PARAMETER)
  15. @Retention(RetentionPolicy.RUNTIME)
  16. @interface Param {
  17.     String value();
  18. }

这里不过多说明，就是两个可配字符串的注解。

2. 定义一套接口

这一步，其实不是必需的。我们完全可以在动态代理中直接显式的调用VirtualHelper类，但既然抽象出来网络Api这块，那就干脆定义一套接口出来来解耦具体实现。

  1. package com.puke.net.proxy;
  3. import java.util.Map;
  5. /**
  6.  * @author zijiao
  7.  * @version 16/8/19
  8.  */
  9. public interface IRequest {
  11.     String url();
  13.     Map<String, Object> params();
  15.     Class<?> responseCls();
  17. }
  1. package com.puke.net.proxy;
  3. import java.util.Map;
  5. /**
  6.  * @author zijiao
  7.  * @version 16/8/19
  8.  */
  9. public class Request implements IRequest {
  11.     String url;
  12.     Map<String, Object> params;
  13.     Class<?> responseCls;
  15.     public Request(String url, Map<String, Object> params, Class<?> responseCls) {
  16.         this.url = url;
  17.         this.params = params;
  18.         this.responseCls = responseCls;
  19.     }
  21.     @Override
  22.     public String url() {
  23.         return url;
  24.     }
  26.     @Override
  27.     public Map<String, Object> params() {
  28.         return params;
  29.     }
  31.     @Override
  32.     public Class<?> responseCls() {
  33.         return responseCls;
  34.     }
  36. }

这是请求接口和实现类，粗略写下，比较简单

  1. package com.puke.net.proxy;
  3. /**
  4.  * @author zijiao
  5.  * @version 16/8/19
  6.  */
  7. public interface INetExecutor {
  9.     <T> T execute(IRequest request);
  11. }
  1. package com.puke.net.proxy;
  3. import com.google.gson.Gson;
  4. import com.puke.net.VirtualHelper;
  6. /**
  7.  * @author zijiao
  8.  * @version 16/8/19
  9.  */
  10. @SuppressWarnings("unchecked")
  11. public class DefaultNetExecutor implements INetExecutor {
  13.     private static final Gson sGson = new Gson();
  15.     @Override
  16.     public <T> T execute(IRequest request) {
  17.         String response = VirtualHelper.request(request.url(), request.params());
  18.         return (T) sGson.fromJson(response, request.responseCls());
  19.     }
  21. }

这个是网络执行器已经默认的实现方式（使用上面的VirtualHelper），主要是抽象出接口可以让业务方自主定制真正的执行操作。

3. 动态代理器

这个就直接上代码了

  1. package com.puke.net.proxy;
  3. import android.text.TextUtils;
  5. import java.lang.annotation.Annotation;
  6. import java.lang.reflect.InvocationHandler;
  7. import java.lang.reflect.Method;
  8. import java.lang.reflect.Proxy;
  9. import java.util.HashMap;
  10. import java.util.Map;
  12. /**
  13.  * @author zijiao
  14.  * @version 16/8/19
  15.  */
  16. @SuppressWarnings("unchecked")
  17. public class ApiGenerator {
  19.     private static final Map<Class, Object> sApiCache = new HashMap<>();
  21.     private static INetExecutor sNetExecutor;
  23.     private static class Handler<T> implements InvocationHandler {
  25.         private Class<T> apiInterface;
  27.         public Handler(Class<T> apiInterface) {
  28.             this.apiInterface = apiInterface;
  29.         }
  31.         @Override
  32.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  33.             IRequest request = resolveRequest(method, args, apiInterface);
  34.             if (sNetExecutor == null) {
  35.                 sNetExecutor = defaultNetExecutor();
  36.             }
  37.             return sNetExecutor.execute(request);
  38.         }
  39.     }
  41.     private static <T> IRequest resolveRequest(Method method, Object[] args, Class<T> apiInterface) {
  42.         StringBuilder urlBuilder = new StringBuilder();
  43.         Map<String, Object> params = null;
  44.         if (apiInterface.isAnnotationPresent(URL.class)) {
  45.             String baseUrl = apiInterface.getAnnotation(URL.class).value();
  46.             if (!TextUtils.isEmpty(baseUrl)) {
  47.                 urlBuilder.append(baseUrl);
  48.             }
  49.         }
  50.         if (method.isAnnotationPresent(URL.class)) {
  51.             String subUrl = method.getAnnotation(URL.class).value();
  52.             if (!TextUtils.isEmpty(subUrl)) {
  53.                 urlBuilder.append(subUrl);
  54.             }
  55.         }
  56.         int index = 0;
  57.         for (Annotation[] annotations : method.getParameterAnnotations()) {
  58.             for (Annotation annotation : annotations) {
  59.                 if (annotation instanceof Param) {
  60.                     String key = ((Param) annotation).value();
  61.                     if (!TextUtils.isEmpty(key)) {
  62.                         if (params == null) {
  63.                             params = new HashMap<>();
  64.                         }
  65.                         params.put(key, args[index]);
  66.                     }
  67.                     break;
  68.                 }
  69.             }
  70.             index++;
  71.         }
  72.         return new Request(urlBuilder.toString(), params, method.getReturnType());
  73.     }
  75.     private static INetExecutor defaultNetExecutor() {
  76.         return new DefaultNetExecutor();
  77.     }
  79.     public static <T> T generateApi(Class<T> apiInterface) {
  80.         if (apiInterface == null || !apiInterface.isInterface()) {
  81.             throw new RuntimeException("the apiInterface is null or isn`t interface.");
  82.         }
  83.         synchronized (ApiGenerator.class) {
  84.             Object api = sApiCache.get(apiInterface);
  85.             if (api == null) {
  86.                 api = Proxy.newProxyInstance(apiInterface.getClassLoader(),
  87.                         new Class[]{apiInterface},
  88.                         new Handler(apiInterface));
  89.                 sApiCache.put(apiInterface, api);
  90.             }
  91.             return (T) api;
  92.         }
  93.     }
  95.     /**
  96.      * 外部提供自定义执行器
  97.      *
  98.      * @param netExecutor 网络执行器
  99.      */
  100.     public static void setNetExecutor(INetExecutor netExecutor) {
  101.         sNetExecutor = netExecutor;
  102.     }
  104. }

到此，我们的动态代理的编码部分就结束了。我们可以看一下ApiGenerator这个类有个sApiCache的静态变量，他缓存了动态代理生成的对象，这里这样做还是很有必要的，防止重复创建Api的代理类造成额外的性能消耗。

4. 使用姿势

业务方只需要按照我们约束的一套标准来写一个interface即可

  1. package com.puke.dynamicproxy;
  3. import com.puke.net.User;
  4. import com.puke.net.proxy.Param;
  5. import com.puke.net.proxy.URL;
  7. /**
  8.  * @author zijiao
  9.  * @version 16/8/19
  10.  */
  11. @URL("http://***.***.***")
  12. public interface LoginApi {
  14.     User login(@Param("username") String username,
  15.                @Param("password") String password);
  17. }

这个是业务方要写的接口，以及对应的一些注解配置。

接下来就可以直接使用LoginApi生成的具体实例了

  1. package com.puke.dynamicproxy;
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5. import android.view.View;
  6. import android.widget.Toast;
  8. import com.puke.net.User;
  9. import com.puke.net.proxy.ApiGenerator;
  11. public class MainActivity extends Activity {
  13.     @Override
  14.     protected void onCreate(Bundle savedInstanceState) {
  15.         super.onCreate(savedInstanceState);
  16.         setContentView(R.layout.activity_main);
  17.         findViewById(R.id.login).setOnClickListener(new View.OnClickListener() {
  18.             @Override
  19.             public void onClick(View v) {
  20.                 LoginApi loginApi = ApiGenerator.generateApi(LoginApi.class);
  21.                 User user = loginApi.login("123", "456");
  22.                 Toast.makeText(MainActivity.this, user.toString(), Toast.LENGTH_SHORT).show();
  23.             }
  24.         });
  25.     }
  26. }

由于此处模拟的网络请求，就不考虑主线程的进行这个操作了。

5. 使用对比

这里我再贴一下两种使用前后的代码对比

  1. public class UserApi {
  3.     private static final String API_LOGIN = "http://***.***.***";
  4.     private static final Gson sGson = new Gson();
  6.     public static User login(String username, String password) {
  7.         Map<String, Object> params = new HashMap<>();
  8.         params.put("username", username);
  9.         params.put("password", password);
  10.         String response = VirtualHelper.request(API_LOGIN, params);
  11.         //注，这里只是为了举例说明一下，就假设此时的数据结构就是跟User一致的
  12.         return sGson.fromJson(response, User.class);
  13.     }
  15. }

这个是传统的Api方式下业务方要写的代码

  1. @URL("http://***.***.***")
  2. public interface LoginApi {
  3.     User login(@Param("username") String username,
  4.                @Param("password") String password);
  5. }

这个是使用了动态代理之后业务方要写的代码

对比一下，明显能感觉到我们的代码精简了一大圈，看上去清晰明了~

这里我们再回归到最近开始提到的问题，当业务逐渐扩大的时候，这两种模式下，无论是开发效率上还是代码精简度上根本不具有可比性。

四、 一些想法

其实，基于动态代理我们还可以做很多事情，当某一类事物有一些共性，我们一直重复去写一堆“孪生”代码，不仅降低了我们的开发效率，还容易让我产生一种思维定式，按照一个固有的模式去重复做一类事太容易固化我们的思维。不仅仅是动态代理，还有很多很多，开发本该是件轻松的事。工欲善其事，必先利其器。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注