《Web应用技术》期末复习(END)

说明：不知道是哪位兄台在群里说了一句，整的我压力山大。这是我个人的期末复习梳理，自己使用并且提供给几位有需要的朋友使用，并不确定期末考试考不考这些。请大家视情况查看和使用，如果有错误，也欢迎大家找我交流。

Web应用技术期末复习

- 一、MVC
- - MVC概述：
- 二、Spring：
- - Spring概述:
  - （1）依赖注入（Dependency Injection）：
  - （2）控制反转（Inversion of Control）：
  - （3）面向切面编程（Aspect-Oriented Programming）：
  - - 目标对象：
    - 通知：
    - 代理对象：
    - 运行效果：
- 三、SpringMVC：
- - （1）SpringMVC概述：
  - （2）对how2j运行原理图理解：
  - （3）课本P161的原理图也要看
- 四、Maven:
- - Maven概述：
- 五、Mybatis：
- - （1）Mybatis概述：
  - （2）基于how2j的Mybatis的简单项目的流程分析：
- 六、SSM：
- - （1）how2j的运行原理图：
  - （2）自绘SSM工作原理流程图：
- 七、SpringBoot：
- - （1）SpringBoot概述：
  - （2）how2j上的SpringBoot项目的启动的解析：
  - （3）增加的内容:
- 八、SpringBoot+SSM：
- - （1）实现思路：
  - （2）具体实现：
  - - 添加按钮：
    - 完善DAO：
    - 完善控制器（含分页插件“PageHelper”详解）：
    - 运行查看：
  - （3）自绘制SpringBoot+SSM工作原理流程图：

一、MVC

MVC概述：

在这里插入图片描述

点击获取清晰思维导图
更多内容可查看：

Web应用技术(第八周/第一次练习/0.5h)
Web应用技术(第八周/第二次练习/4h)

二、Spring：

Spring概述:

点击获取清晰思维导图

（1）依赖注入（Dependency Injection）：

依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的方式，它是Spring框架的核心功能之一。
简单来说，依赖注入指的是要实例化的对象的相关配置已经写好，我们只是通过某些手段（见依赖注入的两种方式）将其注入到相应的属性或在方法中，而不需要再重新new了。

可参考控制反转的示例进行理解。

（2）控制反转（Inversion of Control）：

控制反转（Inversion of Control，IoC）是Spring框架的一个核心概念，指的是将对象的创建、组装和管理等控制权从应用程序代码中转移到框架或容器中，从而实现松耦合、可扩展和可维护的设计。
在传统的应用程序设计中，应用程序代码通常会负责创建和管理对象，这样会导致应用程序代码和对象之间的紧耦合，难以进行单元测试和代码重构。而控制反转则是将这些控制权转移到框架或容器中，让它们来负责对象的创建和管理，从而实现应用程序代码和对象之间的解耦和灵活性。

举一个简单的例子：

// OrderDAO类
public class OrderDAO {
    // 数据访问实现
}

// OrderService类
public class OrderService {
    private OrderDAO orderDAO;  // 依赖注入的对象

    public void setOrderDAO(OrderDAO orderDAO) {  // Setter方法注入
        this.orderDAO = orderDAO;
    }

    // 其他业务方法
}

// Spring配置文件
<bean id="orderService" class="com.example.OrderService">  <!-- 定义OrderService对象 -->
    <property name="orderDAO" ref="orderDAO" />  <!-- 通过依赖注入方式使用OrderDAO对象 -->

上述的例子中，假设有一个订单服务类OrderService，它需要依赖一个订单数据访问对象OrderDAO来实现订单数据的持久化。在传统的设计中，OrderService需要自己创建和管理OrderDAO对象，这样会导致OrderService和OrderDAO之间的紧耦合，难以进行单元测试和代码重构。而在使用Spring框架的控制反转功能后，可以将OrderDAO的创建和管理交给Spring容器来完成，然后在OrderService中通过依赖注入的方式来使用OrderDAO对象，从而实现了松耦合和可测试的设计。

（3）面向切面编程（Aspect-Oriented Programming）：

