Spring 配置文件与 MyBatis 核心用法

注：Spring Boot 同时支持两种格式，混合使用时若 key 重复，Properties 优先级高于 YAML。

1.5 @Value 注解

作用：是 Spring 框架提供了一个 @Value 注解 (org.springframework.beans.factory.annotation.Value)，用于将外部配置文件中的值注入到 Spring 管理的 Bean 中。

示例：(Properties 和 YAML 的读取方式相同)

package org.example.configuration.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Config {
    @Value("${spring.application.name}")
    private String applicationName;

    @Value("${server.port}")
    private Integer port;

    @Value("${spring.datasource.url}")
    private String url;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    public void print() {
        System.out.println("applicationName=" + applicationName);
        System.out.println("port=" + port);
        System.out.println("url=" + url);
        System.out.println("username=" + username);
        System.out.println("password=" + password);
    }
}

package org.example.configuration;

import org.example.configuration.config.Config;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class ConfigurationApplication {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(ConfigurationApplication.class, args);
        Config config = context.getBean(Config.class);
        config.print();
    }
}

运行结果：

applicationName=configuration
port=8080
url=jdbc:mysql://127.0.0.1:3306/database_name?characterEncoding=utf8&useSSL=false
username=root
password=root

2. MyBatis

2.1 概述

MyBatis 是一款优秀的持久层框架，支持自定义 SQL、存储过程、高级映射以及多种配置方式。它消除了几乎所有的 JDBC 代码和参数的手动设置以及结果集的检索。

• 支持存储过程：指的是数据库管理系统 (DBMS) 允许用户创建、存储和执行存储过程的能力。存储过程是一组预编译的 SQL 语句，存储在数据库中，可以被应用程序调用执行。
• 支持高级映射：指通过配置或注解实现复杂 SQL 查询结果与 Java 对象之间的灵活转换。其核心目标是简化数据库关联操作，提升开发效率。
• 支持多种配置方式：MyBatis 支持注解和 XML 两种配置方式。

2.2 前置操作

引入依赖：Spring Web，Mybatis Framework，MySQL Driver，Lombok。

在 application.properties/yml 中添加数据库连接信息：

# 应用程序名称
spring.application.name=configuration
# 应用程序端口号
server.port=8080
# 数据库连接信息
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/database_name?characterEncoding=utf8&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
# 自动驼峰转换
mybatis.configuration.map-underscore-to-camel-case=true

spring:
  application:
    # 应用程序名称
    name: configuration
  # 数据库连接信息
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/database_name?characterEncoding=utf8&useSSL=false
    username: root
    password: root
  # 应用程序端口号
  server:
    port: 8080
mybatis:
  configuration:
    map-underscore-to-camel-case: true
    # 自动驼峰转换

SQL 命名规范：采用下划线分隔单词 (如 order_detail)。 Java 命名规范：大驼峰/小驼峰。

2.3 注解

2.3.1 配置

1. 创建一个接口，并使用 @Mapper 注解修饰。

import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface BlogMapper {
    // 其他代码
}

@Mapper 注解：允许开发者直接在接口方法上通过注解配置 SQL 语句，无需编写 XML 映射文件。适用于简单 SQL 场景，能显著减少配置量。

2. 初始化数据。

CREATE TABLE blog (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(128),
    age INT
);
INSERT INTO blog VALUES (null,'刘备',30),(null,'关羽',28),(null,'张飞',25);

3. 创建对应实体类。

import lombok.Data;

@Data
public class PersonInfo {
    private Integer id;
    private String name;
    private Integer age;

    public PersonInfo(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public PersonInfo() {
    }
}

2.3.2 CRUD

import com.example.spring_mybatis.model.PersonInfo;
import org.apache.ibatis.annotations.*;

@Mapper
public interface BlogMapper {
    @Select("select * from blog")
    List<PersonInfo> getPersonInfoAll();

    @Insert("insert into blog values (#{id},#{name},#{age})")
    Integer addPerson(PersonInfo person);

    @Update("update blog set name = #{name},age = #{age} where id = #{id}")
    Integer updatePerson(PersonInfo personInfo);

