Mapper映射语句高阶应用——ResultMap / 憋错料

resultMap 元素是 MyBatis 中最重要最强大的元素。它就是让你远离 90% 的需要从结果集中取出数据的 JDBC 代码的那个东西 , 而且在一些情形下允许你做一些 JDBC 不支持的事情。事实上 , 编写相似于对复杂语句联合映射这些等同的代码, 也许可以跨过上千行的代码。 ResultMap 的设计就是简单语句不需要明确的结果映射 , 而很多复杂语句确实需要描述它们的关系。

我们通过一个连续的例子，来逐步讲解 ReusltMap 。

要进行 ResultMap 的实验，先设计数据库：

上述是数据库的 E-R 图。

create database if not exists mybatis3;

use mybatis3;

drop table if exists tag;
create table if not exists tag(
  id int primary key not null,
  name varchar(100) not null
);

drop table if exists author;
create table if not exists author(
  id int primary key not null,
  username varchar(100) not null,
  password varchar(100) not null,
  email varchar(100),
  bio varchar(100),
  favourite_section varchar(100)
);

drop table if exists blog;
create table if not exists blog(
  id int primary key not null,
  title varchar(100) not null,
  author_id int not null,
  constraint blog_author_fk foreign key(author_id) references author(id)
    on update cascade on delete cascade
);

drop table if exists post;
create table if not exists post(
  id int primary key not null,
  blog_id int not null,
  author_id int not null,
  create_on date not null,
  section varchar(100),
  subject varchar(100),
  draft varchar(100),
  body varchar(200),
  constraint post_blog_fk foreign key(blog_id) references blog(id)
    on update cascade on delete cascade,
  constraint post_author_fk foreign key(author_id) references author(id)
    on update cascade on delete cascade
);

drop table if exists post_tag;
create table if not exists post_tag(
  post_id int not null,
  tag_id int not null,
  primary key(post_id,tag_id),
  constraint postTag_post_fk foreign key(post_id) references post(id)
    on update cascade on delete cascade,
  constraint postTag_tag_fk foreign key(tag_id) references tag(id)
    on update cascade on delete cascade
);

drop table if exists comment;
create table if not exists comment(
  id int primary key not null,
  post_id int not null,
  name varchar(100) not null,
  comment varchar(300),
  constraint comment_post_fk foreign key(post_id) references post(id)
    on update cascade on delete cascade
);

insert into tag values(111,‘科技‘);
insert into tag values(222,‘文学‘);
insert into tag values(333,‘文档‘);

insert into author values(1,‘zjl‘,‘123‘,‘[email protected]‘,‘no‘,‘spring‘);
insert into author values(2,‘ddt‘,‘123‘,‘[email protected]‘,‘no‘,‘auto‘);
insert into author values(3,‘woya‘,‘123‘,‘[email protected]‘,‘no‘,‘no‘);
insert into author values(4,‘yoiu‘,‘123‘,‘[email protected]‘,‘no‘,‘what‘);
insert into author values(5,‘dwks‘,‘123‘,‘[email protected]‘,‘no‘,‘are‘);

insert into blog values(1,‘博客1‘,1);
insert into blog values(2,‘博客2‘,1);
insert into blog values(3,‘博客3‘,1);
insert into blog values(4,‘博客4‘,2);
insert into blog values(5,‘博客5‘,2);
insert into blog values(6,‘博客6‘,3);
insert into blog values(7,‘博客7‘,4);
insert into blog values(8,‘博客8‘,5);