Spring AOP 是 Spring 框架的一个模块，它提供了面向切面编程的支持。Spring AOP可以让我们将应用程序中的关注点（如日志记录、事务管理、安全控制等）从业务逻辑中分离出来，然后通过特定的技术将这些关注点模块化，最终将其组合成一个完整的应用程序。

Spring AOP相关术语：

切面（Aspect）：切面是一个模块化的关注点，它可以横向切割应用程序，将不同的关注点分离出来，比如日志记录、事务管理、安全控制等。可类比于一个瑞士军刀，每个刀片都是不同的关注点，可以单独使用，也可以组合使用。
连接点（Join Point）：连接点是程序执行过程中可以插入切面的点，比如方法的调用、异常的抛出等。可类比于电路中的插头，连接点就是插头的位置。
通知（Advice）：通知是在连接点上执行的操作，它可以在连接点的前、后、或者抛出异常时执行。比如在方法执行前记录日志、在方法执行后进行事务提交等。可类比于电器的开关，通知就是开关的操作。
切入点（Pointcut）：切入点是连接点的集合，它定义了哪些连接点需要被切入切面。比如对所有的 Service 层方法进行事务管理。可类比于筛子，切点就是筛子的孔。
目标对象（Target）：所有被通知的对象（也可以理解为被代理的对象）都是目标对象，目标对象及其属性改变、行为调用和方法传参的变化被AOP所关注。
织入（Weaving）：织入是指将切面与目标对象结合起来，创建一个新的代理对象的过程。
引入（Introduction）：引入是为类添加新的方法或属性等。比如为一个类添加一个新的接口。可类比于人的学习能力，引入就是学习新技能。

目标对象：

Target.java：

package com.mr.target;

public class Target {
    //程序执行的方法
    public void execute(String name){
        System.out.println("执行execute()方法：" + name);//输出信息
    }
}

通知：

LoggerExcute.java:

package com.mr.log;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class LoggerExecute implements MethodInterceptor {
    // 实现 MethodInterceptor 接口，该接口提供了拦截方法调用的方法
    public Object invoke(MethodInvocation invocation) throws Throwable {
        before();  // 执行前置通知
        invocation.proceed();  // 执行原始方法
        return null;  // 返回 null
    }
    // 前置通知方法
    private void before() {
        System.out.println("程序开始执行！");
    }
}

代理对象：

Manager.java:

package com.mr.main;

import org.springframework.aop.framework.ProxyFactory;   //导入Spring AOP的ProxyFactory类

import com.mr.log.LoggerExecute;                        //导入日志记录的Advice类
import com.mr.target.Target;                            //导入目标类

public class Manager {
    //创建代理
    public static void main(String[] args) {
        Target target = new Target();                 //创建目标对象
        ProxyFactory di=new ProxyFactory();            //创建ProxyFactory对象
        di.addAdvice(new LoggerExecute());             //添加Advice对象
        di.setTarget(target);                          //设置目标对象
        Target proxy=(Target)di.getProxy();            //获取代理对象
        proxy.execute("AOP的简单实现");               //代理执行execute()方法
    } 
}

当我们运行主类Manager时，首先会创建一个目标对象，我们所要实现的核心功能包含在这个目标对象中，接着实例化一个工厂类 ProxyFactory，即di我们可以通过它来设置目标对象、添加 Advice 对象等来创建代理对象,在这里，我们通过 di.setTarget(target) 方法设置了目标对象，通过 di.addAdvice(new LoggerExecute()) 方法添加了一个 Advice 对象，最后通过 di.getProxy() 方法获取代理对象，即一个“四肢健全”的程序，有核心部分，有细枝末节，最后调用代理对象的excute（）方法,实现一次输出。代理对象是目标对象的扩展，所以它仍然具备目标对象的方法。

运行效果：

更多内容可查看：

Web应用技术(第十四周/END)

三、SpringMVC：

（1）SpringMVC概述：

在这里插入图片描述

点击获取清晰思维导图

（2）对how2j运行原理图理解：

在这里插入图片描述

