Mybatis框架(动态SQL及Mybatis缓存)

set标签用于代替update语句 的set关键字，实现动态拼接update语句，它可以用来动态包含需要更新的列，帮我们去掉多余的逗号。

• 在映射器接口UserDao里添加方法

void edit(User user);

• 在映射文件UserDao.xml里配置SQL语句

	update user
    
    	username = #{username},
        sex = #{sex},
        birthday = #{birthday},
    
    where id = #{id}

• 功能测试

@Test
public void testEdit(){
    User user = new User();
    user.setId(51);
    user.setUsername("张三");
    
    userDao.edit(user);
    session.commit();
}

缓存：高速的临时数据存储

略。按步骤准备好User和UserDao、UserDao.xml、SqlMapConfig.xml、log4j.properties

• 了解Mybatis的一级缓存

• 一级缓存，是SqlSession对象提供的缓存
• 执行一次查询之后，查询的结果（JavaBean对象）会被缓存到SqlSession中。
• 再次查询同样的数据，Mybatis会优先从缓存中查找；如果找到了，就不再查询数据库。

• 当调用了SqlSession对象的修改、添加、删除、commit()、close()、clearCache()等方法时，一级缓存会被清空。

package com.is.fwis;

import com.is.fwis.dao.UserDao;
import com.is.fwis.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;


public class CacheTest {

    private UserDao userDao;
    private SqlSession session;
    private InputStream is;
    private SqlSessionFactory factory;

    
    @Test
    public void testLevel1Cache(){
        User user1 = userDao.findById(41);

        //如果在这里使用SqlSession执行了增、删、改、关闭session、提交事务、clearCache方法时，Mybatis会把缓存清除掉
        session.clearCache();

        User user2 = userDao.findById(41);

        System.out.println(user1==user2);
    }

    @Before
    public void init() throws IOException {
        //1. 读取全局配置文件
        is = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2. 得到一个SqlSession对象
        factory = new SqlSessionFactoryBuilder().build(is);
        session = factory.openSession();
        userDao = session.getMapper(UserDao.class);
    }

    @After
    public void destroy() throws IOException {
        session.close();
        is.close();
    }
}

• 了解Mybatis二级缓存的效果

• 二级缓存是Mapper级别的缓存（映射器级别的缓存）
• 同样的映射器Mapper共享二级缓存。UserDao
• 注意：
  • 二级缓存，缓存的是序列化之后的数据；
  • 当从缓存里取数据时，要进行反序列化还原成JavaBean对象
  • 要求JavaBean必须实现序列化接口Serializable
  • 二级缓存需要手动开启

1. 修改全局配置文件，开启二级缓存

1. 哪个映射器要使用二级缓存，就在哪个映射文件里开启二级缓存支持

2. 哪个方法要使用二级缓存，就在方法的配置statement上加useCache="true"

    
    @Test
    public void testLevel2Cache(){
        //第一次：
        SqlSession session1 = factory.openSession();
        UserDao userDao1 = session1.getMapper(UserDao.class);
        User user1 = userDao1.findById(41);
        session1.close();


        //第二次：
        SqlSession session2 = factory.openSession();
        UserDao userDao2 = session2.getMapper(UserDao.class);
        User user2 = userDao2.findById(41);
        session2.close();

        System.out.println(user1==user2);
    }

如果要查询一条数据，有很多关联的其它数据，该如何实现呢？可以使用Mybatis的查询嵌套方式实现需求

如下图所示：

• 要查询一条用户数据，封装成User
• 但是User里还要有：
  • 当前User关联的订单列表
  • 当前User关联的帐号列表
  • 当前User关联的角色列表
  • 当前User关联的收货地址列表
  • 当前User关联的用户详情
    

1. 创建项目，导入jar包，创建JavaBean
2. 创建映射器接口UserDao和AccountDao
3. 创建映射文件UserDao.xml 和AccountDao.xml
4. 创建Mybatis的全局配置文件。 注意，要配置好别名和映射器
5. 准备好log4j日志配置文件
6. 编写单元测试类备用

• 查询所有帐号，及关联的用户。一个帐号Account只关联一个用户User

1. 修改实体类Account
2. 在映射器里加方法
3. 在映射文件配置statement：
   • 编写SQL语句，只查询所有的帐号select * from account