insert into post values(1,1,1,20130729,‘section1‘,‘subject1‘,‘draft1‘,‘body1‘);
insert into post values(2,1,1,20130729,‘section2‘,‘subject2‘,‘draft2‘,‘body2‘);
insert into post values(3,1,1,20130729,‘section3‘,‘subject3‘,‘draft3‘,‘body3‘);
insert into post values(4,2,1,20130729,‘section4‘,‘subject4‘,‘draft4‘,‘body4‘);
insert into post values(5,2,4,20130729,‘section5‘,‘subject5‘,‘draft5‘,‘body5‘);
insert into post values(6,2,2,20130729,‘section6‘,‘subject6‘,‘draft6‘,‘body6‘);
insert into post values(7,3,2,20130729,‘section7‘,‘subject7‘,‘draft7‘,‘body7‘);
insert into post values(8,3,4,20130729,‘section8‘,‘subject8‘,‘draft8‘,‘body8‘);
insert into post values(9,4,2,20130729,‘section9‘,‘subject9‘,‘draft9‘,‘body9‘);
insert into post values(10,5,5,20130729,‘section10‘,‘subject10‘,‘draft10‘,‘body10‘);
insert into post values(11,6,5,20130729,‘section11‘,‘subject11‘,‘draft11‘,‘body11‘);
insert into post values(12,7,5,20130729,‘section12‘,‘subject12‘,‘draft12‘,‘body12‘);
insert into post values(13,8,3,20130729,‘section13‘,‘subject13‘,‘draft13‘,‘body13‘);

insert into post_tag values(1,111);
insert into post_tag values(1,333);
insert into post_tag values(1,222);
insert into post_tag values(2,111);
insert into post_tag values(2,222);
insert into post_tag values(2,333);
insert into post_tag values(3,333);
insert into post_tag values(4,333);
insert into post_tag values(4,222);
insert into post_tag values(4,111);
insert into post_tag values(5,333);
insert into post_tag values(6,333);
insert into post_tag values(6,222);
insert into post_tag values(7,333);
insert into post_tag values(7,222);
insert into post_tag values(7,111);
insert into post_tag values(8,222);
insert into post_tag values(9,222);
insert into post_tag values(10,222);
insert into post_tag values(11,222);
insert into post_tag values(12,111);
insert into post_tag values(13,111);
insert into post_tag values(13,222);
insert into post_tag values(13,333);

insert into comment values(1,1,‘评论1‘,‘评论内容1‘);
insert into comment values(2,1,‘评论2‘,‘评论内容2‘);
insert into comment values(3,2,‘评论3‘,‘评论内容3‘);
insert into comment values(4,2,‘评论4‘,‘评论内容4‘);
insert into comment values(5,2,‘评论5‘,‘评论内容5‘);
insert into comment values(6,3,‘评论6‘,‘评论内容6‘);
insert into comment values(7,4,‘评论7‘,‘评论内容7‘);
insert into comment values(8,5,‘评论8‘,‘评论内容8‘);
insert into comment values(9,6,‘评论9‘,‘评论内容9‘);
insert into comment values(10,7,‘评论10‘,‘评论内容10‘);
insert into comment values(11,8,‘评论11‘,‘评论内容11‘);
insert into comment values(12,9,‘评论12‘,‘评论内容12‘);
insert into comment values(13,10,‘评论13‘,‘评论内容13‘);
insert into comment values(14,11,‘评论14‘,‘评论内容14‘);
insert into comment values(15,12,‘评论15‘,‘评论内容15‘);
insert into comment values(16,12,‘评论16‘,‘评论内容16‘);
insert into comment values(17,13,‘评论17‘,‘评论内容17‘);

因为是进行 MyBatis 的 ResultMap 的相关实验，所以我也就不详细描述数据库设计的相关过程了，只是尽量做到数据库的复杂，包括一些一对一，一对多，多对一以及多对多联系。

所有的数据库涉及到了 5 个类，这些类为： Blog 、 Comment 、 Post 、 Tag 、 Author 。不过这些类中的具体属形成员咱们暂时不添加，因为这关系到 ResultMap 的具体描述，这里我们不做具体解释，这些都会在之后的测试实验中提到。

前提工作已经做好了，现在可以开始测试：

基础 ResultMap

我们先来看个简单的例子，这个例子只是包括了最简单的一些描述，没有复杂的联系（即外键）。

通过数据库，我们选择 Tag 这个类，因为它比较简单，就只有一个 id 和 name 的属性。

将 Tag 补充如下：

package net.mybatis.model;

public class Tag {
  private int id;
  private String name;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  @Override
  public String toString() {
    return this.getClass().getName() + ":[id:" + this.id + ",name:"
        + this.name + "]";
  }
}

