ssm第一讲--Mybatis详细学习

Mybatis学习

本文图文学习教程
学自b站狂神：狂神说–Mybatis篇

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，并且改名为MyBatis 。
• 2013年11月迁移到Github。

如何获取Mybais:

• maven仓库：

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

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

• Github源码：https://github.com/mybatis/mybatis-3/releases

1.2持久化

数据持久化：

• 持久化就是将程序在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 即将数据从原来不“稳定”的内存中转移到“稳定”的数据库的过程
• 举例：冷藏食物

为什么需要持久化：

• 防止丢失重要信息
• 内存太贵了，
• 存放在数据库，即用即取更好

1.3持久层

Dao层、Service层、Controller层…

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

1.4为什么需要Mybatis?

• 帮助程序猿更加方便的将存入到数据库中

• 传统的JDBC代码太复杂了。

• 框架更加简化，更加自动化，易上手。

• 使用人群多。

• 优点：

  • 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
  • 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
  • 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
  • 提供映射标签，支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签，支持对象关系组建维护
  • 提供xml标签，支持编写动态sql。

2.第一个Mybatis程序

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

2.1搭建环境

搭建数据库：

CREATE DATABASE `mybatis`;

Use `mybatis`;

create table `user`(
	`id`  INT(20) NOT NULL PRIMARY KEY, 
	`name` VARCHAR(30) DEFAULT NULL,
  `pwd` VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT into user VALUES(1,"刘一手","123");

INSERT into user VALUES(2,"刘二手","123"),(3,"刘三手","123"),(4,"刘四手","123");

INSERT into user(id,name) VALUES(5,"刘五手");

新建项目

1. 新建一个普通的maven项目,注：固定Maven路径

2. 删除src目录，将项目作为父工程

3. 导入maven依赖

<?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.lxf</groupId>
    <artifactId>20200604-Mybatis-study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--导入依赖-->
    <dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--mybatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

2.2创建一个子模块

• 编写mybatis的核心配置文件

连接数据库错误解决：https://blog.csdn.net/ITMan2017/article/details/100601438

<?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"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="xxxx"/>
            </dataSource>
        </environment>
    </environments>
     <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
     <!--namespace中的包名要和Dao/mapper接口的包名一致！-->
    <mappers>
        <mapper resource="com/lxf/dao/UserMapper.xml"></mapper>
    </mappers>
</configuration>

• 编写mybatis工具类

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

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            //使用Mybatis第一步：获取sqlSessionFactory对象
            InputStream inputStream = MybatisUtils.class.getResourceAsStream("/mybatis-config.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//    public static void main(String[] args) {
//        System.out.println(sqlSessionFactory);
//    }

    //既然有了SqlSessionFactory,就可以从中获取SqlSession的实例了。
    //SqlSession  完全包含了面向数据库执行SQL命令所需的所有方法。
    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession();
    }

}

2.3编写代码

• 实体类

package com.lxf.pojo;

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

    public User() {
    }

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

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getPwd() {
        return pwd;
    }

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

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

• Dao接口

package com.lxf.dao;

import com.lxf.pojo.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserDao {
    //查询所有的User
    List<User> getUserList();
    
    //查询单独一个User
    User getUser(int id);
}

• 接口实现类(由原来的UserDaoImpl–>Mapper配置文件)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.lxf.dao.UserDao">
    <!--select查询语句-->
    <select id="getUserList" resultType="com.lxf.pojo.User">
        select * from mybatis.user;
  </select>
</mapper>

2.4测试

出错点：

1.org.apache.ibatis.binding.BindingException:Type interface com.lxf.dao.UserDao is not konwn to the MapperRegistry

:每一个Mapper.xml没有在Mybatis核心配置文件中注册！

2.路径正确但是Mapper.xml文件资源无法找到：因为maven项目约定大于配置，资源只会在resource文件夹下搜索，pom.xml文件加上以下配置就可以解决错误：

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

测试类（Junit）:

package com.lxf.dao;

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

public class UserDaoTest {
    @Test
    public void test(){


        SqlSession sqlSession =null;
        try{
            //1.获取session
            sqlSession=MybatisUtils.getSqlSession();
            //2.执行SQL
            //方式一(推荐)：
            UserDao userDao = sqlSession.getMapper(UserDao.class);
            System.out.println("userDao.getUserList() = " + userDao.getUserList());

            //方式二：
            User user = sqlSession.selectOne("getUser", 1);
            System.out.println("user = " + user);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭sqlSession
            sqlSession.close();
        }
    }
}

2.5.增删改查

1.修改UserMapper接口：

package com.lxf.dao;

import com.lxf.pojo.User;

import java.util.List;

public interface UserMapper {
    //方式一：
    //查询所有的User,配置在mapper.xml文件中
    List<User> getUserList();

    //查询单独一个User，注解不需要配置xml文件
    User getUserById(int id);

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

    //增加多个用户
    int addUsers(List<User> users);

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

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

}

