Mybatis学习笔记.md · 三淳/Mybatis_Study

[TOC]

## 1、入门

1. 搭建环境（Maven）

2. 导入依赖（`mybatis`、`mysql-connector-java`）
    ```xml 
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
      
    
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.3</version>
    </dependency>
   ```
   
3. 配置mybatis(`mybatis-config.xml`)
   ```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>
    
    <environments default="development">
        
        <environment id="development">
            
            <transactionManager type="JDBC"/>
            
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456w"/>
            </dataSource>
        </environment>
    </environments>
   
    
    <mappers>
        <mapper resource="com/th/dao/UserMapper.xml"/>
    </mappers>
   
   </configuration>
   ```
   
4. 构建工具类，获取`SqlSessionFactory`和`SqlSession`。
   ```java
   public class MybatisUtils {
   
    // 从 XML 中构建 SqlSessionFactory[也可以通过Java 代码构建SqlSessionFactory]
    private static SqlSessionFactory sqlSessionFactory;
    static {
        //第一步：获取SqlSessionFactory对象
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
   
    /*既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。SqlSession 提供了在
    数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。*/
   
   //第二步：通过SqlSessionFactory获取SqlSession对象
    public static SqlSession getSqlSession(){
        //通过静态代码块中的sqlSessionFactory对象调用openSession（）方法得到一个SqlSession 对象
        //将这个SqlSession 对象返回出去，作为工具提供给需要实现数据库操作的对象使用。
        return sqlSessionFactory.openSession();
    }
   }
   ```
   
