mybatis学习笔记续

mybatis的多表查询

mybatis中的多表查询

表之间的关系有几种：

一对多

多对一

一对一

多对多

举例：

用户和订单就是一对多

订单和用户就是多对一

​ 一个用户可以以下多个订单

​ 多个订单属于同一个用户

人和身份证就是一对一

​ 一个人只能有一个身份证号

​ 一个身份证号只能属于一个人

​ 一个学生可以被多个老师教过

​ 一个老师可以教·多个学生

特例：

如果拿出一个订单，他都只能属于一个用户

所以mybatis就把多对一看成了一对一

mybatis中的多表查询：

用户和账户

一个用户可以有多个账户

一个账户只能属于一个用户（多个账户可以属于同一个用户）

步骤：

1.建立两张表：用户表，账户表

让用户表和账户表之间具备一对多的关系：需要使用外键在账户表添加

2.建立两个实体类：用户实体类和账户实体类

让用户和账户的实体类能体现出啦一对多的关系

3.建立两个配置文件

用户的配置文件

账户的配置文件

4.实现配置：

当我们查询用户时，可以同时得到用户下所包含的账户信息

当我们查询账户时，可以同时得到账户的所属用户信息

在开发中的发现在主配置的中的起的别名会在映射文件中起作用，在实现多查询主从表区别主要是结构的不同，无论是在映射的类对象中

一对一的查询

可以将一对一的对应的类进行关联如下列：

例如：在数据库在user与account相关联，一对一，account为从表，user为主表，从表在创建时就可以设置，在实体类中应创建两张表，从表的类应该定义主表类的引用的

public class User implements Serializable {
    private Integer id;
    private  String username;
    private Date birthday;
    private  String sex;
    private String address;

public class Account implements Serializable {
    private  Integer id;
    private  Integer uid;
    private  Double money;
    //从表实体应该包含一个主表实体的对象引用
    private  User user;

在映射文件中，相对应的返回值，就涉及到两张表了，做法如下

<resultMap id="accountDao" type="account">
    <id property="id" column="uid"></id>
    <result property="uid" column="uid"></result>
    <result property="money" column="money"></result>
    <!--一对一的关系映射，配置封装user的内容-->
    <association property="user" column="uid" javaType="user">
        <id property="id" column="id"></id>
        <result column="username" property="username"></result>
        <result column="address" property="address"></result>
        <result column="sex" property="sex"></result>
        <result column="birthday" property="birthday"></result>
    </association>
</resultMap>

然后在相对应的语句中编辑如

<select id="findAll" resultMap="accountDao">
    select a.*,u.* from account a ,user u where  u.id=a.uid;
</select>

另一种的方法为：就是另外定义一个类去继承从表，该表也定义了两个变量

public class AccountUser extends  Account{

