[Java知识库]尚硅谷MyBatis2022

参考博客 ： 嘤桃子

一、MyBatis简介

1、MyBatis历史

??MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下， iBatis3.x正式更名MyBatis。代码于2013年11月迁移到Github。

??iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。 iBatis提供的持久层框架
包括SQL Maps和Data Access Objects（DAO）。

SQL Maps : 数据库中数据和Java数据的映射关系，MyBatis封装jdbc的过程
Data Access Objects : 使用jdbc操作数据库

2、MyBatis特性

1） MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
高级映射：字段和实体类属性不一致的映射

2） MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
避免：不需要手写JDBC代码，设置参数，手动获取结果集

3） MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old JavaObjects，普通的Java对象）映射成数据库中的记录
xml或注解：两种方式配置SQL，xml为主流

4） MyBatis 是一个 半自动的ORM（Object Relation Mapping）框架
半自动：需要手动编写SQL，创建表
ORM:实体对象，和数据创建映射关系

3、MyBatis下载

MyBatis下载地址：https://github.com/mybatis/mybatis-3

4、和其它持久层技术对比

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

二、搭建MyBatis

1、开发环境

IDE：idea
构建工具：maven 3.5.4
MySQL版本：MySQL 5.7
MyBatis版本：MyBatis 3.5.7

2、创建maven工程

a>打包方式：jar

b>引入依赖

<dependencies> 
	<!-- Mybatis核心 --> 
	<dependency> 
		<groupId>org.mybatis</groupId> 
		<artifactId>mybatis</artifactId> 
		<version>3.5.7</version> 
	</dependency> 
	<!-- junit测试 --> 
	<dependency> 
		<groupId>junit</groupId> 
		<artifactId>junit</artifactId> 
		<version>4.12</version> 
		<scope>test</scope> 
	</dependency> 
	<!-- MySQL驱动 --> 
	<dependency> 
		<groupId>mysql</groupId> 
		<artifactId>mysql-connector-java</artifactId> 
		<version>5.1.3</version> 
	</dependency> 
</dependencies>

3、创建MyBatis的核心配置文件

习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。
核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息
核心配置文件存放的位置是src/main/resources目录下

<?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"/> 
				<property name="username" value="root"/> 
				<property name="password" value="123456"/> 
			</dataSource> 
		</environment> 
	</environments> 
	<!--引入映射文件--> 
	<mappers> 
		<mapper resource="mappers/UserMapper.xml"/> 
	</mappers> 
</configuration>

4、 创建mapper接口 & 实体类

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

• MyBatis面向接口编程的两个一致：
• 1。映射文件namespace和Mapper接口的全类名一致
• 2。映射文件中sql语句的id和mapper接口中的方法一致

public interface UserMapper {
    /**
     * 添加用户信息
     * sql写在映射文件中
     */
    int insertUser();

    /**
     * 修改用户信息
     */
    void updateUser();

    /**
     * 删除用户信息
     */
    void deleteUser();

    /**
     * 根据id查询用户信息
     */
    User getUserById();

    /**
     * 查询所有的用户信息
     */
    List<User> getAllUser();
}

User.java

public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private String gender;
    private  String email;

    public User() {
    }
    public User(Integer id, String username, String password, Integer age, String gender, String email) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.gender = gender;
        this.email = email;
    }


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

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

5、 创建MyBatis的映射文件

相关概念：ORM（Object Relationship Mapping）对象关系映射。

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

1、映射文件的命名规则:
表所对应的实体类的类名+Mapper.xml
例如:表t_user，映射的实体类为User，所对应的映射文件为UserMapper.xml (一张表一个映射文件)
因此一个映射文件对应一个实体类，对应一张表的操作
MyBatis映射文件用于编写SQL，访问以及操作表中的数据 MyBatis映射文件存放的位置是src/main/resources/mappers目录下

---

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

a> mapper接口的全类名和映射文件的命名空间(namespace)保持一致
b>mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 一致：mapper接口的全类名和映射文明的命名空间（namespace）保持一致 -->
<mapper namespace="com.atguigu.mybatis.mapper.UserMapper">
	<!--mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致-->
    <!--int insertUser();-->
    <insert id="insertUser">
        insert into t_user values(null, "marina", "456",23,'f',"153456@qq.com")
    </insert>

    <!--void updateUser();-->
    <update id="updateUser">
        update t_user set username = "RUOYI" where id = 4
    </update>

    <!--void deleteUser();-->
    <delete id="deleteUser">
        delete from t_user where id = 5
    </delete>

    <!--User getUserById();-->
    <!--
        查询功能的标签必须设置resultType或者resultMap
        resultType：设置默认的映射关系
        resultMap：设置自定义的映射关系（字段名和表头不一样）
    -->
    <select id="getUserById" resultType="com.atguigu.mybatis.pojo.User">
        select * from t_user where id = 4
    </select>

    <!--List<User> getAllUser();-->
    <select id="getAllUser" resultType="com.atguigu.mybatis.pojo.User">
        select * from t_user
    </select>

</mapper>

6、 通过junit测试功能

public class MyBatisTest {
    /**
     * sqlsession默认不自动提交事务，如果需要自动提交事务，可以使用SqlSessionFactory.openSession(true);
     * @throws IOException
     */
    @Test
    public void testInsertUser() throws IOException {
        //加载核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //获取sqlsessionfactorybuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //获取factory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取sqlsession
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //获取mapper接口对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class); //代理模式

        //测试功能
        int result = mapper.insertUser();

        //提交事务（写的type是JDBC）
//        sqlSession.commit();

        System.out.println("result: " + result);
    }

    @Test
    public void testUpdateUser() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        mapper.updateUser();
        System.out.println("updating...");

    }

    @Test
    public void testDeleteUser() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        mapper.deleteUser();
        System.out.println("deleteUser-...");

    }

    @Test
    public void testSelectUser() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        /**
         * 如果不在UserMapper.xml中配置：
         * <select id="getAllUser" resultType="com.atguigu.mybatis.pojo.User">
         * 
         * 会报错：A query was run and no Result Maps were found
         *           for the Mapped Statement 'com.atguigu.mybatis.mapper.UserMapper.getUserById'
         *          It's likely that neither a Result Type nor a Result Map was specified.
         *
         * com.atguigu.mybatis.mapper.UserMapper.getUserById： 命名空间.方法名
         *
         * 因此，要设置一个a Result Type nor a Result Map，这个type就是返回来的对应的类（要写全类名）
         *
         * 在UserMapper里进行设置
         */
        User user = mapper.getUserById();
        System.out.println(user);

        List<User> allUser = mapper.getAllUser();
        allUser.forEach(user1 -> System.out.println(user1));
    }
}

