mybatis 详解（七）------一对1、一对多、多对多

时间  2019-11-09
标签 mybatis 详解 一对 一对多 多对 栏目 MyBatis 繁體版
原文   原文链接

前面几篇博客咱们用mybatis能对单表进行增删改查操做了，也能用动态SQL书写比较复杂的sql语句。可是在实际开发中，咱们作项目不可能只是单表操做，每每会涉及到多张表之间的关联操做。那么咱们如何用 mybatis 处理多表之间的关联操做呢？请看本篇博客详解。html

　　本篇详细代码：http://pan.baidu.com/s/1eSzmst8 密码：3n3ojava

一、一对一

　　咱们以用户表 user 和订单表 orders 为例。设定一个订单只能由一个 用户建立，那么由订单到用户就是一对一的关系。sql

①、建立用户表 user 和订单表 orders数据库

　　用户表 userapache

　　

　　订单表 orderssession

　　

②、建立项目工程，导入相应的 jar 包mybatis

　　

 

 ③、建立实体类app

　　

　　User.javaide

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package  com.ys.po;
 
public  class  User {
     //用户ID
     private  int  id;
     //用户姓名
     private  String username;
     //用户性别
     private  String sex;
     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 getSex() {
         return  sex;
     }
     public  void  setSex(String sex) {
         this .sex = sex;
     }
     @Override
     public  String toString() {
         return  "User [id="  + id +  ", username="  + username +  ", sex="  + sex
                 +  "]" ;
     }
}

　　Orders.java测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package  com.ys.po;
 
public  class  Orders {
     //订单ID
     private  int  id;
     //用户ID
     private  int  userId;
     //订单数量
     private  String number;
     //和用户表构成一对一的关系，即一个订单只能由一个用户建立
     private  User user;
     
     public  int  getId() {
         return  id;
     }
 
     public  void  setId( int  id) {
         this .id = id;
     }
 
     public  int  getUserId() {
         return  userId;
     }
 
     public  void  setUserId( int  userId) {
         this .userId = userId;
     }
 
     public  String getNumber() {
         return  number;
     }
 
     public  void  setNumber(String number) {
         this .number = number;
     }
 
     public  User getUser() {
         return  user;
     }
 
     public  void  setUser(User user) {
         this .user = user;
     }
 
     @Override
     public  String toString() {
         return  "Orders [id="  + id +  ", userId="  + userId +  ", number="  + number
                 +  ", user="  + user +  "]" ;
     }
 
}

　　

④、建立 OrderMapper 接口和 OrderMapper.xml 文件

　　

　　因为咱们采用 Mapper 代理加载 xxxMapper.xml 文件，这里咱们重复一下 Mapper 代理所需的条件，接口和xml文件必须知足如下几个条件：

　　一、接口必需要和 xml 文件同名且在同一个包下，也就是说 xml 文件中的namespace是接口的全类名　　

　　二、接口中的方法名和xml 文件中定义的 id 一致

　　三、接口输入参数类型要和xml 中定义的 parameterType 一致

　　四、接口返回数据类型要和xml 中定义的 resultType 一致

　　详细介绍参考上一篇博客：http://www.cnblogs.com/ysocean/p/7301548.html

　　OrderMapper 接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package  one.to.one.mapper;
 
import  com.ys.po.Orders;
import  com.ys.po.User;
 
public  interface  OrdersMapper {
     /**
      * 方式一：嵌套结果
      * select * from orders o,user u where o.user_id=u.id and o.id=#{id}
      * @param orderId
      * @return
      */
     //根据订单ID查询订单和用户信息
     public  Orders selectOrderAndUserByOrderID( int  orderId);
     
     /**
      * 方式二：嵌套查询
      * select * from order WHERE id=1;//获得user_id
      * select * from user WHERE id=1   //1 是上一个查询获得的user_id的值
      * @param userID
      * @return
      */
     //根据订单ID获得订单信息(包含user_id)
     public  Orders getOrderByOrderId( int  orderId);
     //根据用户ID查询用户信息
     public  User getUserByUserId( int  userID);
 
}

　　

