优雅地调用接口--手把手带你从0到1实现retrofit框架

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 DNS,旗舰版 1个月
全局流量管理 GTM,标准版 1个月
简介: retrofit作为http请求的接口框架而被众人熟知道,它独特且优雅的接口使用习惯被无数的程序员所认可。http://square.github.io/retrofit/介绍A type-safe HTTP client for Android and JavaRetrofit是一个基于AOP思想,对RestfulApi注解进行动态代理的网络框架。

retrofit作为http请求的接口框架而被众人熟知道,它独特且优雅的接口使用习惯被无数的程序员所认可。http://square.github.io/retrofit/

介绍

A type-safe HTTP client for Android and Java
Retrofit是一个基于AOP思想,对RestfulApi注解进行动态代理的网络框架。

public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();


GitHubService service = retrofit.create(GitHubService.class);

我们的JT框架

        JTHttpClient
                .create()
                .setSecLevel(JtRequest.NORMAL)
                .url(Urls.index_V)
                .build()
                .post(HomeModule.class)
                .subscribe(new JtSingObserver<HomeModule>(this) {
                    @Override
                    public void onSuccess(HomeModule homeModule) {
                        if (homeModule.header.app_login_status == 0) {
                            JTApi.get().logout();
                        }
                        sHomeModule = homeModule;
                        mHomeModule.setValue(homeModule);

                    }

                    @Override
                    public void onError(Throwable e) {
                        sHomeModule = null;
                        mHomeModule.setValue(null);
                        UIUtil.INSTANCE.showExceptionMsg(e);
                    }
                });

我在深思熟虑中打造的JT框架虽然简单易用性和性能上其实已经很优秀,但是经过我再一次的深思熟虑觉得依然存在着一些问题。

  • 模板类代码太多
  • 泛型传递太频发(两次)
  • 链式的调用过程某种程度意味效率的低下(选择遗忘的太多)

Retrofit的实现过程

retrofit的主要技术细节包括:
1.接口的实例化
2.获取泛型的返回值type(数据的解析和实例化观察者需要)
3.获取Method之后通过反射获取方法注解和参数注解

我们忽略了一些AOP编程的细节,而是主要去关注一个注解方法对象(Method)的解析过程。
retrofit将Method对象解析成对应http request;将request的参数给下层的网络适配器adapter(可以认为是OkhttpAdapter),适配器调用自身execute方法,调用成功后通过线程分发器发送到对应的线程。至此,完成了retrofit对网络的完整的抽象。


img_bf4c3513589ee77bd5028681040f79f0.png
retrofit_stay.png
    public <T> T create(final Class<T> service) {//函数的入口,实例化接口对象
        Utils.validateServiceInterface(service);//检查service合法性
        if (validateEagerly) {
            eagerlyValidateMethods(service);
        }
        //动态代理实例化对象
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] {service},
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object... args)
                            throws Throwable {
                        // If the method is a method from Object then defer to normal invocation.
                        //解析method注解并交给call对象(网络执行者,默认okhttpclient)
                        // 触发http请求的方法。invoke会返回Call对象,调用该对象的方法即可完成网络请求
                        return loadMethodHandler(method).invoke(args);

                    }
                });
    }

    MethodHandler loadMethodHandler(Method method) {
        MethodHandler handler;
        synchronized(methodHandlerCache) {//查看静态缓存区,是否有对应method可用,加快执行的速度
            handler = methodHandlerCache.get(method);
            if (handler == null) {
                //创建MethodHandler对象,
                //该对象用来管理
                // requestFactory请求构造器,
                // callFactory(http执行栈默认OkHttpClient),
                // callAdapter回调适配器(用于线程的分发),
                // responseConverter内容转换器
                // 可以认为一种接口method与http请求过程的媒介
                // new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,responseConverter);

                handler = MethodHandler.create(this, method);
                methodHandlerCache.put(method, handler);
            }
        }
        return handler;
    }

    static MethodHandler create(Retrofit retrofit, Method method) {
        //创建callAdapter, callAdapter是一个可以用来触发网络成功或失败的回调的对象,该方法主要
        // 1.查找当前队列中可用的callAdapter
        // 2.不管有没有查找成功都会获取method返回值(method.getGenericReturnType())的泛型type
        // 3.验证合法性
        CallAdapter<?> callAdapter = createCallAdapter(method, retrofit);
        Type responseType = callAdapter.responseType();
        if (responseType == Response.class || responseType == okhttp3.Response.class) {
            throw Utils.methodError(method, "'"
                    + Types.getRawType(responseType).getName()
                    + "' is not a valid response body type. Did you mean ResponseBody?");
        }
        //创建responseConverter,这个方法不关注
        Converter<ResponseBody, ?> responseConverter =
                createResponseConverter(method, retrofit, responseType);
        //解析获得请求的参数,创建requestFactory,最为核心且最复杂的方法
        //        RequestFactory:
        //        private final String method;
        //        private final BaseUrl baseUrl;
        //        private final String relativeUrl;
        //        private final Headers headers;
        //        private final MediaType contentType;
        //        private final boolean hasBody;
        //        private final boolean isFormEncoded;
        //        private final boolean isMultipart;
        //        private final RequestAction[] requestActions;
        RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
        return new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,
                responseConverter);
    }

  
    static RequestFactory parse(Method method, Type responseType, Retrofit retrofit) {
        RequestFactoryParser parser = new RequestFactoryParser(method);

        Annotation[] methodAnnotations = method.getAnnotations();
        //解析method方法的注解annotations[]
        parser.parseMethodAnnotations(responseType, methodAnnotations);
        //解析method参数的注解annotations[][],此处是二维数组
        parser.parseParameters(retrofit, methodAnnotations);

        return parser.toRequestFactory(retrofit.baseUrl());
    }