• 使用resultMap封装结果集，使用association封装关联的那个User
  

public class Account {
    private Integer id;
    private Integer uid;
    private Double money;

    private User user;
 
    //get/set...
}

    
    List queryAllAccount();

    select * from account


    
    
    

    
    

    
    User findById(Integer uid);

    select * from user where id = #{uid}

 
5. 测试 
package com.is.fwis;

import com.is.fwis.dao.AccountDao;
import com.is.fwis.dao.UserDao;
import com.is.fwis.domain.Account;
import com.is.fwis.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.List;


public class NestedQueryTest {
    private InputStream is;
    private SqlSession session;
    private UserDao userDao;
    private AccountDao accountDao;

    
    @Test
    public void testQueryAllAccount(){
        List accounts = accountDao.queryAllAccount();
        accounts.forEach(System.out::println);
    }


    @Before
    public void init() throws IOException {
        //1. 读取全局配置文件
        is = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2. 得到一个SqlSession对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        session = factory.openSession();
        userDao = session.getMapper(UserDao.class);
        accountDao = session.getMapper(AccountDao.class);
    }

    @After
    public void destroy() throws IOException {
        session.close();
        is.close();
    }
}
 
3. 关联一个集合 
目标 
查询用户信息，及其关联的帐号信息集合。
 
分析 
public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    
    private List accounts;
 	
    //get/set...
}
 
在UserDao里增加方法，查询所有用户。执行的语句select * from user
在UserDao.xml里配置statement： 
  
要使用resultMap封装结果集
当封装User里accounts时，使用
 
 
实现 
1. 在UserDao里增加方法 
    
    List queryAllUser();
 
2. 在UserDao.xml里配置statement 

    select * from user


    
    
    
    
    

    
    

    
    List findAccountsByUid(Integer uid);

    SELECT * FROM account WHERe uid = #{uid}

 
4. 测试 
@Test
public void testQueryAllUser(){
    List userList = userDao.queryAllUser();
    userList.forEach(System.out::println);
}
 
四、延迟加载 
在多表关联查询时，比如查询用户信息，及其关联的帐号信息，在查询用户时就直接把帐号信息也一并查询出来了。但是在实际开发中，并不是每次都需要立即使用帐号信息，这时候，就可以使用延迟加载策略了。
 
​ 需要在查询嵌套方式的基础上，才能开启懒加载。
 
1. 什么是延迟加载 
立即加载 
不管数据是否需要使用，只要调用了方法，就立即发起查询。
比如：查询帐号，得到关联的用户；查询用户，得到关联的帐号
 
延迟加载 
 
延迟加载，也叫按需加载，或者叫懒加载。
 
  
只有当真正使用到数据的时候，才发起查询。不使用不发起查询
比如：查询用户信息，不使用accounts的时候，不查询帐号的数据；只有当使用了用户的accounts，Mybatis再发起查询帐号的信息
 
 
先从单表查询，需要使用关联数据时，才进行关联数据的查询。单表查询的速度要比多表关联查询速度快，性能高；
 
 
用不上的数据，暂时不查询，内存占用小
 
 
延迟加载的使用场景 
一对一（多对一），通常不使用延迟加载（建议）。比如：查询帐号，关联加载用户信息
一对多（多对多），通常使用延迟加载（建议）。比如：查询用户，关联加载帐号信息
 
2. 实现延迟加载 
只需要在查询嵌套方式的基础上，开启懒加载即可。 开启懒加载方式：
 
方式一：在全局配置文件中增加配置，开启全局的懒加载
 

    
    
    
    

 
方式二：局部配置懒加载
 
在association标签上、或collection标签上增加属性fetchType，把当前关联加载设置为懒加载
局部配置，会覆盖掉全局配置
 


 
注意：
 
在配置了延迟加载策略后，即使没有调用关联对象的任何方法，当你调用当前对象的
 equals、clone、hashCode、toString方法时也会触发关联对象的查询。
在配置文件中可以使用lazyLoadTriggerMethods配置项覆盖掉mybatis的默认行为。
 

 
总结 
懒加载：延迟加载，按需加载。当用不到关联的数据时，就不查询；只要用到时，才会查询
开启懒加载： 
  