　　OrderMapper .xml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
<?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 namespace= "one.to.one.mapper.OrdersMapper" >
     <!--
     嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集
                                封装联表查询的数据(去除重复的数据)
      select * from orders o,user u where o.user_id=u.id and o.id=#{id}
      -->
     <select id= "selectOrderAndUserByOrderID"  resultMap= "getOrderAndUser" >
         select * from orders o,user u where o.user_id=u.id and o.id=#{id}
     </select>
     <resultMap type= "com.ys.po.Orders"  id= "getOrderAndUser" >
         <!--
             id:指定查询列表惟一标识，若是有多个惟一标识，则配置多个id
             column:数据库对应的列
             property:实体类对应的属性名
           -->
         <id column= "id"  property= "id" />
         <result column= "user_id"  property= "userId" />
         <result column= "number"  property= "number" />
         <!--association:用于映射关联查询单个对象的信息
             property:实体类对应的属性名
             javaType:实体类对应的全类名
           -->
         <association property= "user"  javaType= "com.ys.po.User" >
             <!--
                 id:指定查询列表惟一标识，若是有多个惟一标识，则配置多个id
                 column:数据库对应的列
                 property:实体类对应的属性名
               -->
             <id column= "id"  property= "id" />
             <result column= "username"  property= "username" />
             <result column= "sex"  property= "sex" />
         </association>
     </resultMap>
     
     
     <!--
          方式二：嵌套查询：经过执行另一个SQL映射语句来返回预期的复杂类型
          select user_id from order WHERE id= 1 ; //获得user_id
          select * from user WHERE id= 1    //1 是上一个查询获得的user_id的值
          property:别名(属性名)    column：列名 -->
     <select id= "getOrderByOrderId"  resultMap= "getOrderMap" >
         select * from order where id=#{id}
     </select>
     <resultMap type= "com.ys.po.Orders"  id= "getOrderMap" >
         <id column= "id"  property= "id" />
         <result column= "number"  property= "number" />
         <association property= "userId"   column= "id"  select= "getUserByUserId" >
         
         </association>
     </resultMap>
     <select id= "getUserByUserId"  resultType= "com.ys.po.User" >
         select * from user where id=#{id}
     </select>
     
</mapper>

　　

⑤、向 mybatis-configuration.xml 配置文件中注册 OrderMapper.xml 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?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>
<!-- 加载数据库属性文件 -->
<properties resource= "db.properties" ></properties>
<!-- 定义别名 -->
<typeAliases>
     <!-- mybatis自动扫描包中的po类，自动定义别名，别名是类名(首字母大写或小写均可以,通常用小写) -->
     < package  name= "com.ys.po" />
</typeAliases>
  <environments  default = "development" >
     <environment id= "development" >
       <transactionManager type= "JDBC" />
       <!--dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 链接对象源  -->
       <dataSource type= "POOLED" >
         <property name= "driver"  value= "${jdbc.driver}" />
         <property name= "url"  value= "${jdbc.url}" />
         <property name= "username"  value= "${jdbc.username}" />
         <property name= "password"  value= "${jdbc.password}" />
       </dataSource>
     </environment>
   </environments>
   
   <mappers>
          <!-- 经过OrdersMapper接口注册OrdersMapper.xml文件，
             必须保证：接口和xml在同一个包下，并且名字同样
             OrdersMapper接口的方法名和OrdersMapper.xml文件的id同样
             OrdersMapper接口的输出输出参数和OrdersMapper.xml文件resultType，parameterType类型同样
          -->
          <mapper  class = "one.to.one.mapper.OrdersMapper" />
   </mappers>
</configuration>

　　

⑥、测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package  one.to.one.mapper;
 
import  java.io.InputStream;
 
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  com.ys.po.Orders;
 
