Mybatis

m0_37706089

于 2023-07-10 09:14:24 发布

阅读量77

点赞数

文章标签： mybatis

本文链接：https://blog.csdn.net/m0_37706089/article/details/131512228

版权

Mybatis

MyBatis 介绍

MyBatis 支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
MyBatis 可以使用简单的 xml 或注解用于配置和原始映射，将接口和 java 的 POJO 映射成数据库中的记录
MyBatis 是一个半自动的 ORM (Object Relation Mapping) 框架

和其他持久层技术对比

JDBC
- SQL 夹杂在 Java 代码中耦合度高，导致硬编码内伤
- 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
- 代码冗长，开发效率低
Hibernate 和 JPA
- 操作简单，开发效率高
- 程序中的长难复杂 SQL 需要绕过框架
- 内部自动生产的 SQL，不容易做特殊化
- 基于全映射的自动框架，大量字段的 POJO 进行部分映射时比较困难
- 反射操作太多，导致数据库性能下降
MyBatis
- 轻量级，性能出色
- SQL 和 Java 编码分开，功能界面清晰。Java 代码专注业务、SQL 语句专注数据
- 开发效率稍逊与 Hibernate，但是完全能够接受

搭建 MyBatis

1.创建Maven工程并导入依赖

<dependencies>
    <!--MyBatis依赖-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.13</version>
    </dependency>
    <!--junit5单元测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.9.2</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
    <!--log4j2依赖-->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.20.0</version>
    </dependency>
</dependencies>

2.创建MyBatis核心配置文件

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

    <!--引入jdbc的properties文件，引入后可以使用${key}的方式范围value-->
    <properties resource="jdbc.properties"/>

    <!--
    typeAliases 设置类型别名，即为某个具体的类型设置一个别名（标签需要放到properties之后）
    设置之后，在MyBatis的范围中，就可以使用别名表示一个具体的类型
    -->
    <typeAliases>
        <!--
        typeAlias: 设置一个具体类型的别名
        type: 设置需要起别名的类型的全限定类名
        alias: 设置该类型的别名。如果不设置alias属性，当前的类型有默认的别名，默认值为类名且不区分大小写。
        -->
        <!--        <typeAlias type="cn.test.mybatis.pojo.User" alias="abc"/>-->

        <!--        <typeAlias type="cn.test.mybatis.pojo.User"/>-->

        <!--通过包来设置别名，指定包下的所有类型全部拥有默认的别名，即类名且不区分大小写-->
        <package name="cn.test.mybatis.pojo"/>
    </typeAliases>

    <!--
    environments 配置连接数据库的环境
    default: 默认使用的环境
    -->
    <environments default="development">
        <!--
        environment: 设置一个具体的连接数据库环境
        id: 设置环境的唯一标识，不能重复
        -->
        <environment id="development">
            <!--
            transactionManager: 设置事务管理器
            type: 设置事务管理的方式。
            type=JDBC: 表示使用JDBC原生的事务管理方式
            type=MANAGED: 被管理，例如Spring的声明式事务
            -->
            <transactionManager type="JDBC"/>
            <!--
            dataSource: 设置数据源
            type: 设置数据源的类型
            type=POOLED: 表示使用数据库连接池
            type=UNPOOLED: 表示不使用数据库连接池
            type=JNDI: 表示来使用上下文中的数据源
            -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClassName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>

        <!--测试环境-->
        <environment id="test">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--引入mybatis的映射文件-->
    <mappers>
        <!--        <mapper resource="mappers/UserMapper.xml"/>-->

        <!--
        package: 以包的方式引入映射文件，但是必须满足两个条件
        1. mapper接口和映射文件所在的包必须一致
        2. mapper接口的名字必须和映射文件的名字必须一致
        -->
        <package name="cn.test.mybatis.mapper"/>
    </mappers>
</configuration>

核心配置文件推荐命名为 mybatis-config.xml，该配置文件位于 src/main/resources 目录下

MyBatis 核心配置文件中的标签必须要按照指定的顺序配置:
properties、settings、typeAliases、typeHandler、
objectFactory、objectWrapperFactory、reflectorFactory、
plugins、environments、databaseIdProvider、mappers

