前言

创建数据库表（user和message），并插入数据：

  1. CREATE TABLE `user` (
  2. `id`  varchar(64) NOT NULL ,
  3. `name`  varchar(64) NULL ,
  4. PRIMARY KEY (`id`)
  5. );
  7. CREATE TABLE `info` (
  8. `id`  varchar(64) NOT NULL ,
  9. `uid`  varchar(64) NULL ,
  10. `msg`  varchar(255) NULL ,
  11. PRIMARY KEY (`id`)
  12. );
  15. INSERT INTO `user` (`id`, `name`) VALUES ('1001', 'ahzoo');
  16. INSERT INTO `user` (`id`, `name`) VALUES ('1002', 'ouo');
  17. INSERT INTO `info` (`id`, `uid`, `msg`) VALUES ('2001', '1001', '测试信息');
  18. INSERT INTO `info` (`id`, `uid`, `msg`) VALUES ('2002', '1001', '第二条信息');

再创建两个数据库表（role和user_role），并插入数据，用于多对多操作：

  1. CREATE TABLE `role` (
  2. `id`  varchar(64) NOT NULL ,
  3. `name`  varchar(64) NULL ,
  4. PRIMARY KEY (`id`)
  5. );
  8. CREATE TABLE `user_role` (
  9. `user_id`  varchar(64) NOT NULL ,
  10. `role_id`  varchar(64) NOT NULL 
  11. );
  14. INSERT INTO `role` (`id`, `name`) VALUES ('3001', '用户');
  15. INSERT INTO `role` (`id`, `name`) VALUES ('3002', '管理员');
  17. INSERT INTO `user_role` (`user_id`, `role_id`) VALUES ('1001', '3001');
  18. INSERT INTO `user_role` (`user_id`, `role_id`) VALUES ('1001', '3002');
  19. INSERT INTO `user_role` (`user_id`, `role_id`) VALUES ('1002', '3002');

创建一个springboot项目，并生成增删改查，快速开始。
项目结构：
image.png
依赖：

  1.     <dependencies>
  2.         <dependency>
  3.             <groupId>mysql</groupId>
  4.             <artifactId>mysql-connector-java</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.mybatis.spring.boot</groupId>
  8.             <artifactId>mybatis-spring-boot-starter</artifactId>
  9.             <version>2.2.2</version>
  10.         </dependency>
  11.         <dependency>
  12.             <groupId>org.springframework.boot</groupId>
  13.             <artifactId>spring-boot-starter</artifactId>
  14.         </dependency>
  15.         <dependency>
  16.             <groupId>org.projectlombok</groupId>
  17.             <artifactId>lombok</artifactId>
  18.             <optional>true</optional>
  19.         </dependency>
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter-test</artifactId>
  23.             <scope>test</scope>
  24.         </dependency>
  25.     </dependencies>

一对一

一条信息对应一个发送者，查询信息的发送者。
在Info实体类中增加User对象，这样在对user和info进行联查时，将User对象一起返回：
entity/Info

  1. import lombok.Data;
  2. @Data
  3. public class Info {
  4.     private String id;
  5.     private String uid;
  6.     private String msg;
  7. //    接收一对一查询到的User对象
  8.     private User user;
  9. }

映射文件：
mapper/InfoDao.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.example.demo.mapper.InfoMapper">
  7. <!--    使用Map对象作为返回结果-->
  8.     <select id="selectListToMap" resultType="Map">
  9.         SELECT u.id,u.name,i.id,i.uid,i.msg 
  10.         FROM user u,info i 
  11.         WHERE u.id=i.uid
  12.     </select>
  15.     <resultMap id="BaseResultMap" type="com.example.demo.entity.Info">
  16.         <id property="id" column="id" jdbcType="VARCHAR"/>
  17.         <result property="uid" column="uid" jdbcType="VARCHAR"/>
  18.         <result property="msg" column="msg" jdbcType="VARCHAR"/>
  19.         <association property="user" javaType="com.example.demo.entity.User">
  20. <!--            这里为id字段取个别名（user_id），方便与上面的表的id字段进行区分，然后在下面对别名使用AS进行映射即可-->
  21.             <id property="id" column="user_id" jdbcType="VARCHAR"/>
  22.             <result property="name" column="name" jdbcType="VARCHAR"/>
  23.         </association>
  24.     </resultMap>
  27. <!--    使用Info对象作为返回结果-->
  28.     <select id="selectListByMap" resultMap="BaseResultMap">
  29.         SELECT u.id AS user_id,u.name,i.id,i.uid,i.msg 
  30.         FROM user u,info i 
  31.         WHERE u.id=i.uid
  32.     </select>
  34. </mapper>

