【Mybatis学习笔记】-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_59565183/article/details/130985707

【第一个Mybatis】

思路：搭建环境->导入Mybatis->编写代码->测试

搭建环境

搭建数据库

CREATE DATABASE `mybatis`;

USE mybatis;

CREATE TABLE `user`(
	`id` INT(20) NOT NULL PRIMARY KEY,
	`name` VARCHAR(30) DEFAULT NULL,
	`pwd` VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf-8;

INSERT INTO `user` VALUE
(1,'小明',123456),
(2,'小强',123456),
(3,'小红',123456);

新建项目

1.创建普通maven项目(作为父工程)

导入依赖

<dependencies>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

2.创建模块

导入MySQL
在idea右侧Database中new Data Source，相关信息在下面mybatis的核心配置中需要用到

编写mybatis的核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSl=true&amp;useunicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

编写mybatis工具类

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

//sqlSessionFactory -> sqlSession
public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;
    
    static {
        try {
            //使用Mybatis第一步获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
    //SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    
    public static SqlSession getSession(){
        return sqlSessionFactory.openSession();
    }
}

3.编写代码

实体类

package com.canso.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

@Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

Dao接口

public interface Userdao {
    List<User> getUserList = null;
}

接口实现类由原来的UserDaoImp转变为一个Mapper配置文件

<?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=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.canso.dao.Userdao">
    <select id="getUserList" resultType="com.canso.pojo.User" >
        select * from mybatis.user
    </select>
</mapper>

namespace中的包名要和Dao/Mapper接口一致
id:对应namespace中的方法名
resultType：Sql语句执行的返回值

4.测试

package com.canso.dao;

import com.canso.pojo.User;
import com.canso.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoText {
    @Test
    public void test(){
        //获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSession();
        //执行SQL
        Userdao mapper = sqlSession.getMapper(Userdao.class);
        List<User> userList = mapper.getUserList();

        for (User user : userList) {
            System.out.println(user);
        }

        //关闭SQLSession
        sqlSession.close();
    }
}

可能出现的问题

在核心配置文件中加入下面代码

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/canso/dao/UserMapper.xml"/>
    </mappers>

出现java.lang.ExceptionInInitializerError

在maven项目的pom下加入以下代码

	<build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

没有以上代码的话，当我们执行项目，生成的target中，只会生成resource下的xml文件，在其他目录的xml不会生成，以上代码起到过滤的作用

【CRUD】

namespace中的包名要与Dao/mapper接口的包名一致

id就是对应的namespace中的方法名

resultType是SQL语句执行的返回值

parameterType是参数类型

编写Mapper接口

package com.canso.dao;

import com.canso.pojo.User;
import java.util.List;

public interface UserMapper {
    //查询全部用户
    List<User> getUserList();
    //根据ID查询用户
    User getUserById(int i);
    //增加用户
    int addUser(User user);
    //修改用户
    int updateUser(User user);
    //删除用户
    int deleteUser(int id);
}

Mapper中的sql语句

<?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=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.canso.dao.UserMapper">
    <select id="getUserList" resultType="com.canso.pojo.User" >
        select * from mybatis.user
    </select>

    <select id="getUserById" parameterType="int" resultType="com.canso.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>
<!--增-->
<!--对象中的属性可以直接取出-->
    <insert id="addUser" parameterType="com.canso.pojo.User">
        insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd});
    </insert>
<!--更新-->
    <update id="updateUser" parameterType="com.canso.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id};
    </update>
<!--删除-->
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id = #{id};
    </delete>
</mapper>

测试

注意：增删改操作需要提交事务（sqlSession.commit();），否则表格不会变化

package com.canso.dao;

import com.canso.pojo.User;
import com.canso.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoText {
    @Test
    public void test(){
        //获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //执行SQL
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();

        for (User user : userList) {
            System.out.println(user);
        }

        //关闭SQLSession
        sqlSession.close();
    }
    @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);


        sqlSession.close();
    }
<!--增-->
    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        mapper.addUser(new User(4,"小天","123"));
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }
<!--更新-->
    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        mapper.updateUser(new User(4,"小改","123123"));
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }
<!--删除-->
    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        mapper.deleteUser(4);

        sqlSession.commit();
        sqlSession.close();
    }
}

【XML配置】

xml配置文件中需按以下顺序排放

(properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?)

属性(properties)

xml核心文件中的属性property属性值可以在配置文件中编写，之后核心文件直接引用，达到动态修改

属性全部在配置文件中

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSl=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
<!--    引入外部配置文件-->
    <properties resource="db.properties"/>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/canso/dao/UserMapper.xml"/>
    </mappers>
</configuration>

属性部分在配置文件中

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSl=true&useUnicode=true&characterEncoding=UTF-8

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--核心配置文件-->
<configuration>
<!--    引入外部配置文件-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </properties>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/canso/dao/UserMapper.xml"/>
    </mappers>
</configuration>

若配置文件和核心文件中均有相同属性配置，则优先使用外部配置文件属性值

类型别名

给实体类其别名

核心文件中配置

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