2.修改mapper.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">
<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.lxf.dao.UserMapper">


    <!--select查询语句,查询所有的User-->
    <select id="getUserList" resultType="com.lxf.pojo.User">
        select * from mybatis.user;
  </select>



    <!--select查询语句,查询id对应的User-->
    <select id="getUserById" resultType="com.lxf.pojo.User" parameterType="int">
        select * from mybatis.user where id=#{id};
  </select>


    <!--insert插入语句,插入一个数据-->
    <insert id="addUser" parameterType="com.lxf.pojo.User">
        insert into mybatis.user values(#{id},#{name},#{pwd});
  </insert>


    <!--修改语句,修改一个数据-->
    <update id="updateUser" parameterType="com.lxf.pojo.User" >
        update User as u set u.pwd=#{pwd},u.name=#{name} where u.id=#{id};
    </update>


    <!--insert插入语句,插入多个数据-->
    <insert id="addUsers" parameterType="java.util.List" useGeneratedKeys="true">
        INSERT INTO User (id,name,pwd)
        VALUES
        <foreach collection="list"  separator="," item="item">
            (#{item.id,jdbcType=INTEGER},
            #{item.name,jdbcType=VARCHAR},
            #{item.pwd,jdbcType=VARCHAR})
        </foreach>
  </insert>

	<!--delete删除语句，删除指定用户-->
    <delete id="deleteUser" parameterType="int">
        delete from User where id=#{id};
    </delete>
</mapper>

3.编写测试类：

package com.lxf.dao;

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

import java.util.ArrayList;
import java.util.List;

public class UserMapperTest {
    @Test
    public void test(){
        SqlSession sqlSession =null;
        try{
            //1.获取session
            sqlSession=MybatisUtils.getSqlSession();
            //2.执行SQL
            //方式一(推荐)：
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            System.out.println("userDao.getUserList() = " + userMapper.getUserList());

            //方式二：
            //User user = sqlSession.selectOne("getUser", 1);
            //System.out.println("user = " + user);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭sqlSession
            sqlSession.close();
        }
    }
    @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //根据id查询一个用户
//        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//        User user = mapper.getUserById(1);
//        System.out.println("user = " + user);

        //增加一个用户
//        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//       int i=mapper.addUser(new User(9,"刘德华","234"));
//          if(i>0){
//            System.out.println("插入多条数据成功");
//         }

        //增加多个用户
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList=new ArrayList<User>();
        userList.add(new User(10,"张学友","zxy"));
        userList.add(new User(11,"周润发","zrf"));
        userList.add(new User(12,"周星驰","zxc"));
        int i = mapper.addUsers(userList);
        if (i>0){
            System.out.println("插入多条数据成功");
        }

        //修改一个用户
        //UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //mapper.updateUser(new User(8,"刘八手","888"));

        //删除指定的一个用户
//        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//        mapper.deleteUser(8);

        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }
}

注意点：

1. 增删改需要提交事务

2. 在增加多个数据时，url要加上：&allowMultiQueries=true

3. mapper文件中如果错用标签会发生截然不同的事情，例如：在select标签下sql用增加语句，会导致查询后返回为null,且不需要提交事务。原因：select标签下也可以用其他的查询语句，但select标签默认返回值为null，且不需要提交事务。

2.6万能Map

如果我们的实体类含有大量字段，但是在插入、修改的时候不需要全部填写，就可以用这种方法省时省力

UserMapper接口：

//增加一个用户，万能Map方式
    int addUser2(Map<String,Object> map);

UserMapper.xml配置文件

  <!--insert插入语句，万能Map法-->
    <insert id="addUser2">
        insert into mybatis.user(id,name) values(#{userId},#{userName});
    </insert>

测试类：

 @Test
    public void addUser2(){
        //获取session对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //获取UserMapper对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        Map<String,Object> map=new HashMap<String,Object>();
        map.put("userId",14);
        map.put("userName","王小法");

        //执行方法
        int  i=userMapper.addUser2(map);
        if(i>0){
            System.out.println("插入成功！");
        }
        sqlSession.commit();
        sqlSession.close();
    }

2.7.模糊查询：

1.传统挺配符：% %

List<User> usersLike = userMapper.getUsersLike("%周%");

2.在sql拼接中使用通配符

 select * from user where name like "%"#{value}"%";

3.注意

标签中注释的sql也会编译，所以不用的sql就要删了，注释没用，会报错，一般就是参数数量不匹配。

3.配置解析

1.核心配置文件

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

2.环境配置（environments）

<!--default:默认的环境,写哪个id就对应哪个环境-->
<environments default="test">
    <environment id="development">
        <!--transactionManager:事务管理,
			type:[JDBC|MANAGED]
			JDBC:– 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域(默认)。
			MANAGED:这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器(例如EJB)并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。
		-->
        <transactionManager type="JDBC"/>
        <!--
 			type=[UNPOOLED|POOLED|JNDI]
			UNPOOLED：这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对那些数据库连接可用性要求不高的简单应用程序来说，是一个很好的选择。 性能表现则依赖于使用的数据库，对某些数据库来说，使用连接池并不重要，这个配置就很适合这种情形。
			POOLED： 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这种处理方式很流行，能使并发 Web 应用快速响应请求。
			JNDI – 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用。
		-->
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mybatis?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;allowMultiQueries=true"/>
            <property name="username" value="xxx"/>
            <property name="password" value="xxx"/>
        </dataSource>
    </environment>
    
    
    <environment id="test">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mybatis?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;allowMultiQueries=true"/>
            <property name="username" value="xxx"/>
            <property name="password" value="xxx"/>
        </dataSource>
    </environment>
</environments>

3.属性（properties）

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

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。【db.properties】

编写配置文件：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?userSSL=true&useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true
username=xxx
password=xxx

mybatis-config.xml文件配置：

 	<!--引入外部配置文件-->
    <properties resource="db.properties"/>
	<!-直接配置：可以增加，或者全部配置-->
	<!-若外部配置文件与这里重复，优先外部-->
    <!--<properties resource="db.properties">
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;allowMultiQueries=true"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </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>

常见错误：

4.类型别名（typeAliases）

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

1.直接指定一个类，然后给他起别名（可以DIY别名）

Mybatis.xml文件：

<!--可以给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.lxf.pojo.User" alias="User"/>
    </typeAliases>

UserMapper.xml:

 <!--select查询语句,查询id对应的User-->
    <select id="getUserById" resultType="User" parameterType="int">
        select * from mybatis.user where id=#{id};
  </select>

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

扫描实体类的包，它的默认别名就为这个类的类名，首字母小写。就例如扫描com.lxf.pojo,pojo下有两个类：User、Student

那么他们两个的包路径别名分别为user、student(包名多的时候非常有用，默认是类名首字母小写).

如要DIY类名：在这个包下的类上加上注解：@Alias(“xxx”)

Mybatis.xml文件：

 <!--可以给实体类起别名-->
    <typeAliases>
        <package name="com.lxf.pojo"/>
    </typeAliases>

UserMapper.xml:

 <!--select查询语句,查询id对应的User-->
    <select id="getUserById" resultType="User" parameterType="int">
        select * from mybatis.user where id=#{id};
  </select>

5.设置

6.映射器

MapperRegistry:注册绑定我们的Mapper文件；

方式一【推荐使用】：

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

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

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

注意点：

• 接口和他的Mapper配置文件必须同名！

• 接口和他的Mapper配置文件必须在同一个包下！

方式三：使用扫描包进行注入

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

注意点：

• 接口和他的Mapper配置文件必须同名！

• 接口和他的Mapper配置文件必须在同一个包下！

7.生命周期与作用域

生命周期和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题

SqlSessionFactory

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

SqlSessionFactory：

• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
• 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。
• 因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。
• 类似于全局变量

SqlSession

• 每个线程都应该有它自己的 SqlSession 实例（连接到连接池的一个请求！）。
• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
• 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。
• 用完即关闭，类似于局部变量

4.解决属性名与字段名不一致的问题

数据库的字段：

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

测试问题：查出来的字段password为null（数据库不为null）

 select * from mybatis.user where id=#{id};
 类型处理器
 select id,name,pwd from mybatis.user where id=#{id};

解决方法：

1. 起别名

   select id,name,pwd as password from mybatis.user where id=#{id};
   

2. resultMap

结果集映射

resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来，并在一些情形下允许你进行一些 JDBC 不支持的操作。实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的数千行代码。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

id name pwd
id name password

UserMapper.xml文件配置：

 <!--select查询语句,查询id对应的User-->
    <select id="getUserById" resultMap="UserMap" parameterType="int">
       select *  from mybatis.user where id=#{id};
  </select>
    <!--结果集映射-->
    <resultMap id="UserMap" type="user">
        <!--column:数据库中的字段，property:实体类中的属性-->
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwd" property="password"/>
    </resultMap>

5.日志

5.1日志工厂

• 如果一个数据库操作，出现了异常，我们需要排错。

• 日志可以打印清晰的日志信息，方便我们查询错误信息、sql信息、步骤信息等

• 曾经：sout、debug。现在：日志

• SLF4J
• LOG4J 【掌握】
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING 【掌握】
• NO_LOGGING

在Mybatis具体使用哪一日志，在设置中设定！

1.STDOUT_LOGGING 标准日志输出Mapper.xml配置：

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

注意：logImpl大小写要注意，名字和值都不能多出空格

2.log4j

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

（1）、先导入log4j的包

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

(2)、log4j.properties

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出到相关配置
log4j.appender.console=org.apache.log4j.ConsoleAppender
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
log4j.appender.file.File=./log/lxf.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为日志的实现

 <!--设置-->
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

4.log4j的使用

"C:\Program Files\Java\jdk1.8.0_161\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.4\lib\idea_rt.jar=65112:C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.4\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.4\lib\idea_rt.jar;C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.4\plugins\junit\lib\junit5-rt.jar;C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.4\plugins\junit\lib\junit-rt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\rt.jar;C:\Users\dell\IdeaProjects\20200604-Mybatis-study\mybatis-03\target\test-classes;C:\Users\dell\IdeaProjects\20200604-Mybatis-study\mybatis-03\target\classes;E:\maven\repository\log4j\log4j\1.2.17\log4j-1.2.17.jar;E:\maven\repository\mysql\mysql-connector-java\5.1.47\mysql-connector-java-5.1.47.jar;E:\maven\repository\org\mybatis\mybatis\3.5.2\mybatis-3.5.2.jar;E:\maven\repository\junit\junit\4.12\junit-4.12.jar;E:\maven\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 com.lxf.dao.UserMapperTest,test
[org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
[org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.io.VFS]-Class not found: org.jboss.vfs.VFS
[org.apache.ibatis.io.JBoss6VFS]-JBoss 6 VFS API is not available in this environment.
[org.apache.ibatis.io.VFS]-Class not found: org.jboss.vfs.VirtualFile
[org.apache.ibatis.io.VFS]-VFS implementation org.apache.ibatis.io.JBoss6VFS is not valid in this environment.
[org.apache.ibatis.io.VFS]-Using VFS adapter org.apache.ibatis.io.DefaultVFS
[org.apache.ibatis.io.DefaultVFS]-Find JAR URL: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/test-classes/com/lxf/dao
[org.apache.ibatis.io.DefaultVFS]-Not a JAR: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/test-classes/com/lxf/dao
[org.apache.ibatis.io.DefaultVFS]-Reader entry: UserMapperTest.class
[org.apache.ibatis.io.DefaultVFS]-Listing file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/test-classes/com/lxf/dao
[org.apache.ibatis.io.DefaultVFS]-Find JAR URL: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/test-classes/com/lxf/dao/UserMapperTest.class
[org.apache.ibatis.io.DefaultVFS]-Not a JAR: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/test-classes/com/lxf/dao/UserMapperTest.class
[org.apache.ibatis.io.DefaultVFS]-Reader entry: ����   4 W
[org.apache.ibatis.io.DefaultVFS]-Find JAR URL: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/classes/com/lxf/dao
[org.apache.ibatis.io.DefaultVFS]-Not a JAR: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/classes/com/lxf/dao
[org.apache.ibatis.io.DefaultVFS]-Reader entry: UserMapper.class
[org.apache.ibatis.io.DefaultVFS]-Reader entry: UserMapper.xml
[org.apache.ibatis.io.DefaultVFS]-Listing file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/classes/com/lxf/dao
[org.apache.ibatis.io.DefaultVFS]-Find JAR URL: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/classes/com/lxf/dao/UserMapper.class
[org.apache.ibatis.io.DefaultVFS]-Not a JAR: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/classes/com/lxf/dao/UserMapper.class
[org.apache.ibatis.io.DefaultVFS]-Reader entry: ����   4 	 
 getUserById
 (I)Lcom/lxf/pojo/User;
 
[org.apache.ibatis.io.DefaultVFS]-Find JAR URL: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/classes/com/lxf/dao/UserMapper.xml
[org.apache.ibatis.io.DefaultVFS]-Not a JAR: file:/C:/Users/dell/IdeaProjects/20200604-Mybatis-study/mybatis-03/target/classes/com/lxf/dao/UserMapper.xml
[org.apache.ibatis.io.DefaultVFS]-Reader entry: <?xml version="1.0" encoding="UTF-8" ?>
[org.apache.ibatis.io.ResolverUtil]-Checking to see if class com.lxf.dao.UserMapperTest matches criteria [is assignable to Object]
[org.apache.ibatis.io.ResolverUtil]-Checking to see if class com.lxf.dao.UserMapper matches criteria [is assignable to Object]
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Opening JDBC Connection
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1095293768.
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4148db48]
[com.lxf.dao.UserMapper.getUserById]-==>  Preparing: select * from mybatis.user where id=?; 
[com.lxf.dao.UserMapper.getUserById]-==> Parameters: 1(Integer)
[com.lxf.dao.UserMapper.getUserById]-<==      Total: 1
user = User{id=1, name='刘一手', password='123'}
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4148db48]
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4148db48]
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Returned connection 1095293768 to pool.

