Mybatis学习笔记整理

2024-02-11 18:12:46

MyBatis

环境:

JDK 1.8
MySQL 5.7
Maven 3.6.3
IDEA

知识基础：

JDBC
MySQL
Java基础
Maven
Junit

学习框架一般都有配置文件，学会看官网文档。

MyBatis官网：https://mybatis.org/mybatis-3/zh/index.html

官网非常重要！！！！！请学会去官方找文档资料，这个还是有中文的，后面的框架就都是英文文档了！！！

1、简介

1.1 什么是MyBatis

MyBatis 是一款优秀的持久层框架。
支持定制化SQL、存储过程和高级映射
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了[google code](https://baike.baidu.com/item/google code/2346604)，并且改名为MyBatis 。2013年11月迁移到Github。
最新版本是MyBatis 3.5.6 ，其发布时间是2020年10月6日

如何获取MyBatis？

Maven :https://mvnrepository.com/artifact/org.mybatis/mybatis

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
</dependency>

Github https://github.com/mybatis/mybatis-3

中文文档：https://mybatis.org/mybatis-3/zh/index.html

1.2持久化

数据持久化

持久化就是将程序的数据在持久状态和瞬时状态转化的过程
内存：断电即失
数据库（JDBC），IO文件持久化。存入外部存储介质：硬盘、光盘等

为什么需要持久化

有一些对象不希望断电丢失：支付宝里的账户信息、银行存款...
内存同容量比硬盘贵，同时耗电较高

1.3持久层

常见的层次分类：Dao层、Service层、Controller层

完成持久化工作的代码块
层界限十分明显

1.4为什么需要MyBatis

传统的JDBC代码较复杂，需要简化
可以实现部分自动化配置
帮助程序猿将数据存入到数据库
不用MyBatis也可以，技术没有高低之分
MyBatis较容易上手，同时目前比较流行，使用的人较多

Spring、 SpringMVC、 SpringBoot
优点：
- 简单易学
- 灵活
- 解除SQL与代码的耦合，提高了可维护性
- 提供映射标签，支持对象与数据库的ORM字段关系映射
- 提供对象关系映射标签，支持对象关系组建维护
- 提供xml标签，支持编写动态SQL

2、第一个Mybatis程序

思路：

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

2.1搭建环境

搭建数据库

-- 创建数据库 `Mybatis`
CREATE DATABASE `MyBatis`;
-- 选中数据库
USE `Mybatis`;
-- 创建一张`users`表
CREATE TABLE `users`(
   `id` INT(10) NOT NULL AUTO_INCREMENT,
   `name` VARCHAR(30) NOT NULL,
   `password` VARCHAR(30) NOT NULL,
   PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET='utf8';
-- 插入3条数据
INSERT INTO `users`(`id`,`name`,`password`) VALUES ('1','张三','123456'),('2','李四','123456'),('3','王五','123456');

结果：

新建项目

新建一个Maven普通项目
删除src目录
导入依赖

不适用任何模板：

选择项目路径：

删除src目录，整个项目作为父工程，注意IDEA配置使用自有Maven。

导入依赖：pom.xml文件中导入需要的jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!--父工程-->
    <groupId>com.dachuan</groupId>
    <artifactId>Mybatis-Demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--导入依赖-->
    <dependencies>
        <!--MySQL驱动-->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <!--MyBatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <!--Junit-->
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

2.2创建一个模块

编写Mybatis的核心配置文件
编写MyBatis的工具类
编写代码

配置参考官方：https://mybatis.org/mybatis-3/zh/getting-started.html

首先创建一个子模块

编写Mybatis的核心配置文件

在resources文件夹下创建一个mybatis-config.xml配置文件

<?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核心配置文件 -->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>  <!-- 默认JDBC事务，学过 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/> <!-- 驱动位置，类似于JDBC学过内容 -->
                <!--修改url-->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8"/>
                <!--用户名和密码-->
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!-- 每一个Mapper.xml都需要在Mybatis核心配置文件中注册！ -->
        <mapper resource="com/dachuan/dao/UserMapper.xml"/>
    </mappers>
</configuration>

编写MyBatis工具类

创建包com.dachuan.utils，并在包中创建工具类MyBatisUtils，编写工具类代码。

把资源加载进来
创建一个能执行SQL的对象

package com.dachuan.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;

//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) {
            e.printStackTrace();
        }

    }
    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例
    //SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

2.3编写代码

实体类
DAO接口
接口实现类

编写实体类

实体类 User放在pojo包下,toString方法一定要，为了验证！

package com.dachuan.pojo;

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 + '\'' +
                '}';
    }
}

编写DAO接口类

接口类UserDao放在dao包下

package com.dachuan.dao;

import com.dachuan.pojo.User;

import java.util.List;

public interface UserDao {
    //定义方法，返回值为List<User>,方法名getUserList,获取查询结果
    List<User> getUserList();
}

接口实现类

由原来的UserDaoImpl转变成一个UserMapper配置文件，放在dao包下，注意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">
<!--绑定一个对应的Dapper/Mapper接口-->
<mapper namespace="com.dachuan.dao.UserDao">
    <!--select查询语句-->
    <!--id是方法名-->  <!--返回结果是单个用resultType，集合就是Map-->
    <select id="getUserList" resultType="com.dachuan.pojo.User">
        select * from users
    </select>
</mapper>

2.4测试

注意点：

org.apache.ibatis.binding.BindingException: Type interface com.dachuan.dao.UserDao is not known to the MapperRegistry.
- 需要在核心配置文件mybaties-config.xml中写mapper
```
<mappers>
    
    <mapper resource="com.dachuan.dao.UserMapper.xml"></mapper>
</mappers>
```

The error may exist in com.dachuan.dao.UserMapper.xml

Maven默认无法导出配置文件，在build中加入配置使得配置文件可以被导出。

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