3.创建Mapper接口

mybatis 中的 mapper 接口相当于以前的 dao，但区别在于 mapper 仅仅是接口，我们不需要提供实现类。

package cn.test.mybatis.mapper;

import cn.test.mybatis.pojo.User;

public interface UserMapper {

    int insertUser();

    int updateUser();

    int deleteUser();

    User getUserById(Integer id);
    
    List<User> getAllUsers();
}

4.创建Mybatis映射文件

相关概念：ORM (Object Relationship Mapping) 对象关系映射

对象：Java 的实体类对象
关系：关系型数据库
映射：二者之间存在对应关系

Java概念	数据库概念
类	表
属性	字段/列
对象	记录/行

(1)映射文件的命名规则：

表所对应的实体类的类名+Mapper.xml

例如：表 t_user，映射的实体类为 User，所对应的映射文件为 UserMapper.xml

一个映射文件对应一个实体类，对应一张表的操作

MyBatis 映射文件用于编写 SQL，访问以及操作表中的数据

MyBatis 映射文件存放的位置是 src/main/resources/mappers目录下

(2)MyBatis 中可以面向接口操作数据，要保证两个一致：

mapper 接口的全类名要和映射文件的 namespace 一致
mapper 接口中的方法名和映射文件中的 sql 的 id 一致

Mapper 映射文件编写完成后需要在 Mybatis 的核心配置文件中使用 <mapper> 标签进行引入

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.test.mybatis.mapper.UserMapper">
<!--    mapper接口和映射文件要保证两个一致-->
<!--    1.mapper接口的全类名要和映射文件的namespace一致-->
<!--    2.mapper接口中的方法名和映射文件中的sql的id一致-->
   <insert id="insertUser">
       insert into t_user(username,password,age,gender,email) values('admin','123456',18,'男','123@qq.com')
   </insert>

    <update id="updateUser">
        update t_user
        set username='test',password='6666'
        where id=2
    </update>

    <delete id="deleteUser">
        delete from t_user
        where id = 7
    </delete>

    <!--    resultType: 设置结果类型，即查询的数据要转换为Java的类型-->
	<!--    resultMap: 自定义类型，处理多对一或一对多的映射关系-->
    <select id="getUserById" resultType="cn.test.mybatis.pojo.User">
        select * from t_user
        where id = #{id}
    </select>
    
    <select id="getAllUsers" resultType="cn.test.mybatis.pojo.User">
        select * from t_user
    </select>
</mapper>

5.添加MyBatis日志

这里使用了 log4j2 日志，在 src/main/resources 目录下创建 log4j2.xml 文件。( log4j2 的依赖见第一步导入依赖)

<?xml version="1.0" encoding="UTF-8"?>
<Configuration xmlns="http://logging.apache.org/log4j/2.0/config">

    <Appenders>
        <Console name="stdout" target="SYSTEM_OUT">
            <PatternLayout pattern="%5level [%t] - %msg%n"/>
        </Console>
    </Appenders>

    <Loggers>
        <Logger name="cn.test.mybatis.mapper" level="debug"/>
        <Root level="error" >
            <AppenderRef ref="stdout"/>
        </Root>
    </Loggers>

</Configuration>

6.测试Mapper中的方法

package cn.test.mybatis.test;

import cn.test.mybatis.mapper.UserMapper;
import cn.test.mybatis.pojo.User;
import cn.test.mybatis.utils.SqlSessionUtil;
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 org.junit.jupiter.api.Test;

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

public class MybatisTest {

    @Test
    public void testInsert() throws IOException {
        //1. 读取mybatis的配置文件
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        //2. 通过SqlSessionFactoryBuilder创建SqlSessionFactory对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(inputStream);
        //3. 开启SqlSession，并设置自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //4. 获取mapper的代理类对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //5. 调用UserMapper的insertUser方法
        int result = userMapper.insertUser();
        System.out.println("result: " + result);
        //6. 关闭sqlSession
        sqlSession.close();
    }

