Day2 Mybatis初识（二）

mapper接口开发

传统dao的开发问题(ibatis)

方法调用:字符串易错,硬编码

mapper代理开发

a) 编写全局配置

b) 编写接口(自动根据接口和映射文件创建实现类)

c) 编写映射文件

　　规范:

　　A. 映射文件和mapper接口同包同名(批量加载映射文件)

　　B. 接口的全限定名称必须和mapper映射文件的namespace保持一致

　　C. 接口中方法名称和mapper中的标签id保持一致

　　D. 方法的参数类型和mapper的paramerType保持一致

　　E. 方法的返回值类型和mapper的resultType和resultMap保持一致

<mapper namespace="mapper.BookMapper">
    <select id="queryAll" resultType="book">
      select * from book
    </select>
</mapper>

d) 测试

SqlSession session = MybatisUtils.getSession();
        //根据mapper接口生成实现类对象
        BookMapper mapper = session.getMapper(BookMapper.class);
        System.out.println(mapper.queryAll());
        MybatisUtils.closeSession();

//junit:单元测试
        //1.加入junit的jar
        //2.使用junit实现测试(@test:作为单元直接运行   @before/@after:在test之前运行  )

输入参数和输出结果

输出结果

a) resultType:

如果结果集中所有的字段和对象中属性名称一一对应则映射成功；

如果结果集中字段的名称和属性名称部分一致,则一致的部分映射成功。

如果结果集中字段的名称和属性名称都不一致，则不会创建对象。

b) 字段和属性不一致实现封装

A. 起别名

B. resultMap(实现字段和属性之间的映射)

<!-- 实现结果集和对象的映射
        id:唯一标识
        type:封装的对象类型
     -->
    <resultMap type="book" id="bookMap">
        <!-- id:描述主键字段和属性之间的映射关系 
            column:字段
            property:属性
        -->
        <id column="bi" property="bid"/>
        <!-- result:非主键字段的映射 -->
        <result column="bnam" property="bname"/>
        <result column="autho" property="author"/>
        <result column="pric" property="price"/>
    </resultMap>
    
    <select id="queryAll" resultMap="bookMap">
      select * from book
    </select>

动态sql

if：
<select id="queryCombo" parameterType="book" resultType="book">
        select * from book where 1 = 1
        <if test="bid != 0">
            and bid = #{bid}
        </if>
        <if test="bname != null">
            and bname = #{bname}
        </if>
    </select>

choose:
<choose>
            <when test="bid != 0">
                and bid = #{bid}
            </when>
            <otherwise>
                and bname = #{bname}
            </otherwise>
</choose>

where
<where>
            <if test="bid != 0">
                and bid = #{bid}
            </if> 
            <if test="bname != null">
                and bname = #{bname}
            </if> 
</where>


foreach：
select * from book where bid in
        <!-- collection:遍历的集合
            item:每一项值
            open:开始
            close:结束
            separator:分隔符
         -->
        <foreach collection="list" item="bid" open="(" close=")" separator=",">
            #{bid}
        </foreach>

高级结果映射

1) 查询的结果集分布于多张表

2) 一对多:Role和User(查询role级联查询所有的员工信息)

<resultMap type="role" id="RoleMap">
        <id column="rid" property="rid"/>
        <result column="rname" property="rname"/>
        <!-- collection:将结果集数据封装到集合中
                property:属性
                ofType:单个对象的类型
                column:关联的键
         -->
        <collection property="users" ofType="user" column="rid">
            <id column="uid" property="uid"/>
            <result column="uname" property="uname"/>
            <result column="rid" property="rid"/>
        </collection>
    </resultMap>
    <select id="queryRoleAndUser" resultMap="RoleMap">
        select * from role r left join `user` u on r.rid = u.rid
    </select>