Process finished with exit code 0

4.简单使用

• 在要使用的类中，导入import org.apache.log4j.Logger;
• new一个logger对象，开始测试

 private static Logger logger=Logger.getLogger(UserMapperTest.class);
    @Test
    public void logTest(){
        logger.info("成功进入");
        logger.debug("debug信息");
        logger.error("错误信息");
    }

• 结果

[com.lxf.dao.UserMapperTest]-成功进入
[com.lxf.dao.UserMapperTest]-debug信息
[com.lxf.dao.UserMapperTest]-错误信息

6.分页

为什么分页：减少数据的处理量

6.1使用Limit分页

select * from user limit startIndex,pageSize;
select * from user limit 0,2;

使用Mybatis实现分页，核心SQL

1. 接口

//分页查询
    List<User> getUserBylimit(Map<String,Integer> map);

2. Mapper.xml

<!-- 分页查询-->
<select id="getUserBylimit" resultMap="userMap" parameterType="map">
    select * from user limit #{startIndex},#{pageSize};
</select>

3. 测试

 @Test
    public void getUserByLimit(){
        //获取SqlSession对象
        SqlSession session = MybatisUtil.getSession();

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

        Map<String,Integer> map=new HashMap<String,Integer>();
        //给map添加键值对
        map.put("startIndex",1);
        map.put("pageSize",2);
        //执行方法
        List<User> userBylimit = mapper.getUserBylimit(map);
        for (User user : userBylimit) {
            System.out.println("user = " + user);
        }
        //关闭session
        session.close();

    }

