自定义网络框架之json文本请求

自定义网络框架开发，功能：
支持请求： json文本类型音频，视频，图片类型，批量下载，上传
请求各种数据时，调用层不关心上船参数分装，如（request.addParameters(key,value)）,直接将参数分装成对象传给狂框架，获取数据后，调用层不关心json数据解析
回调时，调用层只需知道传入的json对应的响应类。
回调响应结果发生在主线程（线程切换）
对下载，上传扩展
支持高并发请求，请求队列依次获取，可以设置最大并发数，设置先请求先执行

涉及的知识点：

• 泛型
• 请求队列
• 阻塞队列
• 线程池拒绝策略

设计模式：

• 模板方法模式
• 单例模式
• 策略模式
• 生产者消费者模式
  使用的jar包：
• fastjson（com.alibaba:fastjson:1.2.23）
• httpcore(httpcomponents-httpcore:httpcore:4.0-alpha6)

---

---

下面为json文本请求主要代码和思路

---

首先设计科三个接口分别为请求网络（IHttpService）网络访问结果回调（IHttpListener）和回调结果给调用层的接口（IDataListener）

public interface IDataListener <M>{    //回调结果给调用层    void onSuccess(M m);    void onFail();}public interface IHttpListener {    //网络访问处理结果回调    void onSuccess(HttpEntity httpEntity);    void onFail();}public interface IHttpService {    /*    * 设置url    * */    void setUrl(String url);    //执行获取网络    void execute();    //设置处理接口    void setHttpListener(IHttpListener httpListener);    //设置请求参数    void setRequestParameter( byte[] requestParameter);}

然后主要是接口的实现
IHttpService接口的实现JsonHttpService，主要利用HttpPost（引入的jar包）完成数据请求，并把请求成功的数据传递给IHttpListener的实现类JsonDealListener

public class JsonHttpService implements IHttpService {    private IHttpListener httpListener;    private HttpClient httpClient=new DefaultHttpClient();    private HttpPost httpPost;    private String url;    private byte[] requestParameter;    private HttpRespnceHandler httpRespnceHandler=new HttpRespnceHandler();    @Override    public void setUrl(String url) {        this.url=url;    }    @Override    public void execute() {        httpPost=new HttpPost(url);        ByteArrayEntity byteArrayEntity=new ByteArrayEntity(requestParameter);        httpPost.setEntity(byteArrayEntity);        try{            httpClient.execute(httpPost,httpRespnceHandler);        }catch (IOException e){            httpListener.onFail();        }    }    @Override    public void setHttpListener(IHttpListener httpListener) {        this.httpListener=httpListener;    }    @Override    public void setRequestParameter(byte[] requestParameter) {        this.requestParameter=requestParameter;    }    private class HttpRespnceHandler extends BasicResponseHandler {        @Override        public String handleResponse(HttpResponse response)throws ClientProtocolException {           //响应码            int code=response.getStatusLine().getStatusCode();            //200响应成功,传递请求成功的返回数据            if (code==200){                httpListener.onSuccess(response.getEntity());            }            else {                httpListener.onFail();            }            return null;        }    }}

IHttpListener的实现类JsonDealListener主要完成将起请求成功的结果传递给调用层（IDataListener的实现者）

public class JsonDealListener<M> implements IHttpListener {    private Class<M> responceClass;    private IDataListener<M> dataListener;    /**     * 获取主线程的handler通过handler     *切换至主线程     * */    Handler handler=new Handler(Looper.getMainLooper());    public JsonDealListener(Class<M> responceClass, IDataListener<M> dataListener){        this.responceClass=responceClass;        this.dataListener=dataListener;    }    @Override    public void onSuccess(HttpEntity httpEntity) {        InputStream inputStream=null;        try {            inputStream = httpEntity.getContent();            String content = getContent(inputStream);            final M responce = JSON.parseObject(content, responceClass);            handler.post(new Runnable() {                @Override                public void run() {                    dataListener.onSuccess(responce);                }            });        }catch (IOException e){            dataListener.onFail();        }        }    @Override    public void onFail() {        dataListener.onFail();    }    private String getContent(InputStream inputStream) {        String content = null;        try {            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));            StringBuilder sb = new StringBuilder();            String line = null;            try {                while ((line = reader.readLine()) != null) {                    sb.append(line + "\n");                }            } catch (IOException e) {                System.out.println("Error=" + e.toString());                dataListener.onFail();            } finally {                try {                    inputStream.close();                } catch (IOException e) {                    System.out.println("Error=" + e.toString());                }            }            return sb.toString();        }catch (Exception e){            e.printStackTrace();            dataListener.onFail();        }        return content;    }}

我们将监听，请求服务，url等封装在ReqestHolder类

public class RequestHolder<T> {    //执行下载类    private IHttpService httpService;    //获取数据回调结果的类    private IHttpListener httpListener;    //i请求参数对应的实体    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;    }}

我们将封装的实体类RequestHolder传递给ThreadPoolManager，ThreadPoolManager是我们对请求的优化，主要利用了线程池（ThreadPoolExecutor）和阻塞队列（LinkedBlockingQueue）来保存我们开启的线程，当阻塞队列没有任务时，线程池会阻塞等待，直到阻塞队列填充任务

public class ThreadPoolManager {    private static final String TAG="gjh";    private static ThreadPoolManager instance=new ThreadPoolManager();    //生产者消费者模式    private LinkedBlockingQueue<Future<?>> taskQueue=new LinkedBlockingQueue<>();    private ThreadPoolExecutor threadPoolExecutor;    public static ThreadPoolManager getInstance(){        return instance;    }    private ThreadPoolManager(){        /*        * 参数一核心线程数        * 二 最大线程数        * 三 完成任务后空闲时间        * 四 空闲时间单位秒        * 五 阻塞队列        * 六 拒绝策略        * */        threadPoolExecutor=new ThreadPoolExecutor(4,10,10, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4),handler);        threadPoolExecutor.execute(runnable);    }    private Runnable runnable=new Runnable() {        @Override        public void run() {            while(true){                FutureTask futureTask=null;                try{                //阻塞式函数                    Log.i(TAG,"等待队列"+taskQueue.size());                    //取出任务后如果线程池已满将会执行拒绝策略从新放入taskQueue队列                    futureTask= (FutureTask) taskQueue.take();                    } catch (InterruptedException e) {                    e.printStackTrace();                }                if (futureTask!=null){                    threadPoolExecutor.execute(futureTask);                }                Log.i(TAG,"线程池大小      "+threadPoolExecutor.getPoolSize());            }        }    };    public <T> void execte(FutureTask<T> futureTask) throws InterruptedException {        taskQueue.put(futureTask);    }    private RejectedExecutionHandler handler=new RejectedExecutionHandler(){        @Override        public void rejectedExecution(Runnable runnable, ThreadPoolExecutor threadPoolExecutor) {            try {                taskQueue.put(new FutureTask<Object>(runnable,null));            } catch (InterruptedException e) {                e.printStackTrace();            }        }    };}

然后我们写了Vooley类暴露出外部调用的方法，隐藏了具体的实现

public class Volley {    //暴露给调用层    public static <T,M> void sendRequest(T requestInfo, String url,                                         Class<M> response, IDataListener dataListener){        RequestHolder<T> requestHolder=new RequestHolder<>();        requestHolder.setUrl(url);        IHttpService httpService=new JsonHttpService();        requestHolder.setRequestInfo(requestInfo);        IHttpListener httpListener=new JsonDealListener<>(response,dataListener);        requestHolder.setHttpListener(httpListener);        requestHolder.setHttpService(httpService);        HttpTask<T> httpTask=new HttpTask<>(requestHolder);        try {            ThreadPoolManager.getInstance().execte(new FutureTask<Object>(httpTask,null));        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

测试类：

public class LoginResponse {    private int code;    private String user_id;    private String time;    private String name;    public int getCode() {        return code;    }    public void setCode(int code) {        this.code = code;    }    public String getUser_id() {        return user_id;    }    public void setUser_id(String user_id) {        this.user_id = user_id;    }    public String getTime() {        return time;    }    public void setTime(String time) {        this.time = time;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}public class User {    private String name;    private String password;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }}public class MainActivity extends AppCompatActivity {    public static final String url="";    private static final String Tag="gjh";    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);    }    public void login (View view){        User user=new User();        user.setName("dd");        user.setPassword("sss");        for (int i=0;i<50;i++){            Volley.sendRequest(user, url, LoginResponse.class, new IDataListener<LoginResponse>() {                @Override                public void onSuccess(LoginResponse loginResponse) {                    Log.i(Tag,loginResponse.toString());                }                @Override                public void onFail() {                    Log.i(Tag,"请求失败");                }            });        }    }}