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','123@123.com','no','spring');
insert into author values(2,'ddt','123','ddt@123.com','no','auto');
insert into author values(3,'woya','123','woya@123.com','no','no');
insert into author values(4,'yoiu','123','yoiu@123.com','no','what');
insert into author values(5,'dwks','123','dwks@123.com','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的高阶应用到此为止。

 

         转载请注明出处，谢谢！