6.2RowBounds分页

UserMapper.java接口：

  //分页查询2
    List<User> getUserByRoundBounds();

UserMapper.xml配置文件：

 <!-- 分页查询2-->
    <select id="getUserByRoundBounds" resultMap="userMap">
        select * from user;
    </select>

测试类：

  @Test
    public void getUserByRowBounds(){
        //获取SqlSession对象
        SqlSession session = MybatisUtil.getSession();

        //RowBounds实现
        RowBounds rowBounds = new RowBounds(1, 3);

        List<User> users = session.selectList("com.lxf.dao.UserMapper.getUserByRoundBounds", null, rowBounds);

        for (User user : users) {
            System.out.println("user = " + user);
        }
        //关闭session
        session.close();
    }

6.3分页插件（了解即可）

7.使用注解开发

7.1运行过程

1. 注解在接口上实现

    @Select(value = "select * from user")
    List<User> getUsers();

2. 需要在核心配置文件中绑定

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

3.测试（和之前的Mapper方法一样）

运行过程拓展：

7.2增删改查

1.UserMapper.java接口类

package com.lxf.dao;


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

import java.util.List;

public interface UserMapper {
    @Select(value = "select * from user")
    List<User> getUsers();

    //方法存在多个参数，必须每个参数前面必须加上@Param注解
    @Select(value = "select * from user where id =#{id}")
    User getUserById(int id2);

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

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

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

2.测试类

import com.lxf.dao.UserMapper;
import com.lxf.pojo.User;
import com.lxf.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserMapperTest {

    //查询一个数据
    @Test
    public void test(){
        SqlSession session = MybatisUtil.getSession();

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

//        List<User> users = mapper.getUsers();
//
//        for (User user : users) {
//            System.out.println("user = " + user);
//        }
        User user = mapper.getUserById(1);
        System.out.println("user = " + user);
        session.close();
    }
    //增加一个数据
    @Test
    public void test2(){
        SqlSession session = MybatisUtil.getSession();

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

        int i = mapper.addUser(new User(15,"成龙","cl"));
        if(i>0){
            System.out.println("插入成功！");
        }
        session.close();
    }
    //更新一个数据
    @Test
    public void test3(){
        SqlSession session = MybatisUtil.getSession();

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

        int i = mapper.updateUser(new User(14,"刘小法","lxf"));
        if(i>0){
            System.out.println("更新成功！");
        }
        session.close();
    }


    //删除一个用户
    @Test
    public void test4(){
        SqlSession session = MybatisUtil.getSession();

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

        int i = mapper.deleteUser(5);
        if(i>0){
            System.out.println("删除成功！");
        }
        session.close();
    }

}

3.注意：

• 我已经在工具类设置自动提交，所以增删改不需要提交事务