持久层：
mapper/InfoMapper

  1. import com.example.demo.entity.Info;
  2. import org.apache.ibatis.annotations.Mapper;
  3. import java.util.List;
  4. import java.util.Map;
  6. @Mapper
  7. public interface InfoMapper {
  8.     List<Map<String,String>> selectListToMap();
  9.     List<Info> selectListByMap();
  10. }

测试：
查询目标信息对应的用户信息

  1. import com.example.demo.entity.Info;
  2. import com.example.demo.mapper.InfoMapper;
  3. import org.junit.jupiter.api.Test;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.boot.test.context.SpringBootTest;
  7. import java.util.List;
  8. import java.util.Map;
  11. @SpringBootTest
  12. class InfoTests {
  14.     @Autowired
  15.     InfoMapper infoMapper;
  17.     /**
  18.      * 使用Map对象作为返回结果
  19.      */
  20.     @Test
  21.     public void toGetMapResult(){
  22.         List<Map<String, String>> infos = infoMapper.selectListToMap();
  23.         infos.forEach(System.out::println); 
  24.         /*
  25.         {msg=测试信息, uid=1001, name=ahzoo, id=1001}
  26.         {msg=第二条信息, uid=1001, name=ahzoo, id=1001}
  27.          */
  28.     }
  30.     /**
  31.      * 使用Info对象作为返回结果
  32.      */
  33.     @Test
  34.     public void toGetInfoResult(){
  35.         List<Info> infos = infoMapper.selectListByMap();
  36.         infos.forEach(System.out::println); 
  37.         /*
  38.         Info(id=2001, uid=1001, msg=测试信息, user=User(id=1001, name=ahzoo))
  39.         Info(id=2002, uid=1001, msg=第二条信息, user=User(id=1001, name=ahzoo))
  40.          */
  41.     }
  44. }

image.png

一对多

一个用户可以发送多条信息，查询用户下的所有信息。
在User实体类中增加Info的List对象，用于返回查询到的多个Info对象：
entity/User

  1. import lombok.Data;
  2. import java.util.List;
  4. @Data
  5. public class User{
  6.     private String id;
  7.     private String name;
  8. //    接收一对多查询到的Info对象集合
  9.     private List<Info> infos;
  10. }

持久层：
mapper/UserMapper

  1. import com.example.demo.entity.User;
  2. import org.apache.ibatis.annotations.Mapper;
  3. import java.util.List;
  4. @Mapper
  5. public interface UserMapper {
  6.     List<User> findAllByMap();
  7. }

映射文件：
mapper/UserMapper.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.example.demo.mapper.UserMapper">
  7.     <resultMap id="BaseResultMap" type="com.example.demo.entity.User">
  8.         <id property="id" column="id" jdbcType="VARCHAR"/>
  9.         <result property="name" column="name" jdbcType="VARCHAR"/>
  10.         <!--配置集合信息
  11.         property：自定义集合的名称
  12.         ofType：集合的数据类型
  13.         -->
  14.         <collection property="infos" ofType="com.example.demo.entity.Info">
  15.             <result property="id" column="info_id" jdbcType="VARCHAR"/>
  16.             <result property="uid" column="uid" jdbcType="VARCHAR"/>
  17.             <result property="msg" column="msg" jdbcType="VARCHAR"/>
  18.         </collection>
  19.     </resultMap>
  22.     <!-- 查询目标用户所有发布的信息（这里使用左外连接查询） -->
  23.     <select id="findAllByMap" resultMap="BaseResultMap">
  24.         SELECT u.id,u.name,i.id AS info_id,i.uid,i.msg
  25.         FROM user u
  26.         LEFT OUTER JOIN info i
  27.              ON u.id = i.uid;
  28.     </select>
  30. </mapper>

测试：

  2. import com.example.demo.entity.User;
  3. import com.example.demo.mapper.UserMapper;
  4. import org.junit.jupiter.api.Test;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.test.context.SpringBootTest;
  8. import java.util.List;
  9. @SpringBootTest
  10. public class UserTests {
  12.     @Autowired
  13.     UserMapper userMapper;
  15.     @Test
  16.     public void toGetAll(){
  17.         List<User> allByMap = userMapper.findAllByMap();
  18.         allByMap.forEach(System.out::println);
  19.         /*
  20.         User(id=1001, name=ahzoo, infos=[Info(id=2001, uid=1001, msg=测试信息, user=null), Info(id=2002, uid=1001, msg=第二条信息, user=null)])
  21.          */
  22.     }
  24. }