public  class  OneToOneTest {
     //定义 SqlSession
     SqlSession session = null ;
     
     @Before
     public  void  init(){
         //定义mybatis全局配置文件
         String resource =  "mybatis-configuration.xml" ;
         //加载 mybatis 全局配置文件
         InputStream inputStream = OneToOneTest. class .getClassLoader()
                                     .getResourceAsStream(resource);
         //构建sqlSession的工厂
         SqlSessionFactory sessionFactory =  new  SqlSessionFactoryBuilder().build(inputStream);
         //根据 sqlSessionFactory 产生 session
         session = sessionFactory.openSession();
     }
     
     /**
      * 方式一：嵌套结果
      * select * from orders o,user u where o.user_id=u.id and o.id=#{id}
      */
     @Test
     public  void  testSelectOrderAndUserByOrderId(){
         String statement =  "one.to.one.mapper.OrdersMapper.selectOrderAndUserByOrderID" ;
         //建立OrdersMapper对象，mybatis自动生成mapepr代理对象
         OrdersMapper orderMapper = session.getMapper(OrdersMapper. class );
         Orders order = orderMapper.selectOrderAndUserByOrderID( 1 );
         System.out.println(order);
         session.close();
     }
     
     /**
      * 方式二：嵌套查询
      * select * from order WHERE id=1;//获得user_id
      * select * from user WHERE id=1   //1 是上一个查询获得的user_id的值
      */
     @Test
     public  void  testgetOrderByOrderId(){
         String statement =  "one.to.one.mapper.OrdersMapper.getOrderByOrderId" ;
         //建立OrdersMapper对象，mybatis自动生成mapepr代理对象
         OrdersMapper orderMapper = session.getMapper(OrdersMapper. class );
         Orders order = orderMapper.selectOrderAndUserByOrderID( 1 );
         System.out.println(order);
         session.close();
     }
}

　　

 

 

二、一对多

　　仍是以用户表 user 和 订单表 orders 为例，一个用户能建立多个订单。故用户和订单构成一对多的关联。

　　咱们在 user.java 中添加一个属性 public List<Orders> orders;

①、建立实体类

　　user.java以下，orders.java保持不变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package  com.ys.po;
 
import  java.util.List;
 
public  class  User {
     //用户ID
     private  int  id;
     //用户姓名
     private  String username;
     //用户性别
     private  String sex;
     //一个用户能建立多个订单，用户和订单构成一对多的关系
     public  List<Orders> orders;
     
     public  List<Orders> getOrders() {
         return  orders;
     }
     public  void  setOrders(List<Orders> orders) {
         this .orders = orders;
     }
     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 getSex() {
         return  sex;
     }
     public  void  setSex(String sex) {
         this .sex = sex;
     }
     @Override
     public  String toString() {
         return  "User [id="  + id +  ", username="  + username +  ", sex="  + sex
                 +  "]" ;
     }
}

　　

②、建立 UserMapper 接口和 UserMapper.xml 文件

　　

 

　　UserMapper接口

1
2
3
4
5
6
7
8
9
package  one.to.many.mapper;
 
import  com.ys.po.User;
 
public  interface  UserMapper {
     //根据用户id查询用户信息，以及用户下面的全部订单信息
     public  User selectUserAndOrdersByUserId( int  UserId);
 
}

　　UserMapper.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<?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 namespace= "one.to.many.mapper.UserMapper" >
     <!--
     方式一：嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集
                                封装联表查询的数据(去除重复的数据)
      select * from user u,orders o where u.id=o.user_id and u.id=#{id}
      -->
     <select id= "selectUserAndOrdersByUserId"  resultMap= "getUserAndOrders" >
         select u.*,o.id oid,o.number number from user u,orders o where u.id=o.user_id and u.id=#{id}
     </select>
     <resultMap type= "com.ys.po.User"  id= "getUserAndOrders" >
         <!--id:指定查询列表惟一标识，若是有多个惟一标识，则配置多个id
             column:数据库对应的列
             property:实体类对应的属性名 -->
         <id column= "id"  property= "id" />
         <result column= "username"  property= "username" />
         <result column= "sex"  property= "sex" />
         <!--
             property:实体类中定义的属性名
             ofType：指定映射到集合中的全类名
           -->
         <collection property= "orders"  ofType= "com.ys.po.Orders" >
             <id column= "oid"  property= "id" />
             <result column= "number"  property= "number" />
         </collection>
     </resultMap>
