一、mybatis中的延遲加載

問題引入：在一對多中，有一個用戶對應100個賬戶

• 在查詢用戶的時候，要不要把關聯(lián)賬戶查詢出來？
  （用戶下的賬戶，什么時候使用，什么使用查詢加載---延遲加載）
• 在查詢賬戶的時候，要不要把關聯(lián)用戶查詢出來？
  （賬戶的所屬用戶信息應該是隨著賬戶查詢時一起查詢出來---立即加載）

1. 什么是延遲加載？

在真正使用數(shù)據(jù)時才發(fā)起查詢，不用時不查詢。也叫做按需加載（懶加載）。
一對多、多對多：通常情況下使用延遲加載。

2. 什么是立即加載

不管用戶用，只要一調(diào)用方法，馬上進行查詢。
多對一、一對一：通常情況下采用立即加載。

3. 實戰(zhàn)

• 延遲加載的全局配置

 <!--配置參數(shù)-->
    <settings>
    <!-- 延遲加載的全局開關。當開啟時，所有關聯(lián)對象都會延遲加載。 
    特定關聯(lián)關系中可通過設置 fetchType 屬性來覆蓋該項的開關狀態(tài)。-->
        <setting name="lazyLoadingEnabled" value="true"/>
    <!--開啟時，任一方法的調(diào)用都會加載該對象的所有延遲加載屬性。
     否則，每個延遲加載屬性會按需加載 -->
        <setting name="aggressiveLazyLoading" value="false"/>
        
    </settings>

• 一對一延遲加載的實現(xiàn)：

<mapper namespace="com.seapp.dao.IAccountDao">
    <!--實體類名與數(shù)據(jù)庫列名不一致時通過resultMap來實現(xiàn)實體類名與列名的對應關系    -->
    <resultMap id="accountUserMap" type="account">
        <id column="aid" property="aId"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
        <!--asssociation屬性來確定一對一實體類，
            column：由哪個字段類確定關聯(lián)用戶
            select: 配合延遲加載使用，指定IuserDao中的findById方法（根據(jù)用戶id獲取指定用戶）        -->
        <association property="user" column="uid" select="com.seapp.dao.IUserDao.findById"/>
    </resultMap>
    <!--查詢所有，包含賬戶所屬用戶-->
    <select id="findAllAccountUser" resultMap="accountUserMap">
        select a.id AS aid,a.uid,a.money from account a;
    </select>

• 一對多延遲加載的實現(xiàn)

 <resultMap id="userMap" type="user">
        <id property="id" column="id"></id>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <!-- 指定關聯(lián)對象accounts集合的映射
                ofType:指定集合中元素的類型  
                column：指定根據(jù)什么參數(shù)獲取賬戶信息
                select:指定IAccountDao中根據(jù)uid查詢賬戶的sql方法
                -->
        <collection property="accounts" ofType="account" column="id" select="com.seapp.dao.IAccountDao.findByUserId"/>
    </resultMap>
 <!--查詢所有用戶及關聯(lián)賬戶-->
    <select id="findAll" resultMap="userMap">
        SELECT
            *
        FROM
            USER ;
    </select>

二、mybatis中的緩存

1. 緩存簡介

• 什么是緩存
  存在于內(nèi)存中的臨時數(shù)據(jù)。
• 為什么使用緩存
  減少和數(shù)據(jù)庫的交互次數(shù)，提高執(zhí)行效率。
• 什么樣的數(shù)據(jù)能使用緩存，什么樣的數(shù)據(jù)不能使用緩存？
  適用于緩存的數(shù)據(jù)： 經(jīng)常查詢且不經(jīng)常改動的數(shù)據(jù)、數(shù)據(jù)的正確與否對最終的結果影響不大的。
  不適用于緩存的： 經(jīng)常改動的，數(shù)據(jù)的正確與否對最終結果影響很大的。

2. mybatis中的一級緩存和二級緩存

一級緩存：它指的是Mybatis中SqlSession對象的緩存