//该方法用于通过returnType查找对应的callAdapter并获取实例化的callAdapter对象
    private static CallAdapter<?> createCallAdapter(Method method, Retrofit retrofit) {
        Type returnType = method.getGenericReturnType();
        if (Utils.hasUnresolvableType(returnType)) {
            throw Utils.methodError(method,
                    "Method return type must not include a type variable or wildcard: %s", returnType);
        }
        if (returnType == void.class) {
            throw Utils.methodError(method, "Service methods cannot return void.");
        }
        Annotation[] annotations = method.getAnnotations();
        try {
            return retrofit.callAdapter(returnType, annotations);
        } catch (RuntimeException e) { // Wide exception range because factories are user code.
            throw Utils.methodError(e, method, "Unable to create call adapter for %s", returnType);
        }
    }



JT的实现

主要实现的步骤:

  1. 动态代理实例化接口对象
  2. 在invoke函数中获取被调用的Method对象
  3. 解析并拿到Method中的request参数和返回值泛型的type
//return type
Type returnType = method.getGenericReturnType();
            if (method.getReturnType() == Single.class) {
            } else {
                throw new IllegalArgumentException("you must return a type == Single.class");
            }
            if (returnType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) returnType)
                        .getActualTypeArguments();
                if (actualTypeArguments.length == 1) {
                    mReturnType = actualTypeArguments[0];
                } else {
                    throw new IllegalArgumentException();
                }
            }
//缓存Method的request.builder参数,调用perform方法去注入builder
private List<RequestAction> requestActionList = new ArrayList<>();
  1. 通过jtclient发送http请求
    5.根据3中的返回值泛型type解析response
    6.最后,通知观察者,处理所订阅的事件
        apiService = Proxy.newProxyInstance(service.getClassLoader(),
                new Class<?>[] {service},
                new InvocationHandler() {

                    //这个invoke方法会在代理对象的方法中调用,第一个参数就是代理对象
                    //第二个参数是代理对象调用的方法
                    //第三个参数方法的参数
                    @Override
                    public Object invoke(Object proxy, Method method, Object... args)
                            throws Throwable {
                        validateServiceInterface(service);

                        // If the method is a method from Object then defer to normal invocation.
                        if (method.getDeclaringClass() == Object.class) {
                            return method.invoke(this, args);
                        }
                        //调用loadMethodHandler
                        return loadMethodHandler(method).invoke(args);
                    }
                });

