[MyBatis-04]延迟加载、缓存和注解开发

最新推荐文章于 2022-01-21 17:45:17 发布

学哥斌

最新推荐文章于 2022-01-21 17:45:17 发布

阅读量183

点赞数

分类专栏： Java持久层框架文章标签：数据库 mybatis java

本文链接：https://blog.csdn.net/qq_29051413/article/details/104503305

版权

Java持久层框架专栏收录该内容

9 篇文章 1 订阅

订阅专栏

文章目录

1、Mybatis延迟加载策略
2、Mybatis缓存
3、Mybatis注解开发

1、Mybatis延迟加载策略

Mybatis 中一对一，一对多，多对多关系的配置及实现，可以实现对象的关联查询。实际开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的账户信息。此时就是我们所说的延迟加载。

1.1 什么是延迟加载

延迟加载就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载.
好处：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。
坏处：因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。

1.2 实现需求

需求：查询账户(Account)信息并且关联查询用户(User)信息。如果先查询账户(Account)信息即可满足要求，当我们需要查询用户(User)信息时再查询用户(User)信息。把对用户(User)信息的按需去查询就是延迟加载。
实现多表操作时，我们使用了resultMap来实现一对一，一对多，多对多关系的操作。主要
是通过 association、collection 实现一对一及一对多映射。association、collection 具备延迟加载功能。

1.3 使用association实现延迟加载

1.3.1 账户类

public class Account implements Serializable {
    private Integer ID;
    private Integer UID;
    private double MONEY;

    private User user;
	//省略set和get
}

1.3.2 账户的持久层Dao接口

public interface AccountDao {
    List<Account> findAll();
}

1.3.3 账户的持久层映射文件

<?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:指明是哪一个接口-->
<!--id:指明接口的哪一个方法-->
<!--resultType:指明哪个类来封装访问数据库返回的数据-->
<mapper namespace="cn.klb.domain.dao.AccountDao">
    <!-- 建立对应关系 -->
    <resultMap type="cn.klb.domain.Account" id="accountMap">
        <id column="aid" property="ID"/>
        <result column="uid" property="UID"/>
        <result column="money" property="MONEY"/>
        <!-- 它是用于指定从表方的引用实体属性的 -->
        <association property="user" javaType="cn.klb.domain.User"
        select="cn.klb.domain.dao.UserDao.findById"
        column="uid">
        </association>
    </resultMap>

    <select id="findAll" resultMap="accountMap">
        select * from account
    </select>
</mapper>

select ：填写我们要调用的 select 映射的 id
column ：填写我们要传递给 select 映射的参数
association的这两个属性意思是：当需要加载user信息时，调用select指定的方法，输入column指定的参数。

1.3.4 用户的持久层映射文件

<?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:指明是哪一个接口-->
<!--id:指明接口的哪一个方法-->
<!--resultType:指明哪个类来封装访问数据库返回的数据-->
<mapper namespace="cn.klb.domain.dao.UserDao">
    <select id="findById" parameterType="Integer" resultType="cn.klb.domain.User">
        select * from user where id=#{id};
    </select>
</mapper>

1.3.5 开启Mybatis的延迟加载策略

进入 Mybaits 的官方文档，找到 settings 的说明信息：
在这里插入图片描述
我们需要在 Mybatis 的配置文件 SqlMapConfig.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>

    <!--配置延迟加载-->
    <settings>
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

    <!--配置环境-->
    <environments default="mysql">
        <!--配置sql环境-->
        <environment id="mysql">
            <!--配置事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置连接池-->
            <dataSource type="UNPOOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatisdb"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--配置映射文件-->
    <mappers>
        <mapper resource="cn/klb/dao/UserDao.xml"></mapper>
        <mapper resource="cn/klb/dao/AccountDao.xml"></mapper>
    </mappers>

</configuration>

1.3.6 编写测试方法

@Test
public void testFindAll(){
	List<Account> accounts = accountDao.findAll();
	for (Account account : accounts) {
		System.out.println(account);
	}
}

