Android架构设计02-网络请求框架（一）

最新推荐文章于 2024-06-22 22:42:00 发布

小黄鸡

最新推荐文章于 2024-06-22 22:42:00 发布

阅读量1.2k

点赞数

分类专栏： Android开源框架文章标签： android 架构设计框架网络数据

本文链接：https://blog.csdn.net/SImple_a/article/details/70217246

版权

Android开源框架专栏收录该内容

11 篇文章 0 订阅

订阅专栏

这篇博文是介绍一个类似Volley的网络请求框架。因为整个框架较大。所以要分多篇完成。这一篇介绍通过网络请求得到json数据的部分。后续还有下载部分。

通过发送http请求得到数据。这么简单的问题为什么还要搭建框架呢？
这样的问题如果举例子有点麻烦。我直接说框架的优点。

方便扩展。
支持高并发。

会用到的相关知识点：

泛型
阻塞队列
单例模式
策略模式
生产者消费者模式

类图
这里写图片描述

这么移动乱七八糟的类和接口放到一块让人有点摸不着头绪。但是我把主线用编号给串联起来。抓住了主线就好看多了。
类图中的序号和下文的顺序是一致的。

1 客户端调用框架

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void request(View view){
        String url = "http://api.jisuapi.com/news/get";

        NewsParam param = new NewsParam();
        param.setChannel("头条");
        param.setStart(0);
        param.setNum(10);
        param.setAppkey("89c11311ee47203d");

        Volley.sendRequest(param, url, NewsEntity.class, new IDataListener() {
            @Override
            public void onSuc(Object entity) {
                Log.i("TAG",entity.toString());
            }

            @Override
            public void onFail() {
                Log.i("TAG","请求失败");
            }
        });
    }

}

