框架自我小结

@PatchMapping: 映射 HTTP 的 PATCH 请求，用于部分更新资源。
@RequestMapping: 最通用的映射注解，可以指定多种请求类型。
@RequestMapping(method = RequestMethod.XXX): 通过指定不同的 RequestMethod 枚举值来处理不同类型的请求。
@RequestMapping(value = "/path", headers = "headerKey=headerValue"): 根据请求头信息来映射请求。
@RequestMapping(value = "/path", params = "paramKey=paramValue"): 根据请求参数来映射请求。
@RequestMapping(value = "/path", consumes = "mediaType"): 根据请求的媒体类型来映射请求。
@RequestMapping(value = "/path", produces = "mediaType"): 根据响应的媒体类型来映射请求。

3.一些常见注解的详细展开

1.`@PathVariable` 和 `@RequestParam`

@PathVariable 和 @RequestParam 是 Spring MVC 中常用的两种参数绑定注解，它们的作用和区别如下：

@PathVariable：
- 作用：用于从 URL 中获取路径变量的值，通常用于 RESTful 风格的请求处理。
- 示例：@RequestMapping(value = "/path/{id}", method = RequestMethod.GET) 中的 {id} 就是路径变量，可以使用 @PathVariable 注解将其绑定到方法参数上。
- 示例代码：
```
@RequestMapping(value = "/path/{id}", method = RequestMethod.GET)
public String handleGetRequest(@PathVariable("id") Long id) {
    // 使用 @PathVariable 获取路径变量 id 的值
    return "exampleView";
}
```
@RequestParam：
- 作用：用于从请求参数中获取值，通常用于处理查询参数。
- 示例：在 URL 中使用 ?key=value 的形式传递参数，可以使用 @RequestParam 注解将参数值绑定到方法参数上。
- 示例代码：
```
@RequestMapping(value = "/path", method = RequestMethod.GET)
public String handleGetRequest(@RequestParam("param") String param) {
    // 使用 @RequestParam 获取请求参数 param 的值
    return "exampleView";
}
```
区别：
- @PathVariable 用于获取路径变量的值，而 @RequestParam 用于获取请求参数的值。
- @PathVariable 是从 URL 路径中获取参数，一般用于 RESTful 风格的请求；而 @RequestParam 是从请求参数中获取值，一般用于处理查询参数。
- @PathVariable 注解中需要指定路径变量的名称，而 @RequestParam 注解中需要指定请求参数的名称。
- 如果请求参数是必须的，可以使用 @PathVariable，如果请求参数是可选的，可以使用 @RequestParam。

综上所述，@PathVariable 和 @RequestParam 分别用于获取路径变量和请求参数的值，可以根据具体的场景选择合适的参数绑定方式。

2.`@RequestMapping`

@RequestMapping 注解最多可以写以下几个参数，每个参数的作用如下：

value：指定请求的 URL 路径。可以是一个字符串数组，用于指定多个路径。例如：

@RequestMapping(value = {"/path1", "/path2"}, method = RequestMethod.GET)

method：指定处理请求的 HTTP 方法，包括 GET、POST、PUT、DELETE 等。例如：

@RequestMapping(value = "/path", method = RequestMethod.GET)

params：指定请求必须包含的参数。例如：

@RequestMapping(value = "/path", method = RequestMethod.GET, params = "key=value")

headers：指定请求头信息。例如：

@RequestMapping(value = "/path", method = RequestMethod.GET, headers = "key=value")

consumes：指定处理请求的内容类型（Content-Type），例如接受 JSON 或 XML 格式的请求。例如：

@RequestMapping(value = "/path", method = RequestMethod.POST, consumes = "application/json")

produces：指定返回的内容类型（Accept），例如返回 JSON 或 XML 格式的响应。例如：

@RequestMapping(value = "/path", method = RequestMethod.GET, produces = "application/json")

path：value的别名，用于指定请求的 URL 路径。
name：指定处理器的名称，用于区分不同的处理器。
params和headers可以使用逻辑运算符组合多个条件，例如：

