Mybatis笔记

1.1、简介

• MyBatis 是一款优秀的持久层框架
• 一个半 ORM（对象关系映射）框架
• 它支持定制化 SQL、存储过程以及高级映射。
• MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。

1.2、持久化

持久化就是将程序的数据在持久状态和瞬时状态转化的过程

1.3、为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？

ORM（Object Relational Mapping），对象关系映射，是一种为了解决关系型数据库数据与简单Java对象（POJO）的映射关系的技术。

Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它是全自动的。

Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以，称之为半自动ORM映射工具。

1.4、JDBC编程有哪些不足之处，MyBatis是如何解决这些问题的？

1. 频繁创建、释放数据库连接对象，容易造成系统资源浪费，影响系统性能。可以使用连接池解决这个问题。
   解决：在mybatis-config.xml中配置数据库连接池，使用连接池管理数据库连接。

2. Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。
   解决：将Sql语句配置在XXXXmapper.xml文件中，与java代码分离。

3. 向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。
   解决：Mybatis自动将java对象映射至sql语句。

4. 对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。
   解决：Mybatis自动将sql执行结果映射至java对象。

1.3、优点与缺点

优点

• 传统的JDBC代码太复杂了，方便将数据存入到数据库中。
• sql和代码的分离，提高了可维护性。
• 提供映射标签，支持对象与数据库的orm字段关系映射

缺点

• SQL语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写SQL语句的功底有一定要求

2.1、实例

1、Dao接口

public interface UserDao {
    List<User> getUserList();
}

2、接口实现类由原来的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接口-->
        <!-- namespace中的包名要和 Dao/mapper 接口的包名一致！--> 
<mapper namespace="com.kuang.dao.UserDao">
<!--select查询语句-->
		id : 就是对应的namespace中的方法名；
		resultType：Sql语句执行的返回值！
		parameterType ： 参数类型！
   <select id="getUserList" resultType="com.kuang.pojo.User">
       select * from mybatis.user
   </select>
</mapper>

2.2、万能Map

    //万能的Map
    int addUser2(Map<String,Object> map);

    <!--对象中的属性，可以直接取出来    传递map的key-->
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user (id, pwd) values (#{userid},#{passWord});
    </insert>

    @Test
    public void addUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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


        Map<String, Object> map = new HashMap<String, Object>();

        map.put("userid",5);
        map.put("passWord","2222333");

        mapper.addUser2(map);

        sqlSession.close();
    }

2.3、模糊查询

1. Java代码执行的时候，传递通配符 % %

   List<User> userList = mapper.getUserLike("%李%");
   

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

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

   注意：因为#{…}解析成sql语句时候，会在变量外侧自动加单引号’ '，所以这里 % 需要使用双引号" "，不能使用单引号 ’ '，不然会查不到任何结果。