5. 编写实体类(可使用`lombok`）
   ```xml
   public class User {
   
       private int id;
       private String name;
       private String pwd;
   
       public User() {
       }
   
       public User(int id, String name, String pwd) {
           this.id = id;
           this.name = name;
           this.pwd = pwd;
       }
   
       public int getId() {
           return id;
       }
   
       public void setId(int id) {
           this.id = id;
       }
       ……
       @Override
       public String toString() {
           return "User{" +
                   "id=" + id +
                   ", name='" + name + '\'' +
                   ", pwd='" + pwd + '\'' +
                   '}';
       }
   }
   ```
   
6. Dao接口
   ```xml
   public interface UserMapper {
       List<User> getUserList();
   ```
   
7. 接口实现类Impl【XXXMapper.xml】
   ```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.th.dao.UserMapper">
       
       
       <select id="getUserList" resultType="com.th.pojo.User">
           select * from mybatis.user
       </select>
   </mapper>
   ```
   
8. 在Mybatis核心配置文件中注册每一个Mapper.xml
   
   ```xml
    
    <mappers>
        <mapper resource="com/th/dao/UserMapper.xml"/>
    </mappers>
   ```
   
   参考第二步。
   
8. 测试
   
   ```java
   public void testGetUserList() {
        //第一步：通过工具类获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
   
        //第二步：获取结果集
        try {
            //方式一：getMapper(推荐使用)
            //不仅更清晰，更加类型安全，还不用担心可能出错的字符串字面值以及强制类型转换。
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            List<User> userList = userMapper.getUserList();
   
            //方式二：
            //List<User> userList = sqlSession.selectList("com.th.dao.UserDao.getUserList");
   
            for (User user : userList) {
                System.out.println(user);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //第三步：关闭SqlSession
            sqlSession.close();
        }
    }
   ```
   
9. 注意点
      1. 报错`org.apache.ibatis.binding.BindingException: Type interface com.th.dao.UserMapper is not known to the MapperRegistry.`
      > 每一个XXXMapper.xml文件都必须在mybatis.xml文件中进行注册。
      ```xml
      <mappers>
        <mapper resource="com/th/dao/UserMapper.xml"/>
      </mappers>
      ```
   
      2. 报错`Caused by: java.io.IOException: Could not find resource com/th/dao/UserMapper.xml`
      > Maven约定大于配置，出现这个错误的原因是Maven默认导出`resources`下的配置文件，而src目录下的不会被导出,解决方案是配置使其导出src下的配置文件。
      ```xml
      <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>
   ```
## 2、三大对象作用域
+ SqlSessionFactoryBuilder
  SqlSessionFactoryBuilder用于创建SqlSessionFactory对象，一旦创建了 SqlSessionFactory，就不再需要SqlSessionFactoryBuilder。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是**方法作用域**（也就是**局部方法变量**）
+ SqlSessionFactory
  SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。因此 SqlSessionFactory 的最佳作用域是**应用作用域**。 有很多方法可以做到，最简单的就是使用**单例模式**或者**静态单例模式**。
+ SqlSession
  每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例是**线程不安全**的，因此是不能被共享的，所以它的最佳的作用域是**请求或方法作用域**。每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 **finally** 块中。

## 3、CRUD
+ id:                            对应接口中定义的方法名
+ resultType:            SQL执行后的返回值
+ parameterType：参数类型
+ 注意：**增删改需要提交事务**
+ 
  **1. select**
   1. 编写接口
   ```java
   User getUserById(int id);
   ```
   2. 编写对应的mapper中的sql语句
   ```xml
   <select id="getUserById" parameterType="int" resultType="com.th.pojo.User">
   	select * from mybatis.user where id=#{id}
   </select>
   ```
   3. 测试/实现
   ```java
   @Test
    public void testGetUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try {
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            User userById = mapper.getUserById(1);
            System.out.println(userById);
        } catch (Exception e) {
        	e.printStackTrace();
        } finally {
        	sqlSession.close();
        }
    }
   ```

**2. insert**
1. 编写接口
   ```java
   int insertUser(User user);
   ```
2. 编写对应的mapper中的sql语句
   ```xml
   <insert id="insertUser" parameterType="com.th.pojo.User">
        insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{pwd});
   </insert>
   
   ```
3. 测试/实现
   ```java
    @Test
    public void testInsertUser() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try {
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            int i = mapper.insertUser(new User(4, "王五", "123456"));
            if (i > 0) {
                System.out.println("insert successful");
            }
            //提交事物，这是必须的,否者无法真正的插入数据。
            sqlSession.commit();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            sqlSession.close();
        }
    }
   ```

**3. update**

1. sql语句

```xml
   <update id="updateUser" parameterType="com.th.pojo.User">
   	update mybatis.user set name =#{name},pwd=#{pwd} where id=#{id};
   </update>
   ```

**4. delete**

1. sql语句

```xm
   <delete id="deleteUser" parameterType="int">
      delete from mybatis.user where id=#{id};
   </delete>
   ```

>  **万能的Map**

避免形如在修改某个对象属性时需要传递完整的对象，使用Map则只需要传递有需求的参数即可。以更新数据为例。

1. 编写接口

```java
   int updateUser2(Map<String,Object> map);
   ```

2. 编写对应的mapper中的sql语句

```xml
   <update id="updateUser2" parameterType="map">
       
   	update mybatis.user set name =#{userName} where id=#{userid};
   </update>
   ```

3. 测试/实现

```java
   public void testUpdateUser2(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       try {
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
           
           Map<String, Object> map = new HashMap<>();
           map.put("userid", 4);
           map.put("userName", "燕g");
           
           int i = mapper.updateUser2(map);
           if (i>0){
               System.out.println("Update Successful");
           }
           sqlSession.commit();
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           sqlSession.close();
       }
   }
   ```

4. 总结
   + Map传递参数，直接在sql中取出key即可。
   + 对象传递参数，直接在sql中取出对象属性即可。
   + 只有一个基本参数情况下，可以直接在sql中取到。
   + 多个参数用Map或者注解！

## **4、Mybatis配置解析**

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

注意：在配置时必须按照一下顺序`(properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?)`

### 1. 属性（properties）

1. 作用：实现引用配置文件

2. 使用步骤

1. 编写一个配置文件

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

2. 在核心配置文件中进行引入

```xml
      <properties resource="db.properties">
          <property name="uname" value="root"/>
          <property name="uword" value="mysqlpw"/>
      </properties>
      ```

3. 核心配置文件中配置environments时直接使用

```xml
        <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="${uname}"/>
                    <property name="password" value="${uword}"/>
                </dataSource>
            </environment>
        </environments>
        ```

```tex
   	3. 可以在引入后添加property标签对外部配置文件进行补充，如果有两个相同属性，优先使用外部配置文件！
   	```

### 2. 设置（settings）

| 设置名                   | 描述                                                         | 有效值                                                       | 默认值 |
| :----------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------ |
| cacheEnabled             | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。     | true \| false                                                | true   |
| lazyLoadingEnabled       | 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 `fetchType` 属性来覆盖该项的开关状态。 | true \| false                                                | false  |
| mapUnderscoreToCamelCase | 是否开启驼峰命名自动映射，即从经典数据库列名A_COLUMN 映射到经典 Java 属性名aColumn。 | true \| false                                                | False  |
| logImpl                  | 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。        | SLF4J \| LOG4J(deprecated since 3.5.9) \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING | 未设置 |

### 日志工厂

```xml
<settings>
    
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
```

>  标准日志工厂实现不需要额外导包，注意name和value的值必须严格要求按照标准书写，前后不允许出现空格。

#### LOG4J

是什么？

+ Log4J是 Apache的一个开源项目，通过使用Log4J，我们可以**控制日志信息**输送的目的地是控制台、文件、GU组件
+ 我们也可以控制每一条日志的**输出格式**；
+ 通过定义每一条**日志信息的级别**，我们能够更加细致地控制日志的生成过程
+ 通过一个**配置文件**来灵活地进行配置，而不需要修改应用的代码。

如何用？

1. 导入依赖

```xml
   
   <dependency>
       <groupId>log4j</groupId>
       <artifactId>log4j</artifactId>
       <version>1.2.17</version>
   </dependency>
   ```

2. 创建`log4j.properties`配置文件（网上有详细配置）

```properties
   log4j.rootLogger=DEBUG,console,file
   #控制台输出的相关设置
   #输出出现乱码时在配置文件配置编码格式后还应该设置idea的编码格式。
   log4j.appender.stdout.Encoding=UTF-8
   log4j.appender.console = org.apache.log4j.ConsoleAppender
   # 设置控制台输出的格式为utf-8.
   log4j.appender.console.Encoding=UTF-8
   log4j.appender.console.Target = System.out
   log4j.appender.console.Threshold=DEBUG
   log4j.appender.console.layout = org.apache.log4j.PatternLayout
   log4j.appender.console.layout.ConversionPattern=【%c】-%m%n
   
   
   #文件输出的相关设置
   log4j.appender.file = org.apache.log4j.RollingFileAppender
   # 设置文件输出的格式为utf-8.
   log4j.appender.file.Encoding=UTF-8
   log4j.appender.file.File=./log/log4j.log
   log4j.appender.file.MaxFileSize=10mb
   log4j.appender.file.Threshold=DEBUG
   log4j.appender.file.layout=org.apache.log4j.PatternLayout
   log4j.appender.file.layout.ConversionPattern=【%p】【%d{yy-MM-dd}】【%c】%m%n
   
   #日志输出级别
   log4j.logger.org.mybatis=DEBUG
   log4j.logger.java.sql=DEBUG
   log4j.logger.java.sql.Statement=DEBUG
   log4j.logger.java.sql.ResultSet=DEBUG
   log4j.logger.java.sql.PreparedStatement=DEBUG
   ```

3. 项目中配置LOG4J日志工厂实现

```xml
   <settings>
       <setting name="logImpl" value="LOG4J"/>
   </settings>
   ```

4. 简单使用

在相应的控制台和文件中将有日志输出。

![image-20220210210220453](E:\IDEA_Projects\Mybatis_Study\note.assets\image-20220210210220453.png)

5. 其他使用

1. 在要使用LOG4J的类中创建`Logger`对象（import org.apache.log4j.Logger;）

```java
      //UserMapperTest为需要使用LOG4J的类
      static Logger logger = Logger.getLogger(UserMapperTest.class);
      ```

2. 使用日志级别

```JAVA
      logger.info("进入了testGetUserById");
      logger.debug("进入了testGetUserById");
      logger.error("进入了testGetUserById");
      ```

### 3. 类型别名（typeAliases）

作用：可为 Java 类型设置一个**缩写名字**。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。

1. 自定义别名 （适合Java Bean少的情况下）

```xml
   <typeAliases>
       
   </typeAliases>
   ```

2. 包扫描别名

```xml
   <typeAliases>
       <package name="com.th.pojo"/>
   </typeAliases>
   ```

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

```java
   @Alias("user")
   public class User {
       ...
   }
   ```

###  4. 环境配置（environments）

要求：配置多套运行环境

MyBatis可以适配多种环境，但是每一个SqlSessionFactory实例只能选择一种环境。

MyBatis默认的事物管理器是**JDBC**，连接池**POOLED**；

### 5. 映射器（mappers）

作用：注册绑定Mapper文件

1. **使用相对于类路径的资源引用**

```xml
   <mappers>
     <mapper resource="com/th/dao/UserMapper.xml"/>
   </mappers>
   ```

**推荐使用，不容易出错。**

2. 使用映射器**接口实现类**的完全限定类名

```xml
   <mappers>
     <mapper class="com.th.dao.UserMapper"/>
   </mappers>
   ```

**注意点：接口和它的 Mapper配置文件必须同名且在同一个包下！**

3. 将**包**内的映射器接口实现全部注册为映射器

```xml
   <mappers>
     <package name="com.th.dao"/>
   </mappers>
   ```

**注意点：接口和它的 Mapper配置文件必须同名且在同一个包下！**

4. 使用完全限定资源定位符（URL）

```xml
   <mappers>
     <mapper url="file:///var/mappers/AuthorMapper.xml"/>
   </mappers>
   ```

不使用。

## 5、resultMap

问题：数据库中的字段名与实体类中属性名不一致。导致这个字段查出数据为null。这是因为mybatis类型处理器无法找到这个属性。

作用：解决属性名与字段名不一致的问题。将数据库中字段映射到实体类属性；

解决：

1. 使用mysql语法as取别名
 	2. 使用resultMap

### 使用resultMap

1. Mapper.xml中配置结果集映射，其中id为这个结果集映射的名字，type为返回值的类型。

```xml
   <resultMap id="UserMap" type="user">
       
       <result column="pwd" property="password"/>
   </resultMap>
   ```

2. 使用结果集映射

```xml
   <!-resultMap中的值为以上结果集映射中定义的id值-->
   <select id="getUserById" parameterType="int" resultMap="UserMap">
       select * from mybatis.user where id=#{id}
   </select>
   ```

## 6、分页

分页是为了减少数据的处理量

```sql
SELECT * from table limit startIndex, pagesize;
SELECT * from table limit 3; #[O, n]
```

>  使用Mybatis实现分页，核心SQL

1. 编写接口

```java
   //使用万能的Map获取起始下标以及页面大小
   List<User> getUserByLimit(Map<String,Integer> map);
   ```

2. Mapper.xml

```xml
   
   <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
       select * from mybatis.user limit #{startIndex},#{pageSize};
   </select>
   ```

3. 测试

```java
   public void testGetUserByLimit(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       try {
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
           HashMap<String, Integer> map = new HashMap<>();
           map.put("startIndex", 1);
           map.put("pageSize", 2);
   
           List<User> userList = mapper.getUserByLimit(map);
           for (User user : userList) {
               System.out.println(user);
           }
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           sqlSession.close();
       }
   }
   ```

其他分页实现：RowBounds、分页插件（PageHelper）。

## 7、使用注解开发

1. 注解的使用直接在接口中实现

```java
   @Select("select * from user")
   List<User> getUserList();
   ```

2. 在核心配置文件中绑定接口

```xml
   <mappers>
       <mapper class="com.th.dao.UserMapper"/>
   </mappers>
   ```

3. 测试使用

>  本质：底层还是使用反射

### CRUD

可以在工具类创建的时候设置自动提交事务：

```
public static SqlSession getSqlSession(){
    //true表示自动提交事物
    return sqlSessionFactory.openSession(true);
}
```

1. 编写接口

```java
@Select("select * from user")
List<User> getUserList();

/**当有多个参数时,所有的参数前必须加上@Param("id") 注解*/
@Select("select * from user where id=#{id}")
User getUserById(@Param("id") int ids);

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

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

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

2. 测试类
```
public void testT() {
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    try {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //List<User> userList = userMapper.getUserList();
        //for (User user : userList) {
        //    System.out.println(user);
        //}
        
        //User user = userMapper.getUserById(1);
        //System.out.println(user);
            
        //UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //userMapper.addUser(new User(5, "sfgu", "abyh"));
        
        //userMapper.updateUser(new User(5, "nihao", "nihao"));
        
        //userMapper.deleteUser(5);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        //关闭SqlSession
        sqlSession.close();
    }
}
```

> 关于@Param()注解

+ 基本类型的参数或者String类型，需要加上
+ 引用类型不需要加
+ 如果只有一个基本类型的话，可以忽略，但是建议加上。
+ 在SQL语句中的引用就是@Param("id")中设定的属性名。

> 关于#{}和${}的区别

+ #{}是预编译处理、是**占位符**，${}是字符串替换、是**拼接符**。
+ Mybatis在处理#{}时，会将sql中的#替换为？，调用`PreparedStatement`来赋值；
+ Mybatis在处理${}时，就是把${}替换成变量的值，调用`Statement`来赋值：
+ #{}的变量替换是在DBMS中、变量替换后，#{}对应的变量**自动加上单引号**
+ ${}的变量替换是在DBMS外、变量替换后，${}对应的变量<u>不会加上单引号使用</u>
+ #{}可以有效的**防止SQL注入**，**提高系统安全性**。
+ 建议使用#{}

## 8、复杂查询

解决形如一个老师对应多个学生，多个学生对应一个老师的情况；

处理实体类

```java
//学生实体类
@Data
public class Student {
    private int id;
    private String name;
    //老师对象
    private Teacher teacher;
}

//老师实体类
@Data
public class Teacher {
    private int id;
    private String name;
}
```

### 1. 多对一

> 子查询

```xml

<select id="getStudentList" resultMap="StudentTeacher">
    select * from student
</select>

<select id="getTeacher" resultType="Teacher">
    select * from teacher where id = #{id}
</select>
```

`javaType`：Student实体类中teacher属性是Teacher类型。

`select`：子查询语句的id。

> 联表查询----按照结果查询

```xml

<select id="getStudentList2" resultMap="StudentTeacher2">
    select s.id sid,s.name sname,t.name tname,t.id tid
    from student s,teacher t
    where s.tid=t.id;
</select>

<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
        <result property="id" column="tid" />
    </association>
</resultMap>
```

查询结果：

`Student(id=1, name=小明, teacher=Teacher(id=1, name=秦老师))`
`Student(id=2, name=小红, teacher=Teacher(id=1, name=秦老师))`
`Student(id=3, name=小张, teacher=Teacher(id=1, name=秦老师))`
`Student(id=4, name=小李, teacher=Teacher(id=2, name=黄老师))`
`Student(id=5, name=小王, teacher=Teacher(id=1, name=秦老师))`

### 2. 一对多

获取指定老师的信息以及所有学生信息。

处理实体类

```
//学生实体类
@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}

