Mybits:

mybits核心配置文件：

用于配置 MyBatis 的各种参数和属性，以及引入映射文件（Mapper）。


<?xml version="1.0" encoding="UTF-8" ?>
<!--<!DOCTYPE> 标签：声明了XML文档类型的声明，指定了使用的DTD(文档类型定义）文件的路径和版本。-->
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration 标签：MyBatis的配置文件必须以这个标签作为根标签，包含了所有的配置信息。-->
<configuration>
    <!--设置连接数据库的环境-->
<!--environments 标签：用于配置 MyBatis 的环境，通过 default 属性指定默认的环境。
environment 标签：定义了一个具体的环境，通过 id 属性指定环境的名称，id=test是测试环境，id是
唯一标识不能重复				。
environments是一个复数标签，里面可以存放很多environment标签-->
    <environments default="development">
        <environment id="development">
<!--transactionManager 标签：用于配置事务管理器（数据库操作的管理和实现，
数据库领域，事务管理器通常是由数据库管理系统（DBMS）提供的服务，
用于确保数据库操作的原子性、一致性、隔离性和持久性（ACID）。
事务管理器提供了一种机制，使得多个数据库操作可以作为一个整体执行，
而不是独立的操作，从而避免了数据不一致和丢失的问题。），这里使用的是 JDBC 事务管理器。-->
            <transactionManager type="JDBC"/>
            <!--设置数据库连接-->
<!--dataSource 标签：用于配置数据库连接池，这里使用的是 POOLED (mybits提供是数据池连接技术）
数据源类型。-->
            <dataSource type="POOLED">
<!--property 标签：用于设置数据源的属性，包括数据库驱动、URL、用户名和密码等。-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/myemployees?
serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="A86789234"/>
            </dataSource>
        </environment>
    </environments>
   <!--引入映射文件-->
    <mappers>
        <!--本配置文件和mappers文件是平行的，默认的当前目录下的mappers下的UserMapper-->
        <mapper  resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

mapper映射文件：

用于定义与用户（User）相关的数据库操作。这个映射文件使用了 MyBatis 的 XML 映射语言来定义 SQL 语句和数据库操作方法。映射文件写好后要和mybits的核心配置文件关联，通过标签关联。当我们对数据库进行操作的时候，通过调用相关的mapper接口（与xml文件映射关联了的）中的方法，其中的方法通过xml映射文件关联，然后通过映射文件完成数据库的操作。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--mapper 标签：MyBatis的映射文件必须以这个标签作为根标签，包含了所有的映射信息。
namespace 属性：指定了映射器的命名空间，用于与其他映射器区分开来。-->
<!--映射器：映射器（Mapper）是 MyBatis 框架中的一个组件，用于定义数据库操作和 SQL 语句与 Java 方法之间的映射关系。
映射器将 Java 对象和数据库表之间的数据映射起来，将数据库操作封装成一个个方法，使得 Java 开发人员可以使用面向对象的方式操作数据库，
而不需要编写大量的 SQL 语句。
在 MyBatis 中，映射器通常是一个接口，其中的方法定义了对数据库的操作。映射器的具体实现由 MyBatis 框架自动生成，
可以使用 XML 或者注解的方式来描述 SQL 语句以及与 Java 方法之间的映射关系-->
        <mapper namespace="com.example.demo.mapper.UserMapper">
       <!--int insertUser();insert 标签：定义了一个插入（Insert）操作的 SQL 语句，通过 id 属性指定操作的名称。-->
        <insert id="InsertUser">
         insert into t_user values('admin','123456')
      </insert>
        </mapper>

测试数据库添加数据操作：在test文件中建立测试类

//读取MyBatis的核心配置文件
InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); 
//创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new 
SqlSessionFactoryBuilder();
//通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象 
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is); 
//创建SqlSession对象，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务 
//SqlSession sqlSession = sqlSessionFactory.openSession();
//创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交 
SqlSession sqlSession = sqlSessionFactory.openSession(true); 
//通过代理模式创建UserMapper接口的代理实现类对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配 
映射文件中的SQL标签，并执行标签中的SQL语句
int result = userMapper.insertUser(); 
//上面可以不通过创建类来实现对sql的操作：
// int result = sqlSession.insert("com.example.demo.mapper.UserMapper.InsertUser");
sqlSession.commit();
System.out.println("结果："+result);

添加日志功能：log4j4日志框架

1.在pom文件中添加相关的依赖：

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId> 
   <version>1.2.17</version> 
</dependency

选择的日志级别打印出来的是大于等于当前日志级别的信息。

查询操作：

设置程序的测试程序

  public  void  selectUser() throws IOException {
    InputStream is =  Resources.getResourceAsStream("mybatis.config.xml");
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new
            SqlSessionFactoryBuilder();
    SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = userMapper.getUserById();
    System.out.println(user);
    sqlSession.close(); 
}

修改UserMapper.xml文件
添加：查询的结果放在List的时候其中的resultType不变。

<select id="getUserById" resultType="com.example.demo.object.User">
        select  *from user where  id = 1
    </select>
<!--resultType:设置结果类型，即是查询结果的类型；resultMap：自定义映射，
处理多对1或者1对多的映射关系-->

获取参数的情况：

之所以用arg0和arg1是因为当有多个参数的时候，底层会把参数储存到一个map集合中的，arg0和arg1分别对应传递过来的第一个参数和第二个参数。

相当于自己手动把数值放在map集合中了，访问的时候就用自己设置的键访问即可

因为底层将属性（get和set方法去掉get和set后的字符转小写组成的，当成员变量没有get和set方法的时候，不能当作属性）名和属性值通过map映射的，与上面的访问类似，直接在#{}括号中添加属性名即可。
相当于在底层的map中的键是直接设置Param注解的参数绑定的

mybatis的查询：

select count(age) user:查询的时候会把age列为null的值不算入count中。
这里的resultType实际上是别名是不区分大小写的，mybatis已经设置了常见类型的别名，这里的int和interger都可以而且不区分大小写。

@MapKey(“id”)
以id为返回map的键，其中值为查询结果（通常用在有多个返回结果的查询中），如果有多个结果就返回最后一个结果。其中的id如果无法识别就用null代替，@MapKey(“id”) 注解中的 id 表示一个属性名，表示返回结果集中以哪个属性的值作为 Map 的键。

特殊sql:

模糊查询：

批量删除：
动态设置表名：
这里不能用#{}是因为#{}在拼接sql语句的时候自动添加了引发。

处理多对1映射：注意在映射为实体类的时候，实体类中必须要有无参构造器

1.级联:
在核心配置文件中添加内容为：

<resultMap id="empDeptMap" type="com.example.demo.object.Emp">
       <id column="emp_id" property="empId"></id>
       <result column="emp_name" property="empName"></result>
     <result column="age" property="age"></result>
      <result column="gender" property="gender"></result>
       <result column="dept_id" property="dept.id"></result>
       <result column="dept_name" property="dept.name"></result>
   </resultMap>
   <select id="getEmpById" resultMap="empDeptMap">
    select  *from  t_emp left join  t_dept on t_emp.dept_id=t_dept.dept_id where  t_emp.emp_id = #{empId}
   </select>

元素可以包含多个子元素，每个子元素定义了如何将查询结果中的一列映射到Java对象的一个属性中。子元素通常包含以下属性：

column：指定要映射的查询结果列的名称或别名。
property：指定要映射到Java对象的属性的名称。
jdbcType：指定查询结果列的JDBC类型。
javaType：指定要映射到Java对象属性的类型。

typeHandler：指定要使用的类型处理器，用于在Java对象和数据库类型之间进行转换。子元素用于定义主键的映射，子元素用于定义其他属性的映射。一旦你定义了元素，你可以在标签中，使用 resultMap 属性指定了要使用的结果映射规则。这样，在 MyBatis 映射查询结果时，就会将 empId 列的值映射到 Emp 对象的 empId 属性中，将 empName 列的值映射到 Emp 对象的 empName 属性中。）

sql标签：

MyBatis 中的标签用于定义可重用的 SQL 片段，可以在 Mapper XML 文件中定义标签，并在需要使用这些 SQL 片段的地方引用它们。
例如，可以在 Mapper XML 文件中定义一个标签，用于定义一个可重用的 SQL 片段：

1
2
3

<sql id="selectColumns">
  emp_id, emp_name, emp_salary
</sql>

在这个示例中，标签的 id 属性指定了 SQL 片段的名称为 selectColumns，标签的内容为 SQL 片段的内容，包括查询的列名。
在需要使用这个 SQL 片段的地方，可以使用 ${} 占位符来引用它。例如：

<select id="selectEmp" resultType="Emp">
  select <include refid="selectColumns"/> from t_emp
  where emp_id = #{empId}
</select>

在这个示例中，使用标签引用了之前定义的 SQL 片段，refid 属性指定了 SQL 片段的名称为 selectColumns。这样，在生成 SQL 语句时，MyBatis 会将标签替换为 SQL 片段的内容，生成完整的 SQL 语句。
使用标签可以避免在 Mapper XML 文件中重复编写相同的 SQL 片段，提高了代码的重用性和可维护性。同时，使用标签还可以将复杂的 SQL 语句拆分为多个可重用的 SQL 片段，使 SQL 语句更加清晰易懂。

Mybatis的一级缓存：

MyBatis 的一级缓存是指在同一个 SqlSession 中，对于相同的查询语句和查询条件，MyBatis 可以将查询结果缓存起来，以便后续的查询可以直接使用缓存中的数据，而不需要再次执行 SQL 查询。
一级缓存是 MyBatis 默认开启的，它存储在 SqlSession 中，可以提高查询效率，减少与数据库的交互次数。在同一个 SqlSession 中，如果多次查询相同的数据，那么只有第一次查询会触发 SQL 查询，后续的查询都会从缓存中获取数据，从而提高查询效率。
一级缓存的实现方式是将查询结果存储在一个 Map 对象中，Map 的键值是查询语句和查询条件的组合，Map 的值是查询结果。在同一个 SqlSession 中，如果执行了更新、插入或删除操作，那么 MyBatis 会自动清空一级缓存，以保证缓存中的数据与数据库保持一致。
需要注意的是，一级缓存的作用范围仅限于同一个 SqlSession 中，如果使用多个 SqlSession 进行查询，那么每个 SqlSession 都会独立地维护自己的一级缓存。因此，在某些情况下，如果需要共享缓存，可以考虑使用 MyBatis 的二级缓存。
另外，MyBatis 还提供了一些配置选项，可以对一级缓存进行调整或禁用。例如，可以通过设置 localCacheScope 属性为 STATEMENT 来禁用一级缓存，或者通过设置 flushCache=“true” 属性来强制清空一级缓存。

一级缓存失效的方法：

执行结果的日志有2次sql语句，表示从数据库中进行了2次操作

Mybatis的二级缓存：

MyBatis 的二级缓存是指在多个 SqlSession 之间共享查询结果的缓存机制。与一级缓存不同，二级缓存的作用范围不仅限于同一个 SqlSession，而是可以跨越多个 SqlSession，甚至是多个应用程序实例。使用二级缓存可以减少与数据库的交互次数，提高应用程序的性能。
二级缓存的实现方式是将查询结果存储在一个可插拔的缓存实现中，可以选择使用 Ehcache、Redis 等第三方缓存框架，也可以使用 MyBatis 内置的缓存实现。在同一个应用程序实例中，多个 SqlSession 可以共享同一个缓存实现，从而实现数据的共享。
开启二级缓存需要在 Mapper XML 文件中配置标签，并在 MyBatis 配置文件中开启二级缓存功能。例如，可以在 MyBatis 配置文件中添加以下配置：

<configuration>
  <settings>
    <setting name="cacheEnabled" value="true"/>
  </settings>
</configuration>

在 Mapper XML 文件中，可以添加标签来配置二级缓存的相关属性。例如：

<cache
    eviction="LRU"
    flushInterval="60000"
    size="1024"
    readOnly="true"/>

