概述

MyBatis 是支持普通 SQL 查询,存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的 JDBC 代码和参数的手工设置以及结果集的检索，底层是封装的JDBC。

作用：

  1. 简化JDBC的开发
  2. 自动完成ORM(对象关系映射)

核心资源

  1. 核心配置文件

mybatis-config.xml，配置了事务管理与数据源。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  6. <configuration>
  8.     <!--  配置别名  -->
  9.     <typeAliases>
  10.         <typeAlias type="cn.tedu.pojo.User" alias="User"/>
  11.         <typeAlias type="cn.tedu.pojo.Dept" alias="Dept"/>
  12.     </typeAliases>
  14.     <!--  environments可以配置多个数据库的连接信息，default指定环境，当前默认为test环境  -->
  15.     <environments default="test">
  16.         <environment id="test">
  17.             <!--     使用的事务管理器为JDBC       -->
  18.             <transactionManager type="JDBC"/>
  19.             <!--     连接数据库的配置信息，配置数据源       -->
  20.             <dataSource type="POOLED">
  21.                 <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
  22.                 <property name="url"
  23.                           value="jdbc:mysql://localhost:3306/mybatisdb?characterEncoding=utf8&amp;serverTimezone=Asia/Shanghai"/>
  24.                 <property name="username" value="root"/>
  25.                 <property name="password" value="root"/>
  26.             </dataSource>
  27.         </environment>
  28.     </environments>
  30.     <mappers>
  31.         <mapper resource="mappers/UserMapper.xml"/>
  32.         <mapper resource="mappers/DeptMapper.xml"/>
  33.     </mappers>
  34. </configuration>
  1. 映射文件