7、 加入log4j日志功能

a>加入依赖

<!-- log4j日志 --> 
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

b>加入log4j的配置文件

log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}
%m  (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

日志的级别
FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)
从左到右打印的内容越来越详细

三、核心配置文件详解

<?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>
<!--    MyBatis核心配置文件，标签的顺序
        properties?,settings?,typeAliases?,typeHandlers?,
        objectFactory?,objectWrapperFactory?,reflectorFactory?,
        plugins?,environments?,databaseIdProvider?,mappers?-->


    <properties resource="jdbc.properties"></properties>

<!--    设置类型别名，大小写不敏感。
        如果不设置alias，则默认为类名（大小写不敏感）-->

    <typeAliases>
        <!--
            typeAlias: 设置某个类型的别名
            属性：
                type 设置需要设置别名的类型
                alias 设置某个类型的别名，如果不设置该属性，那么该类型拥有默认的类名，且不区分大小写
        -->
        <typeAlias type="com.atguigu.mybatis.pojo.User" alias="User"></typeAlias>

<!--        以包为单位，将包下所有的类型设置默认的类型别名且不区分大小写-->
        <package name="com.atguigu.mybatis.pojo"/>
    </typeAliases>


    <!--设置连接数据库的环境--> 
    <environments default="development">
	    <!--每一个environment都是具体连接数据库的环境-->
	    <!--
	        一个项目中只会用一个环境，default用于使用默认使用的环境：
	        id：表示连接数据库的环境的唯一标识 不能重复
	
	    -->
	    <environment id="development">
	<!--
	        transactionmanager:设置事务管理方式
	        属性：
	            type="JDBC/MANAGED"
	            JDBC: 在当前环境中，执行sql时，使用的时jdbc原声的事务管理方式，需要手动的提交和回滚事务
	            MANAGED：被管理，例如Spring
	        -->
	        <transactionManager type="JDBC"/>
	
	<!--        dataSource：配置数据源
	            属性"
	                type：设置数据源的类型
	                type=""
	                POOLED:表示使用数据库连接池缓存数据库连接
	                UNPOOLED：表示不实用数据库连接池
	                JNDI：表示使用上下文中的数据源
	-->
	        <dataSource type="POOLED">
	            <!--设置连接数据库的驱动-->
	            <property name="driver" value="${jdbc.driver}"/>
	            <!--设置连接地址-->
	            <property name="url"
	                      value="${jdbc.url}"/>
	            <!--用户名和密码-->
	            <property name="username" value="${jdbc.username}"/>
	            <property name="password" value="${jdbc.password}"/>
	        </dataSource>
	    </environment>
	</environments>
    
    <!--引入映射文件--> 
    <mappers>
<!--        <mapper resource="mappers/UserMapper.xml"/>-->
<!--        BindingException: Type interface com.atguigu.mybatis.mapper.UserMapper is not known to the MapperRegistry.
            没有成功建立映射关系
            以包为单位引入映射文件，要求：
                1。 mapper接口所在的包要和映射文件所在的包一致
                2。 mapper接口要和映射文件的名字一致-->
<!--        com.atguigu.mybatis.mapper创建包时要用/分隔，这样才是目录，否则这整一个就只是文件夹名字而已-->
        <package name="com.atguigu.mybatis.mapper"/>
    </mappers>
</configuration>

设置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="jdbc.properties"></properties>

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

    <!--设置连接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url"
                          value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <package name=""/>
    </mappers>
</configuration>

添加模版步骤

完成后就可以直接new一个mybatis-config模版啦。

设置xxxMapper.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="">

</mapper>

四、MyBatis的CRUD

1. 添加

<!--int insertUser();--> 
<insert id="insertUser"> 
	insert into t_user values(null,'admin','123456',23,'男') 
</insert>

2. 删除

<!--int deleteUser();--> 
<delete id="deleteUser"> 
	delete from t_user where id = 7 
</delete>

3. 修改

<!--int updateUser();--> 
<update id="updateUser"> 
	update t_user set username='ybc',password='123' where id = 6 
</update>

4. 查询

<!--User getUserById();--> 
<select id="getUserById" resultType="com.atguigu.mybatis.bean.User"> 
	select * from t_user where id = 2 
</select>

注意：
1、查询的标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射
关系
resultType：自动映射，用于属性名和表中字段名一致的情况
resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况
2、当查询的数据为多条时，不能使用实体类作为返回值，只能使用集合，否则会抛出异常
TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

工具类

package com.atguigu.mybatis.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

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

/**
 * Date:2021/11/27
 * Author:ybc
 * Description:
 */
public class SqlSessionUtils {

    public static SqlSession getSqlSession(){
        SqlSession sqlSession = null;
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            sqlSession = sqlSessionFactory.openSession(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sqlSession;
    }

}

五、获取参数值的两种方式（重点）

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

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

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

JDBC方式中的占位符和字符串拼接

    @Test
    public void testJDBC() throws SQLException, ClassNotFoundException {
        String username = "cherry";
        Class.forName("");
        Connection connection = DriverManager.getConnection("", "", "");
        // 1. 字符串拼接 ->获得预编译对象 -》sql注入问题
        PreparedStatement preparedStatement = connection.prepareStatement("select * from t_user where username = '" + username + "'");

        // 2. 占位符
        PreparedStatement ps2 = connection.prepareStatement("select * from t_user where username = ?");
        ps2.setString(1, username);
    }

1、单个字面量类型

若mapper接口中的方法参数为单个的字面量类型
此时可以使用${}和#{}以任意的名称获取参数的值，注意${}需要手动加单引号

public interface ParameterMapper {
    /**
     * 单个的字面量类型:
     * 根据用户名查询用户信息
     */
    User getUserByUserName(String username);
}

#{}

<!--    User getUserByUserName(String username);-->
<!--    使用#{}，里面内容可以随便写，都是传进来的username的值-->
    <select id="getUserByUserName" resultType="User">
       select * from t_user where username = #{username}
    </select>

${}

<!--    User getUserByUserName(String username);-->
    <select id="getUserByUserName" resultType="User">
        <!-- 
       select * from t_user where username = ${username}
          如果使用这种方式，得到的sql语句是：
          Preparing: select * from t_user where username = RUOYI
          而其中username的值‘RUOYI’没有单引号，语句不正确，会报错。
          因此要手动添加单引号
       -->
        select * from t_user where username = '${username}'
    </select>

测试类

