• 项目实战：中央控制器实现(1)-基本功能实现-调用Controller中的方法

    1、DispatcherServlet 

    1. package com.csdn.mymvc.core;
    2. import jakarta.servlet.RequestDispatcher;
    3. import jakarta.servlet.ServletContext;
    4. import jakarta.servlet.ServletException;
    5. import jakarta.servlet.annotation.WebServlet;
    6. import jakarta.servlet.http.HttpServlet;
    7. import jakarta.servlet.http.HttpServletRequest;
    8. import jakarta.servlet.http.HttpServletResponse;
    9. import org.junit.Test;
    10. import java.io.IOException;
    11. import java.lang.reflect.InvocationTargetException;
    12. import java.lang.reflect.Method;
    13. import java.util.Arrays;
    14. import java.util.Map;
    15. @WebServlet("/*")
    16. public class DispatcherServlet extends HttpServlet {
    17.  
    18.     private final String BEAN_FACTORY = "beanFactory";
    19.     private final String CONTROLLER_BEAN_MAP = "controllerBeanMap";
    20.  
    21.     @Test
    22.     public void uri() {
    23.         String uri = "/fruit/index";
    24.         String[] arr = uri.split("/");
    25.         System.out.println(Arrays.toString(arr));//[, fruit, index]
    26.     }
    27.     @Override
    28.     protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    29.         String[] staticResourceSuffixes = {".html", ".jsp", ".jpg", ".png", ".gif", ".css", ".js", ".ico"};
    30.         String uri = req.getRequestURI();
    31.         if (Arrays.stream(staticResourceSuffixes).anyMatch(uri::endsWith)) {
    32.             RequestDispatcher defaultDispatcher = req.getServletContext().getNamedDispatcher("default");
    33.             defaultDispatcher.forward(req, resp);
    34.         } else {
    35.  
    36.             String[] arr = uri.split("/");
    37.  
    38.             if (arr == null || arr.length != 3) {
    39.                 throw new RuntimeException(uri + "非法！");
    40.             }
    41.  
    42.             //[, fruit, index]
    43.             String requestMapping = "/" + arr[1];
    44.             String methodMapping = "/" + arr[2];
    45.  
    46.             ServletContext application = getServletContext();
    47.             ControllerDefinition controllerDefinition = ((Map) application.getAttribute(CONTROLLER_BEAN_MAP)).get(requestMapping);
    48.  
    49.             if (controllerDefinition == null) {
    50.                 throw new RuntimeException(requestMapping + "对应的controller组件不存在！");
    51.             }
    52.             //获取请求方式，例如：get或者post
    53.             String requestMethodStr = req.getMethod().toLowerCase();
    54.             //get_/index
    55.             Method method = controllerDefinition.getMethodMappingMap().get(requestMethodStr + "_" + methodMapping);
    56.             Object controllerBean = controllerDefinition.getControllerBean();
    57.  
    58.             try {
    59.                 //调用controllerBean对象中的method方法
    60.                 method.setAccessible(true);
    61.                 method.invoke(controllerBean, req, resp);
    62.             } catch (IllegalAccessException e) {
    63.                 e.printStackTrace();
    64.                 throw new RuntimeException(e);
    65.             } catch (InvocationTargetException e) {
    66.                 e.printStackTrace();
    67.                 throw new RuntimeException(e);
    68.             }
    69.  
    70.         }
    71.     }
    72. }

    2、ControllerDefinition 

    1. package com.csdn.mymvc.core;
    2. import lombok.AllArgsConstructor;
    3. import lombok.Data;
    4. import lombok.NoArgsConstructor;
    5. import java.lang.reflect.Method;
    6. import java.util.HashMap;
    7. import java.util.Map;
    8. //假设有一个uri是：/fruit/index
    9. @Data
    10. @NoArgsConstructor
    11. @AllArgsConstructor
    12. public class ControllerDefinition {
    13.     private String requestMapping;
    14.     private Object controllerBean;
    15.     private Map methodMappingMap = new HashMap<>();
    16. }

    3、ComponentScan

    1. package com.csdn.mymvc.core;
    2. import com.csdn.mymvc.annotation.*;
    3. import java.io.File;
    4. import java.lang.annotation.Annotation;
    5. import java.lang.reflect.Field;
    6. import java.lang.reflect.InvocationTargetException;
    7. import java.lang.reflect.Modifier;
    8. import java.util.*;
    9. public class ComponentScan {
    10.     public static Map beanFactory = new HashMap<>();
    11.     public static Map controllerBeanMap = new HashMap<>();
    12.     static String path = null;
    13.     static {
    14.         //分析文件夹
    15.         path = ComponentScan.class.getClassLoader().getResource("").getPath();
    16.         //  /F:/IdeaProjects/workspace/review/pro13-fruit-DispatcherServlet/target/
    17.         //  pro13-fruit-DispatcherServlet-1.0-SNAPSHOT/WEB-INF/classes/
    18.         //计算机的硬盘根目录是 / ，不论是什么操作系统。只是微软人为的分出盘符的概念
    19.         //System.out.println(path);
    20.         path = path.substring(1);
    21.         //System.out.println(path);
    22.         //   F:/IdeaProjects/workspace/review/pro13-fruit-DispatcherServlet/target
    23.         //   /pro13-fruit-DispatcherServlet-1.0-SNAPSHOT/WEB-INF/classes/
    24.         File rootDir = new File(path);
    25.         //开始解析文件夹 - 组件扫描工作开始
    26.         try {
    27.             //第 1 步：扫描类路径，解析出所有的bean实例，存放到IOC容器中(beanFactory)
    28.             parseFile(rootDir);
    29.             beanFactory.values().forEach(System.out::println);
    30.             //第 2 步：经过第 1 步，所有的bean实例已经创建就绪，但是bean和bean之间的依赖关系没有注入(Injection)
    31.             //本步骤实现 注入依赖关系
    32.             beanFactory.values().forEach(bean -> {
    33.                 //获取bean内部所有的field
    34.                 Field[] fields = bean.getClass().getDeclaredFields();
    35.                 //获取每一个field上的注解信息
    36.                 Arrays.stream(fields)
    37.                         .filter(field -> field.getDeclaredAnnotation(Autowire.class) != null)
    38.                         .forEach(field -> {
    39.                             //获取这个字段的类型的名称
    40.                             String fieldTypeName = field.getType().getName();
    41.                             //System.out.println(fieldTypeName);
    42.                             Object filedValue = beanFactory.values().stream().filter(instance -> {
    43.                                 return field.getType().isAssignableFrom(instance.getClass());
    44.                             }).findFirst().orElseThrow(() -> new RuntimeException(fieldTypeName + "装配失败！"));
    45.  
    46.                             try {
    47.                                 field.setAccessible(true);
    48.                                 field.set(bean, filedValue);
    49.                             } catch (IllegalAccessException e) {
    50.                                 throw new RuntimeException(e);
    51.                             }
    52.                         });
    53.             });
    54.  
    55.             //第 3 步：经过前两个步骤：IOC容器中已经准备好了所有的bean实例。并且bean实例之间的依赖关系也注入完成
    56.             //这一步需要实现的是：uri是：/fruit/index    我们需要实现的是将uri中的两个标识分别映射到具体的controller实例以及controller方法上去
    57.             //简单讲，这一步需要完成将每一个Controller都要存放到controllerBeanMap中
    58.             beanFactory.values().stream()
    59.                     .filter(bean -> bean.getClass().getDeclaredAnnotation(RequestMapping.class) != null)
    60.                     .forEach(bean->{
    61.  
    62.                         ControllerDefinition controllerDefinition = new ControllerDefinition();
    63.  
    64.                         String requestMapping = bean.getClass().getDeclaredAnnotation(RequestMapping.class).value();
    65.                         Object controllerBean = bean;
    66.  
    67.                         controllerDefinition.setRequestMapping(requestMapping);
    68.                         controllerDefinition.setControllerBean(controllerBean);
    69.                         //开始分析bean中的每一个方法
    70.                         Arrays.stream(bean.getClass().getDeclaredMethods()).forEach(method -> {
    71.  
    72.                             GetMapping getMappingAnnotation = method.getDeclaredAnnotation(GetMapping.class);
    73.                             String methodMapping = null;
    74.                             if (getMappingAnnotation != null) {
    75.                                 methodMapping = getMappingAnnotation.value();
    76.                                 methodMapping = "get_" + methodMapping;
    77.                             }
    78.                             PostMapping postMappingAnnotation = method.getDeclaredAnnotation(PostMapping.class);
    79.                             if (postMappingAnnotation != null) {
    80.                                 methodMapping = postMappingAnnotation.value();
    81.                                 methodMapping = "post_" + methodMapping;
    82.                             }
    83.                             if (methodMapping != null) {
    84.                                 controllerDefinition.getMethodMappingMap().put(methodMapping, method);
    85.                             }
    86.                         });
    87.                         //将这个controllerDefinition存放到专门的Controller容器中
    88.                         controllerBeanMap.put(requestMapping, controllerDefinition);
    89.                     });
    90.             System.out.println(beanFactory);
    91.         } catch (ClassNotFoundException e) {
    92.             throw new RuntimeException(e);
    93.         } catch (InvocationTargetException e) {
    94.             throw new RuntimeException(e);
    95.         } catch (NoSuchMethodException e) {
    96.             throw new RuntimeException(e);
    97.         } catch (InstantiationException e) {
    98.             throw new RuntimeException(e);
    99.         } catch (IllegalAccessException e) {
    100.             throw new RuntimeException(e);
    101.         }
    102.     }
    103.     private static void parseFile(File file) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
    104.         if (file.exists()) {
    105.             if (file.isDirectory()) {
    106.                 //获取所有的子目录
    107.                 File[] childFiles = file.listFiles();
    108.                 for (File childFile : childFiles) {
    109.                       parseFile(childFile);
    110.                 }
    111.             } else {
    112.                 String absPath = file.getAbsolutePath();
    113.                 //System.out.println(absPath);
    114.                 String fullClassPath = absPath.substring(path.length());
    115.                 //System.out.println(fullClassPath);
    116.                 if (fullClassPath.endsWith(".class")) {
    117.                     String fullClassPathName = fullClassPath.substring(0, fullClassPath.length() - ".class".length());
    118.                     //System.out.println(fullClassPathName);
    119.                     String fullClassName = fullClassPathName.replaceAll("\\\\", ".");
    120.                     //System.out.println(fullClassName);
    121.                     Class clazz = Class.forName(fullClassName);
    122.                     //System.out.println(clazz.toString());
    123.                     if (clazz.toString().startsWith("class")) {  //排除掉接口、注解....,只关心class
    124.  
    125.                         if (!Modifier.isAbstract(clazz.getModifiers())) {   //排除掉抽象类
    126.  
    127.                             Optional optional = Arrays.stream(clazz.getDeclaredAnnotations()).filter(annotation -> {
    128.                                 return (annotation instanceof Controller || annotation instanceof Service || annotation instanceof Repository);
    129.                             }).findFirst();
    130.  
    131.                             if (!optional.isEmpty()) {
    132.                                 Object bean = clazz.getDeclaredConstructor().newInstance();
    133.                                 beanFactory.put(fullClassName, bean);
    134.                             }
    135.                         }
    136.                     }
    137.                 }
    138.             }
    139.         }
    140.     }
    141. }

    4、ContextLoaderListener 

    1. package com.csdn.mymvc.listener;
    2. import com.csdn.mymvc.core.ComponentScan;
    3. import jakarta.servlet.ServletContext;
    4. import jakarta.servlet.ServletContextEvent;
    5. import jakarta.servlet.ServletContextListener;
    6. import jakarta.servlet.annotation.WebListener;
    7. @WebListener
    8. public class ContextLoaderListener implements ServletContextListener {
    9.     @Override
    10.     public void contextInitialized(ServletContextEvent sce) {
    11.         try {
    12.             Class.forName("com.csdn.mymvc.core.ComponentScan");
    13.             ServletContext application = sce.getServletContext();
    14.             application.setAttribute("beanFactory", ComponentScan.beanFactory);
    15.             application.setAttribute("controllerBeanMap", ComponentScan.controllerBeanMap);
    16.         } catch (ClassNotFoundException e) {
    17.             throw new RuntimeException(e);
    18.         }
    19.     }
    20. }

     5、FruitController

    1. package com.csdn.fruit.controller;
    2. import com.csdn.fruit.dto.PageInfo;
    3. import com.csdn.fruit.dto.PageQueryParam;
    4. import com.csdn.fruit.dto.Result;
    5. import com.csdn.fruit.pojo.Fruit;
    6. import com.csdn.fruit.service.FruitService;
    7. import com.csdn.fruit.util.RequestUtil;
    8. import com.csdn.fruit.util.ResponseUtil;
    9. import com.csdn.mymvc.annotation.*;
    10. import jakarta.servlet.ServletException;
    11. import jakarta.servlet.http.HttpServletRequest;
    12. import jakarta.servlet.http.HttpServletResponse;
    13. import java.io.IOException;
    14. @Controller
    15. @RequestMapping("/fruit")
    16. public class FruitController {
    17.     @Autowire
    18.     private FruitService fruitService;
    19.  
    20.     @GetMapping("/index")
    21.     protected void index(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    22.         Integer pageNo = 1;
    23.         String pageNoStr = req.getParameter("pageNo");
    24.         if (pageNoStr != null && !"".equals(pageNoStr)) {
    25.             pageNo = Integer.parseInt(pageNoStr);
    26.         }
    27.  
    28.         String keyword = "";
    29.         String keywordStr = req.getParameter("keyword");
    30.         if (keywordStr != null) {
    31.             keyword = keywordStr;
    32.         }
    33.         PageQueryParam pageQueryParam = new PageQueryParam(pageNo, 5, keyword);
    34.         PageInfo pageInfo = fruitService.getFruitPageInfo(pageQueryParam);
    35.  
    36.         Result result = Result.OK(pageInfo);
    37.  
    38.         ResponseUtil.print(resp, result);
    39.     }
    40.  
    41.     @PostMapping("/add")
    42.     protected void add(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    43.         Fruit fruit = (Fruit) RequestUtil.readObject(req, Fruit.class);
    44.         fruitService.addFruit(fruit);
    45.         ResponseUtil.print(resp, Result.OK());
    46.     }
    47.  
    48.     @GetMapping("/del")
    49.     protected void del(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    50.         Integer fid = Integer.parseInt(req.getParameter("fid"));
    51.         fruitService.delFruit(fid);
    52.         ResponseUtil.print(resp, Result.OK());
    53.     }
    54.  
    55.     @GetMapping("/edit")
    56.     protected void edit(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    57.         Integer fid = Integer.parseInt(req.getParameter("fid"));
    58.         Fruit fruit = fruitService.getFruitById(fid);
    59.         ResponseUtil.print(resp, Result.OK(fruit));
    60.     }
    61.  
    62.     @GetMapping("/getFname")
    63.     public void getFname(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    64.  
    65.  
    66.         String fname = req.getParameter("fname");
    67.         Fruit fruit = fruitService.getFruitByFname(fname);
    68.         ResponseUtil.print(resp, fruit == null ? Result.OK() : Result.Fail());
    69.     }
    70.  
    71.     @PostMapping("/update")
    72.     protected void update(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    73.         Fruit fruit = (Fruit) RequestUtil.readObject(req, Fruit.class);
    74.         fruitService.updateFruit(fruit);
    75.         ResponseUtil.print(resp, Result.OK());
    76.     }
    77. }

    6、有一个小bug，查询的时候需要重置为首页

    6.1、index.js

    1. let pageNo = 1;
    2. let pageCount = 0;
    3. let keyword=""
    4.  
    5. //当页面加载完成，执行匿名函数
    6. window.onload=function(){
    7.     loadData();
    8. }
    9. function search() {
    10.     keyword=$("#keyword").value
    11.     pageNo = 1;
    12.     loadData(pageNo)
    13. }
    14.  
    15. function page(str) {
    16.     if (str) {
    17.         if (str == "first") {
    18.             pageNo = 1;
    19.         }else if (str == "pre") {
    20.             pageNo = pageNo - 1;
    21.         }else if (str == "next") {
    22.             pageNo = pageNo + 1;
    23.         }else if (str == "last") {
    24.             pageNo = pageCount;
    25.         }
    26.         if (pageNo > pageCount) {
    27.             pageNo=pageCount
    28.         }
    29.         if (pageNo <= 0) {
    30.             pageNo=1
    31.         }
    32.     }
    33.     loadData(pageNo)
    34. }
    35. loadData=function(pageNo=1){//pageNo这个参数有默认值，如果没有传值，则使用默认值 1
    36.     axios({
    37.         method: 'get',
    38.         url: '/fruit/index',
    39.         params: {
    40.             pageNo: pageNo,
    41.             keyword:keyword
    42.         }
    43.     }).then(response => {
    44.         debugger
    45.         let fruitList = response.data.data.list
    46.         pageNo = response.data.data.pageNo
    47.         pageCount = response.data.data.pageCount
    48.         // 此处使用的是axios，那么响应回来的数据自动就是json，
    49.         // 不需要再进行parse(如果是原始的ajax操作，那么一定需要parse)
    50.         // let fruitArr = JSON.parse(fruitList)
    51.         let fruitArr = fruitList;
    52.         let fruitTbl = $("#fruit_tbl")
    53.         //向表格中添加行之前，先删除原来的行
    54.         let rows=fruitTbl.rows
    55.         for (let i = rows.length - 1; i >= 1; i--) {
    56.             fruitTbl.deleteRow(i);
    57.         }
    58.  
    59.         for (let i = 0; i < fruitArr.length; i++) {
    60.             let tr = fruitTbl.insertRow();
    61.             let fnameTD = tr.insertCell();
    62.             let priceTD = tr.insertCell();
    63.             let fcountTD = tr.insertCell();
    64.             let operTD = tr.insertCell();
    65.  
    66.             let fruit = fruitArr[i];
    67.             //fnameTD.innerText = fruit.fname
    68.             fnameTD.innerHTML = 'fid + '">' + fruit.fname + '';
    69.             priceTD.innerText = fruit.price;
    70.             fcountTD.innerText = fruit.fcount;
    71.             operTD.innerHTML = " + fruit.fid + ")\"/>";
    72.         }
    73.     });
    74. }
    75.  
    76. delFruit = function (fid) {
    77.     if (window.confirm('是否确认删除？')) {
    78.         axios({
    79.             method: 'get',
    80.             url: '/fruit/del',
    81.             params:{
    82.                 fid: fid,
    83.             }
    84.         }).then(response=>{
    85.             if (response.data.flag) {
    86.                 window.location.reload();
    87.             }
    88.         });
    89.     }
    90. };

  • 相关阅读:
    字符串——算法专项刷题（三）
    利用Docker 实现 MiniOB环境搭建
    JC/T 482-2022 聚氨酯建筑密封胶检测
    Access denied for user ‘root‘@‘localhost‘ (using password: YES)解决方案
    A Generic Deep-Learning-Based Approach for Automated Surface Inspection-论文阅读笔记
    人大金仓Windows下可以使用计划任务吗？创建完没有反应？
    【愚公系列】2022年10月 LiteDB数据库-.Net Core中的使用
    CoDeSys系列-4、基于Ubuntu的codesys运行时扩展包搭建Profinet主从环境
    vim模式用法总结
    【Android Studio学习】第二篇、APP实现画简易的波形图
  • 原文地址：https://blog.csdn.net/m0_65152767/article/details/134295764