Java动态代理-AOP-实战

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

</blockquote>

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

<h3>什么是代理模式(Proxy)</h3>

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

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

</div>

</div>

<h4>为什么要用代理</h4>

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

<h5>举一个例子</h5>

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

<pre class="hljs java"><code class="java">public interface IPerson {

void say();

}

</code></pre>

有一个Man类，实现了IPerson

<pre class="hljs java"><code class="java">public class Man implements IPerson{

@Override

public void say() {

L.d("man say");

}

</code></pre>

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

<pre class="hljs java"><code class="java">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();

}

</code></pre>

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

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

<pre class="hljs java"><code class="java">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;

}

</code></pre>

然后可以这样使用

<pre class="hljs php"><code class="php">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();

</code></pre>

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

<h4>动态代理的成功案例</h4>

<ul>

<li>Square公司出品的Android Restful 网络请求库Retrofit</li>

<li>Spring AOP （默认使用动态代理，如果没有实现接口则使用CGLIB修改字节码）</li>

</ul>

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

<h4>利用动态代理实现一个低配的Retrofit</h4>

“talk is cheap, show me the code”, 所以捋起袖子干起来。

先新建需要用到的注解类和实体类

<pre class="hljs java"><code class="java">@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;

}

</code></pre>

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

@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);

}

</code></pre>

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

<pre class="hljs java"><code class="java">public class RequestHandler implements InvocationHandler {

@Override

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 实现

//。。。。。

}

</code></pre>

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

<pre class="hljs php"><code class="php">public class Retrofit {

public static <T> T newProxy(Class<T> clazz) {

return (T) Proxy.newProxyInstance(clazz.getClassLoader(),

new Class[] {clazz}, new RequestHandler());

}

</code></pre>

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

<pre class="hljs java"><code class="java">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) {}

}

</code></pre>

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

</div>

</div>

<h4>最后一点小Tip</h4>

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

好了，这篇先到这里，大家开心发财！

</div>

Java动态代理-AOP-实战

推荐阅读更多精彩内容