第四天：mybatis的緩存和注解開發(fā)

mybatis框架 學(xué)習(xí)計劃

共四天
第一天：mybatis入門
mybatis的概述
mybatis的環(huán)境搭建
mybatis入門案例
自定義mybatis框架（主要的目的是為了讓大家了解mybatis中執(zhí)行細節(jié)）
第二天：mybatis基本使用
mybatis的單表crud操作
mybatis的參數(shù)和返回值
mybatis的dao編寫
mybatis配置的細節(jié)
幾個標簽的使用
第三天：mybatis的深入和多表
mybatis的連接池
mybatis的事務(wù)控制及設(shè)計的方法
mybatis的多表查詢
一對多（多對一）
多對多
第四天：mybatis的緩存和注解開發(fā)
mybatis中的加載時機（查詢的時機）
mybatis中的一級緩存和二級緩存
mybatis的注解開發(fā)
單表CRUD
多表查詢

4.1 Mybatis 延遲加載策略（查詢的時機）

? 通過前面的學(xué)習(xí),我們已經(jīng)掌握了 Mybatis 中一對一,一對多,多對多關(guān)系的配置及實現(xiàn),可以實現(xiàn)對象的關(guān)聯(lián)查詢。實際開發(fā)過程中很多時候我們并不需要總是在加載用戶信息時就一定要加載他的賬戶信息。此時就是我們所說的延遲加載。

4.1.1 為什么要用延遲加載策略

延遲加載:
就是在需要用到數(shù)據(jù)時才進行加載,不需要用到數(shù)據(jù)時就不加載數(shù)據(jù)。延遲加載也稱懶加載.
好處:

? 先從單表查詢,需要時再從關(guān)聯(lián)表去關(guān)聯(lián)查詢,大大提高數(shù)據(jù)庫性能,因為查詢單表要比關(guān)聯(lián)查詢多張表速度要快。
壞處:
因為只有當(dāng)需要用到數(shù)據(jù)時,才會進行數(shù)據(jù)庫查詢,這樣在大批量數(shù)據(jù)查詢時,因為查詢工作也要消耗時間,所以可能造成用戶等待時間變長,造成用戶體驗下降。

實現(xiàn)需求

需求:
查詢賬戶(Account)信息并且關(guān)聯(lián)查詢用戶(User)信息。如果先查詢賬戶(Account)信息即可滿足要求,當(dāng)我們需要查詢用戶(User)信息時再查詢用戶(User)信息。把對用戶(User)信息的按需去查詢就是延遲加載。
mybatis 第三天實現(xiàn)多表操作時,我們使用了 resultMap 來實現(xiàn)一對一,一對多,多對多關(guān)系的操作。主要是通過 association、collection 實現(xiàn)一對一及一對多映射。association、collection 具備延遲加載功能。

實際使用場景

在對應(yīng)的四種表關(guān)系中：一對多，一對一，多對多
    一對多，多對多：通常情況下我們都是采用延遲加載。
    一對一：通常情況下我們都是采用立即加載。

4.1.2 使用 assocation 實現(xiàn)延遲加載(一對一)

? 需求:
查詢賬戶信息同時查詢用戶信息。

1. 編寫賬戶實體類

/**
 * 賬號實體類
 */
public class Account implements Serializable {

    private  Integer id;

    private Integer uid;

    private Double money;

    //從表實體應(yīng)該包含一個主體實體的對象引用
    private User user;

// getter + setter 省略

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                '}';
    }
}

2.賬戶的持久層 DAO 接口

public interface AccountDao {

    /**
     * 查詢所有賬號,同時還要獲取到當(dāng)前賬號的所屬用戶信息
     * @return
     */
    List<Account> findAll();
}

3. 賬戶的持久層映射文件

    <!-- 定義account和user的resultMap-->
    <resultMap id="accountUserMap" type="org.example.domain.Account">
        <id property="id" column="id"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 一對一的關(guān)系映射: 配置封裝user的內(nèi)容  配置延遲加載-->
        <association property="user" column="uid" javaType="org.example.domain.User" select="org.example.dao.UserDao.findById">
        </association>

    </resultMap>

    <!-- 查詢所有賬號-->
    <select id="findAll" resultMap="accountUserMap">
            select * from account
    </select>