3. CONCAT(‘%’,#{question},‘%’) 使用CONCAT()函数，推荐

3、配置解析

3.1、映射器（mappers）

MapperRegistry：注册绑定我们的Mapper文件；
方式一： 【推荐使用】

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

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

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

注意点：

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

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

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

注意点：

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

3.2、生命周期和作用域

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

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

SqlSessionFactory：

• 说白了就是可以想象为 ：数据库连接池
• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
• 因此 SqlSessionFactory 的最佳作用域是应用作用域。
• 最简单的就是使用单例模式或者静态单例模式。

SqlSession：

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

3.3、什么是MyBatis的接口绑定？有哪些实现方式？

接口绑定，就是在MyBatis中任意定义接口，然后把接口里面的方法和SQL语句绑定，我们直接调用接口方法就可以，这样比起原来了SqlSession提供的方法我们可以有更加灵活的选择和设置。
接口绑定有两种实现方式：

• 通过注解绑定，就是在接口的方法上面加上 @Select、@Update等注解，里面包含Sql语句来绑定；
• 通过xml里面写SQL来绑定， 在这种情况下，要指定xml映射文件里面的namespace必须为接口的全路径名。
• 当Sql语句比较简单时候，用注解绑定， 当SQL语句比较复杂时候，用xml绑定，一般用xml绑定的比较多。

3.4、使用MyBatis的mapper接口调用时有哪些要求？

1. Mapper.xml文件中的namespace即是mapper接口的类路径。
2. Mapper接口方法名和mapper.xml中定义的每个sql的id相同。
3. Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同。
4. Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同。

3.5、最佳实践中，通常一个Xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗

• Dao接口，就是人们常说的Mapper接口；
• 接口的全限定名（全限定名 = 包名 + 类型名），就是映射文件中的namespace的值；
• 接口的方法名，就是映射文件中MappedStatement的id值；
• 接口方法内的参数，就是传递给sql的参数。
• Mapper接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为key值，可唯一定位一个MappedStatement

举例：

com.mybatis3.mappers.StudentDao.findStudentById，可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面id = findStudentById的MappedStatement。
在Mybatis中，每一个、、、标签，都会被解析为一个MappedStatement对象。

Dao接口里的方法，是不能重载的，因为是全限定名+方法名的保存和寻找策略。

Dao接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象，代理对象proxy会拦截接口方法，转而执行MappedStatement所代表的sql，然后将sql执行结果返回。

## 3.6、Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？

不同的Xml映射文件，如果配置了namespace，那么id可以重复；如果没有配置namespace，那么id不能重复；毕竟namespace不是必须的，只是最佳实践而已。

4、解决数据库属性名 和 实体类字段名 不一致的问题

4.1、起别名

通过在查询的SQL语句中定义字段名的别名，让字段名的别名和实体类的属性名一致。

<select id="getUserById" resultType="com.kuang.pojo.User">
    select id,name,pwd as password from mybatis.user where id = #{id}
</select>

4.2、resultMap

结果集映射

> id   name   pwd
> id   name   password

通过来映射字段名和实体类属性名的一一对应的关系。

<!--结果集映射-->
 <!--id：唯一即可，type：指定实体类-->
<resultMap id="UserMap" type="User">
    <!--column数据库中的字段，property实体类中的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>

<select id="getUserById" resultMap="UserMap">
    select * from mybatis.user where id = #{id}
</select>

5、日志

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

5.1日志工厂

SLF4J
LOG4J 【掌握】
STDOUT_LOGGING 【掌握】

在mybatis核心配置文件中，配置我们的日志！

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

6、分页

6.1、使用Limit分页

语法：SELECT * from user limit startIndex,pageSize;
SELECT * from user limit 3;  #[0,n]

使用Mybatis实现分页，核心SQL

1. 接口

   //分页
   List<User> getUserByLimit(Map<String,Integer> map);
   

2. Mapper.xml

   <!--//分页-->
   <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
       select * from  mybatis.user limit #{startIndex},#{pageSize}
   </select>
   

6.2、RowBounds分页

不再使用SQL实现分页

1. 接口

   //分页2
   List<User> getUserByRowBounds();
   

2. mapper.xml

   <!--分页2-->
   <select id="getUserByRowBounds" resultMap="UserMap">
       select * from  mybatis.user
   </select>
   

3. 测试

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

6.3、分页插件（PageHelper）

7、使用注解开发

7.1注解开发

1. 注解在接口上实现

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

2. 需要再核心配置文件中绑定接口！

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

底层：动态代理！
本质：反射机制实现

7.2 Mybatis详细的执行流程！

7.3、Mybatis工作原理

1. 读取 MyBatis 配置文件
2. 加载映射文件
3. 构造会话工厂
4. 创建会话对象
5. Executor 执行器
6. MappedStatement 对象
7. 输入参数映射
8. 输出结果映射

7.3、CRUD

我们可以在工具类创建的时候实现自动提交事务！

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

编写接口，增加注解

public interface UserMapper {

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

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


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

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

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

7.4、@MapperScan

作用：指定要变成实现类的接口所在的包，然后包下面的所有接口在编译之后都会生成相应的实现类
添加位置：是在Springboot启动类上面添加，另外，使用@MapperScan注解可以作用到多个包

@SpringBootApplication
@MapperScan("cn.mybatis.mappers")
public class SpringbootMybatisDemoApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisDemoApplication.class, args);
    }
}