在浏览器地址栏输入http://127.0.0.1:8080/springmvc/index，向服务器(Tomcat)请求已经部署在服务器中的名为springmvc的项目下，被标记为index的控制器
项目规范配置文件web.xml中规定，所有请求首先都要经过DispatcherServlet处理
DispatcherServlet中指定了springmvc配置文件，即springmvc-servlet.xml
springmvc-servlet.xml中指定了处理器映射器，名称为indexController,具体代码如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="simpleUrlHandlerMapping"
        class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
            	 //请求`index`时，请求会被交给名为`indexController`的处理器映射器处理
                <prop key="/index">indexController</prop>
            </props>
        </property>
    </bean>
    <bean id="indexController" class="controller.IndexController"></bean>
</beans>

当我们请求index时，请求会被交给名为indexController的处理器映射器处理，处理器映射器的本质是controller包下的IndexController类

IndexController指定了要渲染的网页模板，即index.jsp，并且传递了message的数据
在index.jsp中显示message信息

（3）课本P161的原理图也要看

更多内容可查看：

Web应用技术(第十二周/第一次练习/2h)
Web应用技术(第十二周/第二次练习/10min)
Web应用技术(第十二周/第四次练习/1h)

重定向和return见下示篇文章文末：

Web应用技术(第十二周/第五次练习/0.5h)

四、Maven:

Maven概述：

在这里插入图片描述

点击获取清晰思维导图

五、Mybatis：

（1）Mybatis概述：

在这里插入图片描述

点击获取清晰思维导图

（2）基于how2j的Mybatis的简单项目的流程分析：

应用程序在这里指的就是映射测试类，即TestMybatis.java
在这里插入图片描述

六、SSM：

（1）how2j的运行原理图：

在这里插入图片描述

（2）自绘SSM工作原理流程图：

在这里插入图片描述
附：

SSM详细内容
流程图大图

七、SpringBoot：

（1）SpringBoot概述：

在这里插入图片描述

点击获取清晰思维导图

（2）how2j上的SpringBoot项目的启动的解析：

启动SpringBoot应用程序，其本质就是启动一个Java程序：

运行Application.java
从程序入口（main class）进入
调用静态类SpringApplication的run方法
完成SpringBoot应用程序的启动
在浏览器地址栏输入相关请求，访问相关资源

核心代码：

	public static void main(String[] args) { //应用程序的入口
		SpringApplication.run(Application.class, args); //启动Spring Boot应用程序
	}

SpringApplication.run(Application.class, args)是用于启动Spring Boot应用程序的方法，其具体解析如下：

SpringApplication是Spring Boot中的一个静态类，提供了各种启动和配置Spring Boot应用程序的方法。
run()方法是启动Spring Boot应用程序的入口点。它需要两个参数：主要配置类的Class对象和main方法的args数组。
Application.class是主要配置类的Class对象。在Spring Boot应用程序中，我们需要创建一个Java类作为主要配置类，并在其中定义应用程序的配置信息、数据源等组件。在这里，我们将Application类作为主要配置类的Class对象传递给run()方法。
args是main方法接收到的命令行参数。通常情况下，我们直接传递空数组即可。

当调用SpringApplication.run(Application.class, args)方法时，Spring Boot会执行以下步骤：

加载主要配置类，并创建Spring IoC容器。
自动扫描并注册所有的Bean组件。
根据配置信息自动装配Bean组件之间的依赖关系。
启动内嵌的Web服务器（例如Tomcat或Jetty）。
监听HTTP请求，并将请求分发到相应的控制器进行处理。

（3）增加的内容:

说明：思维导图中的内容大部分是来自于SpringBoot的，感觉不太适合我们用，下面提供一份我认为质量较高的ChatGPT对springboot，是什么运行原理，如何启动，有什么优点的一份回答。

Spring
Boot是一个用于简化Spring应用程序开发的框架。它基于Spring框架，通过自动配置和约定大于配置的原则，提供了一种快速构建独立、可执行的、生产级别的Spring应用程序的方式。

Spring Boot的运行原理如下：

Spring Boot使用嵌入式Web服务器来运行应用程序，默认情况下使用Tomcat作为嵌入式Web服务器。当运行Spring Boot应用程序时，它会自动配置嵌入式Web服务器，并使用Spring MVC框架处理HTTP请求和响应。
Spring Boot还提供了自动配置机制，可以根据类路径和配置文件来自动配置Spring应用程序中的各种组件，例如数据库连接池、模板引擎、安全机制等。这可以更快地开发和部署应用程序，而无需手动进行大量配置。

