二、mybatis进阶

1. 关联查询

1.1 多对一

PO类

public class Orders {

    private Integer id; 
    private Integer userId;
    private String number;
    private Date createtime;
    private String note;

    //用户信息
    private User user;
    。。。
 }

映射文件

    <resultMap type="cn.com.model.Orders" id="userordermap">
        <id property="id" column="id" />
        <result property="userId" column="user_id" />
        <result property="number" column="number" />
        <result property="createtime" column="createtime" />
        <result property="note" column="note" />

        <association property="user" javaType="cn.com.model.User">
            <id property="id" column="user_id" />
            <result property="username" column="username" />
            <result property="address" column="address" /> 
        </association>
    </resultMap>

    <select id="findOrdersListResultMap" resultMap="userordermap">
        SELECT  orders.*,   user.username,  user.address
        FROM    orders, user
        WHERE orders.user_id = user.id 
    </select>

多对一中，使用association 映射一方

<association property="user" javaType="cn.com.model.User">
            <id property="id" column="user_id" />
            <result property="username" column="username" />
            <result property="address" column="address" /> 
</association>

“id” 会使用orders中的user_id 对id进行赋值
property : 多方中对应的一方的属性名
javaType：类型

1.2 一对多

PO类

public class Orders {

    private Integer id; 
    private Integer userId;
    private String number;
    private Date createtime;
    private String note;

    //用户信息
    private User user;

    //订单明细
    private List<Orderdetail> orderdetails;
。。。。
}

映射文件

<resultMap type="cn.com.model.Orders" id="userorderdetailmap">
    <id property="id" column="id" />
    <result property="userId" column="user_id" />
    <result property="number" column="number" />
    <result property="createtime" column="createtime" />
    <result property="note" column="note" />
    <association property="user" javaType="cn.com.model.User">
        <id property="id" column="user_id" />
        <result property="username" column="username" />
        <result property="address" column="address" />
    </association>
    <collection property="orderdetails" ofType="cn.com.model.Orderdetail">
        <id property="id" column="orderdetail_id" />
        <result property="itemsId" column="items_id" />
        <result property="itemsNum" column="items_num" />
    </collection>
</resultMap>  

    <select id="findOrdersDetailList" resultMap="userorderdetailmap">
        SELECT  orders.*,user.username,user.address,
                orderdetail.id orderdetail_id,orderdetail.items_id, orderdetail.items_num
        FROM orders,user,orderdetail
        WHERE orders.user_id = user.id
        AND orders.id = orderdetail.orders_id
    </select>

一对多中，一方中会定义多方的一个集合，在映射文件中使用collection映射。

<collection property="orderdetails" ofType="cn.com.model.Orderdetail">
        <id property="id" column="orderdetail_id" />
        <result property="itemsId" column="items_id" />
        <result property="itemsNum" column="items_num" />
</collection>

property：一方中的多方集合属性名称。
ofType：指定关联查询的结果集中的对象类型即List中的对象类型。

1.3 resultMap继承

上面的resultMap userorderdetailmap 可以继承userordermap ，复用重复部分

<resultMap type="cn.com.model.Orders" id="userorderdetailmap" extends="userordermap">

    <collection property="orderdetails" ofType="cn.com.model.Orderdetail">
        <id property="id" column="orderdetail_id" />
        <result property="itemsId" column="items_id" />
        <result property="itemsNum" column="items_num" />
    </collection>
</resultMap> 

resultMap 中用 extends=”父resultMap” 可复用已有的resultMap中的映射配置

1.4 多对多

需要关联查询映射的信息是：用户、订单、订单明细、商品信息
订单：一个用户对应多个订单，使用collection映射到用户对象的订单列表属性中
订单明细：一个订单对应多个明细，使用collection映射到订单对象中的明细属性中
商品信息：一个订单明细对应一个商品，使用association映射到订单明细对象的商品属性中

PO类

public class User { 
    private int id;
    private String username; 
    private String sex; 
    private Date birthday; 
    private String address; 

    //一个用户对应多个订单
    private List<Orders> orders = new ArrayList<Orders>();
}