在这个示例中，eviction 属性指定了缓存的清除策略为 LRU（Least Recently Used），flushInterval 属性指定了缓存的自动刷新时间为 60 秒，size 属性指定了缓存的最大大小为 1024，readOnly 属性指定了缓存是否只读。这些属性的含义和配置方式可以参考 MyBatis 的官方文档。
需要注意的是，二级缓存有一些限制和注意事项。例如，二级缓存中存储的数据是序列化后的对象，可能会导致性能下降；同时，如果数据被频繁地更新，那么缓存的命中率会降低，甚至会出现脏数据。因此，在使用二级缓存时，需要根据具体的业务场景进行适当的配置和调整。

Mybatis缓存查询顺序：

一级缓存只有在关闭或者提交的时候才会在二级缓存中生成数据。

整合第三方缓存：

是在二级缓存的基础上存在的。

Mybatis的逆向工程：

1.在pom.xml增加插件的配置文件：

<plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.0</version>

                <!-- 插件的依赖    -->
                <dependencies>
                <!-- 逆向工程的核心依赖    -->
                <dependency>
               <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-core</artifactId>
                <version>1.3.2</version>
                </dependency>
                <!-- MySQL驱动    -->
                <dependency>
                <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
                <version>8.0.16</version>
              </dependency>
               </dependencies>
                </plugin>

2.新增generatoeConfig.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
       PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
        <generatorConfiguration>
        <!--
targetRuntime: 执行生成的逆向工程的版本
MyBatis3Simple: 生成基本的CRUD（清新简洁版）
MyBatis3: 生成带条件的CRUD（奢华尊享版）
 -->
        <context id="DB2Tables" targetRuntime="MyBatis3">
        <!-- 数据库的连接信息    -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
        connectionURL="jdbc:mysql://localhost:3306/myemployees?serverTimezone=UTC"
        userId="root"
       password="A86789234">
        </jdbcConnection>
        <!-- javaBean的生成策略targetPackage是javaBean生成的目标包，targetProject是生成的路径，.表示
        项目根目录路径，..表示上一级路径,配置这种类似的时候注意路径-->
      <javaModelGenerator targetPackage="com.example.demo.pojo"
        targetProject=".\src\main\java">
          <!--能否使用子包-->
       <property name="enableSubPackages" value="true" />
          <!--把当前字段的前后空格字符去掉生成实体类的属性-->
      <property name="trimStrings" value="true" />
       </javaModelGenerator>
       <!-- SQL映射文件的生成策略 生成在com.example.mybatis.mapper包中的.\src\main\resources路径下   -->
        <sqlMapGenerator targetPackage="com.example.demo.mapper"
        targetProject=".\src\main\resources">
       <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
       <!-- Mapper接口的生成策略    -->
        <javaClientGenerator type="XMLMAPPER"
        targetPackage="com.example.demo.mapper" targetProject=".\src\main\java">
        <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- 逆向分析的表    -->
       <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
        <!-- domainObjectName属性指定生成出来的实体类的类名    -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
        </context>
        </generatorConfiguration>

insert和insertSelective的区别：如果某个属性为null的时候，insert是给改属性对应的列赋值为null,(如果该列有默认值就不会把改列赋值为默认值）,insertSelective是当某个属性为null的时候，不会把该属性对应的列插入数据，使其为默认值（如果有默认值的话）

3.生成的特殊EmpExample类和EmpMapper接口的分析：

MyBatis3 逆向工程生成的 EmpExample 类是用于封装 MyBatis 查询条件的一个实例。EmpExample 类主要包含以下属性和方法：
属性：

oredCriteria：一个 List 类型的属性，用于存放多个 Criteria 对象，每个 Criteria 对象代表一个查询条件。
orderByClause：一个 String 类型的属性，用于存放查询结果的排序方式。相当于 SQL 中的 order by 子句。
distinct：一个 boolean 类型的属性，用于指定查询结果是否去重。相当于 SQL 中的 distinct 关键字。

方法：

EmpExample()：无参构造方法，用于创建一个 EmpExample 对象。
createCriteria()：创建一个 Criteria 对象，并将该对象添加到 oredCriteria 列表中。
getOredCriteria()：获取 oredCriteria 列表，用于设置多个查询条件的情况。
setOrderByClause(String orderByClause)：设置查询结果的排序方式。
getOrderByClause()：获取查询结果的排序方式。
setDistinct(boolean distinct)：设置查询结果是否去重。
isDistinct()：获取查询结果是否去重。
clear()：清空查询条件。

通过 EmpExample 类，可以方便地构建查询条件，实现更加灵活的查询操作。可以通过 createCriteria() 方法创建一个 Criteria 对象，然后通过 Criteria 对象的方法设置查询条件，例如：

EmpExample example = new EmpExample();
Criteria criteria = example.createCriteria();
criteria.andNameEqualTo("Tom");
criteria.andAgeGreaterThan(20);

这个示例代码中，首先创建一个 EmpExample 对象，然后调用 createCriteria() 方法创建一个 Criteria 对象，使用 andNameEqualTo(“Tom”) 方法和 andAgeGreaterThan(20) 方法设置查询条件，表示查询名称为 Tom 并且年龄大于 20 的数据。其中Criteria是内部类。
除了设置查询条件之外，还可以通过 setOrderByClause() 方法设置查询结果的排序方式，通过 setDistinct() 方法设置查询结果是否去重。最后，可以通过调用 empMapper.selectByExample(example) 方法执行查询操作，获取查询结果列表。
其实还有一些内部类，在使用的时候可以通过图来快速查看。

1 2	1.int insertSelective(Emp record)：选择性地插入一条记录到 Emp 表中，只插入指定属性不为 null 的字段。

EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

// 查询操作
EmpExample example = new EmpExample();
example.createCriteria().andNameEqualTo("Tom");
List<Emp> empList = empMapper.selectByExample(example);

// 插入操作
Emp emp = new Emp();
emp.setName("Jerry");
emp.setAge(30);
int rows = empMapper.insert(emp);

// 更新操作
Emp emp = new Emp();
emp.setId(1);
emp.setName("Tom");
int rows = empMapper.updateByPrimaryKey(emp);

// 删除操作
int rows = empMapper.deleteByPrimaryKey(1);

分页功能；

在pom.xml中添加分页插件：

1
2
3

<plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>

可以通过IDEA搜索获取插件的地址

开启分页查询：PageHelper.startPage(1,4);

PageHelper.startPage(1,4) 是一个 Mybatis 分页插件的方法，它的作用是在执行查询之前设置分页参数，表示从第 1 页开始，每页显示 4 条记录。PageHelper 会自动拦截查询语句，添加 limit 子句，实现物理分页

public  void  testPage() throws IOException {
       InputStream is =  Resources.getResourceAsStream("mybatis-config.xml");
       SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new
               SqlSessionFactoryBuilder();
       SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
       SqlSession sqlSession = sqlSessionFactory.openSession(true);
       EmpMapper emp = sqlSession.getMapper(EmpMapper.class);
       //查询功能前开启分页
       Page<Object> page = PageHelper.startPage(1,4);
       List<Emp> list = emp.selectByExample(null);
       System.out.println(list);
       System.out.println(page);

   }

显示的结果为：

19:36:56.157 [main] DEBUG org.apache.ibatis.datasource.pooled.PooledDataSource - Checked out connection 417301556 from pool.
19:36:56.159 [main] DEBUG com.example.demo.mapper.EmpMapper.selectByExample_COUNT - ==>  Preparing: SELECT count(0) FROM t_emp
19:36:56.180 [main] DEBUG com.example.demo.mapper.EmpMapper.selectByExample_COUNT - ==> Parameters: 
19:36:56.197 [main] DEBUG com.example.demo.mapper.EmpMapper.selectByExample_COUNT - <==      Total: 1
19:36:56.199 [main] DEBUG com.example.demo.mapper.EmpMapper.selectByExample - ==>  Preparing: select emp_id, emp_name, age, gender, dept_id from t_emp LIMIT ?
19:36:56.199 [main] DEBUG com.example.demo.mapper.EmpMapper.selectByExample - ==> Parameters: 4(Integer)
19:36:56.202 [main] DEBUG com.example.demo.mapper.EmpMapper.selectByExample - <==      Total: 4
Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=4, pages=1, reasonable=false, pageSizeZero=false}[Emp{empId=1, empName='张三', age=20, gender='男', deptId=1}, Emp{empId=2, empName='李四', age=21, gender='女', deptId=2}, Emp{empId=3, empName='王五', age=22, gender='男', deptId=3}, Emp{empId=4, empName='赵六', age=23, gender='女', deptId=1}]
Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=4, pages=1, reasonable=false, pageSizeZero=false}[Emp{empId=1, empName='张三', age=20, gender='男', deptId=1}, Emp{empId=2, empName='李四', age=21, gender='女', deptId=2}, Emp{empId=3, empName='王五', age=22, gender='男', deptId=3}, Emp{empId=4, empName='赵六', age=23, gender='女', deptId=1}]

进程已结束,退出代码0
//可以看出显示的list被分页显示了。
//查询结果通过 selectByExample() 方法获取，这个方法的参数是一个空的 Example 对象，表示查询所有数据。查询结果是一个 Emp 对象列表。
//最后，分页信息可以通过输出 Page 对象来获取。Page 是 PageHelper 插件提供的一个分页信息类，它包含了当前页码、每页数据条数、总数据条数等分页信息。在这个示例代码中，通过输出 page 对象来获取分页信息。

为什么输出的list会有多余的Pagr信息
在这个示例代码中，输出的 list 中包含了多余的 Page 信息，是因为 PageHelper.startPage() 方法返回的是一个 Page 对象，这个 Page 对象包含了分页信息和查询结果列表。
因此，在查询操作完成之后，如果直接输出查询结果列表，会同时输出 Page 对象的信息和查询结果列表的信息。如果只想输出查询结果列表，可以通过调用 Page 对象的 getList() 方法来获取查询结果列表，例如：

List<Emp> list = emp.selectByExample(null);
Page<Object> page = PageHelper.startPage(1, 4);
List<Emp> resultList = page.getResult();
System.out.println(resultList);

在这个示例代码中，先调用 emp.selectByExample(null) 方法获取查询结果列表，然后再调用 Page 对象的 getResult() 方法获取查询结果列表。这样就可以避免输出多余的 Page 信息。

PageInfo<>

PageInfo<T> 是 MyBatis 分页插件 PageHelper 提供的一个分页信息类，用于封装分页信息和查询结果列表。

PageInfo<T> 类包含以下属性：

pageNum：当前页码。

pageSize：每页显示的数据条数。

size：当前页的实际数据条数。

startRow：当前页第一条数据的行号。

endRow：当前页最后一条数据的行号。

total：总数据条数。

pages：总页数。

list：查询结果列表。

prePage：上一页页码。

nextPage：下一页页码。

isFirstPage：是否为第一页。

isLastPage：是否为最后一页。

hasPreviousPage：是否有上一页。

hasNextPage：是否有下一页。

navigatePages：导航页码数。

navigatepageNums：所有导航页号。

PageInfo<T> 类常用的方法有：

PageInfo(List<T> list, int navigatePages)：构造方法，用于创建一个 PageInfo 对象。

getPageNum()：获取当前页码。

getPageSize()：获取每页显示的数据条数。

getSize()：获取当前页的实际数据条数。

getStartRow()：获取当前页第一条数据的行号。

getEndRow()：获取当前页最后一条数据的行号。

getTotal()：获取总数据条数。

getPages()：获取总页数。

getList()：获取查询结果列表。

getPrePage()：获取上一页页码。

getNextPage()：获取下一页页码。

isFirstPage()：判断是否为第一页。

isLastPage()：判断是否为最后一页。

hasPreviousPage()：判断是否有上一页。

hasNextPage()：判断是否有下一页。

getNavigatePages()：获取导航页码数。

getNavigatepageNums()：获取所有导航页号。