Spring Boot的启动方式有多种，常见的方式包括：

使用Spring Boot的命令行工具（Spring Boot CLI）进行启动。
在IDE中直接运行Spring Boot应用程序的main方法。
打包成可执行的JAR或WAR文件，通过java命令运行。

Spring Boot的优点包括：

简化配置：Spring Boot通过自动配置和约定大于配置的原则，大大减少了开发人员的配置工作，提高了开发效率。
内嵌服务器：Spring Boot内置了多种常用的服务器，可以将应用程序打包成可执行的JAR或WAR文件，方便部署和运行。
自动依赖管理：Spring Boot通过自动依赖管理机制，可以自动管理项目的依赖关系，简化了依赖管理的工作。
健康监测和度量：Spring Boot提供了健康监测和度量的功能，可以方便地监测应用程序的运行状态和性能指标。
易于集成：Spring Boot与其他Spring项目和第三方库的集成非常方便，可以快速搭建复杂的应用程序。
生态系统丰富：Spring Boot拥有庞大的社区和生态系统，有大量的插件和扩展可以使用，提供了丰富的功能和工具支持。

八、SpringBoot+SSM：

（1）实现思路：

实现SpringBoot的CRUD的思想与SSMCRUD的思想是一样的：
我们的crud本质上，也是一种向用户提供的服务，或者说用户的需求。因此为了实现CRUD：

我们需要修改视图，增加相关按钮，以供用户点击
我们需要修改定义服务的接口，以实现接口最终实现功能
我们需要修改DAO(CategoryMapper)，以实现与数据库的交互。
我们需要修改控制器，处理用户不同的/更多的请求。

（2）具体实现：

具体细节见Web应用技术（第十五周/END），这里只提供代码和注释，不做重复讲解了。

添加按钮：

listCategory.jsp：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
 
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> <!-- 导入核心标签库 -->
   
<div align="center"> <!-- HTML页面布局 -->

</div>
 
<div style="width:500px;margin:20px auto;text-align: center"> <!-- HTML页面布局 -->
    <table align='center' border='1' cellspacing='0'> <!-- HTML表格 -->
        <tr> <!-- 表头 -->
            <td>id</td>
            <td>name</td>
            <td>编辑</td>
            <td>删除</td>
        </tr>
        <c:forEach items="${page.list}" var="c" varStatus="st"> <!-- 使用JSTL的forEach标签循环遍历查询结果，并将结果设置到HTML页面中 -->
            <tr>
                <td>${c.id}</td> <!-- 输出Category对象的id属性 -->
                <td>${c.name}</td> <!-- 输出Category对象的name属性 -->
                <td><a href="editCategory?id=${c.id}">编辑</a></td> <!-- 创建超链接，用于跳转到编辑页面 -->
                <td><a href="deleteCategory?id=${c.id}">删除</a></td> <!-- 创建超链接，用于提交删除请求 -->
            </tr>
        </c:forEach>
         
    </table>
    <br>
    <div>
                <a href="?start=1">[首  页]</a> <!-- 创建分页导航，用于快速跳转到指定页面 -->
            <a href="?start=${page.pageNum-1}">[上一页]</a>
            <a href="?start=${page.pageNum+1}">[下一页]</a>
            <a href="?start=${page.pages}">[末  页]</a>
    </div>
    <br>
    <form action="addCategory" method="post"> <!-- 创建表单，用于提交新增请求 -->
    id:<input name="id"> <br> <!-- 创建输入框，用于输入新增记录的名称属性 -->
     
    name: <input name="name"> <br> <!-- 创建输入框，用于输入新增记录的名称属性 -->
    <button type="submit">提交</button> <!-- 创建提交按钮，用于提交新增请求 -->
     
    </form>
</div>

editCategory.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
 pageEncoding="UTF-8" isELIgnored="false"%> <!-- 设置页面编码，并启用表达式语言 -->

<div style="margin:0px auto; width:500px"> <!-- HTML页面布局 -->

<form action="updateCategory" method="post"> <!-- 创建表单，用于提交更新请求 -->

name: <input name="name" value="${c.name}"> <br> <!-- 创建输入框，用于输入更新记录的名称属性，并设置初始值为原有值，通过EL表达式获取 -->

