简单实现Retrofit（替代Okhttp）
1.定义注解参数
@Documented
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface Field {
String value();
}
@Documented
@Target(METHOD)
@Retention(RUNTIME)
public @interface Get {
String value() default "";
}
@Documented
@Target(METHOD)
@Retention(RUNTIME)
public @interface Post {
String value() default "";
}
2.实现回调接口Call和Callback
MyCall .class
public interface MyCall {
//执行网络请求（同步：在当前网络）
String execute() throws Exception;
//在子线程请求网络
void enqueue(MyCallback callback);
}
MyCallback .class
/**
* 网络请求回调接口
*/
public interface MyCallback {
void onResponse( String response);
void onFailure( Exception e);
}
SystemHttpCall .class
/**
* Created by Xionghu on 2017/8/14.
* Desc: 具体的实现类发送请求
*/
public class SystemHttpCall implements MyCall {
private MyServiceMethod serviceMethod;
public SystemHttpCall(MyServiceMethod serviceMethod) {
this.serviceMethod = serviceMethod;
}
@Override
public String execute() throws Exception {
if (serviceMethod.isPost()) {
return HttpUtils.post(serviceMethod.baseUrl(), serviceMethod.getParam());
} else {
return HttpUtils.get(serviceMethod.baseUrl());
}
}
@Override
public void enqueue(MyCallback callback) {
HttpTask httpTask = new HttpTask(this, callback);
httpTask.execute();
}
public class HttpTask extends AsyncTask<Void, Void, String> {
private SystemHttpCall httpCall;
private MyCallback callback;
private HttpTask(SystemHttpCall httpCall, MyCallback callback) {
this.httpCall = httpCall;
this.callback = callback;
}
@Override
protected String doInBackground(Void... params) {
try {
return httpCall.execute();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
protected void onPostExecute(String result) {
if (this.callback != null) {
if (result != null) {
this.callback.onResponse(result);
} else {
this.callback.onFailure(new Exception("网络异常！"));
}
}
}
}
}
3.解析注解方法获取相应参数
public class MyServiceMethod {
private Builder builder;
public MyServiceMethod(Builder builder) {
this.builder = builder;
}
public boolean isPost() {
return this.builder.isPost;
}
public Map<String, Object> getParam() {
return this.builder.paramMap;
}
public String baseUrl() {
StringBuffer buffer = new StringBuffer(
this.builder.retrofit.getBaseUrl() + this.builder.relativeUrl);
if (!isPost()) {
// 如果你不是Post请求，是get请求，需要拼接参数地址
if (this.builder.paramMap != null) {
Set<String> keySet = this.builder.paramMap.keySet();
if (keySet.size() > 0) {
buffer.append("?");
}
for (String key : keySet) {
Object value = this.builder.paramMap.get(key);
buffer.append(key);
buffer.append("=");
buffer.append(value);
buffer.append("&");
}
buffer.deleteCharAt(buffer.length() - 1);
}
}
return buffer.toString();
}
static final class Builder {
final MyRetrofit retrofit;
final Method method;
final Annotation[] methodAnnotations;
final Annotation[][] parameterAnnotationsArray;
String relativeUrl;
// 参数集合
Map<String, Object> paramMap;
Object[] args;
boolean isPost;
public Builder(MyRetrofit retrofit, Method method, Object[] args) {
this.retrofit = retrofit;
this.method = method;
// 方法注解列表(相当于我们的LoginService中的: @POST和@FormUrlEncoded......)
this.methodAnnotations = method.getAnnotations();
// 方法参数注解列表(相当于我们的LoginService中的: @Field......)
this.parameterAnnotationsArray = method.getParameterAnnotations();
this.args = args;
this.paramMap = new HashMap<String, Object>();
}
public MyServiceMethod build() {
// 循环遍历方法注解列表
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
int parameterCount = parameterAnnotationsArray.length;
for (int p = 0; p < parameterCount; p++) {
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
parseParameterAnnotation(p, parameterAnnotations);
}
return new MyServiceMethod(this);
}
/**
* 解析方法注解
*
* @param annotation
*/
public void parseMethodAnnotation(Annotation annotation) {
// 首先判断注解类型(解析目的：获取接口名称,用于拼接地址)
if (annotation instanceof Get) {
this.relativeUrl = ((Get) annotation).value();
isPost = false;
} else if (annotation instanceof Post) {
this.relativeUrl = ((Post) annotation).value();
isPost = true;
}
}
/**
* 解析参数注解
*
* @param p
* @param parameterAnnotations
*/
private void parseParameterAnnotation(int p,
Annotation[] parameterAnnotations) {
// 方法参数值
Object value = args[p];
// 遍历方法参数注解
for (Annotation annotation : parameterAnnotations) {
// 首先需要判断该注解的类型
if (annotation instanceof Field) {
Field field = (Field) annotation;
// 参数的名称(接口参数名称，服务器接口规定的)
String key = field.value();
paramMap.put(key, value);
}
}
}
}
}
4.定义MyRetrofit框架
public class MyRetrofit {
// 缓存方法(为了避免重复加载方法注解，从而耗费性能)
private final Map<Method, MyServiceMethod> serviceMethodCache = new LinkedHashMap<Method, MyServiceMethod>();
public String getBaseUrl() {
return baseUrl;
}
public void setBaseUrl(String baseUrl) {
this.baseUrl = baseUrl;
}
private String baseUrl;
private MyRetrofit(String baseUrl){
this.baseUrl = baseUrl;
}
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 {
MyServiceMethod serviceMethod = loadServiceMethod(method, args);
SystemHttpCall httpCall = new SystemHttpCall(serviceMethod);
return httpCall;
}
});
}
// 第一步：解析方法（说白了解析方法注解和方法参数注解）
// 第二步：实现网络请求
protected MyServiceMethod loadServiceMethod(Method method, Object[] args) {
MyServiceMethod result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new MyServiceMethod.Builder(this, method, args)
.build();
serviceMethodCache.put(method, result);
}
}
return result;
}
public static final class Builder{
private String baseUrl;
public Builder baseUrl(String baseUrl){
this.baseUrl = baseUrl;
return this;
}
public MyRetrofit build(){
if(baseUrl == null){
throw new IllegalStateException("Base URL required.");
}
return new MyRetrofit(baseUrl);
}
}
}
5.具体实现网络请求类
定义接口方法类
public interface MyRetrofitLoginService {
@Post("user/login?platform=android&city_id=101&type=pwd&channel=baiduxi&version=3.2.0&os_version=6.0.1&device_id=866622020797175")
MyCall login(@Field("mobile") String name, @Field("password") String pwd);
}
简单封装请求工具类
public class MyRetrofitTest {
private static String URL_SERVER = "http://api.cloud.test.haocaisong.cn/v2.0/";
public static void login(String name, String pwd, final SimpleSystemLogin.OnHttpResultListener onHttpResultListener) {
MyRetrofit myRetrofit = new MyRetrofit.Builder().baseUrl(URL_SERVER).build();
MyRetrofitLoginService loginService = myRetrofit.create(MyRetrofitLoginService.class);
MyCall myCall = loginService.login(name,pwd);
myCall.enqueue(new MyCallback() {
@Override
public void onResponse(String response) {
onHttpResultListener.onHttpResult(response);
}
@Override
public void onFailure(Exception e) {
}
});
}
}
