MyBatis总结

<cache type="org.apache.ibatis.cache.impl.PerpetualCache"
      size="1024"
      eviction="LRU"
      flushInterval="120000"
      readOnly="false"/>

flushInterval: 可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新   
size: 属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024
readOnly:（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。 速度上会慢一些，但是更安全，因此默认值是 false。
      
二级缓存是事务性的。这意味着，当 SqlSession 完成并提交时，或是完成并回滚，但没有执行 flushCache=true 的 insert/delete/update 语句时，缓存会获得更新。      
Mapper.xml 配置了<cache>之后，select()会被缓存。update()、delete()、insert()会刷新缓存。：如果cacheEnabled=true，Mapper.xml 没有配置标签，还有二级缓存吗？（没有）还会出现CachingExecutor 包装对象吗？（会）
只要cacheEnabled=true 基本执行器就会被装饰。有没有配置<cache>，决定了在启动的时候会不会创建这个mapper 的Cache 对象，只是最终会影响到CachingExecutorquery 方法里面的判断。如果某些查询方法对数据的实时性要求很高，不需要二级缓存，怎么办？我们可以在单个Statement ID 上显式关闭二级缓存（默认是true）      

<select id="selectBlog" resultMap="BaseResultMap" useCache="false">

为什么事务不提交，二级缓存不生效？因为二级缓存使用TransactionalCacheManager（TCM）来管理，最后又调用了TransactionalCache 的getObject()、putObject 和commit()方法，TransactionalCache里面又持有了真正的Cache对象，比如是经过层层装饰的PerpetualCache。在putObject 的时候
只是添加到了entriesToAddOnCommit 里面，只有它的commit()方法被调用的时候才会调用flushPendingEntries()真正写入缓存。它就是在DefaultSqlSession调用commit()的时候被调用的

<cache-ref namespace="com.wuzz.crud.dao.DepartmentMapper" />

# 自定义分页信息
public class MyPage {
    private Integer currentPage;    //当前页是第几页
    private Integer pageSize;       //每页的大小
    //省略set、get...
}

# 自定义拦截器
//表示拦截StatementHandler类的prepare方法
@Intercepts({@Signature(type = StatementHandler.class,method = "prepare",args = {Connection.class,Integer.class})})
public class MyPageInterceptor implements Interceptor{
 
    private Integer defaultPageSize;     //默认每页的大小
    private Integer defaultCurrentPage;  //默认页数
    //实现拦截逻辑
    public Object intercept(Invocation invocation) throws Throwable {
        //获取目标对象
        StatementHandler  statementHandler = (StatementHandler) invocation.getTarget();
        //获取元数据
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
        //获取绑定的sql
        BoundSql boundSql = (BoundSql) metaObject.getValue("delegate.boundSql");
        //获取参数对象
        Object parameterObject = boundSql.getParameterObject();
        //获取传入分页参数
        MyPage myPage = this.getPage(parameterObject);
        String sql = (String) metaObject.getValue("delegate.boundSql.sql");
        boolean isSelect = sql.trim().toLowerCase().startsWith("select");
        //如果不是查询语句，则直接进入下一个操作
        if(!isSelect){
            return invocation.proceed();
        }
        System.out.println("原来的sql："+sql);
        //修改sql
        String page_sql = "select * from ("+sql+") page_table limit ?,?";
        //设置修改过的sql
        metaObject.setValue("delegate.boundSql.sql",page_sql);
        //如果没有传入相应的分页参数，则设置为默认值
        if (myPage.getCurrentPage() == null){
            //设置默认值
            myPage.setCurrentPage(this.defaultCurrentPage);
        }
        if (myPage.getPageSize() == null){
            //设置默认值
            myPage.setPageSize(this.defaultPageSize);
        }
        //获取参数
        PreparedStatement ps = (PreparedStatement) invocation.proceed();
        // 获取sql的总参数个数
        int paramCount = ps.getParameterMetaData().getParameterCount();
        // 设置分页参数
        ps.setInt(paramCount - 1, (myPage.getCurrentPage() - 1) * myPage.getPageSize());
        ps.setInt(paramCount, myPage.getPageSize());
        return ps;
    }
 
    //返回被拦截对象的代理对象
    public Object plugin(Object target) {
        System.out.println("开始包装目标对象");
        return Plugin.wrap(target,this);
    }
 
