1.mybatis的延迟加载
问题：在一对多中，当我们有一个用户，他有100个账户
在查询用户的时候，要不要把关联的账户查出来？
在查询账户的时候，要不要把关联的用户查出来？
解决：在查询用户的时候，用户下的账户信息应该是，什么时候使用，什么时候查询出来，如果每次查询用户的时候都把关联的账户信息查询出来，会浪费内存空间
但是在查询账户时，账所属的用户信息应该是随着账户查询时一起查询出来
1.1.什么是延迟加载：
1.2.延迟加载的优缺点
延迟加载的好处：先从单表查询，需要时再从关联表去关联查询，大大提高数
据库性能，因为查询单表要比关联查询多张表速度要快。
延迟加载的坏处：因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗 时间，所以可能造成用户等待时间变长，造成用户体验下降。
2.多对一、一对一延迟加载的实现
使用assocation实现延迟加载
需求：查询账户信息同时查询用户信息
2.1 账户的持久层 DAO 接口
public interface IAccountDao {
/**
*查询所有账户，同时获取账户的所属用户名称以及它的地址信息
* @return
*/
List<Account> findAll();
}
2.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.IAccountDao">
<!-- 建立对应关系 -->
<resultMap type="account" id="accountMap">
<id column="aid" property="id"/>
<result column="uid" property="uid"/>
<result column="money" property="money"/>
<!-- 它是用于指定从表方的引用实体属性的 -->
<association property="user" javaType="user" select="com.itheima.dao.IUserDao.findById" column="uid">
</association>
</resultMap>
<select id="findAll" resultMap="accountMap">
select * from account
</select>
</mapper>
select： 填写我们要调用的 select 映射的 id
column ： 填写我们要传递给 select 映射的参数
2.3.用户的持久层接口
public interface IUserDao {
/**
*根据 id 查询
* @param userId
* @return
*/
User findById(Integer userId);
}
2.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">
<mapper namespace="com.itheima.dao.IUserDao">
<!-- 根据 id 查询 -->
<select id="findById" resultType="user" parameterType="int" >
select * from user where id = #{uid}
</select>
</mapper>
2.5.开启 Mybatis 的延迟加载策略
我们需要在 Mybatis 的配置文件 SqlMapConfig.xml 文件中添加延迟加载的配置。
<!-- 开启延迟加载的支持 --> <settings> <setting name="lazyLoadingEnabled" value="true"/> <setting name="aggressiveLazyLoading" value="false"/> </settings>
2.6.编写测试只查账户信息不查用户信息。
@Test
public void testFindAll(){
//执行操作
List<Account> accounts = accountDao.findAll();
}
3.一对多，多对多实现延迟加载
我们也可以在一对多关系配置的<collection>结点中配置延迟加载策略。
<collection>结点中也有 select 属性，column 属性。
需求： 完成加载用户对象时，查询该用户所拥有的账户信息。
3.1.在 User 实体类中加入 List<Account>属性
public class User implements Serializable {
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 + "]"; } } 6
3.2.编写用户持久层接口的方法
/** *查询所有用户，同时获取出每个用户下的所有账户信息 *@return */ List<User> findAll();
3.3.编写账户持久层接口的方法
/** * 根据用户 id 查询账户信息 * @param uid * @return */ List<Account> findByUid(Integer uid);
3.4.编写用户持久层映射配置
<resultMap type="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 用于指定集合元素的数据类型 select 是用于指定查询账户的唯一标识（账户的 dao 全限定类名加上方法名称） column 是用于指定使用哪个字段的值作为条件查询 --> <collection property="accounts" ofType="account" select="com.itheima.dao.IAccountDao.findByUid" column="id"> </collection> </resultMap> <!-- 配置查询所有操作 --> <select id="findAll" resultMap="userMap"> select * from user </select>
<collection>标签： 主要用于加载关联的集合对象
select 属性： 用于指定查询 account 列表的 sql 语句，所以填写的是该 sql 映射的 id
column 属性： 用于指定 select 属性的 sql 语句的参数来源，上面的参数来自于 user 的 id 列，所以就写成 id 这一 个字段名了
3.5.编写账户持久层映射配置
<!-- 根据用户 id 查询账户信息 -->
<select id="findByUid" resultType="account" parameterType="int">
select * from account where uid = #{uid}
</select>
3.6.在主配置文件中配置延迟加载
<!-- 开启延迟加载的支持 --> <settings> <setting name="lazyLoadingEnabled" value="true"/> <setting name="aggressiveLazyLoading" value="false"/> </settings>
3.7.测试只加载用户信息
@Test
public void testFindAll() {
//6.执行操作 List<User> users = userDao.findAll();
}
4.立即加载
不管用不用，只要一调用方法，马上发起查询
在对应的四种表关系中：一对多，多对一，一对一，多对多
一对多、多对多：通常情况下我们都是采用延迟加载
多对一、一对一： 通常情况下我们都是采用立即加载
5.mybatis中的缓存
什么是缓存：存在于内存中的临时数据
为什么要使用缓存：减少和数据库的交互次数，提高执行效率
什么样的数据能使用缓存，什么样的数据不能使用缓存：
适用于缓存：经常查询并且不经常改变的。
数据的正确与否对最终的结果影响不大。
不适用于缓存：经常改变的数据
数据的正确与否对最终结果影响很大的。
例如：商品的库存，银行的汇率，股市的牌价
5.1.mybatis的一级缓存和二级缓存
一级缓存：它指的是mybatis中SqlSession对象的缓存（一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。 ）
当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供的一块区域中。
该区域的结果是一个Map，当我们再次查询同样的数据，mybatis会先去SqlSession中查询是否有，有的话直接拿出来用。
当SqlSession对象消失的时候，mybatis的一级缓存也就消失了。
二级缓存：它指的是mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个 SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的
使用步骤：
第一步：让mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）
<settings> <!-- 开启二级缓存的支持 --> <setting name="cacheEnabled" value="true"/> </settings>
因为 cacheEnabled 的取值默认就为 true，所以这一步可以省略不配置。为 true 代表开启二级缓存；为 false 代表不开启二级缓存
第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）
<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="com.itheima.dao.IUserDao">
<!-- 开启二级缓存的支持 -->
<cache></cache>
</mapper>
第三步：让当前的操作支持二级缓存（在select标签中配置）
<!-- 根据 id 查询 -->
<select id="findById" resultType="user" parameterType="int" useCache="true">
select * from user where id = #{uid} </select>
将 UserDao.xml 映射文件中的<select>标签中设置 useCache=”true”代表当前这个 statement 要使用 二级缓存，如果不使用二级缓存可以设置为 false。
注意：针对每次查询都需要最新的数据 sql，要设置成 useCache=false，禁用二级缓存。
二级缓存存的是数据，不是对象，查找的时候会新创一个对象，把数据拿给他，这样前后两次就不是同一个对象了
一级缓存不用开启或者配置，自己就有的
6.mybatis注解开发
6.1.mybatis常用注解说明
@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
@Result:实现结果集封装
@Results:可以与@Result 一起使用，封装多个结果集
@ResultMap:实现引用@Results 定义的封装
@One:实现一对一结果集封装
@Many:实现一对多结果集封装
@SelectProvider: 实现动态 SQL 映射
@CacheNamespace:实现注解二级缓存的使用
6.2.复杂关系映射的注解说明
- @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=""))
6.3.使用mybatis注解实现多对一、一对一
需求：根据账户信息，查询对应的用户信息
6.3.1.编写用户实体类
public class User implements Serializable {
private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;
public Integer getUserId() {
return userId; }
public void setUserId(Integer userId) {
this.userId = userId; }
public String getUserName() {
return userName; }
public void setUserName(String userName) {
this.userName = userName; }
public Date getUserBirthday() {
return userBirthday; }
public void setUserBirthday(Date userBirthday) {
this.userBirthday = userBirthday; }
public String getUserSex() {
return userSex; }
public void setUserSex(String userSex) {
this.userSex = userSex; }
public String getUserAddress() {
return userAddress; }
public void setUserAddress(String userAddress) {
this.userAddress = userAddress; }
@Override
public String toString() {
return "User [userId=" + userId + ", userName=" + userName + ", userBirthday=" + userBirthday + ", userSex=" + userSex + ", userAddress=" + userAddress + "]";
}
}
6.3.2.编写账户的实体类
public class Account implements Serializable {
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 + "]";
}
}
注意： 此处我们故意和数据库表的列名不一致。
6.3.3.添加账户的持久层接口并使用注解配置
public interface IAccountDao {
/**
* 查询所有账户，采用延迟加载的方式查询账户的所属用户
* @return
*/
@Select("select * from account")
@Results(id="accountMap",value= {
@Result(id=true,column="id",property="id"), @Result(column="uid",property="uid"), @Result(column="money",property="money"), @Result(column="uid",property="user",one=@One(select="com.itheima.dao.IUserDao.findById", fetchType=FetchType.LAZY) ) }) List<Account> findAll();
一对一：（根据账户而言）
property对应要封装的user属性，用uid这个字段去查column=“uid”，指向select，select要找到实现功能的那个方法findbyId，写全限定类名（包名+类名+方法名）
one里边有select和fetchType
6.3.4.添加用户的持久层接口并使用注解配置public interface IUserDao {
/**
* 查询所有用户
* @return
*/
@Select("select * from user")
@Results(id="userMap",value= { @Result(id=true,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(); /**
* 根据 id 查询一个用户 * @param userId * @return */ @Select("select * from user where id = #{uid} ") @ResultMap("userMap") User findById(Integer userId); }
6.3.5.测试
6.4.使用mybatis注解实现多对多、一对多
需求：当查询用户信息的时候，也要查询出对应的账户信息
6.4.1.用户实体类
public class User implements Serializable {
private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;
//一对多关系映射：主表方法应该包含一个从表方的集合引用
private List<Account> accounts;
public List<Account> getAccounts() {
return accounts; }
public void setAccounts(List<Account> accounts) {
this.accounts = accounts; }
public Integer getUserId() {
return userId; }
public void setUserId(Integer userId) {
this.userId = userId; }
public String getUserName() {
return userName; }
public void setUserName(String userName) {
this.userName = userName; }
public Date getUserBirthday() {
return userBirthday; }
public void setUserBirthday(Date userBirthday) {
this.userBirthday = userBirthday; }
public String getUserSex() {
return userSex; }
public void setUserSex(String userSex) {
this.userSex = userSex; }
public String getUserAddress() {
return userAddress; }
public void setUserAddress(String userAddress) {
this.userAddress = userAddress; }
@Override
public String toString() {
return "User [userId=" + userId + ", userName=" + userName + ", userBirthday=" + userBirthday + ", userSex=" + userSex + ", userAddress=" + userAddress + "]";
}
}
6.4.2.编写用户的持久层接口并使用注解配置
public interface IUserDao {
/**
* 查询所有用户
* @return
*/
@Select("select * from user")
@Results(id="userMap",value= {
@Result(id=true,column="id",property="userId"), @Result(column="username",property="userName"), @Result(column="sex",property="userSex"), @Result(column="address",property="userAddress"), @Result(column="birthday",property="userBirthday"), @Result(column="id",property="accounts",many=@Many(select="com.itheima.dao.IAccountDao.findByUid", fetchType=FetchType.LAZY) ) }) List<User> findAll(); }
@Many: 相当于<collection>的配置 select 属性：代表将要执行的 sql 语句
fetchType 属性：代表加载方式，一般如果要延迟加载都设置为 LAZY 的值
6.4.3.编写账户的持久层接口并使用注解配置
public interface IAccountDao {
/**
*根据用户 id 查询用户下的所有账户
*@param userId * @return
*/
@Select("select * from account where uid = #{uid} ")
List<Account> findByUid(Integer userId);
}
6.4.4.测试