今日重新写了一遍请求响应前面的代码，第二次学习的时候确实会有不一样的感触。

浏览器端

浏览器执行：解析URL，得到ip port contentAndParams . 通过ip port 创建socke流，再得到一个高级流将contentAndParams发送给服务器。浏览器等待服务器发送信息，并展示信息

  1. package browser;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.util.Scanner;
  10. public class Browser {
  12.     private Scanner sc = new Scanner(System.in);
  13.     private Socket socket = null;
  15.     public void openBrowser() {
  16.         System.out.println("浏览器开始执行了");
  17.         System.out.println("URL:");
  18.         String url = sc.nextLine();
  19.         this.parseURL(url);
  20.     }
  22.     //设计一个方法解析URL
  23.     private void parseURL(String url) {
  24.         //找寻冒号所在位置
  25.         int colonIndex = url.indexOf(":");
  26.         //找寻斜杠所在位置
  27.         int slashIndex = url.indexOf("/");
  28.         //获取Ip port  contentAndParams
  29.         String ip = url.substring(0, colonIndex);
  30.         int port = Integer.parseInt(url.substring(colonIndex + 1, slashIndex));
  31.         String contentAndParams = url.substring(slashIndex + 1);
  32.         //创建连接并发送请求
  33.         this.cerateSocketAndSendRequest(ip, port, contentAndParams);
  34.     }
  36.     //创建socket 将资源发送过去
  37.     private void cerateSocketAndSendRequest(String ip, int port, String contenAndParams) {
  38.         try {
  39.             //通过ip port 创建socket流
  40.             socket = new Socket(ip, port);
  41.             //得到一个PrintWriter流将信息发送出去
  42.             PrintWriter out = new PrintWriter(socket.getOutputStream());
  43.             out.println(contenAndParams);
  44.             out.flush();
  45.             //浏览器等待响应信息
  46.             this.receiveResponseContent();
  47.         } catch (IOException e) {
  48.             e.printStackTrace();
  49.         }
  50.     }
  53.     //设计一个方法 接受服务器回写的响应信息
  54.     private void receiveResponseContent() {
  56.         try {
  57.             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  58.             String responseContent = reader.readLine();
  59.             //解析响应信息并展示
  60.             this.parseResponseContentAndShow(responseContent);
  61.         } catch (IOException e) {
  62.             e.printStackTrace();
  63.         }
  64.     }
  67.     private void parseResponseContentAndShow(String responseContent){
  68.         System.out.println(responseContent);
  69.     }
  70. }

服务器

