实现一个网络框架HttpURLConnection

1.写一个接口

public interface IHttpRequest {

    void setUrl(String url);

    void  setData(byte[] data);

    void setListener(CallbackListener callbackListener);

    void execute();

}

2.实现一个线程池，去处理请求，这个是一个单例
这里有2个队列：LinkedBlockingDeque和ArrayBlockingQueue
有请求过来了，如果不能立马处理就会放到ArrayBlockingQueue里面，等待处理

public class ThreadPoolManager {
    private static ThreadPoolManager threadPoolManager = new ThreadPoolManager();

    public static ThreadPoolManager getInstance(){
        return threadPoolManager;
    }


    //3.队列去维护我们的请求
    //为了好维护我们的请求，所以整了一个队列，所有的请求都提交给服务器，服务器的压力会很大
    private LinkedBlockingDeque<Runnable> mQueue = new LinkedBlockingDeque<>();

    public void addTask(Runnable runnable){
        try {
            //将请求都添加到队列里面去
            mQueue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private ThreadPoolExecutor mThreadPoolExecutor;

    private ThreadPoolManager(){
        //4.整了一个线程池
        mThreadPoolExecutor = new ThreadPoolExecutor(3,10,15, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4),new RejectedExecutionHandler(){

            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                addTask(r);
            }
        });

        mThreadPoolExecutor.execute(coreThread);
    }

    //5.搞一个核心线程，不断的去队列拿请求，然后丢给线程池去处理
    public  Runnable coreThread = new Runnable() {
        Runnable runn =null;
        @Override
        public void run() {
            //死循环
            while (true){
                try {
                    //去队列拿请求
                    runn = mQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //交给线程池去处理
                mThreadPoolExecutor.execute(runn);
            }
        }
    };

}

6.正在进行网络请求的地方，用HttpURLConnection去实现

class JsonHTTPRequest implements IHttpRequest {
    private String url;
    private byte[] data;
    private CallbackListener mCallbackListener;

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

    @Override
    public void setData(byte[] data) {
        this.data = data;
    }

    @Override
    public void setListener(CallbackListener callbackListener) {
        this.mCallbackListener = callbackListener;
    }

    private HttpURLConnection urlConnection;

    @Override
    public void execute() {
        URL url = null;
        try {
            url = new URL(this.url);
            urlConnection = (HttpURLConnection) url.openConnection();
            urlConnection.setConnectTimeout(6000);//连接的超时时间
            urlConnection.setUseCaches(false);//不使用缓存
            urlConnection.setInstanceFollowRedirects(true);//是成员函数，仅作用于当前函数，设置这个连接是否可以被重定向
            urlConnection.setReadTimeout(3000);//响应的超时时间
            urlConnection.setDoInput(true);//设置这个连接是否可以写入数据
            urlConnection.setDoOutput(true);//设置这个连接是否可以输出数据
            urlConnection.setRequestMethod("POST");//设置请求的方式
            urlConnection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");//设置消息的类型
            urlConnection.connect();//连接，上述之前的配置必须要在connect之前完成，实际上它只是建立了一个服务器的TCP连接
            //------------使用字节流发送数据--------------
            OutputStream out = urlConnection.getOutputStream();
            BufferedOutputStream bos = new BufferedOutputStream(out);//缓冲字节流包装字节流
            bos.write(data);//把这个字节数组的数据写入缓冲区中
            bos.flush();//刷新缓冲区，发送数据
            out.close();
            bos.close();
            //------------字节流写入数据--------------------------
            if (urlConnection.getResponseCode() == HttpURLConnection.HTTP_OK) {//得到服务端的返回码是否连接成功
                InputStream inputStream = urlConnection.getInputStream();
                mCallbackListener.onSuccess(inputStream);
            } else {
                throw new RuntimeException("请求失败");
            }

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("请求失败");
        }finally {
            urlConnection.disconnect();
        }

    }
}

7.将InputStream返回来的数据转换成我们想要的对象

class JsonCallbackListener<T> implements CallbackListener {
    private Class<T> responseClass;
    private IJsonDataListener iJsonDataListener;
    private Handler mHandler = new Handler(Looper.getMainLooper());

    public JsonCallbackListener(Class<T> responseClass, IJsonDataListener iJsonDataListener) {
        this.responseClass = responseClass;
        this.iJsonDataListener = iJsonDataListener;
    }

    @Override
    public void onSuccess(InputStream inputStream) {
        String response = getContent(inputStream);
        final T clazz = JSON.parseObject(response, responseClass);
        //更新UI
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                //将数据传出去
                iJsonDataListener.onSuccess(clazz);
            }
        });
    }

    /**
     * 将字节流转换成字符串
     * @param inputStream
     * @return
     */
    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());

            } finally {

                try {

                    inputStream.close();

                } catch (IOException e) {

                    System.out.println("Error=" + e.toString());
                }
            }
            return sb.toString();

        } catch (Exception e) {
            e.printStackTrace();
        }

        return content;
    }
}

8.将数据传出去

public interface IJsonDataListener<T> {
    void onSuccess(T m);
}

9.全部封装到一起，放到一个对象里面去，队列中放一个对象是最好的

class HttpTask<T> implements Runnable {

    IHttpRequest httpRequest;

    public HttpTask(String url, T requestData, IHttpRequest httpRequest, CallbackListener listener) {
        this.httpRequest = httpRequest;
        httpRequest.setUrl(url);
        httpRequest.setListener(listener);
        String content = JSON.toJSONString(requestData);
        try {
            httpRequest.setData(content.getBytes("utf-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

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

10.封装一个方法

public class MNOkHttp {
    public static <T,M> void sendJsonRequest(T requestData,String url,Class<M> response,IJsonDataListener listener){
        IHttpRequest httpRequest = new JsonHTTPRequest();
        CallbackListener callbackListener = new JsonCallbackListener<>(response,listener);
        HttpTask httpTask = new HttpTask(url,requestData,httpRequest,callbackListener);
        ThreadPoolManager.getInstance().addTask(httpTask);
    }
}

public class MainActivity extends AppCompatActivity {
    private String url = "";

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

    private void sendRequest() {
        MNOkHttp.sendJsonRequest(null, url, ResponseClass.class, new IJsonDataListener<ResponseClass>() {
            @Override
            public void onSuccess(ResponseClass m) {
                Log.i("TAG", m.getError_code() + "" + m.getReason());
            }

        });
    }

源码地址https://download.csdn.net/download/jingerlovexiaojie/18800845