Github Mybatis深入学习之映射器XML

       mapper.xml文件的配置是mybatis实体对象和查询接口封装SQL操作的配置文件，其中还包括了查询、修改和删除等操作，并且包含对象的关联映射、数据集合的关联映射、以及对象的缓存设置和缓存引用等操作，了解这些对手动设置和学习对象的关系很有帮助。

 MyBatis的真正的力量是在映射语句。这是奇迹发生的地方。对于所有的力量，映射XML文件相对简单。当然如果你比较它们相当于JDBC代码，你会立即看到节省了95％的代码。MyBatis的构建就是聚焦于SQL的，它最好留出自己的方式。原文地址：http://mybatis.github.io/mybatis-3/sqlmap-xml.html

映射XML文件只有几个一流的元素（它们应该被定义的顺序）：

• cache -配置给定命名空间的缓存。
• cache-ref -缓存配置从另一个命名空间的参考。
• resultMap -最复杂，最强大的元素，介绍了如何将你的对象从数据库结果集。
• parameterMap的 -已过时！老派的参数映射。内联参数是优选的，这些元素在将来可能会被删除。这里没有记录。
• sql -可以重用的SQL块，也可以被其他语句引用。
• insert -一个映射INSERT语句。
• update -映射的UPDATE语句。
• delete -映射DELETE语句。
• select -一个映射的SELECT语句。

select语句是您使用MyBatis最流行的元素之一。把数据库中有价值的数据筛选，直到帮你把它找回来，所以许多应用程序查询远远超过他们修改数据。对于每次插入，更新或者删除，有许多选择。查询是MyBatis的构建原则之一，原因是这么多的重点和精力放在查询和结果映射，查询元素是非常简单的。例如：

<select id="selectPerson" parameterType="int" resultType="hashmap">
SELECT * FROM PERSON WHERE ID = #{id}
</select>

这条语句被称作selectPerson的，需要一个参数类型为int（或Integer），并返回一个HashMap的键是列名映射到行值。注意参数注释：

#{id}

这告诉MyBatis使创建一个PreparedStatement参数。使用JDBC，这样的参数可以由一个“？” 在SQL传递到一个新的预处理，这样的事情：

// Similar JDBC code, NOT MyBatis…
String selectPerson = "SELECT * FROM PERSON WHERE ID=?";
PreparedStatement ps = conn.prepareStatement(selectPerson);
ps.setInt(1,id);

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

2、插入(insert)、更新(update)和删除(delete)

数据修改语句插入，更新和删除，在其实施是非常相似的：

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

insert,update和delete属性

以下是一些例子，插入，更新和删除语句。

