android框架之Retrofit的使用

Retrofit:Square提供的开源产品，为Android平台的应用提供一个类型安全的REST客户端。
REST客户端：REST指一组架构约束条件和原则，满足约束条件和原则的应用程序设计。
架构，软件体系结构分为三部分：构建，用于描述计算机；连接器，用于描述构建的链接部分；配置将构建和连接器组成有机整体。
web基本技术：
URI（统一资源标示符）HTTP（超文本传输协议）（post、get、put、delete）
Hypertext。
1、每个资源都应该有唯一的一个标识
2、使用标准的方法更改资源的状态
3、request和response的自描述
4、资源多重表述
5、无状态服务

下面开始将如何使用Retrofit框架来请求网络数据。
首先，需要导入两个包：
方法：在build.gradle文件中加入如下

compile 'com.squareup.retrofit2:retrofit:2.1.0'
 compile 'com.squareup.retrofit2:converter-gson:2.1.0'

然后编写接口代码，用于解决请求网络地址问题：
以http://m2.qiushibaike.com/article/list/text?page=1
为例。

public interface NetConfig {
    String BASE_URL = "http://m2.qiushibaike.com";


    String URL = "http://www.shougongke.com/index.php?m=Mobq_data&a=topic&versions=1.2.1&page=1";
    /*
    本地内网的地址
     */
    String POST_URL = "http://10.0.168.230:8080/zhangzhang/login";
}

然后采用Gson解析，得到modle.
接着就要在Activity中编写代码了。

1，声明两个私有变量

private Retrofit mRetrofit;
    private NetInterFace netInterFace;

  //初始化Retrofit
        mRetrofit = new Retrofit.Builder().baseUrl(NetConfig.BASE_URL).addConverterFactory(GsonConverterFactory.create()).build();

        netInterFace = mRetrofit.create(NetInterFace.class);
        Call<ResponseBody> netData = netInterFace.getNetData();
        netData.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {

                        if(response.isSuccessful()) {
                            try {
                                String string = response.body().string();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {

            }
        });

    }

    public void onClick(View view) {
        if(view!=null) {
            switch (view.getId()) {
                case R.id.bt_main_get_auto :
                Call<Modle>  netDataWithModle=netInterFace.getNetDataWithModle();
                    netDataWithModle.enqueue(new Callback<Modle>() {
                        @Override
                        public void onResponse(Call<Modle> call, Response<Modle> response) {
                            Modle body = response.body();
                            Log.e("tag",body.toString());
                        }

                        @Override
                        public void onFailure(Call<Modle> call, Throwable t) {

                        }
                    });
                    break;
                case R.id.bt_main_get__params:
                    Call<Modle> netDataWithPage = netInterFace.getNetDataWithPage("1");
                    netDataWithPage.enqueue(new Callback<Modle>() {
                        @Override
                        public void onResponse(Call<Modle> call, Response<Modle> response) {
                            Modle body = response.body();
                            Log.e("tag",body.toString());
                        }

                        @Override
                        public void onFailure(Call<Modle> call, Throwable t) {

                        }
                    });
                    break;
                case R.id.bt_main_get__paramses:
                    Map map=new HashMap();
                    map.put("page","2");
                   // map.put("count","3");
                    Call<Modle> netDataWithParams = netInterFace.getNetDataWithParams(map);
                    netDataWithParams.enqueue(new Callback<Modle>() {
                        @Override
                        public void onResponse(Call<Modle> call, Response<Modle> response) {
                            if(response.isSuccessful()) {
                                Modle body = response.body();
                                Log.e("TAG", "model"+body.toString());
                            }
                        }

                        @Override
                        public void onFailure(Call<Modle> call, Throwable t) {

                        }
                    });
                    break;

                //点击发送Get请求(动态替换路径)
                case R.id.bt_main_get__path:
                    Call<ResponseBody> pathCall = netInterFace.getNetDataWithPath("image");
                    pathCall.enqueue(new Callback<ResponseBody>() {
                        @Override
                        public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                            if(response.isSuccessful()) {
                                try {
                                    Log.e("tag","body"+response.body().string());
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        }

                        @Override
                        public void onFailure(Call<ResponseBody> call, Throwable t) {

                        }
                    });
                    break;


                case R.id.bt_main_get__pathAndParams:
                    Map map1=new HashMap();
                    map1.put("page","1");
                    Call<ResponseBody> pathParamsCall = netInterFace.getNetDataWithPathParams("text", map1);
                                pathParamsCall.enqueue(new Callback<ResponseBody>() {
                                    @Override
                                    public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                                        if(response.isSuccessful()) {
                                            try {
                                                Log.e("TAG", "body"+response.body().string());
                                            } catch (IOException e) {
                                                e.printStackTrace();
                                            }
                                        }
                                    }

                                    @Override
                                    public void onFailure(Call<ResponseBody> call, Throwable t) {

                                    }
                                });
                    break;




                case R.id.bt_main_get__url:
                    Call<ResponseBody> netDataWithUrl = netInterFace.getNetDataWithUrl(NetConfig.URL);
                    netDataWithUrl.enqueue(new Callback<ResponseBody>() {
                        @Override
                        public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                            if(response.isSuccessful()) {
                                try {
                                    Log.e("TAG", "body"+response.body().string());
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        }

                        @Override
                        public void onFailure(Call<ResponseBody> call, Throwable t) {

                        }
                    });
                    break;
                case R.id.bt_main_post__param:
                    Call<ResponseBody> responseBodyCall = netInterFace.postNetDataWithParam(NetConfig.POST_URL, "123", "123");
                    responseBodyCall.enqueue(new Callback<ResponseBody>() {
                        @Override
                        public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                            if(response.isSuccessful()) {
                                try {
                                    Log.e("TAG", ""+response.body().string());
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        }

                        @Override
                        public void onFailure(Call<ResponseBody> call, Throwable t) {

                        }
                    });

                    break;
                case R.id.bt_main_post__exercise:


                    break;
            }
        }
    }