我们接下来要进行的是进行 SQL 语句的映射：

<select id="test1" parameterType="int" resultType="Tag">
        select id,name from tag where id = #{id}
</select>

以之前的挤出来说，我们很容易就可以写出上述的语句，不过这个跟 ResultMap 又有什么关系呢？

MyBatis 其实已经在幕后自动创建了一个 ResultMap 与之对应，而我们不需要手动进行编写，它的规则是基于属性名来映射列到 JavaBean 的属性上。

当列名与 JavaBean 的属性名不一致的时候，可以使用 as 来设定一个别名，因为这个比较简单，我就直接套用 MyBatis 的文档来描述：

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

很容易就知道 as 的具体用法了。

不过，我们也可以用 ResultMap 来定义，这个时候为了方便，我先用 as 来重新设定列名，再根据 ResultMap 更改回去：

<select id="test1" parameterType="int" resultMap="test1Map">
        select
        	id as tag_id,
        	name
        from
        	tag
        where
        	id = #{id}
</select>
<resultMap type="Tag" id="test1Map">
        <id column="tag_id" property="id"/>
        <result column="name" property="name"/>
</resultMap>

在这里我先将 id 的列名利用数据库的 as 别名为 tag_id ，之后，在映射的时候，通过 ResultMap 将， tag_id 重新映射为 id 的属性名。

之前的 select 标签属性中的 resultType 则需要更改为 resultMap ，它的值为引用 ResultMap 标签的 id 值。

resultMap 标签包含的子标签的具体属性，这里先简要介绍一下：

column ：数据库返回过来的列名

property ：要映射对象即（ JavaBean ）的属性名。

至于其他的具体属性将会在之后介绍。

高级结果映射

ResultMap 中包含的子标签有如下几种：


constructor	构造方法
id	一个 ID 结果
result	普通属性字段
association	一个复杂的类型关联，为一对多的形式
collection	复杂类型的集合，为多对一的形式
discriminator	根据结果值引用不同的 ResultMap

上述的子标签会在之后详细介绍，现在模糊不懂没有什么关系。

MyBatis 建议我们的最佳实践也是让我们一步步进行了解，如果一下子进行过于复杂的结果映射，那么不出错是不可能的。

id&result

id 标签为定义一个唯一标识，也就是数据库中诉说的主键

result 则为一个普通的属性

id 与 result 的标签的属性：


property	映射到 javaBean 的字段属性名
column	数据库返回的列名
javaType	该值（ id 或 result ）对应的 java 类型
jdbcType	该值在数据库中的类型
typeHandler	覆盖默认的类型处理器

构造方法

除了使用 id 和 result 来注入 javaBean 属性外，我们还可以通过构造方法的形式来注入属性，比如，我们将 Tag 类中的 id 和 name 都通过构造方法来构建：

package net.mybatis.model;

public class Tag {
  private Integer id;
  private String name;

  public Tag(Integer id,String name){
    this.id = id;
    this.name = name;
  }

  @Override
  public String toString() {
    return this.getClass().getName() + ":[id:" + this.id + ",name:"
        + this.name + "]";
  }
}

<resultMap type="Tag" id="test1Map">
        <constructor>
            <idArg column="tag_id" javaType="int"/>
            <arg column="name" javaType="string"/>
        </constructor>
</resultMap>

其中， idArg 为主键， arg 为普通属性。

注意：在定义构造方法的时候要注意的是，必须以类的形式作为构造函数的参数。比如 int ，在构造的时候，必须更改为 Integer ，具体的原因是 javaType声明的为 int ，这个在 TypeAlianses 中反射到的 java 类型为 Integer ，如果真的只想用 int 来使用构造，那么需要将 javaType 的 int 更改为 _int ，这个问题在文档中也没有提及，以至于在文档它的实际结果也是错误的。

我们的数据库是一个博客数据库，因此，一片博文会对应一个作者，而一个作者拥有多篇博文，这在数据库中的关系为多对一。

而表示这种关系，我们可以使用 association 。

我们定义 Author 类：

package net.mybatis.model;

