但行好事
莫论前程❤

mybatis 详解(七)— 一对一、一对多、多对多

示例源码: https://pan.baidu.com/s/1qY47nQHj6BPmsYezxEBuuA 密码: u54b
目录

  • 1、一对一
  • 2、一对多
  • 3、多对多

​ 前面几篇博客我们用mybatis能对单表进行增删改查操作了,也能用动态SQL书写比较复杂的sql语句。但是在实际开发中,我们做项目不可能只是单表操作,往往会涉及到多张表之间的关联操作。我们现在来学习如何用 mybatis 处理多表之间的关联操作呢?

1、一对一

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

①、创建用户表 user 和订单表 orders

用户表 user
img

订单表 orders

img

②、创建项目工程,导入相应的 jar 包

img

③、创建实体类

img

User.java

public class User {
    //用户ID
    private int id;
    //用户姓名
    private String username;
    //用户性别
    private String sex;
... get和set方法
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex
                + "]";
    }
}

Orders.java

public class Orders {
    //订单ID
    private int id;
    //用户ID
    private int userId;
    //订单数量
    private String number;
    //和用户表构成一对一的关系,即一个订单只能由一个用户创建
    private User user;

    @Override
    public String toString() {
        return "Orders [id=" + id + ", userId=" + userId + ", number=" + number
                + ", user=" + user + "]";
    }

}

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

img

由于我们采用 Mapper 代理加载 xxxMapper.xml 文件,这里我们重复一下 Mapper 代理所需的条件,接口和xml文件必须满足以下几个条件:

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

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

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

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

  OrderMapper 接口

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

<?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 文件

<?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="jdbc.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>

⑥、测试

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();
    }
}

2、一对多

​ 还是以用户表 user 和 订单表 orders 为例,一个用户能创建多个订单。故用户和订单构成一对多的关联。

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

①、创建实体类

 user.java如下,orders.java保持不变

public class User {
    //用户ID
    private int id;
    //用户姓名
    private String username;
    //用户性别
    private String sex;
    //一个用户能创建多个订单,用户和订单构成一对多的关系
    public List<Orders> orders;
    ...
}

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

img

UserMapper接口

package one.to.many.mapper;

import com.ys.po.User;

public interface UserMapper {
    //根据用户id查询用户信息,以及用户下面的所有订单信息
    public User selectUserAndOrdersByUserId(int UserId);

}

UserMapper.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 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 文件

img

、测试

@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();
}

3、多对多

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

  需求:给定角色id,查询这个角色所属的所有用户信息

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

  user 表和上面的保持不变

  role 表

img

两者之间的关联表user_role

img

②、建立对应的实体类

  User.java

public class User{
    private Integer id; //用户ID
    private String  username; //用户名称
    private String sex;    //性别
    public List<Orders> orders //一个用户能创建多个订单,用户和订单构成一对多的关系
    public List<Role> roles;   // 一个用户能够分配多种角色
}

Role.java

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

    private List<User> users;
}

User_Role.java

public class User_Role {
    private User user;
    private Role role;
}

、创建 UserMapper 接口和 UserMapper.xml 文件

  UserMapper 接口

public interface UserMapper {

    //给定一个角色id,要得到具有这个角色的所有用户信息
    public List<User> getUserByRoleId(int roleId);

}

UserMapper.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 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 文件

img

⑤、测试

@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();
}

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

赞(1) 打赏
未经允许不得转载:刘鹏博客 » mybatis 详解(七)— 一对一、一对多、多对多
分享到: 更多 (0)

评论 抢沙发

评论前必须登录!

 

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