Mybatis延迟加载

2020-05-29  本文已影响0人  Clark_

延迟加载的含义

延迟加载又叫按需查询（懒加载），mybatis支持延迟加载，我们希望一次性把常用的级联数据通过sql直接查询出来，而对于那些不常用的的级联数据不要取出，而是等待要用的时候才取出，这些不常用的级联数据可以采用延迟加载的功能。

延迟加载的配置

在mybatis的settings配置中存在两个元素可以配置级联

<caption style="margin: 0px; padding: 0px;">延迟加载的配置项</caption>
| 配置项 | 作用 | 配置选项说明 | 默认值 |
| lazyLoadingEnabled | 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。在特定关联关系中，可通过设置fetchType属性来覆盖该项的开关状态 | true|false | false |
| aggressiveLazyLoading | 当启用时，对任意延迟属性的调用会使带有延迟加载属性的对象完整加载；反之，则每种属性按需加载。 | true|false | 版本3.4.1（包含）之前为true，之后为false |

lazyLoadingEnabled表示延迟加载的总开关，如果将其设置为false，即使侵入式开关设置为true也不会生效。

aggressiveLazyLoading表示侵入式延迟加载开关，在3.4.1版本之前默认是true，之后默认是false。

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "Courier New" !important; font-size: 12px !important;"><settings>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="true"/>
</settings></pre>

** 延迟加载的优缺点**

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

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

加载时机

直接加载：执行完对主加载对象的 select 语句，马上执行对关联对象的 select 查询。
侵入式延迟： 执行对主加载对象的查询时，不会执行对关联对象的查询。但当要访问主加载对象的详情属性时，就会马上执行关联对象的select查询。
深度延迟： 执行对主加载对象的查询时，不会执行对关联对象的查询。访问主加载对象的详情时也不会执行关联对象的select查询。只有当真正访问关联对象的详情时，才会执行对关联对象的 select 查询。

如何实现延迟加载

MyBatis中对于延迟加载设置，只对于resultMap中的collection和association起作用，可以应用到一对一、一对多、多对一、多对多的所有关联关系查询中。

需要注意的是， 延迟加载的应用要求，关联对象的查询与主加载对象的查询必须是分别进行的 select 语句，不能是使用多表连接所进行的select查询。因为多表连接查询，其实质是对一张表的查询，对由多个表连接后形成的一张表的查询。会一次性将多张表的所有信息查询出来。

一对多的多表单独查询方式

修改之前的mapper.xml文件

<!--根据team的id查找player-->
<select id="selectPlayerByTeamId" resultType="Player"> select id,name from t_player WHERE tid=#{id} </select>

<!--关联属性映射关系-->
<!--集合的数据来自select查询，该查询的条件是selectTeamByIdAlone查询出的id-->
<resultMap id="teamMapAlone" type="Team">
    <id column="id" property="id"/>
    <result column="name" property="name"/>
    <collection property="playerList" ofType="Player" select="selectPlayerByTeamId" column="id"/>
</resultMap>

<select id="selectTeamByIdAlone" resultMap="teamMapAlone"> SELECT id,name FROM t_team where id=#{id} </select></pre>

修改之前的dao接口和测试类中的方法：

//dao接口
Team selectTeamByIdAlone(int id); //测试类
@Test public void selectTeamByIdAlone() {
    Team team = teamDao.selectTeamByIdAlone(1);
}

执行之后，可以看到在控制台中分两次发出了sql语句分别查询t_team和t_player表。

开启侵入式延迟

在mybatis.xml文件中添加下面内容，注意该内容的位置一定要在properties与typeAliases之间，在mybatis.xml配置文件中，有些标签是需要按照顺序编写的：

<!--全局参数设置-->
<settings>
    <!--延迟加载总开关-->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!--侵入式延迟加载开关-->
    <!--3.4.1版本之前默认是true，之后默认是false-->
    <setting name="aggressiveLazyLoading" value="true"/>
</settings>

将以上内容配置好之后，再执行上面测试类方法的时候，就会发现在控制台中只发出了一条查询t_team的sql语句，这是因为我们开启了侵入式延迟加载开关，在java程序中并未访问Team中的任何属性，所以mybatis不会去查询其关联的player对象数据。