junit测试

注意测试类尽量放置在与原始类相同的目录，这里UserDaoTest类放在com.dachuan.dao下

package com.dachuan.dao;

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

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //第一步获取sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一:Mapper 执行SQL
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
}

常见问题1：

###Error building SqlSession

查看XML配置文件
常见错误
- XML中有中文注释，可以删掉注释/将头部UTF-8改成utf8/将IDEA默认编码改成UTF-8
- Mybatis-config.xml中mapper的路径设置，是/不是.。
```
   <mappers>
        <mapper resource="com/dachuan/dao/UserMapper.xml"/>
    </mappers>
```

常见问题2：

结果显示为指针

com.dachuan.pojo.User@2698dc7
com.dachuan.pojo.User@43d7741f
com.dachuan.pojo.User@17baae6e

pojo实体类user未重写toString方法，添加上即可。

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

3、CRUD

3.1namespace

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

3.2select

选择、查询语句；

id：就是对应的namespace中的方法名；
resultType：Sql语句执行的返回值！
parameterType：参数类型！

3.3查询

接口类UserMapper：创建一个根据ID查询用户的方法。

    //根据ID查询用户
    User getUserById(int id);

UserMapper.xml:添加SQL语句。使用#{}可以填入变量

<select id="getUserById" parameterType="int" resultType="com.dachuan.pojo.User">
    select * from mybatis.users where `id` = #{id}
</select>

编写测试类UserMapperTest

@Test
public void getUserById(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = userMapper.getUserById(1);
    System.out.println(user);
    sqlSession.close();
}

3.4添加

接口类UserMapper：创建一个插入用户的方法。

//Insert一个用户
int addUser(User user);

UserMapper.xml:添加SQL语句。使用#{}可以填入变量

<insert id="addUser" parameterType="com.dachuan.pojo.User" >
    insert into users(`id`,`name`,`password`) values (#{id},#{name},#{password})
</insert>

编写测试类UserMapperTest，注意增删改需要提交事务才能生效！

//增删改需要提交事务
@Test
public void addUser(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    int res = userMapper.addUser(new User(4,"大川","123456"));
    if(res>0){
        System.out.println("插入成功");
    }
    //提交事务
    sqlSession.commit();
    //关闭会话
    sqlSession.close();
}

3.5修改

接口类UserMapper：创建一个修改用户的方法。

//修改用户
int updateUser(User user);

UserMapper.xml:添加SQL语句。使用#{}可以填入变量

<update id="updateUser" parameterType="com.dachuan.pojo.User" >
    update users set name=#{name},password=#{password} where id=#{id}
</update>

编写测试类UserMapperTest，注意增删改需要提交事务才能生效！

@Test
public void updateUser(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    int res = userMapper.updateUser(new User(4,"小川","111111"));
    if(res>0){
        System.out.println("修改成功");
    }
    //提交事务
    sqlSession.commit();
    //关闭会话
    sqlSession.close();
}

3.6删除

接口类UserMapper：创建一个删除用户的方法。

//删除一个用户
int deleteUser(int id);

UserMapper.xml:添加SQL语句。使用#{}可以填入变量

<delete id="deleteUser" parameterType="int" >
    delete from users where id=#{id}
</delete>

编写测试类UserMapperTest，注意增删改需要提交事务才能生效！

@Test
public void deleteUser(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    int res = userMapper.deleteUser(4);
    if(res>0){
        System.out.println("删除成功");
    }
    //提交事务
    sqlSession.commit();
    //关闭会话
    sqlSession.close();
}

3.7万能的Map

可以利用map对象代替实体类对象来实现传参，这样在参数较多情况下更灵活。尤其在修改参数、查询等操作上。

当有多个参数时，常用的有Map及注解。

接口类：

    //Insert一个用户
    int addUser2(Map<String,Object> map);

测试类：

 @Test
    public void addUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("userID","5");
        map.put("userName","李白");
        map.put("userPassword","123456");
        int res = userMapper.addUser2(map);
        if(res>0){
            System.out.println("插入成功");
        }
        //提交事务
        sqlSession.commit();
        //关闭会话
        sqlSession.close();
    }

4、配置解析

官网文档地址：https://mybatis.org/mybatis-3/zh/configuration.html

4.1核心配置文件

官方默认推荐名字：Mybatis-config.xml

configuration（配置）

properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
- environment（环境变量）
- transactionManager（事务管理器）
- dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

MyBatis可以配置成适应多种环境

但是每个SqlSessionFactory实例只能选择一种环境。

学会使用配置多套运行环境

配置复习：创建一个新的Module:Mybatis02。

注意xml文件标签是有顺序的只能按上面的顺序来写。

4.2配置环境 environments

MyBatis默认的事务管理器：JDBC，连接池：POOLED

<transactionManager type="JDBC"/> <!--type="[JDBC|MANAGED]"-->

<dataSource type="POOLED">  <!-- type="[UNPOOLED|POOLED|JNDI]"-->

4.3属性 Properties

我们可以通过properties户型来实现引用配置文件

这些属性都是可外部配置且可动态替换的，既可以在典型的Java属性文件中配置，也可通过properties元素的子元素来传递。

在resources文件夹中创建db.peoperties

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

在Mybatis-config.xml中调用db.peoperties

<configuration>
    <!--引入外部配置文件db.properties-->
    <properties resource = "db.properties"/>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--引入外部配置文件db.properties的属性配置-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    ……

可以直接引入外部文件
可以在其中增加一些属性配置
如果过两个文件中有同一个字段，优先使用外部配置文件的

<properties resource = "db.properties">
    <!--db.properties中字段和下方增加的属性字段冲突，优先文件中的-->
    <property name="username" value="root" />
    <property name="password" value="111111" />
</properties>

4.4类型别名 typeAliases