输出的信息”

PageInfo{pageNum=1, pageSize=4, size=4, startRow=1, endRow=4, total=4, pages=1,
list=Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=4, pages=1,
reasonable=false, pageSizeZero=false}
[Emp{empId=1, empName='张三', age=20, gender='男', deptId=1},
Emp{empId=2, empName='李四', age=21, gender='女', deptId=2}, Emp{empId=3, 
empName='王五', age=22, gender='男', deptId=3}, Emp{empId=4, empName='赵六',
age=23, gender='女', deptId=1}], prePage=0, nextPage=0, isFirstPage=true, 
isLastPage=true, hasPreviousPage=false, hasNextPage=false, navigatePages=5, 
navigateFirstPage=1, navigateLastPage=1, navigatepageNums=[1]}

Spring:

spring Framework简介：

SpringFramework教程_springframework的教程在官网哪里_疯了的程序员的博客-CSDN博客
 Java中的面向切面编程（AOP）_切面java_pedro7k的博客-CSDN博客

Spring IOC简介：

Spring IOC 是 Spring 框架的核心，它是一种实现了 IoC（Inversion of Control，控制反转）原则的容器，负责创建、配置、管理和装配应用程序中的对象（称为 bean）
5. The IoC container
。IoC 原则是指将对象的依赖关系（即它们需要协作的其他对象）交由外部容器或框架来设置，而不是由对象自己控制，从而实现对象之间的松耦合和动态绑定
Just a moment…
Spring IOC 容器有两种类型：BeanFactory 和 ApplicationContext。BeanFactory 是最基本的容器，提供了依赖注入（Dependency Injection，DI）的功能，即根据配置元数据（可以是 XML、注解或 Java 代码）来注入 bean 的属性或构造参数
5. The IoC container
。ApplicationContext 是 BeanFactory 的子接口，提供了更多的高级功能，如 AOP 集成、消息资源处理、事件发布等5. The IoC container。

Spring DI 简介：

Spring Boot注解全攻略(四)：@Autowired - 掘金
Spring DI（Dependency Injection，依赖注入）是 Spring Framework 的核心之一，它是实现 Spring IOC 的一种方式，用于解决对象之间的依赖关系。Spring DI 通过将对象之间的依赖关系的控制权反转给容器，来解决这些问题。具体来说，它在对象中定义依赖关系的接口，容器则负责实现这些接口并将实现注入到对象中

@Autowired注解详解

@Autowired注解详解——超详细易懂_子时不睡的博客-CSDN博客
 Spring Boot注解全攻略(四)：@Autowired - 掘金

IOC容器在Spirng中的实现：

基于XML的实现

1	ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("application.xml");

解释：
ClassPathXmlApplicationContext 类是 Spring 框架提供的一个实现类，它实现了 ApplicationContext 接口，用于创建和管理 Spring 容器。ClassPathXmlApplicationContext 类的构造器接受一个或多个字符串参数，表示要加载的 XML 配置文件的路径。这些路径是相对于类路径（classpath）的根目录的路径（也就是下图中的classes目录），如果以 / 开头，则表示相对于类路径的根目录，否则表示相对于当前类所在的包。在这行代码中，传入了一个字符串参数 “application.xml”，表示要加载类路径根目录下的 application.xml 文件，该文件定义了 Spring 容器中的 bean。通过这样的方式，就可以创建一个 Spring 容器，并根据 XML 配置文件来初始化和管理 bean。

其实上面的代码可以改成下面的也可以正常运行：

1	ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("/ application.xml");

理解相对路径：

在 Java 项目中，相对路径是指相对于某个参照点的路径，而不是绝对路径。相对路径的好处是可以避免硬编码文件的位置，使得代码更加灵活和可移植。相对路径的参照点可以有以下几种：

• 当前工作目录（working directory），即启动 Java 程序时所在的目录，或者通过 System.setProperty(“user.dir”, path) 方法设置的目录。如果使用 new File(path) 方法来访问文件，那么 path 就是相对于当前工作目录的路径。

• 当前类所在的包（package），即当前类的源文件所在的目录。如果使用 Class.getResource(path) 或 Class.getResourceAsStream(path) 方法来访问文件，那么 path 就是相对于当前类所在的包的路径，如果以 / 开头，则表示相对于类路径（classpath）的根目录。

• 类路径（classpath）的根目录，即 Java 程序加载类和资源的根目录。如果使用 ClassLoader.getResource(path) 或 ClassLoader.getResourceAsStream(path) 方法来访问文件，那么 path 就是相对于类路径的根目录的路径。

• web 工程（web project）的根目录，即 web 工程部署到服务器上的根目录。如果使用 ServletContext.getResource(path) 或 ServletContext.getResourceAsStream(path) 方法来访问文件，那么 path 就是相对于 web 工程的根目录的路径。
也就是相对路径也不一定是相对与当前类所在的目录。

获取bean的三种方法：

person是Student实现的接口，可以根据接口获取bean,当然这个接口只能有一个实现类。

依赖注入setter注入：

什么是依赖注入：

什么是依赖注入_taijianyu的博客-CSDN博客
。在 Spring 中，依赖注入是指 Spring 容器负责创建和管理 bean（即 Spring 容器中管理的对象），并根据 bean 之间的依赖关系，将依赖的 bean 注入到需要它的 bean 中，从而实现控制反转（Inversion of Control，IoC），即控制权由原来的 bean 转移到了 Spring 容器，从而降低了 bean 之间的耦合度，提高了代码的可维护性和可测试性。Spring 支持基于 XML、注解和 Java 代码的三种依赖注入方式，

    <bean id="studentTwo" class="com.example.demo.pojo.Student">
               <constructor-arg value="1002"></constructor-arg>
               <constructor-arg value="李四"></constructor-arg>
               <constructor-arg value="33"></constructor-arg>
               <constructor-arg value="女"></constructor-arg>
    </bean>
<!--只有一个 <constructor-arg >匹配的只有一个有参构造的构造器-->

通过属性赋值，赋值为空：

这给sex属性赋值为null字符串；
这给sex属性赋值为空。

在 Spring Framework 的 XML 配置文件中，可以使用标签来定义一个数组类型的属性值。标签可以包含多个或子标签，每个子标签表示数组中的一个元素。
例如，假设我们有一个 Person 类，它包含一个 hobbies 属性，表示一个人的爱好。hobbies 属性是一个字符串数组类型的属性。我们可以在 XML 配置文件中使用标签来定义这个数组类型的属性值：

<bean id="person" class="com.example.Person">
    <property name="hobbies">
        <array>
            <value>篮球</value>
            <value>足球</value>
            <value>游泳</value>
        </array>
    </property>
</bean>

这个配置将会创建一个 Person 实例，并将 “篮球”、“足球” 和 “游泳” 作为 hobbies 属性的值。在这个配置中，标签包含了三个子标签，每个子标签表示一个字符串类型的数组元素。
除了子标签外，标签还可以包含子标签，用于引用其他 Bean 的实例作为数组元素。例如：

<bean id="basketball" class="com.example.Hobby" />
<bean id="football" class="com.example.Hobby" />
<bean id="swimming" class="com.example.Hobby" />

<bean id="person" class="com.example.Person">
    <property name="hobbies">
        <array>
            <ref bean="basketball" />
            <ref bean="football" />
            <ref bean="swimming" />
        </array>
    </property>
</bean>

这个配置定义了三个 Hobby 类型的 Bean，并将它们分别命名为 “basketball”、“football” 和 “swimming”。然后，它又在标签中使用了三个子标签，分别引用了这三个 Bean 的实例，作为 Person 类的 hobbies 属性的值。

集合类型的依赖注入：依赖注入中util标签的引用和List和Map集和的使用：其实所缺的命名空间的绑定可以在IDEA中自动补充的

util 是 Spring 框架提供的一个命名空间，用于提供一些常用的工具和辅助类。在 Spring 的 XML 配置文件中，我们可以使用 util:* 标签来引用 util 命名空间中的定义，并将其应用到 Bean 的定义中。
在 Spring Framework 的 XML 配置文件中，可以使用标签来定义一个列表类型的属性值。标签可以包含多个或子标签，每个子标签表示列表中的一个元素。
例如，假设我们有三个 Student 类型的 Bean，分别命名为 “studentOne”、“studentTwo” 和 “studentThree”。我们可以在 XML 配置文件中使用 util:list 标签来定义这三个 Bean 实例的列表：

<bean id="studentOne" class="com.example.Student" />
<bean id="studentTwo" class="com.example.Student" />
<bean id="studentThree" class="com.example.Student" />

<util:list id="students">
    <ref bean="studentOne" />
    <ref bean="studentTwo" />
    <ref bean="studentThree" />
</util:list>

这个配置将会创建一个列表类型的 Bean，将 “studentOne”、“studentTwo” 和 “studentThree” 作为列表元素。在这个配置中，util:list 标签包含了三个子标签，每个子标签表示一个引用类型的列表元素。
除了子标签外，util:list 标签还可以包含子标签，用于定义值类型的列表元素。例如：

<util:list id="numbers">
    <value>1</value>
    <value>2</value>
    <value>3</value>
</util:list>

这个配置将会创建一个列表类型的 Bean，将 1、2 和 3 作为列表元素，它们都是整数类型的值。在这个配置中，util:list 标签包含了三个子标签，每个子标签表示一个整数类型的值类型的列表元素。
util:list 是 Spring Framework 中的一个实用工具标签，用于定义列表类型的 Bean。为了使用 util:list 标签，我们需要在 XML 配置文件中导入 Spring 的 util 命名空间。具体方法是在 XML 文件的根标签中添加xmlns:util=“http://www.springframework.org/schema/util” 命名空间声明，同时在
xsi:schemaLocation中添加

1 2	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util
                           http://www.springframework.org/schema/util/spring-util.xsd"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
       
    <!-- 这里可以定义 Bean -->
    
    <util:list id="students">
        <ref bean="studentOne" />
        <ref bean="studentTwo" />
        <ref bean="studentThree" />
    </util:list>
</beans>

详解 xml 文件头部的 xmlns:xsi_萧萧九宸的博客-CSDN博客
xml：命名空间，防止命名冲突
xsi是XML Schema Instance的缩写，它是一个预定义的命名空间前缀，用于引用XML Schema的实例。 xsi:schemaLocation是一个预定义的属性，用于指定XML文档所引用的XML Schema的位置。

@Test
       public  void TestList() {
           ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
           List<Student> students = (List<Student>) context.getBean("students");
           for (Student student : students) {
               System.out.println(student);
           }
       }

测试结果：

<!--map集合类型的bean-->
<util:map id="teacherMap">
   <entry>
       <key>
           <value>10010</value>
       </key>
       <ref bean="teacherOne"></ref>
   </entry>
   <entry>
       <key>
           <value>10086</value>
       </key>
       <ref bean="teacherTwo"></ref>
   </entry>
</util:map>

总结：其实中的键值对还可以这样写：（当值为字符串的时候）
由于标签中的内容会被解析为字符串类型，当值不为字符串的时候用或者
标签，和<value-ref=“teacherOne”/>是等价的。

依赖注入之p命名空间：

p:前缀是一个命名空间前缀，用于简化property元素的写法，它表示该属性是一个property元素的简写形式。
添加后配置文件新增的内容：（红线部分）

依赖注入：

1 2	<bean id = "studentSix" class="com.example.demo.pojo.Student" p:id="1005" p:name="小明" p:sex="女" p:clazz-ref="clazzOne" p:hobbies="游泳,跑步,阅读" ></bean>

测试：

@Test
   public  void TestP() {
       ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
       Student studentSix = context.getBean("studentSix", Student.class);
       System.out.println(studentSix);
   }

1
2

Student{id=1005, name='小明', age=null, sex='女', clazz=Clazz{clazzId=3333, clazzName='最强王者班', students=null}, hobbies=[游泳, 跑步, 阅读], teacherMap=null}
//没有赋值的属性都是null