7.5、在mapper中如何传递多个参数

方法1：顺序传参法

public User selectUser(String name, int deptId);

<select id="selectUser" resultMap="UserResultMap">
    select * from user
    where user_name = #{0} and dept_id = #{1}
</select>

#{}里面的数字代表传入参数的顺序。

这种方法不建议使用，sql层表达不直观，且一旦顺序调整容易出错。

方法2：@Param注解传参法

public User selectUser(@Param("userName") String name, int @Param("deptId") deptId);

<select id="selectUser" resultMap="UserResultMap">
    select * from user
    where user_name = #{userName} and dept_id = #{deptId}
</select>

#{}里面的名称对应的是注解@Param括号里面修饰的名称。

这种方法在参数不多的情况还是比较直观的，推荐使用。

方法3：Map传参法

public User selectUser(Map<String, Object> params);

<select id="selectUser" parameterType="java.util.Map" resultMap="UserResultMap">
    select * from user
    where user_name = #{userName} and dept_id = #{deptId}
</select>

#{}里面的名称对应的是Map里面的key名称。

这种方法适合传递多个参数，且参数易变能灵活传递的情况。

方法4：Java Bean传参法

public User selectUser(User user);

<select id="selectUser" parameterType="com.jourwon.pojo.User" resultMap="UserResultMap">
    select * from user
    where user_name = #{userName} and dept_id = #{deptId}
</select>

#{}里面的名称对应的是User类里面的成员属性。

这种方法直观，需要建一个实体类，扩展不容易，需要加属性，但代码可读性强，业务逻辑处理方便，推荐使用。

7.6、 @Param

概述
首先明确这个注解是为SQL语句中参数赋值而服务的。

@Param的作用就是给参数命名，比如在mapper里面某方法A（int id），当添加注解后A（@Param(“userId”) int id），也就是说外部想要取出传入的id值，只需要取它的参数名userId就可以了。将参数值传如SQL语句中，通过#{userId}进行取值给SQL的参数赋值。

注意点

基本类型的参数或者String类型，需要加上
引用类型不需要加
如果只有一个基本类型的话，可以忽略，但是建议大家都加上！

当使用了@Param注解来声明参数的时候，SQL语句取值使用#{}，${}取值都可以。

当不使用@Param注解声明参数的时候，必须使用的是#{}来取参数。使用${}方式取值会报错。

不使用@Param注解时，参数只能有一个，并且是Javabean。在SQL语句里可以引用JavaBean的属性，而且只能引用JavaBean的属性。

7.6、Mybatis如何执行批量操作

使用foreach标签
foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach标签的属性主要有item，index，collection，open，separator，close。

• item　　表示集合中每一个元素进行迭代时的别名，随便起的变量名；
• index　　指定一个名字，用于表示在迭代过程中，每次迭代到的位置，不常用；
• open　　表示该语句以什么开始，常用“(”；
• separator表示在每次进行迭代之间以什么符号作为分隔符，常用“,”；
• close　　表示以什么结束，常用“)”。

在使用foreach的时候最关键的也是最容易出错的就是collection属性，该属性是必须指定的，但是在不同情况下，该属性的值是不一样的，主要有一下3种情况：

1. 如果传入的是单参数且参数类型是一个List的时候，collection属性值为list
2. 如果传入的是单参数且参数类型是一个array数组的时候，collection的属性值为array
3. 如果传入的参数是多个的时候，我们就需要把它们封装成一个Map了，当然单参数也可以封装成map，实际上如果你在传入参数的时候，在MyBatis里面也是会把它封装成一个Map的，map的key就是参数名，所以这个时候collection属性值就是传入的List或array对象在自己封装的map里面的key

具体用法如下：

<!-- 批量保存(foreach插入多条数据两种方法)
       int addEmpsBatch(@Param("emps") List<Employee> emps); -->
