zoukankan      html  css  js  c++  java

  • 阶段六 模块一 Mybatis

    三层架构

    软件开发常用的架构是三层架构，之所以流行是因为有着清晰的任务划分。一般包括以下三层：

    • 持久层：主要完成与数据库相关的操作，即对数据库的增删改查。

    　　因为数据库访问的对象一般称为Data Access Object（简称DAO），所以有人把持久层叫做DAO层。

    • 业务层：主要根据功能需求完成业务逻辑的定义和实现。

    　　因为它主要是为上层提供服务的，所以有人把业务层叫做Service层或Business层。

    • 表现层：主要完成与最终软件使用用户的交互，需要有交互界面（UI）。
    　　因此，有人把表现层称之为web层或View层。
    　　三层架构之间调用关系为:表现层调用业务层，业务层调用持久层。各层之间必然要进行数据交互，我们一般使用java实体对象来传递数据

    什么是框架？

    框架就是一套规范，既然是规范，你使用这个框架就要遵守这个框架所规定的约束。
    框架可以理解为半成品软件，框架做好以后，接下来在它基础上进行开发。

    为什么使用框架？

    框架为我们封装好了一些冗余，且重用率低的代码。并且使用反射与动态代理机制，将代码实现了通用性，让 开发人员把精力专注在核心的业务代码实现上。

    比如在使用servlet进行开发时，需要在servlet获取表单的参数，每次都要获取很麻烦，而框架底层就使用反射机制和拦截器机制帮助我们获取表单的值，使用jdbc每次做专一些简单的crud的时候都必须写sql，但使用框架就不需要这么麻烦了，直接调用方法就可以。当然，既然是使用框架，那么还是要遵循其一些规范进行配置

    常见的框架

    Java世界中的框架非常的多，每一个框架都是为了解决某一部分或某些问题而存在的。下面列出在目前企业中流行的几种框架（一定要注意他们是用来解决哪一层问题的）：
    • 持久层框架：专注于解决数据持久化的框架。常用的有mybatis、hibernate、spring jdbc等等。
    • 表现层框架：专注于解决与用户交互的框架。常见的有struts2、spring mvc等等。
    • 全栈框架: 能在各层都给出解决方案的框架。比较著名的就是spring。

    Mybatis简介

    MyBatis是一个优秀的基于ORM的半自动轻量级持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码

    ORM思想

    ORM（Object Relational Mapping）对象关系映射
    O（对象模型）：
    　　实体对象，即我们在程序中根据数据库表结构建立的一个个实体javaBean
    R（关系型数据库的数据结构）：
    　　关系数据库领域的Relational（建立的数据库表）
    M（映射）：
    　　从R（数据库）到O（对象模型）的映射，可通过XML文件映射

    ORM作为是一种思想

    帮助我们跟踪实体的变化,并将实体的变化翻译成sql脚本,执行到数据库中去,也就是将实体的变化映射到了表的变化。

    mybatis采用ORM思想解决了实体和数据库映射的问题，对jdbc 进行了封装，屏蔽了jdbc api 底层访问细节，使我们不用与jdbc api 打交道，就可以完成对数据库的持久化操作

    MyBatis开发步骤

    案例需求：通过mybatis查询数据库user表的所有记录，封装到User对象中，打印到控制台上

    步骤分析：

    1. 创建数据库及user表
    2. 创建maven工程，导入依赖（MySQL驱动、mybatis、junit）
    3. 编写User实体类
    4. 编写UserMapper.xml映射配置文件（ORM思想）
    5. 编写SqlMapConfig.xml核心配置文件
    　　 数据库环境配置
     　　映射关系配置的引入(引入映射配置文件的路径)
    6. 编写测试代码
    　　// 1.加载核心配置文件
    　　// 2.获取sqlSessionFactory工厂对象
    　　// 3.获取sqlSession会话对象
    　　// 4.执行sql
    　　// 5.打印结果
    　　// 6.释放资源

    Mybatis映射文件概述

     Mybatis增删改查

    新增注意事项

    - 插入语句使用insert标签

    - 在映射文件中使用parameterType属性指定要插入的数据类型

    - Sql语句中使用#{实体属性名}方式引用实体中的属性值

    - 插入操作使用的API是sqlSession.insert(“命名空间.id”,实体对象);

    - 插入操作涉及数据库数据变化，所以要使用sqlSession对象显示的提交事务，即

    sqlSession.commit()

    修改注意事项

    - 修改语句使用update标签

    - 修改操作使用的API是sqlSession.update(“命名空间.id”,实体对象);

    删除注意事项

    - 删除语句使用delete标签

    - Sql语句中使用#{任意字符串}方式引用传递的单个参数

    - 删除操作使用的API是sqlSession.delete(“命名空间.id”,Object);

    Mybatis核心文件概述

    MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

    配置文档的顶层结构如下：

     MyBatis常用配置解析

    environments标签

    数据库环境的配置，支持多环境配置

    1. 其中，事务管理器（transactionManager）类型有两种：
    　　 - JDBC：
      　　　　这个配置就是直接使用了JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
     

     　　- MANAGED：
    　　 　　 这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期。
      　　　　例如：mybatis与spring整合后，事务交给spring容器管理。
     
    2. 其中，数据源（dataSource）常用类型有三种：
     　　- UNPOOLED：

    　　　　这个数据源的实现只是每次被请求时打开和关闭连接。
     
    　　 - POOLED：
      　　　　这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来。
     
     　　- JNDI :
     　　　　 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用

    properties标签

    实际开发中，习惯将数据源的配置信息单独抽取成一个properties文件，该标签可以加载额外配置的properties：

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql:///mybatis_db
    jdbc.username=root
    jdbc.password=root

     typeAliases标签

    类型别名是为 Java 类型设置一个短的名字。

    为了简化映射文件 Java 类型设置，mybatis框架为我们设置好的一些常用的类型的别名：

     mappers标签

    该标签的作用是加载映射的，加载方式有如下几种：

    1. 使用相对于类路径的资源引用，例如：
    　　<mapper resource="org/mybatis/builder/userMapper.xml"/>
    2. 使用完全限定资源定位符（URL），例如：
    　　<mapper url="file:///var/mappers/userMapper.xml"/>
    3. 使用映射器接口实现类的完全限定类名，例如：
    　　<mapper class="org.mybatis.builder.userMapper"/>
    4. 将包内的映射器接口实现全部注册为映射器，例如：
    <package name="org.mybatis.builder"/>

    Mybatis的API概述

    SqlSession工厂构建器SqlSessionFactoryBuilder

    常用API：SqlSessionFactory build(InputStream inputStream)
    通过加载mybatis的核心文件的输入流的形式构建一个SqlSessionFactory对象

    String resource = "org/mybatis/builder/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(inputStream);

    其中， Resources 工具类，这个类在 org.apache.ibatis.io 包中。Resources 类帮助你从类路径下、文件系统或一个 web URL 中加载资源文件。

     SqlSession工厂对象SqlSessionFactory

    SqlSessionFactory 有多个个方法创建SqlSession 实例。常用的有如下两个：

     SqlSession会话对象

    SqlSession 实例在 MyBatis 中是非常强大的一个类。在这里你会看到所有执行语句、提交或回滚事务和获取映射器实例的方法。

    执行语句的方法主要有：

    <T> T selectOne(String statement, Object parameter)