类别名为Java类，设置一个短的名字
也可以指定一个包名，会所有需要的Javabean，比如实体类的包，它的默认别名就为这个类的类名，但首字母小写！

配置MyBatis-config.xml：

<typeAliases>
    <!--Java类别名，需要设置一个短别名-->
    <typeAlias type="com.dachuan.pojo.User" alias="User" />
    <!--包别名，自动扫名，使用类名小写作为别名-->
    <package name="com.dachuan.pojo" />
</typeAliases>

修改UserMapper.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">
<mapper namespace="com.dachuan.dao.UserMapper">
    <!--使用包别名，自动扫描Javabean的类名小写作为别名-->
    <select id="getUserList" resultType="user">
        select * from mybatis.users
    </select>

实体类较少，可以使用第一种，类别名。支持自定义名字。

实体类较多，建议使用第二种包别名方式，但不支持取别名。如果非要改，可以用注解。

4.5设置

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。完整配置参数，了解即可，具体可看官网。

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

4.6其他配置

类型处理器（typeHandlers）
对象工厂（objectFactory）
插件（plugins）
- mybatis-generator-core
- mybatis-plus
- 通用mapper

4.7映射器 mappers

告诉MyBatis 到哪里去找映射文件。可以使用相对于类路径的资源引用，或完全限定资源定位符、类名、包名等。

方式一

使用相对或绝对路径绑定Mapper.xml配置文件

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

方法二

使用class文件绑定注册

注意点：

接口和Mapper必须同名
接口和Mapper必须在同一个包下

<!--通过class文件都需要在核心配置文件中注册-->
<mappers>
    <mapper class="com.dachuan.dao.UserMapper"/>
</mappers>

方法三

使用扫描包的方式注册

注意点：

接口和它的Mapper必须同名
接口和它的Mapper必须在同一个包下

<!--通过包名扫描，在核心配置文件中注册-->
<mappers>
    <package name="com.dachuan.dao"/>
</mappers>

练习思考

将数据库配置文件外部引入
实体类别名
保证UserMapper接口和UserMapper.xml名字一致，放在同一个包下

4.8生命周期和作用域

非常重要，错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder

一旦创建了SqlSessionFactory，就不再需要它了
局部变量

SqlSessionFactory

数据库连接池
一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
最佳作用域是应用作用域。有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession

连接到数据库连接池的一个请求
SqlSession的实例不是线程安全的，因此是不能被共享的，最佳的作用域是请求或方法作用域
用完之后赶紧关闭，否则占用资源

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

5.1问题

修改实体类的私有属性password 为psd，测试实体类和数据库中字段不一致的问题

public class Users {
    private int id;
    private String name;
    //password 修改为psd，后面的所有方法都要修改
    private String psd;

测试查询方法getUserList(),发现无法取出MySQL中password的数据。

select * from mybatis.users
-- 实际上是
select id,name,psd from mybatis.users

5.2ResultMap

结果集映射

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dachuan.dao.UserMapper">
    <!--配置数据库字段和类字段的对应关系-->
    <resultMap id="UserMap" type="users">
        <result column="id" property="id" />
        <result column="name" property="name" />
        <result column="password" property="psd" />
    </resultMap>
    <!--使用resultMap来映射结果-->
    <select id="getUserList" resultMap="UserMap">
        select * from mybatis.users
    </select>
</mapper>

ResultMap元素是Mybatis中最重要最强大的元素
ResultMap的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了
ResultMap的优秀之处——你完全可以不用显式地配置它们

6、日志

6.1日志工厂

如果一个数据库操作出现了一个异常，需要进行排错，日志就是一个最好的助手！

曾经：sout、debug

Mybatis提供了日志工厂：

在MyBatis中具体使用哪一个日志在设置中设置。

在Mybatis-config.xml中使用默认标准日志

<settings>
    <!--标准日志实现-->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

Opening JDBC Connection
Created connection 1586845078.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@5e955596]
==>  Preparing: select * from mybatis.users where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, 张三, 123456
<==      Total: 1
User{id=1, name='张三', password='123456'}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@5e955596]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@5e955596]
Returned connection 1586845078 to pool.

6.2`log4j`日志

什么是log4j？

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog 守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

配置：

Maven导入包

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

写入配置文件 log4j.properties

log4j.rootLogger=DEBUG,console,file
# 控制台(console)
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.Target=System.out
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n
# 日志文件(logFile)
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.Threshold=DEBUG
log4j.appender.lile.ImmediateFlush=true
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.File=./logs/log.log4j
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n

log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.Statement=DEBUG
log4j.logger.java.ResultSet=DEBUG
log4j.logger.java.PreparedStatement=DEBUG

配置log4j为日志的实现

<settings>
    <setting name="logImpl" value="SLF4J"/>
</settings>

测试使用

简单使用

在要使用的log4j类中，导入包 import org.apache.log4j.Logger;

日志对象，参数为当前类的class

static Logger logger = Logger.getLogger(UserMapperTest.class);

日志级别：DEBUG、INFO、WARN、ERROR

测试时可以用logger来输出结果，而不用像之前用System.out。

@Test
public void testLog4j(){
    logger.info("info:进入testlog4j");
    logger.warn("warn:进入testlog4j");
    logger.error("error:进入testlog4j");
}

7、分页

淘宝、京东、B站等，所有显示的数据基本都会使用分页。

这样可以减少数据的处理量
SQL中使用limit分页,（起始条目，显示几个数据）

-- SELECT * FROM USER LIMIT startIndex,pageSize
SELECT * FROM `users` LIMIT 0,2;

结果：

-- SELECT * FROM USER LIMIT startIndex,pageSize
SELECT * FROM `users` LIMIT 1,3;

7.1使用Limit实现分页

接口Mapper
Mapper.xml
测试

接口userMapper