select: 填寫我們要調(diào)用的 select 映射的 id
column : 填寫我們要傳遞給 select 映射的參數(shù)

4. 用戶的持久層接口和映射文件

/**
 * 根據(jù)Id查詢用戶
 */
User findById(Integer id);

    <!-- 根據(jù)Id查詢用戶-->
    <select id="findById" parameterType="java.lang.Integer" resultType="org.example.domain.User">
    select * from  user where id = #{id}
    </select>

5. 編寫測試只查賬戶信息不查用戶信息。

public class AccountTest {

    private  InputStream in;
    private  SqlSession sqlSession;
    private AccountDao accountDao;

    @Before  // test方法執(zhí)行之前執(zhí)行
    public void init() throws IOException {
            //1.讀取配置文件
             in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.創(chuàng)建 SqlSessionFactory 的構(gòu)建者對象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //3.使用構(gòu)建者創(chuàng)建工廠對象 SqlSessionFactory
            SqlSessionFactory factory = builder.build(in);

            //4.使用 SqlSessionFactory 生產(chǎn) SqlSession 對象
            sqlSession = factory.openSession();

            //5.使用 SqlSession 創(chuàng)建 dao 接口的代理對象
            accountDao = sqlSession.getMapper(AccountDao.class);

    }

    @After // test方法執(zhí)行之后執(zhí)行
    public void destroy() throws IOException {
        //提交事務(wù)
        sqlSession.commit();
        //7.釋放資源
        sqlSession.close();
        in.close();
    }

    /**
     * 查詢所有賬號
     */
    @Test
    public void testFindAll()  {
        List<Account> accounts = accountDao.findAll();
        for(Account account : accounts) {
           // System.out.println(account);
        }
    }
 
}

6 測試結(jié)果

DEBUG example.dao.AccountDao.findAll  - ==>  Preparing: select * from account 
DEBUG example.dao.AccountDao.findAll  - ==> Parameters: 
DEBUG example.dao.AccountDao.findAll  - <==      Total: 3
DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@612679d6]
DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@612679d6]
DEBUG source.pooled.PooledDataSource  - Returned connection 1629911510 to pool.

? 我們發(fā)現(xiàn),因為本次只是將 Account 對象查詢出來放入 List 集合中,并沒有涉及到 User 對象,所以就沒有發(fā)出 SQL 語句查詢賬戶所關(guān)聯(lián)的 User 對象的查詢。

4.1.3 使用 Collection 實現(xiàn)延遲加載(一對多)

同樣我們也可以在一對多關(guān)系配置的<collection>結(jié)點中配置延遲加載策略。
<collection>結(jié)點中也有 select 屬性,column 屬性。
需求:
完成加載用戶對象時,查詢該用戶所擁有的賬戶信息

1. 在 User 實體類中加入List<Account>屬性

/**
 * 用戶的實體類
 */
public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    // 一對多關(guān)系映射; 主表實體應(yīng)該包含從表實體的集合引用
    private List<Account> accounts;
    // 多對多的關(guān)系映射: 一個用戶可以具有多個角色
    private List<Role> roles;

// getter setter 省略

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

2. 編寫用戶和賬戶持久層接口的方法

/**
 * 查詢所有用戶操作
 * @return
 */
List<User> findAll();

/**
 *查詢所有賬戶 根據(jù)用戶id 
 * @return
 */
List<Account> findAllByUid(Integer uid);

3. 編寫用戶持久層映射配置

<!-- 定義User賬號的resultMap -->
<resultMap id="userMap" type="org.example.domain.User">
    <id property="id" column="id"></id>
    <result property="username" column="username"></result>
    <result property="sex" column="sex"></result>
    <result property="birthday" column="birthday"></result>
    <result property="address" column="address"></result>
   
   <!--配置user對象中國accounts集合映射  延遲加載-->
    <collection property="accounts" column="id" ofType="org.example.domain.Account" select="org.example.dao.AccountDao.findAllByUid">

    </collection>

</resultMap>

<!-- 配置查詢所有操作 -->
<select id="findAll" resultMap="userMap">
    select * from user
</select>

<collection>標簽:
        主要用于加載關(guān)聯(lián)的集合對象
select 屬性:
        用于指定查詢 account 列表的 sql 語句,所以填寫的是該 sql 映射的 id
