Android_代理设计模式-动态代理

本文目标

理解并掌握Java的动态代理

1.静态代理

介绍动态代理之前,有兴趣的小伙伴可以看一下什么是静态代理,其实静态代理很简单,无非就是委托方和代理方

• 1.委托方持有协议并调用协议方法
• 2.代理方,遵守协议,实现协议接口的方法

2.动态代理

与静态代理不同的是,动态代理是通过反射在运行时生成代理对象,Java给我们提供了一个便捷的动态代理接口InvocationHandler,源码最终调用的是Native方法去生成我们的代理对象,来直接上代码

2.1动态代理核心代码

/**
 * Author: 信仰年轻
 * Date: 2020-08-27 18:19
 * Email: hydznsqk@163.com
 * Des:
 */
public class MyInvocationHandler implements InvocationHandler {

    /**
     * 被代理的对象
     */
    private Object mObject;

    public MyInvocationHandler(Object object){
        this.mObject = object;
    }

    /**
     * 拿IBank来举例子
     * 当调用了接口中的方法的时候就会回调invoke这个方法,然后会解析该方法上的所有东西(注解,参数,返回值)
     * proxy:接口的代理实现对象,(IBank的实现类对象)
     * method:调用的方法(applyBank方法)
     * args:调用的方法的入参void applyBank(String bankName);
     * 返回值:就是定义接口中方法的返回值在这里是void
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 调用被代理对象的方法,这里其实调用的就是  man 里面的 applyBank 方法
        Object voidObject = method.invoke(mObject,args);
        return voidObject;
    }
}

public class Client {
   public static void main(String[] args) {
        Man man = new Man(this,"风清扬");
        IBank bank =(IBank) Proxy.newProxyInstance(// 返回的是 IBank 的一个实例对象，这个对象是由 Java 给我们创建的 ,调用的是 jni
                        IBank.class.getClassLoader(), // ClassLoader
                        new Class<?>[]{IBank.class}, // 目标接口
                        new MyInvocationHandler(man)); // InvocationHandler (这个类是关键)
        bank.applyBank("中国银行");
    }
}

最核心的就是MyInvocationHandler这个类,该类要实现InvocationHandler并重写invoke方法,该方法有3个参数

• 第1个参数proxy:接口的代理实现对象(IBank接口的实现类对象)
• 第2个参数method:调用的方法(applyBank方法)
• 第3个参数args:调用的方法的入参void applyBank(String bankName);
• 返回值:就是定义接口中方法的返回值在这里是void

然后在Client类的调用方法中
Proxy.newProxyInstance()方法中也要传递3个参数

• 第1个参数:接口的classLoader
• 第2个参数:接口的class对象
• 第3个参数:InvocationHandler的实现类对象
  运行的时候就能为我们生成一个代理对象了,可以理解为new了一个Interface对象给了我们

2.2动态代理辅助代码

/**
 * Author: 信仰年轻
 * Date: 2020-08-27 18:27
 * Email: hydznsqk@163.com
 * Des:
 */
public interface IBank {
    /**
     * 申请办卡
     */
    void applyBank(String bankName);
}

public class Man implements IBank {
    private String name;
    private Context mContext;

    public Man(Context context,String name){
        this.name = name;
        this.mContext = context;
    }

    @Override
    public void applyBank(String bankName) {
        Log.i("TAG",name + "在"+bankName+"申请办卡");
    }
}

3.动态代理实现 Retrofit 的 create

我们来看下 Retrofit 最普通的写法

public class RetrofitSimple {
    private static DataServiceInterface serviceInterface;

    static {
        Retrofit.Builder retrofitBuilder = new Retrofit
                .Builder()
                .baseUrl("https://api.xxxxx.com/")
                .addConverterFactory(GsonConverterFactory.create());
        serviceInterface = retrofitBuilder.build().create(DataServiceInterface.class);
    }

    public static DataServiceInterface getService(){
        return serviceInterface;
    }
}

Call<Result> call = RetrofitSimple.getService().testMethod();

call.enqueue(new Callback<Result>() {
    @Override
    public void onResponse(Call<Result> call, Response<Result> response) {
        Result result = response.body();
        Log.e("TAG","result = "+result.code);
    }

    @Override
    public void onFailure(Call<Result> call, Throwable t) {
         
    }
});

这是没有做任何封装的，相信用过的都能看懂.上面代码最主要的核心在于 Retrofit.create() 我们传递过去的是一个接口的 class给我们返回的是一个对象，而这个对象其实就我们的代理对象，接下来我们简单的实现一下思路的伪代码,如果想看具体的Demo

public class Retrofit {
    /**
     * 1.动态代理
     */
    public <T> T create(Class<T> service) {
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[]{service}, new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //每执行一个方法都会来到这里
                // 判断是不是 Object 的方法
                if (method.getDeclaringClass() == Object.class) {
                    return method.invoke(this, args);
                }
                //2.解析方法上的注解和解析参数上的注解
     
                //3.封装OkHttp请求
          
                return null;
            }
        });
    }
}

public class RetrofitClient {

    private final static ServiceApi mServiceApi;

    static {
        Retrofit retrofit = new Retrofit
                .Builder()
                // 访问后台接口的主路径
                .baseUrl("https://www.fastmock.site/mock/b5b5b4f8bf5a7178e46771346c7940ca/YdHttpServer/")
                .build();
        // 创建一个 实例对象
        mServiceApi = retrofit.create(ServiceApi.class);
    }

    public static ServiceApi getServiceApi() {
        return mServiceApi;
    }
}

 RetrofitClient
                .getServiceApi()
                .userLogin("yd", "123456")
                .enqueue(new Callback<UserLoginResult>() {
                    @Override
                    public void onResponse(Call<UserLoginResult> call, Response<UserLoginResult> response) {
                        final String result = response.body.toString();
                        Log.i("TAG",result);
                    }

                    @Override
                    public void onFailure(Call<UserLoginResult> call, Throwable t) {
                        Log.e("TAG",t.getMessage());
                    }
                });