mybatis学习日记3

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.测试

7.mybatis 基于注解的二级缓存 

 7.1.在 SqlMapConfig 中开启二级缓存支持 

<!-- 配置二级缓存 --> 
<settings> 
  <!-- 开启二级缓存的支持 --> 
  <setting name="cacheEnabled" value="true"/>
</settings>

7.2.在持久层接口中使用注解配置二级缓存 

@CacheNamespace(blocking=true)
  //mybatis 基于注解方式实现配置二级缓存 
  public interface IUserDao {......}

 

posted @ 2019-12-07 12:06  一个名  阅读(404)  评论(0编辑  收藏  举报