• JSD-2204-WebServer(项目终章)-Day18

    1.V25(版本)

    利用反射机制重构DispatcherServlet,使得将来添加新的业务时DispatcherServlet
不必再添加分支判断(不进行修改)

实现:
1:新建包com.webserver.annotation
2:在annotation包下添加两个注解
  @Controller:用于标注哪些类是处理业务的Controller类
  @RequestMapping:用于标注处理某个业务请求的业务方法
3:将com.webserver.controller包下的所有Controller类添加注解@Controller
  并将里面用于处理某个业务的方法标注@RequestMapping并指定该方法处理的请求
4:DispatcherServlet在处理请求时,先扫描controller包下的所有Controller类
  并找到处理该请求的业务方法,使用反射调用.

    1.1项目目录

    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.3ClientHandler

    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.4DispatcherServlet

    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.         //根据请求路径判断是否为处理某个业务
    40.         /*
    41.             当我们得到本次请求路径path的值后，我们首先要查看是否为请求业务:
    42.             1:扫描controller包下的所有类
    43.             2:查看哪些被注解@Controller标注的过的类(只有被该注解标注的类才认可为业务处理类)
    44.             3:遍历这些类，并获取他们的所有方法，并查看哪些时业务方法
    45.               只有被注解@RequestMapping标注的方法才是业务方法
    46.             4:遍历业务方法时比对该方法上@RequestMapping中传递的参数值是否与本次请求
    47.               路径path值一致?如果一致则说明本次请求就应当由该方法进行处理
    48.               因此利用反射机制调用该方法进行处理。
    49.             5:如果扫描了所有的Controller中所有的业务方法，均未找到与本次请求匹配的路径
    50.               则说明本次请求并非处理业务，那么执行下面请求静态资源的操作
    51.          */
    52.         File dir = new File(rootDir,"/com/webserver/controller");
    53.         File[] files = dir.listFiles(f->f.getName().endsWith(".class"));
    54.         for(File file : files){
    55.             String fileName = file.getName();
    56.             String className = fileName.substring(0,fileName.indexOf("."));
    57.             Class cls = Class.forName("com.webserver.controller."+className);
    58.             //判断当前类是否为Controller(是否被@Controller标注)
    59.             if(cls.isAnnotationPresent(Controller.class)){
    60.                 //获取该类中所有方法
    61.                 Method[] methods = cls.getDeclaredMethods();
    62.                 for(Method method : methods){
    63.                     //判断当前方法是否为处理业务的方法(是否被@RequestMapping标注)
    64.                     if(method.isAnnotationPresent(RequestMapping.class)){
    65.                         //获取注解@RequestMapping
    66.                         RequestMapping rm = method.getAnnotation(RequestMapping.class);
    67.                         String value = rm.value();
    68.                         //判断该注解上的参数值是否与本次请求路径一致？若一致说明就是该方法处理这个请求
    69.                         if(value.equals(path)){
    70.                             //实例化当前Controller
    71.                             Object controller = cls.newInstance();
    72.                             //调用当前方法处理该请求
    73.                             method.invoke(controller,request,response);
    74.                             return;//当业务处理完毕直接return,防止执行下面请求静态资源的逻辑
    75.                         }
    76.                     }
    77.                 }
    78.             }
    79.  
    80.         }
    81.  
    82.  
    83.  
    84.         File file = new File(staticDir, path);
    85.         System.out.println("资源是否存在:" + file.exists());
    86.         if (file.isFile()) {
    87.             //将请求的实际文件设置到response的正文上等待响应
    88.             response.setContentFile(file);
    89.         } else {
    90.             file = new File(staticDir, "/root/404.html");
    91.             //将404内容设置到response上等待响应
    92.             response.setStatusCode(404);
    93.             response.setStatusReason("NotFound");
    94.             response.setContentFile(file);
    95.         }
    96.  
    97.     }
    98. }

    1.3HTML文件

    和之前的版本一样

    2.V26版本

    重构代码
上一个版本那种DispatcherServlet每次处理请求时都要扫描controller包,这样性能
底下.因此改为仅扫描一次.

实现:
1:在com.webserver.core包下新建类HandlerMapping
2:定义静态属性Map mapping
  key:请求路径
  value:MethodMapping(内部类),记录处理该请求的方法对象和该方法所属对象
3:在静态块中初始化,完成原DispatcherServlet扫描controller包的工作并初始化map
4:提供静态方法:getMethod可根据请求路径获取处理该请求的方法
5:在DispatcherServlet中处理业务时只需要根据请求获取对应的处理方法利用反射
  机制调用即可

    2.1项目目录

     2.2Java文件

    2.2.1ClientHandler

    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. }

    2.2.2DispatcherServlet

    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. }

    2.2.3HandlerMapping

    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.

    2.3HTML文件

    没有改动

  • 相关阅读:
    Mac版本如何安装docker
    oauth2的知识点
    基于vue和nodejs毕业设计电影购票微信小程序影院
    leetCode 746. 使用最小花费爬楼梯
    SpringCloud搭建微服务之OAuth2实现SSO单点登录
    python 线程 （概念+示例代码）
    Leetcode刷题_贪心相关_c++版
    提高 Web 开发效率的10个VS Code扩展插件，你知道吗？
    【C++】最通俗的多态、虚表、虚指针讲解
    基于 HarmonyOS 的 HTTPS 请求过程开发示例（ArkTS）
  • 原文地址：https://blog.csdn.net/TheNewSystrm/article/details/125433395