  //返回selsession，并设置自动提交为true
  return sqlSessionFactory.openSession(true);

• 在使用注解开发时，方法存在多个参数，必须每个参数前面必须加上@Param注解，而且如果Param指定名字，sql语句中的也要对应

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

• 接口类也要注册到mybatis-config.xml文件中

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

8.多对一处理

• 对学生而言，关联，多个学生关联一个老师【多对一】
• 对老师而言，集合，一个老师教多个学生【一对多】

SQl数据库建立对应的表：

CREATE TABLE `teacher`(
`id` INT(10) not NULL PRIMARY KEY,
`name` VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO teacher(id,name) VALUES(1,'刘老师');

create table `student`(
	`id` INT(10) not null PRIMARY KEY,
	`name` VARCHAR(30) DEFAULT null,
	`tid` INT(10) DEFAULT null,
	KEY `fktid` (`tid`),
	CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO student(id,name,tid) VALUES(1,'小明',1);
INSERT INTO student(id,name,tid) VALUES(2,'小红',1);
INSERT INTO student(id,name,tid) VALUES(3,'小张',1);
INSERT INTO student(id,name,tid) VALUES(4,'小李',1);
INSERT INTO student(id,name,tid) VALUES(5,'小王',1);

测试环境搭建

1. 导入lombok
2. 新建实体类Teacher、Student
3. 建立Mapper接口
4. 建立Mapper.xml文件
5. 在核心配置文件中绑定注册我们的Mapper接口或者文件！
6. 测试查询是否成功！

8.1按照查询嵌套处理

Student类：

package com.lxf.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

    //学生需要关联一个老师！
    private Teacher teacher;
}

Teacher类

package com.lxf.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

StudentMapper.java接口

package com.lxf.dao;

import com.lxf.pojo.Student;

import java.util.List;

public interface StudentMapper {
    //查询所有的学生信息，以及对应的老师的信息！
    List<Student> getStudents();
}

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">
        <!--configuration核心配置文件-->
<mapper namespace="com.lxf.dao.StudentMapper">
        <select id="getStudents" resultMap="studentMap" >
                select * from student
        </select>

        <resultMap id="studentMap" type="Student">
                <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
        </resultMap>

        <select id="getTeacher" resultType="com.lxf.pojo.Teacher">
                select  * from teacher where id=#{id};
        </select>
</mapper>

测试类：

   @Test
    public  void getStudents(){
        SqlSession sqlSession = MybatisUtil.getSession();

        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);

        List<Student> students = studentMapper.getStudents();
        for (Student student: students) {
            System.out.println("student = " + student);
        }

        sqlSession.close();
    }

8.2按照结果嵌套处理

StudentMapper.java接口类：

//查询所有的学生信息，以及对应的老师的信息！
    List<Student> getStudents2();

StudentMapper.xml配置文件：

 <!--方式二：按结果嵌套处理-->
        <select id="getStudents2" resultMap="studentMap2">
                select s.id sid,s.name sname,t.name tname from student s,teacher t where s.tid=t.id;
        </select>

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

测试类：

 @Test
    public  void getStudents2(){
        SqlSession sqlSession = MybatisUtil.getSession();

        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);

        List<Student> students = studentMapper.getStudents2();
        for (Student student: students) {
            System.out.println("student = " + student);
        }

        sqlSession.close();
    }

9.一对多处理

比如：一个老师拥有多个学生！对于老师而言就是一对多的关系

1.环境搭建，和第8点一样