    @Delete("delete from blog where id = #{id}")
    Integer deletePerson(Integer id);
}

按住 alt+insert，可在 test 目录下生成以上方法的测试方法。

import com.example.spring_mybatis.model.PersonInfo;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;

@SpringBootTest
@Slf4j
class BlogMapperTest {
    private final BlogMapper blogMapper;

    @Autowired
    public BlogMapperTest(BlogMapper blogMapper) {
        this.blogMapper = blogMapper;
    }

    @Test
    void getPersonInfoAll() {
        List<PersonInfo> personInfoAll = blogMapper.getPersonInfoAll();
        log.info("查询成功，personInfoAll:{}", personInfoAll.toString());
        // 查询成功，personInfoAll:[PersonInfo(id=1, name=刘备，age=30),
        // PersonInfo(id=2, name=关羽，age=28),
        // PersonInfo(id=3, name=张飞，age=25)]
    }

    @Test
    void addPerson() {
        Integer ret = blogMapper.addPerson(new PersonInfo(null,"赵云",25));
        log.info("添加成功，影响行数:{}", ret.toString());
        // 添加成功，影响行数:1
    }

    @Test
    void updatePerson() {
        Integer ret = blogMapper.updatePerson(new PersonInfo(1,"刘备",35));
        log.info("更新成功，影响行数:{}", ret.toString());
        // 更新成功，影响行数:1
    }

    @Test
    void deletePerson() {
        Integer ret = blogMapper.deletePerson(4);
        log.info("删除成功，影响行数:{}", ret.toString());
        // 删除成功，影响行数:1
    }
}

2.3.3 @Param

作用：用于在 Mapper 接口方法中为形式参数指定名称。当方法有多个参数时，通过该注解明确 SQL 中引用的参数名，避免依赖参数顺序。

@Mapper
public interface BlogMapper {
    // @Param
    @Update("update blog set name = #{name},age = #{age} where id = #{id}")
    Integer updatePersonInfo(@Param("id") Integer userId, @Param("name") String userName, @Param("age") Integer userAge);
}

@SpringBootTest
@Slf4j
class BlogMapperTest {
    private final BlogMapper blogMapper;

    @Autowired
    public BlogMapperTest(BlogMapper blogMapper) {
        this.blogMapper = blogMapper;
    }