    @Test
    public void testUpdate() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        sqlSession.getMapper(UserMapper.class).updateUser();
        sqlSession.close();
    }


    @Test
    public void testDelete() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        sqlSession.getMapper(UserMapper.class).deleteUser();
        sqlSession.close();
    }

    @Test
    public void testGetUserById() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        User user = sqlSession.getMapper(UserMapper.class).getUserById(1);
        System.out.println("User: " + user);
        sqlSession.close();
    }
    
    @Test
    public void testGetAllUsers() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        List<User> userList = sqlSession.getMapper(UserMapper.class).getAllUsers();
        userList.forEach(System.out::println);
        sqlSession.close();
    }

}

package cn.test.mybatis.utils;

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;

public class SqlSessionUtil {

    private static SqlSessionFactory sqlSessionFactory;

   static {
       InputStream inputStream = null;
       try {
           //1. 读取mybatis的配置文件
           inputStream = Resources.getResourceAsStream("mybatis-config.xml");
           //2. 通过SqlSessionFactoryBuilder创建SqlSessionFactory对象
           SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
           sqlSessionFactory = builder.build(inputStream);
       } catch (IOException e) {
           throw new RuntimeException(e);
       }
   }

    public static SqlSession getSqlSession(){
        //3. 开启SqlSession，并设置自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        return sqlSession;
    }
}

7.在idea添加MyBatis的相关模板

点击 idea 的 Settings --> Editor --> File and Code Templates，在 Files 选项下点击 + 号，填写模板名称和模板文件的后缀，再将模板内容复制到内容区域

MyBatis 核心配置文件模板

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="jdbc.properties"/>

    <typeAliases>
        <package name=""/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClassName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--引入mybatis的映射文件-->
    <mappers>
        <package name=""/>
    </mappers>
</configuration>

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">
<mapper namespace="">

</mapper>

MyBatis获取参数值的两种形式

MyBatis 获取参数值的两种方式：${} 和 #{}

${} 的本质就是字符串拼接，#{} 的本质就是占位符赋值

${} 使用字符串拼接的方式拼接 sql，如果为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；

但是 #{} 使用占位符赋值的方式拼接 sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号。

单个字面量类型的参数

如果 mapper 接口中的方法参数为单个的字面量类型

此时可以使用 ${} 和 #{} 以任意的名称获取参数的值，注意 ${} 需要手动加单引号。如：'$ {username}’

多个字面量类型的参数

如果 mapper 接口中的方法参数为多个时，此时 MyBatis 会自动将这些参数放在一个 map 集合中，以 arg0、arg1 … 为键，以参数为值；以 param1、param2… 为键，以参数为值；因此只需要通过 ${} 和 #{} 访问 map 集合的键就可以获取相对应的值，注意 ${} 需要手动添加单引号

mapper 接口中的方法参数类型是 map

如果 mapper 接口中的方法参数类型是 map ，只需要通过 ${} 和 #{} 访问 map 集合的键，就可以获取相应的值，一点要注意 ${} 单引号问题

mapper 接口中的方法参数类型是Java对象类型

如果 mapper 接口方法的参数为实体类类型的参数，只需要通过 ${} 和 #{} 访问实体类中的属性，就可以获取相对应的属性值，一点要注意 ${} 单引号问题

使用@Param注解标注的mapper方法参数

如果使用 @Param 注解标注的 mapper 方法的参数，可以通过 ${} 和 #{} 访问 @Param 注解的 value 属性值，就可以获取相对应的属性值，一点要注意 ${} 单引号问题

还可以使用 param1，param2… 参数为值来获取相对应的属性值

MyBatis的各种查询功能

1.查询一个对象

User getUserById(Integer id);

<select id="getUserById" resultType="User">
    select * from t_user
    where id = #{id}
</select>

2.查询一个list集合

List<User> getAllUsers();

<select id="getUserById" resultType="User">
    select * from t_user
</select>

当查询的数据为多条时，不能使用实体类作为返回值，否则会抛出 TooManyResultsException；但是如果查询的数据只有一条，就可以使用实体类或集合作为返回值

3.查询单个数据

Integer getCount();

<!--resultType这里使用了MyBatis提供的别名-->
<select id="getCount" resultType="integer">
    select count(*) from t_user
</select>

MyBatis 提供了一些为常见的 Java 类型内建的类型别名。它们都是不区分大小写的