Type returnType = method.getGenericReturnType();
            if (method.getReturnType() == Single.class) {
            } else {
                throw new IllegalArgumentException("you must return a type == Single.class");
            }
            if (returnType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) returnType)
                        .getActualTypeArguments();
                if (actualTypeArguments.length == 1) {
                    mReturnType = actualTypeArguments[0];
                } else {
                    throw new IllegalArgumentException();
                }
            }






        MethodHandler(Method method) {
            if (JTApi.get().isDebug()) {
                Log.e("MethodHandler", "MethodHandler-method " + method.getName());
            }
            Type returnType = method.getGenericReturnType();
            if (method.getReturnType() == Single.class) {
            } else {
                throw new IllegalArgumentException("you must return a type == Single.class");
            }
            if (returnType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) returnType)
                        .getActualTypeArguments();
                if (actualTypeArguments.length == 1) {
                    mReturnType = actualTypeArguments[0];
                } else {
                    throw new IllegalArgumentException();
                }
            }
            Annotation[] methodAnnotation = method.getAnnotations();
            for (Annotation annotation : methodAnnotation) {
                if (annotation instanceof Url) {
                    mUrl = ((Url) annotation).value();
                } else if (annotation instanceof Security) {
                    security = ((Security) annotation).value();
                }
            }

            Annotation[][] parameterAnnotations = method.getParameterAnnotations();
            if (parameterAnnotations == null || parameterAnnotations.length == 0) {
                return;
            }
            for (Annotation[] annotations : parameterAnnotations) {
                if (annotations != null && annotations.length != 0) {
                    for (Annotation aMethodAnnotation : annotations) {
                        if (aMethodAnnotation instanceof Field) {
                            Field field = (Field) aMethodAnnotation;
                            requestActionList.add(new FieldRequestAction(field.value()));
                            break;

                        } else if (aMethodAnnotation instanceof FieldMap) {
                            requestActionList.add(new FieldMapRequestAction());
                        } else if (aMethodAnnotation instanceof Path) {
                            Path path = (Path) aMethodAnnotation;
                            requestActionList.add(new PathRequestAction(path.value()));
                        }
                    }
                }
            }
        }
        public Object invoke(Object... objects) {
            JtRequest.Builder builder = JTHttpClient.create().url(mUrl);
            if (objects != null && objects.length > 0) {
                if (objects.length != requestActionList.size()) {
                    throw new NullPointerException("url: " + mUrl + "\nrequestActionList length is "
                            + "not equals objects length");
                }
                for (int i = 0; i < requestActionList.size(); i++) {
                    requestActionList.get(i).perform(builder, objects[i]);
                }
            }

            return builder.setSecLevel(security).build().post(mReturnType);

        }

//execute
builder.setSecLevel(security).build().post(mReturnType);

目录
相关文章
|
4月前
|
前端开发 Java 应用服务中间件
SpringBoot异步接口怎么实现?
### 前言 Servlet 3.0以前,每个HTTP请求由单一线程全程处理;3.0版本引入异步处理,允许提前释放容器线程,提升系统吞吐量。
|
5月前
|
XML Java 数据格式
Acitiviti7基本使用- 2、Servcie服务接口介绍
Acitiviti7基本使用- 2、Servcie服务接口介绍
|
6月前
|
Java Spring
SpringBoot+async异步调用接口以及几个任务同时完成和异步接口实现和调用
SpringBoot+async异步调用接口以及几个任务同时完成和异步接口实现和调用
132 0
|
设计模式 JSON 缓存
Android体系课学习 之 网络请求库Retrofit使用方式(附Demo)
- 网络请求在我们开发中起的很大比重,有一个好的网络框架可以节省我们的开发工作量,也可以避免一些在开发中不该出现的bug - Retrofit是一个轻量级框架,基于OkHttp的一个Restful框架
|
Java API 网络架构
SpringBoot从0到实战2:ApiPost请求工具的引入与简单接口实现
引入开发必备神器ApiPost工具,一款http请求工具,并实现SpringWeb的简单接口实现。
SpringBoot从0到实战2:ApiPost请求工具的引入与简单接口实现
|
负载均衡 开发者 微服务
技术点-SpringCloud 调用接口流程 | 学习笔记
快速学习技术点-SpringCloud 调用接口流程
技术点-SpringCloud 调用接口流程 | 学习笔记
|
JSON API 开发者
Retrofit笔记 | 简析官方API文档(结合示例代码)
Retrofit笔记 | 简析官方API文档(结合示例代码)
|
JSON Java 数据格式
Retrofit笔记 | 基本使用步骤
Retrofit笔记 | 基本使用步骤
|
JSON Android开发 数据格式
RxJava+Retrofit示例 ,Retrofit 注解学习
RxJava+Retrofit示例 ,Retrofit 注解学习
167 0