column 屬性:
        用于指定 select 屬性的 sql 語句的參數(shù)來源,上面的參數(shù)來自于 user 的 id 列,所以就寫成 id 這一個字段名了

4. 編寫賬戶持久層映射配置

<select id="findAllByUid" resultType="org.example.domain.Account">
    select * from account where uid= #{uid}
</select>

5. 測試只加載用戶信息

 package org.example.test;


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 org.example.dao.UserDao;
import org.example.domain.Account;
import org.example.domain.QueryVo;
import org.example.domain.User;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import sun.nio.ch.Net;

import java.io.IOException;
import java.io.InputStream;
import java.util.*;

/**
 *  mybatis 入門案例
 */
public class UserTest {

    private  InputStream in;
    private  SqlSession sqlSession;
    private  UserDao userDao;

    @Before  // test方法執(zhí)行之前執(zhí)行
    public void init() throws IOException {
            //1.讀取配置文件
             in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.創(chuàng)建 SqlSessionFactory 的構(gòu)建者對象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //3.使用構(gòu)建者創(chuàng)建工廠對象 SqlSessionFactory
            SqlSessionFactory factory = builder.build(in);

            //4.使用 SqlSessionFactory 生產(chǎn) SqlSession 對象
            sqlSession = factory.openSession();

            //5.使用 SqlSession 創(chuàng)建 dao 接口的代理對象
            userDao = sqlSession.getMapper(UserDao.class);

    }

    @After // test方法執(zhí)行之后執(zhí)行
    public void destroy() throws IOException {
        //提交事務(wù)
        sqlSession.commit();
        //7.釋放資源
        sqlSession.close();
        in.close();
    }


    @Test
    public void testFindAll()  {
        //6.使用代理對象執(zhí)行查詢所有方法
        List<User> users = userDao.findAll();
    }

}

6 測試結(jié)果:

測試結(jié)果如下:

DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
DEBUG source.pooled.PooledDataSource  - Created connection 1629911510.
DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@612679d6]
DEBUG rg.example.dao.UserDao.findAll  - ==>  Preparing: select * from user 
DEBUG rg.example.dao.UserDao.findAll  - ==> Parameters: 
DEBUG rg.example.dao.UserDao.findAll  - <==      Total: 10
DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@612679d6]
DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@612679d6]
DEBUG source.pooled.PooledDataSource  - Returned connection 1629911510 to pool.

我們發(fā)現(xiàn)并沒有加載 Account 賬戶信息。

4.2 mybatis中的一級緩存和二級緩存

4.2.1 Mybatis 一級緩存

4.2.1.1證明一級緩存的存在

? 一級緩存是 SqlSession級別的緩存,只要 SqlSession 沒有 flush 或 close,它就存在。

1. 編寫用戶持久層 Dao 接口

public interface UserDao {
    /**
     * 根據(jù) id 查詢
     * @param userId
     * @return
     */
    User findById(Integer userId);
}

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">
<mapper namespace="com.itheima.dao.IUserDao">
    <!-- 根據(jù) id 查詢 -->
    <select id="findById" resultType="UsEr" parameterType="int" useCache="true">
        select * from user where id = #{uid}
    </select>
</mapper>

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);
}

4. 測試結(jié)果

DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@e720b71]
DEBUG g.example.dao.UserDao.findById  - ==>  Preparing: select * from user where id = ? 
DEBUG g.example.dao.UserDao.findById  - ==> Parameters: 49(Integer)
DEBUG g.example.dao.UserDao.findById  - <==      Total: 1
第一次查詢的用戶:org.example.domain.User@17d0685f
第二次查詢的用戶:org.example.domain.User@17d0685f
true

    我們可以發(fā)現(xiàn),雖然在上面的代碼中我們查詢了兩次,但最后只執(zhí)行了一次數(shù)據(jù)庫操作,這就是 Mybatis 提供給我們的一級緩存在起作用了。因為一級緩存的存在,導(dǎo)致第二次查詢 id 為 41 的記錄時,并沒有發(fā)出 sql 語句從數(shù)據(jù)庫中查詢數(shù)據(jù),而是從一級緩存中查詢。

4.2.1.2 一級緩存的分析