@RequestMapping(value = "/path", method = RequestMethod.GET, params = {"key1=value1", "key2=value2"})

总的来说，@RequestMapping 注解可以接受多个参数，通过这些参数可以灵活地定义请求映射规则，包括请求路径、请求方法、请求参数、请求头信息等，以及对请求和响应的内容类型进行限制。这些参数可以帮助开发人员更精确地控制请求的处理逻辑。

3、 MyBaits

数据库映射文件

它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

1.关于配置文件

1.书写顺序

在<configuration>标签中的标签可以按照以下推荐顺序书写，以确保配置的清晰性和易读性：

<properties>：指定外部属性文件。
<settings>：配置全局设置。
<typeAliases>：定义Java类的别名。
<typeHandlers>：配置自定义类型处理器。
<objectFactory>：配置对象工厂。
<plugins>：配置插件。
<environments>：配置数据源环境。
<databaseIdProvider>：配置数据库厂商标识。
<mappers>：指定映射器（Mapper）的位置。

这个顺序的目的是按照配置的逻辑顺序和依赖关系进行排列，使配置文件更易于理解和维护。有的项可以不写，虽然并不是强制要求按照这个顺序书写，但遵循这个推荐顺序可以帮助保持一致性，并减少配置错误的可能性。

2.具体用法

1.<configuration>：用于配置MyBatis的全局属性和设置。可以包含子标签如 <settings>、<typeAliases>、<plugins>等，用于配置全局设置、类型别名和插件等。

<configuration>
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <typeAliases>
        <typeAlias type="com.example.User" alias="User"/>
    </typeAliases>
    <plugins>
        <plugin interceptor="com.example.MyPlugin"/>
    </plugins>
</configuration>

2.<properties>：用于指定外部属性文件，可以在配置文件中引用外部属性文件中定义的属性值。

<properties resource="jdbc.properties"/>

关于`<properties>`

需要说明的是：

在Spring的配置文件中指定了外部属性文件（如.properties配置文件，用于保存数据库连接信息等），可以不在MyBatis的XML配置文件中使用<properties>标签来指定外部属性文件。Spring会加载外部属性文件并将属性值注入到MyBatis的配置中，MyBatis可以直接引用这些属性值。

如果在MyBatis的XML配置文件中仍然使用了<properties>标签指定外部属性文件，那么这些属性值会覆盖Spring配置文件中对应的属性值。这可能会导致属性值的混乱和不一致，不建议重复指定外部属性文件。

有多个配置文件怎么办（或者说配置文件是如何定位的）

在MyBatis中，可以通过多种方式处理多个.properties文件的情况，以满足不同需求：

使用多个<properties>标签：在MyBatis配置文件中可以使用多个<properties>标签来引入多个.properties文件，每个<properties>标签可以引入一个.properties文件。例如：
```
<properties resource="jdbc1.properties"/>
<properties resource="jdbc2.properties"/>
```

使用Java代码加载多个.properties文件：在Java代码中可以通过Resources.getResourceAsProperties()方法加载多个.properties文件，并将其合并为一个Properties对象，然后将该对象传递给SqlSessionFactoryBuilder的build()方法。例如：

Properties properties = new Properties();
properties.load(Resources.getResourceAsReader("jdbc1.properties"));
properties.load(Resources.getResourceAsReader("jdbc2.properties"));

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, properties);

使用Spring框架的方式：如果项目使用Spring框架，可以利用Spring的PropertyPlaceholderConfigurer或PropertySourcesPlaceholderConfigurer来管理多个.properties文件，并注入到MyBatis配置中。

无论采用哪种方式，MyBatis都支持引入多个.properties文件，以便灵活地管理和配置属性值。根据具体的需求和项目架构，可以选择适合的方式来处理多个.properties文件的情况。

3.<typeAliases>：用于定义Java类的别名，简化在映射文件中的类的引用。

<typeAliases>
    <typeAlias type="com.example.User" alias="User"/>
</typeAliases>

4.<environments>：用于配置数据源环境，包括数据源的配置和事务管理器的配置。