服务器开放一个端口号，等待接收。接收到一个连接开启一个ServerHandler线程。然后包装socket.getInputStream成高级流读取一行信息，再解析资源。
创建了两个类 HttpServletRequest 和 HttpServletResponse 目的是接收响应求情的信息，另一个是为了接受响应回去的结果。之后找到ServletController类做事情，找到请求名对应的真实类做事情
增加了一个缓存机制，读取到一个请求加载一个，性能提高了

  1. package server;
  3. import java.io.IOException;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. public class Server {
  9.     //开启服务器的方法
  10.     public void serverStart(){
  11.         try {
  12.             System.out.println("浏览器开始执行了");
  13.             //创建一个服务
  14.             ServerSocket server=new ServerSocket(9999);
  15.             while(true){
  16.                 //等待接收
  17.                 Socket socket=server.accept();
  18.                 //开启一个线程
  19.                 new ServerHandler(socket).run();
  21.             }
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26. }
  1. package server;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.net.Socket;
  8. import java.util.HashMap;
  10. public class ServerHandler extends Thread{
  12.     private Socket socket;
  14.     public ServerHandler(Socket socket){
  15.         this.socket=socket;
  16.     }
  18.     public void run(){
  19.         //接收信息
  20.         this.receiveRequest();
  21.         //解析
  22.         //找人做事
  23.         //响应回去
  25.     }
  26.     //接受消息
  27.     private void receiveRequest(){
  29.         try {
  30.             InputStream is=socket.getInputStream();
  31.             InputStreamReader isr=new InputStreamReader(is);
  32.             BufferedReader reader=new BufferedReader(isr);
  33.             //读取消息
  34.             String contentAndParams=reader.readLine();
  35.             //解析
  36.             this.parseContentAndParams(contentAndParams);
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.         }
  41.     }
  43.     //解析资源
  44.     private void parseContentAndParams(String contentAndParams){
  45.         String content=null;
  46.         HashMap<String,String> paramsMap=null;
  47.         //content?key=value&key=value
  48.         //找寻到问号的位置
  49.         int questionMarkIndex=contentAndParams.indexOf("?");
  50.         //判断是否携带了参数
  51.         if(questionMarkIndex!=-1){
  52.             //携带了参数
  53.             content=contentAndParams.substring(0,questionMarkIndex);
  54.             paramsMap=new HashMap<>();
  55.             //处理后面携带的参数
  56.             String params=contentAndParams.substring(questionMarkIndex+1);
  57.             String []keyAndValues=params.split("&");
  58.             for(String keyAndValue:keyAndValues){
  59.                 String []kv=keyAndValue.split("=");
  60.                 paramsMap.put(kv[0],kv[1]);
  61.             }
  62.         }else{
  63.             //若没带参数
  64.             content=contentAndParams;
  65.         }
  66.         //创建了两个类 一个是为了存储接受请求携带的信息
  67.         //一个是为了接受响应回去的结果
  68.         HttpServletRequest request=new HttpServletRequest(content,paramsMap);
  69.         HttpServletResponse response=new HttpServletResponse();
  70.         //找到一个人 让他去底层找到真实的类做事情 并将response填满
  71.         ServletController.findController(request,response);
  72.         //响应回去
  73.         this.responseToBrowser(response);
  75.     }
  77.     //找人做事
  78.     private void responseToBrowser(HttpServletResponse response){
  80.     }
  82. }
  1. package server;
  3. import java.util.HashMap;
  5. public class HttpServletRequest {
  7.     //自定义的一个类
  8.     //目的存储浏览器发送请求和参数
  10.     private String content;
  11.     private HashMap<String,String> paramsMap;
  13.     public HttpServletRequest() {
  14.     }
  16.     public HttpServletRequest(String content, HashMap<String, String> paramsMap) {
  17.         this.content = content;
  18.         this.paramsMap = paramsMap;
  19.     }
  21.     public String getContent() {
  22.         return content;
  23.     }
  25.     public void setContent(String content) {
  26.         this.content = content;
  27.     }
  29.     public HashMap<String, String> getParamsMap() {
  30.         return paramsMap;
  31.     }
  33.     public void setParamsMap(HashMap<String, String> paramsMap) {
  34.         this.paramsMap = paramsMap;
  35.     }
  36. }
  39. package server;
  41. public class HttpServletResponse {
  43.     private StringBuilder responseContent=new StringBuilder();
  46.     public void write(String str){
  47.         responseContent.append(str);
  48.     }
  50.     public String getResponseContent(){
  52.         return this.responseContent.toString();
  53.     }
  55. }
  1. package server;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.lang.reflect.Method;
  6. import java.util.Enumeration;
  7. import java.util.HashMap;
  8. import java.util.Properties;
  10. public class ServletController{
  12.     //这个类的目的是为了管理 findController方法
  13.     //方法之前与服务器做的事情不一样 抽离出来
  14.     //每一次赵信controller类都需要参考web.properties配置文件
  15.         //读取文件性能会变低  因此可以增加一个缓存机制
  16.     //每一个Controller类都是由Controller方法来找寻类
  17.     // 找到类之后执行他的方法
  19.     //增加一个单例模式（controller类只有方法执行 没有属性）
  20.     private static HashMap<String ,String>controllerNameMap=new HashMap<>();
  21.     //添加一个集合 存储被管理的所有Controller类对象
  22.     private static HashMap<String,HttpServlet> controllerObjectMap = new HashMap<>();
  23.     //延迟加载对象的方式
  25.     //创建一个静态块 在当前类加载的时候将配置文件中的所有信息读取出来存入缓存集合中
  26.     static{
  27.         try {
  28.             Properties pro = new Properties();
  29.             pro.load(new FileReader("src//web.properties"));
  30.             Enumeration en = pro.propertyNames();
  31.             while(en.hasMoreElements()){
  32.                 String content = (String)en.nextElement();
  33.                 String realControllerName = pro.getProperty(content);
  34.                 controllerNameMap.put(content,realControllerName);
  35.             }
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         }
  39.     }
  41.     //找人干活---控制层    (controller  action  servlet)
  42.     //content----index     map-----{{name,zzt},{},{}}
  43.     public static void findController(HttpServletRequest request,HttpServletResponse response){
  44.         //获取request对象中的请求名字
  45.         String content = request.getContent();
  46.         try {
  47.             //先去objectMap中找寻需要的对象
  48.             HttpServlet controllerObject = controllerObjectMap.get(content);
  49.             //若对象不存在 证明之前没有使用过
  50.             if(controllerObject==null){
  51.                 //参考配置文件(缓存) 真实类名
  52.                 String realControllerName = controllerNameMap.get(content);
  53.                 //请求对应的真实类名是否存在
  54.                 if(realControllerName!=null){
  55.                     //反射获取类
  56.                     Class clazz = Class.forName(realControllerName);
  57.                     controllerObject = (HttpServlet) clazz.newInstance();
  58.                     //将新创建的对象放在上面的对象集合内
  59.                     controllerObjectMap.put(content,controllerObject);
  60.                 }
  61.             }
  62.             //----以上可以确保controllerObject对象肯定存在-------------
  63.             //反射找寻类中的方法
  64.             Class controllerClass = controllerObject.getClass();
  65.             Method serviceMethod = controllerClass.getMethod("service",HttpServletRequest.class,HttpServletResponse.class);
  66.             serviceMethod.invoke(controllerObject,request,response);
  67.         } catch (ClassNotFoundException e) {
  68.             response.write("请求的"+content+"Controller不存在");
  69.         } catch (NoSuchMethodException e){
  70.             response.write("405 没有可以执行的方法");
  71.         } catch (Exception e){
  72.             e.printStackTrace();
  73.         }
  74.     }
  78. }
  1. package controller;
  3. import server.HttpServlet;
  4. import server.HttpServletRequest;
  5. import server.HttpServletResponse;
  7. public class IndexController extends HttpServlet {
  8.     @Override
  9.     public void service(HttpServletRequest request, HttpServletResponse response) {
  10.         //获取请求发送过来的参数
  11.         System.out.println("控制层执行了");
  12.         //找到业务层做事 业务层找dao层帮忙
  14.         //将业务层得到最终结果 响应给浏览器
  15.         response.write("XXX");
  16.     }
  17. }

总结:学过的知识在复习一遍会有不一样的感触。特别现在对反射 IO流 单例 缓存机制有更深的记忆了。