Rolemapper.xml
<resultMap type="role" id="RoleMap2">
        <id column="rid" property="rid"/>
        <result column="rname" property="rname"/>
        <!-- collection:将结果集数据封装到集合中
                property:属性
                ofType:单个对象的类型
                column:关联的键
         -->
        <collection property="users" ofType="user" column="rid" 
          select="mapper.UserMapper.selectUser">
        </collection>
    </resultMap>
    <select id="queryRoleAndUser2" resultMap="RoleMap2">
        select * from role
    </select>
UserMapper.xml
<select id="selectUser" resultType="user">
        select * from user where rid = #{rid}
    </select>

3) 一对一：查询user及其角色(user)

<resultMap type="user" id="userMap">
        <id column="uid" property="uid"/>
        <result column="uname" property="uname"/>
        <!-- 将结果集数据封装到对象中
            property:对象的属性名称
            column:外键
            javaType:对象的类型
         -->
        <association property="role" column="rid" javaType="role">
            <id column="rid" property="rid"/>
            <result column="rname" property="rname"/>
        </association>
    </resultMap>
   <select id="queryUserAndRole" resultMap="userMap">
       select * from user u
        left join role r
        on u.rid = r.rid;
   </select>

UserMapper:
<resultMap type="user" id="userMap2">
        <id column="uid" property="uid"/>
        <result column="uname" property="uname"/>
        <!-- 将结果集数据封装到对象中
            property:对象的属性名称
            column:外键
            javaType:对象的类型
         -->
        <association property="role" column="rid" javaType="role" 
            select="mapper.RoleMapper.selectRole">
        </association>
    </resultMap>
   <select id="queryUserAndRole2" resultMap="userMap2">
          select * from user
   </select>

RoleMapper
<select id="selectRole" resultType="role">
        select * from role where rid = #{rid}
</select>

延迟加载

1)  延迟加载:按需加载(懒加载),只加载主查询，需要用到子查询信息时才去查询。

2)  <collection><association>都具有延迟加载功能。但是默认关闭。

3)  需要打开延迟加载:

<settings>
    <!-- 延迟加载全局开关 -->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!-- 3.4.1以上为false,否则为true -->
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

缓存

一级缓存

Mybatis中的一级缓存时默认开启的。

在内存中一块区域，以类似于map方式进行数据管理。

当用户第一次查询时，会根据sql，参数，rowbounds以及statement的id生成cacheKey,先从二级缓存中获取数据，如果为空，将从一级缓存中根据生成key获取value值，如果也为空，就从数据库进行查询，然后将key和查询的结果放置到一级缓存中。

当用户再次查询时，仍旧生成cacheKey,通过key从一级缓存中获取值，如果有值此时将直接返回不再查询数据库。

        一级缓存是session级别的缓存。

                   如果执行增删改会清空一级缓存。

二级缓存

在内存中一块区域，以类似于map方式进行数据管理。

当用户第一次查询时，会根据sql，参数，rowbounds以及statement的id生成cacheKey,先从二级缓存中获取数据，如果为空，将从一级缓存中根据生成key获取value值，如果也为空，就从数据库进行查询，然后将key和查询的结果放置到一级缓存中。

当用户再次查询时，仍旧生成cacheKey,通过key从一级缓存中获取值，如果有值此时将直接返回不再查询数据库。

如果执行增删改会清空二级缓存

二级缓存是跨session的缓存。

默认二级缓存关闭。

实体类必须序列化。

<cache>

//读取配置文件转换为流
        InputStream is = Resources.getResourceAsStream("Mybatis.xml");
        //创建ssf对象
        SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(is);
        
        SqlSession session = ssf.openSession(true);
        SqlSession session2 = ssf.openSession(true);
        SqlSession session3 = ssf.openSession(true);
        
        //根据mapper接口生成实现类对象
        BookMapper mapper = session.getMapper(BookMapper.class);
        BookMapper mapper2 = session2.getMapper(BookMapper.class);
        BookMapper mapper3 = session3.getMapper(BookMapper.class);
        
        System.out.println(mapper.queryAll());
        session.close();
        
        System.out.println(mapper2.queryAll());
        session2.close();
        
        System.out.println(mapper3.queryAll());
        session3.close();