? 一級緩存是 SqlSession 范圍的緩存,當(dāng)調(diào)用 SqlSession 的修改,添加,刪除,commit(),close()等方法時,就會清空一級緩存。
第一次發(fā)起查詢用戶 id 為 1 的用戶信息,先去找緩存中是否有 id 為 1 的用戶信息,如果沒有,從數(shù)據(jù)庫查
詢用戶信息。
得到用戶信息,將用戶信息存儲到一級緩存中。
如果 sqlSession去執(zhí)行 commit 操作(執(zhí)行插入、更新、刪除),清空 SqlSession 中的一級緩存,這樣做的目的為了讓緩存中存儲的是最新的信息,避免臟讀。
第二次發(fā)起查詢用戶 id 為 1 的用戶信息,先去找緩存中是否有 id 為 1 的用戶信息,緩存中有,直接從緩存中獲取用戶信息。

4.2.2 Mybatis 二級緩存

? 二級緩存是 mapper 映射級別的緩存,多個 SqlSession去操作同一個 Mapper 映射的 sql 語句,多個SqlSession 可以共用二級緩存,二級緩存是跨 SqlSession的。

? 首先開啟 mybatis 的二級緩存。
sqlSession1 去查詢用戶信息,查詢到用戶信息會將查詢數(shù)據(jù)存儲到二級緩存中。
如果 SqlSession3 去執(zhí)行相同 mapper 映射下 sql,執(zhí)行 commit 提交,將會清空該 mapper 映射下的二級緩存區(qū)域的數(shù)據(jù)。
sqlSession2 去查詢與 sqlSession1 相同的用戶信息,首先會去緩存中找是否存在數(shù)據(jù),如果存在直接從緩存中取出數(shù)據(jù)。

4.2.2.1 二級緩存的開啟與關(guān)閉

第一步:在 SqlMapConfig.xml文件開啟二級緩存

<settings>
    <!-- 開啟二級緩存的支持 -->
    <setting name="cacheEnabled" value="true"/>
</settings>
因為 cacheEnabled 的取值默認就為 true,所以這一步可以省略不配置。為 true 代表開啟二級緩存;為
false 代表不開啟二級緩存。

第二步:配置相關(guān)的Mapper 映射文件

<cache>標簽表示當(dāng)前這個 mapper 映射將使用二級緩存,區(qū)分的標準就看 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="com.itheima.dao.UserDao">
    <!--開啟user支持二級緩存-->
    <cache/>
</mapper>

第三步:配置statement上面的useCache 屬性

<!-- 根據(jù) id 查詢 -->
<select id="findById" resultType="org.example.domain.User" parameterType="int" useCache="true">
    select * from user where id = #{uid}
</select>
將 UserDao.xml 映射文件中的<select>標簽中設(shè)置 useCache=”true”代表當(dāng)前這個 statement 要使用二級緩存,如果不使用二級緩存可以設(shè)置為 false。
注意:針對每次查詢都需要最新的數(shù)據(jù) sql,要設(shè)置成 useCache=false,禁用二級緩存。

4.2.2.2 二級緩存開啟的注意事項

? 當(dāng)我們在使用二級緩存時,所緩存的類一定要實現(xiàn) java.io.Serializable 接口,這種就可以使用序列化方式來保存對象。

4.3 mybatis的注解開發(fā)

? 這幾年來注解開發(fā)越來越流行,Mybatis 也可以使用注解開發(fā)方式,這樣我們就可以減少編寫 Mapper 映射文件了。本次我們先圍繞一些基本的 CRUD 來學(xué)習(xí),再學(xué)習(xí)復(fù)雜映射關(guān)系及延遲加載。

4.3.1 mybatis 的常用注解說明

@Insert:實現(xiàn)新增
@Update: 實現(xiàn)更新
@Delete: 實現(xiàn)刪除
@Select: 實現(xiàn)查詢
@Result: 實現(xiàn)結(jié)果集封裝
@Results: 可以與@Result 一起使用,封裝多個結(jié)果集
@ResultMap: 實現(xiàn)引用@Results 定義的封裝
@One: 實現(xiàn)一對一結(jié)果集封裝
@Many: 實現(xiàn)一對多結(jié)果集封裝
@SelectProvider: 實現(xiàn)動態(tài) SQL 映射
@CacheNamespace: 實現(xiàn)注解二級緩存的使用

4.3.2 使用 Mybatis 注解實現(xiàn)基本 CRUD