當我們執(zhí)行查詢后，查詢的結果會同時存入到SqlSession為我們提供的一塊區(qū)域中。該區(qū)域的結構是一個Map,當我們再次查詢同樣的數(shù)據(jù)時，mybatis會直接先從緩存區(qū)域中獲取緩存數(shù)據(jù)。當SqlSession對象消失時，mybatis的一級緩存也就消失了。

sqlSession.closeCache();//可清空當前緩存

二級緩存：它指的是mybatis中SqlSessionFactory對象的緩存。由同一個SqlSessionFactory對象創(chuàng)建的SqlSession共享其緩存。

二級緩存的使用步驟:

• 第一步：讓mybatis框架支持二級緩存（在SqlMapConfig.xml中配置）。

<!--全局性地開啟或關閉所有映射器配置文件中已配置的任何緩存-->
        <setting name="cacheEnabled" value="true"/>

• 第二步：讓當前映射文件支持二級緩存（在IUserDao.xml中配置）。

<!--  在映射文件中開啟緩存  -->
    <cache/>

• 第三步：讓當前的操作支持二級緩存（在select標簽中配置）。

 <!-- 查詢所有用戶 
      useCache：屬性標簽，開啟緩存
      -->
 <select id="findById" parameterType="int" resultType="user" useCache="true">
        select * FROM user where id = #{id};
    </select>

三、Mybatis中的注解開發(fā)

注意： mybatis中若采用注解開發(fā)，則不可再用xml配置mapper文件開發(fā)。

1. 環(huán)境搭建

• mysql數(shù)據(jù)庫中的user表為基礎數(shù)據(jù)，實現(xiàn)對用戶信息的維護
• maven依賴庫的引入

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.seapp</groupId>
    <artifactId>mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

    </dependencies>

</project>

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

    <properties resource="jdbcConfig.properties"></properties>


    <!--配置參數(shù)-->
    <settings>
        <!--全局性地開啟或關閉所有映射器配置文件中已配置的任何緩存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>


    <!--typeAlises 配置別名，只能配置domain中類的別名    -->
    <typeAliases>
        <package name="com.seapp.mybatis.domain"/>
    </typeAliases>

    <!-- 配置環(huán)境   -->
    <environments default="mysql">
        <!--配置mysql環(huán)境-->
        <environment id="mysql">
            <!--配置事務類型 -->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置數(shù)據(jù)源（連接池）
                type：配置連接池
                    取值：
                        POOLED:采用傳統(tǒng)的javax.sql.DataSource規(guī)范中的連接池，在mybatis中有針對該規(guī)范的實現(xiàn)。
                        UNPOOLED:采用傳統(tǒng)的連接方式，雖然實現(xiàn)了javax.sql.DataSource規(guī)范，但并沒有池的思想。
                        JNDI:采用服務器提供的JNDI技術實現(xiàn)，來獲取DataSource對象，不同服務器所能拿到的DataSource是
                            不同的，注意，如果不是web或maven的war工程，是不能使用的。
            -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射文件的位置，映射配置文件指的是每個dao獨立的配置文件-->
    <!-- 若使用注解配置的話，mapper配置屬性應為class,值為被注解的dao的全限定類名-->
    <mappers>
        <package name="com.seapp.mybatis.dao"/>
    </mappers>
</configuration>

• 關聯(lián)的dataSource數(shù)據(jù)源配置文件 jdbcConfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root

• log4j.properties配置文件

### 設置###
log4j.rootLogger = debug,stdout,D,E

### 輸出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

### 輸出DEBUG 級別以上的日志到=D://logs/error.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = D://logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### 輸出ERROR 級別以上的日志到=D://logs/error.log ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =D://logs/error.log 
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR 
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

2. 單表CRUD操作

• 實體類User.java的實現(xiàn)(關聯(lián)Account賬戶信息，為后續(xù)多表操作打基礎)

package com.seapp.mybatis.domain;

import java.util.Date;
import java.util.List;

/**
 * user實體類的創(chuàng)建
 * @author seapp
 * @date 2020/7/28 23:08
 */
public class User {

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

