[Java知识库]二、Mybatis

二、mybatis

2.1 概述

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录

2.2 快速上手

maven

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>x.x.x</version>
</dependency>

<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>${mysql.version}</version>
</dependency>

配置文件

创建mybatis-conf.xml配置文件,名称可以随意

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="jdbc"/>
            <dataSource type="pooled">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://192.168.141.138:3306/demo"/>
                <property name="username" value="root"/>
                <property name="password" value="XXX"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

获取连接对象

注意:这里获取SqlSessionFactory的方式为建造者模式,mybatis提供了多种配置模式,如xml文件或java api

        //mybatis xml 配置
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-conf.xml");

        //创建SqlSessionFactoryBuilder对象,通过建造者模式构建SqlSessionFactory
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(resourceAsStream);

        //获取数据库连接对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        System.out.println(sqlSession);

2.3 mybatis核心组件

• SqlSessionFactoryBuilder: 构造器,根据配置或者代码的方式获取SqlSessionFactory
• SqlSessionFactory: 生产SqlSession的工厂
• SqlSession: 会话,既可以发送sql获取执行结果也可以获取mapper的接口,在我们实际开发中可能并不常用,我们更多的是使用mybatis提供的sql mapper接口编程技术
• sql mapper:映射器,由一个java接口和xml或注解构成,负责发送sql去执行并返回结果

SqlSessionFactory

会话工厂

使用mybatis的时候首先是通过配置去生产SqlSessionFactory,它是由SqlSessionFactoryBuilder来构建的,其中通过Configuration作为配置引导

在mybatis中我们既可以通过xml的方式来配置,也可以通过代码的方式来配置(不常用), 在SqlSessionFactoryBuilder.build中mybatis会读取配置文件,通过Configuration对象去构建整个mybatis的上下文

SqlSessionFactory是一个接口,它有两个实现类分别为DefaultSqlSessionFactory和SqlSessionManager,前者是默认使用的单线程中使用,后者则是在多线程环境下使用,因为SqlSessionFactory的唯一职责就是生产SqlSession,我们一般会使用单例来处理它

SqlSession

会话

在mybatis中sqlSession是核心接口,它的两个实现类分别为DefaultSqlSession(单线程)和SqlSessionManager(多线程),其主要作用有以下三点

• 获取Mapper接口

  sqlSession.getMapper(StudentMapper.class);
  

• 发送Sql给数据库

• 控制数据库事务

  sqlSession.commit();
  sqlSession.rollback();
  

SqlSession只是一个门面接口,它有很多方法,可以直接发送sql,它就好像一家软件公司的商务人员,实际干活的是工程师,在mybatis中真正干活的是Executor(我们会在后面看到它)

演示

使用后一定记得关闭会话,否则数据库连接资源很快就会被耗尽,整个系统就会进入瘫痪状态!

        SqlSession sqlSession = sqlSessionFactory.openSession();
        try{
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
            //自定义mapper,这里为了演示
            mapper.createStudent(Student);
            sqlSession.commit();
        } catch (Exception ex) {
            sqlSession.rollback();
        }finally {
            sqlSession.close();
        }

Sql Mapper

映射器

映射器是mybatis中最重要也是最复杂的组件,它由一个接口和对应的xml文件(或者注解)组成,包含以下内容:

• 描述映射规则
• 提供sql语句,并可以配置sql参数类型,返回类型,缓存刷新等信息
• 配置缓存
• 提供动态sql

定义POJO

@Data
public class Student {
    private String id;
    private String studentName;
    private Integer studentAge;
    private String studentNo;
}

映射器

包含两部分: 接口和xml文件

StudentMapper接口

public interface StudentMapper {

    List<Student> queryList();
}

StudentMapper映射文件(xml)

注意:需要在mybatis的配置文件中添加该映射文件

    <mappers>
        <!--我这里映射文件在mappers文件夹中定义的,结合实际填写-->
        <mapper resource="mappers/StudentMapper.xml"/>
    </mappers>

<?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" >

<!--命名空间,namespace代表mapper接口包名+接口名-->
<mapper namespace="com.jx.jdbc.mapper.StudentMapper">

    <!--接口方法 id:标识了该sql与方法名相同,resultType:返回值类型-->
    <select id="queryList" resultType="com.jx.jdbc.entity.Student">
        select
        *
        from
        student
    </select>