public class Orders {

    private Integer id; 
    private Integer userId;
    private String number;
    private Date createtime;
    private String note;

    //用户信息
    private User user;

    //订单明细
    private List<Orderdetail> orderdetails;
    。。
}

public class Orderdetail {

    private Integer id;
    private Integer ordersId;
    private Integer itemsId;
    private Integer itemsNum;

    private Items items;
 。。。。   
}

映射文件

<resultMap type="cn.com.model.User" id="userOrderListResultMap">
        <id column="user_id" property="id"/>
        <result column="username" property="username"/>
        <collection property="orders" ofType="cn.com.model.Orders">
          <id  column="id" property="id"/>
          <result property="number" column="number"/>
            <association property="user" javaType="cn.com.model.User">
                <id property="id" column="user_id" />
                <result property="username" column="username" />
                <result property="address" column="address" /> 
            </association>
            <collection property="orderdetails" ofType="cn.com.model.Orderdetail">
                <id  column="orderdetail_id" property="id"/>
                <result property="ordersId" column="id"/>
                <result property="itemsId" column="items_id"/>
                <result property="itemsNum" column="items_num"/>
                <association property="items" javaType="cn.com.model.Items">
                     <id column="items_id" property="id"/>
                     <result column="items_name" property="name"/>
                     <result column="items_detail" property="detail"/>
                </association>
            </collection>
       </collection>
  </resultMap>
  <select id="findAll" resultMap="userOrderListResultMap">
    SELECT  orders.*,   USER .username, USER .address,
            orderdetail.id   orderdetail_id,
            orderdetail.items_id,
            orderdetail.items_num,
            items.name items_name,
            items.detail items_detail
    FROM    orders, USER,orderdetail,items
    WHERE   orders.user_id = USER .id
            AND orders.id = orderdetail.orders_id
            AND orderdetail.items_id = items.id
  </select> 

2. 延迟加载

需要查询关联信息时，使用mybatis延迟加载特性可有效的减少数据库压力，首次查询只查询主要信息，关联信息(如订单用户关系，可先查询订单，需要用户信息)获取时再加载。

2.1 打开延迟加载开关

在mybatis核心配置文件中配置：
lazyLoadingEnabled、aggressiveLazyLoading

设置项	描述	允许值	默认值
lazyLoadingEnabled	全局性设置懒加载。如果设为‘false’，则所有相关联的都会被初始化加载	true,false	false
aggressiveLazyLoading	当设置为‘true’的时候，懒加载的对象可能被任何懒属性全部加载。否则，每个属性都按需加载	true ,false	true

<settings>
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
</settings>

2.2 多对一延迟加载

PO类
一个用户可以有多个订单，多个订单归属一个用户
订单与用户是多对一关系，在订单实体类中增加User的属性

public class Orders {

    private Integer id; 
    private Integer userId;
    private String number;
    private Date createtime;
    private String note; 
    //用户信息
    private User user;
    。。。。。
}

映射文件

• Orders映射文件

在Orders的映射文件中，通过association 配置关联属性，此处不在配置User的各个属性映射
增加select 和 colum属性配置

select=”cn.com.model.UserDao.findUserById”
在association 中配置select属性，指定懒加载关联查询使用的statement，findUserById在user.xml中，所以此处加上命名空间
column=”user_id”
在association 中配置column属性，指定懒加载关联查询使用的statement中需要传入的值

<?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="cn.com.dao.OrdersDao"> 
    <resultMap type="cn.com.model.Orders" id="orderLazyUser">
        <id property="id" column="id" />
        <result property="userId" column="user_id" />
        <result property="number" column="number" />
        <result property="createtime" column="createtime" />
        <result property="note" column="note" />

        <association property="user" javaType="cn.com.model.User"
            select="cn.com.model.UserDao.findUserById" column="user_id">

        </association>
    </resultMap>
    <select id="findOrdersLazyLoadUser" resultMap="orderLazyUser">
        SELECT id,user_id,number,createtime,note  FROM  orders
    </select> 

</mapper>

• User映射文件