这个方法明显使用了account对象的user属性，可以观察日志输出如下：
在这里插入图片描述
因为在account的toString方法中调用了user的toString，所以全加载；当测试方法改为如下：

public void testFindAll(){
	List<Account> accounts = accountDao.findAll();
	//for (Account account : accounts) {
	//	System.out.println(account);
	//}
}

日志输出如下：
在这里插入图片描述
此时不适用account的user属性，所以没有访问，是延迟加载。

1.4 使用Collection实现延迟加载

Collection是用在一对多的情况下，<collection>结点中也有 select 属性，column 属性。

1.4.1 在User实体类中加入List<Account>属性

public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    private List<Account> accounts;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", address='" + address + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", accounts=" + accounts +
                '}';
    }

    //省略set和get
}

1.4.2 编写用户和账户持久层接口的方法

public interface UserDao {

    /**
     * 查询所有用户
     * @return
     */
    List<User> findAll();
}

---- 分割线 ----

public interface AccountDao {

    /**
     * 根据用户id查找账户信息
     * @return
     */
    List<Account> findByUid();
}

1.4.3 编写用户持久层映射配置

<?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:指明是哪一个接口-->
<!--id:指明接口的哪一个方法-->
<!--resultType:指明哪个类来封装访问数据库返回的数据-->
<mapper namespace="cn.klb.domain.dao.UserDao">
    <resultMap type="cn.klb.domain.User" id="userMap">
        <id column="id" property="id"></id>
        <result column="username" property="username"/>
        <result column="address" property="address"/>
        <result column="sex" property="sex"/>
        <result column="birthday" property="birthday"/>
        <!-- collection 是用于建立一对多中集合属性的对应关系
        ofType 用于指定集合元素的数据类型
        -->
        <collection property="accounts" ofType="cn.klb.domain.Account"
                    select="cn.klb.domain.dao.AccountDao.findByUid"
                    column="id">
        </collection>
    </resultMap>

    <select id="findAll" resultMap="userMap">
        select * from user
    </select>
</mapper>

<collection> 标签：主要用于加载关联的集合对象；
select 属性：用于指定查询 account 列表的 sql 语句，所以填写的是该 sql 映射的 id；
column 属性：用于指定 select 属性的 sql 语句的参数来源，上面的参数来自于 user 的 id 列，所以就写成 id 这一个字段名了

1.4.4 编写账户持久层映射配置

<?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:指明是哪一个接口-->
<!--id:指明接口的哪一个方法-->
<!--resultType:指明哪个类来封装访问数据库返回的数据-->
<mapper namespace="cn.klb.domain.dao.AccountDao">
    <select id="findByUid" resultType="cn.klb.domain.Account">
        select * from account where uid=#{uid}
    </select>
</mapper>

1.4.5 编写测试方法

@Test
public void testFindAll(){
List<User> users = userDao.findAll();
	for (User user : users) {
		System.out.println(user);
	}
}

此处对user进行打印输出，其中包含了user的accounts属性，所以是全加载，日志输出如下：
在这里插入图片描述
当不适用user的accounts属性时：

@Test
public void testFindAll(){
List<User> users = userDao.findAll();
	//for (User user : users) {
	//	System.out.println(user);
	//}
}

在这里插入图片描述
明显，此时是延迟加载，没有加载account的信息。

2、Mybatis缓存

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

2.1 Mybatis一级缓存

一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。

2.1.1 编写用户持久层Dao接口

public interface UserDao {

    /**
     * 查询所有
     * @return
     */
    List<User> findById();
}

2.1.2 持久层配置文件

<?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:指明是哪一个接口-->
<!--id:指明接口的哪一个方法-->
<!--resultType:指明哪个类来封装访问数据库返回的数据-->
<mapper namespace="cn.klb.domain.dao.UserDao">
	<select id="findById" parameterType="Integer" resultType="cn.klb.domain.User">
        select * from user where id=#{id};
    </select>
</mapper>

2.1.3 编写测试方法

@Test
public void testFindById() {
	User user = userDao.findById(41);
	System.out.println("第一次查询的用户："+user);
	User user2 = userDao.findById(41);
	System.out.println("第二次查询用户："+user2);
	System.out.println(user == user2);
}