别名	映射的类型
_int	int
_integer	int
string	String
int	Integer
integer	Integer
map	Map
list	List

4.查询一个map集合

查询一条数据为 map 集合

Map<String, Object> getUserByIdToMap(@Param("id") Integer id);

<!--    Map<String,Object> getUserByIdToMap(@Param("id") Integer id);-->
<select id="getUserByIdToMap" resultType="map">
    select * from t_user where id = #{id}
</select>

查询多条数据为 map 集合

List<Map<String, Object>> getAllUsersToMap();

@MapKey("id")
Map<String, Object> getAllUsersToMap2();

<!--    List<Map<String,Object>> getAllUsersToMap();-->
<select id="getAllUsersToMap" resultType="map">
    select * from t_user
</select>
<!--    Map<String, Object> getAllUsersToMap2();-->
<select id="getAllUsersToMap2" resultType="map">
    select * from t_user
</select>

查询多条数据且返回类型需要是 map 集合时，有以下两种方式

将 mapper 接口方法的返回设置成 List<Map<String, Object>> 类型
可以将每条数据转换的 map 集合放到一个大的 map 集合中，但是必须使用 @MapKey 指定每条数据对应的 key

特殊 SQL 的执行

1.模糊查询

List<User> getUserByLike(@Param("keyword") String keyword);