    /**
     * MyBatis获取参数值的各种情况：
     * 情况1： mapper接口方法的参数为单个字面量的参数
     * 可以通过${} #{}以任意的字符串获得参数值，但需要注意${}的单引号问题
     */
    @Test
    public void testgetUserByUserName(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        User user = mapper.getUserByUserName("RUOYI");
        System.out.println(user);
    }

2、多个字面量类型(**)

若mapper接口中的方法参数为多个时

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

public interface ParameterMapper {
    /**
     * 验证登录
     */
    User checkLogin(String username, String password);
}

<!--    User checkLogin(String username, String password);-->
    <select id="checkLogin" resultType="User">
        <!--
        写：select * from t_user where username = #{username} and password = #{password}
        会报错：Parameter 'username' not found. Available parameters are [arg1, arg0, param1, param2]
        因为sql语句没有解析成功-->

        <!--以map集合形式存储，arg0->param1, arg1->param2，这时直接用键arg访问就好了，用param访问也行。

		以下两种方式选一个：-->
        select * from t_user where username = #{arg0} and password = #{arg1}
        select * from t_user where username = '#{param1}' and password = '#{param2}'
    </select>

测试类

    /**
     * 情况2：mapper接口方法的参数为多个时
     * 此时MyBatis会将这些参数放在一个map集合中，以两种方式进行存储
     * a》以arg0，arg1。。为键，参数为值
     * b》以param0，param1。。为键，参数位置
     * 因此只需要通过#{}和${}以键的方式访问值即可，但需要注意${}的单引号问题
     */
    @Test
    public void testCheckLogin(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        User user = mapper.checkLogin("RUOYI","123456");
        System.out.println(user);
    }

3、map集合类型(**)

若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中
只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

public interface ParameterMapper {
	/**
     * 验证登录
     */
    User checkLoginByMap(Map<String, Object> map);
}

<!--    User checkLoginByMap(Map<String, Object> map);-->
<select id="checkLoginByMap" resultType="User">
    select * from t_user where username = #{username} and password = #{password}
</select>

测试类

    /**
     * 情况3：若mapper接口方法的参数有多个时，可以手动将这些参数放在一个map中存储
     * 只需要通过#{} ${}以键的方式访问值即可，但是需要注意${}的单引号问题
     */
    @Test
    public void testCheckLoginByMap(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);

        Map<String, Object> map = new HashMap<>();
        map.put("username","RUOYI");
        map.put("password","123456");

        User user = mapper.checkLoginByMap(map);
        System.out.println(user);
    }

4、 实体类类型(**)

若mapper接口中的方法参数为实体类对象时

此时可以使用${}和#{}，通过访问实体类对象中的属性名获取属性值，注意${}需要手动加单引号

public interface ParameterMapper {
    /**
     * 添加用户信息
     */
    int insertUser(User user);
}

<!--        int insertUser(User user);-->
<!--    找到相对应的get方法，如username->找getUsername()，看get/set方法-->
<insert id="insertUser">
    insert into t_user values(null, #{username}, #{password}, #{age}, #{gender}, #{email})
</insert>

测试类

/**
 * 情况4：mapper接口方法的参数是实体类类型的参数（web从control层传过来的）
 * 只需要通过#{} ${}以属性的方式访问属性值即可，但是需要注意${}的单引号问题
 */
@Test
public void testInsertUser(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);

    User user = new User(null, "Pandora", "4444", 66, "m", "1111@gmail.com");
    mapper.insertUser(user);
}

5、使用@Param标识参数(**)

可以通过@Param注解标识mapper接口中的方法参数

此时，会将这些参数放在map集合中，以@Param注解的value属性值为键，以参数为值；以
param1,param2…为键，以参数为值；只需要通过${}和#{}访问map集合的键就可以获取相对应的值，
注意${}需要手动加单引号

public interface ParameterMapper {
    /**
     * 验证登录 （使用@Param）
     */
    User checkLoginByParam(@Param("username") String username, @Param("password") String password);
}

<!--    以@Param的值为键，参数为值; 或以"param1"/"param2"为键，参数为值-->
<!--    User checkLoginByParam(@Param("username") String username, @Param("password") String password);-->
<select id="checkLoginByParam" resultType="User">
    select * from t_user where username = #{username} and password = #{password}
</select>

测试类

/**
 * 情况5：使用@Param注解来命名参数
 * 此时MyBatis会将这些参数放在一个map集合中，以两种方式进行存储
 * a》以@Param的值为键，参数为值; @Param(value = "xxx")
 * b》以param0，param1...为键，参数为值
 */
@Test
public void testCheckLoginByParam(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    User user = mapper.checkLoginByParam("RUOYI","123456");
    System.out.println(user);
}

6、数组和集合（动态SQL中讲解）

六、MyBatis的各种查询功能

public interface SelectMapper {
    /**
     * 根据id查询用户信息
     */
    User getUserById(@Param("id") Integer id);

    /**
     * 查询所有用户信息
     */
    List<User> getAllUser();

    /**
     * 查询用户信息的总记录数
     */
    Integer getCount();

    /**
     * 根据id查询用户信息为一个map集合
     */
    Map<String, Object> getUserByIdToMap(Integer id);

    /**
     * 查询所有用户信息为map集合
     */
//    List<Map<String, Object>> getAllUserToMap();
    @MapKey("id")
    Map<String, Object> getAllUserToMap();
}

1、查询一个实体类对象

public interface SelectMapper {
    /**
     * 根据id查询用户信息
     */
    //建议添加＠Param
    User getUserById(@Param("id") Integer id);
}

<!--User getUserById(@Param("id") Integer id);-->
<select id="getUserById" resultType="User">
    select * from t_user where id = #{id}
</select>

测试类

    /**
     * MyBatis的各种查询功能：
     * 1。 若查询出的数据只有一条，可以通过实体类对象 / list集合 / map集合 来接收
     * 2。 若查询处的数据有多条，一定不能通过实体类对象来接收，此时会抛出TooManyResultsException
     */
    @Test
    public void testGetUserById(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        User userById = mapper.getUserById(4);
        System.out.println(userById);
    }

2、查询一个List集合

public interface SelectMapper {
	/**
     * 查询所有用户信息
     */
    List<User> getAllUser();
}

<!--    List<User> getAllUser();-->
    <select id="getAllUser" resultType="User">
        select * from t_user
    </select>

测试类

    /**
     * MyBatis的各种查询功能：
     * 1。 若查询出的数据只有一条，可以通过实体类对象 / list集合 / map集合 来接收
     * 2。 若查询处的数据有多条，一定不能通过实体类对象来接收，此时会抛出TooManyResultsException
     */
    @Test
    public void testGetUserById(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List<User> allUser = mapper.getAllUser();
        allUser.forEach(user -> System.out.println(user));
    }

