美文网首页
简单理解网络框架

简单理解网络框架

作者: xihacode | 来源:发表于2020-05-05 15:29 被阅读0次

    有时候看网络框架的源码会看不懂,其实只要我们抓住主体的脉络去看的话, 就容易的多了 ,关键不是怎么写代码,而是思路。


    network.png

    思路

    1. 用户(也就是Activity/Service)发送网络请求,框架负责去处理请求,然后给用户返回来 请求的数据就OK。
    2. 首先网络请求是需要在子线程里的,请求有可能需要很多条,所以需要线程池,需要请求队列。这里举一个例子比较好理解:我(用户1⃣️)中午去餐厅(2⃣️)吃饭,饭菜比较好,所以有很多人去吃饭,餐厅里面的食堂面积有限,所以有很多人需要去排队(3⃣️),里面的人吃完了,外面的人才可以进来,但是当里面的人吃完的时候需要有一个人(服务员 也可以理解成coreThead)去通知外面的人进来(线程调度)。首先我们需要完成的就是“餐厅”那一部分的设计。

    具体实现

    1.创建一个 ThreadPoolManager.java 相当于上图的餐厅 餐厅外面有等待进来的人(LinkedBlockingQueue),里面有负责通知调度的服务员(coreThread),有餐厅食堂(ThreadPoolManager)

    public class ThreadPoolManager {
    
        private static ThreadPoolManager mThreadPoolManager = new ThreadPoolManager();
        //创建等待队列
        private LinkedBlockingQueue<Runnable> mLinkedBlockingQueue = new LinkedBlockingQueue<>();
    
        public static ThreadPoolManager getThreadPoolManagerInstance() {
            return mThreadPoolManager;
        }
        //添加线程到请求队列里
        public void addTask(Runnable runnable) {
            if (runnable != null) {
                try {
                    mLinkedBlockingQueue.put(runnable);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        //创建线程池
        private ThreadPoolExecutor mThreadPoolExecutor;
    
        private ThreadPoolManager() {
            mThreadPoolExecutor = new ThreadPoolExecutor(3, 10, 10,
                    TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(4), new RejectedExecutionHandler() {
                @Override
                public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                    addTask(r);
                }
            });
            mThreadPoolExecutor.execute(coreThread);
        }
    
        //核心线程 相当于服务员, 通过一个死循环 不断的从请求队列里取出来请求数据,扔到线程池里面
        private Runnable coreThread = new Runnable() {
            Runnable runnable = null;
    
            @Override
            public void run() {
                while (true) {
                    try {
                        runnable = mLinkedBlockingQueue.take();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    mThreadPoolExecutor.execute(runnable);
                }
            }
        };
    
    }
    

    2.然后定义请求的接口 也就是1⃣️和2⃣️联系起来的接口

    public interface IHttpRequest {
        void setUrl(String url); // 传过来的url
        void setData(byte[] data); //传过来的请求数据
        void setCallBackListener(CallBackListener listener);//回调函数,回调请求结果的
        void execute();//执行网络操作
    }
    
    public interface CallBackListener {
        void onSuccess(String result);
    
        void Failure();
    }
    

    这个接口这是一个例子,主要是为了说明下这个思想。
    3.有了接口 那就的实现接口里的具体方法了,这里实现一个StringHttpRequest.java

    public class StringHttpRequest implements IHttpRequest {
        private String mUrl;
        private byte[] mData;
        private CallBackListener mListener;
    
        @Override
        public void setUrl(String url) {
            mUrl = url;
    
        }
    
        @Override
        public void setData(byte[] data) {
            mData = data;
        }
    
        @Override
        public void setCallBackListener(CallBackListener listener) {
            mListener = listener;
        }
    
        @Override
        public void execute() {
         
            //执行网络请求;
            HttpURLConnection connection = null;
            InputStream inputStream = null;
            String result = null;
        
            try {
              
                URL url = new URL(mUrl);
                connection = (HttpURLConnection) url.openConnection();
                connection.setRequestMethod("GET");
                // Timeout for reading InputStream arbitrarily set to 3000ms.
                connection.setReadTimeout(3000);
                // Timeout for connection.connect() arbitrarily set to 3000ms.
                connection.setConnectTimeout(3000);
    //            connection.setDoInput(true);
                connection.connect();
    
                int responseCode = connection.getResponseCode();
                if (responseCode != HttpURLConnection.HTTP_OK) {
                    //访问失败
                    mListener.Failure();
                } else {
                    inputStream = connection.getInputStream();
                    if (inputStream != null) {
                        //Converts Stream to String
                        StringBuilder sb = new StringBuilder();
                        String line;
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                        while ((line = bufferedReader.readLine()) != null) {
                            sb.append(line);
                        }
                        result = sb.toString();
                         //回调成功的结果 这里回调字符串 也可以在封装一层
                        mListener.onSuccess(result);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (connection != null) {
                    connection.disconnect();
                }
            }
    
        }
    }
    
    
    1. 把请求和响应组合在一起 HttpTask.java
    public class HttpTask implements Runnable {
        private StringHttpRequest mStringHttpRequest ;
    
        public HttpTask(String url, CallBackListener callBackListener) {
            mStringHttpRequest =new StringHttpRequest();
            mStringHttpRequest.setUrl(url);
            mStringHttpRequest.setCallBackListener(callBackListener);
        }
    
        @Override
        public void run() {
            mStringHttpRequest.execute();
        }
    }
    

    5.把任务添加到请求队列

    public class HttpUtil {
        public static void sendHttpRequest(String url, CallBackListener callBackListener) {
            HttpTask httpTask = new HttpTask(url, callBackListener);
            ThreadPoolManager.getThreadPoolManagerInstance().addTask(httpTask);
        }
    }
    
    1. 这样一个网络框架就完成了 当然这只是为了理清楚大概的思路 有了思路才会有完美的实现。
    public class MainActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            String url = "http://10.0.2.2:8000";//这里自己的本地服务器,因为这里的请求是
          //http 在高版本的Android 里默认是不允许明文传递数据的 需要在MainMainfest里的application
          //标签加上“android:usesCleartextTraffic="true"”
            HttpUtil.sendHttpRequest(url, new CallBackListener() {
                @Override
                public void onSuccess(String result) {
                    Log.d("result: ", "onSuccess: " + result);
                }
    
                @Override
                public void Failure() {
    
                }
            });
        }
    }
    

    相关文章

      网友评论

          本文标题:简单理解网络框架

          本文链接:https://www.haomeiwen.com/subject/jaemghtx.html