特殊情况p语法糖配置的属性为List或者Map的情况：

如果 p:hobbies 是一个 List 或 Map 类型的属性，我们可以使用 util:list 或 util:map 标签来配置它的属性值。例如，假设 com.example.demo.pojo.Student 类中的 hobbies 属性是一个 List 类型的列表，我们可以将标签修改为以下形式：

<bean id="studentSix" class="com.example.demo.pojo.Student"
      p:id="1005" p:name="小明" p:sex="女" p:clazz-ref="clazzOne">
    <property name="hobbies">
        <list>
            <value>游泳</value>
            <value>跑步</value>
            <value>阅读</value>
        </list>
    </property>
</bean>

在这个例子中，我们使用了标签来设置 Student 类中的 hobbies 属性。标签中的 name 属性指定了要设置的属性名，而 util:list 标签中包含了若干个标签，每个标签的文本内容即为列表中的一个元素。在这个例子中，util:list 标签中包含了三个标签，分别设置了 hobbies 列表的三个元素为 “游泳”、“跑步” 和 “阅读”。
如果 p:hobbies 是一个 Map 类型的属性，我们可以使用 util:map 标签来配置它的属性值。例如，假设 com.example.demo.pojo.Student 类中的 hobbies 属性是一个 Map<String, String> 类型的映射表，我们可以将标签修改为以下形式：
在这个例子中，我们同样使用了标签来设置 Student 类中的 hobbies 属性。util:map 标签中包含了若干个标签，每个标签分别表示一个键值对。在这个例子中，我们设置了 hobbies 映射表中的三个键值对，分别为 “1”-“游泳”、“2”-“跑步” 和 “3”-“阅读”。

<bean id="studentSix" class="com.example.demo.pojo.Student"
      p:id="1005" p:name="小明" p:sex="女" p:clazz-ref="clazzOne">
    <property name="hobbies">
        <map>
            <entry key="1" value="游泳"/>
            <entry key="2" value="跑步"/>
            <entry key="3" value="阅读"/>
        </map>
    </property>
</bean>

Spring管理数据源：druid事例

导入依赖：

<!-- MySQL驱动    -->
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.16</version>
</dependency>
<!-- 数据源    -->
<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid</artifactId>
   <version>1.0.31</version>
</dependency>

在您提供的代码片段中，包含了两个 Maven 依赖项，分别是 mysql-connector-java 和 druid，它们用于在 Java 应用程序中使用 MySQL 数据库和数据源。
具体来说，mysql-connector-java 是 MySQL 官方提供的 Java JDBC 驱动程序，用于连接 MySQL 数据库。在 Maven 项目中添加该依赖项后，我们可以在 Java 代码中使用 com.mysql.cj.jdbc.Driver 类来加载 MySQL JDBC 驱动程序，从而连接到 MySQL 数据库。
druid 是阿里巴巴提供的一个高性能 JDBC 连接池框架，它提供了许多高级功能，例如连接池缓存、连接池监控、SQL 防火墙等。在 Maven 项目中添加该依赖项后，我们可以在 Java 代码中使用 com.alibaba.druid.pool.DruidDataSource 类来创建一个 Druid 数据源，从而在应用程序中管理 JDBC 连接池。
设置配置文件：

<bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName"  value="com.mysql.cj.jdbc.Driver"></property>
    <property name="url"  value="jdbc:mysql://localhost:3306/myemployees?serverTimezone=UTC"></property>
    <property name="username"  value="root"></property>
    <property name="password"  value="A86789234"></property>
</bean>

配置文件都是关于数据库连接的文件，一般这些是放在一个数据库配置文件中的。其实可以通过jdbc资源配置文件配置：

jdbc.user=root
jdbc.password=A86789234
jdbc.url=jdbc:mysql://localhost:3306/myemployees?serverTimezone=UTC
jdbc.driver=com.mysql.cj.jdbc.Driver

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName"  value="${jdbc.driver}"></property>
    <property name="url"  value="${jdbc.url}"></property>
    <property name="username"  value="${jdbc.user}"></property>
    <property name="password"  value="${jdbc.password}"></property>
</bean>
</beans>

   @Test
    public  void  testDatasource() throws SQLException {
        ClassPathXmlApplicationContext ioc= new ClassPathXmlApplicationContext("spring-datasource.xml");
        //也可以通过其父类或者所实现的接口
//        DataSource dataSource = ioc.getBean(DataSource.class);
        DruidDataSource druidDataSource = ioc.getBean(DruidDataSource.class);
        System.out.println(druidDataSource.getConnection());

    }
//输出结果：
//com.mysql.cj.jdbc.ConnectionImpl@3e694b3f

bean的作用域：

在 Spring 容器中，Bean 的作用域决定了 Bean 实例的生命周期和可见范围。Spring 提供了以下五种 Bean 作用域：

singleton：单例模式。在整个 Spring 容器中，只会创建一个 Bean 实例，并在需要时共享该实例。默认情况下，所有未显式指定作用域的 Bean 都会使用单例模式。
prototype：原型模式。每次从容器中获取该 Bean 时，都会创建一个新的实例，并返回给调用者。
request：Web 应用程序中的请求作用域。在一次 HTTP 请求中，容器会为每个请求创建一个新的实例，并在请求结束时销毁该实例。
session：Web 应用程序中的会话作用域。在用户会话期间，容器会为每个会话创建一个新的实例，并在会话结束时销毁该实例。
global session：Web 应用程序中的全局会话作用域。与 session 作用域类似，但仅适用于 Portlet 环境。

1
2
3

<bean id="myBean" class="com.example.MyBean" scope="prototype">
    <!-- Bean 的配置信息 -->
</bean>

1.在IOC容器中默认为单例,也即是scope默认为singleton

<bean id = "student" class="com.example.demo.pojo.Student">
    <property name="id" value="1009"></property>
    <property name="name" value="钱九"></property>
    <property name="age" value="29"></property>
    <property name="sex" value="女"></property>
</bean>

  @Test
    public void  testScope()
    {
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-scope.xml");
        Student student1 = ioc.getBean(Student.class);
        Student student2 = ioc.getBean(Student.class);
        System.out.println(student1);
        System.out.println("-----------");
        System.out.println(student2);
        System.out.println(student1==student2);
    }
//Student{id=1009, name='钱九', age=29, sex='女', clazz=null, hobbies=null, teacherMap=null}
//-----------
//Student{id=1009, name='钱九', age=29, sex='女', clazz=null, hobbies=null, teacherMap=null}
//true

2.设置为scope=“prototype”

<bean id = "student" class="com.example.demo.pojo.Student" scope="prototype">
    <property name="id" value="1009"></property>
    <property name="name" value="钱九"></property>
    <property name="age" value="29"></property>
    <property name="sex" value="女"></property>
</bean>

Student{id=1009, name='钱九', age=29, sex='女', clazz=null, hobbies=null, teacherMap=null}
-----------
Student{id=1009, name='钱九', age=29, sex='女', clazz=null, hobbies=null, teacherMap=null}
false

bean的生命周期：

一篇文章让你彻底搞懂Bean后置处理器及执行时机 - 掘金

package com.example.demo.pojo;

public class User {
   private Integer id;
   private String username;
   private String password;
   private Integer age;
   public User() {
       System.out.println("生命周期1：实例化");
 }
   public User(Integer id, String username, String password, Integer age) {
       this.id = id;
       this.username = username;
       this.password = password; 
       this.age = age;
 }
   public Integer getId() { 
       return id;
 }
   public void setId(Integer id) {
       System.out.println("生命周期2：依赖注入");
       this.id = id;

 }
   public String getUsername() { 
       return username;
 }
   public void setUsername(String username) { 
       this.username = username;
 }
   public String getPassword() { 
       return password;
 }
   public void setPassword(String password) { 
       this.password = password;
 }
   public Integer getAge() { 
       return age;
 }
   public void setAge(Integer age) { 
       this.age = age;
 }
   @Override
   public String toString() { 
       return "User{" +
               "id=" + id +
               ", username='" + username + '\'' + 
               ", password='" + password + '\'' + 
               ", age=" + age +
               '}';

 }
 public void  initMethod()
 {
     System.out.println("生命周期3：初始化！");
 }
    public void  destroyMethod()
    {
        System.out.println("生命周期4：销毁！");
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- scope属性：取值singleton（默认值），bean在IOC容器中只有一个实例，IOC容器初始化时创建
    对象   init-method 和destroy-method分别表示初始化和摧毁时调用的方法-->
    <!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象    -->
    <bean class="com.example.demo.pojo.User" scope="prototype" init-method="initMethod" destroy-method="destroyMethod">
        <property name="id" value="1009"></property>
        <property name="username" value="钱九"></property>
        <property name="age" value="29"></property>
        <property name="password" value="123456"></property>
    </bean>
</beans>

  @Test
    public  void  testLife()
    {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-lifetime.xml");
            User user1 = ac.getBean(User.class);
            User user2 = ac.getBean(User.class);
            System.out.println(user1==user2);
            ac.close();//刷新关闭容器关闭刷新
    }
//生命周期1：实例化
//生命周期2：依赖注入
//生命周期3：初始化！
//生命周期1：实例化
//生命周期2：依赖注入
//生命周期3：初始化！
//false
//20:52:59.913 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Closing org.springframework.context.support.ClassPathXmlApplicationContext@6b2fad11, started on Wed Jul 05 20:52:59 CST 2023

那什么时候实例化呢？

<!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象    -->
<bean id="user" class="com.example.demo.pojo.User" scope="prototype" init-method="initMethod" destroy-method="destroyMethod">
    <property name="id" value="1009"></property>
    <property name="username" value="钱九"></property>
     <property name="age" value="29"></property>
    <property name="password" value="123456"></property>
</bean>

 @Test
    public  void  testLife()
    {
        ConfigurableApplicationContext ac = new ClassPathXmlApplicationContext("spring-lifetime.xml");
//            User user1 = ac.getBean(User.class);
           /* User user2 = ac.getBean(User.class);
            System.out.println(user1==user2);
            ac.close();*/
    }
//无输出结果

 @Test
    public  void  testLife()
    {
        ConfigurableApplicationContext ac = new ClassPathXmlApplicationContext("spring-lifetime.xml");
          User user1 = ac.getBean(User.class);
           /* User user2 = ac.getBean(User.class);
            System.out.println(user1==user2);
            ac.close();*/
    }
//生命周期1：实例化
//生命周期2：依赖注入
//生命周期3：初始化

  @Test
    public  void  testLife()
    {
        ConfigurableApplicationContext ac = new ClassPathXmlApplicationContext("spring-lifetime.xml");
          User user1 = ac.getBean(User.class);
            User user2 = ac.getBean(User.class);
            System.out.println(user1==user2);
            ac.close();
    }
//生命周期1：实例化
//生命周期2：依赖注入
//生命周期3：初始化！
//生命周期1：实例化
//生命周期2：依赖注入
//生命周期3：初始化！
//false
//21:51:58.077 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Closing org.springframework.context.support.ClassPathXmlApplicationContext@6b2fad11, started on Wed Jul 05 21:51:57 CST 2023

//进程已结束,退出代码0

可以看出多例模式（scope=“prototype”）是在或者bean对象时实例化

<bean id="user" class="com.example.demo.pojo.User" scope="singleton" init-method="initMethod" destroy-method="destroyMethod">
       <property name="id" value="1009"></property>
       <property name="username" value="钱九"></property>
        <property name="age" value="29"></property>
       <property name="password" value="123456"></property>
   </bean>

  @Test
    public  void  testLife()
    {
        ConfigurableApplicationContext ac = new ClassPathXmlApplicationContext("spring-lifetime.xml");
//          User user1 = ac.getBean(User.class);
           /* User user2 = ac.getBean(User.class);
            System.out.println(user1==user2);
            ac.close();*/
    }
//生命周期1：实例化
//生命周期2：依赖注入
//生命周期3：初始化！

总结：这里可以看出单例为啥后面创建的类和第一个类的地址一样,单例模式在创建容器的时候实例化，依赖注入，初始化，随着容器的关闭而摧毁，多例模式在创建对象的时候实例化，依赖注入，初始化，容器关闭不会摧毁bean

在 Spring 容器中，每个 Bean 的生命周期包括以下三个阶段：

实例化阶段：在这个阶段，容器会使用 Bean 的构造函数或工厂方法创建一个新的 Bean 实例。
初始化阶段：在这个阶段，容器会对 Bean 进行属性注入和其他初始化操作，例如调用 Bean 的 init-method 方法。
销毁阶段：在这个阶段，容器会销毁 Bean 实例，并在销毁前调用 Bean 的 destroy-method 方法进行清理操作。

bean的后置处理器：

bean的后置处理器可以在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口（有2个默认方法），
且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容
器中所有bean都会执行

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MybeanPostProcessor implements BeanPostProcessor {
    //初始化之前执行
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("☆☆☆" + beanName + " = " + bean);
        return bean;
    }
    //初始化之后执行
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("★★★" + beanName + " = " + bean);
        return bean;
    }
}