        private  String username;
        private  String address;

<!--查询所有账户同时包含用户名和地址信息-->
<select id="findAllAccount" resultType="accountUser">
    select a.*,u.* from account a ,user  u where  u.id=a.uid;
</select>

从这个结论来推定这些类的属性用来装从数据库中相对应的值

这种类如：

public class Account implements Serializable {
    private  Integer id;
    private  Integer uid;
    private  Double money;
    //从表实体应该包含一个主表实体的对象引用
    private  User user;

这个就用来装相关的属性值的类

一对多查询

如：查询所有用户信息及用户关联的账号信息

分析：用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息查询出来，我们想到左外连接查询比较合适

表对应中的实体类中的写法为：主表中包含从表的实体类的引用，如

user与account是一对多的关系，user表为主表

user的实体类如下：

public class User implements Serializable {
    private Integer id;
    private  String username;
    private Date birthday;
    private  String sex;
    private String address;
    private List<Account> accounts;

对应的映射文件设置为：

<resultMap id="userAccountMap" type="user">
    <id property="id" column="id"></id>
    <result property="username" column="username"></result>
    <result property="address" column="address"></result>
    <result property="sex" column="sex"></result>
    <result property="birthday" column="birthday"></result>
    <collection property="accounts" ofType="account">
        <id column="aid" property="aid"></id>
        <result column="uid" property="uid"></result>
        <result column="money" property="money"></result>
    </collection>
</resultMap>

<select id="findAll" resultMap="userAccountMap">
    select * from user u left outer join account a on u.id=a.uid;
</select>

多对多

实例：用户与角色

一个用户可以有多个角色

一个角色可以有多个用户

步骤：1.建立两张表：用户表，角色表

让用户表何角色表具有多对多的关系，需要使用中间表，中间表中包含各自的主键，在中间表中是外键

2.建立两个实体类：用户实体类和角色实体类

让用户和角色的实体类能体现出来多对多的关系

各自包含对方一个集合引用

3.建立两个配置文件

用户的配置文件

角色的配置文件

4.实现配置：

当我们查询用户时，可以同时得到用户所包含的角色信息

当我们查询角色时，可以同时得到角色的所赋予的用户信息

总结经验：数据库连接的配置文件和映射文件都是类似于一种计划单，计划单中的有些关键字用来表明特定作用，这些文件会被分析，然后被封装得jdbc标准的被读取被分析的数据，然后连接相关的数据库，数据库中的数据表如果是多联系的，在映射文件中会配置相关的返回值类型，数据表相对应的实体类的应该包含相关联表实体类的引用

如：

public class User implements Serializable {
    private Integer id;
    private  String username;
    private Date birthday;
    private  String sex;
    private String address;
    private List<Role> roles;

映射文件的配置如下：

<resultMap id="userAccountMap" type="user">
    <id property="id" column="id"></id>
    <result property="username" column="username"></result>
    <result property="address" column="address"></result>
    <result property="sex" column="sex"></result>
    <result property="birthday" column="birthday"></result>
    <collection property="roles" ofType="role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
    </collection>
</resultMap>

<select id="findAll" resultMap="userAccountMap">
    select u.*,r.id as rid,r.role_name,r.role_desc from user u
    left outer join user_role ur on u.id=ur.uid
    left outer join role r on r.id=ur.rid;
</select>

Mybatis中的延迟加载

问题：在一对多中，当我们有一个用户，它有100个账户。

在查询用户的时候，要不要把关联的账户查出来

在查询账户的时候，要不要把关联的用户查出来

这时对内存的压力有很大

在查询用户时，用户下的账户信息应该是，什么时候用，什么什有查询

在查询账户时，账户的所属用户信息应该随者账户查询时一起查询出来

什么是延迟加载

在真正使用数据时才发起查询，不用的时候不查询，按需加载

什么是立即加载

不管用不用，一调用方法就马上查询

延迟加载和马上加载的使用取决于表关联关系

表的关联有四种情况，一对多，多对多，通常是延迟加载，一对一，多对一，通常是立即加载

mybatis的缓存和注解开发

mybatis中的缓存

什么是缓存：

存在于内存中的临时数据

为什么使用缓存

减少和数据库的交互次数，提高效率

什么样的数据能使用缓存，什么数据不能使用

适用缓存：经常查询并且不经常改变

数据的正确与否对最终结果影响不大的：

不适合：经常改变的数据

数据的正确与否对最终结果影响很大的

mybatis中的一级缓存和二级缓存

一级缓存：它指的是Mybatis中sqlsession对象的缓存

当我们执行查询之后，查询的结果会同时存入到sqlsession为我们提供一块区域中

该区域的结构是一个map，当我们再次查询同样的数据，mybatis会先去sqlsession中查询是否有，有的话直接拿出来用

当sqlsession对象消失时，mybatis的一级缓存也就会消失。

public void testFirstLevelCache(){
    User user1=userDao.findUserById(Integer.valueOf(41));
    System.out.println(user1);
    sqlSession.clearCache();
    sqlSession=factory.openSession();
    userDao=sqlSession.getMapper(IUserDao.class);
    User user2=userDao.findUserById(Integer.valueOf(41));
    System.out.println(user2);
    System.out.println(user1==user2);
}

一级缓存的分析

一级缓存是sqlsession范围的缓存，当调用sqlsession的修改，添加，删除，commit(),close()等方法时，就会清空一级缓存

@Test
public void testClearCache(){
    User user1=userDao.findUserById(Integer.valueOf(41));
    System.out.println(user1);
    user1.setUsername("唯我独尊");
    userDao.updateUser(user1);
    User user2=userDao.findUserById(Integer.valueOf(41));
    System.out.println(user2);
    System.out.println(user1==user2);
}

二级缓存：

它指的是mybatis中sqlsessionfactory对象的缓存，由同一个sqlsessionfactory对象创建的sqlsession共享其缓存

二级缓存的使用步骤：

第一步：让mybatis框架支持二级缓存(在sqlmapconfig.xml中配置)

<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>

第二步：让当前的映射文件支持二级缓存（在iuserdao.xml配置）

<cache/>

第三步：让当前的操作支持二级缓存（在select标签中配置）

<select id="findUserById" parameterType="int" resultType="com.itheima.domain.User" useCache="true">
    select * from user where id= #{uid};
</select>

@Test
public void testFirstLevelCache(){
    SqlSession sqlSession=factory.openSession();
    IUserDao dao1=sqlSession.getMapper(IUserDao.class);
    User user1=dao1.findUserById(Integer.valueOf(41));
    System.out.println(user1);
    sqlSession.close();
    SqlSession sqlSession2=factory.openSession();
    IUserDao dao2=sqlSession2.getMapper(IUserDao.class);
    User user2=dao2.findUserById(Integer.valueOf(41));
    System.out.println(user2);
    System.out.println(user1==user2);
}