<insert id="insertAuthor" parameterType="domain.blog.Author">
insert into Author (id,username,password,email,bio)
values (#{id},#{username},#{password},#{email},#{bio})
</insert>
<update id="updateAuthor" parameterType="domain.blog.Author">
update Author set
username = #{username},
password = #{password},
email = #{email},
bio = #{bio}
where id = #{id}
</update>
<delete id="deleteAuthor" parameterType="int">
delete from Author where id = #{id}
</delete>

 如前所述，插入一点点更加丰富的，它有一些属性和子元素，从而使其处理以多种方式中的密钥生成。首先，如果你的数据库支持自动生成主键字段（如MySQL和SQL Server），那么你可以简单地设置useGeneratedKeys =“true”，并设置目标属性keyProperty就大功告成了。例如，如果使用了上面的作者表的ID自动生成的列类型，声明将作如下修改：

<insert id="insertAuthor" parameterType="domain.blog.Author" useGeneratedKeys="true"
keyProperty="id">
insert into Author (username,password,email,bio)
values (#{username},#{password},#{email},#{bio})
</insert>

MyBatis有另一种方式来处理密钥生成的数据库不支持自动生成的列类型，或者还不支持的JDBC驱动程序支持自动生成的键。下面是一个简单的例子（傻），会生成一个随机ID（可能你不会这么做，但是这展示的灵活性和MyBatis的真的不介意）：

<insert id="insertAuthor" parameterType="domain.blog.Author">
<selectKey keyProperty="id" resultType="int" order="BEFORE">
select CAST(RANDOM()*1000000 as INTEGER) a from SYSIBM.SYSDUMMY1
</selectKey>
insert into Author
(id, username, password, email,bio, favourite_section)
values
(#{id}, #{username}, #{password}, #{email}, #{bio}, #{favouriteSection,jdbcType=VARCHAR})
</insert>

在上面的例子中，selectKey将首先运行，作者 ID会被设置，然后插入语句会被调用。这给你一个类似的行为在你的数据库中自动生成的密钥，无需复杂的Java代码。selectKey元素描述如下：

<selectKey
keyProperty="id"
resultType="int"
order="BEFORE"
statementType="PREPARED">

3、SQL

这个元素可以被用来定义可重用的SQL代码段，可以包含在其他语句。例如：

<sql id="userColumns"> id,username,password </sql>

SQL片段可以被包含在另一份声明中，例如：

<select id="selectUsers" parameterType="int" resultType="hashmap">
select <include refid="userColumns"/>
from some_table
where id = #{id}
</select>

在所有过去的表格中，你已经看到了一些简单参数的例子。MyBatis中参数是非常强大的元素。对于简单的情况下，大概90％的情况下，是不太多的，例如：

<select id="selectUsers" parameterType="int" resultType="User">
select id, username, password
from users
where id = #{id}
</select>

上面的例子演示了一个非常简单的命名参数映射。参数类型被设置为 int类型，因此这个参数可以任意取名。原始或简单数据类型，如 整数和字符串没有相关属性，从 ​​而将取代参数的值完全。不过，如果你在一个复杂的对象传递，那么其行为是一个有点不同。例如：

<insert id="insertUser" parameterType="User" >
insert into users (id, username, password)
values (#{id}, #{username}, #{password})
</insert>

这是好的和简单的传递参数​​到语句。但也有很多其他功能参数映射。首先，像MyBatis的其他部分，参数可以指定一个更具体的数据类型。

#{property,javaType=int,jdbcType=NUMERIC}

MyBatis的其他地区一样，给javaType几乎总是可以从参数对象中决定，除非对象是一个HashMap的。然后给javaType应该被确定来保证使用正确 类型处理器。

注：所有可能为空的列，如果为null被当作值来传递所需的JDBC JDBC类型。您可以调查自己通过阅读预处理语句（）方法的JavaDoc 。
要进一步自定义类型的处理，也可以指定一个特定的类型处理器 类（或别名），例如：

#{age,javaType=int,jdbcType=NUMERIC,typeHandler=MyTypeHandler}

所以，它已经似乎变得越来越冗长，但事实是，你很少设置任何这些。对于数值类型也有一个数值范围确定小数点后多少有关。

#{height,javaType=double,jdbcType=NUMERIC,numericScale=2}

最后，模式属性允许你指定IN，OUT或INOUT参数。如果参数为 OUT或INOUT，参数对象属性的实际价值将被改变，就像你会想到，如果你要求输出参数。如果模式= OUT（或INOUT）和 jdbcType为CURSOR（也就是Oracle的REFCURSOR），你必须指定一个resultMap的映射结果集到的参数类型。的javaType属性是可选的，它会被自动设置ResultSet的一个光标的jdbcType如果左边的空白。

#{department, mode=OUT, jdbcType=CURSOR, javaType=ResultSet, resultMap=departmentResultMap}

MyBatis也支持更高级的数据类型，比如结构，但是你必须告诉语句类型名称注册out参数时。比如（再次提示，不要在实践中，像这样换行）：

#{middleInitial, mode=OUT, jdbcType=STRUCT, jdbcTypeName=MY_TYPE, resultMap=departmentResultMap}

尽管所有这些强大的选项，大部分的时间你只需指定属性名，MyBatis的休息。在大多数，你会指定的jdbcType为空的列。

#{firstName}
#{middleInitial,jdbcType=VARCHAR}
#{lastName}

5、字符串替换

默认情况下，使用＃{}语法会导致MyBatis使生成的PreparedStatement性能和安全设定值，对PreparedStatement的参数（例如？）。虽然这是更安全，速度更快，而且几乎总是首选，有时你只是想直接注入到SQL语句中的字符串未修改。例如，对于ORDER BY，你可能会使用这样的事情：

ORDER BY ${columnName}

这里的MyBatis不会修改或转义字符串。注：这不是安全地接受用户的输入，并提供一份声明中这样未修改。这将导致潜在的SQL注入攻击，因此，你应该允许用户输入这些字段中，或总是执行自己的逃逸和检查。

6、结果映射（resultMap）

resultMap的元素MyBatis中是最重要，最强大的元素。是什么让你远离JDBC要求的检索数据从结果 s，并且在某些情况下，可以让你做的事情，甚至不支持JDBC 代码的90％ 。事实上，写一个复杂语句联合映射类似的等同的代码，也许可以跨过上千行的代码。的结果映射 s 的设计是这样的简单语句不需要明确的结果映射，更复杂的语句不需要多描述它们的关系是绝对必要的。您已经看到了，没有一个明确的结果映射的简单映射语句的例子。例如：

<select id="selectUsers" parameterType="int" resultType="hashmap">
select id, username, hashedPassword
from some_table
where id = #{id}
</select>

这样一个语句简单导致所有列被自动映射到一个HashMap的键，与resultType属性指定。虽然在很多情况下很有用，一个HashMap中没有一个很好的域模型。它更可能是你的应用程序将使用JavaBeans或域模型的POJO（简单Java对象）。MyBatis的支持。请考虑以下的JavaBean：

package com.someapp.model;
public class User {
private int id;
private String username;
private String hashedPassword;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getHashedPassword() {
return hashedPassword;
}
public void setHashedPassword(String hashedPassword) {
this.hashedPassword = hashedPassword;
}
}

<select id="selectUsers" parameterType="int" resultType="com.someapp.model.User">
select id, username, hashedPassword
from some_table
where id = #{id}
</select>

要记住类型别名是你的朋友。使用它们，这样你就不必继续键入你的类的完全限定路径。例如：

<!-- In Config XML file -->
<typeAlias type="com.someapp.model.User" alias="User"/>
<!-- In SQL Mapping XML file -->
<select id="selectUsers" parameterType="int" resultType="User">
select id, username, hashedPassword
from some_table
where id = #{id}
</select>

在这些情况下，MyBatis会自动创建一个幕后自动映射列到JavaBean属性基于名称的ResultMap。如果列名没有精确匹配，你可以在列名上使用select字句的别名（一个标准的SQL功能）来匹配标签。例如：

<select id="selectUsers" parameterType="int" resultType="User">
select
user_id
as "id",
user_name
as "userName",
hashed_password
as "hashedPassword"
from some_table
where id = #{id}
</select>

ResultMap Ş 伟大的事情是，你已经学到了很多关于他们，但你有没有见过一个！这些简单的情况下，不要求任何超过你在这里看到的。只是出于示例的原因，让我们来看看这是什么最后的示例看起来像一个外部的结果，因为这是另一种方式来解决列名不匹配。

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

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

7、高级结果映射

        MyBatis创建的一个想法：数据库并不总是你想要什么，或者需要他们。虽然我们最喜欢的数据库最好是第三范式或BCNF模式，他们都没有。，这将是巨大的，如果可能有一个单独的数据库映射到所有使用它的应用，它不是。结果映射MyBatis的这个问题提供了答案。例如，我们如何映射下面这个语句？

<!-- Very Complex Statement -->
<select id="selectBlogDetails" parameterType="int" resultMap="detailedBlogResultMap">
select
B.id as blog_id,
B.title as blog_title,
B.author_id as blog_author_id,
A.id as author_id,
A.username as author_username,
A.password as author_password,
A.email as author_email,
A.bio as author_bio,
A.favourite_section as author_favourite_section,
P.id as post_id,
P.blog_id as post_blog_id,
P.author_id as post_author_id,
P.created_on as post_created_on,
P.section as post_section,
P.subject as post_subject,
P.draft as draft,
P.body as post_body,
C.id as comment_id,
C.post_id as comment_post_id,
C.name as comment_name,
C.comment as comment_text,
T.id as tag_id,
T.name as tag_name
from Blog B
left outer join Author A on B.author_id = A.id
left outer join Post P on B.id = P.blog_id
left outer join Comment C on P.id = C.post_id
left outer join Post_Tag PT on PT.post_id = P.id
left outer join Tag T on PT.tag_id = T.id
where B.id = #{id}
</select>

你可能想把它映射到一个智能的对象模型由一个作者写的博客，有很多文章，其中每一个可能为零或许多评论和标签。下面是一个完整的例子（假设作者，博客，帖子，评论和标签都是类型的别名）的复杂结果。看看它，但不要担心，我们将要经过的每一步。尽管它可能看起来令人生畏，它实际上是非常简单的。

<!-- Very Complex Result Map -->
<resultMap id="detailedBlogResultMap" type="Blog">
<constructor>
<idArg column="blog_id" javaType="int"/>
</constructor>
<result property="title" column="blog_title"/>
<association property="author" javaType="Author">
<id property="id" column="author_id"/>
<result property="username" column="author_username"/>
<result property="password" column="author_password"/>
<result property="email" column="author_email"/>
<result property="bio" column="author_bio"/>
<result property="favouriteSection" column="author_favourite_section"/>
</association>
<collection property="posts" ofType="Post">
<id property="id" column="post_id"/>
<result property="subject" column="post_subject"/>
<association property="author" javaType="Author"/>
<collection property="comments" ofType="Comment">
<id property="id" column="comment_id"/>
</collection>
<collection property="tags" ofType="Tag" >
<id property="id" column="tag_id"/>
</collection>
<discriminator javaType="int" column="draft">
<case value="1" resultType="DraftPost"/>
</discriminator>
</collection>
</resultMap>

resultMap元素有很多子元素和一个值得讨论的结构。下面是resultMap的元素的概念图。

• constructor -用于注入结果到后一类的构造函数实例
  • idArg - ID参数标记结果作为ID，将有助于提高整体性能
  • ARG -注入到构造一个正常的结果
• id -一个ID结果;标记结果作为ID，将有助于提高整体性能
• result -注入到字段或JavaBean属性的正常结果
• association -一个复杂的类型关联，许多结果将包成这种类型
  • 嵌套结果映射-关联是resultMap的 Ş自己，或者可以参考一
• collection -复杂类型的集合
  • 嵌套结果映射-集合的resultMap Ş本身，也可以是指一个
• discriminator -使用结果值来决定使用 这结果
  • case -这种情形结果地图
    • 嵌套结果映射 - 这种情形结果也映射本身，因此可以包含很多这些相同的元素，或者它可以参照一个外部的结果。

8、ID和result

<id property="id" column="post_id"/>


<result property="subject" column="post_subject"/>

这些都是最基本的结果映射。这两个ID， 结果到一个单一的一个简单的数据类型（字符串，整型，双，日期等）的属性或字段映射一个单独列的值。两者之间唯一的区别是ID 标记的结果作为标识符的属性时要使用比较对象实例。这有助于提高性能一般，但特别是在性能嵌套结果映射缓存和（即加盟映射）。每个人都有一些属性：

9、支持的JDBC类型

对于未来的参考，MyBatis的支持下面的JDBC类型通过包含的jdbcType枚举。

10、构造器（constructor）

<constructor>
<idArg column="id" javaType="int"/>
<arg column="username" javaType="String"/>
</constructor>

public class User {
//...
public User(int id, String username) {
//...
}
//...
}

<constructor>
<idArg column="id" javaType="int"/>
<arg column="username" javaType="String"/>
</constructor>

<association property="author" javaType="Author">
<id property="id" column="author_id"/>
<result property="username" column="author_username"/>
</association>

<resultMap id="blogResult" type="Blog">
<association property="author" column="author_id" javaType="Author" select="selectAuthor"/>
</resultMap>
<select id="selectBlog" parameterType="int" resultMap="blogResult">
SELECT * FROM BLOG WHERE ID = #{id}
</select>
<select id="selectAuthor" parameterType="int" resultType="Author">
SELECT * FROM AUTHOR WHERE ID = #{id}
</select>

<select id="selectBlog" parameterType="int" resultMap="blogResult">
select
B.id
as blog_id,
B.title
as blog_title,
B.author_id
as blog_author_id,
A.id
as author_id,
A.username
as author_username,
A.password
as author_password,
A.email
as author_email,
A.bio
as author_bio
from Blog B left outer join Author A on B.author_id = A.id
where B.id = #{id}
</select>

<resultMap id="blogResult" type="Blog">
<id property="id" column="blog_id" />
<result property="title" column="blog_title"/>
<association property="author" resultMap="authorResult" />
</resultMap>
<resultMap id="authorResult" type="Author">
<id property="id" column="author_id"/>
<result property="username" column="author_username"/>
<result property="password" column="author_password"/>
<result property="email" column="author_email"/>
<result property="bio" column="author_bio"/>
</resultMap>

<resultMap id="blogResult" type="Blog">
<id property="id" column="blog_id" />
<result property="title" column="blog_title"/>
<association property="author" javaType="Author">
<id property="id" column="author_id"/>
<result property="username" column="author_username"/>
<result property="password" column="author_password"/>
<result property="email" column="author_email"/>
<result property="bio" column="author_bio"/>
</association>
</resultMap>

<select id="selectBlog" parameterType="int" resultMap="blogResult">
select
B.id
as blog_id,
B.title
as blog_title,
A.id
as author_id,
A.username
as author_username,
A.password
as author_password,
A.email
as author_email,
A.bio
as author_bio,
CA.id
as co_author_id,
CA.username
as co_author_username,
CA.password
as co_author_password,
CA.email
as co_author_email,
CA.bio
as co_author_bio
from Blog B
left outer join Author A on B.author_id = A.id
left outer join Author CA on B.co_author_id = CA.id
where B.id = #{id}
</select>

<resultMap id="authorResult" type="Author">
<id property="id" column="author_id"/>
<result property="username" column="author_username"/>
<result property="password" column="author_password"/>
<result property="email" column="author_email"/>
<result property="bio" column="author_bio"/>
</resultMap>

<resultMap id="blogResult" type="Blog">
<id property="id" column="blog_id" />
<result property="title" column="blog_title"/>
<association property="author"
resultMap="authorResult" />
<association property="coAuthor"
resultMap="authorResult"
columnPrefix="co_" />
</resultMap>

SELECT * FROM BLOG WHERE ID = #{id}
SELECT * FROM AUTHOR WHERE ID = #{id}

<select id="selectBlog" resultSets="blogs,authors" resultMap="blogResult">
{call getBlogsAndAuthors(#{id,jdbcType=INTEGER,mode=IN})}
</select>

<resultMap id="blogResult" type="Blog">
<id property="id" column="id" />
<result property="title" column="title"/>
<association property="author" javaType="Author" resultSet="authors" column="author_id" foreignColumn="id">
<id property="id" column="id"/>
<result property="username" column="username"/>
<result property="password" column="password"/>
<result property="email" column="email"/>
<result property="bio" column="bio"/>
</association>
</resultMap>

12、集合（collection）

<collection property="posts" ofType="domain.blog.Post">
<id property="id" column="post_id"/>
<result property="subject" column="post_subject"/>
<result property="body" column="post_body"/>
</collection>

private List<Post> posts;

嵌套查询集合（Nested Select for Collection）
首先，让我们来看看使用嵌套选择加载文章的博客。

<resultMap id="blogResult" type="Blog">
<collection property="posts" javaType="ArrayList" column="id" ofType="Post" select="selectPostsForBlog"/>
</resultMap>
<select id="selectBlog" parameterType="int" resultMap="blogResult">
SELECT * FROM BLOG WHERE ID = #{id}
</select>
<select id="selectPostsForBlog" parameterType="int" resultType="Post">
SELECT * FROM POST WHERE BLOG_ID = #{id}
</select>

<collection property="posts" javaType="ArrayList" column="id" ofType="Post" select="selectPostsForBlog"/>

<collection property="posts" column="id" ofType="Post" select="selectPostsForBlog"/>

<select id="selectBlog" parameterType="int" resultMap="blogResult">
select
B.id as blog_id,
B.title as blog_title,
B.author_id as blog_author_id,
P.id as post_id,
P.subject as post_subject,
P.body as post_body,
from Blog B
left outer join Post P on B.id = P.blog_id
where B.id = #{id}
</select>

<resultMap id="blogResult" type="Blog">
<id property="id" column="blog_id" />
<result property="title" column="blog_title"/>
<collection property="posts" ofType="Post">
<id property="id" column="post_id"/>
<result property="subject" column="post_subject"/>
<result property="body" column="post_body"/>
</collection>
</resultMap>

<resultMap id="blogResult" type="Blog">
<id property="id" column="blog_id" />
<result property="title" column="blog_title"/>
<collection property="posts" ofType="Post" resultMap="blogPostResult" columnPrefix="post_"/>
</resultMap>
<resultMap id="blogPostResult" type="Post">
<id property="id" column="id"/>
<result property="subject" column="subject"/>
<result property="body" column="body"/>
</resultMap>

SELECT * FROM BLOG WHERE ID = #{id}
SELECT * FROM POST WHERE BLOG_ID = #{id}

<select id="selectBlog" resultSets="blogs,posts" parameterType="int" resultMap="blogResult">
{call getBlogsAndPosts(#{id,jdbcType=INTEGER,mode=IN})}
</select>

<resultMap id="blogResult" type="Blog">
<id property="id" column="id" />
<result property="title" column="title"/>
<collection property="posts" ofType="Post" resultSet="posts" column="id" foreignColumn="blog_id">
<id property="id" column="id"/>
<result property="subject" column="subject"/>
<result property="body" column="body"/>
</collection>
</resultMap>

<discriminator javaType="int" column="draft">
<case value="1" resultType="DraftPost"/>
</discriminator>

<resultMap id="vehicleResult" type="Vehicle">
<id property="id" column="id" />
<result property="vin" column="vin"/>
<result property="year" column="year"/>
<result property="make" column="make"/>
<result property="model" column="model"/>
<result property="color" column="color"/>
<discriminator javaType="int" column="vehicle_type">
<case value="1" resultMap="carResult"/>
<case value="2" resultMap="truckResult"/>
<case value="3" resultMap="vanResult"/>
<case value="4" resultMap="suvResult"/>
</discriminator>
</resultMap>

<resultMap id="carResult" type="Car">
<result property="doorCount" column="door_count" />
</resultMap>

<resultMap id="carResult" type="Car" extends="vehicleResult">
<result property="doorCount" column="door_count" />
</resultMap>

<resultMap id="vehicleResult" type="Vehicle">
<id property="id" column="id" />
<result property="vin" column="vin"/>
<result property="year" column="year"/>
<result property="make" column="make"/>
<result property="model" column="model"/>
<result property="color" column="color"/>
<discriminator javaType="int" column="vehicle_type">
<case value="1" resultType="carResult">
<result property="doorCount" column="door_count" />
</case>
<case value="2" resultType="truckResult">
<result property="boxSize" column="box_size" />
<result property="extendedCab" column="extended_cab" />
</case>
<case value="3" resultType="vanResult">
<result property="powerSlidingDoor" column="power_sliding_door" />
</case>
<case value="4" resultType="suvResult">
<result property="allWheelDrive" column="all_wheel_drive" />
</case>
</discriminator>
</resultMap>

<select id="selectUsers" parameterType="int" resultType="User">
select
user_id
as "id",
user_name
as "userName",
hashed_password
from some_table
where id = #{id}
</select>

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

有三个自动映射水平：

• NONE -  禁用自动映射。只有手动映射属性将被设置。
• PARTIAL - 自动映射的结果，除了那些有嵌套结果映射内部定义（加入）。
• FULL -  自动映射一切。

<select id="selectBlog" parameterType="int" resultMap="blogResult">
select
B.id,
B.title,
A.username,
from Blog B left outer join Author A on B.author_id = A.id
where B.id = #{id}
</select>

<resultMap id="blogResult" type="Blog">
<association property="author" javaType="Author" resultMap="authorResult"/>
</resultMap>
<resultMap id="authorResult" type="Author">
<result property="username" column="author_username"/>
</resultMap>

        MyBatis包含一个功能强大的交易查询缓存功能，这是非常可配置和可定制的。 MyBatis 3中的缓存实现已作出很多修改，使其更加强大而且易于配置。默认情况下，只是局部的session缓存，仅用于缓存数据在会话期间启用。要启用全球第二级缓存，你只需要你的SQL映射文件中添加一行：

<cache/>

<cache
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>

使用自定义缓存（Using a Custom Cache）

除了自定义缓存在这些方面，你也可以完全覆盖缓存行为实现自己的缓存，或其他第三方缓存解决方案创建适配器。

<cache type="com.domain.something.MyCustomCache"/>

public interface Cache {
String getId();
int getSize();
void putObject(Object key, Object value);
Object getObject(Object key);
boolean hasKey(Object key);
Object removeObject(Object key);
void clear();
ReadWriteLock getReadWriteLock();
}

<cache type="com.domain.something.MyCustomCache">
<property name="cacheFile" value="/tmp/my-custom-cache.tmp"/>
</cache>

<select ... flushCache="false" useCache="true"/>
<insert ... flushCache="true"/>
<update ... flushCache="true"/>
<delete ... flushCache="true"/>

<cache-ref namespace="com.someone.application.data.SomeMapper"/>

最后

以上就是壮观小松鼠为你收集整理的Github Mybatis深入学习之映射器XML的全部内容，希望文章能够帮你解决Github Mybatis深入学习之映射器XML所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。