    private List<Account> accounts;

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

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

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

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

• IUserDao接口實現(xiàn)

package com.seapp.mybatis.dao;

import com.seapp.mybatis.domain.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;

import java.util.List;

/**
 * 注解實現(xiàn)對User實體類的CRUD.
 * @Select @Update @Delete @Insert
 * @author seapp
 * @date 2020/7/28 23:10
 */
public interface IUserDao {

    /**
     * 查詢所有用戶信息
     * @return
     */
    @Select(value = "select * from user")
    @Results(id = "userMap",value = {@Result(id = true,column = "id",property = "id"),@Result(column = "username",property = "username"),
            @Result(column = "birthday",property = "birthday"),@Result(column = "sex",property = "sex"),
            @Result(column = "address",property = "address"),
            @Result(column = "id",property = "accounts",many = @Many(select = "com.seapp.mybatis.dao.IAccountDao.findByUserId",fetchType = FetchType.LAZY))


    })
    List<User> findAll();

    /**
     * 根據(jù)用戶id獲取用戶信息
     * @param userId
     * @return
     */
    @Select(value = "select * from user where id = #{userId}")
    User findById(Integer userId);


    /**
     * 根據(jù)用戶名稱獲取用戶信息，支持模糊查詢
     * @param userName
     * @return
     */
    //第一種方式
    @Select(value = "select * from user where username like #{username}")
    //第二種方式
//    @Select(value = "select * from user where username like $%(value)%")
    List<User> findByUserName(String userName);


    /**
     * 更新用戶信息
     * @param user
     */
    @Update(value = "update  user set username = #{username}," +
            "birthday = #{birthday},sex = #{sex},address = #{address} " +
            "where id = #{id}")
    void updateUser(User user);


    /**
     * 根據(jù)用戶id,刪除用戶信息
     * @param userId
     */
    @Delete(value = "delete from user where id = #{uid}")
    void deleteUser(Integer userId);


    /**
     * 插入用戶信息
     * @param user
     */
    @Insert("insert into user (username,birthday,sex,address) values " +
            "(#{username},#{birthday},#{sex},#{address});")
    void insertUser(User user);

    /**
     * 聚合查詢
     * @return
     */
    @Select("select count(id) from user")
    Integer getCount();

}

• UserTest.java測試類的實現(xiàn)

package com.seapp.mybatis;

import com.seapp.mybatis.dao.IUserDao;
import com.seapp.mybatis.domain.User;
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.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;

/**
 * @author seapp
 * @date 2020/7/28 23:13
 */
public class UserTest {

    InputStream in ;
    private SqlSession sqlSession;
    private IUserDao userDao;

