<!-- pom.xml中添加测试依赖 -->
<dependencies>
    <!-- Spring Boot 测试核心依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope> <!-- 仅测试环境生效 -->
    </dependency>
    <!-- 若需测试 Web 接口，需引入 Web 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

@Service
public class HelloService {
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

import static org.assertj.core.api.Assertions.assertThat;
// 启动 Spring Boot 上下文，加载容器
@SpringBootTest
public class HelloServiceTest {

    // 注入待测试的 Service
    @Autowired
    private HelloService helloService;

    // 测试方法
    @Test
    public void testSayHello() {
        // 执行方法
        String result = helloService.sayHello("Spring Boot");
        // 断言结果是否符合预期
        assertThat(result).isEqualTo("Hello, Spring Boot!");
    }
}

// src/main/java/com/example/demo/controller/HelloController.java
package com.example.demo.controller;

@RestController
public class HelloController {

    @Autowired
    private HelloService helloService;

    @GetMapping("/hello/{name}")
    public String hello(@PathVariable String name) {
        return helloService.sayHello(name);
    }
}

// src/test/java/com/example/demo/controller/HelloControllerTest.java
package com.example.demo.controller;
// webEnvironment = RANDOM_PORT：启动随机端口，避免端口冲突
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class HelloControllerTest {

    @Autowired
    private TestRestTemplate restTemplate; // Spring提供的RestTemplate测试工具

    @Test
    public void testHelloApi() {
        // 调用接口
        String result = restTemplate.getForObject("/hello/Test", String.class);
        // 断言结果
        assertThat(result).isEqualTo("Hello, Test!");
    }
}

<!-- Spring Boot 官方父工程：简化依赖版本管理，无需手动指定大部分依赖版本 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.3.12</version>
    <relativePath/> <!-- 从 Maven 仓库查找父工程，不依赖本地路径 -->
</parent>

<dependencies>
    <!-- MySQL驱动：实现 Java 程序与 MySQL 数据库的通信 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope> <!-- 仅运行时生效，编译阶段无需 -->
    </dependency>
    <!-- MyBatis 整合 Spring Boot 启动器：自动配置 SqlSessionFactory、Mapper 扫描等核心组件 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>3.0.4</version>
    </dependency>
    <!-- Spring Boot 测试依赖：用于编写单元测试验证 MyBatis 功能 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope> <!-- 仅测试环境生效 -->
    </dependency>
</dependencies>

# MySQL连接核心配置
# 1. 数据库登录账号（替换为你的MySQL用户名）
spring.datasource.username=atguigu
# 2. 数据库登录密码（替换为你的MySQL密码）
spring.datasource.password=atguigu
# 3. 数据库连接URL：IP+端口+数据库名，附加编码、时区等参数避免乱码/时区错误
spring.datasource.url=jdbc:mysql://192.168.100.100/db_demo_crud?characterEncoding=utf8mb4&useSSL=false&serverTimezone=Asia/Shanghai
# 4. MySQL驱动类（8.x版本必须用com.mysql.cj.jdbc.Driver，5.x用com.mysql.jdbc.Driver）
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

-- 1. 创建数据库（指定UTF8MB4编码，避免中文乱码）
CREATE DATABASE db_demo_crud CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE db_demo_crud;

-- 2. 创建t_tiger表（老虎信息表，主键自增）
CREATE TABLE t_tiger(
    tiger_id INT AUTO_INCREMENT PRIMARY KEY, -- 老虎ID（主键）
    tiger_name CHAR(100) NOT NULL,          -- 老虎名称（非空）
    tiger_age INT,                          -- 老虎年龄
    tiger_salary DOUBLE                     -- 模拟薪资（测试用）
);

-- 3. 插入测试数据
INSERT INTO t_tiger (tiger_name, tiger_age, tiger_salary)
VALUES ('王虎', 5, 500.00),
       ('李虎', 3, 800.50),
       ('张虎', 7, 200.75),
       ('赵虎', 4, 200.25),
       ('刘虎', 6, 900.00);

import lombok.Data;

/**
 * 老虎实体类：对应数据库t_tiger表
 * @Data：Lombok注解，自动生成getter、setter、toString、equals/hashCode等方法
 * 核心规则：数据库下划线命名（tiger_id）→ Java驼峰命名（tigerId），MyBatis默认支持该映射
 */
@Data
public class Tiger {
    private Integer tigerId;    // 对应tiger_id（主键）
    private String tigerName;   // 对应tiger_name
    private Integer tigerAge;   // 对应tiger_age
    private Double tigerSalary; // 对应tiger_salary
}

import com.atguigu.mybatis.entity.Tiger;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * Tiger数据访问接口（DAO层）
 * @Mapper：标识为 MyBatis 的 Mapper 接口，Spring Boot 自动创建代理实现类
 */
@Mapper
public interface TigerMapper {
    /**
     * 新增老虎信息
     * @param tiger 新增的老虎对象（包含name/age/salary，无需传id，数据库自增）
     * @return 受影响的行数（新增成功返回1，失败返回0）
     */
    int insertTiger(Tiger tiger);
    /**
     * 根据ID删除老虎信息
     * @param tigerId 老虎ID
     * @return 受影响的行数（删除成功返回1）
     */
    int deleteTigerById(Integer tigerId);
    /**
     * 根据ID更新老虎信息
     * @param tiger 要更新的老虎对象（必须包含tigerId，以及要修改的属性值）
     * @return 受影响的行数（更新成功返回1）
     */
    int updateTigerById(Tiger tiger);
    /**
     * 根据ID查询老虎详情
     * @param tigerId 老虎ID
     * @return 对应的老虎对象（无数据返回null）
     */
    Tiger selectTigerById(Integer tigerId);
    /**
     * 查询所有老虎信息
     * @return 老虎列表（无数据返回空列表，不会返回null）
     */
    List<Tiger> selectTigerList();
}

<?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">
<!-- namespace：绑定对应的Mapper接口全类名，实现接口与XML的关联 -->
<mapper namespace="com.atguigu.mybatis.mapper.TigerMapper">