MainActivity这个类作为框架的客户端。调用时需要用Volley.sendRequest()方法。这个方法的各个参数含义如下。

     /**
     *
     * @param requestInfo  请求参数
     * @param url          请求地址
     * @param response     返回结果
     * @param listener     请求结束后的数据回调
     *
     * @param <T>  请求参数实体类
     * @param <M>  请求结束后得到的数据类型
     */
    public static <T,M> void sendRequest(T requestInfo, String url, Class<M> response, IDataListener listener){

也就是说，客户端只需要调用这个方法，就可以在回调的接口方法中得到数据。
这四个参数代表的含义分别是：
第一个requestInfo：代表把所有的参数封装成一个类，这个类的对象。
第二个url：网络地址。
第三个response：请求的得到的结果的实体类。
第四个listener：网络请求的回调接口。
对于客户端来说，只需要关心这四个参数。其他的细节都不需要考虑。

2 Volley把请求相关的参数封装到RequestHolder对象中

public static <T,M> void sendRequest(T requestInfo, String url, Class<M> response, IDataListener listener){
        RequestHolder<T> requestHolder = new RequestHolder<>();

        //给requestHolder赋值
        requestHolder.setUrl(url);
        requestHolder.setRequestInfo(requestInfo);
        requestHolder.setHttpService(new JsonHttpService());
        requestHolder.setHttpListener(new JsonDealListener<>(response,listener));

        //通过requestHolder构造HttpTask对象
        HttpTask<T> httpTask = new HttpTask<>(requestHolder);

        try{
            //通过线程池管理类来执行Runnable对象
            ThreadPoolManager.getInstance().execute(new FutureTask<Object>(httpTask,null));
        }catch (Exception e){
            listener.onFail();
        }

    }

2 这条线就是把请求和回调相关的参数封装给requestHolder对象.
顺便贴一下RequestHolder代码。

public class RequestHolder<T> {

    //执行网络请求
   private IHttpService httpService;

   //网络请求结束后的回调
   private IHttpListener httpListener;

   //网络请求参数
   private T requestInfo;

   //网络地址
   private String url;

    public IHttpService getHttpService() {
        return httpService;
    }

    public void setHttpService(IHttpService httpService) {
        this.httpService = httpService;
    }

    public IHttpListener getHttpListener() {
        return httpListener;
    }

    public void setHttpListener(IHttpListener httpListener) {
        this.httpListener = httpListener;
    }

    public T getRequestInfo() {
        return requestInfo;
    }

    public void setRequestInfo(T requestInfo) {
        this.requestInfo = requestInfo;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }
}

从这个类中可以看出这个类就是保存了一些请求相关的参数。

3 通过HttpTask用RequestHolder构建JsonHttpService

结合这一行代码可以看出HttpTask就是通过requestHolder用来构建JsonHttpService对象

 //通过requestHolder构造HttpTask对象
        HttpTask<T> httpTask = new HttpTask<>(requestHolder);

下面是HttpTask的完整代码

public class HttpTask<T> implements Runnable {

    private IHttpService httpService;

    public HttpTask(RequestHolder<T> requestHolder) {
        httpService = requestHolder.getHttpService();

        T request = requestHolder.getRequestInfo();

        httpService.setHttpListener(requestHolder.getHttpListener());
        httpService.setUrl(requestHolder.getUrl());
        List<NameValuePair> nameValuePairs = paramEntityToNameValuePair(request);
        try {

            httpService.setParams(nameValuePairs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    //将请求参数的实体类转成键值对的请求参数
    private List<NameValuePair> paramEntityToNameValuePair(T request) {
        List<NameValuePair> nameVauePairs = new ArrayList<>();
        Class<T> tClass = (Class<T>) request.getClass();

        Field[] fields = tClass.getFields();

        for (Field filed : fields) {
            filed.setAccessible(true);
        }
        for (Field field : fields) {
            try {
                if(field.get(request)!=null){
                    nameVauePairs.add(new BasicNameValuePair(field.getName(), field.get(request).toString()));
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }

        return  nameVauePairs;
    }

    @Override
    public void run() {
        httpService.execute();
    }
}

从这个类中可以看出，在构造方法中把requestHolder携带的参数来构建httpService对象，并通过反射来把请求参数的实体类转成 List< NameValuePair>格式的请求参数。这个类实现了Runnalbe接口。而在run()方法中仅有这一行代码

 @Override
    public void run() {
        httpService.execute();
    }

也就是说，线程真正执行的是httpService中的方法。

4 取出RequestHolder中的值

 httpService = requestHolder.getHttpService();

        T request = requestHolder.getRequestInfo();

        httpService.setHttpListener(requestHolder.getHttpListener());
        httpService.setUrl(requestHolder.getUrl());
        List<NameValuePair> nameValuePairs = paramEntityToNameValuePair(request);
        try {

            httpService.setParams(nameValuePairs);
        } catch (Exception e) {
            e.printStackTrace();
        }

5 把RequestHolder中的值赋给httpService
代码同4
6 把Runnable任务添加到任务队列
在Volley类中通过

 try{
            //通过线程池管理类来执行Runnable对象
            ThreadPoolManager.getInstance().execute(new FutureTask<Object>(httpTask,null));
        }catch (Exception e){
            listener.onFail();
        }

来把HttpTask作为一个Runnable对象添加到ThreadPoolManager的任务队列中。

 //阻塞的任务队列
    private LinkedBlockingDeque<Future<?>> taskQueue = new LinkedBlockingDeque<>();

 //添加任务到任务队列
    public <T> void execute(FutureTask<T> futureTask){
        try {
            taskQueue.put(futureTask);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

在看ThreadPoolManager的完整代码

public class ThreadPoolManager {

    //单例
    private static ThreadPoolManager instance = new ThreadPoolManager();

    //阻塞的任务队列
    private LinkedBlockingDeque<Future<?>> taskQueue = new LinkedBlockingDeque<>();

    //线程池
    private ThreadPoolExecutor threadPoolExecutor;

    //获取单例
    public static ThreadPoolManager getInstance(){
        return instance;
    }

    //线程满了并且处理队列也满了，此时交给此handler来处理
    private RejectedExecutionHandler handler = new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            try {
                taskQueue.put(new FutureTask<Object>(r,null));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };

    private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            while(true){
                FutureTask futureTask = null;

                try {
                    // 如果taskQueue.take取出的任务个数为0 线程将会阻塞不往下执行
                    futureTask = (FutureTask) taskQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(futureTask!=null){
                    threadPoolExecutor.execute(futureTask);
                }
            }
        }
    };

    private ThreadPoolManager(){
        /**
         * corePoolSize     核心线程数
         * maximumPoolSize  最大线程数量
         * keepAliveTime    当线程数量超过核心线程数的时候，非核心线程数空闲时等待死亡的时间
         * unit             keepAliveTime的时间单位
         * workQueue        未执行的任务队列
         * handler          线程满了并且处理队列也满了，此时交给此handler来处理
         */
        threadPoolExecutor = new ThreadPoolExecutor(4,10,10, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4),handler);
        threadPoolExecutor.execute(runnable);
    }

    //添加任务到任务队列
    public <T> void execute(FutureTask<T> futureTask){
        try {
            taskQueue.put(futureTask);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

ThreadPoolManager 创建了静态的单例对象。

//单例
    private static ThreadPoolManager instance = new ThreadPoolManager();

 //获取单例
    public static ThreadPoolManager getInstance(){
        return instance;
    }

可以看出在调用getInstance()方法获取单例时，会调用该类的构造方法。

 private ThreadPoolManager(){
        /**
         * corePoolSize     核心线程数
         * maximumPoolSize  最大线程数量
         * keepAliveTime    当线程数量超过核心线程数的时候，非核心线程数空闲时等待死亡的时间
         * unit             keepAliveTime的时间单位
         * workQueue        未执行的任务队列
         * handler          线程满了并且处理队列也满了，此时交给此handler来处理
         */
        threadPoolExecutor = new ThreadPoolExecutor(4,10,10, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4),handler);
        threadPoolExecutor.execute(runnable);
    }

在构造方法中初始化了线程池，并执行runable任务。

 private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            while(true){
                FutureTask futureTask = null;
                Log.i("ThreadPoolManager",taskQueue.size()+"");
                try {
                    // 如果taskQueue.take取出的任务个数为0 线程将会阻塞不往下执行
                    futureTask = (FutureTask) taskQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(futureTask!=null){
                    threadPoolExecutor.execute(futureTask);
                }
            }
        }
    };

runnable中，用死循环来不断取出taskQueue 中的任务对象。

 //阻塞的任务队列
    private LinkedBlockingDeque<Future<?>> taskQueue = new LinkedBlockingDeque<>();

LinkedBlockingDeque简单来说就是一个FIFO firt-in-firt-out先进先出的阻塞队列。给予LinkedList实现。当LinkedBlockingDeque中的的对象个数为0时，线程阻塞直到LinkedBlockingDeque中添加新的对象。

7 开始执行网络请求
之前提到过，
在Volley中把相关的请求参数封装到RequestHolder中，
再通过实例化HttpTask来把RequestHolder的属性赋值给IHttpService.
而在Volley中已经实例化了IHttpService对象

  requestHolder.setHttpService(new JsonHttpService());

所以HttpTask中的httpService对象就是JsonHttpService。
在HttpTask有这么一行是关键

 @Override
    public void run() {
        httpService.execute();
    }

也就是说ThreadPoolManager中线程池真执行的是HttpTask对象，而HttpTask对象的run方法是调用了JsonHttpService中的execute方法。

@Override
    public void execute() {
        httpPost = new HttpPost(url);

        try {
            httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs,"UTF-8"));
            httpClient.execute(httpPost, httpResponseHandler);
        } catch (Exception e) {
            e.printStackTrace();
            listener.onFail();
        }
    }

可以看出，在execute方法中，通过httpClient.execute开始发送请求。
下面是JsonHttpService完整的代码

public class JsonHttpService implements IHttpService {
    private IHttpListener listener;

    private HttpClient httpClient = new DefaultHttpClient();
    private HttpPost httpPost;
    private String url;

    List<NameValuePair> nameValuePairs;

    private HttpResponseHandler httpResponseHandler = new HttpResponseHandler();

    //网络回调
    private class HttpResponseHandler extends BasicResponseHandler {
        @Override
        public String handleResponse(HttpResponse response) throws ClientProtocolException {
            int code = response.getStatusLine().getStatusCode();
            if (code == 200) {
                listener.onSuccess(response.getEntity());
            } else {
                listener.onFail();
            }
            return null;
        }
    }


    @Override
    public void setUrl(String url) {
        this.url = url;
    }

    @Override
    public void execute() {
        httpPost = new HttpPost(url);

        try {
            httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs,"UTF-8"));
            httpClient.execute(httpPost, httpResponseHandler);
        } catch (Exception e) {
            e.printStackTrace();
            listener.onFail();
        }
    }


    @Override
    public void setHttpListener(IHttpListener listener) {
        this.listener = listener;
    }

    @Override
    public void setParams(List<NameValuePair> nameValuePairList) {
        this.nameValuePairs = nameValuePairList;
    }

之前已经说过，JsonHttpService的相关参数已经在HttpTask中通过RequestHolder赋值。所以当开始执行JsonHttpService的execute方法后，就会执行下面的网络回调。

 //网络回调
    private class HttpResponseHandler extends BasicResponseHandler {
        @Override
        public String handleResponse(HttpResponse response) throws ClientProtocolException {
            int code = response.getStatusLine().getStatusCode();
            if (code == 200) {
                listener.onSuccess(response.getEntity());
            } else {
                listener.onFail();
            }
            return null;
        }
    }

8 获取数据解析数据
网络请求成功后，上面的回调即会回调JsonDealListener中的onSuccess方法。
从Volley中的

requestHolder.setHttpListener(new JsonDealListener<>(response,listener));

和HttpTask中的

 httpService.setHttpListener(requestHolder.getHttpListener());

可以得出，JsonHttpService中保存的IHttpListener即为JsonDealListener。
下面是JsonDealListener的onSuccess方法。

 @Override
    public void onSuccess(HttpEntity httpEntity) {
        InputStream inputStream = null;

        try {
            inputStream = httpEntity.getContent();
            String content = getContent(inputStream);
            final M m = JSON.parseObject(content, response);

            handler.post(new Runnable() {
                @Override
                public void run() {
                    dataListener.onSuc(m);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
            dataListener.onFail();
        }
    }

这个方法种中把获取的响应实体通过fastJson的工具解析为对应的实体。
下面是完整代码

public class JsonDealListener<M> implements IHttpListener {

    //返回结果的类型
    private Class<M> response;

    //数据解析后 返回给调用层
    private IDataListener<M> dataListener;

    //主线程中的handler
    private Handler handler = new Handler(Looper.getMainLooper());

    public JsonDealListener(Class<M> response, IDataListener<M> listener) {
        this.response = response;
        this.dataListener = listener;
    }

    @Override
    public void onSuccess(HttpEntity httpEntity) {
        InputStream inputStream = null;

        try {
            inputStream = httpEntity.getContent();
            String content = getContent(inputStream);
            final M m = JSON.parseObject(content, response);

            handler.post(new Runnable() {
                @Override
                public void run() {
                    dataListener.onSuc(m);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
            dataListener.onFail();
        }
    }

    //将流转成字符串
    private String getContent(InputStream inputStream) {
        String content = null;
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

        StringBuilder stringBuilder = new StringBuilder();
        String line = null;


        try {
            while ((line = bufferedReader.readLine()) != null) {
                stringBuilder.append(line + "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
            dataListener.onFail();
        } finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return stringBuilder.toString();
    }

    @Override
    public void onFail() {
        dataListener.onFail();
    }
}

9 把解析的数据回调给客户端
在JsonDealListener中有这一行

  //主线程中的handler
    private Handler handler = new Handler(Looper.getMainLooper());

可以看出hander获取的Looper对象是从主线程中获取的。那么也就是说handler处理的Runable将会在主线程中执行。也就是说在JsonDealListener的onSuccess方法中的

dataListener.onSuc(m);

这一行将会执行在主线程。
这一行最终会回调到客户端

 Volley.sendRequest(param, url, NewsEntity.class, new IDataListener() {
            @Override
            public void onSuc(Object entity) {
                Log.i("TAG",entity.toString());
            }

            @Override
            public void onFail() {
                Log.i("TAG","请求失败");
            }
        });

至此整个流程已结束。
下面是对整个框架核心的总结
（1）框架中很好的体现了面向接口编程，如IHttpService,IHttpListener.相应的实现类为JsonHttpService,JsonDealListener。如果以后执行其他请求也可以通过这个接口进行扩展。比如执行下载请求，也会遵循下面的模板方法。

public interface IHttpService {

    //设置网络请求地址
    void setUrl(String url);

    //执行网络请求
    void execute();

    //设置网络请求回调
    void setHttpListener(IHttpListener listener);

    //设置请求参数
    void setParams(List<NameValuePair> nameValuePairList);;
}

（2）在ThreadPoolManager中，用了生产者和消费者模式。每次执行一个请求，将会把要执行的任务添加到阻塞队列中（生产者），然后开启线程池轮询此队列并取出任务进行处理（消费者）。当队列中的任务数量为0时将该线程将会阻塞。
（3）对于高并发做了很好的措施。首先看这段代码

/**
         * corePoolSize     核心线程数
         * maximumPoolSize  最大线程数量
         * keepAliveTime    当线程数量超过核心线程数的时候，非核心线程数空闲时等待死亡的时间
         * unit             keepAliveTime的时间单位
         * workQueue        未执行的任务队列
         * handler          线程满了并且处理队列也满了，此时交给此handler来处理
         */
        threadPoolExecutor = new ThreadPoolExecutor(4,10,10, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4),handler);

从这段代码中的第五个参数workQueue。查看该参数的源码可以看出，当线程池开始执行任务时，并不会立即执行而是先添加到任务队列中。然后核心线程会先处理任务。当任务足够多后，将会开启非核心线程。当非核心线程也到最大数量时，将会交给handler处理。将此任务重新添加到任务队列。

//线程满了并且处理队列也满了，此时交给此handler来处理
    private RejectedExecutionHandler handler = new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            try {
                taskQueue.put(new FutureTask<Object>(r,null));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };

点击下载源码

小黄鸡

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Android架构设计02-网络请求框架（一）

这篇博文是介绍一个类似Volley的网络请求框架。因为整个框架较大。所以要分多篇完成。这一篇介绍通过网络请求得到json数据的部分。后续还有下载部分。通过发送http请求得到数据。这么简单的问题为什么还要搭建框架呢？这样的问题如果举例子有点麻烦。我直接说框架的优点。方便扩展。支持高并发。会用到的相关知识点：泛型阻塞队列单例模式策略模式生产者消费者模式类图
复制链接

扫一扫

专栏目录