Java动态代理-实战

Java动态代理-实战

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

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

什么是代理模式(Proxy)

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

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

 

动态代理 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的一点点功能，我们的目标还是讲解动态代理这个技术，以及它能够干什么

 

执行结果

最后一点小Tip

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