<!--com.canso.pojo.User的别名User-->
    <select id="getUserList" resultType="User" >
        select * from mybatis.user
    </select>

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean

在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。比如 com.canso.pojo.User 的别名为 user；若有注解，则别名为其注解值。

核心文件中配置

    <typeAliases>
        <package name="com.canso.pojo"/>
    </typeAliases>

    <select id="getUserList" resultType="user" >
        select * from mybatis.user
    </select>

给实体类注释

@Alias("hi")
public class User {
···
}

    <select id="getUserList" resultType="hi" >
        select * from mybatis.user
    </select>

映射器（mappers）

MapperRegistry：注册绑定我们的Mapper文件

方式一：使用resource文件绑定注册

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/canso/dao/UserMapper.xml"/>
    </mappers>

方式二：使用class文件绑定注册

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper class="com.canso.dao.UserMapper"/>
    </mappers>

注意点：

接口和它的Mapper配置文件必须同名
接口和它的Mapper配置文件必须在同一个包下

方式三：使用扫描包绑定注册

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <package name="com.canso.dao"/>
    </mappers>

注意点：

接口和它的Mapper配置文件必须同名
接口和它的Mapper配置文件必须在同一个包下

【resultMap结果映射】

解决属性名和字段名不一致问题

数据库中的字段（密码为pwd）

新建一个项目，拷贝之前的，修改pwd为password，测试实体类字段不一致的情况

@Alias("user")
public class User {
    private int id;
    private String name;
    private String password;

    public User() {
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

测试结果为：password为NULL

解决方法

1.起别名

<select id="getUserList" resultType="user" >
#       select * from mybatis.user
        select id,name,pwd as password from mybatis.user
    </select>

2.resultMap结果集映射

resultMap标签中的id为数据库标签中的resultMap值，type为实体类表

column：数据库中的字段，property：实体类中的属性

<mapper namespace="com.canso.dao.UserMapper">
<!--    结果集映射-->
    <resultMap id="UserMap" type="User">
<!--        column数据库中的字段，property实体类中的属性-->
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwd" property="password"/>
    </resultMap>
    <select id="getUserList"  resultMap="UserMap" >
        select * from mybatis.user
    </select>

</mapper>

【日志】

日志工厂

若数据库操作出现异常，日志可以很好帮我们排错

SLF4J
LOG4J（3.5.9 起废弃）
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING
NO_LOGGING

在mybatis的核心文件中配置我们的需要的日志

    <settings>
        <!-- 标准的日志输出 -->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

【注解】

注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。
注解，可以看作是对一个类/方法的一个扩展的模版，每个类/方法按照注解类中的规则，来为类/方法注解不同的参数，在用到的地方可以得到不同的类/方法中注解的各种参数与值。

CRUD

我们在测试类中需要手动提交事务，若想自动提交事务
可以在Mybatis工具类中将openSession设置为true

    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession(true);
    }

接口

package com.canso.dao;

import com.canso.pojo.User;
import org.apache.ibatis.annotations.*;

import java.util.List;
import java.util.Map;

public interface UserMapper {

    //方法存在多个参数，所有的参数前面必须加上 @param（“id”）注解
    @Select("select * from user where id = #{id}")
    User getUserByID(@Param("id") int id);

    @Insert("insert into user(id,name,pwd) value (#{id},#{name},#{password})")
    int addUser(User user);

    @Update("update user set name=#{name},pwd=#{password} where id=#{id}")
    int updateUser(User user);

    @Delete("delete from user where id = #{uid}")
    int deleteUser(@Param("uid") int id);
}

测试类

package com.canso.dao;

import com.canso.pojo.User;
import com.canso.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;

public class UserDaoText {
    @Test
    public void getUserByID(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User userByID = mapper.getUserByID(1);
        System.out.println(userByID);
        sqlSession.close();
    }
    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int addUser = mapper.addUser(new User(4, "hhh", "5678"));
        System.out.println(addUser);
        sqlSession.close();
    }
    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int updateUser = mapper.updateUser(new User(1,"hi","4567"));
        System.out.println(updateUser);
        sqlSession.close();
    }
    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int deleteUser = mapper.deleteUser(2);
        System.out.println(deleteUser);
        sqlSession.close();
    }
}

注意：核心文件需要绑定注册接口

<!--    绑定接口-->
    <mappers>
        <mapper class="com.canso.dao.UserMapper"/>
    </mappers>

关于@Param()注解

基本类型的参数或String类型，需要加上
引用类型不需要加
如果只有一个基本类型的话，可以忽略
SQL中引用的就是@Param()中设定的属性名

【lombok、多对一、一对多】

Lombok

Lombok是一个Java库，能自动插入编辑器并构建工具，简化Java开发。通过添加注解的方式，不需要为类编写getter或eques方法，同时可以自动化日志变量。
官网：https://www.projectlombok.org/

使用

安装插件
File->Settings->Plugins->lombok

pom中导入maven依赖
https://mvnrepository.com/artifact/org.projectlombok/lombok

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.24</version>
    </dependency>

