名称：Minicat

Minicat要做的事情：作为⼀个服务器软件提供服务的，也即我们可以通过浏览器客户端发送http请求，
Minicat可以接收到请求进⾏处理，处理之后的结果可以返回浏览器客户端。
1）提供服务，接收请求（Socket通信）
2）请求信息封装成Request对象（Response对象）
3）客户端请求资源，资源分为静态资源（html）和动态资源（Servlet）
4）资源返回给客户端浏览器
我们递进式完成以上需求，提出V1.0、V2.0、V3.0版本的需求
V1.0需求：浏览器请求http://localhost:8080,返回⼀个固定的字符串到⻚⾯"Hello Minicat!”
V2.0需求：封装Request和Response对象，返回html静态资源⽂件
V3.0需求：可以请求动态资源（Servlet）
完成上述三个版本后，我们的代码如下：

V1.0实现：

初步实现

  1. 开启socket
  2. 获取输出流，输出指定字符串。
  3. 测试http://localhost:8080 ```java package server;

import java.io.IOException; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket;

/**

  • MiniCat 主类 */ public class Bootstrap { //定义socket定义的端口号 private int port=8080;

    public int getPort() {

    1.  return port;

    }

    public void setPort(int port) {

    1.  this.port = port;

    }

    /**

    • MiniCat 启动需要初始化 展开的操作
    • V1.0需求：浏览器请求http://localhost:8080,返回⼀个固定的字符串到⻚⾯"Hello Minicat!”
    • V2.0需求：封装Request和Response对象，返回html静态资源⽂件
    • V3.0需求：可以请求动态资源（Servlet） */ public void start() throws IOException { //miniCat 1.0 版本 浏览器访问（http://localhost:8080）返回固定字符串到页面 ServerSocket serverSocket =new ServerSocket(port); System.out.println(“MiniCat start on port:”+port); while (true){
      1.  final Socket socket = serverSocket.accept();
      2.  final OutputStream outputStream = socket.getOutputStream();
      3.  outputStream.write("hello MiniCat!".getBytes());
      4.  socket.close();
      } } public static void main(String[] args) { Bootstrap bootstrap = new Bootstrap(); try {
      1.  bootstrap.start();
      } catch (IOException e) {
      1.  e.printStackTrace();
      } } }
  1. 测试结果<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/1699668/1595232724637-7b74b5ae-37fe-4a8b-90c6-af5e2c3e22de.png#align=left&display=inline&height=467&margin=%5Bobject%20Object%5D&name=image.png&originHeight=467&originWidth=689&size=19550&status=done&style=none&width=689)<br />**发现没有请求头和响应头，像这样**<br />**![image.png](https://cdn.nlark.com/yuque/0/2020/png/1699668/1595232861376-484bcb6a-828b-4481-93a4-966ae864781c.png#align=left&display=inline&height=389&margin=%5Bobject%20Object%5D&name=image.png&originHeight=391&originWidth=749&size=28669&status=done&style=none&width=746)**
  2. <a name="nqmpO"></a>
  3. ### 增加响应头
  4. **必要字段有：**
  6. - **HTTP/1.1 200 OK**
  7. - **Content-Type: text/html**
  8. - **Content-Length**
  10. **代码如下：**
  11. ```java
  12. /**
  13.  * http协议工具类，主要提供响应头信息，这里我们只提供200和404
  14.  */
  15. public class HttpProtocolUtil {
  16.     /**
  17.      * 为响应码200提供请求头信息
  18.      * @return
  19.      */
  20.     public static String getHttpHeader200(long contentLength) {
  21.         return "HTTP/1.1 200 OK \n" +
  22.                 "Content-Type: text/html \n" +
  23.                 "Content-Length: " + contentLength + " \n" +
  24.                 "\r\n";
  25.     }
  27.     /**
  28.      * 为响应码404提供请求头信息(此处也包含了数据内容)
  29.      * @return
  30.      */
  31.     public static String getHttpHeader404() {
  32.         String str404 = "<h1>404 not found</h1>";
  33.         return "HTTP/1.1 404 NOT Found \n" +
  34.                 "Content-Type: text/html \n" +
  35.                 "Content-Length: " + str404.getBytes().length + " \n" +
  36.                 "\r\n" + str404;
  37.     }
  38. }

在启动类中增加响应头信息。变更start方法如下:
增加获取http响应头信息，并将length传入，加上data用输出流进行输出。

  1.  /**
  2.      * MiniCat  启动需要初始化 展开的操作
  3.      * V1.0需求：浏览器请求http://localhost:8080,返回⼀个固定的字符串到⻚⾯"Hello Minicat!"
  4.      * V2.0需求：封装Request和Response对象，返回html静态资源⽂件
  5.      * V3.0需求：可以请求动态资源（Servlet）
  6.      */
  7.     public void start() throws IOException {
  8.         //miniCat 1.0 版本 浏览器访问（http://localhost:8080）返回固定字符串到页面
  9.         ServerSocket serverSocket =new ServerSocket(port);
  10.         System.out.println("MiniCat start on port:"+port);
  11.         while (true){
  12.             final Socket socket = serverSocket.accept();
  13.             final OutputStream outputStream = socket.getOutputStream();
  14.             String data="hello MiniCat!";
  15.             String responseText= HttpProtocolUtil.getHttpHeader200(data.getBytes().length)+data;
  16.             outputStream.write(responseText.getBytes());
  17.             socket.close();
  18.         }
  19.     }

V2.0实现：

获取请求信息

  1.  while (true){
  2.             final Socket socket = serverSocket.accept();
  3.             //从输入流中获取请求信息
  4.             final InputStream inputStream = socket.getInputStream();
  5.             //针对网络情况等于0的时候
  6.             int count=0;
  7.             while (count==0){
  8.                 //同一批数据有可能会过不来 获取输入流中的长度
  9.                 count = inputStream.available();
  10.             }
  11.             byte[] bytes=new byte[count];
  12.             inputStream.read(bytes);
  13.             System.out.println("====>请求信息"+new String(bytes));
  14.         }

获取如下：
image.png

封装request：

request封装如下：

  1. /**
  2.  * 把请求信息封装为Request对象（根据InputSteam输入流封装）
  3.  */
  4. public class Request {
  6.     private String method; // 请求方式，比如GET/POST
  7.     private String url;  // 例如 /,/index.html
  9.     private InputStream inputStream;  // 输入流，其他属性从输入流中解析出来
  12.     public String getMethod() {
  13.         return method;
  14.     }
  16.     public void setMethod(String method) {
  17.         this.method = method;
  18.     }
  20.     public String getUrl() {
  21.         return url;
  22.     }
  24.     public void setUrl(String url) {
  25.         this.url = url;
  26.     }
  28.     public InputStream getInputStream() {
  29.         return inputStream;
  30.     }
  32.     public void setInputStream(InputStream inputStream) {
  33.         this.inputStream = inputStream;
  34.     }
  36.     public Request() {
  37.     }
  40.     // 构造器，输入流传入
  41.     public Request(InputStream inputStream) throws IOException {
  42.         this.inputStream = inputStream;
  44.         // 从输入流中获取请求信息
  45.         int count = 0;
  46.         while (count == 0) {
  47.             count = inputStream.available();
  48.         }
  50.         byte[] bytes = new byte[count];
  51.         inputStream.read(bytes);
  53.         String inputStr = new String(bytes);
  54.         // 获取第一行请求头信息
  55.         String firstLineStr = inputStr.split("\\n")[0];  // GET / HTTP/1.1
  57.         String[] strings = firstLineStr.split(" ");
  59.         this.method = strings[0];
  60.         this.url = strings[1];
  62.         System.out.println("=====>>method:" + method);
  63.         System.out.println("=====>>url:" + url);
  66.     }
  67. }

封装response：

  1. package server;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  8. /**
  9.  * 封装Response对象，需要依赖于OutputStream
  10.  *
  11.  * 该对象需要提供核心方法，输出html
  12.  */
  13. public class Response {
  15.     private OutputStream outputStream;
  17.     public Response() {
  18.     }
  20.     public Response(OutputStream outputStream) {
  21.         this.outputStream = outputStream;
  22.     }
  25.     // 使用输出流输出指定字符串
  26.     public void output(String content) throws IOException {
  27.         outputStream.write(content.getBytes());
  28.     }
  31.     /**
  32.      *
  33.      * @param path  url，随后要根据url来获取到静态资源的绝对路径，进一步根据绝对路径读取该静态资源文件，最终通过
  34.      *                  输出流输出
  35.      *              /-----> classes
  36.      */
  37.     public void outputHtml(String path) throws IOException {
  38.         // 获取静态资源文件的绝对路径
  39.         String absoluteResourcePath = StaticResourceUtil.getAbsolutePath(path);
  41.         // 输入静态资源文件
  42.         File file = new File(absoluteResourcePath);
  43.         if(file.exists() && file.isFile()) {
  44.             // 读取静态资源文件，输出静态资源
  45.             StaticResourceUtil.outputStaticResource(new FileInputStream(file),outputStream);
  46.         }else{
  47.             // 输出404
  48.             output(HttpProtocolUtil.getHttpHeader404());
  49.         }
  51.     }
  53. }

编写静态资源工具类：

  1. package server;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  7. public class StaticResourceUtil {
  9.     /**
  10.      * 获取静态资源文件的绝对路径
  11.      * @param path
  12.      * @return
  13.      */
  14.     public static String getAbsolutePath(String path) {
  15.         String absolutePath = StaticResourceUtil.class.getResource("/").getPath();
  16.         return absolutePath.replaceAll("\\\\","/") + path;
  17.     }
  20.     /**
  21.      * 读取静态资源文件输入流，通过输出流输出
  22.      */
  23.     public static void outputStaticResource(InputStream inputStream, OutputStream outputStream) throws IOException {
  25.         int count = 0;
  26.         while(count == 0) {
  27.             count = inputStream.available();
  28.         }
  30.         int resourceSize = count;
  31.         // 输出http请求头,然后再输出具体内容
  32.         outputStream.write(HttpProtocolUtil.getHttpHeader200(resourceSize).getBytes());
  34.         // 读取内容输出
  35.         long written = 0 ;// 已经读取的内容长度
  36.         int byteSize = 1024; // 计划每次缓冲的长度
  37.         byte[] bytes = new byte[byteSize];
  39.         while(written < resourceSize) {
  40.             if(written  + byteSize > resourceSize) {  // 说明剩余未读取大小不足一个1024长度，那就按真实长度处理
  41.                 byteSize = (int) (resourceSize - written);  // 剩余的文件内容长度
  42.                 bytes = new byte[byteSize];
  43.             }
  45.             inputStream.read(bytes);
  46.             outputStream.write(bytes);
  48.             outputStream.flush();
  49.             written+=byteSize;
  50.         }
  51.     }
  52. }
  1. 获取socket输入流，作为获取请求头信息。
  2. 获取socket输出流，作为响应信息。
  3. 分别进行封装。
  4. StaticResourceUtil 根据url进行读取文件，缓冲式输出，一次输出1024.

  5. 最终调用请求封装成request，响应封装成response。传入socket输入及输出流。具体代码如下：

    1. while(true) {
    2.          Socket socket = serverSocket.accept();
    3.          InputStream inputStream = socket.getInputStream();
    5.          // 封装Request对象和Response对象
    6.          Request request = new Request(inputStream);
    7.          Response response = new Response(socket.getOutputStream());
    9.          response.outputHtml(request.getUrl());
    10.          socket.close();
    12.      }

V3.0实现：

  1. 启动先加载配置文件到servlet
  2. 初始化加载servlet，解析web.xml
  3. 找到对应封装好的 request，response。

定义servlet

  • 编写servlet接口： ```java public interface Servlet {

    void init() throws Exception;

    void destory() throws Exception;

    void service(Request request, Response response) throws Exception; }

  2. - 编写HttpServlet
  3. ```java
  4. public abstract class HttpServlet implements Servlet{
  7.     public abstract void doGet(Request request, Response response);
  9.     public abstract void doPost(Request request,Response response);
  12.     @Override
  13.     public void service(Request request, Response response) throws Exception {
  14.         if("GET".equalsIgnoreCase(request.getMethod())) {
  15.             doGet(request,response);
  16.         }else{
  17.             doPost(request,response);
  18.         }
  19.     }
  20. }

  • 自定义servlet

    1. public class LagouServlet extends HttpServlet {
    2.   @Override
    3.   public void doGet(Request request, Response response) {
    5.       String content = "<h1>LagouServlet get</h1>";
    6.       try {
    7.           response.output((HttpProtocolUtil.getHttpHeader200(content.getBytes().length) + content));
    8.       } catch (IOException e) {
    9.           e.printStackTrace();
    10.       }
    11.   }
    13.   @Override
    14.   public void doPost(Request request, Response response) {
    15.       String content = "<h1>LagouServlet post</h1>";
    16.       try {
    17.           response.output((HttpProtocolUtil.getHttpHeader200(content.getBytes().length) + content));
    18.       } catch (IOException e) {
    19.           e.printStackTrace();
    20.       }
    21.   }
    23.   @Override
    24.   public void init() throws Exception {
    26.   }
    28.   @Override
    29.   public void destory() throws Exception {
    31.   }
    32. }

    自定义web.xml

    ```xml <?xml version=”1.0” encoding=”UTF-8” ?>

    lagou servlet.LagouServlet 
  1. <servlet-mapping>
  2.     <servlet-name>lagou</servlet-name>
  3.     <url-pattern>/lagou</url-pattern>
  4. </servlet-mapping>

  1. 目的 输入http://localhost:8080/lagou就可以到LagouServlet
  2. <a name="nCVQi"></a>
  3. #### 更改bootstrap
  4. ```java
  5. loadServlet();       
  6. while(true) {
  7.             Socket socket = serverSocket.accept();
  8.             InputStream inputStream = socket.getInputStream();
  10.             // 封装Request对象和Response对象
  11.             Request request = new Request(inputStream);
  12.             Response response = new Response(socket.getOutputStream());
  14.             // 静态资源处理
  15.             if(servletMap.get(request.getUrl()) == null) {
  16.                 response.outputHtml(request.getUrl());
  17.             }else{
  18.                 // 动态资源servlet请求
  19.                 HttpServlet httpServlet = servletMap.get(request.getUrl());
  20.                 httpServlet.service(request,response);
  21.             }
  23.             socket.close();
  25.         }

引入需要的pom

dom4j，jaxen

  1.         <dependency>
  2.             <groupId>dom4j</groupId>
  3.             <artifactId>dom4j</artifactId>
  4.             <version>1.6.1</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>jaxen</groupId>
  8.             <artifactId>jaxen</artifactId>
  9.             <version>1.1.6</version>
  10.         </dependency>

解析web.xml

  1. 读取文件成document对象
  2. 取到servlet找到servlet-name，对应的class
  3. 找到servlet-name对应的servlet-mapping

  4. 缓存url和servlet ```java private Map servletMap = new HashMap(); /**

    • 加载解析web.xml，初始化Servlet */ private void loadServlet() { InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(“web.xml”); SAXReader saxReader = new SAXReader();

      try {

      1.  Document document = saxReader.read(resourceAsStream);
      2.  Element rootElement = document.getRootElement();
      4.  List<Element> selectNodes = rootElement.selectNodes("//servlet");
      5.  for (int i = 0; i < selectNodes.size(); i++) {
      6.      Element element =  selectNodes.get(i);
      7.      // <servlet-name>lagou</servlet-name>
      8.      Element servletnameElement = (Element) element.selectSingleNode("servlet-name");
      9.      String servletName = servletnameElement.getStringValue();
      10.      // <servlet-class>server.LagouServlet</servlet-class>
      11.      Element servletclassElement = (Element) element.selectSingleNode("servlet-class");
      12.      String servletClass = servletclassElement.getStringValue();
  1.             // 根据servlet-name的值找到url-pattern
  2.             Element servletMapping = (Element) rootElement.selectSingleNode("/web-app/servlet-mapping[servlet-name='" + servletName + "']");
  3.             // /lagou
  4.             String urlPattern = servletMapping.selectSingleNode("url-pattern").getStringValue();
  5.             servletMap.put(urlPattern, (HttpServlet) Class.forName(servletClass).newInstance());
  7.         }
  11.     } catch (DocumentException e) {
  12.         e.printStackTrace();
  13.     } catch (IllegalAccessException e) {
  14.         e.printStackTrace();
  15.     } catch (InstantiationException e) {
  16.         e.printStackTrace();
  17.     } catch (ClassNotFoundException e) {
  18.         e.printStackTrace();
  19.     }
  21. }
  1. <a name="QsgE3"></a>
  2. ## 多线程改造：
  3. 当前问题，现在属于单线程，只能单线程的去处理。<br />所以要改造成多线程方式。
  4. <a name="v3SZ9"></a>
  5. ### 定义requestProcess
  6. ```java
  7. public class RequestProcessor extends Thread {
  9.     private Socket socket;
  10.     private Map<String, HttpServlet> servletMap;
  12.     public RequestProcessor(Socket socket, Map<String, HttpServlet> servletMap) {
  13.         this.socket = socket;
  14.         this.servletMap = servletMap;
  15.     }
  17.     @Override
  18.     public void run() {
  19.         try{
  20.             InputStream inputStream = socket.getInputStream();
  22.             // 封装Request对象和Response对象
  23.             Request request = new Request(inputStream);
  24.             Response response = new Response(socket.getOutputStream());
  26.             // 静态资源处理
  27.             if(servletMap.get(request.getUrl()) == null) {
  28.                 response.outputHtml(request.getUrl());
  29.             }else{
  30.                 // 动态资源servlet请求
  31.                 HttpServlet httpServlet = servletMap.get(request.getUrl());
  32.                 httpServlet.service(request,response);
  33.             }
  35.             socket.close();
  37.         }catch (Exception e) {
  38.             e.printStackTrace();
  39.         }
  41.     }
  42. }

不使用线程池bootstarp

  1.         while(true) {
  2.             Socket socket = serverSocket.accept();
  3.             RequestProcessor requestProcessor = new RequestProcessor(socket,servletMap);
  4.             requestProcessor.start();
  5.         }

使用线程池

定义线程池

  2.         // 定义一个线程池
  3.         int corePoolSize = 10;//基本大小核心线程数
  4.         int maximumPoolSize =50;//最大线程数
  5.         long keepAliveTime = 100L;//保持时间
  6.         TimeUnit unit = TimeUnit.SECONDS;//单位
  7.         BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(50);//线程队列
  8.         ThreadFactory threadFactory = Executors.defaultThreadFactory();//线程工厂
  9.         RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();//拒绝策略 如何拒绝任务
  12.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
  13.                 corePoolSize,
  14.                 maximumPoolSize,
  15.                 keepAliveTime,
  16.                 unit,
  17.                 workQueue,
  18.                 threadFactory,
  19.                 handler
  20.         );

使用线程池改造bootstarp

  1.         while(true) {
  3.             Socket socket = serverSocket.accept();
  4.             RequestProcessor requestProcessor = new RequestProcessor(socket,servletMap);
  5.             //requestProcessor.start();
  6.             threadPoolExecutor.execute(requestProcessor);
  7.         }

为什么并发达到一定数量，使用线程池效率更高一些呢？

  • 提高响应速度（减少了创建新线程的时间）
  • 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
  • 提高线程的可管理性：对线程进行统一分配和监控，避免无限制创建线程导致内存溢出或者耗尽CPU