mybatis learning framework - lazy loading

Rory it repetitious

Lazy loading: 
    that is, the need to use when loading data, do not load the data do not need the data. Lazy loading, also known as lazy loading, load on demand. 
    Lazy loading corresponds to the load immediately: whether used or not, as long as a method is called immediately initiate an inquiry. 
Benefits: 
start with the single-table query, and then go to related queries from the association table when needed, greatly improving database performance, because the single-table queries related query multiple tables than faster. 
Disadvantages: 
Because data is used only when needed, will perform database queries, so that when large quantities of data query, because the query work also consume 
time, it may cause the user to wait longer time, causing the user to experience decline in 

the actual development process many times we do not always need to load user information when it must load his account information. At this point what we call lazy loading. 
Four in the corresponding relationship table: one to many, many to one, one to one, many- 
        to-many, many-to-: Normally we are using lazy loading. 
        Many to one, one to one: In general we are using load immediately.

Overview

1. Open lazy loading

<Configuration> 
    <Settings> 
        <-! loading delay switch defaults to false -> 
        <Setting name = " lazyLoadingEnabled " value = " to true " > </ Setting> 
        <-! positive load to the load demand, the default is false, i.e., not disposed here with same -> 
        <-! <Setting name = " aggressiveLazyLoading " value = " to false " > </ Setting> -> 
    </ Settings>

2. Configure the mapper mapping files, as well as some simple precautions

Personal Stories

Based on: one to many query https://www.cnblogs.com/ccoonngg/p/11330392.html

1. Create a maven project, import dependence

<?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.cong</groupId>
    <artifactId>mybatis_lazyLoad</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

2.两个类

package com.cong.pojo;

public class Account {
    private int aid;
    private int uid;
    private double money;
    //从表实体应该包含一个主表实体的对象引用
    private User user;
    public User getUser() {
        return user;
    }

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

    public int getAid() {
        return aid;
    }

    public void setAid(int aid) {
        this.aid = aid;
    }

    public int getUid() {
        return uid;
    }

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

    public double getMoney() {
        return money;
    }

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

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


package com.cong.pojo;

import java.util.List;

public class User {
    private int uid;
    private String name;
    private char sex;
    private String addr;
    //一对多关系映射：主表实体应该包含从表实体的集合引用
    private List<Account> accounts;
    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }
    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                ", addr='" + addr + '\''+
                '}';
    }

    public int getUid() {
        return uid;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }
}

3.mybatis配置文件

<?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>
        <!-- 延迟加载的开关 默认是false -->
        <setting name="lazyLoadingEnabled" value="true"></setting>
        <!-- 将积极加载改为按需加载，默认是false，即在这里配不配置都一样 -->
        <!--<setting name="aggressiveLazyLoading" value="false"></setting>-->
    </settings>
    <typeAliases>
        <package name="com.cong.pojo"></package>
    </typeAliases>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"></property>
                <property name="url" value="jdbc:mysql://localhost:3306/rainbow?characterEncoding=UTF-8"></property>
                <property name="username" value="root"></property>
                <property name="password" value="123456"></property>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--<mapper class="com.cong.mapper.UserMapper"></mapper>-->
        <package name="com.cong.mapper"></package>
    </mappers>
</configuration>

4.两个映射文件

下面是AccountMapper.xml

<?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.cong.mapper.AccountMapper">
    <!-- 定义封装account和user的resultMap -->
    <resultMap id="accountUserMap" type="account">
        <id property="aid" column="aid"></id>
        <result column="uid" property="uid"></result>
        <result column="money" property="money"></result>
        <!--
        一对一的延迟加载
        select： 填写我们要调用的 select 映射的 id，使用全限定类名
        column ： 填写我们要传递给 select 映射的参数
        -->
        <association property="user" column="uid" javaType="user"
                     select="com.cong.mapper.UserMapper.findById">
        </association>
    </resultMap>
    <!-- 查询所有account，并且关联到它所属于的user-->
    <select id="findAll" resultMap="accountUserMap">
        select * from account
    </select>
    <select id="findByUid" resultType="account">
        select * from account where uid = #{uid};
    </select>
</mapper>










下面是usermapper.xml

<?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.cong.mapper.UserMapper">
    <!-- 定义User的resultMap-->
    <resultMap id="userAccountMap" type="user">
        <id property="uid" column="uid"></id>
        <result property="name" column="name"></result>
        <result property="addr" column="addr"></result>
        <result property="sex" column="sex"></result>
        <!--
        一对多的延迟加载
        ofType 用于指定集合元素的数据类型
        select 用于指定查询account的sql语句，所以填写的是该sql语句映射的id
        column 用于指定 select 属性的 sql 语句的参数来源，
        -->
        <collection property="accounts" ofType="account" notNullColumn="aid"
            column="uid" select="com.cong.mapper.AccountMapper.findByUid"
        >
        </collection>
    </resultMap>
    <!-- 查询所有user，以及它拥有的account -->
    <select id="findAll" resultMap="userAccountMap">
        select * from user
    </select>
    <select id="findById" resultType="user" parameterType="int">
        select * from user where uid = #{uid};
    </select>
</mapper>

5.测试类

import com.cong.mapper.AccountMapper;
import com.cong.mapper.UserMapper;
import com.cong.pojo.Account;
import com.cong.pojo.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.InputStream;
import java.util.List;

public class TestTables {
    private InputStream inputStream;
    private SqlSession sqlSession;
    private AccountMapper accountMapperr;
    private UserMapper userMapper;
    @Test
    public void findAllAccount(){
        List<Account> accounts = accountMapperr.findAll();
        for (Account account : accounts) {
            System.out.println("-------------一个account的信息--------------------");
            System.out.println(account.toString());
            System.out.println(account.getUser());
        }
    }
    @Test
    public void findAllUser(){
        List<User> users = userMapper.findAll();
        for (User user : users) {
            System.out.println("------------------一个user的信息-----------------------");
            System.out.println(user.toString());
            if(!user.getAccounts().isEmpty()){
                for (Account account : user.getAccounts()) {
                    System.out.println("\t" + account);
                }
            }
        }
    }
    @Before
    public void init() throws Exception{
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = factory.openSession();
        accountMapperr = sqlSession.getMapper(AccountMapper.class);
        userMapper = sqlSession.getMapper(UserMapper.class);
    }
    @After
    public  void destroy() throws Exception{
        sqlSession.commit();
        sqlSession.close();
        inputStream.close();
    }
}