1 2	<!-- bean的后置处理器要放入IOC容器才能生效 --> <bean id="myBeanProcessor" class="com.example.demo.pojo.MybeanPostProcessor"/>

    @Test
    public  void  testProcessor()
    {
        ConfigurableApplicationContext ac = new ClassPathXmlApplicationContext("spring-lifetime.xml");
        User user1 = ac.getBean(User.class);
        System.out.println(user1);
        ac.close();
    }
  /*  生命周期1：实例化
    生命周期2：依赖注入
☆☆☆user = User{id=1009, username='钱九', password='123456', age=29}
    生命周期3：初始化！
        ★★★user = User{id=1009, username='钱九', password='123456', age=29}
    User{id=1009, username='钱九', password='123456', age=29}
22:13:39.564 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Closing org.springframework.context.support.ClassPathXmlApplicationContext@73f792cf, started on Wed Jul 05 22:13:39 CST 2023

    进程已结束,退出代码0
*/

接口的默认方法

public interface MyInterface {
    // 抽象方法
    void myMethod();

    // 默认方法
    default void myDefaultMethod() {
        // 方法体
    }
}

默认方法使用default关键字进行声明，接口的默认方法可以访问接口中的静态变量和静态方法，但是不能访问实现类中的成员变量和成员方法。当一个类实现了多个接口并且这些接口中都有相同名称的默认方法时，编译器会报错。此时需要在实现类中覆盖默认方法并指定具体的实现。接口的默认方法可以被实现类直接使用，也可以被实现类重写。接口的默认方法可以被继承，如果一个子接口继承了一个父接口，并且重写了父接口中的默认方法，那么子接口中的默认方法会覆盖父接口中的默认方法。接口的默认方法可以被多继承，如果一个类实现了多个接口，并且这些接口中有相同签名的默认方法，那么这个类必须重写这个默认方法，或者使用super关键字来指定使用哪个接口中的默认方法。

FactoryBean:

package com.example.demo.pojo;

import org.springframework.beans.factory.FactoryBean;

public class UserFactoryBean implements FactoryBean<User> {
   @Override
   public User getObject() throws Exception { 
       return new User();
 }
   @Override
   public Class<?> getObjectType() { 
       return User.class;
 }
}

1	<bean id="user" class="com.example.demo.pojo.UserFactoryBean"></bean>

  @Test
    public  void  factoryTest()
    {
        //获取IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-factory.xml");
        //因为交给IOC容器管理的是user对象
        User user = (User) ac.getBean("user");
        System.out.println(user);
    }
/*    生命周期1：实例化
    User{id=null, username='null', password='null', age=null}*/

基于XML的自动装配：

简单来说就是要装配的bean的中，其中有属性为类（可以创建bean的），这个时候可以不用指定ref或者vaule，指定寻找IOC中的bean

写在前面：

【Spring】使用xml文件实现自动装配；使用注解@Autowired和@Resource实现自动装配_StudiousTiger的博客-CSDN博客
基于xml的自动装配是Spring框架提供的一种简化Bean依赖注入的方式，它可以让Spring容器根据Bean的名称或类型自动查找并注入相应的属性值，而不需要手动指定ref或value属性。在Spring配置文件中，为需要自动装配的Bean添加autowire属性，并指定其值为byName、byType、constructor、default或no。

• byName表示根据Bean的名称进行自动装配，要求Bean的id与被注入属性的名称相同。

• byType表示根据Bean的类型进行自动装配，要求Bean的类型与被注入属性的类型相同，且在容器中只有一个该类型的Bean。

• constructor表示根据构造器参数进行自动装配，要求容器中有与构造器参数类型和顺序相匹配的Bean。

• default表示使用容器默认的自动装配策略，通常是no，即不进行自动装配。

• no表示不进行自动装配，需要手动指定ref或value属性。

下面举一个简单的例子来说明基于xml的自动装配。假设我们有一个Person类，它有一个name属性和一个Car属性：

public class Person {
private String name;
private Car car;

// 省略构造器、getter和setter
}

public class Car {
private String brand;
private double price;

// 省略构造器、getter和setter
}

我们想要让Spring容器自动为Person对象注入Car对象，而不需要手动指定ref属性。我们可以在Spring配置文件中，为Person Bean添加autowire属性，并设置其值为byName或byType：

或者

#### xml的自动装配开始：

public class UserController {
   private UserService userService;
   public void setUserService(UserService userService) {
       this.userService = userService;
 }
   public void saveUser(){
       userService.saveUser();
 }
}

public interface UserService {
     void saveUser();
}

public class UserServiceImpl implements UserService {
   private UserDao userDao;
   public void setUserDao(UserDao userDao) {
         this.userDao = userDao; 
 }
   @Override
   public void saveUser() { 
       userDao.saveUser(); 
 }
    }

public interface UserDao {
    void saveUser();
}

public class UserDaoImpl implements UserDao {
   @Override
   public void saveUser() {
       System.out.println("保存成功"); 
 }
}

上面的类和接口有一环一环的依赖，controller依赖server，server依赖Dap

<bean id="userController" class="com.example.demo.controller.UserController" >
    <property name="userService" ref="userService"></property>
</bean>
    <bean id="userService" class="com.example.demo.service.impl.UserServiceImpl" >
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userDao" class="com.example.demo.UserDao.impl.UserDaoImpl" >
    </bean>

@Test
 public  void  testAutowire ()
 {
     ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-autowire.xml");
     UserController userController = context.getBean(UserController.class);
    userController.saveUser();
 }
 //输出
 //保存成功

###### 修改配置文件自动装配：byType 使用bean标签的autowire属性设置自动装配效果自动装配方式：byType byType：根据类型匹配IOC容器中的某个兼容类型的bean，为属性自动赋值若在IOC中，没有任何一个兼容类型的bean能够为属性赋值，则该属性不装配，即值为默认值 null 若在IOC中，有多个兼容类型的bean能够为属性赋值，则抛出异常 NoUniqueBeanDefinitionException 自动装配方式：byName byName：将自动装配的属性的属性名，作为bean的id在IOC容器中匹配相对应的bean进行赋值

<bean id="userController"
          class="com.example.demo.controller.UserController" autowire="byType">
    </bean>
    <bean id="userService"
          class="com.example.demo.service.impl.UserServiceImpl" autowire="byType">
    </bean>
    <bean id="userDao" class="com.example.demo.UserDao.impl.UserDaoImpl"></bean>

###### 总结： ![image.png](https://cdn.nlark.com/yuque/0/2023/png/28066124/1688572395284-7fc48f55-6850-4e8f-9b82-148eb630de6a.png#averageHue=%23ede9d9&clientId=u03b8032e-d2db-4&from=paste&height=49&id=u8f11fe5c&originHeight=61&originWidth=687&originalType=binary&ratio=1.25&rotation=0&showTitle=false&size=34049&status=done&style=none&taskId=ub921892a-9e64-42ec-bee0-6b2bc914922&title=&width=549.6)**（自动装配只能装配那些接口，类等属性，也就是要用ref标签引用的属性，其他的不能，需要手动设置属性）** ![image.png](https://cdn.nlark.com/yuque/0/2023/png/28066124/1688572942220-8d320593-000c-45a1-b796-a434a5b204c4.png#averageHue=%23edeada&clientId=u03b8032e-d2db-4&from=paste&height=62&id=u7f7b0613&originHeight=77&originWidth=690&originalType=binary&ratio=1.25&rotation=0&showTitle=false&size=58220&status=done&style=none&taskId=u87b52934-0a7f-4080-a642-a755a0a4fe8&title=&width=552) ![image.png](https://cdn.nlark.com/yuque/0/2023/png/28066124/1688573407060-7980193b-507e-44a1-8659-d909df492fab.png#averageHue=%23f5f4ef&clientId=u03b8032e-d2db-4&from=paste&height=93&id=u6ed64cfc&originHeight=116&originWidth=682&originalType=binary&ratio=1.25&rotation=0&showTitle=false&size=85159&status=done&style=none&taskId=u128337dc-3339-46fa-bb84-27541f90112&title=&width=545.6) ###### 自动装配byName: byName自动装配它的作用是根据bean的属性名和xml中定义的bean的id进行匹配，如果匹配成功，则将对应的bean注入到属性中。 #### 基于注解的bean管理：基于xml的管理常用于第三方提供的bean ①注解和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。本质上：所有一切的操作都是Java代码来完成的，XML和注解只是告诉框架中的Java代码如何执行。 **注意：基于注解管理bean的时候，注解是要加到实现类的，不能加到接口的** #### 相关注解： @Component：将类标识为普通组件 @Controller：将类标识为控制层组件 @Service：将类标识为业务层组件 @Repository：将类标识为持久层组件（这4个注解功能都是将类标记为组件，只不过他们各自的含义不一样。对应spring管理ioc的时候，这4个注解是等效的，也就是说这4个注解可以替换，但是对于开发人员来说，他们是有各自不同的含义的）

@Component
@Component注解是标记一个类为Spring管理的组件的基本注解。被@Component注解标记的类会被自动扫描并创建为Bean对象，可以通过IoC容器进行管理和使用。通常情况下，使用@Component注解被标记的类都是一些通用的Bean类，没有特别的业务逻辑。
@Component还有一些扩展的注解，如@Repository, @Service, @Controller等，它们都是@Component的元注解（注解注解的注解），具有相同的功能，但是在不同的层次上有不同的含义。@Component还可以配合@PostConstruct和@PreDestroy注解来指定bean的初始化和销毁方法。

@Controller
@Controller注解是标记一个类为Spring MVC中的控制器的注解。被@Controller注解标记的类会被自动扫描并创建为Bean对象，并且会被Spring MVC框架用作请求处理器。@Controller注解通常用于处理用户请求，并返回相应的视图。

@Service
@Service注解是标记一个类为服务层组件的注解。被@Service注解标记的类会被自动扫描并创建为Bean对象，并且通常用于业务逻辑的处理，例如数据的处理、计算等。@Service注解通常被用作一个服务类的标志。

@Repository
@Repository注解是标记一个类为数据访问层组件的注解。被@Repository注解标记的类会被自动扫描并创建为Bean对象，并且通常用于数据的访问和持久化操作，例如数据库的访问、文件的读写等。

@Autowired
@Autowired注解是自动装配的注解，它可以自动将一个Bean注入到另一个Bean中。它可以用于属性、构造函数和方法上。当一个Bean需要使用其他Bean时，可以使用@Autowired注解将需要的Bean注入到当前Bean中，完成依赖注入。
当用在构造器上时，Spring会自动查找与构造器参数类型匹配的Bean，并将它们注入到相应的位置。如果存在多个类型匹配的Bean，Spring会抛出一个异常。在这种情况下，我们可以使用@Qualifier注解来指定要注入的Bean。
@Qualifier
@Qualifier注解是用于注入特定Bean的注解。当一个接口有多个实现类时，可以使用@Qualifier注解指定需要注入的实现类，避免自动装配出现歧义。