</mapper>

xml文件发送SQL

参数是一个String类型的对象(由一个命名空间加上SQL id组合而成),它完全定位了一条SQL,这样Mybatis就能找到对应的SQL了,当然sqlSession发送sql的多态方法很多可以自行查看源码即可

List<Student> students = sqlSession.selectList("com.jx.jdbc.mapper.StudentMapper.queryList");
System.out.println(students);

Mapper接口发送Sql

通过SqlSession的getMapper方法来获取一个mapper接口就可以调用其方法了,因为XML文件可以通过 命名空间和方法名查找对应的sql

StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
//自定义mapper,这里为了演示
List<Student> students = mapper.queryList();

2.4 生命周期

生命周期是组件的重要问题,尤其是在多线程环境中,错误的使用会造成严重的多线程并发问题

SqlSessionFactoryBuilder

它的作用就是构建SqlSessionFactory,构建完成后就失去了作用,我们不应让它长期存在

SqlSessionFactory

可以被认为是数据库连接池,它必须贯穿整个mybatis应用,应长期保存

SqlSession

用于处理一个业务请求,处理完毕后必须将其关闭,否则会长期占用资源最终导致系统瘫痪

Mapper

它是位SqlSession提供服务的,所以它存在的时间必须小于或等于SqlSession

2.5 配置

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下

• configuration（配置）
  • properties（属性）
  • settings（设置）
  • typeAliases（类型别名）
  • typeHandlers（类型处理器）
  • objectFactory（对象工厂）
  • plugins（插件）
  • environments（环境配置）
    • environment（环境变量）
      • transactionManager（事务管理器）
      • dataSource（数据源）
  • databaseIdProvider（数据库厂商标识）
  • mappers（映射器）

properties

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。例如

<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="dev_user"/>
  <property name="password" value="F2Fa3!33TYyg"/>
</properties>

设置好的属性可以在整个配置文件中用来替换需要动态配置的属性值。比如:

<dataSource type="POOLED">
  <property name="driver" value="${driver}"/>
  <property name="url" value="${url}"/>
  <property name="username" value="${username}"/>
  <property name="password" value="${password}"/>
</dataSource>

这个例子中的 username 和 password 将会由 properties 元素中设置的相应值来替换。 driver 和 url 属性将会由 config.properties 文件中对应的值来替换。这样就为配置提供了诸多灵活选择。

也可以在 SqlSessionFactoryBuilder.build() 方法中传入属性值。例如：

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, props);
// ... 或者 ...
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment, props);

如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：

• 首先读取在 properties 元素体内指定的属性。
• 然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。
• 最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。

settings

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。

typeAliases

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
  <typeAlias alias="Comment" type="domain.blog.Comment"/>
  <typeAlias alias="Post" type="domain.blog.Post"/>
  <typeAlias alias="Section" type="domain.blog.Section"/>
  <typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如

<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author；若有注解，则别名为其注解值。见下面的例子：

@Alias("author")
public class Author {
    ...
}

下面是一些为常见的 Java 类型内建的类型别名。它们都是不区分大小写的，注意，为了应对原始类型的命名重复，采取了特殊的命名风格

typeHandlers

MyBatis 在设置预处理语句（PreparedStatement）中的参数或从结果集中取出一个值时， 都会用类型处理器将获取到的值以合适的方式转换成 Java 类型。下表描述了一些默认的类型处理器。

提示 从 3.4.5 开始，MyBatis 默认支持 JSR-310（日期和时间 API） 。

你可以重写已有的类型处理器或创建你自己的类型处理器来处理不支持的或非标准的类型。 具体做法为：实现 org.apache.ibatis.type.TypeHandler 接口， 或继承一个很便利的类 org.apache.ibatis.type.BaseTypeHandler， 并且可以（可选地）将它映射到一个 JDBC 类型。比如：