    //设置插件配置的参数
    public void setProperties(Properties properties) {
        this.defaultCurrentPage = Integer.valueOf(properties.getProperty("default.currentPage", "1"));
        this.defaultPageSize = Integer.valueOf(properties.getProperty("default.pageSize", "3"));
    }
 
 
    /**
     * 获取分页参数
     *
     * @param parameterObject
     * @return
     */
    private MyPage getPage(Object parameterObject) {
        if (parameterObject == null) {
            return null;
        }
 
        if (parameterObject instanceof Map) {
            // 如果传入的参数是map类型的，则遍历map取出Page对象
            Map<String, Object> parameMap = (Map<String, Object>) parameterObject;
            Set<String> keySet = parameMap.keySet();
            for (String key : keySet) {
                Object value = parameMap.get(key);
                if (value instanceof MyPage) {
                    // 返回MyPage对象
                    return (MyPage) value;
                }
            }
        } else if (parameterObject instanceof MyPage) {
            // 如果传入的是Page类型，则直接返回该对象
            return (MyPage) parameterObject;
        }
 
        // 初步判断并没有传入MyPage类型的参数，返回null
        return null;
    }   
}

# mybatis的主配置文件mybatis-config.xml中
<plugins>
  <!--配置插件-->
  <plugin interceptor="com.qxf.interceptor.MyPageInterceptor">
      <!-- 给插件传值，一般是默认值-->
      <property name="default.currentPage" value="1"></property>
      <property name="default.pageSize" value="5"></property>
  </plugin>
</plugins>

public class Teacher {
    private int id;
    private String name;
}


public class Student {
    private int id;
    private String name;
    //多个学生可以是同一个老师，即多对一
    private Teacher teacher;
}


association:

<mapper namespace="com.ttt.mapper.StudentMapper">

    <select id="getStudents" resultMap="StudentTeacher">
      select * from student
    </select>
    <resultMap id="StudentTeacher" type="Student">
        <!--association关联属性  property属性名 javaType属性类型 column在多的一方的表中的列名-->
        <association property="teacher"  column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
    <!--
    这里传递过来的id，只有一个属性的时候，下面可以写任何值
    association中column多参数配置：
        column="{key=value,key=value}"
        其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。
    -->
    <select id="getTeacher" resultType="teacher">
        select * from teacher where id = #{id}
    </select>

</mapper>





collection:

<mapper namespace="com.ttt.mapper.TeacherMapper">
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid, s.name sname , t.name tname, t.id tid
        from student s,teacher t
        where s.tid = t.id and t.id=#{id}
    </select>

    <resultMap id="TeacherStudent" type="Teacher">
        <result  property="name" column="tname"/>
        <collection property="students" ofType="Student">
            <result property="id" column="sid" />
            <result property="name" column="sname" />
            <result property="tid" column="tid" />
        </collection>
    </resultMap>
</mapper>

关联查询：SELECT orders.*, user.username FROM orders, USER WHERE orders.user_id = user.id
延迟加载相当于：
SELECT orders.*,
(SELECT username FROM USER WHERE orders.user_id = user.id)username FROM orders

思路：
1. 只查询订单信息的statement，使用resultMap
2. 通过查询到的订单信息中的user_id去查询用户信息的statement，得到用户
3. 定义的resultMap将两者关联起来，即用订单信息user_id去查用户

实现：
1. 只查询订单信息的statement

<select id="findOrdersUserLazyLoading" resultMap="OrdersUserLazyLoadingResultMap">
    SELECT * FROM orders
</select>

2. 只查询用户信息的statement
# 此mapper可以与上面不再同一文件中
# 若在不同，在下一步配置resultMap添加延迟加载代码的时候需在select中指定
<select id="findUserById" parameterType="int" resultType="user">
    select * from user where id = #{id}
</select>

3. 延迟加载的 resultMap

<resultMap type="mybatis.po.Orders" id="OrderUserLazyResultMap">
    <id column="id" property="id" />
    <id column="user_id" property="userId" />
    <id column="order_name" property="orderName" />
    
    # 延迟加载实现方式
    # select : 指定延迟加载需要执行的statement的id
    # column : 订单信息中关联用户信息查询的列
    <association property="user" javaType="mybatis.po.User"
        select="mybatis.mapper.UserMapper.findUserById" column="user_id">
    
    </association>
</resultMap>

4. 配置开启延迟加载
mybatis默认没有开启延迟加载，需要在SqlMapConfig.xml中setting配置

<settings>
    <!-- 打开延迟加载的开关 -->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!-- 将积极加载改为消极加载，即延迟加载 -->
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>