一对一、一对多、多对多

一对一

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

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

用户表 user

② 订单表order

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

<properties>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>

	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.4.5</version>
	</dependency>

	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.49</version>
	</dependency>

	<!--添加log4j2相关jar包-->
	<dependency>
		<groupId>org.apache.logging.log4j</groupId>
		<artifactId>log4j-api</artifactId>
		<version>2.7</version>
	</dependency>

	<dependency>
		<groupId>org.apache.logging.log4j</groupId>
		<artifactId>log4j-core</artifactId>
		<version>2.7</version>
	</dependency>

	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.11</version>
		<scope>test</scope>
	</dependency>

</dependencies>

<build>
	<pluginManagement>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.5</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
		</plugins>
	</pluginManagement>

	<resources>
		<resource>
			<directory>src/main/resources</directory>
			<excludes>
				<exclude>**/.svn/*</exclude>
			</excludes>
		</resource>
		<resource>
			<directory>src/main/java</directory>
			<excludes>
				<exclude>**/.svn/*</exclude>
			</excludes>
			<includes>
				<include>**/*.xml</include>
			</includes>
		</resource>
	</resources>
</build>

③ 创建实体类

User：

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
                + "]";
    }
}

Order：

public class Order {
    //订单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文件必须满足以下几个条件：

  1. 接口必须要和 xml 文件同名且在同一个包下，也就是说 xml 文件中的namespace是接口的全类名　　
  2. 接口中的方法名和xml 文件中定义的 id 一致
  3. 接口输入参数类型要和xml 中定义的 parameterType 一致
  4. 接口返回数据类型要和xml 中定义的 resultType 一致

OrderMapper 接口：

public interface OrderMapper {
    /**
     * 方式一：嵌套结果
     * select * from order o,user u where o.user_id=u.id and o.id=#{id}
     *
     * @param orderId
     * @return
     */
    //根据订单ID查询订单和用户信息
    Order selectOrderAndUserByOrderID(int orderId);

    /**
     * 方式二：嵌套查询
     * select * from order WHERE id=1; //得到user_id
     * select * from user WHERE id=1   //1 是上一个查询得到的user_id的值
     *
     * @return
     */

    //根据订单ID得到订单信息(包含user_id)
    Order getOrderByOrderId(int orderId);

    //根据用户ID查询用户信息
    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="com.harvey.one.to.one.mapper.OrderMapper">
    <!--
    嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集
                               封装联表查询的数据(去除重复的数据)
     select * from `order` o,user u where o.user_id=u.id and o.id=#{id}
     -->
    <select id="selectOrderAndUserByOrderID" resultMap="getOrderAndUser">
        select * from `order` o,user u where o.user_id=u.id and o.id=#{id}
    </select>
    <resultMap type="com.harvey.po.Order" 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.harvey.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.harvey.po.Order" 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.harvey.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="db.properties"></properties>
    <!-- 定义别名 -->
    <typeAliases>
        <!-- mybatis自动扫描包中的po类，自动定义别名，别名是类名(首字母大写或小写都可以,一般用小写) -->
        <package name="com.harvey.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>
        <!-- 通过OrderMapper接口注册OrdersMapper.xml文件，
           必须保证：接口和xml在同一个包下，而且名字一样
           OrderMapper接口的方法名和OrderMapper.xml文件的id一样
           OrderMapper接口的输出输出参数和OrderMapper.xml文件resultType，parameterType类型一样
        -->
        <mapper class="com.harvey.one.to.one.mapper.OrderMapper"/>
    </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 = "com.harvey.one.to.one.mapper.OrderMapper.selectOrderAndUserByOrderID";
        //创建OrdersMapper对象，mybatis自动生成mapper代理对象
        OrderMapper orderMapper = session.getMapper(OrderMapper.class);
        Order 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 = "com.harvey.one.to.one.mapper.OrderMapper.getOrderByOrderId";
        //创建OrderMapper对象，mybatis自动生成mapper代理对象
        OrderMapper orderMapper = session.getMapper(OrderMapper.class);
        Order order = orderMapper.selectOrderAndUserByOrderID(1);
        System.out.println(order);
        session.close();
    }
}

一对多 

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

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

①、创建实体类

user.java如下，order.java保持不变

public class User {
    //用户ID
    private int id;
    //用户姓名
    private String username;
    //用户性别
    private String sex;
    //一个用户能创建多个订单，用户和订单构成一对多的关系
    public List<Order> 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;
    }

    public List<Order> getOrders() {
        return orders;
    }

    public void setOrders(List<Order> orders) {
        this.orders = orders;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex
                + "]";
    }
}

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

UserMapper接口：

public interface UserMapper {

    //根据用户id查询用户信息，以及用户下面的所有订单信息
    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="com.harvey.one.to.many.mapper.UserMapper">
    <!--
    方式一：嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集
                               封装联表查询的数据(去除重复的数据)
     select * from user u,`order` 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,`order` o where u.id=o.user_id and u.id=#{id}
    </select>
    <resultMap type="com.harvey.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.harvey.po.Order">
            <id column="oid" property="id"/>
            <result column="number" property="number"/>
        </collection>
    </resultMap>
</mapper>

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

④、测试

@Test
public void testSelectOrderAndUserByOrderId(){
	//String statement = "com.harvey.one.to.many.mapper.UserMapper.selectUserAndOrdersByUserId";
	//创建OrdersMapper对象，mybatis自动生成mapper代理对象
	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 

②、建立对应的实体类

Role：

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：

添加属性

//一个用户能被分配多种角色
public List<Role> roles;

UserRole：

public class UserRole {
    
    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 接口

public interface UserMapper {
     
    //给定一个角色id，要得到具有这个角色的所有用户信息
    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="com.harvey.many.to.many.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.harvey.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 文件 

<mappers>
	<!--多对多-->
	<mapper class="com.harvey.many.to.many.UserMapper"/>
</mappers>

⑤ 测试

@Test
public void testGetUserByRoleId(){
	//String statement = "com.harvey.many.to.many.UserMapper.getUserByRoleId";
	//创建OrdersMapper对象，mybatis自动生成mapepr代理对象
	UserMapper userMapper = session.getMapper(UserMapper.class);
	List<User> users = userMapper.getUserByRoleId(1);
	System.out.println(users);
	session.close();
}

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

 

参考：

 

posted @   残城碎梦  阅读(67)  评论(0)  编辑  收藏  举报
相关博文：
· 基于XML的入门示例
· 源码讲解 —— 接口代理
· Mybatis多表查询
· Mybatis-Plus 如何实现一对多关系 举例 用户与角色
· Mybatis06_多表查询（一对一、一对多、多对多）
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！
点击右上角即可分享
微信分享提示