跨平台调用 Retrofit

为什么不用Spring RestTemplate 与 Feign

Feign

Feign是局域网调用，而这里需求则是跨平台的广域网调用。

RestTemplate - 先提出两个需求：

我们需要像Feign那样配置一个，声明式的接口，在易用性、可读性等方面能有较好的表现。
请求时，BaseUrl也就是域名地址是动态变化的。 =>回答：对RestTemplate来说，每次请求前我们需要提前配置好网关地址，然后再加上请求的Path。无法实现动态的BaseUrl改变与请求接口的统一管理。

Retrofit能解决这些痛点吗？

Retrofit支持BaseUrl的动态改变。
它能将请求接口规划在每个Retrofit Client中进行统一管理。

大致背景

需要完成的是B端类似应用市场的功能，存在Pass与SaaS端，Pass端主要是各个用户对平台自己进行部署安装。SaaS则是我们维护在公网上的Pass，用户可以通过它们自己的Pass平台访问到SaaS从而拿到应用数据实现下载，上传，查看等，所以这里的需求就是需要在Pass端对远程SaaS进行跨平台的调用。

在项目中使用retrofit的演进过程

通常如果存在一个baseurl，只需要配置并build一个retrofit，然后createClient，创建出访问接口的Client。
但在这里我们的baseUrl会时刻改变，意味着SaaS的地址会发送变化。
而且有不同Client访问不同平台的微服务，比如Pass端的访问接口包含了对多个微服务的请求，那么它们就应该划分为不同的Client，统一管理。

存在多个baseurl

创建一个工厂类：使用静态字段BaseUrl和Client，每次请求去查验当前Client是否为空，url是否改变，如果改变或为空则使用build一个Retrofit创建新的Client。
为什么不考虑使用官方推荐的动态url来做，是因为每次请求的时候都需要跟上自己的全路径，而这里我们希望将Path能放在一个统一接口的各个具体的调用方法上。

    private static String baseUrl;

    private static AppMarketClient marketClient;

    public static AppMarketClient createClient(String newUrl) {

        if (marketClient == null || !baseUrl.equals(newUrl)) {
            baseUrl = newUrl;
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(baseUrl)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();

            marketClient = retrofit.create(AppMarketClient.class);
        }

        return marketClient;
    }

存在多个BaseUrl,同时存在多个Client

使用工厂类，类中使用Map，BaseUrl作key，Client作value缓存Client，痛点在于我每个url都要跟上请求的具体微服务网关Path，这样才能区分相同BaseUrl不同微服务的Client，比如http://xxx.com/devops/xxx，与http://xxx.com/market/xxx。

    private static final Map<String, RetrofitClient> retrofitClients = new HashMap<>();

    public static RetrofitClient createClient(String baseUrl, Class<? extends RetrofitClient> clientClass) {
        //如果baseUrl被修改或map中不存在这个RetrofitClient，则创建
        if (!retrofitClients.containsKey(baseUrl)) {
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(baseUrl)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
            retrofitClients.put(baseUrl, retrofit.create(clientClass));
        }
        return retrofitClients.get(baseUrl);
    }

在Github上看到Retrofit废除BaseUrl的Issue，其中提到使用拦截器进行统一处理，从而动态改变BaseUrl

    private static final Retrofit retrofit;
    // 默认值
    private static String baseUrl = "http://localhost";
    private static final Map<String, Object> retrofitClients = new HashMap<>();

    static {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .addInterceptor(chain -> {
                    HttpUrl httpUrl = HttpUrl.parse(baseUrl);
                    if (ObjectUtils.isEmpty(httpUrl)) {
                        throw new CommonException("error.retrofit.baseUrl.illegal", baseUrl);
                    }
                    Request request = chain.request();
                    Request.Builder builder = request.newBuilder();
                    HttpUrl oldHttpUrl = request.url();
                    HttpUrl newFullUrl = oldHttpUrl
                            .newBuilder()
                            .host(httpUrl.host())
                            .build();
                    return chain.proceed(builder.url(newFullUrl).build());
                })
                .build();
        retrofit = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .addConverterFactory(GsonConverterFactory.create())
                .client(okHttpClient)
                .build();
    }

    public static Object createClient(String baseUrl, Class clientClass) {
        RetrofitClientFactory.baseUrl = baseUrl;
        String className = clientClass.getSimpleName();
        if (!retrofitClients.containsKey(className)) {
            retrofitClients.put(className, retrofit.create(clientClass));
        }
        return retrofitClients.get(className);
    }

添加到spring管理

    // 原有工厂类
    private ApplicationContext applicationContext;
    private RetrofitConfig retrofitConfig;

    public RetrofitClientFactory(RetrofitConfig retrofitConfig) {
        this.retrofitConfig = retrofitConfig;
    }

    @Override
    public void setApplicationContext(@NonNull ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    public Object getRetrofitBean(String baseUrl, Class clientName) {
        retrofitConfig.setBaseUrl(baseUrl);
        return applicationContext.getBean(clientName.getSimpleName());
    }


    // Spring配置文件
    private String baseUrl = "http://localhost";

    // todo 修改全局的baseUrl时的线程安全 (修改baseUrl，获取RetrofitClient，发出请求，这三步是一个原子操作)
    public void setBaseUrl(String baseUrl) {
        this.baseUrl = baseUrl;
    }

    @Bean("RemoteTokenRetrofitClient")
    public RemoteTokenRetrofitClient remoteTokenRetrofitClient() {
        Retrofit retrofit = getCommonRetrofit();
        return retrofit.create(RemoteTokenRetrofitClient.class);
    }

    @Bean("AppMarketRetrofitClient")
    public AppMarketRetrofitClient appMarketRetrofitClient() {
        Retrofit retrofit = getCommonRetrofit();
        return retrofit.create(AppMarketRetrofitClient.class);
    }

    private Retrofit getCommonRetrofit() {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .addInterceptor(chain -> {
                    HttpUrl httpUrl = HttpUrl.parse(baseUrl);
                    if (ObjectUtils.isEmpty(httpUrl)) {
                        throw new CommonException("error.retrofit.baseUrl.illegal", baseUrl);
                    }
                    Request request = chain.request();
                    Request.Builder builder = request.newBuilder();
                    HttpUrl oldHttpUrl = request.url();
                    HttpUrl newFullUrl = oldHttpUrl
                            .newBuilder()
                            .host(httpUrl.host())
                            .port(httpUrl.port())
                            .build();
                    return chain.proceed(builder.url(newFullUrl).build());
                })
                .build();
        return new Retrofit.Builder()
                .baseUrl(baseUrl)
                .addConverterFactory(GsonConverterFactory.create())
                .client(okHttpClient)
                .build();
    }