? 單表的 CRUD 操作是最基本的操作,前面我們的學(xué)習(xí)都是基于 Mybaits 的映射文件來實現(xiàn)的。

1. 編寫實體類

public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    // 一對多關(guān)系映射; 主表實體應(yīng)該包含從表實體的集合引用
    private List<Account> accounts;
    // 多對多的關(guān)系映射: 一個用戶可以具有多個角色
    private List<Role> roles;

    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 Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

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

2. 使用注解方式開發(fā)持久層接口

public interface IUserDao {

    /**
     * 查詢所有用戶
     * @return
     */

    @Select("select * from user")
    @Results(id = "userMap",value = {
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "username", column = "username"),
            @Result(property = "sex",column = "sex"),
            @Result(property = "birthday",column = "birthday"),
            @Result(property = "address",column = "address")
    })
    List<User> findAll();

    /**
     * 保存用戶信息
     * @param user
     * @return
     */
    @Insert("insert into user(username,sex,birthday,address) values(#{username},#{sex},#{birthday},#{address})")
    int saveUer(User user);

    /**
     * 修改用戶信息
     * @param user
     * @return
     */
    @Update("update user set username = #{username},sex = #{sex},birthday=#{birthday},address = #{address} where id = #{id}")
    int updateUser(User user);

    /**
     * 根據(jù)ID刪除用戶
     * @param userId
     * @return
     */
    @Delete("delete from user where id = #{userId} ")
    int deleteUser(Integer userId);

    /**
     * 根據(jù)ID查詢用戶
     * @param userId
     * @return
     */
    @ResultMap("userMap")
    @Select("select * from user where id = #{userId} ")
    User findById(Integer userId);

    /**
     * 根據(jù)名稱模糊查詢用戶
     * @param username
     * @return
     */
    @ResultMap("userMap")
    @Select("select * from user where username like concat('%',#{username},'%')")
    List<User> findUserByName(String username);

    /**
     * 查詢總用戶數(shù)
     * @return
     */
    @Select("select count(*) from user")
    int findTotalUser();

}
通過注解方式,我們就不需要再去編寫 UserDao.xml 映射文件了。

3. 編寫測試方法

public class IUserTest {

    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;

    @Before  // test方法執(zhí)行之前執(zhí)行
    public void init() throws IOException {
        //1.讀取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.創(chuàng)建 SqlSessionFactory 的構(gòu)建者對象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        //3.使用構(gòu)建者創(chuàng)建工廠對象 SqlSessionFactory
        SqlSessionFactory factory = builder.build(in);

        //4.使用 SqlSessionFactory 生產(chǎn) SqlSession 對象
        sqlSession = factory.openSession();

        //5.使用 SqlSession 創(chuàng)建 dao 接口的代理對象
        userDao = sqlSession.getMapper(IUserDao.class);

    }

    @After // test方法執(zhí)行之后執(zhí)行
    public void destroy() throws IOException {
        //提交事務(wù)
        sqlSession.commit();
        //7.釋放資源
        sqlSession.close();
        in.close();
    }

    /**
     * 查詢所有賬號
     */
    @Test
    public void testFindAll()  {
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }

    }

    @Test
    public void testSaveUser(){
        User user = new User();
        user.setUsername("唐老鴨");
        user.setSex("男");
        user.setBirthday(new Date());
        user.setAddress("唐寧街10號");
        int i = userDao.saveUer(user);
        System.out.println("受影響行數(shù)-> " + i);
    }

    @Test
    public void testUpdateUser(){
        User user = new User();
        user.setId(54);
        user.setUsername("唐老鴨AAA");
        user.setSex("男");
        user.setBirthday(new Date());
        user.setAddress("唐寧街10號");
        int i = userDao.updateUser(user);
        System.out.println("受影響行數(shù)-> " + i);
    }

    @Test
    public void testDeleteUser(){
        int i = userDao.deleteUser(56);
        System.out.println("受影響行數(shù)-> " + i);
    }

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

    @Test
    public void testFindByName(){
        List<User> users = userDao.findUserByName("唐");
        for(User user: users){
            System.out.println(user);
        }
    }

    @Test
    public void testFindTotla(){
        int total = userDao.findTotalUser();
        System.out.println("總用戶數(shù): " + total);
    }

}