<E> List<E> selectList(String statement, Object parameter)
int insert(String statement, Object parameter)
int update(String statement, Object parameter)
int delete(String statement, Object parameter)

    操作事务的方法主要有：

    void commit() 
void rollback()

    Mybatis基本原理介绍

     代理开发方式

    采用 Mybatis 的基于接口代理方式实现 持久层 的开发，这种方式是我们后面进入企业的主流。

    基于接口代理方式的开发只需要程序员编写 Mapper 接口，Mybatis 框架会为我们动态生成实现类的对象。

    这种开发方式要求我们遵循一定的规范：

    • Mapper.xml映射文件中的namespace与mapper接口的全限定名相同
    • Mapper接口方法名和Mapper.xml映射文件中定义的每个statement的id相同
    • Mapper接口方法的输入参数类型和mapper.xml映射文件中定义的每个sql的parameterType的类型相同
    • Mapper接口方法的输出参数类型和mapper.xml映射文件中定义的每个sql的resultType的类型相同

    Mapper 接口开发方法只需要程序员编写Mapper 接口（相当于Dao 接口），由Mybatis 框架根据接口定义创建接口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法。

    Mybatis基于接口代理方式的内部执行原理

    1、通过追踪源码我们会发现，我们使用的mapper实际上是一个代理对象,是由MapperProxy代理产生的。

    2、追踪MapperProxy的invoke方法会发现，其最终调用了mapperMethod.execute(sqlSession, args)

     3、进入execute方法会发现，最终工作的还是sqlSession

    Mybatis高级查询

    ResutlMap属性

    * resultType
    　　如果实体的属性名与表中字段名一致，将查询结果自动封装到实体类中
    * ResutlMap
    　　如果实体的属性名与表中字段名不一致，可以使用ResutlMap实现手动封装到实体类中

    多条件查询（三种）

    1）方式一

    使用  #{arg0}-#{argn} 或者  #{param1}-#{paramn} 获取参数

    2）方式二

    使用注解，引入 @Param() 注解获取参数

    3）方式三（推荐）

    使用pojo对象传递参数

    模糊查询

    1）方式一

    

    <mapper namespace="com.lagou.mapper.UserMapper">
     
      <select id="findByUsername1" parameterType="string" resultType="user">
       select * from user where username like #{username}
      </select> 
     
    </mapper>
    



    @Test
    public void testFindByUsername() throws Exception {
  UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  List<User> list = userMapper.findByUsername1("%王%");
  for (User user : list) {
    System.out.println(user);
 }
}
    

    

    2）方式二
    

    

    <mapper namespace="com.lagou.mapper.UserMapper">
 
  <!--不推荐使用，因为会出现sql注入问题-->
  <select id="findByUsername2" parameterType="string" resultType="user">
   select * from user where username like '${value}'
  </select>  
 