<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </dataSource>
    </environment>
</environments>

5.<mappers>：用于指定映射器（Mapper）的位置，即映射文件或Mapper接口的位置。

<mappers>
    <mapper resource="com/example/UserMapper.xml"/>
</mappers>

6.<mapper>：用于引入映射文件（Mapper XML文件），定义SQL语句和映射规则。

<mapper namespace="com.example.UserMapper">
    <select id="getUserById" resultType="User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

7.<resultMap>、<select>、<insert>、<update>、<delete>、<sql>等标签的具体用法可以根据需要定义对应的映射规则、SQL语句和可重用的SQL片段。

这些标签的具体用法可以根据项目需求和实际情况进行灵活配置，帮助实现数据操作的定制化和管理。

2.关于sql语句的书写

可以有if判断和循环，传值时，最好用map集合传递，如果只有一个值则不用

4、SSM

整个SSM项目的配置文件执行流程就是：web.xml指定Spring配置文件位置，Spring配置文件中引入MyBatis配置文件，MyBatis配置文件中指定Mapper接口位置。

1.配置文件执行流程

在一个SSM项目中（Spring + Spring MVC + MyBatis），配置文件的执行流程通常如下：

web.xml配置：
- 在web.xml中配置DispatcherServlet，该Servlet会拦截所有请求并将其路由到相应的Controller中。
- 在web.xml中指定Spring配置文件的位置，通常是通过contextConfigLocation参数指定Spring的配置文件路径。
Spring配置文件：
- Spring配置文件中需要配置组件扫描，以扫描并加载所有的Bean。
- 在Spring配置文件中需要引入MyBatis的配置文件，以便整合MyBatis。
MyBatis配置文件：
- MyBatis配置文件中包含了数据源配置、Mapper扫描等信息。
- 在MyBatis配置文件中需要指定Mapper接口的位置，以便MyBatis能够找到对应的Mapper接口。

2.项目举例

web.xml中的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <display-name>Spring MVC Application</display-name>
    <absolute-ordering/>

    <servlet>
        <servlet-name>HelloWeb</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
<!--
**<servlet>元素**：
<servlet-name>: 定义Servlet的名称为`HelloWeb`。
<servlet-class>: 指定Servlet的类为org.springframework.web.servlet.DispatcherServlet，这是Spring MVC框架的前端控制器，负责拦截请求并将其分发给对应的Controller处理。
<load-on-startup>: 指定Servlet在应用启动时就加载，值为1表示优先级为最高。
-->
    
    <servlet-mapping>
        <servlet-name>HelloWeb</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
<!--
**<servlet-mapping>元素**：
<servlet-name>: 指定Servlet的名称为HelloWeb。
<url-pattern>: 指定Servlet的映射路径为/，表示所有的请求都会被该Servlet拦截。
-->
    
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
    </context-param>
<!--
**<context-param>元素**：
<param-name>: 指定参数的名称为contextConfigLocation。
<param-value>: 指定Spring MVC配置文件的位置为/WEB-INF/HelloWeb-servlet.xml，该配置文件会包含Spring MVC框架的相关配置，如Controller映射、视图解析器等。
-->
    
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
<!--
**<listener>元素**：
<listener-class>: 指定监听器类为org.springframework.web.context.ContextLoaderListener，该监听器用于在Web应用程序启动时加载Spring应用程序上下文，通常用于加载Spring的根配置文件。
-->

</web-app>