    /**
     * 測試前的準備工作
     */
    @Before
    public void before() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        sqlSession = factory.openSession();
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    /**
     * 測試完成后資源的釋放
     */
    @After
    public void after(){
        sqlSession.commit();
        sqlSession.close();
        try {
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 測試查詢所有用戶信息
     */
    @Test
    public void findAllUserTest(){

        List<User> userList = userDao.findAll();
        for (User user :
                userList) {
            System.out.println("user = " + user);
            System.out.println("user.getAccounts() = " + user.getAccounts());
        }
    }

    /**
     * 測試根據(jù)用戶id獲取用戶信息
     */
    @Test
    public void findByUserIdTest(){
        User user = userDao.findById(3);
        System.out.println("user = " + user);
    }


    /**
     * 測試根據(jù)用戶名稱查詢用戶，并且支持模糊搜索。
     */
    @Test
    public void findByUserName(){
        //第一種方式
        List<User> userList = userDao.findByUserName("%p%");
        //第二種方式
//        List<User> userList = userDao.findByUserName("p");
        for (User user :
                userList) {
            System.out.println("user = " + user);
        }
    }

    /**
     * 更新用戶信息
     */
    @Test
    public void updateUserTest(){
        //創(chuàng)建更新user對象
        User user = new User();
        user.setId(11);
        user.setUsername("王小2pp");
        user.setBirthday(new Date());
        user.setAddress("中華人民共和國");
        user.setSex("男");
        userDao.updateUser(user);
    }

    /**
     * 測試根據(jù)用戶信息，刪除指定用戶
     */
    @Test
    public void deleteUserTest(){
        userDao.deleteUser(11);
    }

    /**
     * 插入用戶信息
     */
    @Test
    public void insertUserTest(){
        //創(chuàng)建user對象
        User user = new User();
        user.setId(11);
        user.setUsername("李小p");
        user.setBirthday(new Date());
        user.setAddress("中華人民共和國");
        user.setSex("女");
        //執(zhí)行插入語句
        userDao.insertUser(user);
    }


    /**
     * 測試獲取用戶數(shù)量
     */
    @Test
    public void getUserCountTest(){
        Integer count = userDao.getCount();
        System.out.println("count = " + count);
    }

}

3. 多表查詢操作

• 多表操作，增加Account.java實體類(User對象的引入，實現(xiàn)一對一關聯(lián)查詢)

package com.seapp.mybatis.domain;

/**
 * @author seapp
 * @date 2020/7/29 8:49
 */
public class Account {

    private Integer id;
    private Integer uid;
    private Double money;
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

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

• 一對一查詢實現(xiàn)：

 /**
     * 一對一查詢實現(xiàn)：@one中屬性： 
     *          select：指定所關聯(lián)用戶的查詢語句（根據(jù)用戶id查詢用戶信息），
     *          用戶id值由column指定的uid字段來確定
     *          fetchType:指定關聯(lián)數(shù)據(jù)時為“立即加載”還是“懶加載”
     * 
     * @return
     */
    @Select("select * from account")
    @Results({@Result(column = "id",property = "id"),
            @Result(column = "uid",property = "uid"),
            @Result(column = "money",property = "money"),
            @Result(column = "uid",property = "user",
                    one =@One( select = "com.seapp.mybatis.dao.IUserDao.findById",fetchType = FetchType.EAGER))
    })
    List<Account> findAll();

//@one中對應的select語句為：
 /**
     * 根據(jù)用戶id獲取用戶信息
     * @param userId
     * @return
     */
    @Select(value = "select * from user where id = #{userId}")
    User findById(Integer userId);

//測試實現(xiàn)類：
package com.seapp.mybatis;

import com.seapp.mybatis.dao.IAccountDao;
import com.seapp.mybatis.domain.Account;
import com.seapp.mybatis.domain.User;
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.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;

/**
 * @author seapp
 * @date 2020/7/28 23:13
 */
public class AccountTest {

    InputStream in ;
    private SqlSession sqlSession;
    private IAccountDao accountDao;

    /**
     * 測試前的準備工作
     */
    @Before
    public void before() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        sqlSession = factory.openSession();
        accountDao = sqlSession.getMapper(IAccountDao.class);
    }

    /**
     * 測試完成后資源的釋放
     */
    @After
    public void after(){
        sqlSession.commit();
        sqlSession.close();
        try {
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 測試查詢所有賬戶信息并關聯(lián)其用戶
     */
    @Test
    public void findAllAccountTest(){
        List<Account> accountList = accountDao.findAll();
        for (Account account : accountList) {
            System.out.println("account = " + account);
            System.out.println("account.getUser() = " + account.getUser());
        }

    }
}

• 一對多關聯(lián)查詢：

 /**
     * 查詢所有用戶信息
     * @return
     */
    @Select(value = "select * from user")
    @Results(id = "userMap",value = {@Result(id = true,column = "id",property = "id"),
            @Result(column = "username",property = "username"),
            @Result(column = "birthday",property = "birthday"),
            @Result(column = "sex",property = "sex"),
            @Result(column = "address",property = "address"),
            @Result(column = "id",property = "accounts",
                    many = @Many(select = "com.seapp.mybatis.dao.IAccountDao.findByUserId",
                            fetchType = FetchType.LAZY))


    })
    List<User> findAll();

4.緩存的配置

注解中二級緩存的開啟:在接口實現(xiàn)類中，配置如下注解

@CacheNamespace(blocking = true)//開啟二級緩存
public interface IUserDao {
}