//老师实体类
@Data
public class Teacher {
    private int id;
    private String name;
    //老师对应的学生集合
    private List<Student> students;
}
```

> 联表查询

```xml

<select id="getTeacher" resultMap="TeacherStudent">
    select s.id sid,s.name sname,t.name tname,t.id tid
    from student s, teacher t
    where s.tid=t.id and t.id=#{tid}
</select>

<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid"/>
    <result property="name" column="tname"/>
    
    <collection property="students" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection>
</resultMap>
```

> 子查询

```XML

<select id="getTeacher2" resultMap="TeacherStudent2">
    select * from mybatis.teacher where id=#{tid}
</select>
<resultMap id="TeacherStudent2" type="Teacher">
    <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
</resultMap>
<select id="getStudentByTeacherId" resultType="Student">
    select * from mybatis.student where tid=#{tid}
</select>
```

**建议使用联表查询**。

## 9、动态SQL

**什么是动态SQL：动态SQL指的是根据不同的条件生成不同的SQL语句。**

> 搭建环境

```sql
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 '浏览量'
)ENGINE=INNODB DEFAULT CHARSET=utf8
```

> 实体类

```
@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    /**属性名和数据库字段名不一致，可以在配置文件中设置mapUnderscoreToCamelCase值
    <setting name="mapUnderscoreToCamelCase" value="true"/>  */
    private Date createTime;
    private int views;
}
```

>  使用UUID类创建ID

```java
public class IDutils {
    public static String getId(){
        return UUID.randomUUID().toString().replace("-", "");
    }

@Test
    public void test(){
        System.out.println(IDutils.getId());
    }
}
```

### 1. if

> Mapper.xml

```xml
<select id="queryBlogIf" parameterType="map" resultType="blog">
    select * from mybatis.blog where 1=1
    <if test="titleaa != null">
        and title = #{titleaa}
    </if>
    <if test="authoraa != null">
        and author = #{authoraa}
    </if>