此处 的findUserById 在orders映射文件中使用到

<mapper namespace="cn.com.model.UserDao">
    <select id="findUserById" parameterType="int" resultType="cn.com.model.User">
        SELECT * FROM USER WHERE id=#{value}
    </select>
</mapper> 

测试类

@Test
    public void findOrdersLazyLoadUser() throws Exception{ 
        String resource = "sqlmapconfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrdersDao ordersDao = sqlSession.getMapper(OrdersDao.class);
        List<Orders> list = ordersDao.findOrdersLazyLoadUser();
        for(Orders orders:list){
            System.out.println(orders.getUser().getUsername());
        }
        sqlSession.close();
    }

此处在System.out.println(orders.getUser().getUsername());才会查询数据库，加载User的值

3. 查询缓存

Mybatis一级缓存的作用域是同一个SqlSession，在同一个sqlSession中两次执行相同的sql语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次会从缓存中获取数据将不再从数据库查询，从而提高查询效率。当一个sqlSession结束后该sqlSession中的一级缓存也就不存在了。Mybatis默认开启一级缓存。

Mybatis二级缓存是多个SqlSession共享的，其作用域是mapper的同一个namespace，不同的sqlSession两次执行相同namespace下的sql语句且向sql中传递参数也相同即最终执行相同的sql语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次会从缓存中获取数据将不再从数据库查询，从而提高查询效率。

3.1 一级缓存

一级缓存区域是根据SqlSession为单位划分的。
同一个SqlSession每次查询会先从缓存区域找，如果找不到再从数据库查询，查询到数据将数据写入缓存。下一次再次执行相同的查询时，则会从缓存中取出，不再查询数据库。
Mybatis内部存储缓存使用一个HashMap，key为hashCode+sqlId+Sql语句。value为从查询出来映射生成的java对象
sqlSession执行insert、update、delete等操作commit提交后会清空缓存区域。
一级缓存是SQLSession级别的缓存。默认是开启的。

- 测试一级缓存

    SqlSession session = sqlSessionFactory.openSession();
    //获限mapper接口实例
    UserMapper userMapper = session.getMapper(UserMapper.class);
    //第一次查询
    User user1 = userMapper.findUserById(1);
    System.out.println(user1);
    //第二次查询，由于是同一个session则不再向数据发出语句直接从缓存取出
    User user2 = userMapper.findUserById(1);
    System.out.println(user2);
    //关闭session
    session.close();

    SqlSession session = sqlSessionFactory.openSession();
    //获限mapper接口实例
    UserMapper userMapper = session.getMapper(UserMapper.class);
    //第一次查询
    User user1 = userMapper.findUserById(1);
    System.out.println(user1);
    //在同一个session执行更新
    user1 .setUsername("xxx");
    userMapper.updateUser(user1 );
    session.commit();
    //第二次查询，虽然是同一个session但是由于执行了更新操作session的缓存被清空，这里重新发出sql操作
    User user2 = userMapper.findUserById(1);
    System.out.println(user2);

3.2 二级缓存

二级缓存区域是根据mapper的namespace划分的，相同namespace的mapper查询数据放在同一个区域。
每一个namespace会有一个自己的二级缓存，不同的 namespace用不同的二级缓存。
二级缓存与一级缓存区别，二级缓存的范围更大，多个sqlSession可以共享一个UserMapper的二级缓存区域。
UserMapper有一个二级缓存区域（按namespace分） ，其它mapper也有自己的二级缓存区域（按namespace分）。
每次查询会先从缓存区域找，如果找不到从数据库查询，查询到数据将数据写入缓存
在SqlMapConfig.xml设置二级缓存的总开关默认是开启的，但是建议还是配置开启。

3.2.1 开启二级缓存

在核心配置文件SqlMapConfig.xml中加入

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

配置项	描述	允许值	默认值
cacheEnabled	对在此配置文件下的所有cache 进行全局性开/关设置	true，false	true

mybaits的二级缓存是mapper范围级别，除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存。
在UserMapper.xml中开启二缓存，UserMapper.xml下的sql执行完成会存储到它的缓存区域（HashMap）。

