王学岗Retrofit初探(一)——用户名和密码登录的实现



我们的服务端是一个很简单的登录密码：输入用户名密码实现登录功能；当然这个功能很简单，我们看下如何使用Retrofit实现：
我在代码里已经注释的很详细了，这里就不多做讲解了：
先看我们的LoginService接口，有四个方法，分别实现post和get登录，同步请求和异步请求都有

package com.tz.architect.retrofit.simple3.inter;

import java.util.Map;

import retrofit2.Call;
import retrofit2.http.Field;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.GET;
import retrofit2.http.POST;
import retrofit2.http.Query;
import retrofit2.http.QueryMap;

public interface LoginService {
    /**接口名字：aa
     * @FormUrlEncoded post请求需要添加的编码
     * @POST("LoginServlet") ：post请求和请求接口(url地址的最后一个/后的字符串)
     * @Field("username")：post请求的参数名称(服务器接口参数名称)，会自动添加到参数集合
     * String uname:本地的参数名称，unname是自己定义的
     *返回值： Call<T>,T是返回的类型
     */
    @FormUrlEncoded
    @POST("LoginServlet")
    public Call<String> login(@Field("username") String uname,
            @Field("password") String password);
    /**
     *参数一个一个的传太麻烦，传两个 
     */
    @FormUrlEncoded
    @POST("LoginServlet")
    public Call<String> login(@FieldMap Map<String,String> pramsMap);
    /**
     *@Query:get请求拼接url请求参数 
     *拼接之后的url LoginServlet?username=值
     */
    @GET("LoginServlet")
    public Call<String> loginGet(@Query("username") String username,
            @Query("password") String password);

    @GET("LoginServlet")
    public Call<String> loginGet(@QueryMap Map<String,String> pramsMap);

}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

在看我们的SimpleRetrofitLogin类

package com.tz.architect.retrofit.simple3;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.scalars.ScalarsConverterFactory;
import retrofit2.http.QueryMap;
import android.os.AsyncTask;

import com.tz.architect.retrofit.simple1.SimpleSystemLogin.OnHttpResultListener;
import com.tz.architect.retrofit.simple3.inter.LoginService;

/**
 * 网络框架：Retrofit实现
 *1， 依赖了okhttp,是对okhttp的封装和改进
 *2，准备一个java接口——LoginService
 * 
 * @author Dream
 *
 */
public class SimpleRetrofitLogin {
//服务器的接口，注意这里没必要写接口
    private static String URL_SERVER = "http://192.168.2.1:8080/Dream_Architect_Retrofit_Server/";
     //post请求，同步，提交用户名和密码，使用的接口是aa
    public static void loginSync(String username, String password,
            OnHttpResultListener onHttpResultListener) {
        Map<String, String> paramMap = new HashMap<String, String>();
        paramMap.put("username", username);
        paramMap.put("password", password);
        HttpTask httpTask = new HttpTask(paramMap, onHttpResultListener);
        httpTask.execute();
    }

    public static LoginService buildRetrofit() {
        //
        Retrofit retrofit = new Retrofit.Builder().baseUrl(URL_SERVER)
                /**
                 * 格式转换器，服务器返回的数据我采用什么样的方式对它解析;
                 * 转换器有很多种，需要为其准备相应的夹包
                 * Gson(gson)
                 * Jackson 转换json
                 * Moshi     一种数据格式
                 * Protobuf   一种数据格式
                 * Wire       
                 * Simple XML(converter-simplexml)    对xml解析
                 * Scalars(converter-scalars)    解析primitives,boxed,String格式
                 */
                .addConverterFactory(ScalarsConverterFactory.create()).build();

        // loginService实际是一个代理类
        return retrofit.create(LoginService.class);
    }

    public static void executeRetrofit(Call<String> callLogin,
            final OnHttpResultListener onHttpResultListener) {
        try {
            //call既可以执行同步请求也可以执行异步请求
            callLogin.enqueue(new Callback<String>() {

                @Override
                public void onResponse(Call<String> call,
                        Response<String> response) {
                    onHttpResultListener.onHttpResult(response.body());
                }

                @Override
                public void onFailure(Call<String> call, Throwable t) {
                    onHttpResultListener.onHttpResult("登录失败!");
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 异步：采用Retrofit卡框架自带的
     *post请求 ，输入用户名和密码
     * @param username
     * @param password
     * @param onHttpResultListener
     */
    public static void loginAsync(String username, String password,
            final OnHttpResultListener onHttpResultListener) {
        // loginService实际是一个代理类,LoginService是我们定义的接口
        //LoginService loginService = retrofit.create(LoginService.class);
        LoginService loginService = buildRetrofit();
        Call<String> callLogin = loginService.login(username, password);
        executeRetrofit(callLogin, onHttpResultListener);
    }

    public static void loginGet(String username, String password,
            final OnHttpResultListener onHttpResultListener) {
        LoginService loginService = buildRetrofit();
        Call<String> callLogin = loginService.loginGet(username, password);
        executeRetrofit(callLogin, onHttpResultListener);
    }
/**
 * post请求，用Map集合传递参数
 */
    public static void loginPostField(String username, String password,
            final OnHttpResultListener onHttpResultListener) {
        // loginService实际是一个代理类
        LoginService loginService = buildRetrofit();
        Map<String, String> paramMap = new HashMap<String, String>();
        paramMap.put("username", username);
        paramMap.put("password", password);
        Call<String> callLogin = loginService.login(paramMap);
        executeRetrofit(callLogin, onHttpResultListener);
    }

    public static void loginGetQueryMap(String username, String password,
            final OnHttpResultListener onHttpResultListener) {
        // loginService实际是一个代理类
        LoginService loginService = buildRetrofit();
        Map<String, String> paramMap = new HashMap<String, String>();
        paramMap.put("username", username);
        paramMap.put("password", password);
        Call<String> callLogin = loginService.loginGet(paramMap);
        executeRetrofit(callLogin, onHttpResultListener);
    }

    static class HttpTask extends AsyncTask<Void, Void, Object> {

        private Map<String, String> paramMap;
        private OnHttpResultListener onHttpResultListener;

        public HttpTask(Map<String, String> paramMap,
                OnHttpResultListener onHttpResultListener) {
            this.paramMap = paramMap;
            this.onHttpResultListener = onHttpResultListener;
        }

        @Override
        protected Object doInBackground(Void... params) {
            //同步请求任务，post请求，提交用户名密码
            Retrofit retrofit = new Retrofit.Builder().baseUrl(URL_SERVER)
                    .addConverterFactory(ScalarsConverterFactory.create())
                    .build();
            LoginService loginService = retrofit.create(LoginService.class);
            Call<String> callLogin = loginService.login(
                    paramMap.get("username"), paramMap.get("password"));
            try {
                //返回值是string类型
                Response<String> response = callLogin.execute();
                //这里的body直接返回String类型，
                /**
                 * body源码
                 * public T body(){
                 * return body;
                 * }
                **/
                //可以看出，你指定是什么泛型，他返回什么类型
                return response.body();
            } catch (IOException e) {
                e.printStackTrace();
            }

            return null;
        }

        @Override
        protected void onPostExecute(Object result) {
            if (this.onHttpResultListener != null) {
                this.onHttpResultListener.onHttpResult(result);
            }
        }

    }

}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

该类中我自己定义了一个OnHttpResultListener 接口

    public interface OnHttpResultListener {
        public void onHttpResult(Object result);
    }
 
 
1
2
3

在main类中直接调用即可