修改后测试方法：

@Test public void selectTeamByIdAlone() {
    Team team = teamDao.selectTeamByIdAlone(1);
    System.out.println(team.getName());
}

再次执行上面方法之后就会看到控制台中发出两条SQL语句分别查询t_team和t_player,这是因为在java程序中访问了Team的属性name，所以mybatis会将其关联的player对象数据查询出来。

开启深度延迟加载

修改mybatis.xml文件：开启总开关，将aggressiveLazyLoading关闭即可。

<!--全局参数设置-->
<settings>
    <!--延迟加载总开关-->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!--侵入式延迟加载开关-->
    <!--3.4.1版本之前默认是true，之后默认是false-->
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

继续执行上面的测试方法，可以看到控制台中只打印了一条查询t_team表的sql语句。

修改测试方法如下：

@Test public void selectTeamByIdAlone() {
    Team team = teamDao.selectTeamByIdAlone(1);
    System.out.println(team.getName());
    System.out.println(team.getPlayerList().size());
}</pre>

执行上面测试方法之后，可以看到控制台中打印了两条sql语句分别查询t_team和t_player，这说明当开启深度延迟后，只要代码中不使用player相关的数据，mybatis就不会进行sql查询，只有当真正使用的时候才会去发出sql语句查询。

在单个resultMap中使用延迟加载（fetchType）

上面都是通过在mybatis.xml文件中统一配置的深度延迟加载，倘若只希望某些查询支持深度延迟加载的话可以在resultMap中的collection或association添加fetchType属性，配置为lazy之后是开启深度延迟，配置eager是不开启深度延迟。fetchType属性将取代全局配置参数lazyLoadingEnabled的设置

延迟加载总结

通过上面的示例可以发现深度加载的方式最为懒，通过这种方式可以让mybatis在执行查询的时候减少sql的查询从而提高程序的执行效率，但是并不是所有场景下使用懒加载都能提高效率，有些场景比如在查询一对多时，就需要将一方和多方都查询出来，这样的话开启懒加载反而有可能会拖慢程序的执行效率

mybatis的延迟加载就是按需查询，在需要的时候进行查询。

有两张表：

图书表（book）：

image

图书类型表(category)：

image

他们之间通过类型id进行关联，现在我要显示图书类型名，点击类型名再显示该类型下的所有图书。

我们可以这样做在类型实体类里面添加一个属性存放该类型下的图书

public class Category {
    private int cid;
    private String cname;
    private List<Book> books;
//省略get set
}

一次性的把图书类型和图书查询出来，Sql语句如下：

SELECT book.*,cname FROM book,category WHERE book.cid = category.cid

这样做可以完成功能，但是我们只是需要显示图书类型，点击的时候才显示该类型的图书，如果能做到开始只查询类型，点击类型的时候再查询该类型的图书，就不需要进行两表联查了，可以提高查询的效率，也比较节省内存，这就是延迟加载。

延迟加载如何实现？

1. Category实体类同上

2. UserDao.xml:

<mapper namespace="cn.xh.dao.UserDao">
    <select id="findCategoryWithLazingload" resultMap="categoryMap">
        select * from category
    </select>
    <resultMap id="categoryMap" type="cn.xh.pojo.Category">
        <id column="cid" property="cid"></id>
        <result column="cname" property="cname"></result>

        <collection property="books" column="cid" select="findBookWithLazy"></collection>
    </resultMap>

    <select id="findBookWithLazy" parameterType="int" resultType="cn.xh.pojo.Book">
        select * from book where cid = #{cid}
    </select>
</mapper>

只有我们点击类型的时候才需要查询该类型下的图书，所以这里我们没有用两表联查，而是将类型表的查询语句和图书表的查询语句分开。

重点来看下这个配置：

<collection property="books" column="cid" select="findBookWithLazy"></collection>