<input name="id" type="hidden" value="${c.id}"> <!-- 创建隐藏域，用于提交更新记录的id属性，通过EL表达式获取 -->
<button type="submit">提交</button> <!-- 创建提交按钮，用于提交更新请求 -->

</form>
</div>

完善DAO：

package com.how2java.springboot.mapper;

import java.util.List;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import com.how2java.springboot.pojo.Category;

@Mapper // 声明该接口为MyBatis的Mapper接口，需要通过@MapperScan注解扫描到该类
public interface CategoryMapper {

    @Select("select * from category_ ") // 使用@Select注解指定SQL查询语句
    List<Category> findAll(); // 定义findAll()方法，用于查询所有Category对象，并以List集合的形式返回结果集

    @Insert(" insert into category_ ( id,name ) values (#{id},#{name}) ") // 使用@Insert注解指定SQL插入语句
    public int save(Category category); // 定义save()方法，用于新增Category对象，返回值表示影响的行数

    @Delete(" delete from category_ where id= #{id} ") // 使用@Delete注解指定SQL删除语句
    public void delete(int id); // 定义delete()方法，用于删除指定id的Category对象

    @Select("select * from category_ where id= #{id} ") // 使用@Select注解指定SQL查询语句
    public Category get(int id); // 定义get()方法，用于查询指定id的Category对象

    @Update("update category_ set name=#{name} where id=#{id} ") // 使用@Update注解指定SQL更新语句
    public int update(Category category); // 定义update()方法，用于更新Category对象，返回值表示影响的行数

}

完善控制器（含分页插件“PageHelper”详解）：

CategoryController.java：

package com.how2java.springboot.web;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.how2java.springboot.mapper.CategoryMapper;
import com.how2java.springboot.pojo.Category;

@Controller // 声明该类为Spring MVC的Controller类，用于处理HTTP请求和响应。
public class CategoryController {
    @Autowired 
    private CategoryMapper categoryMapper; // 自动注入CategoryMapper对象

    @RequestMapping("/addCategory")
    public String addCategory(Category c) throws Exception {
        categoryMapper.save(c); // 调用CategoryMapper的save()方法保存Category对象
        return "redirect:listCategory"; // 重定向到listCategory请求
    }

    @RequestMapping("/deleteCategory")
    public String deleteCategory(Category c) throws Exception {
        categoryMapper.delete(c.getId()); // 调用CategoryMapper的delete()方法删除指定id的Category对象
        return "redirect:listCategory"; // 重定向到listCategory请求
    }

    @RequestMapping("/updateCategory")
    public String updateCategory(Category c) throws Exception {
        categoryMapper.update(c); // 调用CategoryMapper的update()方法更新Category对象
        return "redirect:listCategory"; // 重定向到listCategory请求
    }

    @RequestMapping("/editCategory")
    public String editCategory(int id, Model m) throws Exception {
        Category c = categoryMapper.get(id); // 调用CategoryMapper的get()方法查询指定id的Category对象
        m.addAttribute("c", c); // 将查询结果设置到Model中作为属性
        return "editCategory"; // 返回逻辑视图名
    }

    @RequestMapping("/listCategory")
    public String listCategory(Model m, @RequestParam(value = "start", defaultValue = "0") int start,
            @RequestParam(value = "size", defaultValue = "5") int size) throws Exception {
        PageHelper.startPage(start, size, "id desc"); // 使用分页插件PageHelper设置分页参数
        List<Category> cs = categoryMapper.findAll(); // 调用CategoryMapper的findAll()方法查询所有Category对象并返回结果集
        PageInfo<Category> page = new PageInfo<>(cs); // 使用PageInfo对结果集进行包装，以支持更多分页信息的获取
        m.addAttribute("page", page); // 将查询结果设置到Model中作为属性
        return "listCategory"; // 返回逻辑视图名
    }

}