输出日志如下：
在这里插入图片描述
我们可以发现，虽然在上面的代码中我们查询了两次，但最后只执行了一次数据库操作，这就是 Mybatis 提供给我们的一级缓存在起作用了。因为一级缓存的存在，导致第二次查询 id为41的记录时，并没有发出sql语句从数据库中查询数据，而是从一级缓存中查询。

2.1.4 一级缓存分析

一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改、添加、删除、commit()、close()等方法时，就会清空一级缓存。
在这里插入图片描述
第一次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，如果没有，从数据库查询用户信息。
得到用户信息，将用户信息存储到一级缓存中。
如果 sqlSession 去执行 commit 操作（执行插入、更新、删除），清空 SqlSession 中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
第二次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，缓存中有，直接从缓存中获取用户信息。

2.1.5 测试一级缓存的清空

@Test
public void testFindById() {
	User user = userDao.findById(41);
	System.out.println("第一次查询的用户："+user);
	
	sqlSession.clearCache();
	userDao = sqlSession.getMapper(UserDao.class);
	
	User user2 = userDao.findById(41);
	System.out.println("第二次查询用户："+user2);
	
	System.out.println(user == user2);
}

日志输出如下：
在这里插入图片描述
当执行sqlSession.close()后，再次获取sqlSession并查询id=41的User对象时，又重新执行了sql语句，从数据库进行了查询操作。

2.2 Mybatis二级缓存

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

2.2.1 二级缓存结构图

在这里插入图片描述
首先开启 mybatis 的二级缓存。
sqlSession1 去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。
如果 SqlSession3 去执行相同 mapper 映射下 sql，执行 commit 提交，将会清空该 mapper 映射下的二级缓存区域的数据。
sqlSession2 去查询与 sqlSession1 相同的用户信息，首先会去缓存中找是否存在数据，如果存在直接从缓存中取出数据。

2.2.2 二级缓存的开启与关闭

第一步：在 SqlMapConfig.xml 文件开启二级缓存

<settings>
	<!-- 开启二级缓存的支持 -->
	<setting name="cacheEnabled" value="true"/>
</settings>

因为 cacheEnabled 的取值默认就为 true，所以这一步可以省略不配置。为 true 代表开启二级缓存；为false 代表不开启二级缓存。
第二步：配置相关的 Mapper 映射文件

<cache>标签表示当前这个 mapper 映射将使用二级缓存，区分的标准就看 mapper 的 namespace 值。

<?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="cn.klb.dao.UserDao">
	<!-- 开启二级缓存的支持 -->
	<cache></cache>
</mapper>

第三步：配置 <select> 上面的 useCache 属性

<!-- 根据 id 查询 -->
<select id="findById" resultType="cn.klb.domain.User" parameterType="int" useCache="true">
	select * from user where id = #{uid}
</select>

将 UserDao.xml 映射文件中的<select>标签中设置 useCache=”true”代表当前这个 statement 要使用二级缓存，如果不使用二级缓存可以设置为 false。
注意：针对每次查询都需要最新的数据 sql，要设置成 useCache=false，禁用二级缓存。

2.2.3 二级缓存测试

public void testFirstLevelCache() {
	SqlSession sqlSession1 = factory.openSession();
	UserDao dao1 = sqlSession1.getMapper(UserDao.class);
	User user1 = dao1.findById(41);
	System.out.println(user1);
	
	sqlSession1.close();//一级缓存消失
	
	SqlSession sqlSession2 = factory.openSession();
	UserDao dao2 = sqlSession2.getMapper(UserDao.class);
	User user2 = dao2.findById(41);
	System.out.println(user2);
	
	sqlSession2.close();
	        
	System.out.println(user1 == user2);
}

日志输出如下：
在这里插入图片描述
经过上面的测试，我们发现执行了两次查询，并且在执行第一次查询后，我们关闭了一级缓存，再去执行第二次查询时，我们发现并没有对数据库发出 sql 语句，所以此时的数据就只能是来自于我们所说的二级缓存。
注意到这两个对象不是同一个，是因为二级缓存存储的是数据，而不是对象。