</mapper>

@Test
public void testFindByUsername() throws Exception {
  UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  List<User> list = userMapper.findByUsername2("%王%");
  for (User user : list) {
    System.out.println(user);
 }
}
    

    

    3）${} 与 #{} 区别【笔试题】
    

    #{} :表示一个占位符号
    

      

    • 通过 #{} 可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。
      • 

    • #{} 可以接收简单类型值或pojo属性值。
      • 

    • 如果parameterType传输单个简单类型值， #{} 括号中名称随便写。
      • 

    

    ${} :表示拼接sql串
    

      

    • 通过 ${} 可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换，会出现sql注入问题。
      • 

    • ${} 可以接收简单类型值或pojo属性值。
      • 

    • 如果parameterType传输单个简单类型值， ${} 括号中只能是value。
      • 

    

    返回主键
    

    useGeneratedKeys
    

    

    <!--
    useGeneratedKeys="true" 声明返回主键
    keyProperty="id" 把返回主键的值，封装到实体的id属性中
注意：只适用于主键自增的数据库，mysql和sqlserver支持，oracle不支持
-->
<insert id="save" parameterType="user" useGeneratedKeys="true" keyProperty="id">
 INSERT INTO `user`(username,birthday,sex,address)
 values(#{username},#{birthday},#{sex},#{address})
</insert>
    

    

    selectKey
    

    

    <!--
    selectKey 适用范围广，支持所有类型数据库
      keyColumn="id" 指定主键列名
      keyProperty="id" 指定主键封装到实体的id属性中
      resultType="int" 指定主键类型
      order="AFTER"  设置在sql语句执行前（后），执行此语句
-->
<insert id="save" parameterType="user">
  <selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER">
   SELECT LAST_INSERT_ID();
  </selectKey>
 INSERT INTO `user`(username,birthday,sex,address)
 values(#{username},#{birthday},#{sex},#{address})
</insert>
    

    

    动态SQL
    

    动态 SQL 之<if>
    

    

    <!--
  where标签相当于 where 1=1，但是如果没有条件，就不会拼接where关键字
-->
<select id="findByIdAndUsernameIf" parameterType="user" resultType="user">
 SELECT * FROM `user`
  <where>
    <if test="id != null">
     AND id = #{id}
    </if>
    <if test="username != null">
     AND username = #{username}
    </if>
  </where>
</select>
    

    

    动态 SQL 之<set>
    

    

    <!--
    set标签在更新的时候，自动加上set关键字，然后去掉最后一个条件的逗号
-->
<update id="updateIf" parameterType="user">
 UPDATE `user`
  <set>
    <if test="username != null">
     username = #{username},
    </if>
    <if test="birthday != null">
     birthday = #{birthday},
    </if>
    <if test="sex !=null">
     sex = #{sex},
    </if>
    <if test="address !=null">
     address = #{address},
    </if>
  </set>
 WHERE id = #{id}
</update>
    

    

    动态 SQL 之<foreach>
    

    

    * <foreach>标签用于遍历集合，它的属性：
     • collection：代表要遍历的集合元素
     • open：代表语句的开始部分
     • close：代表结束部分
     • item：代表遍历集合的每个元素，生成的变量名
     • sperator：代表分隔符
    
































    

    a) 集合
    

    

    <!--
    如果查询条件为普通类型 List集合，collection属性值为：collection 或者 list
-->
<select id="findByList" parameterType="list" resultType="user" >
 SELECT * FROM `user`
  <where>
    <foreach collection="collection" open="id in(" close=")" item="id"
separator=",">
     #{id}
    </foreach>
  </where>
</select>
    

    

    b）数组
    

    

    <!--
    如果查询条件为普通类型 Array数组，collection属性值为：array
-->
<select id="findByArray" parameterType="int" resultType="user">
 SELECT * FROM `user`
  <where>
    <foreach collection="array" open="id in(" close=")" item="id"
separator=",">
     #{id}
    </foreach>
  </where>
</select>
    

    

    SQL片段
    

    映射文件中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的
    

    

    <!--抽取的sql片段-->
<sql id="selectUser">
 SELECT * FROM `user`
</sql>

<select id="findByList" parameterType="list" resultType="user" >
  <!--引入sql片段-->
  <include refid="selectUser"></include>
  <where>
    <foreach collection="collection" open="id in(" close=")" item="id"
separator=",">
     #{id}
    </foreach>
  </where>
</select>
    

    

    Mybatis核心配置文件深入
    

    plugins标签
    

    

    MyBatis可以使用第三方的插件来对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据
    

    开发步骤：
    

    ①导入通用PageHelper的坐标
    

    ②在mybatis核心配置文件中配置PageHelper插件
    

    ③测试分页数据获取
    

    

    ①导入通用PageHelper坐标
    

    

    <!-- 分页助手 -->
<dependency>
  <groupId>com.github.pagehelper</groupId>
  <artifactId>pagehelper</artifactId>
  <version>3.7.5</version>
</dependency>
<dependency>
  <groupId>com.github.jsqlparser</groupId>
  <artifactId>jsqlparser</artifactId>
  <version>0.9.1</version>
</dependency>
    

    

    ②在mybatis核心配置文件中配置PageHelper插件
    

    

    <!-- 分页助手的插件  -->
<plugin interceptor="com.github.pagehelper.PageHelper">
  <!-- 指定方言 -->
  <property name="dialect" value="mysql"/>
</plugin>
    

    

    ③测试分页代码实现
    

    

    @Test
public void testPageHelper(){
  //设置分页参数
  PageHelper.startPage(1,2);
  List<User> select = userMapper2.select(null);
  for(User user : select){
    System.out.println(user);
 }
}
    

    

    获得分页相关的其他参数
    

    

    //其他分页的数据
PageInfo<User> pageInfo = new PageInfo<User>(select);
System.out.println("总条数："+pageInfo.getTotal());
System.out.println("总页数："+pageInfo.getPages());
System.out.println("当前页："+pageInfo.getPageNum());
System.out.println("每页显示长度："+pageInfo.getPageSize());
System.out.println("是否第一页："+pageInfo.isIsFirstPage());
System.out.println("是否最后一页："+pageInfo.isIsLastPage());
    

    

    Mybatis多表查询
    

    关系型数据库表关系分为
    

    

    * 一对一
    * 一对多
    * 多对多
    





























    

    一对一（多对一）
    

    

    <resultMap id="orderMap" type="com.lagou.domain.Order">
  <id column="id" property="id"></id>
  <result column="ordertime" property="ordertime"></result>
  <result column="money" property="money"></result>
 <!--
一对一（多对一）使用association标签关联
        property="user" 封装实体的属性名
        javaType="user" 封装实体的属性类型
    -->
  <association property="user" javaType="com.lagou.domain.User">
    <id column="uid" property="id"></id>
    <result column="username" property="username"></result>
    <result column="birthday" property="birthday"></result>
    <result column="sex" property="sex"></result>
    <result column="address" property="address"></result>
  </association>
</resultMap>
    

    

    一对多
    

    

    <resultMap id="userMap" type="com.lagou.domain.User">
<id column="id" property="id"></id>
  <result column="username" property="username"></result>
  <result column="birthday" property="birthday"></result>
  <result column="sex" property="sex"></result>
  <result column="address" property="address"></result>
 <!--
      一对多使用collection标签关联
        property="orderList"  封装到集合的属性名
        ofType="order"     封装集合的泛型类型
    -->
  <collection property="orderList" ofType="com.lagou.domain.Order">
    <id column="oid" property="id"></id>
    <result column="ordertime" property="ordertime"></result>
    <result column="money" property="money"></result>
  </collection>
</resultMap>
<select id="findAllWithOrder" resultMap="userMap">
 SELECT *,o.id oid FROM USER u LEFT JOIN orders o ON u.`id`=o.`uid`;
</select>
    

    

    多对多
    

    

    <resultMap id="userAndRoleMap" type="com.lagou.domain.User">
  <id column="id" property="id"></id>
  <result column="username" property="username"></result>
  <result column="birthday" property="birthday"></result>
  <result column="sex" property="sex"></result>
  <result column="address" property="address"></result>
  <collection property="orderList" ofType="com.lagou.domain.Role">
    <id column="rid" property="id"></id>
    <result column="role_name" property="roleName"></result>
    <result column="role_desc" property="roleDesc"></result>
  </collection>
</resultMap>
<select id="findAllWithRole" resultMap="userAndRoleMap">
 SELECT * FROM USER u LEFT JOIN user_role ur ON u.`id`=ur.`uid` INNER JOIN
role r ON ur.`rid` = r.`id`;
</select>
    

    

    MyBatis多表配置方式
    

    

    * 多对一（一对一）配置：使用<resultMap>+<association>做配置
    * 一对多配置：使用<resultMap>+<collection>做配置
    * 多对多配置：使用<resultMap>+<collection>做配置
    * 多对多的配置跟一对多很相似，难度在于SQL语句的编写。
    




























    

    MyBatis嵌套查询
    

    什么是嵌套查询
    

    嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询，再使用mybatis的语法嵌套在一起。
    

    举个栗子
    

    

    * 需求：查询一个订单，与此同时查询出该订单所属的用户
    

    1. 联合查询
    

    　　SELECT * FROM orders o LEFT JOIN USER u ON o.`uid`=u.`id`;
    

    2. 嵌套查询
    

    　　2.1 先查询订单
    

    　　　　SELECT * FROM orders
    

    　　2.2 再根据订单uid外键，查询用户
    

    　　　　SELECT * FROM `user` WHERE id = #{根据订单查询的uid}
    

    　　2.3 最后使用mybatis，将以上二步嵌套起来
    

    　　　　...
    


























    

    一对一嵌套查询
    

    

    <!--一对一嵌套查询-->
<resultMap id="orderMap" type="order">
  <id column="id" property="id"></id>
  <result column="ordertime" property="ordertime"></result>
  <result column="money" property="money"></result>
  <!--根据订单中uid外键，查询用户表-->
  <association property="user" javaType="user" column="uid"
select="com.lagou.mapper.UserMapper.findById"></association>
</resultMap>
<select id="findAllWithUser" resultMap="orderMap" >
 SELECT * FROM orders
</select>
    

    

    一对多嵌套查询
    

    

    <!--一对多嵌套查询-->
<resultMap id="userMap" type="user">
  <id column="id" property="id"></id>
  <result column="username" property="username"></result>
  <result column="birthday" property="birthday"></result>
  <result column="sex" property="sex"></result>
  <result column="address" property="address"></result>
  <!--根据用户id，查询订单表-->
  <collection property="orderList" column="id" ofType="order"
select="com.lagou.mapper.OrderMapper.findByUid"></collection>
</resultMap>
<select id="findAllWithOrder" resultMap="userMap">
 SELECT * FROM `user`
</select>
    

    

    多对多嵌套查询
    

    

    <!--多对多嵌套查询-->
<resultMap id="userAndRoleMap" type="user">
  <id column="id" property="id"></id>
  <result column="username" property="username"></result>
  <result column="birthday" property="birthday"></result>
  <result column="sex" property="sex"></result>
  <result column="adress" property="address"></result>
  <!--根据用户id，查询角色列表-->
  <collection property="roleList" column="id" ofType="role"
select="com.lagou.mapper.RoleMapper.findByUid"></collection>
</resultMap>
<select id="findAllWithRole" resultMap="userAndRoleMap">
   SELECT * FROM `user`
</select>


<select id="findByUid" parameterType="int" resultType="role">
 SELECT r.id,r.`role_name` roleName,r.`role_desc` roleDesc FROM role r
 INNER JOIN user_role ur ON r.`id` = ur.`rid` WHERE ur.`uid` = #{uid}
</select>
    

    

    

    一对一配置：使用<resultMap>+<association>做配置，通过column条件，执行select查询
    

    一对多配置：使用<resultMap>+<collection>做配置，通过column条件，执行select查询
    

    多对多配置：使用<resultMap>+<collection>做配置，通过column条件，执行select查询
    

    优点：简化多表查询操作
    

    缺点：执行多次sql语句，浪费数据库性能
    

    

    MyBatis加载策略
    

    什么是延迟加载？
    

    在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。
    

    

    * 优点：
    
　　先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

    * 缺点：
    

    　　因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。
    

    * 在多表中：
    

    　　一对多，多对多：通常情况下采用延迟加载
    

    　　一对一（多对一）：通常情况下采用立即加载
    

    * 注意：
    

    　　延迟加载是基于嵌套查询来实现的
    

    

    局部延迟加载
    

    在association和collection标签中都有一个fetchType属性，通过修改它的值，可以修改局部的加载策略。
    

    

    <!-- 开启一对多 延迟加载 -->
<resultMap id="userMap" type="user">
<id column="id" property="id"></id>
  <result column="username" property="username"></result>
  <result column="password" property="password"></result>
  <result column="birthday" property="birthday"></result>
  <!--
fetchType="lazy" 懒加载策略
fetchType="eager" 立即加载策略
-->
  <collection property="orderList" ofType="order" column="id"
        select="com.lagou.dao.OrderMapper.findByUid" fetchType="lazy">
  </collection>
</resultMap>
<select id="findAll" resultMap="userMap">
 SELECT * FROM `user`
</select>
    

    

    设置触发延迟加载的方法
    

    大家在配置了延迟加载策略后，发现即使没有调用关联对象的任何方法，但是在你调用当前对象的equals、clone、hashCode、toString方法时也会触发关联对象的查询。
    

    我们可以在配置文件中使用lazyLoadTriggerMethods配置项覆盖掉上面四个方法。
    

    

    <settings>
  <!--所有方法都会延迟加载-->
  <setting name="lazyLoadTriggerMethods" value="toString()"/>
</settings>
    

    

    全局延迟加载
    

    

    <settings>
  <!--开启全局延迟加载功能-->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>
    

    

    注意
    

    局部的加载策略优先级高于全局的加载策略。
    

    MyBatis缓存
    

    为什么使用缓存？
    

    　　当用户频繁查询某些固定的数据时,第一次将这些数据从数据库中查询出来,保存在缓存中。当用户再次查询这些数据时,不用再通过数据库查询,而是去缓存里面查询。减少网络连接和数据库查询带来的损耗,从而提高我们的查询效率,减少高并发访问带来的系统性能问题。
    

    　　一句话概括：经常查询一些不经常发生变化的数据，使用缓存来提高查询效率。
    

    　　像大多数的持久化框架一样，Mybatis也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。 Mybatis中缓存分为一级缓存，二级缓存。
    

    一级缓存
    

    　　一级缓存是SqlSession级别的缓存，是默认开启的
    

    　　所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如果没有声明需要刷新，并且缓存没有超时的情况下，SqlSession都会取出当前缓存的数据，而不会再次发送SQL到数据库。
    

    分析
    

    一级缓存是SqlSession范围的缓存，执行SqlSession的C（增加）U（更新）D（删除）操作，或者调用clearCache()、commit()、close()方法，都会清空缓存。
    

     
    

    

    1. 第一次发起查询用户id为41的用户信息，先去找缓存中是否有id为41的用户信息，如果没有，从数据库 查询用户信息。
    

    2. 得到用户信息，将用户信息存储到一级缓存中。
    

    3. 如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
    

    4. 第二次发起查询用户id为41的用户信息，先去找缓存中是否有id为41的用户信息，缓存中有，直接从缓存中获取用户信息。
    

    

    二级缓存
    

    二级缓存是namspace级别（跨sqlSession）的缓存，是默认不开启的
    

    二级缓存的开启需要进行配置，实现二级缓存的时候，MyBatis要求返回的POJO必须是可序列化的。也就是要求实现Serializable接口，配置方法很简单，只需要在映射XML文件配置 <cache/> 就可以开启二级缓存了。
    

    



    

    <settings>
  <!--
因为cacheEnabled的取值默认就为true，所以这一步可以省略不配置。
为true代表开启二级缓存；为false代表不开启二级缓存。
  -->
  <setting name="cacheEnabled" value="true"/>
</settings>

<mapper namespace="com.lagou.dao.UserMapper">
  <!--当前映射文件开启二级缓存-->
  <cache></cache>
  <!--
<select>标签中设置useCache=”true”代表当前这个statement要使用二级缓存。
如果不使用二级缓存可以设置为false
    注意：
      针对每次查询都需要最新的数据sql，要设置成useCache="false"，禁用二级缓存。
-->
  <select id="findById" parameterType="int" resultType="user" useCache="true">
   SELECT * FROM `user` where id = #{id}
  </select>
</mapper>
    

    

    二级缓存是mapper映射级别的缓存，多个SqlSession去操作同一个Mapper映射的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。
    

     
    


    

     1. 映射语句文件中的所有select语句将会被缓存。
    

    2. 映射语句文件中的所有insert、update和delete语句会刷新缓存。
    

    

    注意问题（脏读）
    

    　　mybatis的二级缓存因为是namespace级别，所以在进行多表查询时会产生脏读问题
    

    小结
    

    

    1. mybatis的缓存，都不需要我们手动存储和获取数据。mybatis自动维护的。
    

    2. mybatis开启了二级缓存后，那么查询顺序：二级缓存--》一级缓存--》数据库
    

    3. 注意：mybatis的二级缓存会存在脏读问题，需要使用第三方的缓存技术解决问题。
    

    

    MyBatis注解
    

    

    * @Insert：实现新增，代替了<insert></insert>
    

    * @Delete：实现删除，代替了<delete></delete>
    

    * @Update：实现更新，代替了<update></update>
    

    * @Select：实现查询，代替了<select></select>
    


    * @Result：实现结果集封装，代替了<result></result>
    

    * @Results：可以与@Result 一起使用，封装多个结果集，代替了<resultMap></resultMap>
    

    * @One：实现一对一结果集封装，代替了<association></association>
    

    * @Many：实现一对多结果集封装，代替了<collection></collection>
    

    

    MyBatis注解的增删改查【重点】
    

    

    public interface UserMapper {
 
  @Select("SELECT * FROM `user`")
  public List<User> findAll();
  @Insert("INSERT INTO `user`(username,birthday,sex,address) VALUES(#
{username},#{birthday},#{sex},#{address})")
  public void save(User user);
  @Update("UPDATE `user` SET username = #{username},birthday = #{birthday},sex
= #{sex},address = #{address} WHERE id = #{id}")
  public void update(User user);
  @Delete("DELETE FROM `user` where id = #{id}")
  public void delete(Integer id);
}
    

    

    使用注解实现复杂映射开发
    

    之前我们在映射文件中通过配置 <resultMap>、<association>、<collection> 来实现复杂关系映射。
    

    使用注解开发后，我们可以使用 @Results、@Result，@One、@Many 注解组合完成复杂关系的配置。
    

    


     一对一查询
    

    

    public interface OrderMapper {
  @Select("SELECT * FROM orders")
  @Results({
      @Result(id = true, column = "id", property = "id"),
      @Result(column = "ordertime", property = "ordertime"),
      @Result(column = "money", property = "money"),
      @Result(property = "user", javaType = User.class,
          column = "uid", one = @One(select =
"com.lagou.mapper.UserMapper.findById", fetchType = FetchType.EAGER))
 })
  public List<Order> findAllWithUser();
}
    

    

    一对多查询
    

    

    public interface UserMapper {
  @Select("SELECT * FROM `user`")
  @Results({
    @Result(id = true, column = "id", property = "id"),
    @Result(column = "brithday", property = "brithday"),
    @Result(column = "sex", property = "sex"),
    @Result(column = "address", property = "address"),
    @Result(property = "orderList", javaType = List.class,
        column = "id" ,
        many = @Many(select = "com.lagou.mapper.OrderMapper.findByUid"))
 })
  public List<User> findAllWithOrder();
}
    

    

    多对多查询
    

    

    public interface UserMapper {
  @Select("SELECT * FROM `user`")
  @Results({
    @Result(id = true, column = "id", property = "id"),
    @Result(column = "brithday", property = "brithday"),
    @Result(column = "sex", property = "sex"),
    @Result(column = "address", property = "address"),
    @Result(property = "roleList", javaType = List.class,
        column = "id" ,
        many = @Many(select = "com.lagou.mapper.RoleMapper.findByUid"))
 })
  public List<User> findAllWithRole();
}

public interface RoleMapper {
  @Select("SELECT * FROM role r INNER JOIN user_role ur ON r.`id` = ur.`rid`
WHERE ur.`uid` = #{uid}")
  public List<Role> findByUid(Integer uid);
}
    

    

    基于注解的二级缓存
    

    在Mapper接口中使用注解配置二级缓存
    

    

    @CacheNamespace
public interface UserMapper {...}
    

    

    注解延迟加载
    

    不管是一对一还是一对多 ，在注解配置中都有fetchType的属性
    

    

    * fetchType = FetchType.LAZY 表示懒加载
    

    * fetchType = FetchType.EAGER 表示立即加载
    

    * fetchType = FetchType.DEFAULT 表示使用全局配置
    

    

    小结
    

    

    * 注解开发和xml配置优劣分析
    

    　　1.注解开发和xml配置相比，从开发效率来说，注解编写更简单，效率更高。
    

    　　2.从可维护性来说，注解如果要修改，必须修改源码，会导致维护成本增加。xml维护性更强。
    

    

    

    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  求约数的个数-牛客
                    
    成绩排序 -- 牛客
                    
    SpringBoot学习笔记4-整合Jdbc Template-Mybatis-多数据源-事务管理-JPA
                    
    SpringBoot学习笔记3-自定义拦截器-全局异常处理-Freemarker-Thymeleaf-定时任务调度
                    
    SpringBoot学习笔记2-日志管理-开发模式-web开发-FastJson
                    
    SpringBoot学习笔记1-简介-全局配置文件-starter-profiles-自动配置原理
                    
    将Ueditor文件上传至OSS
                    
    nouveau :failed to create kernel chanel,-22
                    
    教你怎么炼鸡肉
                    
    教你怎么写猜年龄游戏
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/zhf123/p/14424288.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看