全局开启
局部开启：在association标签或者collection标签上加属性 fetchType="lazy"
 
 
五、多表关联查询 
1. 搭环境 
搭建Mybatis开发环境：略
 
针对user表和account表进行关联查询。两张表的关系是：一个user对多个account
 
分别准备好两张表对应的实体类User， Account
 
2. 一对一（多对一）关联查询 
目标 
需求：查询所有帐户表信息，及其关联的用户信息
 
分析 
 
编写多表查询的SQL语句。
 
注意：查询结果集里一定不能有重名列；如果有重名列，就起别名，保证所有列名不重复
 
#查询所有帐户表信息，及其关联的用户信息
SELECT a.id aid, a.uid, a.money, u.* FROM account a LEFT JOIN USER u ON a.uid = u.id
 
 
调整的JavaBean实体类
 
要查询帐号，就封装到Account对象里
 
每个帐号关联一个用户数据：在Account里加一个成员变量private User user
 
 
使用Mybatis执行SQL，使用resultMap封装结果
 
当封装关联的那个User时，使用association标签
 
 
实现 
1) 修改Account类 
Account中要有User的引用
 
public class Account {
    private Integer id;
    private Integer uid;
    private Double money;

    private User user;
 
    //get/set...
}
 
2) 在映射器接口AccountDao中增加方法 
public interface AccountDao {
    
    List queryAllAccount();

}
 
3) 在映射文件AccountDao.xml中增加statement 
使用resultMap手动映射封装结果集
 



    
        SELECT a.id aid, a.uid, a.money, u.* FROM account a LEFT JOIN USER u ON a.uid = u.id
    
    
        
        
        

        
            
            
            
            
            
        
    

 
4) 在单元测试类中编写测试代码 
package com.is.fwis;

import com.is.fwis.dao.AccountDao;
import com.is.fwis.dao.UserDao;
import com.is.fwis.domain.Account;
import com.is.fwis.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.List;


public class DuobiaoQueryTest {
    private InputStream is;
    private SqlSession session;
    private UserDao userDao;
    private AccountDao accountDao;

    @Test
    public void testQueryAllAccount(){
        List accounts = accountDao.queryAllAccount();
        accounts.forEach(System.out::println);
    }

    @Before
    public void init() throws IOException {
        //1. 读取全局配置文件
        is = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2. 得到一个SqlSession对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        session = factory.openSession();
        userDao = session.getMapper(UserDao.class);
        accountDao = session.getMapper(AccountDao.class);
    }

    @After
    public void destroy() throws IOException {
        session.close();
        is.close();
    }
}
 
3. 一对多（多对多）关联查询 
查询所有用户(user)信息，以及每个用户拥有的所有帐号(account)信息
 
分析 
 
编写多表查询SQL语句
 
注意：查询结果集里不能有重名列。如果有，就起别名，保证所有列名不重复
 
#查询所有用户(user)信息，以及每个用户拥有的所有帐号(account)信息
SELECT u.*, a.id aid, a.uid, a.money FROM USER u LEFT JOIN account a ON u.id = a.uid
 
 
改造JavaBean
 
把查询结果集里user表数据，封装到User对象里
 
一个用户关联多个帐号，所以在User里应该有一个private List accounts;
 
 
执行SQL语句，用resultMap封装结果；
 
当封装到其中关联的集合List时，使用collection标签封装
 
 
实现 
1) 修改User类 
User类中要有List，用于保存用户拥有的帐号信息集合
 
public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    
    private List accounts;
 	
    //get/set...
}
 
2) 在映射器接口UserDao中增加方法 
package com.is.fwis.dao;

import com.is.fwis.domain.User;

import java.util.List;


public interface UserDao {

    List queryAllUser();
}
 
3) 在配置文件UserDao.xml中增加statement 
封装结果集时，要使用resultMap手动映射
 



    
       SELECT u.*, a.id aid, a.uid, a.money FROM USER u LEFT JOIN account a ON u.id = a.uid
    
    
        
        
        
        
        

        
            
            
            
        
    

    
    @Test
    public void testQueryAllUser(){
        List userList = userDao.queryAllUser();
        userList.forEach(System.out::println);
    }