2.2.4 二级缓存注意事项

当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，这种就可以使用序列化方式来保存对象。

3、Mybatis注解开发

这几年来注解开发越来越流行，Mybatis 也可以使用注解开发方式，这样我们就可以减少编写 Mapper 映射文件了。

3.1 Mybatis的常用注解说明

@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
@Result:实现结果集封装
@Results:可以与@Result 一起使用，封装多个结果集
@ResultMap:实现引用@Results 定义的封装
@One:实现一对一结果集封装
@Many:实现一对多结果集封装
@SelectProvider: 实现动态 SQL 映射
@CacheNamespace:实现注解二级缓存的使用

3.2 使用Mybatis注解实现CRUD

3.2.1 编写实体类

public class User implements Serializable {
    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;

	//省略set和get

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userAddress='" + userAddress + '\'' +
                ", userSex='" + userSex + '\'' +
                ", userBirthday=" + userBirthday +
                '}';
    }
}

此处故意和数据库表的列名不一致。

3.2.2 使用注解方式开发持久层接口

public interface UserDao {

    /**
     * 查询所有用户信息
     * @return
     */
    @Select("select * from user")
    @Results(id = "userMap",
            value = {
                    @Result(id = true, column = "id", property = "userId"),
                    @Result(column = "id", property = "userId"),
                    @Result(column = "username", property = "userName"),
                    @Result(column = "sex", property = "userSex"),
                    @Result(column = "address", property = "userAddress"),
                    @Result(column = "birthday", property = "userBirthday")
            })
    List<User> findAll();
    
    /**
     * 通过userId查询用户
     * @param userId
     * @return
     */
    @Select("select * from user where id = #{uid}")
    @ResultMap("userMap")
    User findById(Integer userId);

}

3.2.3 编写SqlMapConfig配置文件

<?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>

    <settings>
        <!--配置延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>

        <!-- 开启二级缓存的支持 -->
        <setting name="cacheEnabled" value="true"/>
    </settings>

    <!--配置环境-->
    <environments default="mysql">
        <!--配置sql环境-->
        <environment id="mysql">
            <!--配置事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置连接池-->
            <dataSource type="UNPOOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatisdb"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--配置映射文件-->
    <mappers>
        <mapper class="cn.klb.domain.dao.UserDao"></mapper>
    </mappers>

</configuration>

3.2.4 编写测试方法

public class AnnotationTest {
    private InputStream in = null;
    private SqlSessionFactory factory = null;
    private SqlSession sqlSession = null;
    private UserDao userDao = null;

    @Before
    public void init() throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession();
        //4.获取dao代理对象
        userDao = sqlSession.getMapper(UserDao.class);
    }

    @After
    public void destroy() throws Exception{
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

    @Test
    public void testFindById(){
        User user = userDao.findById(45);
        System.out.println(user);
    }
}

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

实现复杂关系映射之前我们可以在映射文件中通过配置<resultMap>来实现，在使用注解开发时我们需要借助 @Results，@Result ，@One ，@Many 。

3.3.1 复杂关系映射的注解说明

@Results注解:
	代替的是标签<resultMap>
	该注解中可以使用单个@Result注解，也可以使用@Result集合
	@Results({@Result(),@Result()})
	或
	@Results(@Result())

@Resutl注解:
	代替了<id> 标签和<result> 标签
	@Result中属性介绍：
	id 是否是主键字段
	column 数据库的列名
	property 需要装配的属性名
	one 需要使用的@One注解(@Result(one=@One)()))
	many 需要使用的@Many注解(@Result(many=@many)()))

@One注解(一对一)
	代替了<assocation>标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。
	@One注解属性介绍：
		select 指定用来多表查询的sqlmapper
		fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。
	使用格式：
		@Result(column=" ",property="",one=@One(select=""))

@Many  注解（多对一）
	代替了<Collection> 标签, 是多表查询的关键，在注解中用来指定子查询返回对象集合
	注意：聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，属性的 javaType（一般为 ArrayList）但是注解中可以不定义；
	使用格式：
		@Result(property="",column="",many=@Many(select=""))