3、查询单个数据

public interface SelectMapper {
    /**
     * 查询用户信息的总记录数
     */
    Integer getCount();
}

<!--    Integer getCount();-->
<!--    integer写大小写都可以，写 Integer/integer/_int/_integer  都可以，都是java.lang.Integer的别名-->
    <select id="getCount" resultType="java.lang.Integer">
        select count(*) from t_user
    </select>

测试类

    /**
     * 获取记录数
     *
     * MyBatis中设置了默认的类型别名
     * Java.lang.Integer -> int, integer
     * int -> _int, _integer
     * Map -> map
     * List -> list
     */
    @Test
    public void testGetCount(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        System.out.println(mapper.getCount());
    }

默认类型别名

4、 查询一条数据为map集合

public interface SelectMapper {
    /**
     * 根据id查询用户信息为一个map集合
     */
    Map<String, Object> getUserByIdToMap(Integer id);
}

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

测试类

    /**
     * 如果没有实体类对象，就把它映射成map集合
     * 从数据库中查询数据，将其映射为map集合
     * 例如把它传到网页端，就映射成json对象，所以转成map很常用
     *
     * 以字段为键
     */
    @Test
    public void testgetUserByIdToMap(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        System.out.println(mapper.getUserByIdToMap(4));
    }

5、查询多条数据为map集合

方式一

/**
* 查询所有用户信息为map集合 
* @return 
* 将表中的数据以map集合的方式查询，一条数据对应一个map；
* 若有多条数据，就会产生多个map集合，此 时可以将这些map放在一个list集合中获取 
*/ 
List<Map<String, Object>> getAllUserToMap();

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

方式二

public interface SelectMapper {
	/**
	* 查询所有用户信息为map集合 
	* @return 
	* 将表中的数据以map集合的方式查询，一条数据对应一个map；
	* 若有多条数据，就会产生多个map集合，并 且最终要以一个map的方式返回数据，此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的 map集合 
	*/ 
    @MapKey("id")
    Map<String, Object> getAllUserToMap();
}

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

结果： 
<!-- 
{ 
	1={password=123456, sex=男, id=1, age=23, username=admin}, 
	2={password=123456, sex=男, id=2, age=23, username=张三}, 
	3={password=123456, sex=男, id=3, age=23, username=张三} 
}
-->

七、特殊SQL的执行

1、模糊查询

模糊查询中使用 #{} 可能会出现一些问题，所以使用 ${}

public interface SQLMapper {
    /**
     * 根据用户名模糊查询用户信息
     */
    List<User> getUserByLike(@Param("username") String username);
}

<!--    List<User> getUserByLike(@Param("username") String username);-->
<!--    使用#{}，因为包括在单引号里，会被认为是字符串的一部分:select * from t_user where username like '%#{username}%'-->
<!--    三种方式-->

<!--
错误写法
	select * from t_user where username like '%#{username}%'
