Java设计模式——适配器模式

适配器模式是将一个类的接口转换成开发者希望的另一个接口
下面参考Retrofit的源码学习适配器模式，Retrofit现在的Andorid开发者基本都用到过，里面用到了很多设计模式比如动态代理模式，适配器模式等。下面来看其中的一个适配器
在使用Retrofit的时候我们经常会看到下面的写法来添加一个addCallAdapterFactory，如果我们不添加，会有自己的一个CallAdapter返回一个Call对象，如果我们想和RxJava结合使用只需要添加一个RxJava的CallAdapter即可。

Retrofit retrofit = new Retrofit.Builder()
         .baseUrl("")
         .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
         .build();
//  Retrofit的create方法源码       
public  T create(final Class service) {
   ......
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[] { service },
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
              throws Throwable {
        ......
            ServiceMethod serviceMethod =
                (ServiceMethod) loadServiceMethod(method);
            OkHttpCall okHttpCall = new OkHttpCall(serviceMethod, args);
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }

下面开始仿照Retrofit写一下适配器模式
首先有一个Call接口和CallAdapter适配器和一个Call的实现类OkHttpCall，CallAdapter中有一个抽象工厂类里面有个get()方法可以返回自己。

public interface Call {
    void enqueue();
}

public interface CallAdapter {

    T adapt(Call call);

    abstract class Factory{
       public abstract CallAdapter get();
    }
}
public class OkHttpCall implements Call {
    @Override
    public void enqueue() {
      //请求网络
    }
}

实现一个默认的 CallAdapter

public class ExecutorCallAdapterFactory extends CallAdapter.Factory {
    @Override
    public CallAdapter get() {
        return new CallAdapter<Object, Call>() {
            @Override
            public Call adapt(Call call) {
                System.out.println("default 方式");
                return new ExectorCallbackCall();
            }
        };
    }
    static final class ExectorCallbackCall implements Call{

        @Override
        public void enqueue() {

        }
    }
}

在实现一个RxJava的CallAdapter

public class RxJavaCallAdapterFactory extends CallAdapter.Factory {
    @Override
    public CallAdapter get() {
        return new CallAdapter<Object, Observable>() {
            @Override
            public  Observable adapt(Call call) {
                System.out.println("rxjava 方式");
                ObservableOnSubscribe subscribe = new ObservableOnSubscribe() {
                    @Override
                    public void subscribe(ObservableEmitter emitter) throws Exception {

                    }
                };
                return Observable.create(subscribe);
            }
        };
    }
}

Retrofit类中调用

public class Retrofit {

    private CallAdapter.Factory mFactory;

    private Retrofit(CallAdapter.Factory factory) {
        mFactory = factory;
    }

    public CallAdapter callAdapter(){
        return mFactory.get();
    }

    public  T create(){
      ServiceMethod serviceMethod = new ServiceMethod.Builder(this).build();
      OkHttpCall okHttpCall = new OkHttpCall();
      return (T) serviceMethod.adapt(okHttpCall);
    }

    public static final class Builder{
        CallAdapter.Factory mFactory;
        public Builder addCallAdapterFactory(CallAdapter.Factory factory){
            mFactory = factory;
            return this;
        }
        public Retrofit build(){
            if(mFactory == null){
                return new Retrofit(new ExecutorCallAdapterFactory());
            }
            return new Retrofit(mFactory);
        }
    }
}

通过ServiceMethod把Retrofit和CallAdapter连起来

public class ServiceMethod {

    private CallAdapter mCallAdapter;

    private  ServiceMethod(Builder builder) {
       mCallAdapter = builder.mCallAdapter;
    }

    T adapt(Call call){
        return mCallAdapter.adapt(call);
    };

    static final class Builder{
        Retrofit mRetrofit;
        CallAdapter mCallAdapter;

        public Builder(Retrofit retrofit) {
            mRetrofit = retrofit;
        }
        public ServiceMethod build(){
            mCallAdapter = createCallAdapter();
            return new ServiceMethod(this);
        }

        private CallAdapter createCallAdapter() {
            return mRetrofit.callAdapter();
        }
    }
}

最后调用：

Retrofit retrofit = new Retrofit.Builder()
                .addCallAdapterFactory(new RxJavaCallAdapterFactory())
                .build();
  retrofit.create();

如果不加addCallAdapterFactory运行输出：“default 方式”
如果添加了运行输出：“rxjava 方式”
适配器模式完成。