@Value
@Value注解是用于注入属性值的注解，可以将配置文件中的属性值注入到Bean中。@Value注解可以用于属性、构造函数和方法上。

@PostConstruct
@PostConstruct注解是在Bean初始化之后执行的方法级别注解。当Bean初始化完成后，@PostConstruct注解的方法会被自动调用，可以在该方法中进行一些初始化操作。

@PreDestroy
@PreDestroy注解是在Bean销毁之前执行的方法级别注解。当Bean销毁之前，@PreDestroy注解的方法会被自动调用，可以在该方法中进行一些清理操作。

#### 扫描组件： ###### 最基本的：为了让spring能够扫描到注解，需要在spring的配置文件添加关于扫描的配置，和在pom文件中添加相关的依赖

1
2
3

<context:component-scan base-package="com.example">
   </context:component-scan>
   <!-component-scan:组件扫描，base-package:通过包来扫描，包名写的越精确扫描的时间越短->

<!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包    -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.1</version>
</dependency>

###### 指定排除的：

<context:component-scan base-package="com.atguigu"> 
   <!-- context:exclude-filter标签：指定排除规则    --> 
   <!--
type：设置排除或包含的依据
type="annotation"，根据注解排除，expression中设置要排除的注解的全类名
type="assignable"，根据类型排除，expression中设置要排除的类型的全类名
在IDE中，可以使用快捷键或右键菜单来复制类的全类名，
例如在IDEA中，可以选中一个类名，然后右键选择Copy Reference，
  或者使用Ctrl+Alt+Shift+C快捷键。-->
expression="org.springframework.stereotype.Controller"/> 
       <!--<context:exclude-filter type="assignable" 
expression="com.atguigu.controller.UserController"/>-->
</context:component-scan

###### 只扫描指定的：

<context:component-scan base-package="com.atguigu" use-default-filters="false"> 
   <!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则    -->
   <!-- use-default-filters属性：取值false表示关闭默认扫描规则    -->
   <!-- 此时必须设置use-default-filters="false"，因为默认规则即扫描指定包下所有类    --> 
   <!--
type：设置排除或包含的依据
type="annotation"，根据注解排除，expression中设置要排除的注解的全类名
type="assignable"，根据类型排除，expression中设置要排除的类型的全类名
-->
   <context:include-filter type="annotation" 
expression="org.springframework.stereotype.Controller"/>
<!--<context:include-filter type="assignable" 
expression="com.atguigu.controller.UserController"/>-->
</context:component-scan>

#### bean的id: 在Spring中，Bean ID可以通过多种方式指定，包括：

默认规则:扫描加注解
当使用@Component等注解标记一个类时，如果没有显式指定Bean ID，则默认使用类名的首字母小写作为Bean ID。例如，一个名为UserService的类，其默认的Bean ID为userService。
使用@Bean注解
当使用@Bean注解在配置类中定义一个Bean时，可以显式指定Bean ID。例如：

@Configuration
public class AppConfig {
    @Bean("userService")
    public UserService userService() {
        return new UserServiceImpl();
    }
}

在这个例子中，@Bean注解用于定义一个Bean，并指定了Bean ID为userService。
3.使用注解的value属性自定义id：

使用XML配置
在XML配置文件中，可以使用元素来定义一个Bean，并指定Bean ID。例如：

1
2
3

<bean id="userService" class="com.example.demo.UserService">
    <!-- 配置其他属性 -->
</bean>

在这个例子中，使用元素定义了一个名为userService的Bean，并指定其类为com.example.demo.UserService。

基于注解的自动装配：

注意：

基于注解的自动装配，不需要在本类中为该属性设置get和set方法

@Autowired:

用法：在基于注解的自动装配中用于将一个Bean注入到另一个Bean中。
1.可以标识在成员变量上，这个时候该成员方法可以不用在它所在的类中设置相关的get和set方法。
2.当我们使用@Autowired注解时，Spring会自动查找与被注入的属性或方法参数类型匹配的Bean，并将它们注入到相应的位置。例如：

@Component
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    // ...
}

在这个例子中，我们使用@Autowired注解将UserDao注入到了UserServiceImpl中的userDao属性中。当Spring容器启动时，它会自动找到一个类型为UserDao的Bean，并将它注入到userDao属性中。
@Autowired注解可以用在构造器、属性、方法上。当用在构造器上时，Spring会自动查找与构造器参数类型匹配的Bean，并将它们注入到相应的位置。例如：

@Component
public class UserController {
    private UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    // ...
}

在这个例子中，我们使用@Autowired注解将userService注入到了构造器中。当Spring容器启动时，它会自动查找一个类型为UserService的Bean，并将它注入到构造器中。
需要注意的是，如果存在多个类型匹配的Bean，Spring会抛出一个异常。在这种情况下，我们可以使用@Qualifier注解来指定要注入的Bean。例如：

@Component
public class UserServiceImpl implements UserService {
    @Autowired
    @Qualifier("userDaoImpl")
    private UserDao userDao;

    // ...
}

在这个例子中，我们使用@Qualifier注解指定了要注入的Bean的名称为"userDaoImpl"。这样，当存在多个类型为UserDao的Bean时，Spring会查找名称为"userDaoImpl"的Bean并将它注入到userDao属性中。
required: 这个属性可以指定是否必须存在一个匹配的bean。默认值是true，如果没有找到匹配的bean，会抛出异常。如果设置为false，那么当没有找到匹配的bean时，字段或者参数会被设置为null。

原理：

代理模式的介绍：

二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标
方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑
的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调
用和打扰，同时让附加功能能够集中在一起也有利于统一维护。（简单来说就是在调用目标对象之前进行额外的操作，这个时候就需要进行代理，用代理对象来调用目标对象的操作，并且在代理对象中实现额外操作。可能是使用到代理的情况：当创建一个对象的开销很大时，可以使用代理来延迟对象的创建，只有在需要访问对象时才会创建对象，从而减少了开销。当需要控制对对象的访问时，可以使用代理来限制对对象的访问。代理可以检查调用者的权限，从而保护对象的安全性。）

public interface UserService {
    void save(User user);
}

public class UserServiceImpl implements UserService {
    @Override
    public void save(User user) {
        // 保存用户信息
    }
}

public class UserProxy implements UserService {
    private UserService userService = new UserServiceImpl();

    @Override
    public void save(User user) {
        // 在保存用户信息之前进行一些操作，例如记录日志等
        userService.save(user);
        // 在保存用户信息之后进行一些操作，例如发送消息等
    }
}

在这个示例中，UserProxy类是UserService接口的实现类，它包含一个UserService类型的成员变量userService。在UserProxy类的save方法中，我们可以在调用userService的save方法之前和之后执行其他操作。这样，我们就可以通过UserProxy类来控制对UserServiceImpl对象的访问，从而实现代理模式。

静态代理：

静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来
说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代
码，日志功能还是分散的，没有统一管理。
提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理
类来实现。这就需要使用动态代理技术了

动态代理：

jdk动态代理

JDK动态代理是Java提供的一种动态代理实现方式，它基于接口实现，通过反射机制在运行时生成代理类，实现对接口方法的代理。JDK动态代理的代理对象名称是由Proxy类的静态方法newProxyInstance动态生成的，它的格式是$Proxy+数字，其中的数字是随机生成的，所以其名称是不可预测的。
JDK动态代理需要实现InvocationHandler接口，该接口只有一个方法invoke，该方法会在代理对象调用方法时被调用，从而实现对被代理方法的增强逻辑。
下面是一个简单的JDK动态代理示例，假设有一个UserService接口和一个UserServiceImpl类，我们可以使用JDK动态代理来对UserServiceImpl对象进行代理：

public interface UserService {
    void save(User user);
}

public class UserServiceImpl implements UserService {
    @Override
    public void save(User user) {
        // 保存用户信息
    }
}

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在调用被代理对象的方法之前执行一些操作，例如记录日志等
        Object result = method.invoke(target, args);
        // 在调用被代理对象的方法之后执行一些操作，例如发送消息等
        return result;
    }
}

public class Demo {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        MyInvocationHandler handler = new MyInvocationHandler(userService);
        UserService proxy = (UserService) Proxy.newProxyInstance(
            userService.getClass().getClassLoader(),
            userService.getClass().getInterfaces(),
            handler
        );
        proxy.save(new User());
    }
}

在这个示例中，我们创建了一个MyInvocationHandler类来实现对UserServiceImpl对象的代理。在MyInvocationHandler类中，我们通过反射调用被代理对象的方法，并在调用之前和之后执行一些操作。然后，我们使用Proxy类的静态方法newProxyInstance来创建代理对象，并将其强制转换为UserService类型。最后，我们调用代理对象的save方法来保存用户信息。

AOP介绍：

简单来说就是我们要调用目标对象方法的之前或者之后，我们要进行额外的操作，我们不通过修改目标对象的方法来实现，而是通过其他方法实现这就是AOP要解决的问题。
见尚硅谷笔记

基于注解的AOP：

准备：

配置pom文件依赖：

<!-- 基于Maven依赖传递性，导入spring-context依赖(是IOC的依赖)即可导入当前所需所有jar包    -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.1</version>
</dependency>
<!-- junit测试    -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

配置Spring配置文件：

<!--
 基于注解的AOP的实现：
 1、将目标对象和切面交给IOC容器管理（注解+扫描）
 2、开启AspectJ的自动代理，为目标对象自动生成代理
 3、将切面类通过注解@Aspect标识
 <context:component-scan>标签用于自动扫描指定包及其子包下的类，并将其注册为bean。
     在启用基于注解的AOP时，我们需要使用该标签来扫描所有带有@Aspect注解的类，并将其转换为切面
<aop:aspectj-autoproxy />元素表示开启基于AspectJ注解的AOP自动代理，
让Spring容器能够识别@Aspect注解标注的切面类，并根据切面类中的通知和切入点配置为目标对象生成
代理对象。
    -->
    <context:component-scan base-package="com.example">
    </context:component-scan>
 <aop:aspectj-autoproxy />

package com.example;

public interface Calculator {
int add(int i, int j);
int sub(int i, int j);
int mul(int i, int j);
int div(int i, int j);
}

package com.example;

import org.springframework.stereotype.Component;

@Component
public class CalculatorPureImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部    result = " + result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部    result = " + result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
              System.out.println("方法内部    result = " + result);
       return result;
 }
   
    @Override
   

    public int div(int i, int j) {
       int result = i / j;
       System.out.println("方法内部    result = " + result);
       return result;
 }
}

package com.example;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;
//在切面中需要通过指定的注解，将方法标识为通知方法
// @Aspect表示这个类是一个切面类
@Aspect
// @Component注解保证这个切面类能够放入IOC容器，切面类必须要做IOC容器中 
@Component
public class LogAspect {
    //@Before前置通知，在方法执行之前执行,下面的*表示当前类中的所有方法，..表示任意参数
   @Before("execution(public int  CalculatorPureImpl.* (..))")
   //JoinPoint连接点
               public void beforeMethod(JoinPoint joinPoint){
       //joinPoint.getSignature()获取当前连接点方法的签名信息，getName()获取连接点方法的方法名
       String methodName = joinPoint.getSignature().getName();
       //joinPoint.getArgs()获取连接点方法的参数列表
       String args = Arrays.toString(joinPoint.getArgs());
       System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
                 }
     //@After后置通知，也就是方法返回值返回之后才直接执行。
   @After("execution(*  com.example.CalculatorPureImpl.*(..))")
   public void afterMethod(JoinPoint joinPoint){
       String methodName = joinPoint.getSignature().getName();
       System.out.println("Logger-->后置通知，方法名："+methodName);
 }
    //在返回通知中若要获取目标对象的返回值，只需要通过 @AfterReturning注解的returning属性，
//    returning：参数名称，用于指定返回结果的变量名。在通知方法中，可以使用该变量来访问返回结果。这里的返回结果变量名为result。
//    throwing：参数名称，用于指定抛出的异常变量名。在通知方法中，可以使用该变量来访问抛出的异常。这里的异常变量名为ex。
    @AfterReturning(value = "execution(* com.example.CalculatorPureImpl.*(..))", returning = "result")
               public void afterReturningMethod(JoinPoint joinPoint, Object result){
       String methodName = joinPoint.getSignature().getName();
       System.out.println("Logger-->返回通知，方法名："+methodName+"，结 果："+result);
                 }
//环绕通知（前面几种通知的集合）：ProceedingJoinPoint继承自JoinPoint接口。相对于JoinPoint，
//ProceedingJoinPoint多了一个proceed()方法，用于手动调用目标方法并获取返回值。
//环绕通知必须有返回值，返回值的类型是proceed方法返回的类型

