Java动态代理-实战

怼烎@ 2021-11-11 16:58 224阅读 0赞

# Java动态代理-实战 #

# 只要是写Java的，动态代理就一个必须掌握的知识点，当然刚开始接触的时候，理解的肯定比较浅，渐渐的会深入一些，这篇文章通过实战例子帮助大家深入理解动态代理。 #

说动态代理之前，要先搞明白什么是代理，代理的字面意思已经很容易理解了，我们这里撇开其他的解释，我们只谈设计模式中的代理模式

### 什么是代理模式(Proxy) ###

定义：给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用

在代理模式中，是需要代理对象和目标对象实现同一个接口（如果是不同的接口，那就是适配器模式了），看下面的UML图

![webp][]

动态代理 uml.png

#### 为什么要用代理 ####

最最最主要的原因就是，在不改变目标对象方法的情况下对方法进行增强，比如，我们希望对方法的调用增加日志记录，或者对方法的调用进行拦截，等等...

##### 举一个例子 #####

现有一个IPerson接口，只有一个方法say()

public interface IPerson { void say(); }

有一个Man类，实现了IPerson

public class Man implements IPerson{ @Override public void say() { L.d("man say"); } }

现在需要在say方法被调用的时候，记录方法被调用的时间，最直接的就是修改Man的say方法，但是这样做的弊端就是如果有很多实现了IPerson接口的类，那就需要修改多处代码，而且这样的修改可能会导致其他的代码出问题(可能并不是所有的say都需要记录调用时间)。怎么办呢，这时候代理就要登场了！

#### 静态代理 ####

public class ManProxy implements IPerson{ private IPerson target; public IPerson getTarget() { return target; } public ManProxy setTarget(IPerson target) { this.target = target; return this; } @Override public void say() { if (target != null) { L.d("man say invoked at : " + System.currentTimeMillis()); target.say(); } } }

这样我们需要新建一个ManProxy类同样实现IPerson接口，将要代理的对象传递进来，这样就可以在不修改Man的say方法的情况下实现了我们的需求。这其实就是静态代理。那你可能要问，既然有了静态代理，为什么需要动态代理呢，因为静态代理有一个最大的缺陷：接口与代理类是1对1的，有多个接口需要代理，就需要新建多个代理类，繁琐，类爆炸。

#### 动态代理 ####

我们先尝试用动态代理来解决上面的问题。先新建一个类实现InvocationHandler，

public class NormalHandler implements InvocationHandler { private Object target; public NormalHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { L.d("man say invoked at : " + System.currentTimeMillis()); method.invoke(target, args); return null; } }

然后可以这样使用

Man man = new Man(); NormalHandler normalHandler = new NormalHandler(man); AnnotationHandler annotationHandler = new AnnotationHandler(); IPerson iPerson = (IPerson) Proxy.newProxyInstance(IPerson.class.getClassLoader(), new Class[] {IPerson.class, IAnimal.class}, annotationHandler); iPerson.say();

可以看到NormalHandler中代理的对象是Object类型，所以它是被多个接口代理复用的，这样就解决静态代理类爆炸，维护困难的问题。我们重点看NormalHandler中的invoke方法，第二个参数method就是我们实际调用时的方法，所以动态代理使用了反射，为了灵活稍稍牺牲一点性能。

#### 动态代理的成功案例 ####

*  Square公司出品的Android Restful 网络请求库Retrofit
 *  Spring AOP （默认使用动态代理，如果没有实现接口则使用CGLIB修改字节码）

这2个库不用多说了，Github上面Star数都是好几万的网红项目。

#### 利用动态代理实现一个低配的Retrofit ####

“talk is cheap, show me the code”, 所以捋起袖子干起来。  
先新建需要用到的注解类和实体类

@Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface GET { String value(); } @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface POST { String value(); } @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) public @interface Query { String value(); } //更新实体类 public class CheckUpdate { private boolean hasUpdate; private String newVersion; public boolean isHasUpdate() { return hasUpdate; } public void setHasUpdate(boolean hasUpdate) { this.hasUpdate = hasUpdate; } public String getNewVersion() { return newVersion; } public void setNewVersion(String newVersion) { this.newVersion = newVersion; } @Override public String toString() { return "Has update : " + hasUpdate + " ; The newest version is : " + newVersion; } }