测试环境搭建

1.导入lombok,Mysql的student和teacher表
2.新建实体类Teacher，Student
3.建立Mapper接口
4.建立Mapper.xml文件
5.在核心配置文件中绑定注册我们的Mapper接口或文件
6.测试查询是否能够成功

1.pom中导包

<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>

2.新建实体类Teacher，Student

package com.canso.pojo;

import lombok.Data;

@Data
public class Student {
    private int id;
    private String name;
    //学生关联老师
    private Teacher teacher;
}

package com.canso.pojo;

import lombok.Data;

@Data
public class Teacher {
    private int id;
    private String name;
}

3.建立Mapper接口

package com.canso.dao;

import com.canso.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface TeacherMapper {
    @Select("select * from teacher where id=#{tid}")
    Teacher getTeacher(@Param("tid") int id);
}

package com.canso.dao;

public interface StudentMapper {
}

4.建立Mapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.canso.dao.TeacherMapper">

</mapper>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.canso.dao.StudentMapper">

</mapper>

5.在核心配置文件中绑定注册我们的Mapper接口或文件

  <mappers>
        <mapper class="com.canso.dao.TeacherMapper"/>
        <mapper class="com.canso.dao.StudentMapper"/>
    </mappers>

6.测试查询是否能够成功

多对一处理

按照查询嵌套处理

子查询

    <select id="getStudent" resultMap="StudentTeacher">
        select * from mybatis.student;
    </select>
    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
<!-- 复杂的属性，需要单独处理，对象：association，集合：collection -->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="Teacher">
        select * from mybatis.teacher where id=#{id}
    </select>

按照结果嵌套处理

联表查询

  <select id="getStudent2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.name tname
        from mybatis.teacher t,mybatis.student s
        where s.tid=t.id;
    </select>
    <resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>

一对多处理

环境与多对一测试类似，差别如下：

按照结果嵌套查询

实体类：

@Data
public class Teacher {
    private int id;
    private String name;
    //一个老师拥有多个学生
    private List<Student> students;
}

@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}

TeacherMapper

<!--    按照结果嵌套查询-->
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid,s.name sname,t.id tid,t.name tname
        from mybatis.student s ,mybatis.teacher t
        where s.tid=t.id and t.id=#{tid};
    </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!-- 复杂的属性，需要单独处理，对象：association，集合：collection -->
        <!-- javaType：指定属性的类型，集合类的泛型信息，使用ofType -->
        <collection property="student" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

测试

 @Test
    public void textTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);
        sqlSession.close();
    }

【动态SQL】

动态SQL即是通过不同的条件生成不同的SQL语句

如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。
借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。
if
choose (when, otherwise)
trim (where, set)
foreach

搭建环境

新建数据库

新建项目

导包
编写核心配置文件

编写工具类、实体类

@Data
public class Customer {
    private int cId;
    private String name;
    private String location;
    private int salary;
}

实体类对应Mapper接口以及xml文件

if元素

where 后面添加判断语句

CustomerMapper.java

List<Customer> queryCustomer(Map map);

CustomerMapper.xml

<!--    if-->
    <select id="queryCustomer" parameterType="map" resultType="Customer">
        select * from exp07.customer where 1=1
        <if test="name!=null">
            and name = #{name}
        </if>
    </select>

Mytext

@Test
    public void queryCustomer(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        CustomerMapper mapper = sqlSession.getMapper(CustomerMapper.class);
        HashMap hashMap = new HashMap();
        hashMap.put("name","孙萌");
        List<Customer> customers = mapper.queryCustomer(hashMap);
        for (Customer customer : customers) {
            System.out.println(customer);
        }
        sqlSession.close();
    }

where元素

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

select * from exp07.customer
<where>
    ···
</where>

choose (when, otherwise)元素

choose后面加条件，when：条件成立，执行，otherwise：否则执行

<!--    choose-->
    <select id="queryChooseCustomer" parameterType="map" resultType="Customer">
        select * from exp07.customer
            <where>
                <choose>
                    <when test="name!=null">
                        name=#{name}
                    </when>
                    <when test="location!=null">
                        and location=#{location}
                    </when>
                    <otherwise>
                        and salary=#{salary}
                    </otherwise>
                </choose>
            </where>
    </select>

trim (where, set)

prefix：前缀
suffixOverrides：后缀

set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ...
</trim>

foreach

foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。

<select id="queryChooseCustomer" parameterType="map" resultType="Customer">
  SELECT * FROM POST P
  <where>
    <foreach item="item" index="index" collection="list"
        open="ID in (" separator="," close=")" nullable="true">
          #{item}
    </foreach>
  </where>
</select>

SQL片段

有时，需要将功能相同的部分抽取出来，方便复用

公共部分

<sql id="if-customer">
    <if test="name!=null">
        name=#{name}
    </if>
    <if test="location!=null">
        and location=#{location}
    </if>
</sql>

include

    <select id="queryChooseCustomer" parameterType="map" resultType="Customer">
        select * from exp07.customer
            <where>
                <include refid="if-customer"></include>
            </where>
    </select>