   @Around("execution(*  com.example.CalculatorPureImpl.*(..))")
   public Object aroundMethod(ProceedingJoinPoint joinPoint){
             String methodName = joinPoint.getSignature().getName(); 
       String args = Arrays.toString(joinPoint.getArgs());
       Object result = null; 
       try {

           System.out.println("环绕通知-->目标对象方法执行之前"); 
   //目标对象（连接点）方法的执行，只有下面这条语句执行后才能在目标对象方法中添加额外的操作
           result = joinPoint.proceed();
           System.out.println("环绕通知-->目标对象方法返回值之后"); 
       } catch (Throwable throwable) {//捕获目标对象方法的异常
           throwable.printStackTrace();
           System.out.println("环绕通知-->目标对象方法出现异常时"); 
       } finally {
           System.out.println("环绕通知-->目标对象方法执行完毕"); 
     }
       return result; 
 }
}

@Test
   public void  test()
   {
       ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("aop.annotation.xml");
       //AOP底层是代理模式，这里我们应该获取代理对象的bean,如果获取的是目标对象会报该对象的bean不可用
       //注意这里的代理对象表示LogAspect,代理对象而是AOP底层JDK动态代理生成的，名称是不可预测的
       //但是它却实现了目标对象的接口，可以通过接口声明
        Calculator logAspect= ioc.getBean(Calculator.class);
        logAspect.add(1,1);
   }

切面的优先级：

@Order注解是Spring AOP中用于指定通知顺序的注解。通常情况下，多个切面的通知会按照它们定义的顺序依次执行。但是，如果我们需要显式地指定通知的执行顺序，可以使用@Order注解来实现。
@Order注解可以用于类级别和方法级别，它的值越小，优先级越高

jdbcTemplate:

Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

<dependencies>
   <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包    -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context</artifactId>
       <version>5.3.1</version>
   </dependency>
   <!-- Spring 持久化层支持jar包    -->
   <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个 
jar包    -->
   <!-- 导入    orm 包就可以通过    Maven 的依赖传递性把其他两个也导入    -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-orm</artifactId>
       <version>5.3.1</version>
   </dependency>
   <!-- Spring 测试相关 ,后面在引入junit是为了让junit在Spring测试环境中运行   -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-test</artifactId>
       <version>5.3.1</version>
   </dependency>
   <!-- junit测试    -->
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
   </dependency>
   <!-- MySQL驱动    -->
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>8.0.16</version>
   </dependency>
   <!-- 数据源    -->
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>druid</artifactId>
       <version>1.0.31</version>
   </dependency>
</dependencies

jdbc.username=root
jdbc.password=A86789234
jdbc.url=jdbc:mysql://localhost:3306/myemployees?serverTimezone=UTC
jdbc.driver=com.mysql.cj.jdbc.Driver

 <!-- 导入外部属性文件 classpath:类路径，web资源中要指定，   -->
<context:property-placeholder location="classpath:jdbc.properties" />
<!-- 配置数据源    -->
<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
   <property name="url" value="${jdbc.url}"/>
   <property name="driverClassName" value="${jdbc.driver}"/>
   <property name="username" value="${jdbc.username}"/>
   <property name="password" value="${jdbc.password}"/>
</bean>
<!-- 配置    JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
   <!-- 装配数据源    -->
   <property name="dataSource" ref="druidDataSource"/>
</bean>

//指定当前测试类在Spring的测试环境中执行，此时就可以通过注入的方式直接获取IOC容器的bean
@RunWith(SpringJUnit4ClassRunner.class)
//表示通过类路径的方式配置当前Spring测试环境的配置
@ContextConfiguration("classpath:springJdbc.xml")
public class jdbcTest {
        //使用spring的测试环境进行测试，需要将测试中要使用的对象注入spring容器中，这里采用注解自动装配注入
        @Autowired
        private JdbcTemplate jdbcTemplate;
        @Test
        public  void  testInsert()
        {//没有insert插入，可以通过update实现
            jdbcTemplate.update("insert into t_emp values(5,?,?,?,2)","赵士",29,"女");

        }
}

@Test
//查询一条数据为一个实体类对象 
public void testSelectEmpById(){
   String sql = "select * from t_emp where id = ?";
//BeanPropertyRowMapper将查询结果映射到Emp对象中。
   Emp emp = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<> 
(Emp.class), 1);
   System.out.println(emp);
}

在使用BeanPropertyRowMapper进行映射时，Emp类中的属性需要满足以下要求：

Emp类必须有一个无参构造函数，否则会在映射时抛出InstantiationException异常。

要映射的类必须有一个默认的或无参的构造方法，不能只有带参的构造方法。要映射的类要有公共的setter和getter方法，不能只有其中一个。要映射的类必须是一个顶级类或静态内部类，不能是非静态的内部类。

Emp类中的属性名必须与数据库表中的列名相对应，也可以可以通过使用“驼峰”大小写将用下划线分隔的部分的名称转换为相同的名称来匹配。比如：first_name可以转换为firstName
Emp类中的属性类型必须与数据库表中相应列的数据类型一致或可以自动转换。例如，如果数据库表中某个列的数据类型为VARCHAR，对应的Emp类中的属性类型可以是String或者其他类型，只要可以进行自动转换即可。

声明式事务：

详解 spring 声明式事务(@Transactional)_purple.taro的博客-CSDN博客
所谓声明式事务，就是通过配置的方式，比如通过配置文件（xml）或者注解的方式，告诉spring，哪些方法需要spring帮忙管理事务，然后开发者只用关注业务代码，而事务的事情spring自动帮我们控制。

基于注解的声明式事务：

<dependencies>
   <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包    -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context</artifactId>
       <version>5.3.1</version>
   </dependency>
   <!-- Spring 持久化层支持jar包    -->
   <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个 
jar包    -->
   <!-- 导入    orm 包就可以通过    Maven 的依赖传递性把其他两个也导入    -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-orm</artifactId>
       <version>5.3.1</version>
   </dependency>
   <!-- Spring 测试相关    -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-test</artifactId>
       <version>5.3.1</version></dependency>
   <!-- junit测试    -->
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
   </dependency>
   <!-- MySQL驱动    -->
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>8.0.16</version>
   </dependency>
   <!-- 数据源    -->
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>druid</artifactId>
       <version>1.0.31</version>
   </dependency>
</dependencies>

jdbc.username=root
jdbc.password=A86789234
jdbc.url=jdbc:mysql://localhost:3306/myemployees?serverTimezone=UTC
jdbc.driver=com.mysql.cj.jdbc.Driver

