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请求，所以技术在于灵活运用。
好了，这篇先到这里，大家开心发财！