</select>
```

**`if`标签内`test`表示条件。**

但是这里还是会出现一个问题就是多余了 `where 1=1`，这是不正规，但是如果没有这个条件在拼接SQL时出现`AND`和`OR`，导致语法错误。

改造，使用`where`标签。

```xml
<select id="queryBlogIf" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <if test="titleaa != null">
            and title = #{titleaa}
        </if>
        <if test="authoraa != null">
            and author = #{authoraa}
        </if>
    </where>
</select>
```

> 测试

```java
public void testqueryBlogIf(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try {
            BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
            HashMap map = new HashMap();
//            map.put("titleaa", "Java");
            map.put("authoraa", "狂神说");
            List<Blog> blogs = mapper.queryBlogIf(map);
            for (Blog blog : blogs) {
                System.out.println(blog);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            sqlSession.close();
        }
    }
```

### 2. choose (when, otherwise)

+ `choose` ：MyBatis 提供了的choose 元素像 Java 中的 switch 语句。
+ `when`：当以第一满足条件时直接拼接后续即便满足也不会再拼接。
+ `otherwise`：当when条件都不满足时拼接。

> Mapper.xml

```xml
<select id="queryBlogChoose" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <choose>
            <when test="titleaa != null">
                and title=#{titleaa}
            </when>
            <when test="authoraa!=null">
                and author=#{authoraa}
            </when>
            <otherwise>
                and views=#{viewaa}
            </otherwise>
        </choose>
    </where>
</select>
```

>  测试

```java
public void testqueryBlogChoose(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try {
            BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
            HashMap map = new HashMap();
//            map.put("titleaa", "Java");
//            map.put("authoraa", "狂神说");
            map.put("viewaa", 9999);
            List<Blog> blogs = mapper.queryBlogChoose(map);
            for (Blog blog : blogs) {
                System.out.println(blog);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            sqlSession.close();
        }
    }
```

### 3. trim (where, set)

> Mapper.xml

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

`set` 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

可以自定义` trim` 元素来定制` where `元素的功能。

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

> 测试

```java
public void testUpdateBlog(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    try {
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        map.put("title", "JavaWeb");
        map.put("author", "狂神说Java");
        map.put("id", "89fde7b2e83e4ae3b2505b3fec27967f");
        mapper.updateBlog(map);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        sqlSession.close();
    }
}
```

### 4. foreach

对集合进行遍历（尤其是在构建 IN 条件语句的时候）。

![image-20220302093617149](E:\IDEA_Projects\Mybatis_Study\note.assets\image-20220302093617149.png)

> 	Mapper.xml

```xml
<select id="queryBlogForeach" parameterType="map" resultType="Blog">
    select * from mybatis.blog
    <where>
        <foreach collection="ids" item="id" open="(" close=")" separator="or">
            id=#{id}
        </foreach>
    </where>
</select>
```

> 测试

```xml
public void testQueryBlogForeach(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    try {
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap hashMap = new HashMap();
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        hashMap.put("ids", list);
        List<Blog> blogs = mapper.queryBlogForeach(hashMap);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
    }
    sqlSession.close();
}
```

> 拼接的SQL

```==>  Preparing: select * from mybatis.blog WHERE ( id=? or id=? or id=? )  ```
```==> Parameters: 1(Integer), 3(Integer), 4(Integer)```

### 5、SQL片段

将某些公共SQL提取出来，方便复用。

1. 使用`sql`标签抽取出公共部分。

```xml
   <sql id="queryBlogIf-sql">
       <if test="titleaa!=null">
           title=#{titleaa}
       </if>
       <if test="authoraa!=null">
           and author=#{authoraa}
       </if>
   </sql>
   ```

2. 在需要使用的时候使用`include`标签引用即可。

```xml
   <select id="queryBlogIf" parameterType="map" resultType="blog">
       select * from mybatis.blog
       <where>
           <include refid="queryBlogIf-sql"></include>
       </where>
   </select>
   ```

3. 注意
   1. 最好基于单表定义SQL片段，多张表时不适用。
   2. 不要存在`where`标签。

## 10、缓存

### 1. 一级缓存

> 一级缓存也叫本地缓存： SqlSession

+ 与数据库同一次会话期间查询的数据会放在本地缓存中。
+ 以后如果需要获取相同数据，直接从缓存中取，不在查询数据库。
+ 一级缓存默认开启，也无法关闭。

>  测试

1. 开启日志

2. 测试在一个SqlSession中查询两次相同记录

```JAVA
   public void testQueryUserById(){
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           try {
               UserMapper mapper = sqlSession.getMapper(UserMapper.class);
               User user = mapper.queryUserById(2);
               System.out.println(user);
               System.out.println("==========一级缓存在sqlSession中有效，默认开启============");
               User user2 = mapper.queryUserById(2);
               System.out.println(user2);
               System.out.println("===============user == user2=======");
               System.out.println(user == user2);
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               sqlSession.close();
           }
       }
   ```

3. 查看日志输出

![image-20220302102944828](E:\IDEA_Projects\Mybatis_Study\note.assets\image-20220302102944828.png)

4. 缓存失效
   1. 查询不同记录
   2. 增删改改变原来的记录，导致刷新缓存
   3. 查询不同的Mapper.xml
   4. 手动清理缓存` sqlSession.clearCache();`

### 2. 二级缓存

> 二级缓存也叫全局缓存，解决一级缓存作用域低的问题

+ 基于namespace级别的缓存，一个名称空间，对应一个二级缓存。
+ 工作机制：
  + 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中。
  + 如果会话关闭，这个对话的一级缓存就消失了，但是一级缓存中的可以保存到二级缓存。
  + 新的会话查询信息，就可以从二级缓存中获取内容。
  + 不同的mapper查询出的数据会放在自己对应的缓存（map）中。

> 测试

1. 显示开启全局缓存

```xml
   <settings>
       
       <setting name="cacheEnabled" value="true"/>
   </settings>
   ```

2. 在当前Mapper中开启二级缓存`<cache/>`

```xml
   <cache/>
   ```

当然也可以自定义参数

```xml
   <cache
     eviction="FIFO"
     flushInterval="60000"
     size="512"
     readOnly="true"/>
   ```

**查询顺序： 先查看二级缓存中是否存在===》一级缓存中是否存在  ===》 数据库**

### 3. 自定义缓存——Ehcache

> Ehcache是一种广泛使用的开源Java分布式缓存，主要面向通用缓存。

1. 导入依赖

```xml
   <dependency>
       <groupId>org.mybatis.caches</groupId>
       <artifactId>mybatis-ehcache</artifactId>
       <version>1.1.0</version>
   </dependency>
   ```

2. 在当前Mapper.xml文件中使用自定义缓存

```xml
   <cache type="org.mybatis.caches.ehcache.EhcacheCache" />
   ```

3. 添加配置文件`ehcache.xml`。

```xml
   <?xml version="1.0" encoding="UTF-8"?>
   <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
            updateCheck="false">
   
       <diskStore path="./tmpdir/Tmp_EhCache"/>
   
       <defaultCache
               eternal="false"
               maxElementsInMemory="10000"
               overflowToDisk="false"
               diskPersistent="false"
               timeToIdleSeconds="1800"
               timeToLiveSeconds="259200"
               memoryStoreEvictionPolicy="LRU"/>
   
       <cache
               name="cloud_user"
               eternal="false"
               maxElementsInMemory="5000"
               overflowToDisk="false"
               diskPersistent="false"
               timeToIdleSeconds="1800"
               timeToLiveSeconds="1800"
               memoryStoreEvictionPolicy="LRU"/>
   </ehcache>
   ```

## 11、面试题

### 1、Mybatis的优缺点

+ 优点：
  + 基于SQL语句编程，相当**灵活**，不会对应用程序或者数据库的现有设计造成任何影响，SQL写在XML里，解除sql与程序代码的**耦合**，便于**统一管理**；提供XML标签，支持编写**动态SQL语句**，并**可重用**。
  + 与JDBC相比，减少了50%以上的代码量，**消除**了JDBC大量**冗余**的代码，不需要手动开关连接；
  + 很好的与各种数据库**兼容**（因为MyBatis使用jDBC来连接数据库，所以只要JDBC支持的数据库MyBatis都支持）。
  + 能够与Spring很好的集成；
  + 提供**映射标签**，支持对象与数据库的**ORM（对象关系映射）**字段关系映射；提供对象关系映射标签，支持对象关系组件维护。
+ 缺点：
  + SQL语句的编写**工作量较大**，尤其当字段多、关联表多时，对开发人员编写SQL语句的功底有一定要求。
  + SQL语句依赖于数据库，导致数据库**移植性差**，不能随意更换数据库。

### 2、MyBatis与Hibernate有哪些区别

MyBatis主要是对SQL的编写，而Hibernate更多是对象关系映射。

+ 学习成本

Hibernate是一个重量级的框架，正真掌握需要比MyBatis难，MyBatis相对容易上手；

+ 开发速度

如果业务场景仅仅是简单增删改查不涉及复杂查询，Hibernate更快，因为它已经封装好了SQL

如果针对大型项目有许多复杂语句，MyBatis会更灵活，开发效率也会更高；

+ 工作量

均有对应的代码生成工具，可以生成简单的DAO层方法；针对高级查询，Mybatis需要手动编写SQL、ResultMap，而Hibernate有良好的映射机制，无需关注SQL生成以及结果映射，可以更加专注与业务流程。

+ SQL优化

Hibernate默认会讲表中所有字段查询出来，会比较消耗性能，MyBatis手动编写，可按照需求查询字段；

Hibernate调优需要打印SQL，而其形态比较难理解；但是Hibernate有自带日志统计功能；

### 3、Mybatis插件运行原理

Mybatis只支持针对

+ ParameterHandler：参数处理，解决Java数据类型与数据库支持类型的一个转换等问题；

+ ResultSetHandler  ：JDBC中结果集映射处理；

+ StatementHandler：设置参数以及结果集的转换；

+ Executor：Mybatis核心，用于SQL生成以及SQL语句的查询缓存维护；

这4种接口的插件，Mybatis使用JDK的**动态代理**，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这4种接口对象的方法时，就会进入拦截方法，具体就是**InvocationHandler**的invoke（）方法，拦截那些你指定需要拦截的方法。

三淳/Mybatis_Study

简介

发行版

贡献者

近期动态

三淳/Mybatis_Study .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

三淳/Mybatis_Study