@MappedTypes(String.class)
@MappedJdbcTypes(JdbcType.VARCHAR)
public class GenderTypeHandler extends BaseTypeHandler<String> {
    @Override
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, String parameter, JdbcType jdbcType) throws SQLException {
        System.out.println("自定义TypeHandler 设置参数");
        preparedStatement.setString(i,parameter);
    }

    @Override
    public String getNullableResult(ResultSet resultSet, String columnName) throws SQLException {
        System.out.println("自定义TypeHandler 根据列名获取值");
        return resultSet.getString(columnName);
    }

    @Override
    public String getNullableResult(ResultSet resultSet, int columnIndex) throws SQLException {
        System.out.println("自定义TypeHandler 根据列下标获取值");
        return resultSet.getString(columnIndex);
    }

    @Override
    public String getNullableResult(CallableStatement callableStatement, int columnIndex) throws SQLException {
        return null;
    }
}

<!-- mybatis-config.xml -->
<typeHandlers>
  <package name="com.jx.jdbc.typehandler"/>
</typeHandlers>
或
<typeHandlers>
  <typeHandler handler="com.jx.jdbc.typehandler.GenderTypeHandler"/>
</typeHandlers>

使用自定义typeHandler

<select id="queryOne" resultType="com.jx.jdbc.entity.Student">
    select
    *
    from
    student
    where
    id = #{id,typeHandler=com.jx.jdbc.typehandler.GenderTypeHandler}
</select>

使用上述的类型处理器将会覆盖已有的处理 Java String 类型的属性以及 VARCHAR 类型的参数和结果的类型处理器。 要注意 MyBatis 不会通过检测数据库元信息来决定使用哪种类型，所以你必须在参数和结果映射中指明字段是 VARCHAR 类型， 以使其能够绑定到正确的类型处理器上。这是因为 MyBatis 直到语句被执行时才清楚数据类型。

通过类型处理器的泛型，MyBatis 可以得知该类型处理器处理的 Java 类型，不过这种行为可以通过两种方法改变：

• 在类型处理器的配置元素（typeHandler 元素）上增加一个 javaType 属性（比如：javaType=“String”）；
• 在类型处理器的类上增加一个 @MappedTypes 注解指定与其关联的 Java 类型列表。 如果在 javaType 属性中也同时指定，则注解上的配置将被忽略。

可以通过两种方式来指定关联的 JDBC 类型：

• 在类型处理器的配置元素上增加一个 jdbcType 属性（比如：jdbcType=“VARCHAR”）；
• 在类型处理器的类上增加一个 @MappedJdbcTypes 注解指定与其关联的 JDBC 类型列表。 如果在 jdbcType 属性中也同时指定，则注解上的配置将被忽略。

当在 ResultMap 中决定使用哪种类型处理器时，此时 Java 类型是已知的（从结果类型中获得），但是 JDBC 类型是未知的。 因此 Mybatis 使用 javaType=[Java 类型], jdbcType=null 的组合来选择一个类型处理器。 这意味着使用 @MappedJdbcTypes 注解可以限制类型处理器的作用范围，并且可以确保，除非显式地设置，否则类型处理器在 ResultMap 中将不会生效。 如果希望能在 ResultMap 中隐式地使用类型处理器，那么设置 @MappedJdbcTypes 注解的 includeNullJdbcType=true 即可。 然而从 Mybatis 3.4.0 开始，如果某个 Java 类型只有一个注册的类型处理器，即使没有设置 includeNullJdbcType=true，那么这个类型处理器也会是 ResultMap 使用 Java 类型时的默认处理器。

objectFactory

每次 MyBatis 创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成实例化工作。 默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认无参构造方法，要么通过存在的参数映射来调用带有参数的构造方法。 如果想覆盖对象工厂的默认行为，可以通过创建自己的对象工厂来实现。比如：

public class ExampleObjectFactory extends DefaultObjectFactory {
  public Object create(Class type) {
    return super.create(type);
  }
  public Object create(Class type, List<Class> constructorArgTypes, List<Object> constructorArgs) {
    return super.create(type, constructorArgTypes, constructorArgs);
  }
  public void setProperties(Properties properties) {
    super.setProperties(properties);
  }
  public <T> boolean isCollection(Class<T> type) {
    return Collection.class.isAssignableFrom(type);
  }}