Student实体类：

package com.lxf.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

    //学生需要关联一个老师！
    private int tid;
}

Teacher实体类：

package com.lxf.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

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

    //一个学生拥有多个学生
    private List<Student> students;
}

9.1按照查询嵌套查询

TeacherMapper.java接口类：

//获取这个老师及其所有的学生
    Teacher getTeachers2(@Param("tid") int id);

TeacherMapper.java配置文件：

 <!--方式一：按查询嵌套处理-->
        <select id="getTeachers2" resultMap="teacherMap2" >
                select * from mybatis.teacher where id=#{tid};
        </select>
        <resultMap id="teacherMap2" type="com.lxf.pojo.Teacher">
                <result column="id" property="id"/>
                <result column="name" property="name"/>
                <collection property="students" column="id" javaType="ArrayList" ofType="com.lxf.pojo.Student" select="getStudentByTeacherId"/>
        </resultMap>

        <select id="getStudentByTeacherId" resultType="com.lxf.pojo.Student">
                select * from mybatis.student where tid=#{tid};
        </select>

测试类：

 @Test
    public void getTeachers2(){
        SqlSession sqlSession = MybatisUtil.getSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeachers2(1);
        System.out.println("teacher = " + teacher);
        sqlSession.close();
    }

9.2按照结果嵌套查询

TeacherMapper.java接口类：

  //获取这个老师及其所有的学生
    Teacher getTeachers3(@Param("tid") int id);

TeacherMapper.java配置文件：

 <!--方式二：按结果嵌套处理-->
        <select id="getTeachers3" resultMap="teacherMap3">
                select t.id tid,t.name tname,s.id sid,s.name sname,s.tid stid from teacher t,student s where t.id=#{tid} and s.tid=#{tid};
        </select>
        <resultMap id="teacherMap3" type="com.lxf.pojo.Teacher">
                <result property="id" column="tid"/>
                <result property="name" column="tname"/>
                <collection property="students" ofType="com.lxf.pojo.Student">
                        <result property="id" column="sid"/>
                        <result property="name" column="sname"/>
                        <result property="tid" column="stid"/>
                </collection>
        </resultMap>

测试类：

   @Test
    public void getTeachers3(){
        SqlSession sqlSession = MybatisUtil.getSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeachers3(1);
        System.out.println("teacher = " + teacher);
        sqlSession.close();
    }

小结：

1. 关联-association【多对一】

2. 集合-collection【一对多】

3. javaType & ofType

   1. javaType 用来指定实体类中属性的类型
   2. ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

注意点：

• 保证sql的可读性
• 注意一对多和多对一中，属性名和字段的问题！
• 如果问题不好排查错误，可以使用日志，建议使用Log4j

10.动态SQL

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

如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

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

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