public interface UserMapper {
    //创建分页查询的方法，传入分页参数。
    List<User> getUserByLimit(Map<String,Integer> map);
}

UserMapper.xml

<!--查询SQL语句编写，传入两个参数startIndex，pageSize，传入参数类型Map-->
<select id="getUserByLimit" parameterType="map" resultType="user" >
    select * from mybatis.users limit #{startIndex},#{pageSize}
</select>

测试类：

@Test
public void getUserByLimitTest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    //创建存放参数的Map对象，存入两个参数。
    HashMap<String,Integer> map = new HashMap<String, Integer>();
    map.put("startIndex",0);
    map.put("pageSize",2);
    //userList用于存放查询结果
    List<User> userList = userMapper.getUserByLimit(map);
    //通过历遍List使用logger输出userList内数据
    for (User user : userList) {
        logger.info(user);
    }
    //别忘了关闭SqlSession对象
    sqlSession.close();
}

7.2RowBounds实现分页

此方法Mybatis官方文档中不推荐使用

接口Mapper

    //使用RowBounds
    List<User> getUserByRowBounds();

Mapper.xml

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

测试

@Test
public void getUserByRowBounds(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //Rowbounds实现
    RowBounds rowBounds = new RowBounds(1, 2);
    //Java代码层实现分页
    List<User> userList = sqlSession.selectList("com.dachuan.dao.UserMapper.getUserByRowBounds",null,rowBounds);
    for (User user : userList) {
        logger.info(user);
    }
    sqlSession.close();
}

7.3分页插件

分页插件有很多，了解即可

PageHelper：https://pagehelper.github.io/

了解即可！

8、使用注解开发

8.1面向接口编程

学过面向对象编程，也学过接口，但真正开发中，很多时候都会选择面向接口编程

根本原因：

解耦：可拓展，提高服用
分层开发中，上层不用管具体的实现
大家都遵守共同的标准，使得开发变得容易，规范性更好

关于接口的理解：

接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离
接口的本身反映了系统设计人员对系统的抽象理解
接口应有两类：
- 第一类是对一个个体的抽象，它可对应为一个抽象体abstract class
- 第二类是对一个个体某一方面的抽象，即形成一个抽象面interface
一个体有可能有多个抽象面，抽象体与抽象面是有区别的

三个面向的区别：

面向对象是指：考虑问题时以对象为单位，考虑它的属性和方法
面向过程是指：考虑问题时以一个具体流程（事务过程）为单位，考虑它的实现
接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题，更多体现对系统整体的架构的约束

8.2使用注解开发

注解在接口上实现
需要在核心配置文件上绑定接口
测试

本质是反射机制实现，底层:动态代理

使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。
选择何种方式来配置映射，以及认为是否应该要统一映射语句定义的形式，完全取决于你和你的团队。换句话说，永远不要拘泥于一种方式，你可以很轻松的在基于注解和 XML 的语句映射方式间*移植和切换。

可以删除UserMapper.xml配置文件，将SQL语句通过注解写到UserMapper接口中

public interface UserMapper {
    //使用注解
    @Select("select * from users")
    List<User> getUser();
}

修改配置文件Mybatis-config.xml

 <!--每一个Mapper都要申明路径,使用注解开发的话，需要将mapper指向UserMapper接口-->
    <mappers>
        <mapper class="dachuan.dao.UserMapper"/>
    </mappers>

8.3CRUD

用注解方式实现增删改查操作

我们可以在工具类创建的时候实现自动事务提交。给一个Boolean参数true设置自动提交事务。

查看OpenSession方法源码：boolean参数作用就是autoCommit

    public SqlSession openSession(boolean autoCommit) {
        return this.sqlSessionFactory.openSession(autoCommit);
    }

插入

使用@Insert注解，首先在UserMapper接口类中添加方法addUser

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

然后再Test类中调用

@Test
public void addUserTest(){
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    int res = userMapper.addUser(new User(6,"杜甫","123456"));
    if(res>0){
        System.out.println("插入成功");
    }
    sqlSession.commit();
    sqlSession.close();
}

结果：

删除

使用@Delete注解，首先在UserMapper接口类中添加方法deleteUser

@Delete("Delete from users where name=#{name}")
int deleteUser(Map<String,String> map);

然后再Test类中调用

@Test
public void deleteUserTest(){
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    HashMap<String,String> map = new HashMap<>();
    map.put("name","杜甫");
    int res = userMapper.deleteUser(map);
    if(res>0){
        System.out.println("删除成功");
    }
    sqlSession.commit();
    sqlSession.close();
}

修改

使用@Update注解，首先在UserMapper接口类中添加方法setUser

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

然后再Test类中调用

@Test
public void setUserTest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    int res = userMapper.setUser(new User(5,"小白","111111"));
    if(res>0){
        System.out.println("修改成功");
    }
    sqlSession.commit();
    sqlSession.close();
}

关于`@Param()`注解

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

`#{}`和`${}`

#{}是预编译处理，${}是字符串替换
Mybatis 在处理#{}时，会将 sql 中的#{}替换为?号，调用 PreparedStatement 的 set 方法来赋值
Mybatis 在处理${}时，就是把${}替换成变量的值
使用#{}可以有效的防止 SQL 注入，提高系统安全性

9、Lombok

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.
Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.

lombok是一个可以通过简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 Java 代码的工具。

官网：https://projectlombok.org/

使用步骤

在IDEA中安装lombok插件，2020.3之后的IDEA自带插件，无需安装
在项目中导入lombok包，Maven仓库查询：https://mvnrepository.com

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.18</version>
    <scope>provided</scope>
</dependency>

在实体类上加注解即可

//常用的
//添加get和set方法
@Getter and @Setter
@FieldNameConstants
    //添加toString方法