4.3.3 使用注解實現(xiàn)復(fù)雜關(guān)系映射開發(fā)

? 實現(xiàn)復(fù)雜關(guān)系映射之前我們可以在映射文件中通過配置<resultMap>來實現(xiàn),在使用注解開發(fā)時我們需要借助@Results 注解,@Result 注解,@One 注解,@Many 注解。

@Results 注解
代替的是標簽 <resultMap>
該注解中可以使用單個@Result注解,也可以使用@Result集合 @Results({@Result(),@Result()})或@Results(@Result())
@Resutl 注解
代替了 <id>標簽和<result>標簽
@Result 中 屬性介紹:
**id** 是否是主鍵字段
**column** 數(shù)據(jù)庫的列名
**property** 需要裝配的屬性名
**one** 需要使用的@One 注解(@Result(one=@One()))

? **many** 需要使用的@Many 注解(@Result(many=@many()))
@One 注解(一對一)
代替了<assocation>標簽,是多表查詢的關(guān)鍵,在注解中用來指定子查詢返回單一對象。
@One 注解屬性介紹:
**select**
指定用來多表查詢的 sqlmapper
**fetchType** 會覆蓋全局的配置參數(shù) lazyLoadingEnabled
使用格式:
@Result(column=" ",property="",one=@One(select=""))
@Many 注解(多對一)
代替了<Collection>標簽,是是多表查詢的關(guān)鍵,在注解中用來指定子查詢返回對象集合。
注意:聚集元素用來處理“一對多”的關(guān)系。需要指定映射的 Java 實體類的屬性,屬性的 javaType(一般為 ArrayList)但是注解中可以不定義;
使用格式:
@Result(property="",column="",many=@Many(select=""))

4.3.3.1使用注解實現(xiàn)一對一復(fù)雜關(guān)系映射及延遲加載

1 添加 User 實體類及 Account 實體類

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

    // 一對多關(guān)系映射; 主表實體應(yīng)該包含從表實體的集合引用
    private List<Account> accounts;


    // 省略getter,setter 和 toString 方法
    
    }
    
    public class Account implements Serializable {

    private  Integer id;

    private Integer uid;

    private Double money;

    //從表實體應(yīng)該包含一個主體實體的對象引用
    private User user;
    
    // 省略getter,setter 和 toString 方法
}
    

2. 添加賬戶的持久層接口并使用注解配置

public interface IAccountDao {

    /**
     * 查詢所有賬號,并且獲取每個賬號的用戶信息
     * @return
     */
    @Select("select * from account")
    @Results(id = "accountMap",value = {
            @Result(id = true,column = "id",property = "id"),
            @Result(property = "uid",column = "uid"),
            @Result(property = "money",column = "money"),
            @Result(property = "user",column = "uid",one = @One(select = "org.example.dao.IUserDao.findById",fetchType = FetchType.LAZY))
    })
    List<Account> findAll();
}
@One:
相當(dāng)于<assocation>的配置
    select 屬性:代表將要執(zhí)行的 sql 語句
    fetchType 屬性:代表加載方式,一般如果要延遲加載都設(shè)置為 LAZY 的值

3 添加用戶的持久層接口并使用注解配置

public interface IUserDao {

    /**
     * 查詢所有用戶
     * @return
     */

    @Select("select * from user")
    @Results(id = "userMap",value = {
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "username", column = "username"),
            @Result(property = "sex",column = "sex"),
            @Result(property = "birthday",column = "birthday"),
            @Result(property = "address",column = "address"),
            @Result(property = "accounts",column = "id",many = @Many(select = "org.example.dao.IAccountDao.findAccountByUid",fetchType = FetchType.LAZY))
    })
    List<User> findAll();
    
        /**
     * 根據(jù)ID查詢用戶
     * @param userId
     * @return
     */
    @Select("select * from user where id = #{userId} ")
    User findById(Integer userId);
}
@Many:
相當(dāng)于<collection>的配置
    select 屬性:代表將要執(zhí)行的 sql 語句
    fetchType 屬性:代表加載方式,一般如果要延遲加載都設(shè)置為 LAZY 的值

4 測試一對一關(guān)聯(lián)及延遲加載

public class IAccountTest {

    private  InputStream in;
    private  SqlSession sqlSession;
    private IAccountDao accountDao;