接下来是接口方法类, 接口url地址这里随便写的，大家知道意思就OK了。

public interface ApiService { @POST("http://www.baidu.com/login") Observable<User> login(@Query("username") String username, @Query("password") String password); @GET("http://www.baidu.com/checkupdate") Observable<CheckUpdate> checkUpdate(@Query("version") String version); }

接下来就是我们的重点代理类RequestHandler，里面的核心是解析方法注解的返回值和参数，包括返回值的泛型，在Json反序列化的时候回用到

public class RequestHandler implements InvocationHandler { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Annotation[] annotations = method.getAnnotations(); if (annotations != null && annotations.length > 0) { Annotation annotation = annotations[0]; if (annotation instanceof GET) { GET get = (GET) annotation; return handleGetRequest(method, get, args); }else if (annotation instanceof POST) { POST post = (POST) annotation; return handlePostRequest(method, post, args); } } return null; } private Observable handleGetRequest(Method method, GET get, Object[] params) { String url = get.value(); Type genericType = method.getGenericReturnType(); Parameter[] parameters = method.getParameters(); ParameterizedType parameterizedType = (ParameterizedType) genericType; Class returnGenericClazz = null; //解析方法返回值的参数类型 if (parameterizedType != null) { Type[] types = parameterizedType.getActualTypeArguments(); for (int i = 0; i < types.length; i++) { Class cls = (Class) types[i]; returnGenericClazz = cls; break; } } //解析请求参数，然后拼接到url if (params != null) { url += "?"; for (int i = 0; i < params.length; i++) { Query query = parameters[i].getAnnotation(Query.class); url += query.value() + "=" + params[0].toString(); if (i < params.length - 1) { url += "&"; } } } final String getUrl = url; final Class returnClazz = returnGenericClazz; return Observable.create(observableEmitter -> { Request request = new Request.Builder().url(getUrl).build(); Response response = new OkHttpClient() .newCall(request).execute(); if (response.isSuccessful()) { // String responseStr = response.body().string(); //这里mock返回数据 String responseStr = MockFactory.mockCheckUpdateStr(); Object result = new Gson().fromJson(responseStr, returnClazz); observableEmitter.onNext(result); }else { observableEmitter.onError(new IllegalStateException("http request failed!")); } observableEmitter.onComplete(); }); } private Observable handlePostRequest(Method method, POST post, Object[] params) { //篇幅关系，这里省略，可以参考get 实现 //。。。。。 } }

新建一个门面类Retrofit，方便调用

public class Retrofit { public static <T> T newProxy(Class<T> clazz) { return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] {clazz}, new RequestHandler()); } }

一个低配版的Retrofit就完成了，赶紧去测试一下

public static void main(String[] args) { ApiService apiService = ApiService apiService = Retrofit.newProxy(ApiService.class); Observable<CheckUpdate> checkUpdateObservable = apiService.checkUpdate("3.1.0"); checkUpdateObservable.subscribeOn(Schedulers.io()) .subscribe(checkUpdate -> L.d(checkUpdate.toString()), throwable -> L.d(throwable.getMessage())); //等待工作线程执行完成 Scanner sc = new Scanner(System.in); if (sc.next() != null) {} }

最终的执行结果，当然这里只是初步实现了Retrofit的一点点功能，我们的目标还是讲解动态代理这个技术，以及它能够干什么

![webp 1][]

执行结果

#### 最后一点小Tip ####

可以看到，我们上面的低配的Retrofit，并没有被代理的类，因为我们仅仅通过解析ApiService接口中的注解中的信息已经足够我们去发起Http请求，所以技术在于灵活运用。  
好了，这篇先到这里，大家开心发财！

转载于:https://www.cnblogs.com/wangenxian/p/10885298.html

[webp]: /images/20211109/8d56f007bf0c418d84d4359257597189.png
[webp 1]: /images/20211109/1fda5a50f13445938ea2956bf1cfc83d.png