@ToString
@EqualsAndHashCode
    //添加全参数、部分参数、无参数构造方法
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
    //实体类方法添加
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
@var
@UtilityClass

示例：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private String password;

此插件根据实际情况，不推荐使用。

后续内容为了节省代码编写时间，可能会出现这类注解，能看懂即可。

10、多对一处理

多个表关联一个表

有一个学生表，包含若干个学生，通过外键关联了同一个老师

回顾MySQL的查询方式

子查询
联表查询

测试环境搭建

创建teacher表，包含两个字段id,name,并插入测试数据

CREATE TABLE teacher(
   `id` INT(10) NOT NULL AUTO_INCREMENT,
   `name` VARCHAR(50) NOT NULL,
   PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO teacher(`id`,`name`) VALUES('1','大川'),('2','李白');

创建student表，包含3个字段id,name,tid,并插入测试数据

CREATE TABLE student(
   `id` INT(10) NOT NULL AUTO_INCREMENT,
   `name` VARCHAR(50) NOT NULL,
   `tid` INT(10) ,
   PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO student(`id`,`name`,`tid`) VALUES
('1','张三','1'),('2','李四','2'),
('3','王五','2'),('4','关羽','1'),
('5','张飞','1'),('6','刘备','1');

新建Java Module

创建核心配置文件Mybatis-config.xml

<?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都要申明路径-->
    <mappers>
        <mapper class="com.dachuan.dao.TeacherMapper" />
        <mapper class="com.dachuan.dao.StudentMapper" />
    </mappers>
</configuration>

配置db.properties

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

创建工具类MyBatisUtils

package com.dachuan.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 MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static{

        try {
            String resource = "Mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }

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

创建实体类 Teacher和Student

Teacher

package com.dachuan.pojo;

public class Teacher {
    private int id;
    private String name;
    public Teacher() {
    }
    public Teacher(int id, String name) {
        this.id = id;
        this.name = name;
    }
    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;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

Student：注意有一个外键tid，在实体类中用Teacher对象来对应字段

package com.dachuan.pojo;

public class Student {
    private int id;
    private String name;
    //tid是外键，关联teacher，所以这里关联一个Teacher对象
    private Teacher teacher;

    public Student() {
    }

    public Student(int id, String name, Teacher teacher) {
        this.id = id;
        this.name = name;
        this.teacher = teacher;
    }

    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 Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

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

创建TeacherMapper和 StudentMapper接口

TeacherMapper

package com.dachuan.dao;

import com.dachuan.pojo.Teacher;

public interface TeacherMapper {
    Teacher getTeacherById(int id);
}

StudentMapper

package com.dachuan.dao;

import com.dachuan.pojo.Student;

public interface StudentMapper {
    Student getStudentById(int id);
}

编写TeacherMapper.xml和StudentMapper.xml

TeacherMapper.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.dachuan.dao.TeacherMapper">
    <select id="getTeacherById" parameterType="int" resultType="com.dachuan.pojo.Teacher">
        select * from teacher where id=#{id}
    </select>
</mapper>

StudentMapper.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.dachuan.dao.StudentMapper">
    <select id="getStudentById" parameterType="int" resultType="com.dachuan.pojo.Student">
        select * from student where id=#{id}
    </select>
</mapper>

编写测试方法getTeacherByIdTest getStudentByIdTest

@Test
public void getTeacherByIdTest(){
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    TeacherMapper teacherMapper = sqlSession.getMapper(TeacherMapper.class);
    Teacher teacher = teacherMapper.getTeacherById(2);
    System.out.println(teacher);
    sqlSession.close();
}
@Test
public void getStudentByIdTest(){
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
    Student student = studentMapper.getStudentById(2);
    System.out.println(student);
    sqlSession.close();
}

测试结果

老师结果没问题：

学生的测试结果存在问题：teacher =null，不合理，存在问题需要解决。

主要解决方式有两种：按照查询嵌套处理（子查询），按照结果嵌套处理（联表查询）

按照查询嵌套处理

思路：

查询学生的信息
根据查询出来学生的tid，查找对应的老师

修改StudentMapper.xml实现嵌套查询

首先将将查询结果类型改成resultMap
修改resultMap的属性，其中id，name不变
配置对teacher表的子查询语句getTeacher
使用association配置来对teacher对象进行子查询,对应关系是tid

<?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.dachuan.dao.StudentMapper">
    <!--修改resultMap的属性-->
    <resultMap id="StudentWithTeacher" type="com.dachuan.pojo.Student">
        <!--id,name不变-->
        <result property="id" column="id" />
        <result property="name" column="name" />
        <!--teacher对象需要嵌套查询才能得到-->
        <association property="teacher" column="tid" javaType="com.dachuan.pojo.Teacher" select="getTeacher" />
    </resultMap>
    <!--将查询结果类型改成resultMap-->
    <select id="getStudentById" parameterType="int" resultMap="StudentWithTeacher">
        select * from student where id=#{id}
    </select>
    <!--配置对teacher表的子查询语句getTeacher-->
    <select id="getTeacher" resultType="com.dachuan.pojo.Teacher">
        select * from teacher where id=#{tid}
    </select>
</mapper>

查询结果展示：

按照结果嵌套处理

使用联表查询的方式实现：

查询学生信息（id,姓名，老师id，老师名字）联表实现方式：

SELECT s.id,s.name,s.tid,t.name FROM student AS s ,teacher AS t WHERE s.tid = t.id

这里类似，创建getStudentList方法和测试方法。

//StudentMapper创建查询方法getStudentList
List<Student> getStudentList();
//StudentMapperTest中创建对应的测试方法
@Test
public void getStudentListTest(){
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> studentList = studentMapper.getStudentList();
    for (Student student : studentList) {
        System.out.println(student);
    }
    sqlSession.close();
}

修改配置文件StudentMapper.xml

实现方式

getStudentList中实现SQL的语句用联表查询语句，查询结果取别名sid sname ttid tname
将这些查询得到的表格内容，通过resultMap对应到实体类中去
对于实体类中的复杂对象，用association嵌套处理

<?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.dachuan.dao.StudentMapper">
    <resultMap id="StudentWithTeacher" type="com.dachuan.pojo.Student">
        <!--查询结果存如实体类中-->
        <result property="id" column="sid" />
        <result property="name" column="sname" />
        <!--复杂对象，用association嵌套处理-->
        <association property="teacher" javaType="com.dachuan.pojo.Teacher">
            <result property="id" column="ttid" />
            <result property="name" column="tname" />
        </association>
    </resultMap>
    <select id="getStudentList" resultMap="StudentWithTeacher">
        <!--查询结果取别名-->
        select s.id as sid,s.name as sname,t.id as ttid,t.name as tname from student as s ,teacher as t where s.tid = t.id
    </select>
</mapper>

11、一对多处理

刚才是多个学生对应一个老师，对于老师而言就是一对多的关系！

测试环境搭建

修改学生实体类Student

@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private int id;
    private String name;
    //之前这里用的老师对象，现在改成tid。
    private int tid;
}

修改老师实体类Teacher

@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Teacher {
    private int id;
    private String name;
    //增加与学生的关系，由于是一对多，所以用List<Student>集合
    private List<Student> studentList;
}

创建获取全部老师的接口方法

public interface TeacherMapper {
    List<Teacher> getTeacherList();
}

按原先的方法，创建接口方法配置文件

<mapper namespace="com.dachuan.dao.TeacherMapper">
    <select id="getTeacherList" resultType="com.dachuan.pojo.Teacher">
        select * from teacher
    </select>
</mapper>

创建测试方法测试

@Test
public void getTeacherListTest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    TeacherMapper teacherMapper = sqlSession.getMapper(TeacherMapper.class);
    List<Teacher> teacherList = teacherMapper.getTeacherList();
    for (Teacher teacher : teacherList) {
        System.out.println(teacher);
    }
    sqlSession.close();
}

测试结果：

仍然是相同的问题，Teacher对象中的studentList在输出时为null，无法获取到关联数据。

按照结果嵌套查询

首先，分析联表查询的SQL语句

SELECT s.id AS sid,s.name AS sname,t.name AS tname,t.id AS tid
FROM student AS s,teacher AS t 
WHERE t.id = 1 AND t.id = s.tid

结果：

需要考虑把结果映射到对象teacher中去。

<resultMap id="TeacherWithStudent" type="com.dachuan.pojo.Teacher">
    <result property="id" column="tid" />
    <result property="name" column="tname" />
    //对于集合使用collection，使用ofType分解，将学生对应的内容拆解
    <collection property="studentList" ofType="com.dachuan.pojo.Student">
        <result property="id" column="sid" />
        <result property="name" column="sname" />
        <result property="tid" column="tid" />
    </collection>
</resultMap>
<select id="getTeacherById" parameterType="int" resultMap="TeacherWithStudent">
    SELECT s.id AS sid,s.name AS sname,t.name AS tname,t.id AS tid
    FROM student AS s,teacher AS t
    WHERE t.id = #{tid} AND t.id = s.tid
</select>

编写测试类

@Test
public void getTeacherByIdTest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    TeacherMapper teacherMapper = sqlSession.getMapper(TeacherMapper.class);
    Teacher teacher = teacherMapper.getTeacherById(2);
        System.out.println(teacher);
    sqlSession.close();
}

结果：

按照查询嵌套处理

首先在TeacherMapper中创建查询方法

    //获取指定老师下的所有学生
    Teacher getTeacherById2(@Param("tid") int id);

然后TeacherMapper.xml配置基础查询语句，能查出teacher的数据

<select id="getTeacherById2" parameterType="int" resultMap="TeacherWithStudent2">
	select * from teacher where id = #{tid}
</select>

其中嵌套需要查询tid为查询ID的学生信息的查询语句

<select id="getStudent" resultType="com.dachuan.pojo.Student">
    select * from student where tid = #{tid}
</select>

将查询的数据关联到teacher对象中，使用collection，调用getStudent子查询语句

<resultMap id="TeacherWithStudent2" type="com.dachuan.pojo.Teacher" >
    <result property="id" column="id" />
    <result property="name" column="name" />
    <collection property="studentList" javaType="ArrayList" ofType="com.dachuan.pojo.Student" select="getStudent" column="tid" />
</resultMap>

结果：

小结

关联 - association 多对一
集合 - collection 一对多
javaType & ofType
- JavaType 用来指定实体类中属性的类型
- ofType 用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

注意点

保证SQL的可读性，尽量保证通俗易懂
注意一对多和多对一中，属性名和字段的问题
如果问题不好排查错误，建议使用log4j生成日志排查

常见面试题

MySQL引擎
InnoDB底层原理
索引
索引优化

12、动态SQL

什么是动态SQL:动态SQL就是指根据不同的条件生成不同的SQL语句

利用动态SQL这一特性可以彻底摆脱这种痛苦

借助功能强大的基于 OGNL的表达式现在要学习的元素种类比原来的一半还要少。

if
choose (when, otherwise)
trim (where, set)
foreach

12.1搭建环境

创建表blog

CREATE TABLE `blog`(
   `id` VARCHAR(50) NOT NULL COMMENT '博客ID',
   `title` VARCHAR(100) NOT NULL COMMENT '博客标题',
   `author` VARCHAR(30) NOT NULL COMMENT '作者',
   `create_time` DATETIME NOT NULL COMMENT '创建时间',
   `views` INT(30) NOT NULL COMMENT '浏览量',
   PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

创建一个基础工程

导包
编写核心配置文件

<!--配置驼峰命名和数据库下划线命名转换-->
<settings>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<!--配置接口配置文件位置-->
<mappers>
    <mapper class="com.dachuan.dao.BlogMapper" />
</mappers>

编写工具类

//自动生成UUID
public class IdUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
}

编写实体类

@Data
public class Blog {
    private String id;
    private String title;
    private  String author;
    private Date createTime; //存在字段名不一致，需要在核心配置中修改
    private int views;
}

编写实体类对应的Mapper接口和Mapper.xml文件

//接口增加插入数据的方法addBlog
public interface BlogMapper {
    int addBlog(Blog blog);
}

<mapper namespace="com.dachuan.dao.BlogMapper">
    <insert id="addBlog" parameterType="com.dachuan.pojo.Blog">
        insert into blog(id,title,author,create_time,views) values (#{id},#{title},#{author},#{createTime},#{views})
    </insert>
</mapper>

创建测试类并插入数据

public class BlogMapperTest {
    @Test
    public void addBlogTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
        Blog blog = new Blog();
        blog.setId(IdUtils.getId());
        blog.setTitle("Mybatis技术");
        blog.setAuthor("张三");
        blog.setCreateTime(new Date());
        blog.setViews(9999);
        blogMapper.addBlog(blog);
        blog.setId(IdUtils.getId());
        blog.setTitle("Java技术");
        blog.setAuthor("李四");
        blogMapper.addBlog(blog);
        blog.setId(IdUtils.getId());
        blog.setTitle("MySQL技术");
        blog.setAuthor("张三");
        blog.setViews(1000);
        blogMapper.addBlog(blog);
        blog.setId(IdUtils.getId());
        blog.setTitle("MySQl技术");
        blog.setAuthor("李白");
        blogMapper.addBlog(blog);
        sqlSession.commit();
        sqlSession.close();
    }
}

结果：

12.2 IF语句

如果传入了参数比如title，就按title查询，如果传入了title和author则同时判断，如果没有传入参数，则查询所有参数。

创建接口方法

List<Blog> getBlogListIf(Map map);

配置接口配置文件

使用<if>判断参数是否为空并拼接SQL语句

<select id="getBlogListIf" parameterType="map" resultType="com.dachuan.pojo.Blog">
    select * from blog where 1=1
    <if test="title != null">
        and title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</select>

创建测试类

不传入任何参数时

@Test
public void getBlogListIfTest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
    //创建空的Map，直接调用，即没有传入参数
    HashMap map = new HashMap();
    List<Blog> blogList = blogMapper.getBlogListIf(map);
    for (Blog blog : blogList) {
        System.out.println(blog);
    }
    sqlSession.close();
}

传入参数title=MySQL技术时

map.put("title","MySQL技术");

传入参数author=张三时

map.put("author","张三");

传入两个参数title=MySQL技术，author=张三时

map.put("author","张三");
map.put("title","MySQL技术");

上述语句中存在问题：where 1=1不是很正规也不安全，当是 or条件时，就会出问题。

12.3 where标签

官方讲的较详细：https://mybatis.org/mybatis-3/zh/dynamic-sql.html

理解：

将1=1去掉，语句变成如下：

<select id="getBlogListIf" parameterType="map" resultType="com.dachuan.pojo.Blog">
    //这里为了防止if判断均失败的情况
    select * from blog where
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</select>

但存在问题：

如果title为null，SQL语句变成如下，多了一个and。

select * from blog where
and author = #{author}

这会导致查询失败。

如果两个参数都为null，SQL语句变成,多了一个where

select * from blog where

这个查询也会失败。这个问题不能简单地用条件元素来解决。这个问题是如此的难以解决，以至于解决过的人不会再想碰到这种问题。

MyBatis 有一个简单且适合大多数场景的解决办法。而在其他场景中，可以对其进行自定义以符合需求。而这，只需要一处简单的改动：

<select id="getBlogListIf" parameterType="map" resultType="com.dachuan.pojo.Blog">
    //这里为了防止if判断均失败的情况
    select * from blog 
    <where>
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
    </where>
</select>

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

测试：

不传入任何参数时

传入参数title=MySQL技术时

传入参数author=张三时

传入两个参数title=MySQL技术，author=张三时

12.3 choose(when、otherwise)

有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句，when元素相当于case语句，otherwise相当于默认查询条件。

传入了 title就按title查找，传入了author就按author查找的情形。若两者都没有传入，就返回view > 5000的 BLOG（这可能是管理员认为，与其返回大量的无意义随机 Blog，还不如返回一些优质的 Blog）

<select id="getBlogListIf" parameterType="map" resultType="com.dachuan.pojo.Blog">
    select * from blog
    <where>
        <choose>
            <when test="title != null">
                title = #{title}
            </when>
            <when test="author != null">
                and author = #{author}
            </when>
            <otherwise>
                and views >= 5000
            </otherwise>
        </choose>
    </where>
</select>

测试结果，未传入参数时：

当传入查询不到的参数时呢：

12.4 set

与where类似，根据传入的参数，自动忽略set或语句后的,

常规的set的SQL语句

UPDATE blog SET title = '标题', author = '作者' WHERE id = '对应的UUID';

set为update中使用的关键字，为此创建修改博客方法

int updateBlog(Map map);

配置Mapper.xml配置文件

<update id="updateBlog" parameterType="map">
    update blog
    <set>
        <if test="title != null">
            title = #{title},
        </if>
        <if test="author != null">
            author = #{author},
        </if>
    </set>
    where id = #{}
</update>

配置测试类测试：

@Test
public void updateBlog(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
    HashMap map = new HashMap();
    map.put("id","581cca20668a45c3be7854c47249c684");
    map.put("author","大川");
    map.put("title","Spring技术");
    int res = blogMapper.updateBlog(map);
    sqlSession.commit();
    sqlSession.close();
}

只传入map.put("author","小川");

不传入任何数据，报错，语句不完整了。

12.5trim(set where)

where相当于

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

set相当于

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

所谓动态SQL，本质还是SQL语句，知识我们可以在SQL层面，可以去执行一个逻辑代码

12.6 SQL片段

有的时候，我们可能会将一些功能抽取出来，以便复用。

使用sql标签抽取公共部分

<sql id="ifTitleAuthor">
    <if test="title != null">
        and title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</sql>

在要使用的地址使用include标签引用即可

<select id="getBlogListIf" parameterType="map" resultType="com.dachuan.pojo.Blog">
    select * from blog
    <where>
        <include refid="ifTitleAuthor" />
    </where>
</select>

注意事项：

最好基于单表来定义sql片段
最好不错在where标签

12.7 foreach

以下为官方例子：https://mybatis.org/mybatis-3/zh/dynamic-sql.html

动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。比如：

<select id="selectPostIn" resultType="domain.blog.Post">
  SELECT *
  FROM POST P
  WHERE ID in
  <foreach item="item" index="index" collection="list"
      open="(" separator="," close=")">
        #{item}
  </foreach>
</select>

以案例来解释和理解

我需要查点击量大于5000而且作者是张三或者李四或者李白……的Blog信息

正常的SQL语句

SELECT * FROM blog WHERE views >= 5000 AND (author ='张三' OR author ='李四' OR author ='李白' ……)

根据输入的选择的条件不同，OR的格式和参数也不同

编写接口方法

List<Blog> getBlogWithViewsAndAuthor(Map map);

编写Mapper.xml配置文件

<select id="getBlogWithViewsAndAuthor" resultType="com.dachuan.pojo.Blog">
    select * from blog
    <where>
        views >= #{views}
        <foreach collection="authors" item="author" open ="and (" separator="or" close=")">
            author = #{author}
        </foreach>
    </where>
</select>

编写测试方法：

@Test
public void getBlogWithViewsAndAuthorTest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
    HashMap map = new HashMap();
    //创建一个List存放需要同时查询的作者
    List<String> authorList = new ArrayList<String>();
    authorList.add("张三");
    authorList.add("李四");
    authorList.add("李白");
    //传入一个map作为参数，包含一个views，和一个不定长的authors
    map.put("views",5000);
    map.put("authors",authorList);
    List<Blog> blogList = blogMapper.getBlogWithViewsAndAuthor(map);
    for (Blog blog : blogList) {
        System.out.println(blog);
    }
    sqlSession.close();
}

测试结果：拼接语句正常，结果也符合要求

动态SQL就是在拼接SQL语句，只要保证SQL的正确ing，按照SQL的格式去排列即可。

建议：

在MySQL中先测试确保无误，再拼接！

13、缓存

13.1简介

什么是缓存Cache？
- 存在内存中的临时数据
- 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题
为什么使用缓存？
- 减少和数据库的交互次数，减少系统开销，提高系统效率
什么样的数据能使用缓存？
- 经常查询并且不经常改变的数据

13.2Mybatis缓存

Mybatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率
Mybatis系统中默认定义了两级缓存：一级缓存、二级缓存
- 默认情况下，只有一级缓存开启（SqlSession级别的缓存，也称为本地缓存）
- 二级缓存需要手动开启和配置，它是基于namespace级别的缓存
- 为了提高扩展性，Mybatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

13.3一级缓存

一级缓存也叫本地缓存
- 与数据库同一次会话期间查询到的数据会放在本地缓存中
- 以后如果需要获得相同的数据，直接从缓存中拿，不必再去查询数据库

13.4二级缓存

二级缓存也叫全局缓存，一级缓存作用域太低，所以诞生了二级缓存
基于namespace级别的缓存，一个名称空间，对应一个二级缓存
工作机制
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
- 如果当前会话关闭，这个会话对应的一级缓存就没了，但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中
- 新的会话查询信息，就可以从二级缓存中获取内容
- 不同的mapper查出的数据会放在自己对应的缓存（map）中
- 先查二级缓存、再查一级缓存、最后查数据库

以上就是Mybatis学习笔记记录！

码农公寓

MyBatis

1、简介

1.1 什么是MyBatis

1.2持久化

1.3持久层

1.4为什么需要MyBatis

2、第一个Mybatis程序

2.1搭建环境

搭建数据库

新建项目

2.2创建一个模块

编写Mybatis的核心配置文件

编写MyBatis工具类

2.3编写代码

2.4测试

3、CRUD

3.1namespace

3.2select

3.3查询

3.4添加

3.5修改

3.6删除

3.7万能的Map

4、配置解析

4.1核心配置文件

4.2配置环境 environments

4.3属性 Properties

4.4类型别名 typeAliases

4.5设置

4.6其他配置

4.7映射器 mappers

方式一

方法二

方法三

练习思考

4.8生命周期和作用域

SqlSessionFactoryBuilder

SqlSessionFactory

SqlSession

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

5.1问题

5.2ResultMap

6、日志

6.1日志工厂

6.2log4j日志

简单使用

7、分页

7.1使用Limit实现分页

7.2RowBounds实现分页

7.3分页插件

8、使用注解开发

8.1面向接口编程

8.2使用注解开发

8.3CRUD

插入

删除

修改

关于@Param()注解

#{}和${}

9、Lombok

10、多对一处理

测试环境搭建

按照查询嵌套处理

按照结果嵌套处理

11、一对多处理

测试环境搭建

按照结果嵌套查询

按照查询嵌套处理

小结

注意点

常见面试题

12、动态SQL

12.1搭建环境

12.2 IF语句

12.3 where标签

12.3 choose(when、otherwise)

12.4 set

12.5trim(set where)

12.6 SQL片段

6.2`log4j`日志

关于`@Param()`注解

`#{}`和`${}`