    @Before  // test方法執(zhí)行之前執(zhí)行
    public void init() throws IOException {
            //1.讀取配置文件
             in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.創(chuàng)建 SqlSessionFactory 的構(gòu)建者對象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

            //3.使用構(gòu)建者創(chuàng)建工廠對象 SqlSessionFactory
            SqlSessionFactory factory = builder.build(in);

            //4.使用 SqlSessionFactory 生產(chǎn) SqlSession 對象
            sqlSession = factory.openSession();

            //5.使用 SqlSession 創(chuàng)建 dao 接口的代理對象
            accountDao = sqlSession.getMapper(IAccountDao.class);

    }

    @After // test方法執(zhí)行之后執(zhí)行
    public void destroy() throws IOException {
        //提交事務(wù)
        sqlSession.commit();
        //7.釋放資源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for(Account account : accounts){
            System.out.println("--------每個賬號的信息--------");
            System.out.println(account);
            System.out.println("--------每個賬號所屬人員的信息--------");
            System.out.println(account.getUser());
        }
    }
}

4.3.3.2 使用注解實現(xiàn)一對多復(fù)雜關(guān)系映射

1 User 實體類加入List<Account>

/**
  * 用戶實體類
  */
public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    // 一對多關(guān)系映射; 主表實體應(yīng)該包含從表實體的集合引用
    private List<Account> accounts;


    // 省略getter,setter 和 toString 方法
    
    }
    
/**
  * 賬戶實體類
  */
    public class Account implements Serializable {

    private  Integer id;

    private Integer uid;

    private Double money;

    //從表實體應(yīng)該包含一個主體實體的對象引用
    private User user;
    
    // 省略getter,setter 和 toString 方法
}

2 編寫用戶的持久層接口并使用注解配置

public interface IUserDao {

    /**
     * 查詢所有用戶
     * @return
     */

    @Select("select * from user")
    @Results(id = "userMap",value = {
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "username", column = "username"),
            @Result(property = "sex",column = "sex"),
            @Result(property = "birthday",column = "birthday"),
            @Result(property = "address",column = "address"),
            @Result(property = "accounts",column = "id",many = @Many(select = "org.example.dao.IAccountDao.findAccountByUid",fetchType = FetchType.LAZY))
    })
    List<User> findAll();
}
@Many:
相當(dāng)于<collection>的配置
    select 屬性:代表將要執(zhí)行的 sql 語句
    fetchType 屬性:代表加載方式,一般如果要延遲加載都設(shè)置為 LAZY 的值

3 編寫賬戶的持久層接口并使用注解配置

public interface IAccountDao {
    @Select("select * from account where uid = #{userId}")
    List<Account> findAccountByUid(Integer userId);
}

4 添加測試方法

public class IUserTest {

    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;

    @Before  // test方法執(zhí)行之前執(zhí)行
    public void init() throws IOException {
        //1.讀取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.創(chuàng)建 SqlSessionFactory 的構(gòu)建者對象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        //3.使用構(gòu)建者創(chuàng)建工廠對象 SqlSessionFactory
        SqlSessionFactory factory = builder.build(in);

        //4.使用 SqlSessionFactory 生產(chǎn) SqlSession 對象
        sqlSession = factory.openSession();

        //5.使用 SqlSession 創(chuàng)建 dao 接口的代理對象
        userDao = sqlSession.getMapper(IUserDao.class);

    }

    @After // test方法執(zhí)行之后執(zhí)行
    public void destroy() throws IOException {
        //提交事務(wù)
        sqlSession.commit();
        //7.釋放資源
        sqlSession.close();
        in.close();
    }

    /**
     * 查詢所有賬號
     */
    @Test
    public void testFindAll()  {
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
            for(Account account : user.getAccounts()){
                System.out.println(account);
            }
        }

    }
}

4.3.4 mybatis 基于注解的二級緩存

1 在 SqlMapConfig中開啟二級緩存支持

<!-- 配置二級緩存 -->
<settings>
<!-- 開啟二級緩存的支持 -->
<setting name="cacheEnabled" value="true"/>
</settings>

2 在持久層接口中使用注解配置二級緩存

/**
 * 用戶的持久層接口
 */
@CacheNamespace(blocking=true)  //mybatis 基于注解方式實現(xiàn)配置二級緩存
public interface IUserDao {}