    @Test
    void updatePersonInfo() {
        Integer ret = blogMapper.updatePersonInfo(1,"刘玄德",30);
        log.info("更新成功，影响行数:{}", ret.toString());
        // 更新成功，影响行数:1
    }
}

2.4 XML

2.4.1 配置

1. 创建一个接口，并使用 @Mapper 注解修饰。

import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface BlogXMLMapper {
    // 其他代码
}

2. 配置 MyBatis 的 XML 文件路径。

mybatis:
  mapper-locations: classpath:mybatis/**Mapper.xml
  # 配置 mybatis 的 xml 文件路径
  # 标识位于 resources/mybatis 路径下任何以 Mapper 结尾的 xml 文件为 mybatis 的配置文件

3. 在 resources/mybatis 路径下创建以 Mapper 结尾的 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">
<!-- namespace：用于指定该 XML 文件对应的 Java 接口或类的全限定名 -->
<mapper namespace="com.example.spring_mybatis.mapper_blog.BlogXMLMapper"></mapper>

2.4.2 示例

在接口中声明方法。

import com.example.spring_mybatis.model_blog.PersonInfo;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;

@Mapper
public interface BlogXMLMapper {
    List<PersonInfo> getPersonInfoAll();
}

在对应 XML 文件中实现接口方法。

• id：是 MyBatis 映射文件中 SQL 语句的唯一标识符。需与 Mapper 接口中的方法名一致，保证映射正确。
• resultType：指定 SQL 查询结果映射的 Java 对象类型，需为全限定类名。

<mapper namespace="com.example.spring_mybatis.mapper_blog.BlogXMLMapper">
    <select id="getPersonInfoAll" resultType="com.example.spring_mybatis.model_blog.PersonInfo">
        select * from blog
    </select>
</mapper>

按住 alt+insert，可在 test 目录下生成以上方法的测试方法。

import com.example.spring_mybatis.model_blog.PersonInfo;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;

@SpringBootTest
@Slf4j
class BlogXMLMapperTest {
    private final BlogXMLMapper blogXMLMapper;

    @Autowired
    public BlogXMLMapperTest(BlogXMLMapper blogXMLMapper) {
        this.blogXMLMapper = blogXMLMapper;
    }

    @Test
    void getPersonInfoAll() {
        List<PersonInfo> personInfoAll = blogXMLMapper.getPersonInfoAll();
        log.info("查询成功，personInfoAll:{}", personInfoAll.toString());
    }
}

运行结果：

2.5 动态 SQL

动态 SQL：指在程序运行时根据条件或参数动态生成的 SQL 语句。与静态 SQL 相比，动态 SQL 更具灵活性，适用于需要根据不同条件构建查询的场景。例如，在某些 web/app 进行账号注册时会出现非必填选项。MyBatis 的注解和 XML 两种方式都能实现动态 SQL，但 XML 较为方便，所以下文使用 XML 来实现动态 SQL。

2.5.1 trim 标签

作用：用于自定义字符串截取规则。包含四个属性：

• prefix：最终结果添加前缀。
• suffix：最终结果添加后缀。
• prefixOverrides：去除首部指定内容。
• suffixOverrides：去除尾部指定内容。

2.5.2 if 标签

作用：用于条件判断，通常在 where 或 set 语句中使用。当 test 表达式的值为 true 时，包含标签内的 SQL 片段。

<insert id="addPersonInfo">
    insert into blog
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="id != null"> id, </if>
        <if test="name != null"> name, </if>
        <if test="age != null"> age, </if>
    </trim>
    values
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="id != null"> #{id}, </if>
        <if test="name != null"> #{name}, </if>
        <if test="age != null"> #{age}, </if>
    </trim>
</insert>

2.5.3 where 标签

作用：替代 SQL 中的 where 关键字。当 if 条件成立时才会加入 SQL 片段，并自动去除第一个子句的 and/or。

<select id="getPersonInfoByNameAndAge">
    select * from blog
    <where>
        <if test="name != null"> and name = #{name} </if>
        <if test="age != null"> and age = #{age} </if>
    </where>
</select>

2.5.4 set 标签

作用：用于 update 语句。当 if 条件成立时才会加入 SQL 片段，并自动去除最后一个子句的逗号。

<update id="updatePersonInfo">
    update blog
    <set>
        <if test="name != null"> name = #{name}, </if>
        <if test="age != null"> age = #{age}, </if>
    </set>
    <where> and id = #{id} </where>
</update>

2.5.5 foreach 标签

作用：用于集合遍历。主要属性：

• collection：集合参数名。
• item：当前元素变量名。
• open/close：包围符号。
• separator：分隔符。

@Test
void getPersonInfoById() {
    ArrayList<Integer> ids = new ArrayList<>();
    ids.add(1);
    ids.add(2);
    ids.add(3);
    List<PersonInfo> personInfoById = blogXMLMapper.getPersonInfoById(ids);
    System.out.println(personInfoById);
}

<select id="getPersonInfoById" resultType="com.example.spring_mybatis.model_blog.PersonInfo">
    select * from blog where id in
    <foreach collection="ids" item="id" open="(" close=")" separator=",">
        #{id}
    </foreach>
</select>

2.5.6 include 标签

作用：用于引用 SQL 片段，通过 refid 指定要引用的片段 id。需配合 sql 标签使用，实现代码复用。

<sql id="collection"> id,name,age </sql>
<select id="getPersonInfoAll" resultType="com.example.spring_mybatis.model_blog.PersonInfo">
    select <include refid="collection"></include> from blog
</select>

2.6 主键返回

主键返回：指在数据库插入操作后，自动获取刚插入记录的主键值。在 MyBatis 中使用注解和 XML 都能获取到返回的主键。

1. 注解实现

@Mapper
public interface BlogMapper {
    @Options(useGeneratedKeys = true, keyProperty = "id")
    @Insert("insert into blog values (#{id},#{name},#{age})")
    Integer addPerson(PersonInfo person);
}

@SpringBootTest
@Slf4j
class BlogMapperTest {
    private final BlogMapper blogMapper;

    @Autowired
    public BlogMapperTest(BlogMapper blogMapper) {
        this.blogMapper = blogMapper;
    }

    @Test
    void addPerson() {
        PersonInfo personInfo = new PersonInfo(null,"黄忠",60);
        Integer ret = blogMapper.addPerson(personInfo);
        log.info("添加成功，影响行数:{},返回的主键值:{}", ret.toString(), personInfo.getId());
        // 添加成功，影响行数:1,返回的主键值:6
    }
}

2. 通过 XML 实现

@SpringBootTest
@Slf4j
class BlogXMLMapperTest {
    private final BlogXMLMapper blogXMLMapper;

    @Autowired
    public BlogXMLMapperTest(BlogXMLMapper blogXMLMapper) {
        this.blogXMLMapper = blogXMLMapper;
    }

    @Test
    void addPersonInfo() {
        PersonInfo personInfo = new PersonInfo();
        personInfo.setAge(40);
        personInfo.setName("曹操");
        Integer ret = blogXMLMapper.addPersonInfo(personInfo);
        log.info("添加成功，影响行数:{},返回的主键值:{}", ret.toString(), personInfo.getId());
        // 添加成功，影响行数:1,返回的主键值:7
    }
}

<insert id="addPersonInfo" useGeneratedKeys="true" keyProperty="id">
    insert into blog
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="id != null"> id, </if>
        <if test="name != null"> name, </if>
        <if test="age != null"> age, </if>
    </trim>
    values
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="id != null"> #{id}, </if>
        <if test="name != null"> #{name}, </if>
        <if test="age != null"> #{age}, </if>
    </trim>
</insert>

2.7 预编译/即时 SQL

预编译 SQL (Prepared Statements)：SQL 语句在程序运行前被预先编译并存储在数据库中。执行时只需传递参数，无需重新编译 SQL 语句。

• 安全性高：通过参数化查询避免 SQL 注入攻击。参数化查询是一种将 SQL 语句与用户输入数据分离的数据库操作方式，查询语句中使用占位符 (如 ?、@param 等) 代替直接拼接用户输入，执行时通过预编译机制将参数动态绑定到占位符位置。
• 性能优化：编译一次，多次执行，减少数据库开销。

即时 SQL (Dynamic SQL)：在程序运行时动态生成并立即编译执行，每次执行都可能涉及完整的 SQL 解析和编译过程。

• 灵活性高：可根据运行时条件动态拼接 SQL 语句。
• 潜在风险：直接拼接用户输入可能导致 SQL 注入。
• 性能开销：每次执行需重新编译。

# 占位符会使用预编译机制，将参数值安全地绑定到 SQL 语句中，防止 SQL 注入攻击。MyBatis 会将 # 替换为 ?，然后通过 JDBC 的预编译功能设置参数值。 $ 占位符直接进行字符串替换，将参数值拼接到 SQL 语句中，不会进行预编译或转义处理。

SQL 注入攻击：当恶意输入 " 'or 1 = '1 " 时。

1. 预编译 SQL

@Select("select * from blog where name= #{name}")
List<UserInfo> queryByName(String name);

预编译 SQL 会根据参数的类型判断是否需要加引号，上述 name 参数是 String 类型，需要加引号，这就是参数化查询的作用。最终 SQL：

select * from blog where name = " 'or 1='1 ";
# 整个 'or 1='1 会作为 name 的值

2. 即时 SQL

@Select("select * from blog where name= '${name}'")
List<UserInfo> queryByName(String name);

即时 SQL 不会判断参数类型从而是否添加引号，所以需要手动加上单引号。最终 SQL：

select * from blog where name =''or1='1';
# 因为 1=1 是恒等式，所以该表的数据会被全部查询出来，这就是 SQL 注入