<mapper namespace="cn.com.dao.OrdersDao"> 
    <!-- 开启本 mapper的 namespace下的二级缓存-->
    <cache type=""/>

type指定实现mybatis cache 接口的实现类 类名，默认是org.apache.ibatis.cache.impl.PerpetualCache

3.2.2 pojo类实现序列化接口

为了将缓存数据取出执行反序列化操作，因为二级缓存数据存储介质多种多样，不一样在内存。

public class Orders implements Serializable{
    private Integer id; 
    private Integer userId;
    private String number;
    private Date createtime;
    private String note; 
    //用户信息
    private User user;
    。。
}

3.2.3 测试1

String resource = "sqlmapconfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(inputStream);
        SqlSession sqlSession1 = sqlSessionFactory.openSession();
        OrdersDao ordersDao1 = sqlSession1.getMapper(OrdersDao.class);
        //第一次查询，缓存中没数据，请求数据库查询
        Orders  orders1 = ordersDao1.findById(3);
        //sqlsession关闭
        sqlSession1.close();

        SqlSession sqlSession2 = sqlSessionFactory.openSession();
        OrdersDao ordersDao2 = sqlSession2.getMapper(OrdersDao.class);
        //第二次查询，缓存中有数据，从缓存中取出数据，不再请求数据库查询
        Orders  orders2 = ordersDao2.findById(3);
        sqlSession2.close();

3.2.4 测试2

    String resource = "sqlmapconfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(inputStream);
        SqlSession sqlSession1 = sqlSessionFactory.openSession();
        OrdersDao ordersDao1 = sqlSession1.getMapper(OrdersDao.class);
        //第一次查询，缓存中没数据，请求数据库查询
        Orders  orders1 = ordersDao1.findById(3);
        //sqlsession关闭
        sqlSession1.close();

        SqlSession sqlSession3 = sqlSessionFactory.openSession();
        OrdersDao ordersDao3 = sqlSession3.getMapper(OrdersDao.class);
        //第二次查询，缓存中有数据，从缓存中取出数据，不再请求数据库查询
        Orders  orders3 = ordersDao3.findById(3);
        orders3.setCreatetime(new Date());
        ordersDao3.updateOrder(orders3);
        sqlSession3.commit();
        //执行提交，清空OrderMapper下边的二级缓存,防止脏读
        sqlSession3.close();

        SqlSession sqlSession2 = sqlSessionFactory.openSession();
        OrdersDao ordersDao2 = sqlSession2.getMapper(OrdersDao.class);
        //第三次查询，缓存中没有数据，请求数据库查询
        Orders  orders2 = ordersDao2.findById(3);
        sqlSession2.close();

3.2.5 特定查询禁用二级缓存（useCache配置）

在statement中设置useCache=false可以禁用当前select语句的二级缓存，即每次查询都会发出sql去查询，默认情况是true，即该sql使用二级缓存。

<select id="findById" useCache="false" parameterType="int" resultMap="orderLazyUser">

3.2.6 刷新缓存（清空缓存）

在mapper的同一个namespace中，如果有其它insert、update、delete操作数据后需要刷新缓存，如果不执行刷新缓存会出现脏读。

设置statement配置中的flushCache=”true” 属性，默认情况下为true即刷新缓存，如果改成false则不会刷新。使用缓存时如果手动修改数据库表中的查询数据会出现脏读。
一般下执行完commit操作都需要刷新缓存，flushCache=true表示刷新缓存，这样可以避免数据库脏读。

3.3 mybatis整合ehcache

ehcache是一个分布式缓存框架。我们系统为了提高系统并发，性能、一般对系统进行分布式部署（集群部署方式）
不使用分布缓存，缓存的数据在各各服务单独存储，不方便系统 开发。所以要使用分布式缓存对缓存数据进行集中管理。
mybatis无法实现分布式缓存，需要和其它分布式缓存框架进行整合。

3.3.1 整合原理

mybatis提供了一个cache接口，如果要实现自己的缓存逻辑，实现cache接口开发即可。