nameMapper.xml，存放大量的CRUD的SQL语句。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--此文件为User的映射文件-->
  3. <!DOCTYPE mapper
  4.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  5.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  7. <!--namespace为映射文件的唯一标识-->
  8. <mapper namespace="userMapper">
  9.     <!--  查询id为为1的用户信息，
  10.     id为sql语句的唯一标识,
  11.     resultType="类的全路径"，用于封装查询到的结果
  12.     -->
  13.     <select id="getById" resultType="cn.tedu.pojo.User">
  14.         select *
  15.         from user
  16.         where id = 1
  17.     </select>
  19.     <!--  查询所有用户信息  -->
  20.     <select id="getInfo" resultType="cn.tedu.pojo.User">
  21.         select *
  22.         from user
  23.     </select>
  25.     <!--  根据用户名查询指定用户信息
  26.     SQl动态获取参数时，可以使用#{}或${}
  27.     #{}底层使用了高级传输器，安全高效，会自动进行字符串拼接
  28.     ${}底层使用了低级传输器，会发生SQL注入
  29.     -->
  31.     <!--  User为别名，在配置文件中设置  -->
  32.     <select id="getByName" resultType="User">
  33.         select *
  34.         from user
  35.         where name = #{name}
  36.     </select>
  38.     <!--    <insert id="addUser" parameterType="User">-->
  39.     <!--        insert into user-->
  40.     <!--        values (null, #{name}, #{addr}, #{age})-->
  41.     <!--    </insert>-->
  42. </mapper>
  1. 核心工具类

会话工厂：SqlSessionFactory：产生会话
会话SqlSession：执行SQL语句

  1. package cn.tedu.test;
  3. import cn.tedu.pojo.Dept;
  4. import cn.tedu.pojo.User;
  5. import org.apache.ibatis.io.Resources;
  6. import org.apache.ibatis.session.SqlSession;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  9. import org.junit.jupiter.api.Test;
  11. import java.io.IOException;
  12. import java.io.InputStream;
  13. import java.util.List;
  15. public class TestMybatis {
  16.     @Test
  17.     public void get() throws IOException {
  18.         //获取sqlSessionFactory
  19.         InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
  20.         SqlSessionFactory session = new SqlSessionFactoryBuilder().build(in);
  21.         //开启会话，获取SqlSession准备执行Sql语句
  22.         SqlSession sqlSession = session.openSession();
  24.         //查询id为1的用户信息
  25.         User user = sqlSession.selectOne("userMapper.getById");
  26.         Integer id = user.getId();
  27.         String name = user.getName();
  28.         String addr = user.getAddr();
  29.         Integer age = user.getAge();
  30.         System.out.println("id=" + id + ",name=" + name + ",addr=" + addr + ",age=" + age);
  32.         //查询所有用户信息
  33.         List<User> info = sqlSession.selectList("userMapper.getInfo");
  34.         for (User u : info) {
  35.             System.out.println(u);
  36.         }
  38.         //查询指定用户信息
  39.         String userName = "hanmeimei";
  40.         User user1 = sqlSession.selectOne("userMapper.getByName", userName);
  41.         System.out.println(user1);
  43. //        User user1 = new User();
  44. //        user1.setName("马钊").setAddr("地府").setAge(-125);
  45. //        sqlSession.insert("addUser",user1);
  46. //        sqlSession.commit();
  48.         //查询dept表中id为1的信息
  49.         Dept d1 = sqlSession.selectOne("deptMapper.getById");
  50.         System.out.println(d1);
  51.     }
  52. }
  1. ORM

对象关系映射，将表中的字段与类中的属性进行映射，使用类中的属性保存的表中的字段值。

示例

准备数据

  1. create database mybatisdb default character set utf8;
  2. use mybatisdb;
  3. create table user(id int primary key auto_increment,name varchar(100),addr varchar(100),age int);
  4. Insert into user values(null,'hanmeimei','北京',28);
  5. Insert into user values(null,'xiongda','上海',20);
  6. Insert into user values(null,'xiaonger','上海',19);
  7. DROP TABLE IF EXISTS `dept`;
  8. CREATE TABLE `dept` (
  9.   `id` int(11) NOT NULL AUTO_INCREMENT,
  10.   `dname` varchar(14) DEFAULT NULL,
  11.   `loc` varchar(13) DEFAULT NULL,
  12.   PRIMARY KEY (`id`)
  13. ) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8;
  15. -- ----------------------------
  16. -- Records of dept
  17. -- ----------------------------
  18. INSERT INTO `dept` VALUES ('1', '呵呵呵', '一区');
  19. INSERT INTO `dept` VALUES ('2', '哈哈哈哈', '二区');
  20. INSERT INTO `dept` VALUES ('3', 'operations', '二区');
  21. INSERT INTO `dept` VALUES ('5', 'java教研部', '大钟寺');
  22. INSERT INTO `dept` VALUES ('10', '开发', '西二旗');
  23. DROP TABLE IF EXISTS `emp`;
  24. CREATE TABLE `emp` (
  25.   `id` int(11) NOT NULL AUTO_INCREMENT,
  26.   `ename` varchar(10) DEFAULT NULL,
  27.   `job` varchar(9) DEFAULT NULL,
  28.   `mgr` decimal(4,0) DEFAULT NULL,
  29.   `hiredate` date DEFAULT NULL,
  30.   `sal` decimal(7,2) DEFAULT NULL,
  31.   `comm` decimal(7,2) DEFAULT NULL,
  32.   `deptno` int(11) DEFAULT NULL,
  33.   PRIMARY KEY (`id`)
  34. ) ENGINE=InnoDB AUTO_INCREMENT=510 DEFAULT CHARSET=utf8;
  36. -- ----------------------------
  37. -- Records of emp
  38. -- ----------------------------
  39. INSERT INTO `emp` VALUES ('100', 'jack', '副总', null, '2002-05-03', '90000.00', null, '1');
  40. INSERT INTO `emp` VALUES ('200', 'tony', '总监', '100', '2015-02-02', '10000.00', '2000.00', '2');
  41. INSERT INTO `emp` VALUES ('300', 'hana', '经理', '200', '2017-02-02', '8000.00', '1000.00', '2');
  42. INSERT INTO `emp` VALUES ('400', 'leo', '员工', '300', '2019-02-22', '3000.00', '200.12', '2');
  43. INSERT INTO `emp` VALUES ('500', 'liu', '员工', '300', '2019-03-19', '3500.00', '200.58', '2');
  44. INSERT INTO `emp` VALUES ('502', '王一博', 'topidol.', '1000', '2021-03-31', '20000.00', '99.00', '88');
  45. INSERT INTO `emp` VALUES ('504', '蔡徐坤', 'rapper', '10', '2021-03-29', '100.00', '1000.00', '100');

创建核心配置文件

mybatis-config.xml

  3. <?xml version="1.0" encoding="UTF-8"?>
  4. <!DOCTYPE configuration
  5.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  6.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  8. <configuration>
  9.     <!--  environments可以配置多个数据库的连接信息，default指定环境，当前默认为test环境  -->
  10.     <environments default="test">
  11.         <environment id="test">
  12.             <!--     使用的事务管理器为JDBC       -->
  13.             <transactionManager type="JDBC"/>
  14.             <!--     连接数据库的配置信息，配置数据源       -->
  15.             <dataSource type="POOLED">
  16.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  17.                 <property name="url"
  18.                           value="jdbc:mysql://localhost:3306/mybatisdb?characterEncoding=utf8&amp;serverTimezone=Asia/Shanghai"/>
  19.                 <property name="username" value="root"/>
  20.                 <property name="password" value="root"/>
  21.             </dataSource>
  22.         </environment>
  23.     </environments>
  24. </configuration>

创建映射文件

UserMapper.xml

映射语句需写在mapper双标签中，其中namespace是映射文件的唯一标识，在<mapper><mapper/>中可以编写SQL语句，每种语句具有自己的双标签，<select></select>标签中可以编写查询语句，id为SQL语句的为一标识，resultType为类的全路径，封装查询到的结果。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--此文件为User的映射文件-->
  3. <!DOCTYPE mapper
  4.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  5.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  7. <!--namespace为映射文件的唯一标识-->
  8. <mapper namespace="userMapper">
  9.     <!--  查询id为为1的用户信息，
  10.     id为sql语句的唯一标识,
  11.     resultType="类的全路径"，用于封装查询到的结果
  12.     -->
  13.     <select id="getById" resultType="cn.tedu.pojo.User">
  14.         select *
  15.         from user
  16.         where id = 1
  17.     </select>
  18. </mapper>

将映射文件注册到配置文件中

在映射文件创建完毕后，需要将映射文件注册到mybatis配置文件（mybtis-config.xml）中才可使其生效。注册代码为：

  1. <mappers>
  2.         <mapper resource="mappers/UserMapper.xml"/>
  3. </mappers>

<mappers></mappers>标签中注册需要进行注册的映射文件，resource中为映射文件相对于配置文件的相对路径。

测试

进行SQL操作需要使用SqlSessionFactory,因此需要实例化SqlSessionFactoryBuilder来构建SqlSessionFactory，使用输入流来进行数据传输，Resource中提供了各种工具类，使用其中的getResourceAsStream方法，参数为mybatis的配置文件路径。将输入流实例化后使用SqlSessionFactoryBuilder的方法build进行数据流传输。然后开启session会话执行SQL语句。
sqlSession中有各种方法进行SQL语句的执行，使用时需要使用映射文件中的SQL语句的id来确定执行那一条语句。

  1. package cn.tedu.test;
  3. import cn.tedu.pojo.User;
  4. import org.apache.ibatis.io.Resources;
  5. import org.apache.ibatis.session.SqlSession;
  6. import org.apache.ibatis.session.SqlSessionFactory;
  7. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  8. import org.junit.jupiter.api.Test;
  10. import java.io.IOException;
  11. import java.io.InputStream;
  12. import java.util.List;
  14. public class TestMybatis {
  15.     @Test
  16.     public void get() throws IOException {
  17.         //获取sqlSessionFactory
  18.         InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
  19.         SqlSessionFactory session = new SqlSessionFactoryBuilder().build(in);
  20.         //开启会话，获取SqlSession准备执行Sql语句
  21.         SqlSession sqlSession = session.openSession();
  23.         //查询id为1的用户信息
  24.         User user = sqlSession.selectOne("userMapper.getById");
  25.         Integer id = user.getId();
  26.         String name = user.getName();
  27.         String addr = user.getAddr();
  28.         Integer age = user.getAge();
  29.         System.out.println("id=" + id + ",name=" + name + ",addr=" + addr + ",age=" + age);
  31.     }
  32. }

根据姓名查询user表中的用户信息

映射语句

{name}为传递的用户姓名。可在测试文件中自定义。

  1. <select id="getByName" resultType="User">
  2.         select *
  3.         from user
  4.         where name = #{name}
  5. </select>

进行查询
selectOne方法参数的第一个参数为SQL语句的唯一标识，第二个参数为进行查询的姓名。

  1. //查询指定用户信息
  2. String userName = "hanmeimei";
  3. User user1 = sqlSession.selectOne("userMapper.getByName", userName);
  4. System.out.println(user1);

别名

可以在mybatis的配置文件中为结果集起别名，配置代码如下：

  1. <!--  配置别名  -->
  2.     <typeAliases>
  3.         <typeAlias type="cn.tedu.pojo.User" alias="User"/>
  4. </typeAliases>

在映射文件中使用别名

resultType即为别名。

  1. <!--  User为别名，在配置文件中设置  -->
  2.     <select id="getByName" resultType="User">
  3.         select *
  4.         from user
  5.         where name = #{name}
  6. </select>

#{}与$的区别

SQl动态获取参数时，可以使用#{}或${}
#{}底层使用了高级传输器，安全高效，会自动进行字符串拼接
${}底层使用了低级传输器，会发生SQL注入

接口开发

1.创建映射文件

<mapper></mapper>标签中的namespace为接口的全路径，SQL语句中的id为接口中的方法名，以此来进行映射文件与接口的一一对应。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--此文件为User的映射文件-->
  3. <!DOCTYPE mapper
  4.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  5.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  7. <!--namespace的值为接口中的全路径-->
  8. <mapper namespace="cn.tedu.dao.DeptMapper">
  9.     <!--  id为接口中的方法名  -->
  10.     <select id="getById" resultType="Dept">
  11.         select *
  12.         from dept
  13.         where id = 1
  14.     </select>
  15. </mapper>

2.创建接口

注意接口名与接口中的方法名与映射文件的配置进行对应。

  1. package cn.tedu.dao;
  3. import cn.tedu.pojo.Dept;
  5. public interface DeptMapper {
  6.     Dept getById();
  7. }

3.使用接口进行SQL操作

需要使用反射获取指定接口，然后调用接口中的方法，接口中的方法与映射文件的SQL语句对应，调用后将会返回映射文件中的结果集。

  1. package cn.tedu.test;
  3. import cn.tedu.dao.DeptMapper;
  4. import cn.tedu.pojo.Dept;
  5. import org.apache.ibatis.io.Resources;
  6. import org.apache.ibatis.session.SqlSession;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  9. import org.junit.jupiter.api.Test;
  11. import java.io.IOException;
  12. import java.io.InputStream;
  14. public class TestInterface {
  15.     @Test
  16.     public void get() throws IOException {
  17.         InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
  18.         SqlSessionFactory session = new SqlSessionFactoryBuilder().build(in);
  19.         SqlSession sqlSession = session.openSession();
  21.         //使用反射获取指定接口
  22.         DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
  23.         //调用接口中的方法，接口中的方法将会执行查询语句并返回结果集
  24.         Dept d = mapper.getById();
  25.         System.out.println(d);
  26.     }
  27. }

4.在接口开发中使用参数

查询办公地址为2区的部门信息，将loc设为#{loc}

  1. <select id="getByLoc" resultType="Dept">
  2.         select *
  3.         from dept
  4.         where loc = #{loc};
  5. </select>

在接口中创建方法

因为映射文件中的地址需要参数，因此接口方法中需要设置参数。

  1. package cn.tedu.dao;
  3. import cn.tedu.pojo.Dept;
  5. import java.util.List;
  7. public interface DeptMapper {
  8.     Dept getById();
  9.     List<Dept> getDnameInfo(Object dname);
  10.     List<Dept> getByLoc(Object loc);
  11. }

调用接口方法并进行参数传递

  1. InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
  2. SqlSessionFactory session = new SqlSessionFactoryBuilder().build(in);
  3. SqlSession sqlSession = session.openSession();
  5. //使用反射获取指定接口
  6. DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
  7. List<Dept> d3 = mapper.getByLoc("二区");
  8. System.out.println(d3);

动态SQL

sql和include

使用Sql标签可以提取SQL片段，来提高SQL的复用性，其中id为Sql标签的唯一标识，使用时需要使用include来指定引用片段，指定使用Sql标签需要使用refid属性来指定Sql的唯一标识id，以此来使用指定的Sql片段。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--此文件为User的映射文件-->
  3. <!DOCTYPE mapper
  4.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  5.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  7. <!--namespace的值为接口中的全路径-->
  8. <mapper namespace="cn.tedu.dao.DeptMapper">
  10.     <sql id="cols">
  11.         id,dname,loc
  12.     </sql>
  14.     <!--  id为接口中的方法名  -->
  15.     <select id="getById" resultType="Dept">
  16.         select
  17.         <include refid="cols"/>
  18.         from dept
  19.         where id = 1
  20.     </select>
  21. </mapper>

if

在执行SQL时可以添加判断条件，只有当判断条件满足时，才会执行该SQL语句，使用test属性设置判断条件。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--此文件为User的映射文件-->
  3. <!DOCTYPE mapper
  4.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  5.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  7. <!--namespace的值为接口中的全路径-->
  8. <mapper namespace="cn.tedu.dao.DeptMapper">
  10.     <sql id="cols">
  11.         id,dname,loc
  12.     </sql>
  14.     <select id="getDnameInfo" resultType="Dept">
  15.         select
  16.         <include refid="cols"/>
  17.         from dept
  18.         <!--    if条件不满足将不会执行if标签中的语句    -->
  19.         <if test="dname != null">
  20.             where dname = #{dname};
  21.         </if>
  22.     </select>
  23. </mapper>

where

在执行SQL语句时，若if标签中有AND或OR语句，那么当if标签中的条件不生效时，执行该SQL语句将会报错。where可以避免这种情况。

  1. <select id="find" resultType="Item" >
  2. SELECT <include refid="cols"/> FROM tb_item
  3. <where> 
  4.     <if test="title != null"> title like #{title} </if>
  5.     <if test="sellPoint != null">and sell_point like #{sellPoint}</if>
  6. </where>
  7. </select>

foreach标签

MyBatis的foreach标签应用于多参数的交互如：多参数（相同参数）查询、循环插入数据等，foreach标签包含collection、item、open、close、index、separator，且常用于遍历集合构建in条件语句或批量操作语句。

属性 描述
collection 参数名称，根据Mapper接口的参数名确定，也可以使用@Param注解指定参数名，若为map集合，则为key-value中的key；该参数必选。
item 表示集合中每一个元素进行迭代时的别名，若collection为List、Set或者数组，则表示其中的元素，相当于for循环中的i；若collection为map，则代表key-value的value，该参数为必选
open 表示该语句以什么开始，最常用的是左括弧’(’，注意:mybatis会将该字符拼接到整体的sql语句之前，并且只拼接一次，该参数为可选项
close 表示该语句以什么结束，最常用的是右括弧’)’，注意:mybatis会将该字符拼接到整体的sql语句之后，该参数为可选项
separator 分隔符，每次循环完成后添加此分隔符；mybatis会在每次迭代后给sql语句append上separator属性指定的字符，该参数为可选项
index 在list、Set和数组中,index表示当前迭代的位置，在map中，index代指是元素的key，该参数是可选项。

特殊字符

XML文件中有些字符正常使用无法使用，因此需要转义，例如>, < , & , ‘ , “ 等字符。

若想正常使用有两种方式：

  1. 使用<![CDATA[“需要转义的语句”]]，括号中为需要换一的语句

    1. <![CDATA[
    2.  and age<=#{age}
    3. ]]>

  2. 使用特殊字符 | 普通字符 | 名称 | 转义后 | | —- | —- | —- | | < | 小于号 | < | | > | 大于号 | > | | & | 和 | & | | ‘ | 单引号 | ' | | “ | 双引号 | " |

ResultMap

概述

当数据库中字段名与pojo对象的属性名一致时可以使用resultType，因此resultType只能完成简单的ORM。
单数字段名与pojo对象中的属性名不一致时需要使用resultMap。

使用方法：

映射文件

  1. <resultMap id="userInfoRM" type="cn.tedu.pojo.UserInfo">
  2.         <result property="userName" column="user_name"/>
  3.         <result property="userAddr" column="user_addr"/>
  4.         <result property="userAge" column="user_age"/>
  5. </resultMap>

pojo类

  1. package cn.tedu.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import lombok.experimental.Accessors;
  8. @Data
  9. @NoArgsConstructor
  10. @AllArgsConstructor
  11. @Accessors(chain = true)
  12. public class UserInfo {
  13.     private Integer id;
  14.     private String userName;
  15.     private String userAddr;
  16.     private String userAge;
  17. }

数据表
image.png

其中id为resultMap的唯一标识，type为pojo类的全路径，resultMap标签中将pojo类中的属性与数据表中的名称不同的字段进行一对一映射。property属性为pojo类的属性，column为数据表的字段名。

自动匹配规范驼峰规则

数据库中字段名一般全大写，多个单词之间使用下划线隔开，java中属性一般使用java驼峰规则，因此需要大量resultMap标签，可以开启驼峰规则自动映射，自动转换。

mapper配置中不需要写字段与属性的配置，会进行自动映射，但主键需要单独写，其他的可以使用驼峰规则自动映射。

在mybatis的核心配置文件Mybatis-config.xml开启驼峰规则，代码如下。

  1. <settings>
  2.         <!--    开启驼峰规则    -->
  3.         <setting name="mapUnderscoreToCamelCase" value="true"/>
  4. </settings>

在映射文件中配置驼峰规则开启，使用autoMapping属性将其设置为true

  1. <resultMap id="userInfoRM" type="cn.tedu.pojo.UserInfo" autoMapping="true">
  2. </resultMap>

参数传递

Mybatis参数传递只支持单值传参，多值传参需要进行封装，将多个值封装为单值。

封装方式有两种：

  1. 封装为对象
  2. 封装为Map集合

一般使用最多的为封装为对象，若不能封装为对象，则使用Map封装集合。

封装为对象传参

创建对象并通过set方法赋值，调用DAO接口时传递参数为封装的对象，Mybatis会自动根据传递的对象的值进行给SQL语句拼接。

测试类：

  1. @SpringBootTest
  2. public class TestMybatis {
  3.     @Autowired
  4.     private UserMapper userMapper;
  5.     /*
  6.     查询年龄为18且为男的数据，适用对象封装。
  7.      */
  8.     @Test
  9.     public void testMybatis() {
  10.         User user = new User().setSex("男").setAge(18);
  11.         List<User> users = userMapper.findWhere(user);
  12.         System.out.println(users);
  13.     }
  14. }

DAO：

  1. package com.jt.dao;
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.jt.pojo.User;
  5. import org.apache.ibatis.annotations.Mapper;
  6. import org.apache.ibatis.annotations.Param;
  8. import java.util.List;
  10. @Mapper
  11. /*
  12. 继承BaseMapper接口必须添加泛型对象，否则映射表报错
  13. 自己创建的接口不要与接口方法重名
  14.  */
  15. public interface UserMapper extends BaseMapper<User> {
  16.     List<User> findWhere(User user);
  17. }

Mapper.XML

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.jt.dao.UserMapper">
  6.     <select id="findWhere" resultType="com.jt.pojo.User">
  7.         select *
  8.         from demo_user
  9.         where sex = #{sex}
  10.           and age = #{age};
  11.     </select>
  12. </mapper>

封装为Map集合

将多个参数封装为Map集合需要使用@Param注解，例如：List<User> findAge(@Param("minAge") int minAge, @Param("maxAge") int maxAge);@Param注解参数为Map集合中的key也即参数名称，value为参数值。

测试类：

  1. @SpringBootTest
  2. public class TestMybatis {
  3.     @Autowired
  4.     private UserMapper userMapper;
  5.     /*
  6.     查询：age<18 or age>100
  7.      */
  8.     @Test
  9.     public void testMybatis2() {
  10.         int minAge = 18;
  11.         int maxAge = 100;
  12.         List<User> users = userMapper.findAge(minAge, maxAge);
  13.         for (User user : users) {
  14.             System.out.println(user);
  15.         }
  16.     }
  17. }

DAO:

  1. package com.jt.dao;
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.jt.pojo.User;
  5. import org.apache.ibatis.annotations.Mapper;
  6. import org.apache.ibatis.annotations.Param;
  8. import java.util.List;
  10. @Mapper
  11. /*
  12. 继承BaseMapper接口必须添加泛型对象，否则映射表报错
  13. 自己创建的接口不要与接口方法重名
  14.  */
  15. public interface UserMapper extends BaseMapper<User> {
  16.     /*
  17.     mybatis原生只支持单值传参，
  18.     多值传参需要封装为单值
  19.     1.封装为对象
  20.     2.封装为Map集合
  21.     若为多值传参自动封装为Map集合key为参数名称，value为参数值
  22.      */
  23.     List<User> findAge(@Param("minAge") int minAge, @Param("maxAge") int maxAge);
  24. }

Mapper.XML

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.jt.dao.UserMapper">
  6.     <select id="findAge" resultType="com.jt.pojo.User">
  7.         select *
  8.         from demo_user
  9.         where age &lt; #{minAge}
  10.            or age > #{maxAge};
  11.     </select>
  12. </mapper>