关联查询就涉及到多个表的查询了,这里以用户表和订单表为例，用户表还是用之前文章使用的那个，订单表这里需要创建一个，sql语句如下：
CREATE TABLE `orders` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`user_id` int(11) NOT NULL COMMENT '下单用户id',
`number` varchar(32) NOT NULL COMMENT '订单号',
`createtime` datetime NOT NULL COMMENT '创建订单时间',
`note` varchar(100) DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`),
KEY `FK_orders_1` (`user_id`),
CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
添加一些测试数据：
INSERT INTO `orders` VALUES ('3', '1', '1000010', '2015-02-04 13:22:35', null);
INSERT INTO `orders` VALUES ('4', '1', '1000011', '2015-02-03 13:22:41', null);
INSERT INTO `orders` VALUES ('5', '10', '1000012', '2015-02-12 16:13:23', null);
观察上面订单表的数据可以知道订单表中id=3和4记录是和用户表中id=1的记录存在关联，订单表id=5的和用户表id=10的记录有关联。
用户表是（一方），订单表示（多方），他们是一对多的关系，反之订单表和用户表就是多对一的关系。
单个对象的映射关系是什么意思？
它是指查询一张表的一条记录级联查询另一张表的一条记录，通常用在“一对一”关系的表的级联查询。
虽然我们的订单表和用户表是“多对一”的关系，但是如果单独看待一条订单记录的话，它是有唯一的一条用户记录与之对应的，这么局部范围来看的话就相当于“一对一”的关系了。
对应的sql语句查询就是这样：
select o.* ,u.id uid,username,birthday,sex,address from orders o,user u where o.user_id = u.id;
执行结果：
前面是订单信息，后面是用户信息，但是每一条订单记录都有唯一的一条用户记录与之对应，这样看的话就是“一对一”的关系了。
对于这条sql语句的查询结果，用mybatis的话有2种方式来处理：
- 单独定义一个javabean，封装sql语句查询的所有字段
- 使用association标签来对另一张表的sql查询语句的字段和对应的javabean属性做关系映射
优缺点：
方式1的话有点类似于偏方了，不够灵活，它需要保证 resultType中的javabean属性和sql语句查询的字段完全对应，好处就是不需要书写sql查询语句的字段和该javabean的属性的映射关系，只要保证他们的名字一样即可，个人不太喜欢用，因为无端端有多了一个javabean类。
方式2的话是mybatis推荐使用的，灵活度高，使用者可以自行配置字段和属性的对应关系，缺点就是增加编辑映射文件的代码量，个人感觉这个不算什么缺点，它很类似hibernate中配置映射文件的感觉。
下面分别介绍这2种方式的实现。
方式1
创建一个javabean，这里叫做CustomerOrders并继承Orders类，Orders类长这样：
public class Orders {
private Integer id;
private Integer userId;
private String number;
private Date createtime;
private String note;
//getter and setter..
}
CustomerOrders类长这样:
//Orders中的字段从继承Orders中获取
public class CustomerOrders extends Orders{
//对应user表查询字段的属性名
private int uid; //这里用uid,对应sql语句查询id字段的别名.
private String username;// 用户姓名
private int sex;// 性别
private Date birthday;// 生日
private String address;// 地址
//getter and setter..
}
然后创建OrderMapper接口类，添加查询方法：
//查询订单级联查询一条用户记录
public List<CustomerOrders> findOrdersAndUser();
接着添加OrderMapper.xml映射文件,配置内容如下:
<?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">
<!-- mapper接口代理实现规则:
1.映射文件中namespace要等于接口的全路径名称
2. 映射文件中sql语句的id要等于接口的方法名称
3. 映射文件中传入参数类型要等于接口方法的传入参数类型
4. 映射文件中返回结果集类型要等于接口方法的返回值类型,如果接口方法的返回值类型是集合,那么它表示的就是集合中的泛型参数类型 -->
<mapper namespace="blog.csdn.net.mchenys.mapper.OrderMapper">
<!-- 一对一:自动映射(取巧的方式,不够灵活)
前提是需要保证 resultType中的参数类型的属性和sql语句查询的字段完全对应.
-->
<select id="findOrdersAndUser" resultType="blog.csdn.net.mchenys.poj.CustomerOrders">
select o.* ,u.id uid,username,birthday,sex,address
from orders o,user u
where o.user_id = u.id;
</select>
</mapper>
对应的OrderMapperTest测试类代码:
package blog.csdn.net.mchenys.test;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
import blog.csdn.net.mchenys.mapper.OrderMapper;
import blog.csdn.net.mchenys.poj.CustomerOrders;
import blog.csdn.net.mchenys.poj.Orders2;
public class OrderMapperTest {
private SqlSessionFactory factory;
@Before
public void setUp() throws Exception {
InputStream config = Resources.getResourceAsStream("SqlMapConfig.xml");
factory = new SqlSessionFactoryBuilder().build(config);
}
@Test
public void testFindOrdersAndUser() {
SqlSession session = factory.openSession();
OrderMapper mapper = session.getMapper(OrderMapper.class);
List<CustomerOrders> list = mapper.findOrdersAndUser();
for (CustomerOrders co : list) {
System.out.println("订单id=" + co.getId() + ", 用户id=" + co.getUid() + ", 用户名=" + co.getUsername() + ", 下单日期="
+ co.getCreatetime());
}
}
}
测试结果如下:
结果和上面的sql语句查询一样,没啥毛病。
方式2
这种方式才是正规的方式，无需创建一个单独的javabean，只需要修改下Orders类，在里面增加一个User对象的引用，为了避免影响到方式一的CustomerOrders类，我这里新建一个订单类就叫Orders2，内容如下：
public class Orders2 {
private Integer id;
private Integer userId;
private String number;
private Date createtime;
private String note;
private User user; //一方，持有用户信息
//getter and setter..
}
然后在OrderMapper.xml映射文件中声明下Orders2 类和User类的属性与sql查询语句字段的对应关系，需要用到一个新的标签，叫做resultMap标签，它有2个属性：
- id：resultMap的唯一标识
- type：存放询查询结果的那个javabean的全路径名称
标签体内会用到下面3个子标签：
-
id 标签：指定主键字段对应关系，有2个属性
- column:sql查询语句用到的字段名
- property:javabean的属性名称
-
result标签：指定非主键字段的对应关系，属性和id标签一样。
-
association标签：指定查询结果的javabean中用于表示另一方的对象与sql查询语句字段的映射关系，他可以包含id标签和 result标签，拥有2个属性
- property：被包含的javabean在指定对象类中的属性名
- javatype：被包含的javabean的类型(全路径名称)
介绍完标签的用法后，在OrderMapper.xml配置文件就可以这样使用resultMap标签：
<!-- 定义resultMap -->
<resultMap id="ordersAndUserMap" type="blog.csdn.net.mchenys.poj.Orders2" >
<!-- 订单表sql语句的映射 -->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<!-- 用户表sql语句的映射 -->
<association property="user" javaType="blog.csdn.net.mchenys.poj.User">
<!-- 这里是uid,是跟查询的sql语句的字段对应的,我这里sql语句对用户表的id字段起了别名是uid -->
<id column="uid" property="id"/>
<result column="username" property="username"/>
<result column="birthday" property="birthday"/>
<result column="sex" property="sex"/>
<result column="address" property="address"/>
</association>
</resultMap>
有了映射关系后，该怎么来用呢？
select标签中有一个resultMap属性，可以用来引入定义好的resultMap，只需要把它的唯一id填写到select标签中的resultMap属性即可，因此select标签可以这样写：
<!-- 通过resultMap属性指定对应的resultMap标签 -->
<select id="findOrdersAndUser2" resultMap="ordersAndUserMap">
select o.* ,u.id uid,username,birthday,sex,address
from orders o, user u
where o.user_id = u.id;
</select>
完整的OrderMapper.xml文件配置如下：
<?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">
<!-- mapper接口代理实现规则:
1.映射文件中namespace要等于接口的全路径名称
2. 映射文件中sql语句的id要等于接口的方法名称
3. 映射文件中传入参数类型要等于接口方法的传入参数类型
4. 映射文件中返回结果集类型要等于接口方法的返回值类型,如果接口方法的返回值类型是集合,那么它表示的就是集合中的泛型参数类型 -->
<mapper namespace="blog.csdn.net.mchenys.mapper.OrderMapper">
<!-- 定义resultMap -->
<resultMap id="ordersAndUserMap" type="blog.csdn.net.mchenys.poj.Orders2" >
<!-- 订单表sql语句的映射 -->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<!-- 用户表sql语句的映射 -->
<association property="user" javaType="blog.csdn.net.mchenys.poj.User">
<!-- 这里是uid,是跟查询的sql语句的字段对应的,我这里sql语句对用户表的id字段起了别名是uid -->
<id column="uid" property="id"/>
<result column="username" property="username"/>
<result column="birthday" property="birthday"/>
<result column="sex" property="sex"/>
<result column="address" property="address"/>
</association>
</resultMap>
<!-- 通过resultMap属性指定对应的resultMap标签 -->
<select id="findOrdersAndUser2" resultMap="ordersAndUserMap">
select o.* ,u.id uid,username,birthday,sex,address
from orders o, user u
where o.user_id = u.id;
</select>
</mapper>
然后在OrderMapper接口中添加findOrdersAndUser2方法：
public List<Orders2> findOrdersAndUser2();
测试类OrderMapperTest中添加下面的测试方法
@Test
public void testFindOrdersAndUser2() {
SqlSession session = factory.openSession();
OrderMapper mapper = session.getMapper(OrderMapper.class);
List<Orders2> list = mapper.findOrdersAndUser2();
for (Orders2 order : list) {
System.out.println("订单id=" + order.getId() + ", 用户id=" + order.getUser().getId() + ", 用户名="
+ order.getUser().getUsername() + ", 下单日期=" + order.getCreatetime());
}
}
执行结果如下：
执行结果和上面的一样，都是3条订单记录，搞定。
767
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