3.3.2 使用注解实现一对一复杂关系映射及延迟加载

一个账户只能属于一个用户，属于一对一。
User实体类：

public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

	//省略set和get
}

Account实体类：

public class Account implements Serializable {
    private Integer ID;
    private Integer UID;
    private double MONEY;

    private User user;
    //省略set和get
}

AccountDao使用注解配置：

public interface AccountDao {

    /**
     * 查询所有账户，延迟加载账户所属用户
     *
     * @return
     */
    @Select("select * from account")
    @Results(value = {
            @Result(column = "uid", property = "user",
                    one = @One(select = "cn.klb.domain.dao.UserDao.findById",
                            fetchType = FetchType.LAZY
                    ))
    })
    List<Account> findAll();
}

UserDao使用注解配置：

public interface UserDao {
    /**
     * 通过userId查询用户
     *
     * @param userId
     * @return
     */
    @Select("select * from user where id = #{uid}")
    //@ResultMap("userMap")
    User findById(Integer userId);
}

测试延迟加载：

public class AccountTest {
    private InputStream in = null;
    private SqlSessionFactory factory = null;
    private SqlSession sqlSession = null;
    private AccountDao accountDao = null;

    @Before
    public void init() throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession();
        //4.获取dao代理对象
        accountDao = sqlSession.getMapper(AccountDao.class);
    }

    @After
    public void destroy() throws Exception{
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for (Account account : accounts) {
            System.out.println(account);
        }
    }
}

此时的testFindAll()方法使用了account的user属性，属于全加载，所以日志输出如下：
在这里插入图片描述
当测试方法改为：

    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        //for (Account account : accounts) {
        //    System.out.println(account);
        //}
    }

此时没有使用account的user属性，所以是延迟加载，日志输出如下：
在这里插入图片描述

3.3.3 使用注解实现一对多复杂关系映射

一个用户有多个账户，属于一对多。
User实体类加入accounts属性：

public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    private List<Account> accounts;
    //省略set和get
}

编写User的持久层接口：

public interface UserDao {

    /**
     * 查询所有
     *
     * @return
     */
    @Select("select * from user")
    @Results(value = {
            @Result(column = "id", property = "accounts",
                    many = @Many(
                            select = "cn.klb.domain.dao.AccountDao.findByUid",
                            fetchType = FetchType.LAZY
                    ))
    })
    List<User> findAll();
}

编写Account的持久层接口：

public interface AccountDao {

    /**
     * 根据用户id查找账户信息
     *
     * @return
     */
    @Select("select * from account where uid = #{uid}")
    List<Account> findByUid();
}

添加测试方法：

public class AnnotationTest {
    private InputStream in = null;
    private SqlSessionFactory factory = null;
    private SqlSession sqlSession = null;
    private UserDao userDao = null;

    @Before
    public void init() throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession();
        //4.获取dao代理对象
        userDao = sqlSession.getMapper(UserDao.class);
    }

    @After
    public void destroy() throws Exception{
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

这里用到了user的accounts属性，日志输出如下：
在这里插入图片描述
修改测试方法：

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        //for (User user : users) {
         //   System.out.println(user);
        //}
    }

此时没有使用user的accounts属性，日志输出如下：
在这里插入图片描述

3.4 Mybatis基于注解的二级缓存

3.4.1 在SqlMapCondig中开启二级缓存支持

<!-- 配置二级缓存 -->
<settings>
<!-- 开启二级缓存的支持 -->
	<setting name="cacheEnabled" value="true"/>
</settings>

3.4.2 在持久层接口中使用注解配置二级缓存

@CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存
public interface UserDao {}

学哥斌

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[MyBatis-04]延迟加载、缓存和注解开发

1、Mybatis延迟加载策略 Mybatis 中一对一，一对多，多对多关系的配置及实现，可以实现对象的关联查询。实际开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的账户信息。此时就是我们所说的延迟加载。1.1 什么是延迟加载延迟加载就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载. 好处：先从单表查询，需要时再从关联表去关联查询...
复制链接

扫一扫