<!-- mybatis-config.xml -->
<objectFactory type="org.mybatis.example.ExampleObjectFactory">
  <property name="someProperty" value="100"/>
</objectFactory>

ObjectFactory 接口很简单，它包含两个创建实例用的方法，一个是处理默认无参构造方法的，另外一个是处理带参数的构造方法的。 另外，setProperties 方法可以被用来配置 ObjectFactory，在初始化你的 ObjectFactory 实例后， objectFactory 元素体中定义的属性会被传递给 setProperties 方法。

mappers

既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。例如：

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

<!-- 使用完全限定资源定位符（URL） -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

<!-- 使用映射器接口实现类的完全限定类名,注意这种形式必须保正接口名和xml名一致并且在同一个包下 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

<!-- 将包内的映射器接口实现全部注册为映射器,注意这种形式必须保正接口名和xml名一致并且在同一个包下 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

这些配置会告诉 MyBatis 去哪里找映射文件

2.6 日志

Mybatis 通过使用内置的日志工厂提供日志功能。内置日志工厂将会把日志工作委托给下面的实现之一：

• SLF4J
• Apache Commons Logging
• Log4j 2
• Log4j (deprecated since 3.5.9)
• JDK logging

MyBatis 内置日志工厂基于运行时自省机制选择合适的日志工具。它会使用第一个查找得到的工具（按上文列举的顺序查找）。如果一个都未找到，日志功能就会被禁用。

不少应用服务器（如 Tomcat 和 WebShpere）的类路径中已经包含 Commons Logging，所以在这种配置环境下的 MyBatis 会把它作为日志工具，记住这点非常重要。这将意味着，在诸如 WebSphere 的环境中，它提供了 Commons Logging 的私有实现，你的 Log4J 配置将被忽略。MyBatis 将你的 Log4J 配置忽略掉是相当令人郁闷的（事实上，正是因为在这种配置环境下，MyBatis 才会选择使用 Commons Logging 而不是 Log4J）。如果你的应用部署在一个类路径已经包含 Commons Logging 的环境中，而你又想使用其它日志工具，你可以通过在 MyBatis 配置文件 mybatis-config.xml 里面添加一项 setting 来选择别的日志工具

<configuration>
  <settings>
    ...
    <setting name="logImpl" value="LOG4J"/>
    ...
  </settings>
</configuration>

logImpl 可选的值有：SLF4J、LOG4J、LOG4J2、JDK_LOGGING、COMMONS_LOGGING、STDOUT_LOGGING、NO_LOGGING，或者是实现了接口 org.apache.ibatis.logging.Log 的，且构造方法是以字符串为参数的类的完全限定名。（译者注：可以参考org.apache.ibatis.logging.slf4j.Slf4jImpl.java的实现）你也可以调用如下任一方法来使用日志工具：

org.apache.ibatis.logging.LogFactory.useSlf4jLogging();
org.apache.ibatis.logging.LogFactory.useLog4JLogging();
org.apache.ibatis.logging.LogFactory.useJdkLogging();
org.apache.ibatis.logging.LogFactory.useCommonsLogging();
org.apache.ibatis.logging.LogFactory.useStdOutLogging();

2.7 XML映射器

Select

<select
  id="selectPerson"
  parameterType="int"
  parameterMap="deprecated"
  resultType="hashmap"
  resultMap="personResultMap"
  flushCache="false"
  useCache="true"
  timeout="10"
  fetchSize="256"
  statementType="PREPARED"
  resultSetType="FORWARD_ONLY">

insert/update/delete

keyProperty/keyColumn属性:对于自增数据运行在标签中设置,对于不是自增的设计,需要单独使用

<selectKey keyProperty="id" resultType="int" order="BEFORE">
 select CAST(RANDOM()*1000000 as INTEGER) a from SYSIBM.SYSDUMMY1
 insert into XXX ...
</selectKey>

<insert
  id="insertAuthor"
  parameterType="domain.blog.Author"
  flushCache="true"
  statementType="PREPARED"
  keyProperty=""
  keyColumn=""
  useGeneratedKeys=""
  timeout="20">

<update
  id="updateAuthor"
  parameterType="domain.blog.Author"
  flushCache="true"
  statementType="PREPARED"
  timeout="20">