collection，association是支持延迟加载的，这里的select属性表示要执行的sql语句，column表示执行sql语句要传的参数，该参数为select *** **from category查询出来的字段cid,property=”books”表示查询出来的结果给到books属性。

  1. 在mybatis的核心配置文件中配置：
<settings>
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"></setting>
</settings>

注意，这个配置必须写在properties配置的后面，typeAliases的前面。

将lazyLoadingEnabled设置为true表示开启延迟加载，默认为false.

将aggressiveLazyLoading设置为false表示按需加载，默认为true

关于这两个设置后面再详加探讨。

4. 测试：

@Test
public void testDo(){
    SqlSession session = sqlSessionFactory.openSession();
    UserDao u =  session.getMapper(UserDao.class);//用动态代理的方式自动生成接口的实现类
 List<Category> lst  =  u.findCategoryWithLazingload();
 for (Category c : lst) {
        System.out.println(c.getCname());

    }
    session.close();
}

执行看看日志：

image

这段代码只涉及到了图书类型，并未涉及到图书部分，所以只执行了select * from category从类型表中查询出类型信息。

再来测试这段代码：

@Test
public void testDo1(){
    SqlSession session = sqlSessionFactory.openSession();
    UserDao u =  session.getMapper(UserDao.class);//用动态代理的方式自动生成接口的实现类
 List<Category> lst  =  u.findCategoryWithLazingload();
 for (Category c : lst) {
        System.out.println(c.getCname());
    }
    List<Book> lstBook = lst.get(0).getBooks();
    session.close();
}

执行看看日志：

image

这里执行了两个sql语句：

Select * from category

Select * from book where cid = ?

对比这两段代码，可以看到， 只有当执行List<Book> lstBook = lst.get(0).getBooks();这行代码的时候才会去执行sql语句Select * from book where cid = ?。

这就是延迟加载里的按需执行sql语句，只有在需要的时候才会去执行。

回顾一下第三个步骤中的配置：

此时 lazyLoadingEnabled设置为true, aggressiveLazyLoading设置为false，表示延迟加载开启，按需加载也开启。分析一下在这种配置下代码的每一步都做了什么：

1.List<Category> lst = u.findCategoryWithLazingload();执行到这行代码的时候从数据库中查询图书类型的信息。

2.System.out.println(c.getCname());执行这行代码的时候因为图书类型信息已经被查询出来，所以不需要再和数据库交互。

3.List<Book> lstBook = lst.get(0).getBooks();执行这行代码的时候从数据库中查询该类型下图书的信息。

如果将lazyLoadingEnabled设置为true, aggressiveLazyLoading设置为true,表示延迟加载开启，按需加载关闭，代码每一步都做了什么呢？

1.List<Category> lst = u.findCategoryWithLazingload();执行到这行代码的时候从数据库中查询图书类型的信息。

2.System.out.println(c.getCname());执行这行代码的时候，需要加载图书类型的属性“类型名”，因为将按需加载关闭，所以此时会把Category的所有属性都加载进来，包括List<Book> books,会去数据库中查询图书的信息。

3.List<Bosok> lstBook = lst.get(0).getBooks();执行这行代码的时候因为图书的信息已经被加载进来，不需要查询数据库。

如果将lazyLoadingEnabled设置为false，相当于关闭了延迟加载，此时无论aggressiveLazyLoading是true还是false都会在执行

List<Category> lst = u.findCategoryWithLazingload();

的时候将类型和图书的信息都查询出来。

总结一下：

一：延迟加载就是按需加载，在需要查询的时候再去查询，使用延迟加载可以避免表连接查询，表连接查询比单表查询的效率低，但是它需要多次与数据库进行交互，所以延迟加载并不是银弹，使用需谨慎。

二：关于延迟加载有两个重要的设置：lazyLoadingEnabled表示延迟加载是否开启，如果设置为true表示开启，此时还需要设置aggressiveLazyLoading为false,才能做到按需加载，如果aggressiveLazyLoading设置为true则按需加载关闭，此时只要加载了某个属性就会将所有属性都加载。

lazyLoadingEnabled的默认值为false

aggressiveLazyLoading的默认值为true

上一篇下一篇

猜你喜欢

热点阅读