栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java学习之RPC常用工具Retrofit使用样例

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java学习之RPC常用工具Retrofit使用样例

Java学习之RPC常用工具Retrofit使用样例
  • Retrofit简介
  • Retrofit实战
    • 添加依赖
    • 创建 用于描述网络请求 的接口
    • 创建 Retrofit 实例
    • 创建 网络请求接口实例
    • 发送网络请求(异步/同步)
    • 处理返回数据
  • Retrofit进阶
    • DecoratedCall
    • RetrofitCircuitBreaker
    • CircuitBreakerCallAdapter
    • 使用样例
  • 参考链接

Retrofit简介
  • 概念

    Retrofit是Square开源的一款基于OkHttp封装的网络请求框架,主要的网络请求还是OkHttp来完成,Retrofit只是对OkHttp进行了封装。

Retrofit实战
  • 使用步骤

    1. 添加Retrofit库的依赖
    2. 创建 接收服务器返回数据 的类
    3. 创建 用于描述网络请求 的接口
    4. 创建 Retrofit 实例
    5. 创建 网络请求接口实例 并 配置网络请求参数
    6. 发送网络请求(封装了 数据转换、线程切换的操作)
    7. 处理服务器返回的数据
添加依赖
  • pom

        
            com.squareup.retrofit2
            retrofit
            2.5.0
        
        
        
            com.squareup.retrofit2
            converter-scalars
            2.5.0
            test
        
        
        
            com.squareup.retrofit2
            adapter-rxjava2
            2.3.0
            test
        
    
    
    
    
创建 用于描述网络请求 的接口
  • 内容介绍

    Retrofit将 Http请求 抽象成 Java接口:采用 注解 描述网络请求参数 和 配置网络请求参数。

  • 流程说明

    用 动态代理 动态 将该接口的注解“翻译”成一个 Http 请求,最后再执行 Http 请求

    注:接口中的每个方法的参数都需要使用注解标注,否则会报错。

  • 案例源码

        import io.reactivex.Single;
        import okhttp3.ResponseBody;
        import retrofit2.Call;
        import retrofit2.http.GET;
    
        public interface RetrofitService {
    
            // @GET注解的作用:采用Get方法发送网络请求
            // greeting() = 接收网络请求数据的方法
            // 其中返回类型为Call<*>,*是接收数据的类
            @GET("greeting")
            Call greeting();
    
            @GET("delegated")
            Single delegated();
    
            // 如果想直接获得Responsebody中的内容,可以定义网络请求返回值为Call
            @GET("greetingsResponse")
            Call greetingsResponse();
    
            @GET("robot/index")
            Call getString(@Query("info") String info, @Query("key") String key);
        }
    
    
创建 Retrofit 实例
  • 案例源码

        final long TIMEOUT = 1500; // ms
        OkHttpClient client =
            new OkHttpClient.Builder()
                .connectTimeout(TIMEOUT, TimeUnit.MILLISECONDS)
                .readTimeout(TIMEOUT, TimeUnit.MILLISECONDS)
                .writeTimeout(TIMEOUT, TimeUnit.MILLISECONDS)
                .build();
    
        Retrofit retrofit = new Retrofit.Builder()
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava平台
            .addConverterFactory(ScalarsConverterFactory.create()) // 设置数据解析器
            .baseUrl("http://op.juhe.cn/") // 设置网络请求的Url地址
            .client(client)
            .build();
    
    
    
创建 网络请求接口实例
  • 案例源码

    
        // 创建 网络请求接口 的实例
        RetrofitService service = retrofit.create(RetrofitService.class);
    
        //对 发送请求 进行封装
        Call call = service.getString("你好", "2833a660902644508778b5dfd452c080");
    
    
    
    
    
发送网络请求(异步/同步)
  • 案例源码

    
    
        //发送网络请求(异步)
        call.enqueue(new Callback() {
            //请求成功时回调
            @Override
            public void onResponse(Call call, Response response) {
                //请求处理,输出结果
                response.body().show();
            }
    
            //请求失败时候的回调
            @Override
            public void onFailure(Call call, Throwable throwable) {
                System.out.println("连接失败");
            }
        });
    
    
        // 发送网络请求(同步)
        Response response = call.execute();
    
    
    
    
    
处理返回数据
  • 案例源码

    
        // 对返回数据进行处理
        response.body().show();
    
    
    
Retrofit进阶
  • 内容介绍

    熔断器适配Retrofit,添加熔断功能。