<!-- MySQL下批量保存，可以foreach遍历 mysql支持values(),(),()语法 --> //推荐使用
<insert id="addEmpsBatch">
    INSERT INTO emp(ename,gender,email,did)
    VALUES
    <foreach collection="emps" item="emp" separator=",">
        (#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
    </foreach>
</insert>

<!-- 这种方式需要数据库连接属性allowMutiQueries=true的支持
 如jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true -->  
<insert id="addEmpsBatch">
    <foreach collection="emps" item="emp" separator=";">                                 
        INSERT INTO emp(ename,gender,email,did)
        VALUES(#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
    </foreach>
</insert>

7.6、{} 与 ${} 的区别

• #{}是占位符，预编译处理，可以防止SQL注入；像传进来的数据会加个" "（#将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号）
• ${}是拼接符，字符串替换，没有预编译处理，不能防止SQL注入。这个方式一般用于传入数据库对象，例如传入表名.

使用 ${} 的话会导致 sql 注入。所以为了防止 SQL 注入，能用 #{} 的不要去用 ${}

7.7、如何获取生成的主键

对于支持主键自增的数据库（MySQL）

<insert id="insertUser" useGeneratedKeys="true" keyProperty="userId" >
    insert into user( 
    user_name, user_password, create_time) 
    values(#{userName}, #{userPassword} , #{createTime, jdbcType= TIMESTAMP})
</insert>

属性	描述
keyProperty	selectKey 语句结果应该被设置的目标属性。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
keyColumn	匹配属性的返回结果集中的列名称。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
resultType	结果的类型，MyBatis 通常可以推算出来。MyBatis 允许任何简单类型用作主键的类型，包括字符串。如果希望作用于多个生成的列，则可以使用一个包含期望属性的 Object 或一个 Map。

8、动态 SQL

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

Mybatis动态sql可以让我们在Xml映射文件内，以标签的形式编写动态sql，完成逻辑判断和动态拼接sql的功能，Mybatis提供了9种动态sql标签trim|where|set|foreach|if|choose|when|otherwise|bind。

执行原理：使用OGNL从sql参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql的功能。

8.1、动态 SQL格式

8.1.1、IF

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

8.1.2、choose (when, otherwise)

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

8.1.3、trim (where,set)

select * from mybatis.blog
<where>
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</where> 

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

if
where
set
choose
when

8.2、SQL片段

有的时候，我们可能会将一些功能的部分抽取出来，方便复用！

• 使用SQL标签抽取公共的部分

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

• 在需要使用的地方使用Include标签引用即可

  <select id="queryBlogIF" parameterType="map" resultType="blog">
      select * from mybatis.blog
      <where>
          <include refid="if-title-author"></include>
      </where>
  </select>
  

注意事项：

• 最好基于单表来定义SQL片段！
• 不要存在where标签

9、缓存 （了解）

9.1、简介

查询 ： 连接数据库 ，耗资源！
一次查询的结果，给他暂存在一个可以直接取到的地方！–> 内存 ： 缓存

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

什么是缓存？

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

为什么使用缓存？

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

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

• 经常查询并且不经常改变的数据。【可以使用缓存】

9.2、Mybatis缓存

• MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。

• MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存

  • 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
  • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
  • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

9.3、一级缓存

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

• 与数据库同一次会话期间查询到的数据会放在本地缓存中。

• 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库；

缓存失效的情况：

• 查询不同的东西
• 增删改操作，可能会改变原来的数据，所以必定会刷新缓存！
• 查询不同的Mapper.xml
• 手动清理缓存！

总结：

• 一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到连接到关闭连接这个区间段！
• 一级缓存就是一个Map

9.4、二级缓存

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

步骤：

• 开启全局缓存

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

• 在要使用二级缓存的Mapper中开启

  <!--在当前Mapper.xml中使用二级缓存-->
  <cache/>
  

  也可以自定义参数

  <!--在当前Mapper.xml中使用二级缓存-->
  <cache  eviction="FIFO"
         flushInterval="60000"
         size="512"
         readOnly="true"/>
  

• 测试
  出问题：我们需要将实体类序列化！否则就会报错！

  Caused by: java.io.NotSerializableException: com.kuang.pojo.User
  

总结：

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

9.5、缓存原理