</mapper>

　　

 ③、向 mybatis-configuration.xml 配置文件中注册 UserMapper.xml 文件

　　

 

④、测试

1
2
3
4
5
6
7
8
9
@Test
public  void  testSelectOrderAndUserByOrderId(){
     String statement =  "one.to.many.mapper.UserMapper.selectUserAndOrdersByUserId" ;
     //建立OrdersMapper对象，mybatis自动生成mapepr代理对象
     UserMapper userMapper = session.getMapper(UserMapper. class );
     User user = userMapper.selectUserAndOrdersByUserId( 1 );
     System.out.println(user.getOrders().size());
     session.close();
}

　　

 

 

三、多对多

 　　这里咱们以用户 user 表和 角色role 表为例，假定一个用户能被分配成多重角色，而一种角色也能分给多个用户，故用户和角色构成多对多的关系。

　　需求：给定角色id，查询这个角色所属的全部用户信息

①、在数据库中创建相应的表

　　user 表和上面的保持不变

　　role 表

　　

　　二者之间的关联表user_role 

　　

 

②、创建对应的实体类

　　User.java

　　

　　Role.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package  com.ys.po;
 
import  java.util.List;
 
public  class  Role {
     private  int  id;
     private  String name;
     
     private  List<User> users;
 
     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  List<User> getUsers() {
         return  users;
     }
 
     public  void  setUsers(List<User> users) {
         this .users = users;
     }
 
}

　　User_Role.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package  com.ys.po;
 
public  class  User_Role {
     private  User user;
     private  Role role;
     public  User getUser() {
         return  user;
     }
     public  void  setUser(User user) {
         this .user = user;
     }
     public  Role getRole() {
         return  role;
     }
     public  void  setRole(Role role) {
         this .role = role;
     }
}

　　

 ③、建立 UserMapper 接口和 UserMapper.xml 文件

 　　UserMapper 接口

1
2
3
4
5
6
7
8
9
10
11
12
package  many.to.many.mapper;
 
import  java.util.List;
 
import  com.ys.po.User;
 
public  interface  UserMapper {
     
     //给定一个角色id，要获得具备这个角色的全部用户信息
     public  List<User> getUserByRoleId( int  roleId);
 
}

　　UserMapper.xml 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?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 namespace= "many.to.many.mapper.UserMapper" >
     
     <select id= "getUserByRoleId"  resultMap= "getUserMap" >
         select * from user_role ur,user u where ur.user_id=u.id and ur.role_id=#{id}
     </select>
     
     <resultMap type= "com.ys.po.User"  id= "getUserMap" >
         <id column= "id"  property= "id" />
         <result column= "username"  property= "username" />
         <result column= "sex"  property= "sex" />
     </resultMap>
</mapper>

　　

  ④、向 mybatis-configuration.xml 配置文件中注册 UserMapper.xml 文件

 　　

⑤、测试

1
2
3
4
5
6
7
8
@Test
public  void  testGetUserByRoleId(){
     String statement =  "many.to.many.mapper.UserMapper.getUserByRoleId" ;
     //建立OrdersMapper对象，mybatis自动生成mapepr代理对象
     UserMapper userMapper = session.getMapper(UserMapper. class );
     List<User> users = userMapper.getUserByRoleId( 1 );
     session.close();
}

　　多对多主要是关联关系要找好，而后根据关联去查询。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程