DecoratedCall
  • 内容介绍

    用于实现并装饰Retrofit的Call接口

  • 案例源码

        import java.io.IOException;
        import okhttp3.Request;
        import retrofit2.Call;
        import retrofit2.Callback;
        import retrofit2.Response;
    
        
        public abstract class DecoratedCall implements Call {
    
            private final Call call;
    
            public DecoratedCall(Call call) {
                this.call = call;
            }
    
            @Override
            public Response execute() throws IOException {
                return this.call.execute();
            }
    
            @Override
            public void enqueue(Callback callback) {
                call.enqueue(callback);
            }
    
            @Override
            public boolean isExecuted() {
                return call.isExecuted();
            }
    
            @Override
            public void cancel() {
                call.cancel();
            }
    
            @Override
            public boolean isCanceled() {
                return call.isCanceled();
            }
    
            @Override
            public abstract Call clone();
    
            @Override
            public Request request() {
                return call.request();
            }
        }
    
    
    
    
RetrofitCircuitBreaker
  • 内容介绍

    用于装饰改造Retrofit的Call,并在发生异常时通知熔断器

  • 案例源码

        import io.github.resilience4j.circuitbreaker.CallNotPermittedException;
        import io.github.resilience4j.circuitbreaker.CircuitBreaker;
        import io.github.resilience4j.core.StopWatch;
        import io.github.resilience4j.retrofit.internal.DecoratedCall;
        import retrofit2.Call;
        import retrofit2.Callback;
        import retrofit2.Response;
    
        import java.io.IOException;
        import java.util.concurrent.TimeUnit;
        import java.util.function.Predicate;
    
        
        public interface RetrofitCircuitBreaker {
    
            
            static  Call decorateCall(final CircuitBreaker circuitBreaker, final Call call,
                final Predicate responseSuccess) {
                return new CircuitBreakingCall<>(call, circuitBreaker, responseSuccess);
            }
    
            class CircuitBreakingCall extends DecoratedCall {
    
                private final Call call;
                private final CircuitBreaker circuitBreaker;
                private final Predicate responseSuccess;
    
                public CircuitBreakingCall(Call call, CircuitBreaker circuitBreaker,
                    Predicate responseSuccess) {
                    super(call);
                    this.call = call;
                    this.circuitBreaker = circuitBreaker;
                    this.responseSuccess = responseSuccess;
                }
    
                @Override
                public void enqueue(final Callback callback) {
                    try {
                        circuitBreaker.acquirePermission();
                    } catch (CallNotPermittedException cb) {
                        callback.onFailure(call, cb);
                        return;
                    }
    
                    final long start = System.nanoTime();
                    call.enqueue(new Callback() {
                        @Override
                        public void onResponse(final Call call, final Response response) {
                            if (responseSuccess.test(response)) {
                                circuitBreaker.onResult(System.nanoTime() - start, TimeUnit.NANOSECONDS, response);
                            } else {
                                final Throwable throwable = new Throwable(
                                    "Response error: HTTP " + response.code() + " - " + response.message());
                                circuitBreaker
                                    .onError(System.nanoTime() - start, TimeUnit.NANOSECONDS, throwable);
                            }
                            callback.onResponse(call, response);
                        }
    
                        @Override
                        public void onFailure(final Call call, final Throwable t) {
                            if (call.isCanceled()) {
                                circuitBreaker.releasePermission();
                            } else {
                                circuitBreaker.onError(System.nanoTime() - start, TimeUnit.NANOSECONDS, t);
                            }
                            callback.onFailure(call, t);
                        }
                    });
                }
    
                @Override
                public Response execute() throws IOException {
                    circuitBreaker.acquirePermission();
                    final StopWatch stopWatch = StopWatch.start();
                    try {
                        final Response response = call.execute();
    
                        if (responseSuccess.test(response)) {
                            circuitBreaker.onResult(stopWatch.stop().toNanos(), TimeUnit.NANOSECONDS, response);
                        } else {
                            final Throwable throwable = new Throwable(
                                "Response error: HTTP " + response.code() + " - " + response.message());
                            circuitBreaker
                                .onError(stopWatch.stop().toNanos(), TimeUnit.NANOSECONDS, throwable);
                        }
    
                        return response;
                    } catch (Exception exception) {
                        if (call.isCanceled()) {
                            circuitBreaker.releasePermission();
                        } else {
                            circuitBreaker
                                .onError(stopWatch.stop().toNanos(), TimeUnit.NANOSECONDS, exception);
                        }
                        throw exception;
                    }
                }
    
                @Override
                public Call clone() {
                    return new CircuitBreakingCall<>(call.clone(), circuitBreaker, responseSuccess);
                }
            }
        }
    
    
    
    
CircuitBreakerCallAdapter