Spring配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">


    <context:component-scan base-package="org.jsoft"/>
    <mvc:annotation-driven/>
    <mvc:resources mapping="/assets/js/**" location="/assets/js/"/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="ignoreResourceNotFound" value="false"/>
        <property name="locations">
            <list>
                <value>classpath:dbconfig.properties</value>
            </list>
        </property>
    </bean>

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
        <property name="defaultAutoCommit" value="false"/>
    </bean>

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="mapperScannerConfigurer">
        <property name="basePackage" value="org.jsoft.dao"/>
    </bean>


    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* org.jsoft..*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="delete*" propagation="REQUIRED" read-only="false"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="insert*" propagation="REQUIRED" read-only="false"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="add*" propagation="REQUIRED" read-only="false"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="update*" propagation="REQUIRED" read-only="false"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="edit*" propagation="REQUIRED" read-only="false"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="save*" propagation="REQUIRED" read-only="false"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="execut*" propagation="REQUIRED" read-only="false"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="batch*" propagation="REQUIRED" read-only="false"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="query*" propagation="NOT_SUPPORTED" read-only="true"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="find*" propagation="NOT_SUPPORTED" read-only="true"
                       rollback-for="java.lang.Exception"/>
            <tx:method name="select*" propagation="NOT_SUPPORTED" read-only="true"
                       rollback-for="java.lang.Exception"/>
        </tx:attributes>
    </tx:advice>

</beans>

MyBaits配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias alias="user" type="org.jsoft.vo.User"/>
    </typeAliases>
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

与Spring Boot对比

在Spring Boot项目中，通常不需要再配置web.xml、Spring配置文件（如applicationContext.xml）、以及DispatcherServlet等传统的配置文件。这是与传统的SSM项目最大的区别之一。

在Spring Boot中，主要使用application.properties或application.yml来进行配置，这些配置文件可以包含应用程序的所有配置信息，包括数据库连接、端口号、日志级别、缓存配置等。application.properties和application.yml的最大作用就是简化了项目的配置操作，使得开发者可以更方便地进行配置管理。

Spring Boot还提供了自动配置（Auto-Configuration）功能，根据项目中引入的依赖和类路径下的文件，Spring Boot会自动配置应用程序的各种组件，大大减少了开发者需要手动配置的工作量。

因此，Spring Boot的设计理念是约定优于配置，通过约定大于配置的方式简化了项目的配置和开发，提高了开发效率。

5、Maven

依赖管理（主要为jar包等的管理，减少开发人员在环境配置上所需的时间）

核心：POM文件

POM文件（Project Object Model）是Maven项目的核心文件之一，它定义了项目的基本信息、依赖关系、构建配置等。POM文件是一个XML文件，包含了项目的坐标、依赖、插件、构建配置等信息。在Maven中，POM文件是项目的“脊梁”，所有的操作都是基于POM文件进行的。通常，POM文件位于项目的根目录下，文件名为pom.xml。

Maven中的优先级关系

除了项目级配置和命令行参数的优先级外，Maven 中还有其他一些配置的优先级关系，包括：

内置默认值：Maven 在执行构建过程时会使用一些内置的默认配置值，如果没有在 pom.xml 或 settings.xml 中定义相应的配置，Maven 将会使用这些默认值。
父子项目继承：在 Maven 多模块项目中，子项目可以继承父项目的配置。如果在子项目中没有重新定义某个配置项，那么将会沿用父项目中的配置。
Profile 优先级：如果在 pom.xml 中定义了多个 profile，并且这些 profile 都符合激活条件，那么后面定义的 profile 会覆盖前面定义的 profile 中相同属性的配置。
系统属性和环境变量：可以通过系统属性和环境变量来覆盖 pom.xml 和 settings.xml 中的配置。系统属性优先级高于环境变量。

综上所述，Maven 中配置的优先级关系并不仅限于项目级配置和命令行参数，还涉及到内置默认值、父子项目继承、Profile 优先级以及系统属性和环境变量的影响。理解这些优先级关系有助于更好地管理和控制 Maven 项目的配置。

6、Spring Boot

1.一定要使用Maven吗

在Spring Boot项目中，使用Maven并不是强制的。除了Maven，你也可以使用Gradle等构建工具来管理依赖。然而，由于Spring Boot项目通常依赖大量的第三方库和框架，使用Maven可以更方便地管理这些依赖项，同时也能够利用Maven的生态系统来更轻松地构建和部署项目。因此，建议在Spring Boot项目中使用Maven作为依赖管理工具。

2.与SSM框架的区别

其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

starter是SpringBoot启动，作用是简化配置，能快速进入业务开发阶段，而不是停留在搭建环境、配置框架等重复性操作上。