public class Author {
  private int id;
  private String username;
  private String password;
  private String email;
  private String bio;
  private String favouriteSection;

  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 getPassword() {
    return password;
  }

  public void setPassword(String password) {
    this.password = password;
  }

  public String getEmail() {
    return email;
  }

  public void setEmail(String email) {
    this.email = email;
  }

  public String getBio() {
    return bio;
  }

  public void setBio(String bio) {
    this.bio = bio;
  }

  public String getFavouriteSection() {
    return favouriteSection;
  }

  public void setFavouriteSection(String favouriteSection) {
    this.favouriteSection = favouriteSection;
  }

  @Override
  public String toString() {
    return this.getClass().getName() + ":[id:" + this.id + ",username:"
        + this.username + ",password:" + this.password + ",email:"
        + this.email + ",bio:" + this.bio + ",favouriteSection:"
        + this.favouriteSection + "]";
  }

}

接着定义 Blog 类：

package net.mybatis.model;

public class Blog {
  private int id;
  private String title;
  private Author author;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public int getId() {
    return id;
  }

  public String getTitle() {
    return title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public Author getAuthor() {
    return author;
  }

  public void setAuthor(Author author) {
    this.author = author;
  }

  @Override
  public String toString() {
    return this.getClass().getName() + ":[id:" + this.id + ",title:"
        + this.title + ",author:" + this.author + ",posts:" + "]";
  }
}

我们在 Blog 类中加了一个 Author 的对象，这个是用来关联 Author 类的。

因为 MyBatis 在定义 SQL 映射后自动映射的过程中，需要 JAVABean 有一个联系的属性。

<select id="test2" parameterType="int" resultMap="test2Map" >
        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
        from
        	Blog B
        	left join Author A on (B.author_id = A.id)
        where
        	B.id = #{id}
    </select>
    <resultMap type="Blog" id="test2Map">
        <id property="id" column="blog_id" javaType="int"/>
        <result property="title" column="blog_title" javaType="string"/>
        <association property="author" column="blog_author_id" javaType="Author">
            <id property="id" column="author_id" javaType="_int"/>
      <result property="username" column="author_username" javaType="string"/>
      <result property="password" column="author_password" javaType="string"/>
      <result property="email" column="author_email" javaType="string"/>
      <result property="bio" column="author_bio" javaType="string"/>
      <result property="favouriteSection" column="author_favourite_section" javaType="string"/>
        </association>
</resultMap>

在 <resultMap> 标签中，存在着的 association 标签即为关联。

association 的处理有两种方式，一种是 select 的嵌套查询，另一种是嵌套 ResultMap 结果。

嵌套 ResultMap 结果就是上述的例子，在这个例子中，还可以将 <association> 标签中的 Author 剥离开来，重新形成一个 id 为 authorResult 的 resultMap ，那么这个 authorResult 的 resultMap 就可以重用。而 <assocation> 只需要引用 resultMap 这个属性值为 authorResult 即可。

另外一种 select 的嵌套，如，可将上述的例子分解为：

<resultMap type="Blog" id="test2Map">
        <id property="id" column="blog_id" javaType="int"/>
        <result property="title" column="blog_title" javaType="string"/>
        <association property="author" column="blog_author_id" javaType="Author" select="test2DivideSelect">
        </association>
    </resultMap>
    <select id="test2DivideSelect" parameterType="int" resultType="Author">
        select * from author where id = #{id}
</select>

这种方式简单并且容易理解，不过它却有个致命的缺点，那就是如果查询的为大型数据集合和列表的情况下，那么所需要查询的 SQL 语句条数的数量会是惊人的。即是： “N+1” 的情况，即需要对返回回来的 N 条数据进行细节添加。

如果 Blog 中存在一个相同的属性，这个属性，属性名字不同，但是类型相同，比如， Blog 中存在一个 author ，如果还存在一个 co-author 又该如何，在这种情况

下，我们可以使用 columnPrefix 属性：

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

多对一映射

相对于上面的一对多映射，还有一种就是多对一映射，上述就说过，一篇博文对应有一个作者，那么一个作者必然对应有多篇博文。这个关系就是多对一的关系，而想要使用这个关系，那么就需要用到 collection 的标签。

将 Author 的类修改如下：

package net.mybatis.model;

import java.util.List;

public class Author {
  private int id;
  private String username;
  private String password;
  private String email;
  private String bio;
  private String favouriteSection;