package org.apache.ibatis.cache;
import java.util.concurrent.locks.ReadWriteLock;
public interface Cache {
    String getId(); 
    void putObject(Object key, Object value); 
    Object getObject(Object key); 
    Object removeObject(Object key); 
    void clear(); 
    int getSize(); 
    ReadWriteLock getReadWriteLock(); 
}

mybatis默认实现cache类是：

package org.apache.ibatis.cache.impl;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;

import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.cache.CacheException;

/**
 * @author Clinton Begin
 */
public class PerpetualCache implements Cache {

  private String id;

  private Map<Object, Object> cache = new HashMap<Object, Object>();

  public PerpetualCache(String id) {
    this.id = id;
  }

  public String getId() {
    return id;
  }

  public int getSize() {
    return cache.size();
  }

  public void putObject(Object key, Object value) {
    cache.put(key, value);
  }

  public Object getObject(Object key) {
    return cache.get(key);
  }

  public Object removeObject(Object key) {
    return cache.remove(key);
  }

  public void clear() {
    cache.clear();
  }

  public ReadWriteLock getReadWriteLock() {
    return null;
  }

  public boolean equals(Object o) {
    if (getId() == null) throw new CacheException("Cache instances require an ID.");
    if (this == o) return true;
    if (!(o instanceof Cache)) return false;

    Cache otherCache = (Cache) o;
    return getId().equals(otherCache.getId());
  }

  public int hashCode() {
    if (getId() == null) throw new CacheException("Cache instances require an ID.");
    return getId().hashCode();
  } 
}

3.3.2 加入ehcache包

下载地址：http://download.csdn.net/detail/hxskmx/8802683

ehcache实现mybatis cache接口 实现类

3.3.3 mybatis整合ehcache

配置mapper中cache中的type为ehcache对cache接口的实现类型。

<mapper namespace="cn.congxing.model.User"> 
    <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

3.3.4 加入ehcache的配置文件

在classpath下配置ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <diskStore path="F:\develop\ehcache" />
    <defaultCache 
        maxElementsInMemory="1000" 
        maxElementsOnDisk="10000000"
        eternal="false" 
        overflowToDisk="false" 
        timeToIdleSeconds="120"
        timeToLiveSeconds="120" 
        diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

4. generator代码生成

4.1 下载generator

http://download.csdn.net/detail/hxskmx/8802897

4.2 配置文件

generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <context id="testTables" targetRuntime="MyBatis3">
        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>

        <!--数据库连接的信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root"   password="123">
        </jdbcConnection>

        <!-- <jdbcConnection driverClass="oracle.jdbc.OracleDriver"
            connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:orcl" userId="demo" password="demo">
        </jdbcConnection> -->

        <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和 
            NUMERIC 类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- targetProject:生成PO类的位置 -->
        <javaModelGenerator targetPackage="cn.congxing.model"
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="cn.congxing.model" 
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetPackage：mapper接口生成的位置 -->
        <javaClientGenerator type="XMLMAPPER"
            targetPackage="cn.congxing.dao" 
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>
        <!-- 指定数据库表 -->
        <table tableName="items"></table>
        <table tableName="orders"></table>
        <table tableName="orderdetail"></table>
        <table tableName="user"></table>
        <!-- <table schema="" tableName="sys_user"></table>
        <table schema="" tableName="sys_role"></table>
        <table schema="" tableName="sys_permission"></table>
        <table schema="" tableName="sys_user_role"></table>
        <table schema="" tableName="sys_role_permission"></table> -->

        <!-- 有些表的字段需要指定java类型
         <table schema="" tableName="">
            <columnOverride column="" javaType="" />
        </table> -->
    </context>
</generatorConfiguration>

4.3 生成代码

package cn.congxing.test; 

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;

public class GeneratorSqlmap {

    public void generator() throws Exception{

        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        //指定 逆向工程配置文件
        File configFile = new File("config/generatorConfig.xml"); 
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
                callback, warnings);
        myBatisGenerator.generate(null);

    } 
    public static void main(String[] args) throws Exception {
        try {
            GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
            generatorSqlmap.generator();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}