• 手写SpringBoot底层代码（WebServer项目）

    1.WebServer项目

    1.1项目目录

    1.1.1Java目录

    1.1.2HTML目录

    1.2Java代码

    1.2.1Controller(注解)

    1. package com.webserver.annotations;
    2.  
    3. import java.lang.annotation.ElementType;
    4. import java.lang.annotation.Retention;
    5. import java.lang.annotation.RetentionPolicy;
    6. import java.lang.annotation.Target;
    7.  
    8. @Target(ElementType.TYPE)
    9. @Retention(RetentionPolicy.RUNTIME)
    10. public @interface Controller {
    11. }

    1.2.2RequestMapping(注解)

    1. package com.webserver.annotations;
    2.  
    3. import java.lang.annotation.ElementType;
    4. import java.lang.annotation.Retention;
    5. import java.lang.annotation.RetentionPolicy;
    6. import java.lang.annotation.Target;
    7.  
    8. @Target(ElementType.METHOD)
    9. @Retention(RetentionPolicy.RUNTIME)
    10. public @interface RequestMapping {
    11.     String value();
    12. }

    1.2.3ArticleController(文章业务)

    1. package com.webserver.controller;
    2.  
    3. import com.webserver.annotations.Controller;
    4. import com.webserver.annotations.RequestMapping;
    5. import com.webserver.core.ClientHandler;
    6. import com.webserver.entity.Article;
    7. import com.webserver.http.HttpServletRequest;
    8. import com.webserver.http.HttpServletResponse;
    9.  
    10. import java.io.File;
    11. import java.io.FileOutputStream;
    12. import java.io.IOException;
    13. import java.io.ObjectOutputStream;
    14. import java.net.URISyntaxException;
    15. @Controller
    16. public class ArticleController {
    17.     private static File rootDir;
    18.     private static File staticDir;
    19.  
    20.     //表示articles目录
    21.     private static File articleDir;
    22.     static{
    23.         try {
    24.             rootDir = new File(
    25.                     ClientHandler.class.getClassLoader()
    26.                             .getResource(".").toURI()
    27.             );
    28.             staticDir = new File(rootDir,"static");
    29.         } catch (URISyntaxException e) {
    30.             e.printStackTrace();
    31.         }
    32.  
    33.         articleDir = new File("articles");
    34.         if(!articleDir.exists()){
    35.             articleDir.mkdirs();
    36.         }
    37.     }
    38.  
    39.     @RequestMapping("/myweb/writeArticle")
    40.     public void writeArticle(HttpServletRequest request, HttpServletResponse response){
    41.         //1获取表单数据
    42.         String title = request.getParameter("title");
    43.         String author = request.getParameter("author");
    44.         String content = request.getParameter("content");
    45.         if(title==null||author==null||content==null){
    46.             File file = new File(staticDir,"/myweb/article_info_error.html");
    47.             response.setContentFile(file);
    48.             return;
    49.         }
    50.  
    51.         //2写入文件
    52.         File articleFile = new File(articleDir,title+".obj");
    53.         if(articleFile.exists()){//文件存在,说明重复的标题,不能发表(需求过于严苛,后期数据库可通过ID避免该问题).
    54.             File file = new File(staticDir,"/myweb/have_article.html");
    55.             response.setContentFile(file);
    56.             return;
    57.         }
    58.  
    59.         Article article = new Article(title,author,content);
    60.         try (
    61.                 FileOutputStream fos = new FileOutputStream(articleFile);
    62.                 ObjectOutputStream oos = new ObjectOutputStream(fos);
    63.         ){
    64.             oos.writeObject(article);
    65.             File file = new File(staticDir,"/myweb/article_success.html");
    66.             response.setContentFile(file);
    67.         } catch (IOException e) {
    68.             e.printStackTrace();
    69.         }
    70.  
    71.  
    72.         //3响应页面
    73.  
    74.  
    75.  
    76.     }
    77. }

    1.2.4ToolsController(二维码，验证码业务)

    1. package com.webserver.controller;
    2.  
    3. import com.webserver.annotations.Controller;
    4. import com.webserver.annotations.RequestMapping;
    5. import com.webserver.http.HttpServletRequest;
    6. import com.webserver.http.HttpServletResponse;
    7. import qrcode.QRCodeUtil;
    8.  
    9. import javax.imageio.ImageIO;
    10. import java.awt.*;
    11. import java.awt.image.BufferedImage;
    12. import java.io.FileOutputStream;
    13. import java.io.IOException;
    14. import java.util.Random;
    15.  
    16. @Controller
    17. public class ToolsController {
    18.     @RequestMapping("/myweb/createQR")
    19.     public void createQR(HttpServletRequest request, HttpServletResponse response){
    20.         String line = request.getParameter("content");
    21.         try {
    22.             response.setContentType("image/jpeg");
    23.             QRCodeUtil.encode(
    24.                     line,   //二维码上显示的文字
    25.                     "./logo.jpg",   //二维码中间的logo图
    26.                     response.getOutputStream(),//生成的二维码数据会通过该流写出
    27.                     true);//是否压缩logo图片的尺寸
    28.  
    29.             System.out.println("二维码已生成");
    30.         } catch (Exception e) {
    31.             e.printStackTrace();
    32.         }
    33.  
    34.  
    35.     }
    36.  
    37.     @RequestMapping("/myweb/random.jpg")
    38.     public void createRandomImage(HttpServletRequest request,HttpServletResponse response){
    39.         response.setContentType("image/jpeg");
    40.  
    41.         //1创建一张空白图片，同时指定宽高   理解为:搞一张白纸，准备画画
    42.         BufferedImage image = new BufferedImage(
    43.                 70,30,BufferedImage.TYPE_INT_RGB
    44.         );
    45.  
    46.         //2通过图片获取绘制该图片的画笔，通过这个画笔就可以往该图片上绘制了
    47.         Graphics g = image.getGraphics();
    48.  
    49.         Random random = new Random();
    50.         //3随机生成个颜色涂满整张画布
    51.         Color color = new Color(
    52.                 random.nextInt(256),
    53.                 random.nextInt(256),
    54.                 random.nextInt(256));
    55.         g.setColor(color);//设置画笔颜色
    56.         g.fillRect(0,0,70,30);
    57.  
    58.         //4向画布上绘制文字
    59.         String line = "abcdefghjiklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    60.         g.setFont(new Font(null,Font.BOLD,20));
    61.         for(int i=0;i<4;i++) {
    62.             color = new Color(
    63.                     random.nextInt(256),
    64.                     random.nextInt(256),
    65.                     random.nextInt(256));
    66.             g.setColor(color);//设置画笔颜色
    67.             String str = line.charAt(random.nextInt(line.length())) + "";
    68.             g.drawString(str, i*15+5, 18+ random.nextInt(11)-5);
    69.         }
    70.  
    71.         //5随机生成5条干扰线
    72.         for(int i=0;i<5;i++){
    73.             color = new Color(
    74.                     random.nextInt(256),
    75.                     random.nextInt(256),
    76.                     random.nextInt(256));
    77.             g.setColor(color);//设置画笔颜色
    78.             g.drawLine(random.nextInt(71), random.nextInt(31),
    79.                     random.nextInt(71), random.nextInt(31));
    80.         }
    81.  
    82.  
    83.         try {
    84.             ImageIO.write(image,"jpg",
    85.                     response.getOutputStream());
    86.             System.out.println("图片已生成");
    87.         } catch (IOException e) {
    88.             e.printStackTrace();
    89.         }
    90.     }
    91.  
    92.  
    93.     public static void main(String[] args) {
    94.         //1创建一张空白图片，同时指定宽高   理解为:搞一张白纸，准备画画
    95.         BufferedImage image = new BufferedImage(
    96.                 70,30,BufferedImage.TYPE_INT_RGB
    97.         );
    98.  
    99.         //2通过图片获取绘制该图片的画笔，通过这个画笔就可以往该图片上绘制了
    100.         Graphics g = image.getGraphics();
    101.  
    102.         Random random = new Random();
    103.         //3随机生成个颜色涂满整张画布
    104.         Color color = new Color(
    105.                 random.nextInt(256),
    106.                 random.nextInt(256),
    107.                 random.nextInt(256));
    108.         g.setColor(color);//设置画笔颜色
    109.         g.fillRect(0,0,70,30);
    110.  
    111.         //4向画布上绘制文字
    112.         String line = "abcdefghjiklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    113.         g.setFont(new Font(null,Font.BOLD,20));
    114.         for(int i=0;i<4;i++) {
    115.             color = new Color(
    116.                     random.nextInt(256),
    117.                     random.nextInt(256),
    118.                     random.nextInt(256));
    119.             g.setColor(color);//设置画笔颜色
    120.             String str = line.charAt(random.nextInt(line.length())) + "";
    121.             g.drawString(str, i*15+5, 18+ random.nextInt(11)-5);
    122.         }
    123.  
    124.         //5随机生成5条干扰线
    125.         for(int i=0;i<5;i++){
    126.             color = new Color(
    127.                     random.nextInt(256),
    128.                     random.nextInt(256),
    129.                     random.nextInt(256));
    130.             g.setColor(color);//设置画笔颜色
    131.             g.drawLine(random.nextInt(71), random.nextInt(31),
    132.                        random.nextInt(71), random.nextInt(31));
    133.         }
    134.  
    135.  
    136.         try {
    137.             ImageIO.write(image,"jpg",
    138.                           new FileOutputStream("./random.jpg"));
    139.             System.out.println("图片已生成");
    140.         } catch (IOException e) {
    141.             e.printStackTrace();
    142.         }
    143.  
    144.     }
    145.  
    146. //    public static void main(String[] args) {
    147. //        try {
    148. //            String line = "扫你妹!";
    149. //            //参数1:二维码上显示的文字，参数2:二维码图片生成的位置
    150.             QRCodeUtil.encode(line,"./qr.jpg");
    151. //
    152. //            //参数1:二维码上显示的文字，参数2:二维码中间的logo图，
    153. //            //参数3:二维码生成的位置，参数4:是否压缩logo图片的尺寸
    154.             QRCodeUtil.encode(line,"./logo.jpg",
    155.                       "./qr.jpg",true);
    156. //
    157. //            QRCodeUtil.encode(
    158. //                    line,   //二维码上显示的文字
    159. //                    "./logo.jpg",   //二维码中间的logo图
    160. //                    new FileOutputStream("./qr.jpg"),//生成的二维码数据会通过该流写出
    161. //                    true);//是否压缩logo图片的尺寸
    162. //
    163. //            System.out.println("二维码已生成");
    164. //        } catch (Exception e) {
    165. //            e.printStackTrace();
    166. //        }
    167. //    }
    168. }

    1.2.5UserController(用户业务)

    1. package com.webserver.controller;
    2.  
    3. import com.webserver.annotations.Controller;
    4. import com.webserver.annotations.RequestMapping;
    5. import com.webserver.entity.User;
    6. import com.webserver.http.HttpServletRequest;
    7. import com.webserver.http.HttpServletResponse;
    8. import org.apache.log4j.Logger;
    9.  
    10. import java.io.*;
    11. import java.util.ArrayList;
    12. import java.util.List;
    13.  
    14. /**
    15.  * 处理与用户相关的业务操作
    16.  */
    17. @Controller
    18. public class UserController {
    19.     private static Logger logger = Logger.getLogger(UserController.class);
    20.  
    21.     //表示users目录
    22.     private static File userDir;
    23.  
    24.     static {
    25.         userDir = new File("users");
    26.         if (!userDir.exists()) {
    27.             userDir.mkdirs();
    28.         }
    29.     }
    30.  
    31.     /**
    32.      * 生成展示所有用户信息的动态页面
    33.      *
    34.      * @param request
    35.      * @param response
    36.      */
    37.     @RequestMapping("/myweb/showAllUser")
    38.     public void showAllUser(HttpServletRequest request, HttpServletResponse response) {
    39.         /*
    40.             1:通过读取users目录下所有的obj文件，进行反序列化
    41.               得到所有的注册用户信息(若干的User对象)将他们存入一个List集合备用
    42.             2:拼接一个HTML页面，并将所有用户信息拼接到table表格中用于展示给用户
    43.             3:将拼接好的HTML代码作为正文给浏览器响应回去
    44.          */
    45.         //1
    46.         List<User> userList = new ArrayList<>();
    47.         /*
    48.             1.1:通过File的listFiles方法，从userDir目录下获取所有的obj文件
    49.                 要使用文件过滤器
    50.             1.2:遍历每一个obj文件，并利用对象流与文件流的连接，将obj文件中的
    51.                 User对象反序列化出来
    52.             1.3:将反序列化的User对象存入userList集合中
    53.          */
    54.         //1.1
    55.         File[] subs = userDir.listFiles(f -> f.getName().endsWith(".obj"));
    56.         //1.2
    57.         for (File userFile : subs) {
    58.             try (
    59.                     FileInputStream fis = new FileInputStream(userFile);
    60.                     ObjectInputStream ois = new ObjectInputStream(fis);
    61.             ) {
    62.                 User user = (User) ois.readObject();
    63.                 //1.3
    64.                 userList.add(user);
    65.             } catch (IOException e) {
    66.                 e.printStackTrace();
    67.             } catch (ClassNotFoundException e) {
    68.                 e.printStackTrace();
    69.             }
    70.         }
    71.  
    72.         System.out.println(userList);
    73.  
    74.         //2将数据拼接到html生成页面
    75.  
    76.         response.setContentType("text/html");
    77.  
    78.         PrintWriter pw = response.getWriter();
    79.         pw.println("<!DOCTYPE html>");
    80.         pw.println("<html lang=\"en\">");
    81.         pw.println("<head>");
    82.         pw.println("<meta charset=\"UTF-8\">");
    83.         pw.println("<title>用户列表</title>");
    84.         pw.println("</head>");
    85.         pw.println("<body>");
    86.         pw.println("<center>");
    87.         pw.println("<h1>用户列表</h1>");
    88.         pw.println("<table border=\"1\">");
    89.         pw.println("<tr>");
    90.         pw.println("<td>用户名</td>");
    91.         pw.println("<td>密码</td>");
    92.         pw.println("<td>昵称</td>");
    93.         pw.println("<td>年龄</td>");
    94.         pw.println("</tr>");
    95.         for (User user : userList) {
    96.             pw.println("<tr>");
    97.             pw.println("<td>" + user.getUsername() + "</td>");
    98.             pw.println("<td>" + user.getPassword() + "</td>");
    99.             pw.println("<td>" + user.getNickname() + "</td>");
    100.             pw.println("<td>" + user.getAge() + "</td>");
    101.             pw.println("</tr>");
    102.         }
    103.         pw.println("</table>");
    104.         pw.println("</center>");
    105.         pw.println("</body>");
    106.         pw.println("</html>");
    107.         System.out.println("页面已生成");
    108.  
    109.  
    110.  
    111.  
    112.  
    113.     }
    114.  
    115.     @RequestMapping("/myweb/login")
    116.     public void login(HttpServletRequest request, HttpServletResponse response) {
    117.         //1获取用户输入的登录信息
    118.         String username = request.getParameter("username");
    119.         String password = request.getParameter("password");
    120.         if (username == null || password == null) {
    121.             response.sendRedirect("/myweb/login_info_error.html");
    122.             return;
    123.         }
    124.  
    125.         //2
    126.         File userFile = new File(userDir, username + ".obj");
    127.         if (userFile.exists()) {//用户名输入正确
    128.             try (
    129.                     FileInputStream fis = new FileInputStream(userFile);
    130.                     ObjectInputStream ois = new ObjectInputStream(fis);
    131.             ) {
    132.                 //读取该注册用户信息
    133.                 User user = (User) ois.readObject();
    134.                 if (user.getPassword().equals(password)) {//密码正确
    135.                     //登录成功
    136.                     response.sendRedirect("/myweb/login_success.html");
    137.                     return;
    138.                 }
    139.             } catch (IOException | ClassNotFoundException e) {
    140.                 e.printStackTrace();
    141.             }
    142.         }
    143.  
    144.         //如果程序走到这里,情况1:用户名没有输入正确，文件不存在
    145.         //              情况2:用户名对了，但是密码不对
    146.         response.sendRedirect("/myweb/login_fail.html");
    147.  
    148.  
    149.     }
    150.  
    151.     @RequestMapping("/myweb/reg")
    152.     public void reg(HttpServletRequest request, HttpServletResponse response) {
    153.         logger.info("开始处理注册");
    154.         /*
    155.             1:获取用户在注册页面上输入的注册信息
    156.             2:将注册信息保存起来
    157.             3:给用户回馈一个注册结果页面
    158.          */
    159.         //1
    160.         //调用getParameter时传入的参数应当与页面上表单中输入框的名字一致(输入框name属性的值)
    161.         String username = request.getParameter("username");
    162.         String password = request.getParameter("password");
    163.         String nickname = request.getParameter("nickname");
    164.         String ageStr = request.getParameter("age");
    165.         logger.info(username + "," + password + "," + nickname + "," + ageStr);
    166.         /*
    167.             添加一个判断，要求:如果上述四个信息有null值或者年龄不是数字
    168.             立刻给用户响应一个错误提示页面:reg_info_error.html
    169.             该页面居中显示一行字:注册信息输入有误，请重新注册。
    171.             正则表达式:[0-9]+
    172.          */
    173.         if (username == null || password == null || nickname == null || ageStr == null ||
    174.                 !ageStr.matches("[0-9]+")) {
    175.             /*
    176.                http://localhost:8088/myweb/reg?username=fancq&password=123456&nickname=fcq&age=22
    178.                给浏览器发送的响应内容:
    179.                HTTP/1.1 302 Moved Temporarily(CRLF)
    180.                Location: /myweb/reg_info_error.html(CRLF)(CRLF)
    182.                浏览器接收到该响应后，根据状态代码302得知服务器希望他自动再发起一次请求
    183.                来请求指定的位置
    184.                指定的位置是哪里?浏览器根据响应头Location得知位置
    185.                此时得到的Location位置为:/myweb/reg_info_error.html
    187.                由于浏览器之前的请求(发起注册):
    188.                http://localhost:8088/myweb/reg?username=fancq&password=123456&nickname=fcq&age=22
    189.                因此浏览器理解本次重新请求的路径就是:
    190.                http://localhost:8088/myweb/reg_info_error.html
    191.              */
    192.             response.sendRedirect("/myweb/reg_info_error.html");
    193.             return;
    194.         }
    195.  
    196.         int age = Integer.parseInt(ageStr);
    197.         System.out.println(username + "," + password + "," + nickname + "," + age);
    198.  
    199.         //2
    200.         User user = new User(username, password, nickname, age);
    201.         File userFile = new File(userDir, username + ".obj");
    202.         /*
    203.             判断重名，如果是已注册用户，则响应页面:have_user.html告知
    204.             该页面居中显示一行字:该用户已存在，请重新注册。
    205.          */
    206.         if (userFile.exists()) {//该文件存在则说明是重复用户
    207.             response.sendRedirect("/myweb/have_user.html");
    208.             return;
    209.         }
    210.  
    211.  
    212.         try (
    213.                 FileOutputStream fos = new FileOutputStream(userFile);
    214.                 ObjectOutputStream oos = new ObjectOutputStream(fos);
    215.         ) {
    216.             //这里序列化的是注册用户信息，因此是user对象！！！！！！！！！！！！
    217.             oos.writeObject(user);
    218.  
    219.             //3
    220.             response.sendRedirect("/myweb/reg_success.html");
    221.         } catch (IOException e) {
    222.             e.printStackTrace();
    223.             logger.error(e.getMessage(), e);
    224.         }
    225.  
    226.  
    227.     }
    228.  
    229. }

    1.2.6ClientHandler(和浏览器建立响应的类)

    1. package com.webserver.core;
    2.  
    3. import com.webserver.http.EmptyRequestException;
    4. import com.webserver.http.HttpServletRequest;
    5. import com.webserver.http.HttpServletResponse;
    6.  
    7. import java.io.*;
    8. import java.lang.reflect.InvocationTargetException;
    9. import java.net.Socket;
    10. import java.net.URISyntaxException;
    11. import java.nio.charset.StandardCharsets;
    12. import java.util.HashMap;
    13. import java.util.Locale;
    14. import java.util.Map;
    15.  
    16. /**
    17.  * 该线程任务是负责与一个客户端进行一次HTTP交互
    18.  * 浏览器与服务端交互组从一问一答的原则。因此服务端处理一次HTTP交互，步骤如下:
    19.  * 1:解析请求(接受浏览器发送过来的请求内容)
    20.  * 2:处理请求(根据浏览器发送的请求理解其意图并进行对应的处理)
    21.  * 3:发送响应(将处理结果发送给浏览器)
    22.  *
    23.  *
    24.  */
    25. public class ClientHandler implements Runnable{
    26.     private Socket socket;
    27.     public ClientHandler(Socket socket){
    28.         this.socket = socket;
    29.     }
    30.  
    31.     public void run() {
    32.         try {
    33.             //1解析请求
    34.             HttpServletRequest request = new HttpServletRequest(socket);
    35.             HttpServletResponse response = new HttpServletResponse(socket);
    36.  
    37.             //2处理请求
    38.             DispatcherServlet servlet = new DispatcherServlet();
    39.             servlet.service(request,response);
    40.  
    41.             //3发送响应
    42.             response.response();
    43.  
    44.  
    45.  
    46.         } catch (IOException e) {
    47.             e.printStackTrace();
    48.         } catch (EmptyRequestException e) {
    49.  
    50.         } catch (ClassNotFoundException e) {
    51.             e.printStackTrace();
    52.         } catch (InvocationTargetException e) {
    53.             e.printStackTrace();
    54.         } catch (InstantiationException e) {
    55.             e.printStackTrace();
    56.         } catch (IllegalAccessException e) {
    57.             e.printStackTrace();
    58.         } finally {
    59.             try {
    60.                 //按照HTTP协议要求，一次交互后要断开连接
    61.                 socket.close();
    62.             } catch (IOException e) {
    63.                 e.printStackTrace();
    64.             }
    65.         }
    66.  
    67.     }
    68.  
    69.  
    70.  
    71.  
    72.  
    73. }

    1.2.7DispatcherServlet(处理业务的中转)

    1. package com.webserver.core;
    2.  
    3. import com.webserver.annotations.Controller;
    4. import com.webserver.annotations.RequestMapping;
    5. import com.webserver.controller.ArticleController;
    6. import com.webserver.controller.ToolsController;
    7. import com.webserver.controller.UserController;
    8. import com.webserver.http.HttpServletRequest;
    9. import com.webserver.http.HttpServletResponse;
    10.  
    11. import java.io.File;
    12. import java.io.IOException;
    13. import java.lang.reflect.InvocationTargetException;
    14. import java.lang.reflect.Method;
    15. import java.net.URISyntaxException;
    16. import java.nio.file.Files;
    17.  
    18. /**
    19.  * 负责处理请求环节
    20.  */
    21. public class DispatcherServlet {
    22.     private static File rootDir;
    23.     private static File staticDir;
    24.  
    25.     static {
    26.         try {
    27.             rootDir = new File(
    28.                     ClientHandler.class.getClassLoader()
    29.                             .getResource(".").toURI()
    30.             );
    31.             staticDir = new File(rootDir, "static");
    32.         } catch (URISyntaxException e) {
    33.             e.printStackTrace();
    34.         }
    35.     }
    36.  
    37.     public void service(HttpServletRequest request, HttpServletResponse response) throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException {
    38.         String path = request.getRequestURI();
    39.         //path:/myweb/index.html
    40.         //判断当前请求是否为请求业务
    41.         HandlerMapping.MethodMapping mm = HandlerMapping.getMethod(path);
    42.         if(mm!=null){
    43.             Method method = mm.getMethod();
    44.             Object controller = mm.getController();
    45.             method.invoke(controller,request,response);
    46.             return;
    47.         }
    48.  
    49.         File file = new File(staticDir, path);
    50.         System.out.println("资源是否存在:" + file.exists());
    51.         if (file.isFile()) {
    52.             //将请求的实际文件设置到response的正文上等待响应
    53.             response.setContentFile(file);
    54.         } else {
    55.             file = new File(staticDir, "/root/404.html");
    56.             //将404内容设置到response上等待响应
    57.             response.setStatusCode(404);
    58.             response.setStatusReason("NotFound");
    59.             response.setContentFile(file);
    60.         }
    61.  
    62.     }
    63. }

    1.2.8HandlerMapping(通过反射机制读取注解中的value)

    1. package com.webserver.core;
    2.  
    3. import com.webserver.annotations.Controller;
    4. import com.webserver.annotations.RequestMapping;
    5.  
    6. import java.io.File;
    7. import java.lang.reflect.Method;
    8. import java.net.URISyntaxException;
    9. import java.util.HashMap;
    10. import java.util.Map;
    11.  
    12. /**
    13.  * 使用当前类维护请求路径与对应的Controller中处理该请求的方法
    14.  * 使得DispatcherServlet在处理请求时判断是否为业务可以使用当前类完成。
    15.  */
    16. public class HandlerMapping {
    17.     public static Map<String,MethodMapping> mapping = new HashMap();
    18.     static{
    19.         initMapping();
    20.     }
    21.     private static void initMapping(){
    22.         try {
    23.             File rootDir = new File(HandlerMapping.class.getClassLoader().
    24.                                     getResource(".").toURI());
    25.             File dir = new File(rootDir,"/com/webserver/controller");
    26.             File[] files = dir.listFiles(f->f.getName().endsWith(".class"));
    27.             for(File file : files){
    28.                 String fileName = file.getName();
    29.                 String className = fileName.substring(0,fileName.indexOf("."));
    30.                 Class cls = Class.forName("com.webserver.controller."+className);
    31.                 //判断当前类是否为Controller(是否被@Controller标注)
    32.                 if(cls.isAnnotationPresent(Controller.class)){
    33.                     //将该Controller实例化
    34.                     Object controller = cls.newInstance();
    35.                     //获取该类中所有方法
    36.                     Method[] methods = cls.getDeclaredMethods();
    37.                     for(Method method : methods){
    38.                         //判断当前方法是否为处理业务的方法(是否被@RequestMapping标注)
    39.                         if(method.isAnnotationPresent(RequestMapping.class)){
    40.                             //获取注解@RequestMapping
    41.                             RequestMapping rm = method.getAnnotation(RequestMapping.class);
    42.                             /*
    43.                                 比如:
    44.                                 @Controller
    45.                                 public class UserController{
    46.                                     @RequestMapping("/myweb/reg")
    47.                                     public void reg(HttpServletRequest request,HttpServletResponse response){...}
    48.                                     ...
    49.                                 }
    51.                                 Object controller : UserController对象
    52.                                 Method method : reg()方法
    53.                                 String value : "/myweb/reg"
    54.                              */
    55.                             String value = rm.value();//该方法处理的请求路径
    56.                             MethodMapping mm = new MethodMapping(method,controller);
    57.                             mapping.put(value,mm);
    58.                         }
    59.                     }
    60.                 }
    61.             }
    62.         } catch (URISyntaxException e) {
    63.             e.printStackTrace();
    64.         } catch (ClassNotFoundException e) {
    65.             e.printStackTrace();
    66.         } catch (InstantiationException e) {
    67.             e.printStackTrace();
    68.         } catch (IllegalAccessException e) {
    69.             e.printStackTrace();
    70.         }
    71.     }
    72.  
    73.     /**
    74.      * 根据请求路径获取处理该请求的Controller以及对应的方法
    75.      * @param uri
    76.      * @return
    77.      */
    78.     public static MethodMapping getMethod(String uri){
    79.         return mapping.get(uri);
    80.     }
    81.  
    82.     public static void main(String[] args) {
    83.         mapping.forEach(
    84.                 (k,v)->{
    85.                     System.out.println("请求路径"+k);
    86.                     System.out.println("对应的处理方法:"+v.getMethod().getName());
    87.                 }
    88.         );
    89.     }
    90.  
    91.  
    92.     public static class MethodMapping{
    93.         //method.invoke(controller,...);
    94.         private Method method;      //方法对象
    95.         private Object controller;  //方法所属的Controller对象
    96.  
    97.         public MethodMapping(Method method, Object controller) {
    98.             this.method = method;
    99.             this.controller = controller;
    100.         }
    101.  
    102.         public Method getMethod() {
    103.             return method;
    104.         }
    105.  
    106.         public Object getController() {
    107.             return controller;
    108.         }
    109.     }
    110. }
    111.  
    112.  
    113.  
    114.  
    115.  
    116.  
    117.

    1.2.9WebServerApplication(项目的启动类)

    1. package com.webserver.core;
    2.  
    3. import java.io.IOException;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    6. import java.util.concurrent.Executor;
    7. import java.util.concurrent.ExecutorService;
    8. import java.util.concurrent.Executors;
    9.  
    10. /**
    11.  * WebServer主类
    12.  * WebServer是一个Web容器，实现了Tomcat的基础功能。
    13.  * 通过本次项目我们的目标是:
    14.  * 1:理解Tomcat底层工作原理
    15.  * 2:理解HTTP协议的规定
    16.  * 3:理解SpringBoot
    17.  */
    18. public class WebServerApplication {
    19.     private ServerSocket serverSocket;
    20.     private ExecutorService threadPool;
    21.  
    22.     /**
    23.      * 初始化WebServer
    24.      */
    25.     public WebServerApplication(){
    26.         try {
    27.             System.out.println("正在启动服务端...");
    28.             /*
    29.                 当端口被其他程序占用时，这里会抛出异常:
    30.                 java.net.BindException:address already in use:JVM
    31.                 解决:
    32.                 1:杀死该java进程(推荐)
    33.                 2:重启电脑(不推荐)
    34.                 3:更换端口(通常重启后还不行，说明被其他程序占用该端口了)
    35.              */
    36.             serverSocket = new ServerSocket(8088);
    37.             threadPool = Executors.newFixedThreadPool(50);
    38.  
    39.             System.out.println("服务端启动完毕!");
    40.         } catch (IOException e) {
    41.             e.printStackTrace();
    42.         }
    43.     }
    44.  
    45.     /**
    46.      * 服务端开始工作的方法
    47.      */
    48.     public void start(){
    49.         try {
    50.             while(true) {
    51.                 System.out.println("等待客户端连接...");
    52.                 Socket socket = serverSocket.accept();
    53.                 System.out.println("一个客户端连接了!");
    54.                 //启动一个线程处理该客户端交互
    55.                 ClientHandler clientHandler = new ClientHandler(socket);
    56.                 threadPool.execute(clientHandler);
    57.             }
    58.  
    59.         } catch (IOException e) {
    60.             e.printStackTrace();
    61.         }
    62.     }
    63.  
    64.     public static void main(String[] args) {
    65.         WebServerApplication webServerApplication = new WebServerApplication();
    66.         webServerApplication.start();
    67.     }
    68. }

    1.2.10Article(文章实体类)

    1. package com.webserver.entity;
    2.  
    3. import java.io.Serializable;
    4.  
    5. public class Article implements Serializable {
    6.     public static final long serialVersionUID = 1L;
    7.  
    8.     private String title;
    9.     private String author;
    10.     private String content;
    11.  
    12.     public Article(String title, String author, String content) {
    13.         this.title = title;
    14.         this.author = author;
    15.         this.content = content;
    16.     }
    17.  
    18.     public String getTitle() {
    19.         return title;
    20.     }
    21.  
    22.     public void setTitle(String title) {
    23.         this.title = title;
    24.     }
    25.  
    26.     public String getAuthor() {
    27.         return author;
    28.     }
    29.  
    30.     public void setAuthor(String author) {
    31.         this.author = author;
    32.     }
    33.  
    34.     public String getContent() {
    35.         return content;
    36.     }
    37.  
    38.     public void setContent(String content) {
    39.         this.content = content;
    40.     }
    41. }

    1.2.11User(用户实体类)

    1. package com.webserver.entity;//实体
    2.  
    3. import java.io.Serializable;
    4.  
    5. /**
    6.  * User的每一个实例用于表示一个注册用户信息
    7.  */
    8. public class User implements Serializable {
    9.     public static final long serialVersionUID = 1L;
    10.     private String username;
    11.     private String password;
    12.     private String nickname;
    13.     private int age;
    14.  
    15.     public User(){}
    16.  
    17.     public User(String username, String password, String nickname, int age) {
    18.         this.username = username;
    19.         this.password = password;
    20.         this.nickname = nickname;
    21.         this.age = age;
    22.     }
    23.  
    24.     public String getUsername() {
    25.         return username;
    26.     }
    27.  
    28.     public void setUsername(String username) {
    29.         this.username = username;
    30.     }
    31.  
    32.     public String getPassword() {
    33.         return password;
    34.     }
    35.  
    36.     public void setPassword(String password) {
    37.         this.password = password;
    38.     }
    39.  
    40.     public String getNickname() {
    41.         return nickname;
    42.     }
    43.  
    44.     public void setNickname(String nickname) {
    45.         this.nickname = nickname;
    46.     }
    47.  
    48.     public int getAge() {
    49.         return age;
    50.     }
    51.  
    52.     public void setAge(int age) {
    53.         this.age = age;
    54.     }
    55.  
    56.     @Override
    57.     public String toString() {
    58.         return "User{" +
    59.                 "username='" + username + '\'' +
    60.                 ", password='" + password + '\'' +
    61.                 ", nickname='" + nickname + '\'' +
    62.                 ", age=" + age +
    63.                 '}';
    64.     }
    65. }
    66.  
    67.  
    68.  
    69.  
    70.  
    71.  
    72.

    1.2.12EmptyRequestException(处理数组下标越界那个异常)

    1. package com.webserver.http;
    2.  
    3. /**
    4.  * 空请求异常
    5.  * 当HttpServletRequest解析请求过程中发现本次是空请求则会抛出该异常
    6.  */
    7. public class EmptyRequestException extends Exception{
    8.     public EmptyRequestException() {
    9.     }
    10.  
    11.     public EmptyRequestException(String message) {
    12.         super(message);
    13.     }
    14.  
    15.     public EmptyRequestException(String message, Throwable cause) {
    16.         super(message, cause);
    17.     }
    18.  
    19.     public EmptyRequestException(Throwable cause) {
    20.         super(cause);
    21.     }
    22.  
    23.     public EmptyRequestException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    24.         super(message, cause, enableSuppression, writableStackTrace);
    25.     }
    26. }
    27.  
    28.  
    29.  
    30.  
    31.  
    32.

    1.2.13HttpServletRequest(解析浏览器发送过来的请求)

    1. package com.webserver.http;
    2.  
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.io.UnsupportedEncodingException;
    6. import java.net.Socket;
    7. import java.net.URLDecoder;
    8. import java.nio.charset.StandardCharsets;
    9. import java.util.HashMap;
    10. import java.util.Map;
    11.  
    12. /**
    13.  * 请求对象
    14.  * 该类的每一个实例用于表示客户端发送过来的一个HTTP请求
    15.  * 每个请求由三部分构成:
    16.  * 请求行，消息头，消息正文
    17.  */
    18. public class HttpServletRequest {
    19.     private Socket socket;
    20.  
    21.     //请求行的相关信息
    22.     private String method;//请求方式
    23.     private String uri;//抽象路径
    24.     private String protocol;//协议版本
    25.  
    26.     private String requestURI;//uri中的请求部分,"?"左侧的内容
    27.     private String queryString;//uri中的参数部分,"?"右侧的内容
    28.     private Map<String,String> parameters = new HashMap<>();//每一组参数 key:参数名 value:参数值
    29.  
    30.  
    31.     //用一个Map保存所有的消息头，其中key:消息头名字，value:消息头的值
    32.     private Map<String,String> headers = new HashMap<>();
    33.  
    34.     public HttpServletRequest(Socket socket) throws IOException, EmptyRequestException {
    35.         this.socket = socket;
    36.         //1.1解析请求行
    37.         parseRequestLine();
    38.         //1.2解析消息头
    39.         parseHeaders();
    40.         //1.3解析消息正文
    41.         parseContent();
    42.     }
    43.  
    44.     //解析请求行
    45.     private void parseRequestLine() throws IOException, EmptyRequestException {
    46.         String line = readLine();
    47.         if(line.isEmpty()){//读取请求行是空串，则说明本次为空请求
    48.             throw new EmptyRequestException();
    49.         }
    50.  
    51.         System.out.println(line);
    52.         //将请求行按照空格拆分为三部分，并赋值给三个变量
    53.         String[] data = line.split("\\s");
    54.         method = data[0];
    55.         uri = data[1];
    56.         protocol = data[2];
    57.         parseURI();//进一步解析uri
    58.         //测试路径:http://localhost:8088/myweb/index.html
    59.         System.out.println("method:"+method);//method:GET
    60.         System.out.println("uri:"+uri);//uri:/myweb/index.html
    61.         System.out.println("protocol:"+protocol);//protocol:HTTP/1.1
    62.     }
    63.     //进一步解析URI
    64.     private void parseURI(){
    65.         /*
    66.             uri有两种情况:
    67.             1:不含有参数的
    68.               例如: /myweb/index.html
    69.               直接将uri的值赋值给requestURI即可.
    71.             2:含有参数的
    72.               例如:/myweb/reg?username=fancq&password=123456&nickname=chuanqi&age=22
    73.               将uri中"?"左侧的请求部分赋值给requestURI
    74.               将uri中"?"右侧的参数部分赋值给queryString
    75.               将参数部分首先按照"&"拆分出每一组参数，再将每一组参数按照"="拆分为参数名与参数值
    76.               并将参数名作为key，参数值作为value存入到parameters中。
    77.          */
    78.         String[] data = uri.split("\\?");
    79.         requestURI = data[0];
    80.         if(data.length>1){
    81.             queryString = data[1];
    82.             parseParameters(queryString);
    83.         }
    84.         System.out.println("requestURI:"+requestURI);
    85.         System.out.println("queryString:"+queryString);
    86.         System.out.println("parameters:"+parameters);
    87.     }
    88.     //解析参数
    89.     private void parseParameters(String line){
    90.         //将参数部分中的%XX内容转换为对应字符
    91.         try {
    92.             line = URLDecoder.decode(line,"UTF-8");
    93.         } catch (UnsupportedEncodingException e) {
    94.             e.printStackTrace();
    95.         }
    96.  
    97.         //首先按照"&"拆分出每一组参数
    98.         String[] data = line.split("&");
    99.         //遍历拆分后的数组取出每一组参数
    100.         for(String para : data){//username=fancq
    101.             //将每一组参数按照"="拆分为参数名和参数值
    102.             String[] paraArray = para.split("=");
    103.             //将参数名和参数值分别以key,value形式存入parameters(Map中)
    104.             parameters.put(paraArray[0], paraArray.length>1?paraArray[1]:null);
    105.         }
    106.     }
    107.  
    108.     //解析消息头
    109.     private void parseHeaders() throws IOException {
    110.         while(true) {
    111.             String line = readLine();
    112.             if(line.isEmpty()){//读取单独读取了CRLF则停止循环
    113.                 break;
    114.             }
    115.             System.out.println(line);
    116.             String[] data = line.split(":\\s");
    117.             headers.put(data[0].toLowerCase(),data[1]);
    118.  
    119.         }
    120.         System.out.println(headers);
    121.     }
    122.     //解析消息正文
    123.     private void parseContent() throws IOException {
    124.         /*
    125.             1:如何确定含有正文?
    126.              post请求才含有正文
    127.              判断请求方式是否为post请求
    129.             2:如果存在正文，则要先将正文读取回来。读取多少个字节呢?
    130.               通过消息头:Content-Length得知正文长度以便读取
    132.             3:如何判定该正文的所有字节表示什么内容呢?
    133.               通过消息头:Content-Type得知
    135.               这里我们仅处理一种:form表单提交的用户输入信息
    136.               Content-Type: application/x-www-form-urlencoded
    137.               如果是上面的类型，则正文是一个字符串，内容就是原GET请求提交时
    138.               在抽象路径中"?"右侧的内容。
    139.               格式如:
    140.               username=xxxxx&password=xxxx&....
    141.               因此当我们将正文转换为字符串后，要拆分参数来初始化:parameters
    143.               实际这里将来要写分支判断不同的类型，来进行不同的处理。
    144.          */
    145.         if("post".equalsIgnoreCase(method)){
    146.             //获取Content-Length
    147.             String contentLength = getHeader("content-length");
    148.             if(contentLength!=null){//确保存在正文长度
    149.                 //将长度转换为int值
    150.                 int length = Integer.parseInt(contentLength);
    151.                 System.out.println("正文长度:"+length);
    152.  
    153.                 //根据正文长度将正文内容读取回来
    154.                 InputStream in = socket.getInputStream();
    155.                 byte[] data = new byte[length];
    156.                 in.read(data);
    157.  
    158.                 //根据Content-Type的类型来对正文数据进行解析
    159.                 String contentType = getHeader("content-type");
    160.                 //将来根据不同的值对正文进行不同的解析操作，这里仅处理form提交的数据
    161.                 if("application/x-www-form-urlencoded".equalsIgnoreCase(contentType)){
    162.                     String line = new String(data, StandardCharsets.ISO_8859_1);
    163.                     System.out.println("正文内容:"+line);
    164.                     parseParameters(line);
    165.                 }
    166.                 //这里后期继续else if分支判断其他类型...
    167.  
    168.             }
    169.         }
    170.  
    171.     }
    172.  
    173.     /**
    174.      * 将读取一行字符串的操作定义成方法进行重用
    175.      * 通常复用代码的方法中如果需要处理异常时，通常都是直接抛出给调用者处理
    176.      * @return
    177.      */
    178.     private String readLine() throws IOException {
    179.         /*
    180.             socket对象无论调用多少次getInputStream和getOutputStream
    181.             获取回来的始终是同一条输入或输出流
    182.          */
    183.         InputStream in = socket.getInputStream();
    184.         int d ;
    185.         char cur='a',pre='a';//cur表示本次读取的字符,pre表示上次读取的字符
    186.         StringBuilder builder = new StringBuilder();
    187.         while((d = in.read()) != -1){
    188.             cur = (char)d;//本次读取到的字符
    189.             if(pre==13&&cur==10){//是否连续读取了回车+换行
    190.                 break;
    191.             }
    192.             builder.append(cur);
    193.             pre = cur;//在进行下一轮读取前，要将本次读取的字符记作"上次读取的字符"
    194.         }
    195.         return builder.toString().trim();//获取拼接好的一行字符串内容
    196.     }
    197.  
    198.     public String getMethod() {
    199.         return method;
    200.     }
    201.  
    202.     public String getUri() {
    203.         return uri;
    204.     }
    205.  
    206.     public String getProtocol() {
    207.         return protocol;
    208.     }
    209.  
    210.     public String getHeader(String name) {
    211.         return headers.get(name);
    212.     }
    213.  
    214.     public String getRequestURI() {
    215.         return requestURI;
    216.     }
    217.  
    218.     public String getQueryString() {
    219.         return queryString;
    220.     }
    221.  
    222.     /**
    223.      * 根据参数名获取对应的参数值
    224.      * @param name
    225.      * @return
    226.      */
    227.     public String getParameter(String name) {
    228.         //paratemers key:参数名(页面表单中输入框的名字)  value:参数值(输入框上用户输入的信息)
    229.         return parameters.get(name);
    230.     }
    231. }

    1.2.14HttpServletResponse(处理用户发送给浏览器的请求)

    1. package com.webserver.http;
    2.  
    3. import java.io.*;
    4. import java.net.Socket;
    5. import java.nio.charset.StandardCharsets;
    6. import java.nio.file.Files;
    7. import java.util.HashMap;
    8. import java.util.Map;
    9. import java.util.Map.Entry;
    10. import java.util.Set;
    11.  
    12. /**
    13.  * 响应对象
    14.  * 该类的每一个实例用于表示发送给客户端(浏览器)的一个HTTP响应内容
    15.  * 每个响应由三部分构成:
    16.  * 状态行，响应头，响应正文
    17.  */
    18. public class HttpServletResponse {
    19.     private Socket socket;
    20.  
    21.     //状态行相关信息
    22.     private int statusCode = 200;//状态代码，默认为200
    23.     private String statusReason = "OK";//状态描述，默认为OK
    24.  
    25.     //响应头相关信息
    26.     //key:响应头名字   value:响应头的值
    27.     private Map<String,String> headers = new HashMap<>();
    28.  
    29.  
    30.     //响应正文相关信息
    31.     private File contentFile;//响应正文对应的实体文件
    32.     private byte[] contentData;//以一组字节作为正文内容(通常动态数据使用)
    33.  
    34.     private ByteArrayOutputStream baos;
    35.  
    36.  
    37.  
    38.  
    39.     public HttpServletResponse(Socket socket){
    40.         this.socket = socket;
    41.     }
    42.  
    43.     /**
    44.      * 将当前响应对象内容按照标准的HTTP响应格式发送给浏览器
    45.      */
    46.     public void response() throws IOException {
    47.         //发送前的准备工作
    48.         sendBefore();
    49.         //3.1发送状态行
    50.         sendStatusLine();
    51.         //3.2发送响应头
    52.         sendHeaders();
    53.         //3.3将文件的所有字节作为正文内容发送给浏览器
    54.         sendContent();
    55.     }
    56.     //响应发送前的准备工作
    57.     private void sendBefore(){
    58.         if(baos!=null){//如果baos不为null，则说明用过这个流写出过动态数据
    59.             contentData = baos.toByteArray();//将内部的字节数组获取(动态数据)
    60.             addHeader("Content-Length",contentData.length+"");
    61.         }
    62.     }
    63.  
    64.  
    65.     //发送状态行
    66.     private void sendStatusLine() throws IOException {
    67.         println("HTTP/1.1" + " " + statusCode + " " + statusReason);
    68.     }
    69.     //发送响应头
    70.     private void sendHeaders() throws IOException {
    71.         /*
    72.             headers
    73.             KEY                 VALUE
    74.             Content-Type        text/html
    75.             Content-Length      2323
    76.             ...                  ...
    77.          */
    78.         //遍历headers将所有的响应头发送给浏览器
    79.         Set<Entry<String,String>> entrySet = headers.entrySet();
    80.         for(Entry<String,String> e : entrySet){
    81.             String key = e.getKey();
    82.             String value = e.getValue();
    83.             //println("Content-Type: text/html");
    84.             println(key + ": " + value);
    85.         }
    86.  
    87.         //单独发送回车+换行表示响应头部分发送完毕了
    88.         println("");
    89.     }
    90.     //发送响应正文
    91.     private void sendContent() throws IOException {
    92.         if(contentData!=null){//是否有动态数据作为正文
    93.             OutputStream out = socket.getOutputStream();
    94.             out.write(contentData);
    95.  
    96.         }else if(contentFile!=null) {
    97.             //try()意味着编译后有finally用于遍历流。所以这不违背try不能单独定义的原则
    98.             try (
    99.                     FileInputStream fis = new FileInputStream(contentFile);
    100.             ) {
    101.                 OutputStream out = socket.getOutputStream();
    102.                 byte[] buf = new byte[1024 * 10];//10kb
    103.                 int len;//记录每次实际读取到的字节数
    104.                 while ((len = fis.read(buf)) != -1) {
    105.                     out.write(buf, 0, len);
    106.                 }
    107.             }
    108.         }
    109.     }
    110.  
    111.  
    112.  
    113.  
    114.     private void println(String line) throws IOException {
    115.         OutputStream out = socket.getOutputStream();
    116.         byte[] data = line.getBytes(StandardCharsets.ISO_8859_1);
    117.         out.write(data);//发送状态行内容
    118.         out.write(13);//发送回车符
    119.         out.write(10);//发送换行符
    120.     }
    121.  
    122.     /**
    123.      * 重定向到uri指定的路径
    124.      * @param uri
    125.      */
    126.     public void sendRedirect(String uri){
    127.         //1设置状态代码位302
    128.         statusCode = 302;
    129.         statusReason = "Moved Temporarily";
    130.  
    131.         //2添加必要的响应头Location指定浏览器再次请求的位置
    132.         addHeader("Location",uri);
    133.     }
    134.  
    135.  
    136.     public int getStatusCode() {
    137.         return statusCode;
    138.     }
    139.  
    140.     public void setStatusCode(int statusCode) {
    141.         this.statusCode = statusCode;
    142.     }
    143.  
    144.     public String getStatusReason() {
    145.         return statusReason;
    146.     }
    147.  
    148.     public void setStatusReason(String statusReason) {
    149.         this.statusReason = statusReason;
    150.     }
    151.  
    152.     public File getContentFile() {
    153.         return contentFile;
    154.     }
    155.  
    156.     public void setContentFile(File contentFile) {
    157.         this.contentFile = contentFile;
    158.          /*
    159.                 根据正文文件类型来设置Content-Type用于告知浏览器该正文类型以便其理解.
    160.                 但是在HTTP协议中规定:如果发送响应时,不包含Content-Type响应头时,则是
    161.                 让浏览器自行理解正文类型.
    162.              */
    163.         try {
    164.             //该方法会自动分析文件对应的Content-Type值,若无法识别会返回null
    165.             //http://localhost:8088/TeduStore/index.html
    166.                 /*
    167.                     比如:file表示的是 index.html 文件
    168.                     该方法返回值为:"text/html"
    170.                         file表示的是 jquery.js 文件
    171.                     该方法那会的值为:"application/javascript"
    173.                  */
    174.             String type = Files.probeContentType(contentFile.toPath());
    175.             if(type!=null) {
    176.                 addHeader("Content-Type", type);
    177.             }
    178.         } catch (IOException e) {
    179.         }
    180.         addHeader("Content-Length",contentFile.length()+"");
    181.  
    182.  
    183.     }
    184.  
    185.     /**
    186.      * 添加一个响应头
    187.      * @param name
    188.      * @param value
    189.      */
    190.     public void addHeader(String name,String value){
    191.         headers.put(name,value);
    192.     }
    193.  
    194.     public OutputStream getOutputStream(){
    195.         if(baos==null){
    196.             baos = new ByteArrayOutputStream();
    197.         }
    198.         return baos;
    199.     }
    200.  
    201.     public PrintWriter getWriter(){
    202.         /*
    203.             进行流连接，创建一个PrintWrtier并最终连接到属性baos上
    204.             将该PrintWriter返回给外界使用。
    205.          */
    206.         OutputStream out = getOutputStream();//baos
    207.         OutputStreamWriter osw = new OutputStreamWriter(out,StandardCharsets.UTF_8);
    208.         BufferedWriter bw = new BufferedWriter(osw);
    209.         return new PrintWriter(bw,true);
    210.  
    211. //        return new PrintWriter(
    212. //                new BufferedWriter(
    213. //                        new OutputStreamWriter(
    214. //                                getOutputStream(),StandardCharsets.UTF_8
    215. //                        )
    216. //                ),true
    217. //        );
    218.     }
    219.  
    220.     /**
    221.      * 添加响应头Content-Type以及对应的值
    222.      * @param mime
    223.      */
    224.     public void setContentType(String mime){
    225.         addHeader("Content-Type",mime);
    226.     }
    227.  
    228. }

    1.3HTML代码

    1.3.1article_info_error.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>失败</title>
    6. </head>
    7. <body>
    8.   <center>
    9.     <h1>文章输入信息有误,请<a href="/myweb/writeArticle.html">重新发表</a></h1>
    10.   </center>
    11. </body>
    12. </html>

    1.3.2article_success.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>成功</title>
    6. </head>
    7. <body>
    8.   <center>
    9.     <h1>发表成功!</h1>
    10.   </center>
    11. </body>
    12. </html>

    1.3.3classTable.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>课程表</title>
    6. </head>
    7. <body>
    8.   <center>
    9.       <h1>课程表</h1>
    10.       <table border="1">
    11.           <tr>
    12.               <td>&nbsp;</td>
    13.               <td>星期一</td>
    14.               <td>星期二</td>
    15.               <td>星期三</td>
    16.               <td>星期四</td>
    17.               <td>星期五</td>
    18.           </tr>
    19.           <tr>
    20.               <td rowspan="4">上午</td>
    21.               <td>语文</td>
    22.               <td>数学</td>
    23.               <td>英语</td>
    24.               <td>体育</td>
    25.               <td>生物</td>
    26.           </tr>
    27.           <tr>
    28.               <td>生物</td>
    29.               <td>数学</td>
    30.               <td>英语</td>
    31.               <td>语文</td>
    32.               <td>体育</td>
    33.           </tr>
    34.           <tr>
    35.               <td>生物</td>
    36.               <td>数学</td>
    37.               <td>英语</td>
    38.               <td>语文</td>
    39.               <td>体育</td>
    40.           </tr>
    41.           <tr>
    42.               <td>生物</td>
    43.               <td>数学</td>
    44.               <td>英语</td>
    45.               <td>语文</td>
    46.               <td>体育</td>
    47.           </tr>
    48.           <tr>
    49.               <td colspan="6" align="center"><a href="http://www.bilibili.com">午休,bilibili一下</a></td>
    50.           </tr>
    51.           <tr>
    52.               <td rowspan="4">下午</td>
    53.               <td>语文</td>
    54.               <td>数学</td>
    55.               <td>英语</td>
    56.               <td>体育</td>
    57.               <td>生物</td>
    58.           </tr>
    59.           <tr>
    60.               <td>生物</td>
    61.               <td>数学</td>
    62.               <td>英语</td>
    63.               <td>语文</td>
    64.               <td>体育</td>
    65.           </tr>
    66.           <tr>
    67.               <td>生物</td>
    68.               <td>数学</td>
    69.               <td>英语</td>
    70.               <td>语文</td>
    71.               <td>体育</td>
    72.           </tr>
    73.           <tr>
    74.               <td>生物</td>
    75.               <td>数学</td>
    76.               <td>英语</td>
    77.               <td>语文</td>
    78.               <td>体育</td>
    79.           </tr>
    80.       </table>
    81.   </center>
    82. </body>
    83. </html>

    1.3.4createQR.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>二维码生成器</title>
    6. </head>
    7. <body>
    8.     <center>
    9.         <h1>二维码生成器</h1>
    10.         <form action="/myweb/createQR" method="post">
    11.             <table border="1">
    12.                 <tr>
    13.                     <td>内容</td>
    14.                     <td><input type="text" name="content"></td>
    15.                 </tr>
    16.                 <tr>
    17.                     <td align="center" colspan="2"><input type="submit" value="生成"></td>
    18.                 </tr>
    19.             </table>
    20.         </form>
    21.     </center>
    22. </body>
    23. </html>

    1.3.5have_article.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>失败</title>
    6. </head>
    7. <body>
    8.   <center>
    9.     <h1>该文章已经存在了,请<a href="/myweb/writeArticle.html">重新发表</a></h1>
    10.   </center>
    11. </body>
    12. </html>

    1.3.6have_user.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>失败</title>
    6. </head>
    7. <body>
    8.   <center>
    9.     <h1>该用户已存在，请<a href="/myweb/reg.html">重新注册</a></h1>
    10.   </center>
    11. </body>
    12. </html>

    1.3.7index.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>我的首页</title>
    6. </head>
    7. <body>
    8. <!--
    9.      <h1>-<h6>:标题，分为1-6级标题。标题独占一行
    10.      <center>:居中，该标签在HTML5中已经不再建议使用了。没学习样式前临时使用
    11.      <input>:输入组件。它是一套组件，用来在页面上获取用户输入的。
    13.              属性type决定着该组件的样式。
    14.              常见的值有:
    15.                  text:文本框
    16.                  button:按钮
    17.                  checkbox:多选框
    18.                  radio:单选框
    19.                  submit:提交按钮
    20.                  password:密码框
    21.      <a>:超链接，标签中间的文本是超链接对应的文字，属性href用于指定跳转的路径
    22.      <br>:换行
    23.      <table>标签:表格。属性border用于指定边框。
    24.                  <table>标签中包含<tr>标签用于表示行
    25.                  <tr>标签中包含<td>标签用于表示列
    26.                  <td>标签中常见属性:
    27.                  align:对其方式。left左对齐,right右对齐,center剧中对其
    28.                  colspan:跨列合并列，合并是从左向右合并列
    29.                  rowspan:跨行合并列，合并是从上向下合并列
    31.      <img>:图片标签，src属性用于指定图片的路径
    33.      在页面上我们经常会使用路径去定位页面上要使用的额外资源，比如CSS文件，JS文件
    34.      图片文件等。
    35.      例如图片:
    36.      <img src=""> 这里的src就是用于指定图片的路径的
    37.      路径分两种:相对路径和绝对路径
    38.      相对路径常用的:"./",即:当前目录
    39.      在浏览器中和我们在java源代码中"./"位置不是相同的！！！！！！
    40.      原因是页面是被浏览器理解的。
    42.      在页面上"./"的位置浏览器理解的是:URL地址当中抽象路径里的最后一个"/"的位置
    43.      例如:
    44.      请求inde.html时，我们在地址栏上输入的路径为:
    45.      http://localhost:8088/myweb/index.html
    46.      在这个页面上我们使用了<img src="logo.png"> 注:不写"./"默认就是从"./"开始
    47.      此时浏览器判定该图片的实际位置是哪里，就是根据请求当前页面的URL地址决定:
    48.      当前URL地址中抽象路径部分为:/myweb/index.html
    49.      因此"./"理解的就是这里最后一个"/"的位置为:/myweb/
    50.                                                ^
    51.                                             ./的位置
    53.      所以确定了图片的抽象路径部分为:/myweb/logo.png
    54.      因此浏览器实际请求图片的路径为:
    55.      http://localhost:8088/myweb/logo.png
    58.      绝对路径:"/",即:根
    59.      在页面上"/"的位置浏览器理解的是:URL地址当中抽象路径里的第一个"/"的位置
    60.      同样，如果在当前页面上<img src="/myweb/logo.png">
    61.      此时浏览器理解的"/myweb/logo.png"发先路径从"/"开始，即:从根开始。
    62.      请求当前页面路径:http://localhost:8088/myweb/index.html
    63.                                         ^
    64.                                    就是抽象路径的根
    66.      因此该图片实际请求位置:
    67.      http://localhost:8088/myweb/logo.png
    70.      相对路径存在定位不准确情况，常见于服务端转发404时
    71.      例如:请求一个不存在的页面
    72.      http://localhost:8088/myweb/123.html
    73.      服务端发现该页面不存在后，就响应了root目录下的404.html
    74.      而404页面上我们指定图片如果为:<img src="404.png">
    75.      那么浏览器在得到404页面时，理解的404图片实际位置是哪里?
    76.      由于浏览器是请求 http://localhost:8088/myweb/123.html看到的404页面
    77.      因此浏览器会参考该地址中抽象路径部分:/myweb/123.html来分析404图片位置
    78.      由于"./404.png"中的"./"是当前目录，因此浏览器认为该图片的抽象路径应当为:
    79.      "/myweb/404.png"于是请求了:http://localhost:8088/myweb/404.png
    81.      为了定位准确，我们选取绝对路径中的根"/"
    82.      <img src="/root/404.png">
    86.  -->
    87.     <center>
    88.         <!--<h1>百度</h1>-->
    89.         <img src="/myweb/logo.png"><br>
    90.         <input type="text" size="32">
    91.         <input type="button" value="百度一下" onclick="alert('点你妹啊!')">
    92.         <br>
    93.         <a href="/myweb/reg.html">注册</a>
    94.         <a href="/myweb/login.html">登录</a>
    95.         <a href="/myweb/showAllUser">用户列表</a>
    96.         <br>
    97.         <a href="/myweb/writeArticle.html">发表文章</a>
    98.         <br>
    99.         <a href="/myweb/createQR.html">二维码生成器</a>
    100.         <br>
    101.         <a href="http://www.taobao.com">淘宝</a>
    102.         <br>
    103.         <table border="1">
    104.             <tr>
    105.                 <td>第一列</td>
    106.                 <td>第二列</td>
    107.                 <td colspan="2" align="center">第三列</td>
    108.             </tr>
    109.             <tr>
    110.                 <td rowspan="2">第一列</td>
    111.                 <td>第二列</td>
    112.                 <td>第三列</td>
    113.                 <td>第四列</td>
    114.             </tr>
    115.             <tr>
    116.                 <td>第二列</td>
    117.                 <td>第三列</td>
    118.                 <td>第四列</td>
    119.             </tr>
    120.         </table>
    121.     </center>
    122.  
    123. </body>
    124. </html>

    1.3.8login.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>用户登录</title>
    6. </head>
    7. <body>
    8.     <center>
    9.         <h1>用户登录</h1>
    10.         <form action="/myweb/login" method="post">
    11.             <table border="1">
    12.                 <tr>
    13.                     <td>用户名</td>
    14.                     <td><input name="username" type="text"></td>
    15.                 </tr>
    16.                 <tr>
    17.                     <td>密码</td>
    18.                     <td><input name="password" type="password"></td>
    19.                 </tr>
    20.                 <tr>
    21.                     <td colspan="2" align="center"><input type="submit" value="登录"></td>
    22.                 </tr>
    23.             </table>
    24.         </form>
    25.     </center>
    26. </body>
    27. </html>

    1.3.9login_fail.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>失败</title>
    6. </head>
    7. <body>
    8.     <center>
    9.         <h1>登录失败，用户名或密码不正确!请<a href="/myweb/login.html">重新登录</a></h1>
    10.     </center>
    11. </body>
    12. </html>

    1.3.10login_info_error.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>错误</title>
    6. </head>
    7. <body>
    8.     <center>
    9.         <h1>登录信息输入有误，请<a href="/myweb/login.html">重新登录</a></h1>
    10.     </center>
    11. </body>
    12. </html>

    1.3.11login_success.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>成功</title>
    6. </head>
    7. <body>
    8.     <center>
    9.         <h1>登录成功，欢迎回来!</h1>
    10.     </center>
    11. </body>
    12. </html>

    1.3.12reg.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>用户注册</title>
    6. </head>
    7. <body>
    8.     <center>
    9.         <h1>用户注册</h1>
    10.         <!--
    11.             表单组件<form>
    12.             表单用于将用于在页面上输入的信息提交给服务端使用的组件。
    13.             表单上有两个重要的属性:
    14.             action:用于指定表单提交的路径
    15.             method:用于指定表单提交的方式，该方式有两个可选值
    16.                     GET:地址栏形式提交，表单数据会被拼接到URL的抽象路径中
    17.                     POST:打包提交，表单数据会被包含在请求的消息正文中。
    18.                          当表单数据含有用户隐私信息或附件时则需要使用POST形式提交表单。
    19.                     method属性不指定时，默认为GET形式提交表单。
    20.             注意:所有输入组件只有被包含在form表单中并且必须使用name属性为该组件取名字才会被提交！！
    21.                 输入组件取的名字可以任意定义，但是不能有中文(英文数字)。
    23.             http://localhost:8088/myweb/reg?username=fancq&password=123456&nickname=chuanqi&age=22
    24.             表单提交后的URL中抽象路径:
    25.             /myweb/reg?username=fancq&password=123456&nickname=chuanqi&age=22
    27.             URL地址中抽象路径部分可以使用"?"分隔为两块,分别是请求部分和参数部分
    28.             请求部分由表单action决定.参数部分由表单中输入框决定
    29.             格式:
    30.             请求部分?输入框1名字=输入框1信息&输入框2名字=输入框2信息&.....
    31.          -->
    32.         <form action="/myweb/reg" method="get">
    33.             <table border="1">
    34.               <tr>
    35.                 <td>用户名</td>
    36.                 <td><input name="username" type="text"></td>
    37.               </tr>
    38.               <tr>
    39.                 <td>密码</td>
    40.                 <td><input name="password" type="password"></td>
    41.               </tr>
    42.               <tr>
    43.                 <td>昵称</td>
    44.                 <td><input name="nickname" type="text"></td>
    45.               </tr>
    46.               <tr>
    47.                 <td>年龄</td>
    48.                 <td><input name="age" type="text"></td>
    49.               </tr>
    50.                 <tr>
    51.                     <td><img src="/myweb/random.jpg"></td>
    52.                     <td><input name="code" type="text"></td>
    53.                 </tr>
    54.               <tr>
    55.                 <td colspan="2" align="center">
    56.                   <input type="submit" value="注册">
    57.                 </td>
    58.               </tr>
    59.             </table>
    60.         </form>
    61.     </center>
    62. </body>
    63. </html>

    1.3.13reg_info_error.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>失败</title>
    6. </head>
    7. <body>
    8.   <center>
    9.     <h1>注册信息输入有误，请<a href="/myweb/reg.html">重新注册</a></h1>
    10.   </center>
    11. </body>
    12. </html>

    1.3.14reg_success.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>成功</title>
    6. </head>
    7. <body>
    8.   <center>
    9.     <h1>恭喜您，注册成功了!</h1>
    10.   </center>
    11. </body>
    12. </html>

    1.3.15writeArticle.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>发表文章</title>
    6. </head>
    7. <body>
    8.     <center>
    9.         <h1>发表文章</h1>
    10.         <form action="/myweb/writeArticle" method="get">
    11.             <table border="1">
    12.                 <tr>
    13.                     <td>标题</td>
    14.                     <td><input name="title" type="text"></td>
    15.                 </tr>
    16.                 <tr>
    17.                     <td>作者</td>
    18.                     <td><input name="author" type="text"></td>
    19.                 </tr>
    20.                 <tr>
    21.                     <td>内容</td>
    22.                     <td><textarea cols="50" rows="10" name="content"></textarea></td>
    23.                 </tr>
    24.                 <tr>
    25.                     <td colspan="2" align="center"><input type="submit" value="发表"></td>
    26.                 </tr>
    27.             </table>
    28.         </form>
    29.     </center>
    30. </body>
    31. </html>

    1.3.16 404.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>404</title>
    6. </head>
    7. <body>
    8.   <center>
    9.     <img src="/root/404.png">
    10.     <h1>404,资源不存在!</h1>
    11.   </center>
    12. </body>
    13. </html>

    1.4(配置文件)

    1.4.1pom.xml

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0</modelVersion>
    6.  
    7.     <groupId>org.example</groupId>
    8.     <artifactId>WebServer</artifactId>
    9.     <packaging>pom</packaging>
    10.     <version>1.0-SNAPSHOT</version>
    11.     <modules>
    12.         <module>V1</module>
    13.         <module>V2</module>
    14.         <module>V3</module>
    15.         <module>V4</module>
    16.         <module>V5</module>
    17.         <module>V6</module>
    18.         <module>V7</module>
    19.         <module>V8</module>
    20.         <module>V9</module>
    21.         <module>V10</module>
    22.         <module>V11</module>
    23.         <module>V12</module>
    24.         <module>V13</module>
    25.         <module>V14</module>
    26.         <module>V15</module>
    27.         <module>V16</module>
    28.         <module>V17</module>
    29.         <module>V18</module>
    30.         <module>V19</module>
    31.         <module>V20</module>
    32.         <module>V21</module>
    33.         <module>V22</module>
    34.         <module>V23</module>
    35.         <module>V24</module>
    36.         <module>V25</module>
    37.         <module>V26</module>
    38.         <module>V27</module>
    39.     </modules>
    40.  
    41.     <properties>
    42.         <!-- 设置 JDK 版本为 1.8 -->
    43.         <maven.compiler.target>1.8</maven.compiler.target>
    44.         <maven.compiler.source>1.8</maven.compiler.source>
    45.         <!-- 设置编码为 UTF-8 -->
    46.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    47.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    48.         <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
    49.     </properties>
    50.  
    51.     <dependencies>
    52.         <dependency>
    53.             <groupId>org.slf4j</groupId>
    54.             <artifactId>slf4j-log4j12</artifactId>
    55.             <version>1.7.25</version>
    56.         </dependency>
    57.  
    58.     </dependencies>
    59.  
    60. </project>

    1.4.2log4j.properties

    1. log4j.rootLogger=INFO, console, file
    2. log4j.appender.console=org.apache.log4j.ConsoleAppender
    3. log4j.appender.console.layout=org.apache.log4j.PatternLayout
    4. log4j.appender.console.layout.ConversionPattern=%d %p [%c] - %m%n
    5. log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
    6. log4j.appender.file.File=logs/log.log
    7. log4j.appender.file.layout=org.apache.log4j.PatternLayout
    8. log4j.appender.A3.MaxFileSize=1024KB
    9. log4j.appender.A3.MaxBackupIndex=10
    10. log4j.appender.file.layout.ConversionPattern=%d %p [%c] - %m%n

    1.4.3pom.xml(配置文件中标签的含义)

    1. <project ><!-- 声明规范：pom版本标签（必须要的），表示是一个固定的版本，指定了当前pom的版本 -->
    2.  
    3.     <modelVersion><!--声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变，虽然如此，但它仍然是必不可少的，
    4.                                           这是为了当Maven引入了新的特性或者其他模型变更的时候，确保稳定性。 -->
    5.  
    6.     <groupId><!--项目的组织标识符，对应src/main目录下的Java的目录结构。
    7.                                       例如，本项目中的com.manage.maven既是项目组织标识符，也是src/main目录下的Java代码包。-->
    8.  
    9.     <artifactId><!--项目的标识符，可用来区分不同的项目。例如，本项目中是hello-maven也可以是test-maven。-->
    10.  
    11.     <packaging><!--项目产生的构件类型，例如jar、war、ear、pom。插件可以创建他们自己的构件类型，所以前面列的不是全部构件类型 -->
    12.  
    13.     <version><!--项目的版本号，项目打包后的JAR文件的版本号跟这里对应。-->
    14.  
    15.     <modules>模块根目录
    16.         <module>V1</module>模块
    17.         
    18.  
    19.     <properties><!--有时候对于同一个技术需要编写很多个依赖引入相关的jar包，每个依赖中都要填写版本号，倘若更换版本号的话，修改的地方比较多，
    20.                     所以可以使用properties统一管理版本号，logback-version可以自由命名，通过${}方式进行引用：-->
    21.         <!-- 设置 JDK 版本为 1.8 -->
    22.         <maven.compiler.target>1.8</maven.compiler.target>
    23.         <maven.compiler.source>1.8</maven.compiler.source>
    24.         <!-- 设置编码为 UTF-8 -->
    25.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    26.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    27.         <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
    28.     </properties>
    29.  
    30.     <dependencies><!--一个完整的JAR依赖配置。-->
    31.         <dependency><!--我们要使用的jar包的gav信息放到这里，这样maven就可以自动下载相关jar包了。-->
    32.             <groupId>org.slf4j</groupId>
    33.             <artifactId>slf4j-log4j12</artifactId>
    34.             <version>1.7.25</version>
    35.         </dependency>
    36.     </dependencies>
    37.  
    38.  
    39. </project>

    1.5代码执行流程

     上诉项目一共写了27个版本想看那个版本做了什么的去看JSD第二阶段

  • 相关阅读:
    Spring Boot 笔记 021 项目部署
    Elk-Metricbeat配置Tomcat的日志分析 (Metricbeat-part3)
    Electron之单例+多窗口
    CenOS7各种自启动配置
    NLP工具——Stanza设置GPU device
    Vue.js 事件监听全解析
    如何利用Api接口获取手机当前的网络位置信息
    Redis启停脚本
    ES6 入门—ES6 迭代器
    【Spring源码】8. 捋下invokeBeanFactoryPostProcessors()主要处理流程
  • 原文地址：https://blog.csdn.net/TheNewSystrm/article/details/125436380