  private List<Blog> blogs;

  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 getPassword() {
    return password;
  }

  public void setPassword(String password) {
    this.password = password;
  }

  public String getEmail() {
    return email;
  }

  public void setEmail(String email) {
    this.email = email;
  }

  public String getBio() {
    return bio;
  }

  public void setBio(String bio) {
    this.bio = bio;
  }

  public String getFavouriteSection() {
    return favouriteSection;
  }

  public void setFavouriteSection(String favouriteSection) {
    this.favouriteSection = favouriteSection;
  }

  public List<Blog> getBlogs() {
    return blogs;
  }

  public void setBlogs(List<Blog> blogs) {
    this.blogs = blogs;
  }

  @Override
  public String toString() {
    return this.getClass().getName() + ":[id:" + this.id + ",username:"
        + this.username + ",password:" + this.password + ",email:"
        + this.email + ",bio:" + this.bio + ",favouriteSection:"
        + this.favouriteSection + ",blogs:"+this.blogs+"]";
  }

}

我们添加了：

private List<Blog> blogs;

这个属性，然后设置了它的 setter 和 getter 方法。

下面，如果我们要通过一个作者获取到他写了哪些博文，那么该如何做呢？

<select id="test3" parameterType="int" resultMap="test3Map">
        select
        	A.id as author_id,
        	A.username as author_username,
        	A.email as author_email,
        	B.id as blog_id,
        	B.title as blog_title,
        	B.author_id as blog_author_id
        from
        	Author A
        	left join Blog B on (A.id = B.author_id)
        where
        	A.id = #{id}
    </select>
    <resultMap type="Author" id="test3Map">
        <id column="author_id" property="id" javaType="_int"/>
        <result column="author_username" property="username" javaType="string"/>
        <result column="author_email" property="email" javaType="string"/>
        <collection column="blog_author_id" property="blogs" javaType="ArrayList" ofType="Blog">
            <id column="blog_id" property="id" javaType="_int"/>
            <result column="blog_title" property="title" javaType="string"/>
        </collection>
</resultMap>

就如上述所说， collection 即表示“多个 ” 的关系， 必须注意的是，一定要指定 ofType 属性，这个 ofType 属性指的是集合的元素类型，缺少这个属性， MyBatis 会报出设定参数错误的提示 。

就如同 association 一样， collection 也分两种：一种为嵌套查询 select ，另一种为嵌套结果 resultMap ，用法也跟 association 一致，在这里就不再详细述说。

对于上述所说的一对多，多对一，数据库当然还有另外一种形式：多对多。这种关系在前面的基础上，应该已经能够猜的出来了，其实也就是在对多对的两个类中添加一个对方的私有 List 集合属性。这样在 select 映射中，不管用哪种为主体，都可以成功映射。

最后来个复杂的，包括了以上所有的描述：

<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.create_on as post_create_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 join Author A on B.author_id = A.id
           left join Post P on B.id = P.blog_id
           left join Comment C on P.id = C.post_id
           left join Post_Tag PT on PT.post_id = P.id
           left join Tag T on PT.tag_id = T.id
      where B.id = #{id}
  </select>
  <resultMap id="detailedBlogResultMap" type="Blog">
    <constructor>
      <idArg column="blog_id" javaType="int" />
    </constructor>
    <result property="title" column="blog_title" />
    <association property="author" column="blog_author_id" 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>
    <!-- <association property="author" column="author_id" javaType="Author" select="selectAuthor"></association> -->
    <collection property="posts" javaType="ArrayList" column="post_blog_id" ofType="Post">
      <id property="id" column="post_id" />
      <result property="subject" column="post_subject" />
      <association property="author" column="post_author_id" javaType="Author" />
      <collection property="comments" javaType="ArrayList" column="comment_post_id" ofType="Comment">
        <id property="id" column="comment_id" />
      </collection>
      <collection property="tags" javaType="ArrayList" ofType="Tag">
        <id property="id" column="tag_id" />
        <result property="name" column="tag_name"/>
      </collection>
    </collection>
</resultMap>

对于同一个数据库来说，我们往往通过不同的查询会返回不同的结果（即返回数据库的列不同）。在这种情况下，鉴别器的作用就凸显出来了。我们通过比较不同的鉴别器类型的值来判断使用哪个 resultMap 。

为了举这个例子，我们创建一个新的表：

drop table if exists dis;
create table if not exists dis(
  id int primary key not null,
  name varchar(100) not null,
  type_id int not null,
  test1 varchar(100),
  test2 varchar(100),
  test3 varchar(100)
);

insert into dis values(1,‘dis1‘,1,‘test11‘,‘test21‘,‘test31‘);
insert into dis values(2,‘dis2‘,1,‘test12‘,‘test22‘,‘test32‘);
insert into dis values(3,‘dis3‘,2,‘test13‘,‘test23‘,‘test33‘);
insert into dis values(4,‘dis4‘,2,‘test14‘,‘test24‘,‘test34‘);
insert into dis values(5,‘dis5‘,2,‘test15‘,‘test25‘,‘test35‘);
insert into dis values(6,‘dis6‘,3,‘test16‘,‘test26‘,‘test36‘);
insert into dis values(7,‘dis7‘,3,‘test17‘,‘test27‘,‘test37‘);

创建 Dis 类

package net.mybatis.model;

public class Dis {
  private int id;
  private String name;
  private int type_id;
  private String test1;
  private String test2;
  private String test3;
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getType_id() {
    return type_id;
  }
  public void setType_id(int type_id) {
    this.type_id = type_id;
  }
  public String getTest1() {
    return test1;
  }
  public void setTest1(String test1) {
    this.test1 = test1;
  }
  public String getTest2() {
    return test2;
  }
  public void setTest2(String test2) {
    this.test2 = test2;
  }
  public String getTest3() {
    return test3;
  }
  public void setTest3(String test3) {
    this.test3 = test3;
  }

}

接下来就是 SQL 的映射：

<select id="test4" resultMap="test4Map">
        select
        	id,
        	name,
        	type_id as type,
        	test1,
        	test2,
        	test3
        from
        	dis
    </select>
    <resultMap type="Dis" id="test4Map">
        <id column="id" property="id" javaType="_int"/>
        <result column="name" property="name" javaType="string"/>
        <discriminator javaType="_int" column="type" >
            <case value="1" resultType="string">
                <result column="test1" property="test1" javaType="string"/>
            </case>
            <case value="2" resultType="string">
                <result column="test2" property="test2" javaType="string"/>
            </case>
            <case value="3" resultType="string">
                <result column="test3" property="test3" javaType="string"/>
            </case>
        </discriminator>
</resultMap>

在这里需要注意的是，选择的列必须要在类中写出来，而且每个 case 标签中的resultType 属性必须设置，否则 MyBatis 会报空参数异常。

到现在为止， Mapper 的高阶应用到此为止。

http://www.tuicool.com/articles/j6ZVFb

http://blog.csdn.net/dearday/article/details/9621113

时间： 2024-08-02 12:43:37

Mapper映射语句高阶应用——ResultMap

基础 ResultMap

高级结果映射

Mapper映射语句高阶应用——ResultMap的相关文章

深入浅出Mybatis系列（八）---mapper映射文件配置之select、resultMap[转]

深入浅出Mybatis系列（八）---mapper映射文件配置之select、resultMap good

深入浅出Mybatis系列（八）---mapper映射文件配置之select、resultMap

MyBatis框架中Mapper映射配置的使用及原理解析(三) 配置篇 Configuration

《JS权威指南学习总结--8.8.2高阶函数》

Haskell高阶函数

深入浅出Mybatis系列（七）---mapper映射文件配置之insert、update、delete[转]

三、MyBatis系列：Mapper 映射之使用POJO实体来接收数据和传入参数

匿名方法，Lambda表达式，高阶函数