<?xml version="1.0" encoding="UTF-8"?>
<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:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://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/tool http://www.springframework.org/schema/tool/spring-tool.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 导入外部属性文件 classpath:类路径，web资源中要指定，   -->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!-- 配置数据源    -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 配置    JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 装配数据源    -->
        <property name="dataSource" ref="druidDataSource"/>
    </bean>
    <!--这段代码用来告诉Spring框架需要扫描哪个包下的类，并将这些类注册
          为Spring容器中的Bean对象-->
    <context:component-scan base-package="com.example">
    </context:component-scan>
    <!--配置事务管理器 这里的ref是链接数据源的id这里使用的是druidDataSource数据源-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="druidDataSource"></property>
    </bean>
    <!--开启事务注解驱动(annotion选择tx中的）注意此处的tx要导入的命名空间。
    <tx:annotation-driven>：用来开启Spring的声明式事务支持
    transaction-manager：用来指定事务管理器的bean名称。
    transaction-manager后面的值是事务管理器的id，若事务管理器的id为transactionManager
    那么transaction-manager可以省略不写·
    开启后将可以使用@Transaction注解所标识的的方法或类中的所有方法使用事务管理。
    @Transaction加到方法上，该方法就是连接点，加到类上，该类的所有方法都是连接点。
    这样可以对@Transaction注解方法或者类进行事务性管理-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

CREATE TABLE `t_book` (
`book_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键', 
`book_name` varchar(20) DEFAULT NULL COMMENT '图书名称', 
`price` int(11) DEFAULT NULL COMMENT '价格',
`stock` int(10) unsigned DEFAULT NULL COMMENT '库存（无符号）', 
PRIMARY KEY (`book_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
insert  into `t_book`(`book_id`,`book_name`,`price`,`stock`) values (1,'斗破苍 
穹',80,100),(2,'斗罗大陆',50,100);
CREATE TABLE `t_user` (
`user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键', 
`username` varchar(20) DEFAULT NULL COMMENT '用户名',
`balance` int(10) unsigned DEFAULT NULL COMMENT '余额（无符号）', 
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
insert  into `t_user`(`user_id`,`username`,`balance`) values (1,'admin',50);

 @Controller
public class BookController { 
   @Autowired
   private BookService bookService;
   public void buyBook(Integer bookId, Integer userId){ 
       bookService.buyBook(bookId, userId);
 } 
}

1
2
3

public interface BookService {
   void buyBook(Integer bookId, Integer userId); 
}

@Service
public class BookServiceImpl implements BookService { 
   @Autowired
 @Transactional 
   private BookDao bookDao; 
   @Override
   public void buyBook(Integer bookId, Integer userId) { 
       //查询图书的价格
       Integer price = bookDao.getPriceByBookId(bookId); 
       //更新图书的库存
       bookDao.updateStock(bookId); 
       //更新用户的余额
       bookDao.updateBalance(userId, price); 
 }
 }

public interface BookDao {
   Integer getPriceByBookId(Integer bookId); 
   void updateStock(Integer bookId);
   void updateBalance(Integer userId, Integer price); 
}

@Repository
public class BookDaoImpl implements BookDao { 
   @Autowired
   private JdbcTemplate jdbcTemplate; 
   @Override
   public Integer getPriceByBookId(Integer bookId) {
       String sql = "select price from t_book where book_id = ?";
       return jdbcTemplate.queryForObject(sql, Integer.class, bookId); 
 }
   @Override
   public void updateStock(Integer bookId) {
       String sql = "update t_book set stock = stock - 1 where book_id = ?"; 
       jdbcTemplate.update(sql, bookId);
 }
   @Override
   public void updateBalance(Integer userId, Integer price) {
       String sql = "update t_user set balance = balance - ? where user_id = 
?";
       jdbcTemplate.update(sql, price, userId); 
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<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:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://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/tool http://www.springframework.org/schema/tool/spring-tool.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 导入外部属性文件 classpath:类路径，web资源中要指定，   -->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!-- 配置数据源    -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 配置    JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 装配数据源    -->
        <property name="dataSource" ref="druidDataSource"/>
    </bean>
    <!--配置事务管理器-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="druidDataSource"></property>
    </bean>
    <!--开启事务注解驱动(annotion选择tx中的）注意此处的tx要导入的命名空间。-->
    <tx:annotation-driven/>
</beans>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx-annotation.xml") 
public class TxByAnnotationTest {
   @Autowired
   private BookController bookController; 
   @Test
   public void testBuyBook(){
       bookController.buyBook(1, 1); 
 }
}

事务的属性：

readonly
未完待续。。。。

SpringMvc:（只包括相关的知识点，相关程序没有走，只是结合老师给的）

MVC介绍：

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分
M：Model，模型层，指工程中的JavaBean，作用是处理数据
JavaBean分为两类：
一类称为实体类Bean：专门存储业务数据的，如 Student、User 等
一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。
V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器
MVC的工作流程：用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller
调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果
找到相应的View视图，渲染数据后最终响应给浏览器

SpringMVC的特点：

SpringMVC是Spring的一个后续产品，是Spring的一个子项目
SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、
WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了 SpringMVC 作为 Java EE 项目
表述层开发的首选方案。
注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台 servlet
Spring 家族原生产品，与 IOC 容器等基础设施无缝对接基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理。表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案。代码清新简洁，大幅度提升开发效率。内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可。性能卓著，尤其适合现代大型、超大型互联网项目要求。

入门案例：（下面方法由于IDEA是2023的有错误的，后面完全是跟着老师的源码）

项目创建：

（选择Web应用程序）

常见新的mvc工程：项目结构图如下

导入相关依赖：

<dependencies>
   <!-- SpringMVC -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-webmvc</artifactId>
       <version>5.3.1</version>
   </dependency>
   <!-- 日志    -->
   <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>
       <version>1.2.3</version>
   </dependency>
   <!-- ServletAPI -->
   <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>javax.servlet-api</artifactId>
       <version>3.1.0</version>
       <scope>provided</scope>
   </dependency>
   <!-- Spring5和Thymeleaf整合包    -->
   <dependency>
       <groupId>org.thymeleaf</groupId>
       <artifactId>thymeleaf-spring5</artifactId>
       <version>3.0.12.RELEASE</version>
   </dependency>
</dependencies>

注：由于 Maven 的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶端的依赖，其他靠传递性导入。

配置web.xml

注册SpringMVC的前端控制器DispatcherServlet，此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为- servlet.xml，例如，以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC- servlet.xml

<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理    -->
<servlet>
   <servlet-name>springMVC</servlet-name>
   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet- 
class>
</servlet>
<servlet-mapping>
   <servlet-name>springMVC</servlet-name> 
   <!--
       设置springMVC的核心控制器所能处理的请求的请求路径
       /所匹配的请求可以是/login或.html或.js或.css方式的请求路径 
       但是/不能匹配.jsp请求路径的请求
   -->
   <url-pattern>/</url-pattern> 
</servlet-mapping>

扩展配置方式
可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置 SpringMVC前端控制器DispatcherServlet的初始化时间。

<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理    -->
<servlet>
   <servlet-name>springMVC</servlet-name>
   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet- 
class>
   <!-- 通过初始化参数指定SpringMVC配置文件的位置和名称    --> 
   <init-param>
       <!-- contextConfigLocation为固定值    -->
       <param-name>contextConfigLocation</param-name>
       <!-- 使用classpath:表示从类路径查找配置文件，例如maven工程中的 
src/main/resources -->
       <param-value>classpath:springMVC.xml</param-value> 
   </init-param>
   <!--
作为框架的核心组件，在启动过程中有大量的初始化操作要做 
而这些操作放在第一次请求时才执行会严重影响访问速度
因此需要通过此标签将启动控制DispatcherServlet的初始化时间提前到服务器启动时 
-->
   <load-on-startup>1</load-on-startup> 
</servlet>
<servlet-mapping>
   <servlet-name>springMVC</servlet-name> 
   <!--
       设置springMVC的核心控制器所能处理的请求的请求路径
       /所匹配的请求可以是/login或.html或.js或.css方式的请求路径 
       但是/不能匹配.jsp请求路径的请求
   -->
   <url-pattern>/</url-pattern> 
</servlet-mapping>

标签中使用/和/*的区别：/所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请求.因此就可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到相应的页面 /*则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写法

创建请求控制器

由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器.请求控制器中每一个处理请求的方法成为控制器方法,因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识 .为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在.

1
2
3

@Controller
public class HelloController { 
}

创建SpringMVC的配置文件

<!-- 自动扫描包    -->
<context:component-scan base-package="com.atguigu.mvc.controller"/> 
<!-- 配置Thymeleaf视图解析器：实现视图渲染和页面跳转    -->
<bean id="viewResolver"
class="org.thymeleaf.spring5.view.ThymeleafViewResolver"> 
  <!--name属性设置为order，value属性设置为1，
  这将设置Thymeleaf视图解析器的顺序为1。在Spring MVC中，
  有多个视图解析器可用，按顺序运行，
  直到找到能够处理请求的视图解析器为止。-->
   <property name="order" value="1"/>
   <property name="characterEncoding" value="UTF-8"/> 
   <property name="templateEngine">
       <bean class="org.thymeleaf.spring5.SpringTemplateEngine"> 
           <property name="templateResolver">
               <bean
class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                    <!--配置前缀和后缀可以通过路径路径访问-->
                 <!-- 视图前缀    -->
                   <property name="prefix" value="/WEB-INF/templates/"/>
                   <!-- 视图后缀    -->
                   <property name="suffix" value=".html"/>
                   <property name="templateMode" value="HTML5"/>
                   <property name="characterEncoding" value="UTF-8" />
               </bean>
           </property>
       </bean>
   </property>
</bean>
<!--
  处理静态资源，例如html、js、css、jpg
 若只设置该标签，则只能访问静态资源，其他请求则无法访问
  此时必须设置<mvc:annotation-driven/>解决问题 
-->
<mvc:default-servlet-handler/>
<!-- 开启mvc注解驱动    -->
<mvc:annotation-driven>
   <mvc:message-converters>
       <!-- 处理响应中文内容乱码    --> 
       <bean
class="org.springframework.http.converter.StringHttpMessageConverter">
           <property name="defaultCharset" value="UTF-8" />
           <property name="supportedMediaTypes">
               <list>
                   <value>text/html</value>
                   <value>application/json</value>
               </list>
           </property>
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

测试HelloWorld

首先配置tomcat服务器
实现对首页的访问,在请求控制器中创建处理请求的方法

// @RequestMapping注解：处理请求和控制器方法之间的映射关系
// @RequestMapping注解的value属性可以通过请求地址匹配请求，/表示的当前工程的上下文路径 
// localhost:8080/springMVC/
@RequestMapping("/") 
public String index() { 
   //设置视图名称
   return "index"; 
}

②通过超链接跳转到指定页面
在主页index.html中设置超链接

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
   <meta charset="UTF-8">
   <title>首页</title>
</head>
<body>
   <h1>首页</h1>
   <a th:href="@{/hello}">HelloWorld</a><br/>
</body>
</html>

在请求控制器中创建处理请求的方法

@RequestMapping("/hello") 
public String HelloWorld() { 
   return "target";
}

@RequestMapping注解

位置：

1、@RequestMapping注解标识的位置
* @RequestMapping标识一个类：设置映射请求的请求路径的初始信息
* @RequestMapping标识一个方法：设置映射请求请求路径的具体信息
* 2、@RequestMapping注解value属性
* 作用：通过请求的请求路径匹配请求
* value属性是数组类型，即当前浏览器所发送请求的请求路径匹配value属性中的任何一个值
* 则当前请求就会被注解所标识的方法进行处理
* 3、@RequestMapping注解的method属性
* 作用：通过请求的请求方式匹配请求
* method属性是RequestMethod类型的数组，即当前浏览器所发送请求的请求方式匹配method属性中的任何一中请求方式
* 则当前请求就会被注解所标识的方法进行处理
* 若浏览器所发送的请求的请求路径和@RequestMapping注解value属性匹配，但是请求方式不匹配
* 此时页面报错：405 - Request method 'xxx' not supported
* 在@RequestMapping的基础上，结合请求方式的一些派生注解：
* @GetMapping,@PostMapping,@DeleteMapping,@PutMapping
* 4、@RequestMapping注解的params属性
* 作用：通过请求的请求参数匹配请求，即浏览器发送的请求的请求参数必须满足params属性的设置
* params可以使用四种表达式：
* "param"：表示当前所匹配请求的请求参数中必须携带param参数
* "!param"：表示当前所匹配请求的请求参数中一定不能携带param参数
* "param=value"：表示当前所匹配请求的请求参数中必须携带param参数且值必须为value
* "param!=value"：表示当前所匹配请求的请求参数中可以不携带param，若携带值一定不能是value
* 若浏览器所发送的请求的请求路径和@RequestMapping注解value属性匹配，但是请求参数不匹配
* 此时页面报错：400 - Parameter conditions "username" not met for actual request parameters:
* 5、@RequestMapping注解的headers属性
* 作用：通过请求的请求头信息匹配请求，即浏览器发送的请求的请求头信息必须满足headers属性的设置
* 若浏览器所发送的请求的请求路径和@RequestMapping注解value属性匹配，但是请求头信息不匹配
* 此时页面报错：404
* 6、SpringMVC支持ant风格的路径
* 在@RequestMapping注解的value属性值中设置一些特殊字符
* ?:任意的单个字符（不包括?）
* *:任意个数的任意字符（不包括?和/）
* **:任意层数的任意目录，注意使用方式只能**写在双斜线中，前后不能有任何的其他字符
* 7、@RequestMapping注解使用路径中的占位符
* 传统：/deleteUser?id=1
* rest：/user/delete/1
* 需要在@RequestMapping注解的value属性中所设置的路径中，使用{xxx}的方式表示路径中的数据
* 在通过@PathVariable注解，将占位符所标识的值和控制器方法的形参进行绑定
* 获取请求参数的方式：
* 1、通过servletAPI获取
* 只需要在控制器方法的形参位置设置HttpServletRequest类型的形参
* 就可以在控制器方法中使用request对象获取请求参数
* 2、通过控制器方法的形参获取
* 只需要在控制器方法的形参位置，设置一个形参，形参的名字和请求参数的名字一致即可
* 3、@RequestParam：将请求参数和控制器方法的形参绑定
* @RequestParam注解的三个属性：value、required、defaultValue
* value:设置和形参绑定的请求参数的名字
* required:设置是否必须传输value所对应的请求参数
* 默认值为true，表示value所对应的请求参数必须传输，否则页面报错：
* 400 - Required String parameter 'xxx' is not present
* 若设置为false，则表示value所对应的请求参数不是必须传输，若为传输，则形参值为null
* defaultValue:设置当没有传输value所对应的请求参数时，为形参设置的默认值，此时和required属性值无关
* 4、@RequestHeader：将请求头信息和控制器方法的形参绑定
* 5、@CookieValue：将cookie数据和控制器方法的形参绑定
* 6、通过控制器方法的实体类类型的形参获取请求参数
* 需要在控制器方法的形参位置设置实体类类型的形参，要保证实体类中的属性的属性名和请求参数的名字一致
* 可以通过实体类类型的形参获取请求参数
* 7、解决获取请求此参数的乱码问题
* 在web.xml中配置Spring的编码过滤器CharacterEncodingFilter
* 向域对象共享数据：
* 1、通过ModelAndView向请求域共享数据
* 使用ModelAndView时，可以使用其Model功能向请求域共享数据
* 使用View功能设置逻辑视图，但是控制器方法一定要将ModelAndView作为方法的返回值
* 2、使用Model向请求域共享数据
* 3、使用ModelMap向请求域共享数据
* 4、使用map向请求域共享数据
* 5、Model和ModelMap和map的关系
* 其实在底层中，这些类型的形参最终都是通过BindingAwareModelMap创建
* public class BindingAwareModelMap extends ExtendedModelMap {}
* public class ExtendedModelMap extends ModelMap implements Model {}
* public class ModelMap extends LinkedHashMap<String, Object> {}

表单提交和axios是post请求，超链接和地址栏输出的都是get请求。
请求头和响应头不区分的键不区分大小写，但是值区分。HTTP Cookie - HTTP | MDN
【Web】Servlet三大作用域、JSP四大作用域 - Nemo& - 博客园
 form表单中的enctype=“multipart/form-data“什么意思?_夜阑卧听风吹雨，铁马冰河入梦来的博客-CSDN博客