帮助开发者做很多版本的控制，依赖管理以及Spring中很多制式化的配置，大大节约时间

SpringBootApplication注解也帮助开发者配置很多制式化配置，如IoC扫描路径等等

Spring Boot:
- Spring Boot是一个快速开发微服务的框架，它通过约定大于配置的方式来简化Spring应用程序的开发和部署。
- Spring Boot提供了内嵌的Tomcat、Jetty等服务器，使得项目可以打包成一个独立的可执行JAR文件，方便部署和运行。
- Spring Boot提供了自动配置和起步依赖等功能，可以快速搭建项目，减少了繁琐的配置工作。
SSM框架（Spring + SpringMVC + MyBatis）:
- SSM框架是传统的Java Web开发框架，结合了Spring框架、SpringMVC框架和MyBatis框架。
- Spring框架提供了依赖注入和面向切面编程等功能，SpringMVC框架用于处理Web请求和响应，MyBatis框架用于数据库访问。
- SSM框架需要手动配置各个组件之间的关联关系，开发者需要花费较多的时间来配置和调试项目。

总的来说，Spring Boot更适合快速开发微服务和构建独立的可执行应用程序，而SSM框架更适合传统的Java Web项目开发。选择使用哪种框架取决于项目需求和开发团队的技术栈。

3.常用注解

对于Spring Boot框架，常用的注解有很多，以下列举一些常见的注解及其作用：

@SpringBootApplication:
作用：标识一个Spring Boot应用的主启动类，通常放在项目的入口类上。
@RestController:
作用：结合@Controller和@ResponseBody，用于标识一个类为RESTful风格的Controller。
@RequestMapping:
作用：用于映射HTTP请求到相应的处理方法。
@Autowired:
作用：用于自动装配Spring容器中的Bean对象。
@Service:

作用：用于标识一个类为服务层组件。
@Repository:
作用：用于标识一个类为数据访问层组件。
@Configuration:
作用：用于定义配置类，可以替代XML配置文件。
@Value:
作用：用于注入配置文件中的属性值。
@ComponentScan:
作用：用于指定Spring组件扫描的包路径。
@EnableAutoConfiguration:
作用：开启Spring Boot的自动配置功能，根据项目的依赖自动配置Spring应用。

这些注解是在Spring Boot项目中经常使用的，可以帮助简化配置、提高开发效率，同时也符合Spring Boot的约定大于配置的设计理念。根据具体的需求和场景，选择合适的注解可以让项目更加清晰和易于维护。

7.RESTful 风格

REST（Representational State Transfer）是一种软件架构风格，是一种设计风格而不是标准，通常用于构建分布式系统和网络应用程序。RESTful 风格是基于 REST 架构原则设计的应用程序的风格。

以下是 RESTful 风格的一些主要特点和原则：

资源（Resources）：在 RESTful 风格中，所有的数据和功能都被视为资源。每个资源都有一个唯一的标识符（URI），通过 URI 对资源进行访问和操作。
统一接口（Uniform Interface）：RESTful 风格使用统一的接口来定义客户端和服务器之间的通信方式。这包括使用标准的 HTTP 方法（GET、POST、PUT、DELETE）对资源进行操作，以及使用标准的媒体类型（如 JSON、XML）来表示资源的状态。
状态无关（Stateless）：RESTful 风格要求服务器不保存客户端的状态，每个请求都包含足够的信息以便服务器能够理解并处理请求。这样可以提高系统的可伸缩性和可靠性。
客户端-服务器架构（Client-Server Architecture）：RESTful 风格将客户端和服务器分离，使它们可以独立演化。客户端和服务器之间通过接口进行通信，使得系统更加灵活和可扩展。
无状态通信（Stateless Communication）：每个请求都包含足够的信息，服务器不需要保存客户端的状态。这样可以降低服务器的负担，提高系统的可伸缩性。
缓存（Cacheable）：RESTful 风格支持缓存，服务器可以标记响应是否可以被缓存，客户端可以根据响应的缓存标记来决定是否使用缓存。