10.1搭建环境

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` VARCHAR(30) NOT NULL COMMENT '创建时间',
		`views` INT(30) not null COMMENT '浏览量'
)ENGINE=INNODB DEFAULT CHARSET=utf8

创建一个基础工程

1. 导包
2. 编写配置文件
3. 编写实体类
4. 编写实体类对应的Mapper接口和Mapper.XML文件

10.2增加数据

BlogMapper.java接口文件：

  //插入数据
    int addBlog(Blog blog);

BlogMapper.xml配置文件：

 <insert id="addBlog" parameterType="com.lxf.pojo.Blog">
            insert into mybatis.blog(id,title,author,create_time,views) values (#{id},#{title},#{author},#{createTime},#{views});
        </insert>

测试类

  @Test
    public void addBlog(){
        SqlSession sqlSession = MybatisUtil.getSession();

        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        int i = mapper.addBlog(new Blog(IDUtils.getID(), "Mybatis学习方法", "刘一手", new SimpleDateFormat("yyyy-MM-dd HH-mm-ss").format(new Date()), 1060));
        int j = mapper.addBlog(new Blog(IDUtils.getID(), "SpringMVC学习方法", "刘二手", new SimpleDateFormat("yyyy-MM-dd HH-mm-ss").format(new Date()), 530));
        int k = mapper.addBlog(new Blog(IDUtils.getID(), "Spring5学习方法", "刘三手", new SimpleDateFormat("yyyy-MM-dd HH-mm-ss").format(new Date()), 777));
        int l = mapper.addBlog(new Blog(IDUtils.getID(), "SSM学习方法", "刘四手", new SimpleDateFormat("yyyy-MM-dd HH-mm-ss").format(new Date()), 666));
        if(i>0&&j>0&&k>0&&l>0){
            System.out.println("成功插入四条数据！");
        }
        sqlSession.close();
    }

10.3 IF查询

BlogMapper.java接口类

 //查询博客
    List<Blog> queryBlogIF(Map map);

BlogMapper.xml配置文件：

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

测试类：

	@Test
    public void queryBlogIF(){
        SqlSession sqlSession = MybatisUtil.getSession();

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

        HashMap map=new HashMap();
        map.put("title","Mybatis学习方法");
        map.put("author","刘四手");

        List<Blog> blogs = mapper.queryBlogIF(map);
        for (Blog blog : blogs) {
            System.out.println("blog = " + blog);
        }
        sqlSession.close();
    }

10.4choose(when、otherwise)查询

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

还是上面的例子，但是策略变为：传入了 “title” 就按 “title” 查找，传入了 “author” 就按 “author” 查找的情形。若两者都没有传入，就返回views大于多少的 BLOG（这可能是管理员认为，与其返回大量的无意义随机 Blog，还不如返回一些由管理员挑选的 Blog）。

BlogMapper.java接口类：

 //查询博客
    List<Blog> queryBlogChoose(Map map);

BlogMapper.xml配置文件：

<select id="queryBlogChoose" parameterType="map" resultType="com.lxf.pojo.Blog">
    select * from mybatis.blog
     <!--where在10.5中有示例-->
    <where>
        <choose>
            <when test="title !=null">
                title=#{title}
            </when>
            <when test="author !=null">
                author=#{author}
            </when>
            <otherwise>
                views > #{views}
            </otherwise>
        </choose>
    </where>
</select>

测试类：

 @Test
    public void queryBlogChoose(){
        SqlSession sqlSession = MybatisUtil.getSession();

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

        HashMap map=new HashMap();
        map.put("title","Mybatis学习方法");
        map.put("author","刘四手");
        map.put("views",666);

        List<Blog> blogs = mapper.queryBlogChoose(map);
        for (Blog blog : blogs) {
            System.out.println("blog = " + blog);
        }
        sqlSession.close();
    }

10.5trim、where、set标签

1.where标签

思考:如果没有where 1=1这个条件该怎么查？以下有解决方法:

<select id="queryBlogIF" parameterType="map" resultType="com.lxf.pojo.Blog">
            select * from  mybatis.blog where
            <if test="title !=null">
                 title=#{title}
            </if>
            <if test="author !=null">
                or author=#{author}
            </if>
        </select>

如果没有匹配的条件会怎么样？最终这条 SQL 会变成这样：

SELECT * FROM BLOG
WHERE

这会导致查询失败。如果匹配的只是第二个条件又会怎样？这条 SQL 会是这样:

SELECT * FROM BLOG
WHERE
or author=#{author}

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

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

 <select id="queryBlogIF" parameterType="map" resultType="com.lxf.pojo.Blog">
            select * from  mybatis.blog
            <where>
                <if test="title !=null">
                    title=#{title}
                </if>
                <if test="author !=null">
                    or author=#{author}
                </if>
            </where>
</select>

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

2.set标签

用于动态更新语句的类似解决方案叫做 set。set 元素可以用于动态包含需要更新的列，忽略其它不更新的列，它会检测，是否多余，多余则会自动去掉，比如下面最后views参数没传递就会造成,多余。

BlogMapper.java接口类：

//更新数据
    int updateBlogSet(Map map);

BlogMapper.xml配置文件：

 <!--update set标签-->
    <update id="updateBlogSet" parameterType="map" >
        update blog
        <set>
            <if test="title !=null">
                title=#{title},
            </if>
            <if test="author !=null">
                author=#{author},
            </if>
            <if test="views !=null">
                views=#{views}
            </if>
        </set>
        where id=#{id}
    </update>

测试类：

 @Test
    public void updateBlogSet(){
        SqlSession sqlSession = MybatisUtil.getSession();

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

        HashMap map=new HashMap();
        map.put("title","Mybatis学习简便方法");
        map.put("author","刘五手");
        //map.put("views",690);
        map.put("id","72bae714f52f4cf196e194114cb35b1f");
        int i = mapper.updateBlogSet(map);
        if(i>0){
            System.out.println("更新数据成功");
        }
        sqlSession.close();
    }

3.trim

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

如果 where 元素与你期望的不太一样，你也可以通过自定义 trim 元素来定制 where 元素的功能。比如，和 where 元素等价的自定义 trim 元素为：

<select id="queryBlogIF" parameterType="map" resultType="com.lxf.pojo.Blog">
            select * from  mybatis.blog
            <trim prefix="WHERE" prefixOverrides="AND |OR ">
                <if test="title !=null">
                    title=#{title}
                </if>
                <if test="author !=null">
                    or author=#{author}
                </if>
            </trim>
</select>

prefixOverrides 属性会忽略通过管道符分隔的文本序列（注意此例中的空格是必要的）。上述例子会移除所有 prefixOverrides 属性中指定的内容，并且插入 prefix 属性中指定的内容。

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

来看看与 set 元素等价的自定义 trim 元素吧：

<!--update set标签-->
    <update id="updateBlogSet" parameterType="map" >
        update blog
        <trim prefix="SET" suffixOverrides=",">
            <if test="title !=null">
                title=#{title},
            </if>
            <if test="author !=null">
                author=#{author},
            </if>
            <if test="views !=null">
                views=#{views}
            </if>
        </trim>
        where id=#{id}
    </update>

注意，我们覆盖了后缀值设置，并且自定义了前缀值。一般上面两种用where和set就可以了，如果mybatis没有的建议再用trim

10.6foreach

举例（查询一些指定id的Blog）：

BlogMapper.java接口类：

//查询第多个记录的博客
    List<Blog> queryBlogForeach(Map map);

BlogMapper.xml配置文件：

<!--foreach标签-->
    <select id="queryBlogForeach" parameterType="map" resultType="com.lxf.pojo.Blog">
        select * from blog
        <where>
            /*
                collection：要循环的list名字
                open：开始语句
                separator:每个循环后添加的分隔符（除最后一次）
                close：结束语句
                item：list中每个数据
                index:list的下标
             */
            <foreach collection="ids" separator="," open="id in (" close=")"  item="item">
                #{item}
            </foreach>
        </where>
    </select>

测试类：

@Test
public void queryBlogForeach(){
    SqlSession sqlSession = MybatisUtil.getSession();

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

    HashMap map=new HashMap();
    List list=new ArrayList();
    list.add("4");
    list.add("3");
    list.add("1");
    map.put("ids",list);
    List<Blog> blogs = mapper.queryBlogForeach(map);
    for (Blog blog : blogs) {
        System.out.println("blog = " + blog);
    }
    sqlSession.close();
}

10.7 SQL片段

• 目的：实现SQL代码的复用:

		<!--SQl片段-->    
        <sql id="if-title-authorOR">
            <if test="title !=null">
                title=#{title}
            </if>
            <if test="author !=null">
                or author=#{author}
            </if>
        </sql>
        <!--where if查询-->
        <select id="queryBlogIF" parameterType="map" resultType="com.lxf.pojo.Blog">
            select * from  mybatis.blog
            <where>
               <include refid="if-title-authorOR"></include>
            </where>
        </select>

10.8bind

bind 元素允许你在 OGNL 表达式以外创建一个变量，并将其绑定到当前的上下文。比如：

<select id="selectBlogsLike" resultType="Blog">
  <bind name="pattern" value="'%' + _parameter.getTitle() + '%'" />
  SELECT * FROM BLOG
  WHERE title LIKE #{pattern}
</select>

10.9多数据库支持

如果配置了 databaseIdProvider，你就可以在动态代码中使用名为 “_databaseId” 的变量来为不同的数据库构建特定的语句。比如下面的例子：

<insert id="insert">
  <selectKey keyProperty="id" resultType="int" order="BEFORE">
    <if test="_databaseId == 'oracle'">
      select seq_users.nextval from dual
    </if>
    <if test="_databaseId == 'db2'">
      select nextval for seq_users from sysibm.sysdummy1"
    </if>
  </selectKey>
  insert into users values (#{id}, #{name})
</insert>

11.缓存

11.1、简介

查询：连接数据库，耗资源！

​ 一次查询的结果，给他暂存到一个可以直接取得地方！–>内存；缓存

我们再次查询相同得数据时，直接走缓存，就不用走数据库了

1. 什么是缓存[Cache]?

• 存在内存中的临时数据。

• 将用户经常查询到的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，从而提高查询的效率，解决了高并发系统的性能问题

2. 为什么使用缓存

• 减少和数据库的交互次数，减少系统开销，提高系统效率。

3. 什么样的数据能使用缓存？

• 经常查询并且不经常改变的数据

11.2、Mybatis缓存

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

13.3、一级缓存

• 一级缓存也叫本地缓存

  • 与数据库同一次会话期间查询到的数据会放在本地缓存中。
  • 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；

• 缓存失效的情况：

  • 查询不同的东西
  • 查询之间有增删改操作，可能会改变原来的数据，所以必定会刷新缓存！
  • 手动清除缓存也会导致缓存失效

14.4、二级缓存

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

步骤：

1. 开启全局缓存

		 <!--开启全局缓存-->
        <setting name="cacheEnabled" value="true"/>

2. UserMapper文件配置

 <cache eviction="FIFO" flushInterval="600000" size="500" />

UserMapper.java接口类：

//查询所有的User
List<User> getUsers();

UserMapper.xml配置文件

<select id="getUsers" resultType="com.lxf.pojo.User">
            select * from user;
        </select>
        <cache eviction="FIFO" flushInterval="600000" size="500" />

测试类：

 @Test
        public void getUsers(){
            SqlSession sqlSession1 = MybatisUtil.getSession();
            SqlSession sqlSession2 = MybatisUtil.getSession();

            UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
            List<User> users1 = mapper1.getUsers();
            for (User user : users1) {
                System.out.println("user = " + user);
            }
            sqlSession1.close();

            System.out.println("==========================================");

            UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
            List<User> users2 = mapper2.getUsers();
            for (User user : users2) {
                System.out.println("user = " + user);
            }

            sqlSession2.close();
        }

问题：未将实体类序列化而报错。解决方法:实体类继承serializable接口就可以了

14.5、小结：

• 只有开启了二级缓存，在一个Mapper下有效
• 所有的数据都会先放在一级缓存中；
• 只有当会话提交，或者关闭的时候，才会提交到二级缓存中

14.6、自定义缓存Ehcache

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

1. 导依赖

   <!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
   <dependency>
       <groupId>org.mybatis.caches</groupId>
       <artifactId>mybatis-ehcache</artifactId>
       <version>1.2.1</version>
   </depenency>
   

2. UserMapper.xml配置：

 <!--eh缓存-->
        <cache type="org.mybatis.caches.ehcache.EhcacheCache" />

3. resource目录下建一个ehcache.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">
    <!--
      name:缓存名称
      maxElementsInMemory：缓存中最大允许创建的对象数
      maxInMemory：设定内存中创建对象的最大值。
      eternal：设置元素（译注：内存中对象）是否永久驻留。如果是，将忽略超时限制且元素永不消亡。
      overflowToDisk：设置当内存中缓存达到 maxInMemory 限制时元素是否可写到磁盘上。
      timeToIdleSeconds：设置某个元素消亡前的停顿时间。
      timeToLiveSeconds：为元素设置消亡前的生存时间.
      memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
      diskPersistent：重启时内存不持久化到硬盘。
     -->
    <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>