    <!-- 1. 新增老虎：id=接口方法名，parameterType=参数类型（实体类全类名） -->
    <insert id="insertTiger" parameterType="com.atguigu.mybatis.entity.Tiger">
        INSERT INTO t_tiger (tiger_name, tiger_age, tiger_salary)
        VALUES (#{tigerName}, #{tigerAge}, #{tigerSalary})
    </insert>

    <!-- 2. 根据ID删除老虎：#{tigerId}为参数占位符，防止SQL注入 -->
    <delete id="deleteTigerById" parameterType="java.lang.Integer">
        DELETE FROM t_tiger WHERE tiger_id = #{tigerId}
    </delete>

    <!-- 3. 根据ID更新老虎：动态取值实体类的属性 -->
    <update id="updateTigerById" parameterType="com.atguigu.mybatis.entity.Tiger">
        UPDATE t_tiger
        SET tiger_name = #{tigerName},
            tiger_age = #{tigerAge},
            tiger_salary = #{tigerSalary}
        WHERE tiger_id = #{tigerId}
    </update>

    <!-- 4. 根据ID查询老虎：resultType=返回值类型（实体类全类名） -->
    <select id="selectTigerById" parameterType="java.lang.Integer" resultType="com.atguigu.mybatis.entity.Tiger">
        SELECT tiger_id tigerId,
               tiger_name tigerName,
               tiger_age tigerAge,
               tiger_salary tigerSalary
        FROM t_tiger
        WHERE tiger_id = #{tigerId}
    </select>

    <!-- 5. 查询所有老虎：resultType指定每行数据映射的实体类 -->
    <select id="selectTigerList" resultType="com.atguigu.mybatis.entity.Tiger">
        SELECT tiger_id tigerId,
               tiger_name tigerName,
               tiger_age tigerAge,
               tiger_salary tigerSalary
        FROM t_tiger
    </select>
</mapper>

# MyBatis配置：指定Mapper XML文件的存储路径
mybatis.mapper-locations=classpath:/mapper/*Mapper.xml
# 可选优化：开启驼峰命名自动映射（tiger_id → tigerId），可省略SQL中的AS别名
mybatis.configuration.map-underscore-to-camel-case=true

/**
 * MyBatis单元测试类
 * @SpringBootTest：启动 Spring 容器，自动扫描并注入 TigerMapper 代理对象
 */
@SpringBootTest
public class MyBatisTest {

    // 注入 TigerMapper（Spring Boot 自动创建的 MyBatis 代理对象）
    @Resource
    private TigerMapper tigerMapper;

    /**
     * 测试查询所有老虎信息
     */
    @Test
    public void testSelectTigerList() {
        // 调用Mapper方法执行SQL，查询所有老虎
        List<Tiger> tigerList = tigerMapper.selectTigerList();
        // 遍历输出结果
        for (Tiger tiger : tigerList) {
            System.out.println("老虎信息：" + tiger);
        }
    }
    /**
     * 可选：测试新增老虎（验证insert方法）
     */
    @Test
    public void testInsertTiger() {
        Tiger tiger = new Tiger();
        tiger.setTigerName("陈虎");
        tiger.setTigerAge(8);
        tiger.setTigerSalary(1000.0);
        // 调用新增方法，返回受影响行数
        int rows = tigerMapper.insertTiger(tiger);
        System.out.println("新增老虎受影响行数：" + rows); // 新增成功返回1
    }
}

老虎信息：Tiger(tigerId=1, tigerName=王虎, tigerAge=5, tigerSalary=500.0)
老虎信息：Tiger(tigerId=2, tigerName=李虎, tigerAge=3, tigerSalary=800.5)
老虎信息：Tiger(tigerId=3, tigerName=张虎, tigerAge=7, tigerSalary=200.75)
老虎信息：Tiger(tigerId=4, tigerName=赵虎, tigerAge=4, tigerSalary=200.25)
老虎信息：Tiger(tigerId=5, tigerName=刘虎, tigerAge=6, tigerSalary=900.0)

logging.level.com.atguigu.mybatis.mapper=debug

-- 创建t_emp表
CREATE TABLE t_emp(
    emp_id INT AUTO_INCREMENT PRIMARY KEY, 
    emp_name CHAR(100) NOT NULL,
    emp_salary DOUBLE 
);

-- 插入测试数据
INSERT INTO t_emp (emp_name,  emp_salary)
VALUES ('张三',500.00),
       ('李四', 800.50),
       ('王五', 200.75);

@Data
public class Employee {
    private Long empId;
    private String empName;
    private Double empSalary;
}

@Mapper
public interface EmployeeMapper {

}

<?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 namespace="com.atguigu.mybatisproject.mapper.TigerMapper">
</mapper>

Employee selectEmployee(Integer empId);

<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
    select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{empId}
</select>

int insertEmployee(Employee employee);

<insert id="insertEmployee">
    insert into t_emp(emp_name,emp_salary) values(#{empName},#{empSalary})
</insert>

int updateEmployee(@Param("empId") Integer empId,@Param("empSalary") Double empSalary);

<update id="updateEmployee">
    update t_emp set emp_salary=#{empSalary} where emp_id=#{empId}
</update>

int updateEmployeeByMap(Map<String, Object> paramMap);

<update id="updateEmployeeByMap">
   update t_emp set emp_salary=#{empSalaryKey} where emp_id=#{empIdKey}
</update>

@Test
public void testUpdateEmpNameByMap() {
    
    Map<String, Object> paramMap = new HashMap<>();
    
    paramMap.put("empSalaryKey", 999.99);
    paramMap.put("empIdKey", 5);
    
    int result = mapper.updateEmployeeByMap(paramMap);
    
    System.out.println("result = " + result);
}

int selectEmpCount();

<select id="selectEmpCount" resultType="int">
    select count(*) from t_emp
</select>

@Test
public void testEmpCount() {
    int count = employeeMapper.selectEmpCount();
    System.out.println("count = " + count);
}

Employee selectEmployee(Integer empId);

<!-- 编写具体的SQL语句，使用id属性唯一的标记一条SQL语句 -->
<!-- resultType属性：指定封装查询结果的Java实体类的全类名 -->
<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
    <!-- MyBatis 负责把 SQL 语句中的 #{} 部分替换成“?”占位符 -->
    <!-- 给每一个字段设置一个别名，让别名和Java实体类中属性名一致 -->
    select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{empId}
</select>

Map<String,Object> selectEmpNameAndMaxSalary();

<!-- Map<String,Object> selectEmpNameAndMaxSalary(); -->
<!-- 返回工资最高的员工的姓名和他的工资 -->
<select id="selectEmpNameAndMaxSalary" resultType="map">
        SELECT
            emp_name 员工姓名,
            emp_salary 员工工资
        FROM t_emp WHERE emp_salary=(SELECT MAX(emp_salary) FROM t_emp)
</select>

@Test
public void testQueryEmpNameAndSalary() {
    Map<String, Object> resultMap = employeeMapper.selectEmpNameAndMaxSalary();

    Set<Map.Entry<String, Object>> entrySet = resultMap.entrySet();

    for (Map.Entry<String, Object> entry : entrySet) {
        String key = entry.getKey();
        Object value = entry.getValue();
        System.out.println(key + "=" + value);
    }
}

List<Employee> selectAll();

<select id="selectAll" resultType="com.atguigu.mybatis.entity.Employee">
    select emp_id empId,emp_name empName,emp_salary empSalary
    from t_emp
</select>

@Test
public void testSelectAll() {
    List<Employee> employeeList = employeeMapper.selectAll();
    for (Employee employee : employeeList) {
        System.out.println("employee = " + employee);
    }
}

int insertEmployee(Employee employee);

<!-- useGeneratedKeys属性字面意思就是“使用生成的主键” -->
<!-- keyProperty属性可以指定主键在实体类对象中对应的属性名，MyBatis 会将拿到的主键值存入这个属性 -->
<insert id="insertEmployee" useGeneratedKeys="true" keyProperty="empId">
    insert into t_emp(emp_name,emp_salary)
    values(#{empName},#{empSalary})
</insert>

@Test
public void testSaveEmp() {
    Employee employee = new Employee(); 
    employee.setEmpName("john");
    employee.setEmpSalary(666.66);
    employeeMapper.insertEmployee(employee);
    System.out.println("employee.getEmpId() = " + employee.getEmpId());
}

<insert id="insertEmployee" 
		parameterType="com.atguigu.mybatis.beans.Employee"  
			databaseId="oracle">
		<selectKey order="BEFORE" keyProperty="id" resultType="integer">
			select employee_seq.nextval from dual 
		</selectKey>
		insert into orcl_employee(id,last_name,email,gender) values(#{id},#{lastName},#{email},#{gender})
</insert>

<insert id="insertEmployee" 
		parameterType="com.atguigu.mybatis.beans.Employee"  
			databaseId="oracle">
		<selectKey order="AFTER" keyProperty="id" resultType="integer">
			select employee_seq.currval from dual 
		</selectKey>	
	insert into orcl_employee(id,last_name,email,gender) values(employee_seq.nextval,#{lastName},#{email},#{gender})
</insert>

<!-- 编写具体的SQL语句，使用id属性唯一的标记一条SQL语句 -->
<!-- resultType属性：指定封装查询结果的Java实体类的全类名 -->
<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
    <!-- MyBatis 负责把 SQL 语句中的 #{} 部分替换成“?”占位符 -->
    <!-- 给每一个字段设置一个别名，让别名和Java实体类中属性名一致 -->
    select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{empId}
</select>

mybatis.configuration.map-underscore-to-camel-case=true

<!-- Employee selectEmployee(Integer empId); -->
<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
    select emp_id,emp_name,emp_salary from t_emp where emp_id=#{empId}
</select>

<!-- 专门声明一个resultMap设定column到property之间的对应关系 -->
<resultMap id="selectEmployeeByRMResultMap" type="com.atguigu.mybatis.entity.Employee">
    
    <!-- 使用id标签设置主键列和主键属性之间的对应关系 -->
    <!-- column属性用于指定字段名；property属性用于指定Java实体类属性名 -->
    <id column="emp_id" property="empId"/>
    
    <!-- 使用result标签设置普通字段和Java实体类属性之间的关系 -->
    <result column="emp_name" property="empName"/>
    <result column="emp_salary" property="empSalary"/>
</resultMap>
    
<!-- Employee selectEmployeeByRM(Integer empId); -->
<select id="selectEmployeeByRM" resultMap="selectEmployeeByRMResultMap">
    select emp_id,emp_name,emp_salary from t_emp where emp_id=#{empId}
</select>

<!-- List<Tiger> selectTigerByCondition(Tiger tiger); -->
<select id="selectTigerByCondition" resultType="com.atguigu.mybatis.entity.Tiger">
    select tiger_id,tiger_name,tiger_salary from t_tiger
    
    <!-- where标签会自动去掉“标签体内前面多余的and/or” -->
    <where>
        <!-- 使用if标签，让我们可以有选择的加入SQL语句的片段。这个SQL语句片段是否要加入整个SQL语句，就看if标签判断的结果是否为true -->
        <!-- 在if标签的test属性中，可以访问实体类的属性，不可以访问数据库表的字段 -->
        <if test="tigerName != null">
            <!-- 在if标签内部，需要访问接口的参数时还是正常写#{} -->
            or tiger_name=#{tigerName}
        </if>
        <if test="tigerSalary &gt; 500">
            or tiger_salary>#{tigerSalary}
        </if>
        <!--
         第一种情况：所有条件都满足 WHERE tiger_name=? or tiger_salary>?
         第二种情况：部分条件满足 WHERE tiger_salary>?
         第三种情况：所有条件都不满足 没有where子句
         -->
    </where>
</select>

<!-- void updateTigerDynamic(Tiger tiger) -->
<update id="updateTigerDynamic">
    update t_tiger
    <!-- set tiger_name=#{tigerName},tiger_salary=#{tigerSalary} -->
    <!-- 使用set标签动态管理set子句，并且动态去掉两端多余的逗号 -->
    <set>
        <if test="tigerName != null">
            tiger_name=#{tigerName},
        </if>
        <if test="tigerSalary &lt; 800">
            tiger_salary=#{tigerSalary},
        </if>
    </set>
    where tiger_id=#{tigerId}
    <!--
         第一种情况：所有条件都满足 SET tiger_name=?, tiger_salary=?
         第二种情况：部分条件满足 SET tiger_salary=?
         第三种情况：所有条件都不满足 update t_tiger where tiger_id=?
            没有set子句的update语句会导致SQL语法错误
     -->
</update>

<!-- List<Tiger> selectTigerByConditionByTrim(Tiger tiger) -->
<select id="selectTigerByConditionByTrim" resultType="com.atguigu.mybatis.entity.Tiger">
    select tiger_id,tiger_name,tiger_age,tiger_salary
    from t_tiger
    
    <!-- prefix属性指定要动态添加的前缀 -->
    <!-- suffix属性指定要动态添加的后缀 -->
    <!-- prefixOverrides属性指定要动态去掉的前缀，使用“|”分隔有可能的多个值 -->
    <!-- suffixOverrides属性指定要动态去掉的后缀，使用“|”分隔有可能的多个值 -->
    <!-- 当前例子用where标签实现更简洁，但是trim标签更灵活，可以用在任何有需要的地方 -->
    <trim prefix="where" suffixOverrides="and|or">
        <if test="tigerName != null">
            tiger_name=#{tigerName} and
        </if>
        <if test="tigerSalary &gt; 300">
            tiger_salary>#{tigerSalary} and
        </if>
        <if test="tigerAge &lt;= 5">
            tiger_age=#{tigerAge} or
        </if>
        <if test="tigerName=='王虎'">
            tiger_name=#{tigerName}
        </if>
    </trim>
</select>

<!-- List<Tiger> selectTigerByConditionByChoose(Tiger tiger) -->
<select id="selectTigerByConditionByChoose" resultType="com.atguigu.mybatis.entity.Tiger">
    select tiger_id,tiger_name,tiger_salary from t_tiger
    where
    <choose>
        <when test="tigerName != null">tiger_name=#{tigerName}</when>
        <when test="tigerSalary &lt; 800">tiger_salary &lt; 800</when>
        <otherwise>1=1</otherwise>
    </choose>
    
    <!--
     第一种情况：第一个when满足条件 where tiger_name=?
     第二种情况：第二个when满足条件 where tiger_salary < 800
     第三种情况：两个when都不满足 where 1=1 执行了otherwise
     -->
</select>

<!--
    collection属性：要遍历的集合
    item属性：遍历集合的过程中能得到每一个具体对象，在item属性中设置一个名字，将来通过这个名字引用遍历出来的对象
    separator属性：指定当foreach标签的标签体重复拼接字符串时，各个标签体字符串之间的分隔符
    open属性：整个循环把字符串拼好后，字符串整体的前面要添加的字符串
    close属性：整个循环把字符串拼好后，字符串整体的后面要添加的字符串
    index属性：这里起一个名字，便于后面引用
        遍历List集合，这里能够得到List集合的索引值
        遍历Map集合，这里能够得到Map集合的key
 -->
<foreach collection="tigerList" item="tiger" separator="," open="values" index="myIndex">
    <!-- 在foreach标签内部如果需要引用遍历得到的具体的一个对象，需要使用item属性声明的名称 -->
    (#{tiger.tigerName},#{myIndex},#{tiger.tigerSalary})
</foreach>

spring.datasource.url=jdbc:mysql://192.168.198.100:3306/mybatis-example?allowMultiQueries=true

<!-- int updateTigerBatch(@Param("tigerList") List<Tiger> tigerList) -->
<update id="updateTigerBatch">
    <foreach collection="tigerList" item="tiger" separator=";">
        update t_tiger set tiger_name=#{tiger.tigerName} where tiger_id=#{tiger.tigerId}
    </foreach>
</update>

Parameter 'tigerList' not found. Available parameters are [arg0, collection, list]

<!-- 使用sql标签抽取重复出现的SQL片段 -->
<sql id="mySelectSql">
    select tiger_id,tiger_name,tiger_age,tiger_salary from t_tiger
</sql>

<!-- 使用include标签引用声明的SQL片段 -->
<include refid="mySelectSql"/>

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
<!-- Mybatis与SpringBoot集成 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.4</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

# 数据库连接配置
spring.datasource.url=jdbc:mysql://localhost:3306/你的数据库名?useUnicode=true&characterEncoding=utf8mb4&useSSL=false&serverTimezone=Asia/Shanghai
# 你的数据库用户名
spring.datasource.username=root
# 你的数据库密码
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# MyBatis配置
# 驼峰命名转换（role_id → roleId）
mybatis.configuration.map-underscore-to-camel-case=true
# 实体类所在包（替换为你的实际包名）
mybatis.type-aliases-package=com.example.demo.entity
# 指定Mapper XML文件位置
mybatis.mapper-locations=classpath:mapper/*.xml

/**
 * 用户DAO接口（XML版）
 * 配合 SysUserMapper.xml 实现SQL逻辑
 */
public interface SysUserMapper {
    /**
     * 根据ID删除用户
     */
    boolean deleteById(Long id);
    /**
     * 根据ID更新用户（动态更新非空字段）
     */
    boolean updateById(@Param("id") Long id, @Param("sysUser") SysUser sysUser);
    /**
     * 新增用户（返回受影响行数）
     */
    int insert(SysUser sysUser);

    /**
     * 兼容原逻辑：插入成功返回实体，失败返回null
     */
    default SysUser save(SysUser sysUser) {
        int rows = this.insert(sysUser);
        return rows > 0 ? sysUser : null;
    }

    /**
     * 根据ID查询用户
     */
    SysUser getById(Long id);

    /**
     * 条件查询用户列表
     */
    List<SysUser> list(@Param("username") String username, @Param("phone") String phone, @Param("status") Integer status);

    /**
     * 登录校验（密码不加密，直接匹配）
     */
    boolean login(@Param("username") String username, @Param("password") String password);
}

<?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">

<!-- namespace 必须对应 SysUserMapper 接口的全类名 -->
<mapper namespace="此处自己填写">

    <!-- 通用结果集映射（复用查询字段） -->
    <resultMap id="SysUserResultMap" type="SysUser">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="phone" property="phone"/>
        <result column="avatar" property="avatar"/>
        <result column="status" property="status"/>
        <result column="role_id" property="roleId"/>
        <result column="create_time" property="createTime"/>
        <result column="update_time" property="updateTime"/>
    </resultMap>

    <!-- 1. 根据ID删除用户 -->
    <delete id="deleteById">
        DELETE FROM sys_user WHERE id = #{id}
    </delete>

    <!-- 2. 根据ID更新用户（动态更新非空字段） -->
    <update id="updateById">
        UPDATE sys_user
        <set>
            <if test="sysUser.username != null and sysUser.username != ''">
                username = #{sysUser.username},
            </if>
            <if test="sysUser.password != null and sysUser.password != ''">
                password = #{sysUser.password},
            </if>
            <if test="sysUser.phone != null and sysUser.phone != ''">
                phone = #{sysUser.phone},
            </if>
            <if test="sysUser.avatar != null and sysUser.avatar != ''">
                avatar = #{sysUser.avatar},
            </if>
            <if test="sysUser.status != null">
                status = #{sysUser.status},
            </if>
            <if test="sysUser.roleId != null">
                role_id = #{sysUser.roleId},
            </if>
            update_time = NOW()
        </set>
        WHERE id = #{id}
    </update>

    <!-- 3. 新增用户（返回自增ID） -->
    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO sys_user (
            username, password, phone, avatar, status, role_id, create_time, update_time
        ) VALUES (
            #{username}, #{password}, #{phone}, #{avatar}, #{status}, #{roleId}, NOW(), NOW()
        )
    </insert>

    <!-- 4. 根据ID查询用户 -->
    <select id="getById" resultMap="SysUserResultMap">
        SELECT id, username, password, phone, avatar, status, role_id, create_time, update_time
        FROM sys_user
        WHERE id = #{id}
    </select>

    <!-- 5. 条件查询用户列表 -->
    <select id="list" resultMap="SysUserResultMap">
        SELECT id, username, password, phone, avatar, status, role_id, create_time, update_time
        FROM sys_user
       <where>
            <if test="username != null and username != ''">
                AND username LIKE CONCAT('%', #{username}, '%')
            </if>
            <if test="phone != null and phone != ''">
                AND phone = #{phone}
            </if>
            <if test="status != null">
                AND status = #{status}
            </if>
        </where>   
    </select>

    <!-- 6. 登录校验（密码不加密，直接匹配） -->
    <select id="login" resultType="boolean">
        SELECT COUNT(*) > 0
        FROM sys_user
        WHERE username = #{username}
          AND password = #{password}
    </select>

</mapper>

@SpringBootApplication
@MapperScan("mapper包地址！") //替代的每个Mapper添加 @Mapper注解
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private SysUserMapper userMapper;

    // 新增用户
    public SysUser addUser(SysUser user) {
        return userMapper.save(user);
    }
    // 根据ID删除用户
    public boolean removeUser(Long id) {
        return userMapper.deleteById(id);
    }
    // 根据ID更新用户
    public boolean editUser(Long id, SysUser user) {
        return userMapper.updateById(id, user);
    }
    // 根据ID查询用户
    public SysUser getUserById(Long id) {
        return userMapper.getById(id);
    }
    // 条件查询用户列表
    public List<SysUser> listUsers(String username, String phone, Integer status) {
        return userMapper.list(username, phone, status);
    }
    // 登录校验
    public boolean login(String username, String password) {
        return userMapper.login(username, password);
    }
}

CREATE TABLE `t_customer` (
	 `customer_id` INT NOT NULL AUTO_INCREMENT, 
	 `customer_name` CHAR(100), 
	 PRIMARY KEY (`customer_id`) 
);
CREATE TABLE `t_order` ( 
	`order_id` INT NOT NULL AUTO_INCREMENT, 
	`order_name` CHAR(100), 
	`customer_id` INT, 
	PRIMARY KEY (`order_id`) 
); 
INSERT INTO `t_customer` (`customer_name`) VALUES ('c01');
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o1', '1'); 
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o2', '1'); 
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o3', '1'); 

@Data
public class Customer {    
    private Integer customerId;
    private String customerName;
    private List<Order> orderList;// 体现的是对多的关系
}

@Data
public class Order {    
    private Integer orderId;
    private String orderName;
    private Customer customer;// 体现的是对一的关系
}

public interface OrderMapper {    
    Order selectOrderWithCustomer(Integer orderId);
}

<!-- 创建resultMap实现“对一”关联关系映射 -->
<!-- id属性：通常设置为这个resultMap所服务的那条SQL语句的id加上“ResultMap” -->
<!-- type属性：要设置为这个resultMap所服务的那条SQL语句最终要返回的类型 -->
<resultMap id="selectOrderWithCustomerResultMap" type="com.atguigu.mybatis.entity.Order">

    <!-- 先设置Order自身属性和字段的对应关系 -->
    <id column="order_id" property="orderId"/>
    <result column="order_name" property="orderName"/>

    <!-- 使用association标签配置“对一”关联关系 -->
    <!-- property属性：在Order类中对一的一端进行引用时使用的属性名 -->
    <!-- javaType属性：一的一端类的全类名 -->
    <association property="customer" javaType="com.atguigu.mybatis.entity.Customer">
        <!-- 配置Customer类的属性和字段名之间的对应关系 -->
        <id column="customer_id" property="customerId"/>
        <result column="customer_name" property="customerName"/>
    </association>

</resultMap>

<!-- Order selectOrderWithCustomer(Integer orderId); -->
<select id="selectOrderWithCustomer" resultMap="selectOrderWithCustomerResultMap">
    SELECT order_id,order_name,c.customer_id,customer_name
    FROM t_order o
    LEFT JOIN t_customer c
    ON o.customer_id=c.customer_id
    WHERE o.order_id=#{orderId}
</select>

@Test
public void testRelationshipToOne() {
    // 查询Order对象，检查是否同时查询了关联的Customer对象
    Order order = orderMapper.selectOrderWithCustomer(2);
    System.out.println("order = " + order);
}

public interface CustomerMapper {   
    Customer selectCustomerWithOrderList(Integer customerId);
}

<!-- 配置resultMap实现从Customer到OrderList的“对多”关联关系 -->
<resultMap id="selectCustomerWithOrderListResultMap"
           type="com.atguigu.mybatis.entity.Customer">
    
    <!-- 映射Customer本身的属性 -->
    <id column="customer_id" property="customerId"/>
    <result column="customer_name" property="customerName"/>
    
    <!-- collection标签：映射“对多”的关联关系 -->
    <!-- property属性：在Customer类中，关联“多”的一端的属性名 -->
    <!-- ofType属性：集合属性中元素的类型 -->
    <collection property="orderList" ofType="com.atguigu.mybatis.entity.Order">
        <!-- 映射Order的属性 -->
        <id column="order_id" property="orderId"/>
        <result column="order_name" property="orderName"/>    
    </collection>
    
</resultMap>
    
<!-- Customer selectCustomerWithOrderList(Integer customerId); -->
<select id="selectCustomerWithOrderList" resultMap="selectCustomerWithOrderListResultMap">
    SELECT c.customer_id,c.customer_name,o.order_id,o.order_name
    FROM t_customer c
    LEFT JOIN t_order o
    ON c.customer_id=o.customer_id
    WHERE c.customer_id=#{customerId}
</select>

@Test
public void testRelationshipToMulti() {    
    // 查询Customer对象同时将关联的Order集合查询出来
    Customer customer = customerMapper.selectCustomerWithOrderList(1);
    
    System.out.println("customer.getCustomerId() = " + customer.getCustomerId());
    System.out.println("customer.getCustomerName() = " + customer.getCustomerName());
    
    List<Order> orderList = customer.getOrderList();
    for (Order order : orderList) {
        System.out.println("order = " + order);
    }
}

<!--Customer selectCustomerWithLazyOrderList(Integer customerId);-->
<!-- 专门指定一条SQL语句，用来查询Customer，而且是仅仅查询Customer本身，不携带Order关联 -->
<select id="selectCustomerWithLazyOrderList" resultMap="selectCustomerWithLazyOrderListResultMap">
    select customer_id,customer_name from t_customer
    where customer_id=#{customerId}
</select>

<!--List<Order> selectOrderListByCustomerId(Integer customerId);-->
<select id="selectOrderListByCustomerId" resultType="com.atguigu.mybatis.entity.Order">
    select order_id,order_name from t_order where customer_id=#{customerId}
</select>

<!-- orderList集合属性的映射关系，使用分步查询 -->
<!-- 在collection标签中使用select属性指定要引用的SQL语句 -->
<!-- select属性值的格式是：Mapper配置文件的名称空间.SQL语句id -->
<!-- column属性：指定Customer和Order之间建立关联关系时所依赖的字段 -->
<collection
    property="orderList"
    select="com.atguigu.mybatis.mapper.CustomerMapper.selectOrderListByCustomerId"
    column="customer_id"/>

DEBUG 11-30 11:10:05,796 ==>  Preparing: select customer_id,customer_name from t_customer where customer_id=?   (BaseJdbcLogger.java:145) 
DEBUG 11-30 11:10:05,866 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 11-30 11:10:05,889 ====>  Preparing: select order_id,order_name from t_order where customer_id=?   (BaseJdbcLogger.java:145) 
DEBUG 11-30 11:10:05,890 ====> Parameters: 1(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 11-30 11:10:05,895 <====      Total: 3  (BaseJdbcLogger.java:145) 
DEBUG 11-30 11:10:05,896 <==      Total: 1  (BaseJdbcLogger.java:145) 
customer = c01
order = Order{orderId=1, orderName='o1'}
order = Order{orderId=2, orderName='o2'}
order = Order{orderId=3, orderName='o3'}

<!-- 使用 settings 对 MyBatis 全局进行设置 -->
<settings>
    <!-- 开启延迟加载功能：需要配置两个配置项 -->
    <!-- 1、将lazyLoadingEnabled设置为true，开启懒加载功能 -->
    <setting name="lazyLoadingEnabled" value="true"/>

    <!-- 2、将aggressiveLazyLoading设置为false，关闭“积极的懒加载” -->
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

<!-- MyBatis 全局配置 -->
<settings>
    <!-- 开启延迟加载功能 -->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

mybatis.configuration.lazy-loading-enabled=true

@Test
public void testSelectCustomerWithLazyOrderListResultMap() throws Exception{
    Customer customer = customerMapper.selectCustomerWithLazyOrderList(1);
    System.out.println("customer.getCustomerName() = " + customer.getCustomerName());

    // 先指定具体的时间单位，然后再让线程睡一会儿
    TimeUnit.SECONDS.sleep(5);

    List<Order> orderList = customer.getOrderList();
    for (Order order : orderList) {
        System.out.println("order = " + order);
    }
}

DEBUG .a.m.m.C.selectCustomerWithLazyOrderList : ==>  Preparing: select customer_id,customer_name from t_customer where customer_id = ?
DEBUG .a.m.m.C.selectCustomerWithLazyOrderList : ==> Parameters: 1(Integer)
DEBUG .a.m.m.C.selectCustomerWithLazyOrderList : <==      Total: 1
customer.getCustomerName() = c01
DEBUG c.a.m.m.O.selectOrderListByCustomerId    : ==>  Preparing: select order_id, order_name from t_order where customer_id = ?
DEBUG c.a.m.m.O.selectOrderListByCustomerId    : ==> Parameters: 1(Integer)
DEBUG c.a.m.m.O.selectOrderListByCustomerId    : <==      Total: 3
order = Order(orderId=1, orderName=o1, customer=null)
order = Order(orderId=2, orderName=o2, customer=null)
order = Order(orderId=3, orderName=o3, customer=null)

# 1. 驼峰命名映射（核心必配）
mybatis.configuration.map-underscore-to-camel-case=true
# 2. 自动映射规则（支持嵌套映射）
mybatis.configuration.auto-mapping-behavior=FULL
# 3. 控制台打印SQL（调试用）
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
# 4. 延迟加载（性能优化）
mybatis.configuration.lazy-loading-enabled=true
#mybatis.configuration.aggressive-lazy-loading=false
# 5. SQL执行超时时间（30秒）
mybatis.configuration.default-statement-timeout=30

# 之前已配置的基础参数
spring.datasource.url=jdbc:mysql://localhost:3306/你的数据库名?useUnicode=true&characterEncoding=utf8mb4&useSSL=false&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
mybatis.type-aliases-package=com.example.demo.entity
mybatis.mapper-locations=classpath:mapper/*.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.atguigu</groupId>
    <artifactId>hello-mp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>hello-mp</name>
    <description>hello-mp</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
    url: jdbc:mysql://192.168.10.101:3306/hello_mp?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2b8

@Data
@TableName("t_tiger") // 核心修改：指定数据库表名为t_tiger
public class Tiger {

    // 核心修改：主键字段匹配t_tiger表的tiger_id，类型为Integer（表是INT类型）
    @TableId(value = "tiger_id", type = IdType.AUTO)
    private Integer tigerId;

    // 核心修改：匹配表的tiger_name字段
    @TableField("tiger_name")
    private String tigerName;

    // 核心修改：匹配表的tiger_age字段
    @TableField("tiger_age")
    private Integer tigerAge;

    // 核心修改：匹配表的tiger_salary字段（DOUBLE类型）
    @TableField("tiger_salary")
    private Double tigerSalary;
}

// 核心修改：泛型替换为Tiger，对应新实体类
// @Mapper 
public interface TigerMapper extends BaseMapper<Tiger> {
}

@SpringBootApplication
// 注意：若Mapper放在com.atguigu.hellomp.mapper下，路径无需改；若改名需同步调整
@MapperScan("com.atguigu.hellomp.mapper") 
public class HelloMpApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloMpApplication.class, args);
    }
}

@SpringBootTest
class TigerMapperTest {

    // 核心修改：注入TigerMapper
    @Autowired
    private TigerMapper tigerMapper;

    // 测试查询所有老虎数据
    @Test
    public void testSelectList() {
        List<Tiger> tigers = tigerMapper.selectList(null);
        tigers.forEach(System.out::println);
    }

    // 测试根据ID查询老虎
    @Test
    public void testSelectById() {
        // 核心修改：ID类型为Integer（匹配表的INT类型），测试数据用1（对应插入的第一条数据）
        Tiger tiger = tigerMapper.selectById(1);
        System.out.println(tiger);
    }

    // 测试新增老虎数据
    @Test
    public void testInsert() {
        Tiger tiger = new Tiger();
        tiger.setTigerName("钱虎"); // 匹配表的tiger_name字段
        tiger.setTigerAge(8);       // 匹配表的tiger_age字段
        tiger.setTigerSalary(600.00); // 匹配表的tiger_salary字段
        tigerMapper.insert(tiger);
    }

    // 测试根据ID更新老虎数据
    @Test
    public void testUpdateById() {
        Tiger tiger = tigerMapper.selectById(1);
        tiger.setTigerName("王虎-更新"); // 修改名称
        tigerMapper.updateById(tiger);
    }

    // 测试根据ID删除老虎数据
    @Test
    public void testDeleteById() {
        // 注意：测试删除后可重新插入数据，避免影响其他测试
        tigerMapper.deleteById(1);
    }
}

// 显式指定表名为t_tiger（核心：解决实体类名Tiger与表名t_tiger的匹配）
@TableName(value = "t_tiger") 
public class Tiger {
    // ... 字段
}

@TableName("t_tiger")
public class Tiger {
    // 核心：绑定主键字段tiger_id，指定自增策略（匹配表的AUTO_INCREMENT）
    @TableId(value = "tiger_id", type = IdType.AUTO)
    private Integer tigerId; 
    // ... 其他字段
}

@TableName("t_tiger")
public class Tiger {
    @TableId(value = "tiger_id", type = IdType.AUTO)
    private Integer tigerId;

    // 绑定普通字段tiger_name（属性名tigerName与字段名匹配，value可省略）
    @TableField("tiger_name") 
    private String tigerName;

    // 简写：属性名tigerAge对应字段tiger_age，省略value
    @TableField
    private Integer tigerAge;

    // 示例：查询时忽略该字段（select=false）
    @TableField(value = "tiger_salary", select = false)
    private Double tigerSalary;
    
    // 示例：仅实体类属性，无对应数据库字段（exist=false）
    @TableField(exist = false)
    private String tempRemark;
}

// 继承BaseMapper并指定泛型为Tiger，自动获得t_tiger表的通用CRUD方法
public interface TigerMapper extends BaseMapper<Tiger> {
    // 无需编写基础CRUD方法，MyBatis-Plus自动生成实现
    // 复杂业务SQL可在此自定义（如多表联查）
}

public interface TigerService extends IService<Tiger> {
    // 可自定义复杂业务方法（如按薪资区间查询老虎）
}

@Service
public class TigerServiceImpl extends ServiceImpl<TigerMapper, Tiger> implements TigerService {
    // 通用CRUD方法无需实现，继承即可使用
}

// 注入Mapper（实际开发建议在Service层使用）
@Autowired
private TigerMapper tigerMapper;

// 1. 方式1：直接new实例（官方基础写法）
QueryWrapper<Tiger> queryWrapper = new QueryWrapper<>();
// 链式拼接条件：tiger_age = 5 AND tiger_name LIKE '%虎%' AND tiger_salary BETWEEN 200 AND 900
// 注：字段名需与数据库表（t_tiger）完全一致
queryWrapper.eq("tiger_age", 5)        // 等值条件：=
            .like("tiger_name", "虎")  // 模糊查询：LIKE '%虎%'
            .between("tiger_salary", 200, 900) // 范围查询：BETWEEN
            .orderByDesc("tiger_age"); // 排序：ORDER BY tiger_age DESC

// 2. 方式2：Wrappers工具类（官方推荐快捷方式，简化泛型声明）
QueryWrapper<Tiger> queryWrapper2 = Wrappers.query();
queryWrapper2.ne("tiger_age", 3)       // 不等值：!=
            .isNotNull("tiger_salary") // 非空：IS NOT NULL
            .in("tiger_id", 1, 2, 3);  // IN条件：IN (1,2,3)

// 3. 配合Mapper/Service执行查询（官方标准调用方式）
List<Tiger> tigerList = tigerMapper.selectList(queryWrapper);

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.example.demo.entity.Tiger;
import com.example.demo.mapper.TigerMapper;
import org.springframework.beans.factory.annotation.Autowired;

@Autowired
private TigerMapper tigerMapper;

// 1. 方式1：直接new实例（演示null值更新，官方核心特性）
UpdateWrapper<Tiger> updateWrapper = new UpdateWrapper<>();
// 拼接更新逻辑：SET tiger_salary = null, tiger_name = '更新虎' WHERE tiger_id = 1
updateWrapper.set("tiger_salary", null) // 支持将字段设为null（实体更新无法实现）
             .set("tiger_name", "更新虎") // 设置普通字段值
             .eq("tiger_id", 1);         // 更新条件

// 2. 方式2：Wrappers工具类（官方推荐）
UpdateWrapper<Tiger> updateWrapper2 = Wrappers.update();
// 拼接更新逻辑：SET tiger_age = 8 WHERE tiger_name LIKE '王%'
updateWrapper2.set("tiger_age", 8)
              .likeRight("tiger_name", "王"); // 左模糊：LIKE '王%'

// 3. 配合Mapper执行更新（官方标准：第一个参数传null，全量通过Wrapper控制）
int affectedRows = tigerMapper.update(null, updateWrapper);

@Autowired
private TigerMapper tigerMapper;

// 1. 方式1：直接new实例（类型安全，无硬编码）
LambdaQueryWrapper<Tiger> lambdaQueryWrapper = new LambdaQueryWrapper<>();
// 拼接条件：tiger_age = 5 AND tiger_name LIKE '%虎%'（引用实体属性，IDE自动补全）
lambdaQueryWrapper.eq(Tiger::getTigerAge, 5)
                  .like(Tiger::getTigerName, "虎")
                  .gt(Tiger::getTigerSalary, 500);

// 2. 方式2：Wrappers工具类（官方推荐，简化代码）
LambdaQueryWrapper<Tiger> lambdaQueryWrapper2 = Wrappers.lambdaQuery();
lambdaQueryWrapper2.ne(Tiger::getTigerAge, 3)
                  .isNotNull(Tiger::getTigerSalary)
                  .orderByDesc(Tiger::getTigerAge);

// 3. 执行查询（与普通Wrapper调用方式一致）
List<Tiger> tigerList = tigerMapper.selectList(lambdaQueryWrapper);

@Autowired
private TigerMapper tigerMapper;

// 1. 方式1：直接new实例（无硬编码字段名）
LambdaUpdateWrapper<Tiger> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
// 拼接更新逻辑：SET tiger_name = 'Lambda虎', tiger_salary = 600 WHERE tiger_id = 1
lambdaUpdateWrapper.set(Tiger::getTigerName, "Lambda虎")
                   .set(Tiger::getTigerSalary, 600.00)
                   .eq(Tiger::getTigerId, 1);

// 2. 方式2：Wrappers工具类（官方推荐）
LambdaUpdateWrapper<Tiger> lambdaUpdateWrapper2 = Wrappers.lambdaUpdate();
// 拼接更新逻辑：SET tiger_age = tiger_age + 1 WHERE tiger_name = '李虎'
lambdaUpdateWrapper2.setSql("tiger_age = tiger_age + 1") // 支持原生SQL片段
                   .eq(Tiger::getTigerName, "李虎");

// 3. 执行更新
int affectedRows = tigerMapper.update(null, lambdaUpdateWrapper);

// 动态参数（可能为null）
String tigerName = "虎"; 
Integer minSalary = 300;

LambdaQueryWrapper<Tiger> wrapper = Wrappers.lambdaQuery();
// 仅当tigerName非null时，拼接“tiger_name LIKE '%虎%'”
wrapper.like(tigerName != null, Tiger::getTigerName, tigerName);
// 仅当minSalary非null时，拼接“tiger_salary > 300”
wrapper.gt(minSalary != null, Tiger::getTigerSalary, minSalary);

// 正确：(tiger_age > 3 AND tiger_salary > 500) OR tiger_name = '王虎'
LambdaQueryWrapper<Tiger> wrapper = Wrappers.lambdaQuery();
wrapper.nested(w -> w.gt(Tiger::getTigerAge, 3).gt(Tiger::getTigerSalary, 500))
       .or()
       .eq(Tiger::getTigerName, "王虎");

-- 给t_tiger表添加逻辑删除字段：deleted，默认值0（未删除）
ALTER TABLE t_tiger ADD deleted INT DEFAULT 0 ;  
-- 说明：1=逻辑删除，0=未逻辑删除（MyBatis-Plus默认规则）

@Data
@TableName("t_tiger") // 对应t_tiger表
public class Tiger {

    // 主键：tiger_id（自增）
    @TableId(value = "tiger_id", type = IdType.AUTO)
    private Integer tigerId;

    // 老虎名称
    @TableField("tiger_name")
    private String tigerName;

    // 老虎年龄
    @TableField("tiger_age")
    private Integer tigerAge;

    // 老虎薪资
    @TableField("tiger_salary")
    private Double tigerSalary;

    // 核心：逻辑删除字段（适配t_tiger表的deleted字段）
    @TableLogic
    private Integer deleted;
}

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted # 逻辑删除字段的实体类属性名（此处为deleted）
      logic-delete-value: 1       # 逻辑已删除值（默认为1，对应t_tiger表的deleted=1）
      logic-not-delete-value: 0   # 逻辑未删除值（默认为0，对应t_tiger表的deleted=0）

@SpringBootTest
class TigerMapperTest {

    @Autowired
    private TigerMapper tigerMapper;

    // 逻辑删除：删除tiger_id=5的老虎数据
    @Test
    public void testLogicDelete() {
        // 调用deleteById，实际执行UPDATE语句
        tigerMapper.deleteById(5);
    }
}

JDBC Connection [com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@5871a482] will not be managed by Spring
==>  Preparing: UPDATE t_tiger SET deleted=1 WHERE tiger_id=? AND deleted=0 
==>  Parameters: 5(Integer) 
<==    Updates: 1

@Test
public void testSelectNotDeleted() {
    // 传null表示无额外条件，仅查询未逻辑删除的数据
    tigerMapper.selectList(null);
}

==>  Preparing: SELECT tiger_id,tiger_name,tiger_age,tiger_salary,deleted FROM t_tiger WHERE deleted=0 
==>  Parameters: 
<==      Total: 4

<!-- MySQL驱动 -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

<!-- MyBatis-Plus核心依赖（替代原生MyBatis） -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version>
</dependency>

<!-- Spring Boot 测试依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

<!-- Lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

# 数据库连接配置（不变）
spring.datasource.url=jdbc:mysql://localhost:3306/你的数据库名?useUnicode=true&characterEncoding=utf8mb4&useSSL=false&serverTimezone=Asia/Shanghai
# 你的数据库用户名
spring.datasource.username=root
# 你的数据库密码
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# MyBatis-Plus核心配置（替代原MyBatis配置）
# 驼峰命名转换（默认开启，可省略）
mybatis-plus.configuration.map-underscore-to-camel-case=true
# 实体类所在包
mybatis-plus.type-aliases-package=com.example.demo.entity
# 无需配置mapper-locations，因为MP通用CRUD无需XML

/**
 * 用户Mapper接口（MyBatis-Plus版）
 * 继承BaseMapper<SysUser>，自动获得MP封装的通用CRUD方法
 */
public interface SysUserMapper extends BaseMapper<SysUser> {
}

/**
 * 定义所有业务方法，后续AOP可直接切入这些方法
 */
public interface UserService extends IService<SysUser> {
    // 登录校验（AOP可切入此方法做日志/权限校验）
    boolean login(String username, String password);

    // 根据ID删除用户（AOP可切入此方法做操作日志）
    boolean removeUserById(Long id);

    // 根据ID更新用户（AOP可切入此方法做数据校验/事务）
    Boolean updateUserById(Long id, SysUser sysUser);

    // 新增用户（AOP可切入此方法做数据脱敏/事务）
    SysUser saveUser(SysUser user);

    // 根据ID查询用户（AOP可切入此方法做数据权限）
    SysUser getUserById(Long id);

    // 条件查询用户列表（AOP可切入此方法做分页/数据过滤）
    List<SysUser> getUserList(String username, String phone, Integer status);
}

/**
 * 业务逻辑全部在此实现，后续AOP切面直接增强此类的方法
 */
@Service
public class UserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements UserService {
    @Autowired
	SysUserMapper sysUserMapper;
    
    // 登录校验：核心业务逻辑（AOP可切入）
    @Override
    public boolean login(String username, String password) {
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysUser::getUsername, username)
               .eq(SysUser::getPassword, password);
        return sysUserMapper.exists(wrapper);
    }

    // 根据ID删除：核心业务逻辑（AOP可切入）
    @Override
    public boolean removeUserById(Long id) {
        return this.removeById(id);
    }

    // 根据ID更新：核心业务逻辑（AOP可切入）
    @Override
    public Boolean updateUserById(Long id, SysUser sysUser) {
        sysUser.setId(id);
        return this.updateById(sysUser);
    }

    // 新增用户：核心业务逻辑（AOP可切入）
    @Override
    public SysUser saveUser(SysUser user) {
        boolean success = this.save(user);
        return success ? user : null;
    }

    // 根据ID查询：核心业务逻辑（AOP可切入）
    @Override
    public SysUser getUserById(Long id) {
        return this.getById(id);
    }

    // 条件查询：核心业务逻辑（AOP可切入）
    @Override
    public List<SysUser> getUserList(String username, String phone, Integer status) {
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(StringUtils.isNotBlank(username), SysUser::getUsername, username)
               .eq(StringUtils.isNotBlank(phone), SysUser::getPhone, phone)
               .eq(status != null, SysUser::getStatus, status);
        return this.list(wrapper);
    }
}

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.demo.mapper") // 替换为你的SysUserMapper所在包
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

@RestController
@RequestMapping("auth")
public class LoginController {

    @Autowired
    private UserService userService; // 注入Service，仅调用方法

    @PostMapping("login")
    public Result login(HttpSession session, @Valid @RequestBody SysUserLoginDto user, BindingResult bindingResult) {
        // 1. 仅做参数格式校验（表现层职责）
        if (bindingResult.hasErrors()) {
            return Result.fail(500, "账号和密码不符合规则,登录失败！");
        }

        // 2. 调用Service业务方法（无任何业务逻辑，仅转发）
        boolean logined = userService.login(user.getUsername(), user.getPassword());

        // 3. 仅做响应处理（表现层职责）
        if (!logined) {
            return Result.fail("账号或者密码错误！");
        }
        session.setAttribute("username", user.getUsername());
        return Result.success("登录成功！");
    }

    @GetMapping("logout")
    public Result logout(HttpSession session) {
        // 仅做Session操作（表现层职责）
        session.removeAttribute("username");
        session.invalidate();
        return Result.success("退出登录成功！");
    }
}

@RequestMapping("user")
@RestController
public class UserController {

    @Autowired
    private UserService userService; // 注入Service，仅调用方法

    // 删除用户：仅调用Service.removeUserById
    @DeleteMapping("{id}")
    public Result removeUser(HttpSession session, @PathVariable Long id) {
        boolean deleted = userService.removeUserById(id); // 调用Service
        if (deleted) {
            return Result.success("删除ID为" + id + "的用户成功！");
        } else {
            return Result.fail("删除失败：ID为" + id + "的用户不存在！");
        }
    }

    // 更新用户：仅调用Service.updateUserById
    @PutMapping("{id}")
    public Result updateUser(
            HttpSession session,
            @PathVariable Long id,
            @Valid @RequestBody SysUser sysUser,
            BindingResult bindingResult){

        // 仅做参数校验（表现层职责）
        if (bindingResult.hasErrors()) {
            String errorMsg = bindingResult.getFieldErrors().stream()
                    .map(error -> error.getField() + "：" + error.getDefaultMessage())
                    .collect(Collectors.joining("；"));
            return Result.fail(500, "参数校验失败：" + errorMsg);
        }

        // 调用Service业务方法
        Boolean updatedUser = userService.updateUserById(id, sysUser);

        // 仅做响应处理
        if (updatedUser){
            return Result.success("更新ID为" + id + "的用户成功！");
        }
        return Result.fail("更新失败：ID为" + id + "的用户不存在！");
    }

    // 新增用户：仅调用Service.saveUser
    @PostMapping
    public Result saveUser(
            HttpSession session,
            @Valid @RequestBody SysUser user,
            BindingResult bindingResult
    ) {
        // 仅做参数校验（表现层职责）
        if (bindingResult.hasErrors()) {
            String errorMsg = bindingResult.getFieldErrors().stream()
                    .map(error -> error.getField() + "：" + error.getDefaultMessage())
                    .collect(Collectors.joining("；"));
            return Result.fail(500, "参数校验失败：" + errorMsg);
        }

        // 调用Service业务方法
        SysUser savedUser = userService.saveUser(user);

        // 仅做响应处理
        return Result.success("新增用户成功！", savedUser);
    }

    // 查询单用户：仅调用Service.getUserById
    @GetMapping("{id}")
    public Result findById(HttpSession session, @PathVariable Long id) {
        SysUser sysUser = userService.getUserById(id); // 调用Service
        System.out.println("查询到的用户：" + sysUser);
        if (sysUser == null) {
            return Result.fail("查询失败：ID为" + id + "的用户不存在！");
        }
        return Result.success("查询成功！", sysUser);
    }

    // 条件查询：仅调用Service.getUserList
    @GetMapping("/list")
    public Result getUserList(
            HttpSession session,
            @RequestParam(required = false) String username,
            @RequestParam(required = false) String phone,
            @RequestParam(required = false) Integer status) {

        // 调用Service业务方法
        List<SysUser> sysUserList = userService.getUserList(username, phone, status);

        // 仅做响应处理
        return Result.success("查询成功！共找到" + sysUserList.size() + "条数据", sysUserList);
    }
}

/**
 * 配置类：集中管理第三方类的Bean创建逻辑
 * @Configuration：标识为Spring配置类，替代XML配置文件
 * 核心：配置类本身会被纳入IoC容器，内部@Bean方法的返回值也会成为IoC容器中的Bean
 */
@Configuration
public class Demo15Config {
}

<!-- Druid连接池：第三方数据源，替代Spring默认的HikariCP -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.21</version>
</dependency>

<!-- Apache DBUtils：简化JDBC操作，提供QueryRunner工具类 -->
<dependency>
    <groupId>commons-dbutils</groupId>
    <artifactId>commons-dbutils</artifactId>
    <version>1.8.0</version>
</dependency>

<!-- MySQL驱动：实现Java与MySQL的通信 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.30</version>
    <scope>runtime</scope>
</dependency>

# 数据库连接参数（自定义前缀atguigu，避免与Spring内置属性冲突）
atguigu.username=atguigu
atguigu.password=atguigu
atguigu.url=jdbc:mysql://192.168.47.100/delivery_system?characterEncoding=utf8mb4&serverTimezone=Asia/Shanghai
atguigu.driver=com.mysql.cj.jdbc.Driver

@Configuration // 声明为Spring配置类
@PropertySource("classpath:config/jdbc.properties") // 加载外部配置文件（classpath=resources目录）
public class Demo15Config {

    // @Value：从配置文件中读取指定key的值，注入到当前属性
    @Value("${atguigu.username}")
    private String userName; // 数据库账号

    @Value("${atguigu.password}")
    private String password; // 数据库密码

    @Value("${atguigu.url}")
    private String url; // 数据库连接URL

    @Value("${atguigu.driver}")
    private String driverClassName; // MySQL驱动类名
    
}

@Configuration
@PropertySource("classpath:config/jdbc.properties")
public class Demo15Config {

    // 省略配置参数注入的属性...

    /**
     * 创建Druid数据源Bean，纳入IoC容器管理
     * @Bean("myDruidDataSource")：自定义Bean的ID为myDruidDataSource（默认是方法名getDruidDataSource）
     * @Scope("prototype")：设置为多实例（默认单例，开发中极少用多实例）
     * @return DruidDataSource对象（IoC容器会缓存该对象）
     */
    @Bean("myDruidDataSource")
    // @Scope("prototype") // 如需多实例则打开注释，默认单例无需配置
    public DataSource getDruidDataSource() {
        // 手动创建Druid数据源对象（第三方类，无法加@Component注解）
        DruidDataSource druidDataSource = new DruidDataSource();
        // 设置数据库连接参数（从配置文件注入的属性）
        druidDataSource.setUsername(userName);
        druidDataSource.setPassword(password);
        druidDataSource.setUrl(url);
        druidDataSource.setDriverClassName(driverClassName);
        // 返回对象：Spring会自动将该对象存入IoC容器
        return druidDataSource;
    }
}

/**
 * 创建QueryRunnerBean，依赖IoC容器中的DataSource
 * 核心：方法参数为DataSource时，Spring自动注入IoC容器中对应的Bean（按类型匹配）
 */
@Bean // 默认Bean ID为getQueryRunner
public QueryRunner getQueryRunner(DataSource dataSource) {
    // 传入IoC容器中的Druid数据源创建QueryRunner
    return new QueryRunner(dataSource);
}

@Bean
public QueryRunner getQueryRunner() {
    // 调用getDruidDataSource()：实际返回IoC容器中的Druid数据源，而非新创建
    DataSource dataSource = getDruidDataSource();
    return new QueryRunner(dataSource);
}

public class Demo15Test {
    public static void main(String[] args) throws Exception {
        // 1. 创建Spring IoC容器，加载配置类（替代XML配置）
        AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext(Demo15Config.class);

        // 2. 从IoC容器获取QueryRunner Bean（按ID/类型获取）
        // 方式1：按Bean ID获取（ID为方法名getQueryRunner）
        QueryRunner queryRunner = ioc.getBean("getQueryRunner", QueryRunner.class);
        
        // 方式2：按类型获取（容器中只有1个QueryRunner Bean时可用）
        // QueryRunner queryRunner = ioc.getBean(QueryRunner.class);

        // 3. 调用QueryRunner操作数据库（插入数据）
        String sql = """
                INSERT INTO sys_user(username, `password`, nickname)
                VALUES("good333", "123456", "feifei");
                """;
        int affectedRows = queryRunner.update(sql); // 执行插入，返回受影响行数
        System.out.println("插入数据成功，受影响行数：" + affectedRows); // 成功返回1

        // 4. 关闭IoC容器（可选，测试用）
        ioc.close();
    }
}

插入数据成功，受影响行数：1

// 推荐方式：直接加@Service，Spring自动扫描创建Bean
@Service
public class UserService {
    // ...
}

// 不推荐：配置类中用@Bean创建（多此一举）
@Configuration
public class Demo15Config {
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

@Configuration
public class MPConfiguration {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 核心：添加分页插件，指定数据库类型为MySQL（适配t_tiger表）
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

// 查询t_tiger表：第2页，每页3条数据
IPage<Tiger> page = new Page<>(2, 3);

@SpringBootTest
public class PageTest {

    @Autowired
    private TigerService tigerService; // 注入通用Service

    @Autowired
    private TigerMapper tigerMapper;   // 注入通用Mapper

    // 1. 通用Service无条件分页查询t_tiger表
    @Test
    public void testPageService() {
        // 构造分页对象：第2页，每页3条
        Page<Tiger> page = new Page<>(2, 3);
        // 执行分页查询
        Page<Tiger> tigerPage = tigerService.page(page);
        
        // 打印分页结果
        System.out.println("总记录数：" + tigerPage.getTotal());
        System.out.println("总页数：" + tigerPage.getPages());
        System.out.println("当前页数据：");
        tigerPage.getRecords().forEach(System.out::println);
    }

    // 2. 通用Mapper条件分页查询t_tiger表（薪资>200的老虎）
    @Test
    public void testPageMapper() {
        // 构造分页对象：第1页，每页2条
        IPage<Tiger> page = new Page<>(1, 2);
        // 构造查询条件：tiger_salary > 200
        QueryWrapper<Tiger> wrapper = new QueryWrapper<>();
        wrapper.gt("tiger_salary", 200);
        
        // 执行条件分页查询
        IPage<Tiger> tigerPage = tigerMapper.selectPage(page, wrapper);
        
        // 打印结果
        System.out.println("符合条件的总记录数：" + tigerPage.getTotal());
        System.out.println("当前页数据：");
        tigerPage.getRecords().forEach(System.out::println);
    }

    // 3. 自定义SQL分页查询t_tiger表
    @Test
    public void testCustomMapper() {
        // 构造分页对象：第1页，每页4条
        IPage<Tiger> page = new Page<>(1, 4);
        // 执行自定义SQL分页
        IPage<Tiger> tigerPage = tigerMapper.selectTigerPage(page);
        
        // 打印结果
        System.out.println("总记录数：" + tigerPage.getTotal());
        System.out.println("当前页数据：");
        tigerPage.getRecords().forEach(System.out::println);
    }
}

package com.atguigu.hellomp.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.atguigu.hellomp.entity.Tiger;

public interface TigerMapper extends BaseMapper<Tiger> {
    // 自定义t_tiger表分页查询方法
    IPage<Tiger> selectTigerPage(IPage<?> page);
}

<?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">
<!-- namespace需与Mapper接口全类名一致 -->
<mapper namespace="com.atguigu.hellomp.mapper.TigerMapper">
    <!-- 自定义分页查询：只需写基础查询逻辑，分页由插件自动处理 -->
    <select id="selectTigerPage" resultType="com.atguigu.hellomp.entity.Tiger">
        select tiger_id, tiger_name, tiger_age, tiger_salary 
        from t_tiger
    </select>
</mapper>

mybatis-plus:
  # 自定义Mapper.xml扫描路径（适配t_tiger表的TigerMapper.xml）
  mapper-locations: classpath*:/mapper/**/*.xml
  # 可选：配置实体类别名包，简化XML中的resultType
  type-aliases-package: com.atguigu.hellomp.entity