<!--    List<User> getUserByLike(@Param("keyword") String keyword);-->
<select id="getUserByLike" resultType="User">
    <!--        select * from t_user where username like '%${keyword}%'-->
    <!--        select * from t_user where username like concat('%',#{keyword},'%')-->
    select * from t_user where username like "%"#{keyword}"%"
</select>

可以使用 ${} 、concat、“” 方式来进行拼接

2.批量删除

void deleteMoreUser(@Param("ids") String ids);

<delete id="deleteMoreUser">
    delete from t_user where id in(${ids})
</delete>

3.动态表名

List<User> getUserList(@Param("tableName") String tableName);

<!--    List<User> getUserList();-->
<select id="getUserList" resultType="User">
    select * from ${tableName}
</select>

4.添加功能获取自增的主键

void insertUserAndReturnKey(User user);

<!--
useGeneratedKeys: 表示当前添加功能使用了自增的主键
keyProperty: 将添加的数据的自增主键为实体类型的参数的属性赋值
-->
<insert id="insertUserAndReturnKey" useGeneratedKeys="true" keyProperty="id">
    insert into t_user(username,password,age,gender,email)
    values (#{username},#{password},#{age},#{gender},#{email})
</insert>

自定义映射resultMap

1. resultMap处理字段和属性的映射关系

如果字段名和实体类中的属性名不一致，可以通过 resultMap 设置自定义的映射

List<Emp> getEmpList();

<!--
resultMap: 设置自定义的映射关系
id: 唯一标识
type: 处理映射关系的实体类型
常用标签:
id: 处理主键和实体类中属性的映射关系
result: 处理普通字段和实体类中属性的映射关系
标签中的属性:
column: 设置映射关系中的字段名，必须是sql查询出的某个字段
property: 设置映射关系中的属性的属性名，必须是处理的实体类类型中的属性名
-->
<resultMap id="empResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="dept_id" property="deptId"></result>
</resultMap>

<select id="getEmpList" resultMap="empResultMap">
    select * from t_emp
</select>

如果只是下划线与驼峰的关系，可以使用以下方式

<!--
字段名和属性名不一致的情况，可以使用以下方式处理:
1. 为查询字段设置别名，别名和属性名保持一致
2. 当字段符合MySQL的要求使用 _ ，而属性符合java的要求使用驼峰
   此时可以在MyBatis的核心配置文件中设置一个全局配置，可以自动将下划线映射为驼峰
   mapUnderscoreToCamelCase=true
-->
<!--    List<Emp> getEmpList();-->
<select id="getEmpList" resultType="Emp">
    select * from t_emp
</select>

MyBatis的核心配置文件中设置mapUnderscoreToCamelCase属性

<settings>
    <!--是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。-->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

多对一的映射关系

1.使用级联方式

Emp getEmpById(@Param("id") Integer id);

<resultMap id="empAndDeptResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="gender" property="gender"></result>
    <result column="age" property="age"></result>
    <result column="dept_id" property="dept.deptId"></result>
    <result column="dept_name" property="dept.deptName"></result>
</resultMap>
<!--    Emp getEmpById(@Param("id") Integer id);-->
<select id="getEmpById" resultMap="empAndDeptResultMap">
    select * from t_emp
    left join t_dept
    on t_emp.dept_id = t_dept.dept_id
    where t_emp.emp_id = #{id}
</select>

2.使用 association 标签

association 处理多对一的映射关系（处理实体类类型的属性）

Emp getEmpById(@Param("id") Integer id);

<resultMap id="empAndDeptResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="gender" property="gender"></result>
    <result column="age" property="age"></result>
    <result column="dept_id" property="deptId"></result>
    <association property="dept" javaType="Dept">
        <id column="dept_id" property="deptId"></id>
        <result column="dept_name" property="deptName"></result>
    </association>
</resultMap>
<!--    Emp getEmpById(@Param("id") Integer id);-->
<select id="getEmpById" resultMap="empAndDeptResultMap">
    select * from t_emp
    left join t_dept
    on t_emp.dept_id = t_dept.dept_id
    where t_emp.emp_id = #{id}
</select>

3.分布查询

分布查询第 2 步的 maper 方法与映射

Dept getDeptById(@Param("deptId") Integer deptId);

<!--    Dept getDeptById(@Param("deptId") Integer deptId);-->
<select id="getDeptById" resultType="Dept">
    select *
    from t_dept
    where dept_id = #{deptId}
</select>

分布查询第 1 步的 maper 方法与映射

Emp getEmpById(@Param("id") Integer id);

<resultMap id="empAndDeptByStepResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="gender" property="gender"></result>
    <result column="age" property="age"></result>
    <result column="dept_id" property="deptId"></result>
    <!--        
    property: 设置需要处理映射关系的属性的属性名
    select: 设置分布查询的sql的唯一标识
    column: 将查询出的结果的某个字段作为分布查询的sql的条件
    -->
    <association property="dept" select="cn.test.mybatis.mapper.DeptMapper.getDeptById"
                 column="dept_id"></association>
</resultMap>

<select id="getEmpById" resultMap="empAndDeptByStepResultMap">
    select *
    from t_emp
    where emp_id = #{id}
</select>

分布查询的优点：可以实现延迟加载

但必须在核心配置文件中设置全局配置信息

lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载

aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载

此时就可以实现按需加载，获取的数据是什么，就只会执行相应的 sql。此时可通过 association 和 collection 中的 fetchType 属性设置当前的分布查询是否使用延迟加载。

fetchType=“lazy” 表示延迟加载；fetchType=“eager” 表示立即加载

一对多的映射关系

1. 使用 collection

Dept getDeptAndEmpById(@Param("deptId") Integer deptId);

<resultMap id="deptAndEmpResultMap" type="Dept">
    <id column="dept_id" property="deptId"></id>
    <result column="dept_name" property="deptName"></result>
    <!--
    collection: 处理一对多的映射
    ofType: 设置集合中存放数据的类型
    -->
    <collection property="empList" ofType="Emp">
        <id column="emp_id" property="empId"></id>
        <result column="emp_name" property="empName"></result>
        <result column="gender" property="gender"></result>
        <result column="age" property="age"></result>
        <result column="dept_id" property="deptId"></result>
    </collection>
</resultMap>
<!--    Dept getDeptAndEmpById(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpById" resultMap="deptAndEmpResultMap">
    select *
    from t_dept
             left join t_emp on t_dept.dept_id = t_emp.dept_id
    where t_dept.dept_id = #{deptId}
</select>

2.使用分步查询

分布查询第 2步的 maper 方法与映射

List<Emp> getEmpListByDeptId(@Param("deptId") Integer deptId);

<!--    List<Emp> getEmpListByDeptId(@Param("deptId") Integer deptId);-->
<select id="getEmpListByDeptId" resultType="Emp">
    select *
    from t_emp
    where dept_id = #{deptId}
</select>

分布查询第 1 步的 maper 方法与映射

Dept getDeptAndEmpById2(@Param("deptId") Integer deptId);

<resultMap id="deptAndEmpResultMap2" type="Dept">
    <id column="dept_id" property="deptId"></id>
    <result column="dept_name" property="deptName"></result>
    <collection property="empList" select="cn.test.mybatis.mapper.EmpMapper.getEmpListByDeptId" column="dept_id"></collection>
</resultMap>
<!--    Dept getDeptAndEmpById(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpById2" resultMap="deptAndEmpResultMap2">
    select *
    from t_dept
    where dept_id = #{deptId}
</select>

动态SQL

MyBatis 框架的动态 SQL 技术是一种根据特定条件动态拼接 SQL 语句的功能，它存在的意义是为了解决拼接SQL 语句字符串时的痛点问题。

1.if

if 标签可以test属性的表达式进行判断，如果表达式的结果为true，则标签中的内容会执行。反之不会执行

2.where

如果where标签中有条件成立，会自动生成关键字
会自动将where标签中内容前多余的and去掉，但是其中内容后面的and不会去掉
如果where标签中没有任何条件成立，则where标签没有任何功能

List<Emp> getEmpByCondition(Emp emp);

<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
   <where>
       <if test="empName != null and empName != ''">
           emp_name = #{empName}
       </if>
       <if test="age != null and age != ''">
           and age = #{age}
       </if>
       <if test="gender != null and gender != ''">
           and gender = #{gender}
       </if>
   </where>
</select>

3.trim

prefix、suffix：在标签中内容前面或内容后面添加指定内容

prefixOverrides、suffixOverrides：在标签中内容前面或内容后面去掉指定内容

<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
    <trim prefix="where" suffixOverrides="and">
        <if test="empName != null and empName != ''">
            emp_name = #{empName} and
        </if>
        <if test="age != null and age != ''">
            age = #{age} and
        </if>
        <if test="gender != null and gender != ''">
            gender = #{gender}
        </if>
    </trim>
</select>

4.choose、when、otherwise

相当于 java 中的 if…else if …else

when至少有一个，otherwise 最多只有一个

List<Emp> getEmpByChoose(Emp emp);

<!--    List<Emp> getEmpByChoose(Emp emp);-->
<select id="getEmpByChoose" resultType="Emp">
    select * from t_emp
    <where>
        <choose>
            <when test="empName != null and empName != ''">
                emp_name = #{empName}
            </when>
            <when test="age != null and age != ''">
                age = #{gender}
            </when>
            <when test="gender != null and gender != ''">
                gender = #{gender}
            </when>
        </choose>
    </where>
</select>

5.foreach

Mapper 的方法中的参数如果为 List，MyBatis 默认以 list 为键，参数为值放到 map 集合中，在 Mapper.xml 中使用时以 list 来获取

Mapper 的方法中的参数如果为 Array，MyBatis 默认以 array 为键，参数为值放到 map 集合中，在 Mapper.xml 中使用时以 array 来获取

可以使用 @Param 注解的 value 属性来设置自定义 key，在 Mapper.xml 中使用时以自定义的 key 来获取

void insertMoreEmp(@Param("emps") List<Emp> emps);

<!--    void insertMoreEmp(List<Emp> emps);-->
<insert id="insertMoreEmp">
    insert into t_emp (emp_name,age,gender) values
    <foreach collection="emps" item="emp" separator=",">
       (#{emp.empName},#{emp.age},#{emp.gender})
    </foreach>
</insert>

批量删除

foreach 标签的 open 设置语句开始的字符串，close 设置语句结束的字符串。

collection：设置需要循环的数组或集合

item：用一个字符串表示数组或集合中的每一项

separator：设置每次循环的数据之间的分割符

void deleteMoreEmp(@Param("empIds") Integer[] empIds);

<!--    void deleteMoreEmp(@Param("empIds") Integer[] empIds);-->
<delete id="deleteMoreEmp">
    delete
    from t_emp
    where emp_id in
    <foreach collection="empIds" item="empId" separator="," open="(" close=")">
        #{empId}
    </foreach>
</delete>

6.sql

sql 片段，可以使用 include 标签来引用该 sql 片段

<sql id="empColumns">
	emp_id,emp_name,age,gender,dept_id
</sql>

<select id="getEmpByCondition" resultType="Emp">
    select <include refid="empColumns"></include> from t_emp
    <trim prefix="where" suffixOverrides="and">
        <if test="empName != null and empName != ''">
            emp_name = #{empName} and
        </if>
        <if test="age != null and age != ''">
            age = #{age} and
        </if>
        <if test="gender != null and gender != ''">
            gender = #{gender}
        </if>
    </trim>
</select>

MyBatis 的缓存

1.MyBatis的一级缓存

一级缓存是 SqlSession 级别的，通过同一个 SqlSession 查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接读取，不会从数据库重新访问

使用一级缓存失效的四种情况：

不同的 SqlSession 对应不同的一级缓存。
同一个 SqlSession 但查询条件不同
同一个 SqlSession 两次查询期间执行了任何一次增删改操作
同一个 SqlSession 两次查询期间手动清空了缓存

2.MyBatis的二级缓存

二级缓存是 SqlSessionFactory 级别的，通过同一个 SqlSessionFactory 创建的 SqlSession 的查询结果会被缓存；此后如果再次执行相同的查询语句，结果从缓存中获取

二级缓存开启的条件：

在核心配置文件中，设置全局配置属性 cacheEnabled=“true”，默认为 true，不需要设置。
在映射文件中设置标签 <cache/>
二级缓存必须在 SqlSession 关闭或提交后有效
查询的数据转换的实体类类型必须实现序列化的接口

二级缓存失效的情况：

两次查询期间执行了任何一次增删改操作，会使一级和二级缓存同时失效。

3.二级缓存的相关配置

在 mapper 配置文件中添加 cache 标签可以设置一些属性：

eviction 属性：缓存回收策略，默认是 LRU。

LRU (Least Recently Used) 最近最少使用的：移除最长时间不被使用的对象

FIFO (First in First out) 先进先出：按对象进入缓存的顺序来移除它们

SOFT 软引用：移除基于垃圾收集器状态和弱引用规则的对象
flushInterval 属性：刷新间隔，单位毫秒

默认情况是不设置，也就是没有刷新间隔，缓存仅仅是调用语句时刷新
size 属性：引用数目，正整数

代表缓存最多可以存储多少个对象，太大容易导致内存溢出
readOnly 属性：只读，true、false

true：只读缓存，会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改，这提供了很重要的性能优势

false：读写缓存，会返回缓存对象的拷贝（通过序列化），这会慢一些，因此默认是 false

4. MyBatis缓存查询的顺序

先查二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用
如果二级缓存没有命中，再查一级缓存
如果一级缓存也没有命中，则查询数据库
SqlSession 关闭后，一级缓存中的数据会写入二级缓存中

5.整合第三方缓存EHCache

MyBatis的逆向工程

正向工程：先创建Java实体类，由框架赋值根据实体类生成数据表。Hidernate 是支持正向工程的

逆向工程：先创建数据库表，由框架赋值根据数据库表，反向生成如下资源：

Java 实体类
Mapper 接口
Mapper 映射文件

1.创建逆向工程的步骤

1. 添加依赖

依赖

<dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.9.2</version>
        </dependency>

        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <!--log4j2依赖-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.20.0</version>
        </dependency>

    </dependencies>

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

                <dependencies>
                    <dependency>
                        <groupId>org.mybatis.generator</groupId>
                        <artifactId>mybatis-generator-core</artifactId>
                        <version>1.3.2</version>
                    </dependency>

                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.33</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

2.创建MyBatis核心配置文件

3.创建逆向工程的配置文件

文件名必须是：generatorConfig.xml

generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>

    <!-- 数据库驱动:选择你的本地硬盘上面的数据库驱动包 -->
    <!--    <classPathEntry  location="D:\maven-warehouse\repository\mysql\mysql-connector-java\5.1.47\mysql-connector-java-5.1.47.jar"/>-->
    <!-- <classPathEntry  location="D:\maven-warehouse\repository\mysql\mysql-connector-java\8.0.17\mysql-connector-java-8.0.17.jar"/> -->

    <context id="DB2Tables" targetRuntime="MyBatis3">
        <!-- 实体类生成序列化属性-->
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>
        <!-- 实体类重写HashCode()和equals()-->
        <plugin type="org.mybatis.generator.plugins.EqualsHashCodePlugin"/>
        <!-- 实体类重写toString() -->
        <plugin type="org.mybatis.generator.plugins.ToStringPlugin"/>

        <commentGenerator>
            <!-- 是否去除自动生成的注释 -->
            <property name="suppressAllComments" value="true"/>
            <!-- 生成注释是否带时间戳-->
            <property name="suppressDate" value="true"/>
            <!-- 生成的Java文件的编码格式 -->
            <property name="javaFileEncoding" value="utf-8"/>
            <!-- 格式化java代码-->
            <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
            <!-- 格式化XML代码-->
            <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
        </commentGenerator>

        <!-- 数据库连接驱动类,URL，用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://127.0.0.1:3306/ssm?useUnicode=true&amp;characterEncoding=UTF-8"
                        userId="root" password="123456">
        </jdbcConnection>

        <!-- java类型处理器：处理DB中的类型到Java中的类型 -->
        <javaTypeResolver type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl">
            <!-- 是否有效识别DB中的BigDecimal类型 -->
            <property name="forceBigDecimals" value="true"/>
        </javaTypeResolver>

        <!-- 生成Domain模型：包名(targetPackage)、位置(targetProject) -->
        <javaModelGenerator targetPackage="cn.test.mybatis.pojo" targetProject=".\src\main\java">
            <!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false -->
            <property name="enableSubPackages" value="true"/>
            <!-- 设置是否在getter方法中，对String类型字段调用trim()方法-->
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>

        <!-- 生成xml映射文件：包名(targetPackage)、位置(targetProject) -->
        <sqlMapGenerator targetPackage="cn.test.mybatis.mapper" targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>

        <!-- 生成DAO接口：包名(targetPackage)、位置(targetProject) -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="cn.test.mybatis.mapper" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

        <!-- 要生成的表：tableName - 数据库中的表名或视图名，domainObjectName - 实体类名 -->
        <table tableName="t_emp" domainObjectName="Emp"></table>

        <table tableName="t_dept" domainObjectName="Dept"></table>

    </context>
</generatorConfiguration>

**在侧边栏 maven 中找到当前的 mudole，在 Plugins 中找到 mybatis-generator 下的 mybatis-generator:generate 点击它就能生成对应的 java bean、mapper 以及 example 文件 **

注意：点击 mybatis-generator:generate 前先确定数据库的表是否已经创建了

分页插件

1.添加依赖

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
</dependency>

2.配置分页插件

在 Mybatis 的核心配置文件中配置插件

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

3.分页插件的使用

在查询功能之前使用 PageHelper.startPage(int pageNum, int pageSize) 开启分页功能

pageNum 当前的页面
pageSize 每页显示的条数
size 当前页显示的真实条数
total 总记录数
pages 总页数
prePage 上一页的页码
nextPage 下一页的页码
isFirstPage/isLastPage：是否为第一页/最后一页
hasPreviousPage/hasNextPage：是否有上一页/下一页
navigatePages 导航分页的页码数
navigatepageNums 导航分页的页码 [1,2,3,4,5]

@Test
public void testGetEmpByCondition2(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
    //查询功能之前开启分页功能
    Page<Object> page = PageHelper.startPage(1, 4);
    List<Emp> empList = mapper.getEmpByCondition(null);
    //查询功能之后可以获取相关的所有数据
    PageInfo<Emp> list = new PageInfo<>(empList,2);
    System.out.println(page);
    System.out.println("-----------------------");
    System.out.println(list);
    sqlSession.close();
}

m0_37706089

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Mybatis

MybatisMyBatis 介绍MyBatis 支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集MyBatis 可以使用简单的 xml 或注解用于配置和原始映射，将接口和 java 的 POJO 映射成数据库中的记录MyBatis 是一个半自动的 ORM (Object Relation Mapping) 框架和其他持久层技术对比JDBCSQL 夹杂在 Java 代码中耦合度高，导致硬编码内伤
复制链接

扫一扫