<delete
  id="deleteAuthor"
  parameterType="domain.blog.Author"
  flushCache="true"
  statementType="PREPARED"
  timeout="20">

insert/update/delete标签属性

selectKey属性

sql

这个元素可以用来定义可重用的 SQL 代码片段，以便在其它语句中使用。 参数可以静态地（在加载的时候）确定下来，并且可以在不同的 include 元素中定义不同的参数值。比如：

<sql id="userColumns"> ${alias}.id,${alias}.username,${alias}.password </sql>

这个 SQL 片段可以在其它语句中使用，例如：

<select id="selectUsers" resultType="map">
  select
    <include refid="userColumns"><property name="alias" value="t1"/></include>,
    <include refid="userColumns"><property name="alias" value="t2"/></include>
  from some_table t1
    cross join some_table t2
</select>

结果映射

resultMap

• constructor
  • idArg: ID 参数；标记出作为 ID 的结果可以帮助提高整体性能
  • arg - 将被注入到构造方法的一个普通结果
• id: 一个 ID 结果；标记出作为 ID 的结果可以帮助提高整体性能
• result: 注入到字段或 JavaBean 属性的普通结果
• association: 一个复杂类型的关联；许多结果将包装成这种类型嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用
• collection: 一个复杂类型的集合嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用
• discriminator: 使用结果值来决定使用哪个 resultMap
  • case:基于某些值的结果映射

自动映射

在简单的场景下，MyBatis 可以为你自动映射查询结果(resultType),在复杂场景我们需要构建结果映射(resultMap),两种可以混合使用

当自动映射查询结果时，MyBatis 会获取结果中返回的列名并在 Java 类中查找相同名字的属性（忽略大小写）。 这意味着如果发现了 ID 列和 id 属性，MyBatis 会将列 ID 的值赋给 id 属性。

注意: 需要开启mybatis的驼峰命名

<resultMap id="userResultMap" type="User">
  <result property="password" column="hashed_password"/>
</resultMap>

<select id="selectUsers" resultMap="userResultMap">
  select
    user_id             as "id",
    user_name           as "userName",
    hashed_password
  from some_table
  where id = #{id}
</select>

在这种情况下,对于每一个结果映射，在 ResultSet 出现的列，如果没有设置手动映射，将被自动映射。在自动映射处理完毕后，再处理手动映射。 在下面的例子中，id 和 userName 列将被自动映射，hashed_password 列将根据配置进行映射。

缓存

Mybatis缓存等级分为一级缓存与二级缓存,一级缓存默认开启SqlSession上的缓存,二级缓存则是SqlSessionFactory上的缓存

测试一级缓存

// ...
StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
//测试获取ID为0df529fa-8136-43a3-9b89-e8289bcdf9e6的结果,查询两次
Student student = mapper.queryOne("0df529fa-8136-43a3-9b89-e8289bcdf9e6");
log.info(student.toString());
student = mapper.queryOne("0df529fa-8136-43a3-9b89-e8289bcdf9e6");
log.info(student.toString());
//...

虽然代码对同一个对象进行了两次获取,但是实际只有一条SQL被执行,其原因就是使用了同一个SqlSession,当一个会话第一次通过SQL和参数获取对象后,它将会被缓存起来,如果下次的SQL和参数没有变化并且缓存没有超时或者生声明需要刷新时,那么它就会从缓存中获取数据,而不是通过SQL获取

开启二级缓存

需要在SQL映射文件中(XXXMapper.xml)添加 <cache/>,并且实体类必须序列化(Serializable)且执行的sql需要commit才会生效,这个语句会产生如下效果

注意: 必须commit才会缓存到SqlSessionFactory上被共享!

• 映射语句文件中的所有 select 语句的结果将会被缓存。
• 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
• 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
• 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
• 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
• 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

<cache
  eviction="FIFO" //清除策略 LRU:移除最长时间不被使用的对象。FIFO:先进先出：按对象进入缓存的顺序来移除它们。SOFT:软引用：基于垃圾回收器状态和软引用规则移除对象。WEAK:弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象
  flushInterval="60000" //刷新时间
  size="512" //最多可以存储结果对象或列表的引用
  readOnly="true"/> //是否只读