可以看到所有用户下的所有信息都被查询到

image.png

多对多

一个用户可以有多个角色，一个角色可以属于多个用户，查询用户对应的角色，及角色对应的用户。
在User实体类中增加Role的List对象，用于返回查询到的多个Role对象：
entity/User

  1. import lombok.Data;
  2. import java.util.List;
  4. @Data
  5. public class User{
  6.     private String id;
  7.     private String name;
  8.     private List<Role> roles;
  9. }

同理：
entity/Role

  1. import lombok.Data;
  2. import java.util.List;
  4. @Data
  5. public class Role {
  7.     private String id;
  8.     private String name;
  9.     private List<User> users;
  10. }

持久层：
mapper/RoleMapper

  1. import com.example.demo.entity.Role;
  2. import org.apache.ibatis.annotations.Mapper;
  3. import java.util.List;
  4. @Mapper
  5. public interface RoleMapper {
  6.     List<Role> getAllUser();
  7. }

mapper/UserMapper

  1. import com.example.demo.entity.User;
  2. import org.apache.ibatis.annotations.Mapper;
  3. import java.util.List;
  4. @Mapper
  5. public interface UserMapper {
  6.     List<User> getAllRole();
  7. }

映射文件：
mapper/RoleMapper

  2.     <resultMap id="roleMap" type="com.example.demo.entity.Role">
  3.         <id property="id" column="id" jdbcType="VARCHAR"/>
  4.         <result property="name" column="name" jdbcType="VARCHAR"/>
  5.         <collection property="users" ofType="com.example.demo.entity.User">
  6.             <result property="id" column="role_id" jdbcType="VARCHAR"/>
  7.             <result property="name" column="name" jdbcType="VARCHAR"/>
  8.         </collection>
  9.     </resultMap>
  11.     <select id="getAllUser" resultMap="roleMap">
  12.         SELECT u.id,u.name,r.id AS role_id,r.name
  13.         FROM user u
  14.         LEFT OUTER JOIN user_role ur ON u.id = ur.user_id
  15.         LEFT OUTER JOIN role r ON r.id = ur.role_id
  16.     </select>

mapper/UserMapper

  2.     <resultMap id="userMap" type="com.example.demo.entity.User">
  3.         <id property="id" column="id" jdbcType="VARCHAR"/>
  4.         <result property="name" column="name" jdbcType="VARCHAR"/>
  5.         <collection property="roles" ofType="com.example.demo.entity.Role">
  6.             <result property="id" column="role_id" jdbcType="VARCHAR"/>
  7.             <result property="name" column="name" jdbcType="VARCHAR"/>
  8.         </collection>
  9.     </resultMap>
  11.     <select id="getAllRole" resultMap="userMap">
  12.         SELECT u.id,u.name,r.id AS role_id,r.name
  13.         FROM user u
  14.         LEFT OUTER JOIN user_role ur ON u.id = ur.user_id
  15.         LEFT OUTER JOIN role r ON r.id = ur.role_id
  16.     </select>

测试：

  2.     @Autowired
  3.     RoleMapper roleMapper;
  4.     @Autowired
  5.     UserMapper userMapper;
  7.     @Test
  8.     public void toGetAllUser(){
  9.         List<Role> allUser = roleMapper.getAllUser();
  10.         allUser.forEach(System.out::println);
  11. /*
  12.         Role(id=1001, name=ahzoo, users=[User(id=3001, name=ahzoo, roles=null), User(id=3002, name=ahzoo, roles=null)])
  13.         Role(id=1002, name=ouo, users=[User(id=null, name=ouo, roles=null)])
  14. */
  16.     }
  17.     @Test
  18.     public void toGetAllRole(){
  19.         List<User> allRole = userMapper.getAllRole();
  20.         allRole.forEach(System.out::println);
  22. /*
  23.         User(id=1001, name=ahzoo, roles=[Role(id=3001, name=ahzoo, users=null), Role(id=3002, name=ahzoo, users=null)])
  24.         User(id=1002, name=ouo, roles=[Role(id=null, name=ouo, users=null)])
  26.  */
  27.     }

image.png
image.png