正确写法
	方法一：
	select * from t_user where username like '%${username}%'
	方法二：
	select * from t_user where username like concat('%', #{username}, '%')
	方法三：推荐使用
	select * from t_user where username like "%"#{username}"%"
-->
<select id="getUserByLike" resultType="User">
   <!--第三种 推荐使用-->
    select * from t_user where username like "%"#{username}"%"
</select>

测试类

    @Test
    public void testGetUserByLike(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
        List<User> user = mapper.getUserByLike("RUOYI");
        System.out.println(user);
    }

2、批量删除

public interface SQLMapper {
    /**
     * 批量删除
     */
    int deleteMore(@Param("ids") String ids);
}

<!--    int deleteMore(String ids);-->
<!--    不能使用#{}，因为他会自动添加单引号，变成delete from t_user where id in ('9，10，11')-->
<delete id="deleteMore">
    delete from t_user where id in (${ids})
</delete>

测试类

@Test
public void testDeleteMore(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    int result = mapper.deleteMore("12, 13");
    System.out.println(result);
}

３、动态设置表名

public interface SQLMapper {
    /**
     * 查询指定表中的数据
     */
    List<User> getUserByTableName(String tableName);
}

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

测试类

@Test
public void testGetUserByTableName(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    List<User> t_user = mapper.getUserByTableName("t_user");
    System.out.println(t_user);
}

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

public interface SQLMapper {
    /**
     * 添加用户
     */
    void insetUser(User user);
}

<!--    void insetUser(User user);-->
<!--    方法的返回值是固定的
        useGeneratedKeys    设置当前标签中的sql使用了自增的主键 (id)
        keyProperty         将自增的主键的值 赋值给 传输到映射文件中的参数的某个属性（user.id）
-->
<insert id="insetUser" useGeneratedKeys="true" keyProperty="id">
    insert into t_user values(null, #{username}, #{password},#{age},#{gender},#{email})
</insert>

测试类

@Test
public void testInsetUser(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    mapper.insetUser(new User(null, "兔兔","111",11,"f","abc@qq.com"));
}

八、自定义映射resultMap

package com.atguigu.mybatis.pojo;

public class Dept {
    private Integer did;
    private String deptName;

    @Override
    public String toString() {
        return "Dept{" +
                "did=" + did +
                ", deptName='" + deptName + '\'' +
                '}';
    }

    getset...
}

package com.atguigu.mybatis.pojo;

/**
 * @author Chen Ruoyi
 * @date 2022/3/1 9:07 PM
 */
public class Emp {
    private Integer eid;
    private String empName;
    private Integer age;
    private String sex;
    private String email;

	private Dept dept;
    public Emp() {
    }

    public Emp(Integer eid, String empName, Integer age, String sex, String email) {
        this.eid = eid;
        this.empName = empName;
        this.age = age;
        this.sex = sex;
        this.email = email;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "eid=" + eid +
                ", empName='" + empName + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
    getset...
}
	

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

（1）实用resultMap映射

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

<!--
	resultMap：设置自定义映射 
	属性： 
		id：表示自定义映射的唯一标识 
		type：查询的数据要映射的实体类的类型 
	子标签： 
		id：设置主键的映射关系 
		result：设置普通字段的映射关系 
		association：设置多对一的映射关系 
		collection：设置一对多的映射关系 
	属性： 
		property：设置映射关系中实体类中的属性名 
		column：设置映射关系中表中的字段名 
--> 
<resultMap id="userMap" type="User"> 
	<id property="id" column="id"></id> 
	<result property="userName" column="user_name"></result> 
	<result property="password" column="password"></result> 
	<result property="age" column="age"></result> 
	<result property="sex" column="sex"></result> 
</resultMap> 
<!--List<User> testMohu(@Param("mohu") String mohu);--> 
<select id="testMohu" resultMap="userMap"> 
	<!--select * from t_user where username like '%${mohu}%'--> 
	select id,user_name,password,age,sex from t_user where user_name like concat('%',#{mohu},'%') 
</select>

（2）实用全局配置

若字段名和实体类中的属性名不一致，但是字段名符合数据库的规则（使用_），实体类中的属性
名符合Java的规则（使用驼峰）


此时也可通过以下两种方式处理字段名和实体类中的属性的映射关系
??a>可以通过为字段起别名的方式，保证和实体类中的属性名保持一致
??b>可以在MyBatis的核心配置文件中设置一个全局配置信息mapUnderscoreToCamelCase，可以在查询表中数据时，自动将_类型的字段名转换为驼峰


例如：字段名user_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为
userName

<!--设置MyBatis的全剧配置-->
<settings>
	<!--将下划线自动映射成驼峰，比如emp_name -> empName -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

（3）查询SQL起别名

<select id="testMohu" resultMap="userMap"> 
	<!--select * from t_user where username like '%${mohu}%'--> 
	select id,user_name as 'userName',password,age,sex from t_user where user_name like concat('%',#{mohu},'%') 
</select>

2、多对一映射处理

查询员工信息以及员工所对应的部门信息

public interface EmpMapper {
    /**
     * 查询员工及其所对应的部门信息
     */
    Emp getEmpAndDept(@Param("eid") Integer eid);
}

a>级联方式处理映射关系

<resultMap id="empDeptMap" type="Emp"> 
	<id column="eid" property="eid"></id> 
	<result column="ename" property="ename"></result> 
	<result column="age" property="age"></result> 
	<result column="sex" property="sex"></result> 
	<!--多对一：级连属性-->
	<result column="did" property="dept.did"></result> 
	<result column="dname" property="dept.dname"></result> 
</resultMap> 
<!--Emp getEmpAndDeptByEid(@Param("eid") int eid);--> 
<select id="getEmpAndDeptByEid" resultMap="empDeptMap"> 
	select emp.*,dept.* from t_emp emp 
	left join t_dept dept on emp.did = dept.did 
	where emp.eid = #{eid} 
</select>

b>使用association处理映射关系

<resultMap id="empDeptMap" type="Emp"> 
	<id column="eid" property="eid"></id> 
	<result column="ename" property="ename"></result> 
	<result column="age" property="age"></result> 
	<result column="sex" property="sex"></result> 
	<!--多对一：association
		association:处理多对一的映射关系
		property:需要处理的多对一映射关系的属性名属性名
		javaType:该属性的类型
	-->
	<association property="dept" javaType="Dept"> 
		<id column="did" property="did"></id> 
		<result column="dname" property="dname"></result> 
	</association> 
</resultMap> 
<!--Emp getEmpAndDeptByEid(@Param("eid") int eid);--> 
<select id="getEmpAndDeptByEid" resultMap="empDeptMap"> 
	select emp.*,dept.* from t_emp emp 
	left join t_dept dept on emp.did = dept.did 
	where emp.eid = #{eid} 
</select>

c>分步查询

1）查询员工信息

/**
* 通过分步查询查询员工信息 
* @param eid 
* @return 
*/ 
Emp getEmpByStep(@Param("eid") int eid);

<resultMap id="empDeptStepMap" type="Emp"> 
	<id column="eid" property="eid"></id> 
	<result column="ename" property="ename"></result> 
	<result column="age" property="age"></result> 
	<result column="sex" property="sex"></result> 
	<!--
		select：设置分步查询，查询某个属性的值的sql的标识（namespace.sqlId） 
		column：将sql以及查询结果中的某个字段设置为分步查询的条件 
	-->
	<association property="dept"
				select="com.atguigu.MyBatis.mapper.DeptMapper.getEmpDeptByStep" 
				column="did"> 					
	</association>
</resultMap> 
<!--Emp getEmpByStep(@Param("eid") int eid);--> 
<select id="getEmpByStep" resultMap="empDeptStepMap"> 
	select * from t_emp where eid = #{eid} 
</select>

2）根据员工所对应的部门id查询部门信息

/** 
* 分步查询的第二步：根据员工所对应的did查询部门信息 
* @param did 
* @return 
*/
Dept getEmpDeptByStep(@Param("did") int did);

<!--Dept getEmpDeptByStep(@Param("did") int did);--> 
<select id="getEmpDeptByStep" resultType="Dept"> 
	select * from t_dept where did = #{did} 
</select>

延迟加载

分步查询的优点：
??可以实现延迟加载，但是必须在核心配置文件中设置全局配置信息：

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

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

通过fetchType参数，可以手动控制延迟加载或立即加载，否则根据全局配置的属性决定是延迟加载还是立即加载。

<resultMap id="empDeptStepMap" type="Emp"> 
	<id column="eid" property="eid"></id> 
	<result column="ename" property="ename"></result> 
	<result column="age" property="age"></result> 
	<result column="sex" property="sex"></result> 
	<!--
		select：设置分步查询，查询某个属性的值的sql的标识（namespace.sqlId） 
		column：将sql以及查询结果中的某个字段设置为分步查询的条件 
		开启全局加载的情况下
		fetchType:lazy延迟  | eager 立即
	-->
	<association property="dept"
				select="com.atguigu.MyBatis.mapper.DeptMapper.getEmpDeptByStep" 
				column="did"
				fetchType="eager"> 					
	</association>
</resultMap> 
<!--Emp getEmpByStep(@Param("eid") int eid);--> 
<select id="getEmpByStep" resultMap="empDeptStepMap"> 
	select * from t_emp where eid = #{eid} 
</select>

3、一对多映射处理

根据部门id查找部门以及部门中的员工信息

?? 需要查询一对多、多对一的关系，需要在“一”的pojo中加入List<多>属性，在“多”的pojo中加入“一”。
?? 也就是说，在Dept类中，要加入private List emps;；在Emp类中，要加入private Dept dept;。然后给他们各自添加get、set方法，重写构造器和toString()

a>collection处理映射

/**
* 根据部门id查新部门以及部门中的员工信息 
* @param did 
* @return 
*/ 
Dept getDeptEmpByDid(@Param("did") int did); 

<resultMap id="deptEmpMap" type="Dept"> 
	<id property="did" column="did"></id> 
	<result property="dname" column="dname"></result> 
	<!--
		collection：处理一对多的映射关系
		ofType：设置collection标签所处理的集合属性中存储数据的类型 
	--> 
	<collection property="emps" ofType="Emp"> 
		<id property="eid" column="eid"></id> 
		<result property="ename" column="ename"></result> 
		<result property="age" column="age"></result> 
		<result property="sex" column="sex"></result> 
	</collection> 
</resultMap> 
<!--Dept getDeptEmpByDid(@Param("did") int did);--> 
<select id="getDeptEmpByDid" resultMap="deptEmpMap"> 
	select dept.*,emp.* from t_dept dept 
	left join t_emp emp on dept.did = emp.did 
	where dept.did = #{did} 
</select>

b>分步查询

1）查询部门信息

/**
* 分步查询部门和部门中的员工 
* @param did 
* @return 
*/ 
Dept getDeptByStep(@Param("did") int did);

<resultMap id="deptEmpStep" type="Dept"> 
	<id property="did" column="did"></id> 
	<result property="dname" column="dname"></result> 
	<collection property="emps" 
				fetchType="eager" 			
				select="com.atguigu.MyBatis.mapper.EmpMapper.getEmpListByDid" 
				column="did"> </collection> 
</resultMap> 
<!--Dept getDeptByStep(@Param("did") int did);--> 
<select id="getDeptByStep" resultMap="deptEmpStep"> 
	select * from t_dept where did = #{did} 
</select>

2）根据部门id查询部门中的所有员工

/**
* 根据部门id查询员工信息 
* @param did 
* @return 
*/
List<Emp> getEmpListByDid(@Param("did") int did);

<!--List<Emp> getEmpListByDid(@Param("did") int did);--> 
<select id="getEmpListByDid" resultType="Emp"> 
	select * from t_emp where did = #{did} 
</select>

九、动态SQL()

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

1、if

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

应用场景：多条件查询

public interface DynamicSQLMapper {
    /**
     * 多条件查询
     */
    List<Emp> getEmpByCondition(Emp emp);
}

<!--List<Emp> getEmpByCondition(Emp emp);-->
<!--加上1=1使得：即使emp_name为空，也不会导致sql语句变成：where and xxx-->
<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp where 1=1
    <if test="empName != null and empName != ''">
        and emp_name = #{empName}
    </if>
    <if test="age != null and age != ''">
        and age = #{age}
    </if>
    <if test="email != null and email != ''">
        and email = #{email}
    </if>
    <if test="sex != null and sex != ''">
        and sex = #{sex}
    </if>
</select>

测试类

/**
 * 动态sql
 * 1： if： 根据标签中test属性所对应的内容决定标签中的内容是否拼接在sql语句中
 */
@Test
public void testGetEmpByCondition(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    // 各信息都不为null/空字符串
    List<Emp> emp1 = mapper.getEmpByCondition(new Emp(null, "Apple", 22, "女", "123@gmail.com"));
    // 中间存在查询出来是空，可能导致"select * from t_emp where emp_name= ? and and sex = ?..."的and和and在一起的情况
    List<Emp> emp2 = mapper.getEmpByCondition(new Emp(null, "Apple", null, "女", "123@gmail.com"));
    // 第一个查询条件为空字符串，可能导致"select * from t_emp where and age = ? and ..."的where和and在一起的情况
    List<Emp> emp3 = mapper.getEmpByCondition(new Emp(null, null, null, "女", "123@gmail.com"));        System.out.println(emp1);
    System.out.println(emp1);
    System.out.println(emp2);
    System.out.println(emp3);
}

2、where、set

应用场景：多条件查询

public interface DynamicSQLMapper {
    /**
     * 多条件查询
     */
    List<Emp> getEmpByCondition(Emp emp);
}

<!--where标签中，如果有内容，则添加关键字，如果没有内容，则把and/or去掉-->
<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
    <where>
        <if test="empName != null and empName != ''">
            and emp_name = #{empName}
        </if>
        <if test="age != null and age != ''">
            and age = #{age}
        </if>
        <if test="email != null and email != ''">
            and email = #{email}
        </if>
        <if test="sex != null and sex != ''">
            and sex = #{sex}
        </if>
    </where>
</select>

测试类

/**
 * 2、where：
 *      当where标签中有内容时，会自动生成where关键字，并将内容前多余的and或or去掉
 *      当where标签中没有内容时，此时where标签没有任何效果
 *          注意：where标签不能将其中内容后面多余的and或or去掉
 */
@Test
public void testGetEmpByCondition2(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    // 各信息都不为null/空字符串
    List<Emp> emp1 = mapper.getEmpByCondition(new Emp(null, "Apple", 22, "女", "123@gmail.com"));
    // 中间存在查询出来是空，可能导致"select * from t_emp where emp_name= ? and and sex = ?..."的and和and在一起的情况
    List<Emp> emp2 = mapper.getEmpByCondition(new Emp(null, "Apple", null, "女", "123@gmail.com"));
    // 第一个查询条件为空字符串，可能导致"select * from t_emp where and age = ? and ..."的where和and在一起的情况
    List<Emp> emp3 = mapper.getEmpByCondition(new Emp(null, null, null, "女", "123@gmail.com"));        System.out.println(emp1);
    System.out.println(emp1);
    System.out.println(emp2);
    System.out.println(emp3);
}

where和if一般结合使用：
a>若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字
b>若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的
and去掉
注意：where标签不能去掉条件最后多余的and

3、trim

多条件查询

public interface DynamicSQLMapper {
    /**
     * 多条件查询
     */
    List<Emp> getEmpByCondition(Emp emp);
}

<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
	<!--
		trim:标签中没有内容无任何内容拼接
		prefix|suffix: 将标签中内容前面或后面添加指定内容
		prefixOverrides | suffixOverrides : 将trim标签中内容前面或后面去掉指定内容
	-->
    <trim prefix="where" suffixOverrides="and|or">
        <if test="empName != null and empName != ''">
            emp_name = #{empName} and
        </if>
        <if test="age != null and age != ''">
            age = #{age} or
        </if>
        <if test="email != null and email != ''">
            email = #{email} and
        </if>
        <if test="sex != null and sex != ''">
            sex = #{sex}
        </if>
    </trim>
</select>

测试类

/**
 * 3、trim
 *      若标签中有内容时：
 *          prefix/suffix   在trim标签中内容前面或后面 去添加指定内容
 *          prefixOverrides/suffixOverrides   在trim标签中内容前面或后面 去删掉指定内容
 *      若标签中没有内容时：trim标签也没有任何效果
 */
@Test
public void testGetEmpByCondition3(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    // 各信息都不为null/空字符串
    List<Emp> emp1 = mapper.getEmpByCondition(new Emp(null, "Apple", 22, "女", "123@gmail.com"));
    // 中间存在查询出来是空，可能导致"select * from t_emp where emp_name= ? and and sex = ?..."的and和and在一起的情况
    List<Emp> emp2 = mapper.getEmpByCondition(new Emp(null, "Apple", null, "女", "123@gmail.com"));
    // 第一个查询条件为空字符串，可能导致"select * from t_emp where and age = ? and ..."的where和and在一起的情况
    List<Emp> emp3 = mapper.getEmpByCondition(new Emp(null, null, null, "女", "123@gmail.com"));
    System.out.println(emp1);
    System.out.println(emp2);
    System.out.println(emp3);
}

4、choose、when、otherwise

choose、when、otherwise相当于if…else if…else

public interface DynamicSQLMapper {
    /**
     * 测试choose when otherwise
     */
    List<Emp> getEmpByChoose(Emp emp);
}

<!--List<Emp> getEmpByChoose(Emp emp);-->
<select id="getEmpByChoose" resultType="Emp">
    select * from t_emp
    <where>
    	<!--条件中只有一个条件会被满足-->
        <choose>
            <when test="empName != null and empName != ''">
                emp_name = #{empName}
            </when>
            <when test="age != null and age != ''">
                age = #{age}
            </when>
            <when test="sex != null and sex != ''">
                sex = #{sex}
            </when>
            <when test="email != null and email != ''">
                email = #{email}
            </when>
            <otherwise>
                did = 2
            </otherwise>
        </choose>
    </where>
</select>

测试类

/**
 * 4、choose/when/otherwise: 相当于if..else if..else
 *  when至少要有一个， otherwise最有只能有一个
 *
 */
@Test
public void testGetEmpByChoose(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    // 各信息都不为null/空字符串
    List<Emp> emp1 = mapper.getEmpByChoose(new Emp(null, "Apple", 22, "女", "123@gmail.com"));
    // 中间存在查询出来是空，可能导致"select * from t_emp where emp_name= ? and and sex = ?..."的and和and在一起的情况
    List<Emp> emp2 = mapper.getEmpByChoose(new Emp(null, "Apple", null, "女", "123@gmail.com"));
    // 第一个查询条件为空字符串，可能导致"select * from t_emp where and age = ? and ..."的where和and在一起的情况
    List<Emp> emp3 = mapper.getEmpByChoose(new Emp(null, null, null, "", ""));
    System.out.println(emp1);
    System.out.println(emp2);
    System.out.println(emp3);
}

5、foreach

应用场景1： 通过数组实现批量删除

public interface DynamicSQLMapper {
    /**
     * 通过数组实现批量删除
     */
    int deleteMoreByArray(@Param("eids") Integer[] eids);
}

<!--int deleteMoreByArray(Integer[] eids);-->
<!--没加@Param时，
        报错：Parameter 'eids' not found. Available parameters are [array, arg0]
        因此最好都加上@Param-->
<!--int deleteMoreByArray(@Param("eids") Integer[] eids);-->
<delete id="deleteMoreByArray">
    delete from t_emp where eid in
        <foreach collection="eids" item="eid" separator="," open="(" close=")">
            #{eid}
		</foreach>
</delete>



<!--int deleteMoreByArray(Integer[] eids);-->
<delete id="deleteMoreByArray">
<!--方法2：-->
    delete from t_emp where
    <foreach collection="eids"  item="eid" separator="or">
        eid = #{eid}
    </foreach>
</delete>

测试类

/**
 * 5、foreach
 */
@Test
public void testDeleteMoreByArray(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    int result = mapper.deleteMoreByArray(new Integer[]{7, 8, 9});
    System.out.println(result);
}

应用场景2： 通过list集合实现批量添加

public interface DynamicSQLMapper {
    /**
     * 通过list集合实现批量添加
     */
    int insertMoreByList(@Param("emps") List<Emp> emps);
}

<!--int insertMoreByList(List<Emp> emps);-->
<!--不加注解会报错：Parameter 'emps' not found. Available parameters are [arg0, collection, list]-->
<!--int insertMoreByList(@Param("emps") List<Emp> emps);-->
<insert id="insertMoreByList">
    insert into t_emp values
	<!--
 	foreach
 	    collection  需要循环的数组或集合
	    item        表示数组或集合中的每一个数据
	    separator   循环体之间的分隔符
	    open        foreach标签所循环的所有内容的开始符
	    close       foreach标签所循环的所有内容的结束符
	-->
    <foreach collection="emps" item="emp" separator=",">
        (null, #{emp.empName}, #{emp.age}, #{emp.sex}, #{emp.email}, null)
    </foreach>
</insert>

测试类

/**
 * 5、foreach
 *      collection  需要循环的数组或集合
 *      item        表示数组或集合中的每一个数据
 *      separator   循环体之间的分隔符
 *      open        foreach标签所循环的所有内容的开始符
 *      close       foreach标签所循环的所有内容的结束符
 */
@Test
public void testInsertMoreByList(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    Emp emp1 = new Emp(null, "Mary", 23, "女", "11111@qq.com");
    Emp emp2 = new Emp(null, "Linda", 23, "女", "1144111@qq.com");
    Emp emp3 = new Emp(null, "Jackoline", 23, "女", "1122111@qq.com");
    List<Emp> emps = Arrays.asList(emp1, emp2, emp3);
    System.out.println(mapper.insertMoreByList(emps));
}

6、sql片段

public interface DynamicSQLMapper {
    /**
     * 获取所有员工的某些信息
     */
    List<Emp> getAllEmpNameAndAge();
}

<!--sql片段-->
<!--List<Emp> getAllEmpNameAndAge();-->
<sql id="empColumns">emp_name, age</sql>
<select id="getAllEmpNameAndAge" resultType="Emp">
    select <include refid="empColumns"></include> from t_emp
</select>

测试类

/**
 * 6、sql片段
 *   设置：
 *   <sql id="empColumns">emp_name, age</sql>
 *   使用：
 *   select <include refid="empColumns"></include> from t_emp
 */
@Test
public void testGetAllEmp(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    System.out.println(mapper.getAllEmpNameAndAge());
}

十、MyBatis的缓存

一级缓存和二级缓存级别不一样，一级缓存默认开启.
缓存只对查询功能有效

1、一级缓存

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

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

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

(1) 不同的SqlSession对应不同的一级缓存

    @Test
    public void testCache(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
        Emp emp1 = mapper.getEmpById(3);
        System.out.println(emp1);
        System.out.println("========第二次调用========从缓存中取数据");
        Emp emp2 = mapper.getEmpById(3);
        System.out.println(emp2);

        System.out.println("\n========即使用的不是同一个Mapper，也同样从缓存中取(同一个sqlsession)========");
        CacheMapper mapper2 = sqlSession.getMapper(CacheMapper.class);
        Emp empByMapper2 = mapper2.getEmpById(3);
        System.out.println(empByMapper2);

        System.out.println("\n========一级缓存的范围在sqlsession中，换一个新的sqlsession就会再次用sql读取数据========");
        SqlSession sqlSession2 = SqlSessionUtils.getSqlSession();
        CacheMapper mapper2BySqlSession2 = sqlSession2.getMapper(CacheMapper.class);
        System.out.println(mapper2BySqlSession2.getEmpById(3));
    }

（2）同一个SqlSession但是查询条件不同

    @Test
    public void testCache3(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);

        System.out.println("=====第一次获取数据=====");
        Emp emp1 = mapper.getEmpById(3);
        System.out.println(emp1);
        
        System.out.println("\n=====查询条件不同=====");
        Emp emp2 = mapper.getEmpById(5);
        System.out.println(emp2);
    }

（3） 同一个SqlSession两次查询期间执行了任何一次增删改操作

    @Test
    public void testCache2(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);

        System.out.println("=====第一次获取数据=====");
        Emp emp1 = mapper.getEmpById(3);
        System.out.println(emp1);
        Emp emp2 = mapper.getEmpById(3);
        System.out.println(emp2);

        System.out.println("\n=====进行增删改操作=====");
        mapper.insetEmp(new Emp(null, "Joey", 44, "男", "8888@gmai.com"));

        System.out.println("\n=====同一个sqlsession，再获取数据=====");
        Emp emp3 = mapper.getEmpById(3);
        System.out.println(emp3);
    }

（4）同一个SqlSession两次查询期间手动清空了（一级）缓存

    @Test
    public void testCache4(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);

        System.out.println("=====第一次获取数据=====");
        Emp emp1 = mapper.getEmpById(3);
        System.out.println(emp1);

        System.out.println("\n=====两次查询期间手动清空缓存=====");
        sqlSession.clearCache();

        System.out.println("\n=====再次查询id=3的emp=====");
        Emp emp2 = mapper.getEmpById(3);
        System.out.println(emp2);
    }

2、二级缓存

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

二级缓存开启的条件

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

?? 使二级缓存失效的情况: 两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效
没有提交sqlsession时，数据会保存在一级缓存中，提交后，会保存在二级缓存中。

在映射文件中设置标签<cache />

测试

    @Test
    public void testCacheTwo(){
        //这里不能用工具类了，因为每次都会创建新的sqlsessionfactory
//        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
//        CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);

        //只要是同一个sqlsessionfactory获得的sqlsession就可以
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
            CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
            System.out.println(mapper1.getEmpById(1));

            System.out.println("Cache Hit Ratio：缓存命中率，指的是在缓存中有没有这条数据");
            System.out.println("=====二级缓存未打开，没从缓存中获取数据=====");
            SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
            CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
            System.out.println(mapper2.getEmpById(1));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

关闭sqlSession，再看是用sql从数据库读取数据还是从缓存中取数据：

3、二级缓存相关配置

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

• eviction属性:缓存回收策略

  1. LRU(Least Recently Used) – 最近最少使用的:移除最长时间不被使用的对象。
  2. FIFO(First in First out) – 先进先出:按对象进入缓存的顺序来移除它们。
  3. SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。
  4. WEAK –弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。
     默认的是 LRU。

• flushInterval属性:刷新间隔，单位毫秒

  默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句（增删改） 时刷新

• size属性:引用数目，正整数

  代表缓存最多可以存储多少个对象，太大容易导致内存溢出

• readOnly属性:只读，true/false

  1. true:只读缓存; 会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。【性能好】
  2. false:读写缓存; 会返回缓存对象的拷贝(通过序列化)。这会慢一些，但是安全，因此默认是 false。【安全】

4、缓存查询顺序

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

5、整合第三方缓存EHCache

只能代替二级缓存！
?? 这部分只要会配置就可以了。

（1）添加依赖

<!-- Mybatis EHCache整合包 --> 
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.1</version>
</dependency>

<!-- slf4j日志门面的一个具体实现 --> 
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

<?xml version="1.0" encoding="utf-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<!-- 磁盘保存路径 -->
<diskStore path="这里改成你需要保存缓存的磁盘路径"/>
    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

（3）设置二级缓存类型

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

（4）加入logback日志
存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日志。
创建logback的配置文件logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true"> <!-- 指定日志输出的位置 -->
    <appender name="STDOUT">
    class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
    <!-- 日志输出的格式 -->
    <!-- 按照顺序分别是:时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
                <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
            </encoder>
        </appender>
    <!-- 设置全局日志级别。日志级别按顺序分别是:DEBUG、INFO、WARN、ERROR -->
    <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
    <root level="DEBUG">
        <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
        <appender-ref ref="STDOUT" />
    </root>
    <!-- 根据特殊需求指定局部日志级别 -->
    <logger name="com.atguigu.mybatis.mapper" level="DEBUG"/>
</configuration>

十一、MyBatis逆向工程

示例：t_dept和t_emp

<?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>org.example</groupId>
    <artifactId>MyBatis_MBG</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <!-- 依赖MyBatis核心包 -->
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.3</version>
        </dependency>
        <!-- log4j日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>

    </dependencies>
    <!-- 控制Maven在构建过程中相关配置 -->
    <build>
        <!-- 构建过程中用到的插件 -->
        <plugins>
            <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.0</version>
                <!-- 插件的依赖 -->
                <dependencies>
                    <!-- 逆向工程的核心依赖 -->
                    <dependency>
                        <groupId>org.mybatis.generator</groupId>
                        <artifactId>mybatis-generator-core</artifactId>
                        <version>1.3.2</version>
                    </dependency>
                    <!-- 数据库连接池 -->
                    <dependency>
                        <groupId>com.mchange</groupId>
                        <artifactId>c3p0</artifactId>
                        <version>0.9.2</version>
                    </dependency>
                    <!-- MySQL驱动 -->
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.8</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

</project>

在src/main/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>

    <properties resource="jdbc.properties"></properties>

    <!--设置连接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url"
                          value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

</configuration>

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8
jdbc.username=root
jdbc.password=写你的数据库密码

创建log4j.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"
                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                     xsi:schemaLocation="http://jakarta.apache.org/log4j/ ">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}
%m  (%F:%L) \n"/>
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug"/>
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info"/>
    </logger>
    <root>
        <level value="debug"/>
        <appender-ref ref="STDOUT"/>
    </root>
</log4j:configuration>