在这个控制器中，CUD的路由及其方法是相对比较简单，这里来说一说我对R（查询/分页）路由及其方法的理解：

  @RequestMapping("/listCategory")
    public String listCategory(Model m, 
    		@RequestParam(value = "start", defaultValue = "0") int start,
            @RequestParam(value = "size", defaultValue = "5") int size) throws Exception {
        PageHelper.startPage(start, size, "id asc"); // 使用分页插件PageHelper设置分页参数
        List<Category> cs = categoryMapper.findAll(); // 调用CategoryMapper的findAll()方法查询所有Category对象并返回结果集
        PageInfo<Category> page = new PageInfo<>(cs); // 使用PageInfo对结果集进行包装，以支持更多分页信息的获取
        m.addAttribute("page", page); // 将查询结果设置到Model中作为属性
        return "listCategory"; // 返回逻辑视图名
    }

上述代码中，

PageHelper.startPage(start, size, "id asc");

表示从以size数量的元组为一页的第start页开始，采用按id升序的方式展示到前端页面上。

			@RequestParam(value = "start", defaultValue = "0") int start,
            @RequestParam(value = "size", defaultValue = "5") int size

这段代码声明了参数start和size，并设置了他们的默认值分别为0和5。

List<Category> cs = categoryMapper.findAll(); // 调用CategoryMapper的findAll()方法查询所有Category对象并返回结果集
PageInfo<Category> page = new PageInfo<>(cs); // 使用PageInfo对结果集进行包装，以支持更多分页信息的获取

第一行代码中，我们调用 categoryMapper.findAll() 方法查询数据库中的所有 Category 记录。这个方法可能会返回大量数据，如果直接全部查询出来，就可能会导致内存溢出等问题。因此，在实际应用中，我们通常会将查询结果进行分页，以提高系统性能和用户体验。

在第二行代码中，我们使用 PageInfo 对查询结果进行包装，并将其保存到 page 变量中。PageInfo 是 MyBatis 分页插件 PageHelper 提供的一个分页数据类，可以将查询结果封装成一个带有分页信息的对象。在这里，我们将查询结果 cs 传入 PageInfo 的构造函数中，并通过泛型指定了查询结果的类型。MyBatis 会根据查询参数和分页设置，自动计算出总页数、当前页码等分页信息，并将其保存在 PageInfo 对象中。

由于我们是使用插件进行分页的，因此我们需要对插件进行配置：
PageHelperConfig.java：

package com.how2java.springboot.config;

import java.util.Properties;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.github.pagehelper.PageHelper;

@Configuration //该类为配置类
public class PageHelperConfig {

    @Bean //创建一个Bean实例，用于注入PageHelper对象到容器中
    public PageHelper pageHelper() {
        PageHelper pageHelper = new PageHelper(); //创建一个PageHelper对象

        Properties p = new Properties(); //创建Properties对象，用于设置PageHelper的属性
        p.setProperty("offsetAsPageNum", "true"); //设置offsetAsPageNum属性为true
        p.setProperty("rowBoundsWithCount", "true"); //设置rowBoundsWithCount属性为true
        p.setProperty("reasonable", "true"); //设置reasonable属性为true

        pageHelper.setProperties(p); //将设置好的属性赋值给PageHelper对象

        return pageHelper; //返回PageHelper对象
    }
}

这份代码我探明的目前只有这份代码本身，@Configuration 和@Bean注解，以及 p.setProperty(“reasonable”, “true”)。

这份代码配合两个注解，实现IOC和DI
p.setProperty(“reasonable”, “true”)用于启用合理化策略，处理一些边界情况。例如当页码小于1时，会将页码强制设为1；当页码大于总页数时，会将页码强制设为总页数。这样可以保证查询结果的准确性和用户体验。

其他部分经我测试，在该案例中是可有可无的。

更新：

p.setProperty("rowBoundsWithCount", "true");

这行代码使得在查询结果进行分页时，不一次性查完全部数据，为CPU增加负担，以提高系统性能和用户体验。

运行查看：

运行application.java后，在浏览器中访问http://127.0.0.1:8080/listCatgory
在这里插入图片描述

（3）自绘制SpringBoot+SSM工作原理流程图：

在这里插入图片描述

更多内容可查看：

Web应用技术（第十五周/END）
Web应用技术（第十六周/END）

~~6.20修改了SpringMVC和SpringBoot部分内容，使用本博客的同学请重新查阅这部分内容。~~

本博客主要整理期末考试的考点，更多具体内容可参考每部分后所附的博客链接。