1 一对多、多对多、自关联多对多、自关联一对多场景描述
 
之前在做网页开发的时候一直用Sqlalchemy来操作数据库，当我用到自关联多对多和自关联一对多的时候，sqlalchemy的配置会有一些辅助的参数，配置起来很麻烦，灵机一动我就想了一下，为什么不能直接写sql呢！！！虽然sql语句写起来不是很方便，但是sql才是各种ORM框架的基本，话不多说，开搞
 
1.1 概念
 
本节内容是自己对于数据库表直接关系的一些个人理解，非官方语言描述，都是大白话
 
一对多关系：
 
生活中有很多一对多关系的实例，比如一个教师内有n个上课的学生，教师是一方，学生是多方
工作中每个职位的多名员工，职位是一方，同属这个职位的员工是多方
项目开发中可能会遇到一些权限的划分，权限规则role 和 同一个role下面的user也是一个一对多的关系
 
多对多关系：
 
学生选课系统，所选的课程与选课的学生就是一个多对多关系，多对多关系不能通过主键与外键的关联实现，
必须建一个三方表，三方表中存放两个关系表的主键，将一个多对多的关系转换成两个一对多的关系。
在第三张表中通过外键关联另外两张表的主键
 
自关联一对多关系：
 
新闻网站、社交网站的评论系统就是一个自关联的一对多关系，一条评论可以有n条子评论，
但是一条子评论只能有一条父评论
 
自关联多对多关系：
 
典型的自关联多对多是用户关注表，比如微博、等社交软件，用户表之间会存在自关联多对多关系，
一个用户可以有n个粉丝，同样一个用户也可以被N个用户关注
 
1.2 创建表格& 插入数据
 
一对多关系：
 
# 1：role表 M：user表
# 新建roles表 
create table roles(
	id int primary key auto_increment,
	name varchar(10) unique not null
)charset=utf8; 
# 插入一些测试数据
insert into roles (`name`) values ("admin"),("other");
# 新建users表
CREATE TABLE `test`.`users`  (
  `id` int(0) NOT NULL AUTO_INCREMENT,
  `uname` varchar(255) NULL,
  `role_id` int(0) NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `role_id` FOREIGN KEY (`role_id`) REFERENCES `test`.`roles` (`id`)
);
# 插入一些测试数据
insert into users (`uname`,`r_id`) values ("张三",1),("里斯",2),("王刚",2),
("金鹏展翅",2),("大鸟飞天",2),("花花公子",2),("犯上作乱",2),("天兵天将",2),("非你莫属",2)

 
多对多关系：
 
# 用户表、兴趣爱好表、user_habbit_table
# 新建兴趣爱好表
create table habbits (
	id int primary key auto_increment,
	hname varchar(30)
)charset=utf8;
# 插入一些测试数据
insert into habbits (hname) 
values ("打篮球"),("打台球"),("踢足球"),("乒乓球"),("橄榄球"),("羽毛球"),("网球")

# 新建用户与爱好关联表
CREATE TABLE `test`.`union_table`  (
  `id` int(0) NOT NULL AUTO_INCREMENT,
  `user_id` int(0) NULL,
  `h_id` int(0) NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `user_id` FOREIGN KEY (`user_id`) REFERENCES `test`.`users` (`id`),
  CONSTRAINT `habbit_id` FOREIGN KEY (`h_id`) REFERENCES `test`.`habbits` (`id`)
);
# 插入测试数据
insert into union_table (user_id,h_id) values (1,1),(1,2),(1,5),(2,4),(2,3),(2,7),(3,1),(3,2),(3,3),(3,6)
 
自关联一对多关系：
 
# 创建评论表
create table comments (
	id int primary key auto_increment,
	content varchar(200),
	parent_id int,
	ctime TIMESTAMP default now()
) charset =utf8;
# 插入测试数据
insert into comments (content,parent_id) values ("今天天气真好",NULL),
("我觉得文章写的不错",NULL),
("为什么今天库里投篮不准了",NULL),
("明天上学的路上我要买一张报纸",NULL),
("你是一个乖宝宝",NULL)

# 添加子评论
insert into comments (content,parent_id) values ("天龙八部好看",1),
("乔丹的篮球打的很棒",2),
("明天是周末，可以出去玩",3),
("想想明天的生活也会很好",4),
("今天吃了三个包子",5)


insert into comments (content,parent_id) values ("潘金莲怒打西门庆",1),
("吕布死后，关羽见到谁都是匹夫",2),
("当你慢慢学会设计数据路的时候",3),
("天气虽然很好但是我也不想出去打球",4),
("明明就是一个大骗子非要说自己是好人",5)
 
自关联多对多关系：
 
# 自关联一对多可以在一张表中表现出关系，但是自关联多对多需要借助一张follows表才能表现结构
# 新建一张follows表
CREATE TABLE `test`.`Untitled`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `follower_id` int(11) NULL DEFAULT NULL,
  `followed_id` int(11) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `follower_id`(`follower_id`) USING BTREE,
  INDEX `followed_id`(`followed_id`) USING BTREE,
  CONSTRAINT `followed_id` FOREIGN KEY (`followed_id`) REFERENCES `test`.`users` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT,
  CONSTRAINT `follower_id` FOREIGN KEY (`follower_id`) REFERENCES `test`.`users` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
# 插入一些测试数据
insert into follows (follower_id,followed_id) 
values (1,2),(1,3),(1,4),
(2,5),(2,7),(2,1),
(3,6),(3,1),(3,2),
(4,1),(4,2),(4,6)
 
1.3 查询数据
 
一对多查询
 
#  查询某一种角色的所有用户
select * from users 
where r_id = (
select id from roles where name = "other"
)
 
多对多查询
 
# 查询某个人的所有爱好
select * from habbits
where id in (
select h_id from union_table where user_id = (
select id from users where uname like "张三"))

# 查询某一种爱好有哪些用户喜欢
select * from users 
where id in (
select user_id from union_table where h_id = (
select id from habbits where hname like "打篮球"
)
)

 
自关联一对多查询
 
# 查询一级评论
select * from comments 
where parent_id is null

# 查询一个父级评论的所有子评论
select * from comments
where parent_id = 1
 
自关联多对多查询
 
# 查询一个用户的所有粉丝
select u.id,u.uname from follows as f 
inner join users as u on u.id = f.follower_id
where f.followed_id = (
select id from users where uname = "张三"
)
 
1.4 总结
 
本文用的数据库是mysql
 后续会写一个详细的sqlalchemy处理关系表的文章，比对一下两种方法的优劣势

 
Mybatis的多表关联查询（多对多）
 
项目目录结构
实现 Role 到 User 多对多
业务要求
用户与角色的关系模型
编写角色实体类
编写 Role 持久层接口
实现的 SQL 语句
编写映射文件
测试代码
  
实现 User 到 Role 的多对多
业务要求
编写用户实体类
编写 User持久层接口
实现的 SQL 语句
编写映射文件
测试代码
 

 
mybatis中的多表查询：

	示例：用户和角色
		一个用户可以有多个角色
		一个角色可以赋予多个用户
	步骤：
		1、建立两张表：用户表，角色表
			让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含各自的主键，在中间表中是外键。
		2、建立两个实体类：用户实体类和角色实体类
			让用户和角色的实体类能体现出来多对多的关系
			各自包含对方一个集合引用
		3、建立两个配置文件
			用户的配置文件
			角色的配置文件
		4、实现配置：
			当我们查询用户时，可以同时得到用户所包含的角色信息
			当我们查询角色时，可以同时得到角色的所赋予的用户信息
 
项目目录结构
 
 
实现 Role 到 User 多对多
 
 
 
多对多关系其实我们看成是双向的一对多关系。
 
 
业务要求
 
 
 
需求：
 当我们查询角色时，可以同时得到角色的所赋予的用户信息。
 分析：
 查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中间表(USER_ROLE 表)才能关联到用户信息。
 
 
用户与角色的关系模型
 
 
 
用户与角色的多对多关系模型如下：
 
 
 
角色表：
 
 用户表：
 
 用户角色中间表：
 
 
编写角色实体类
 
Role：
 
package com.keafmd.domain;

import java.io.Serializable;
import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: Role
 * @Description: 角色实体类
 * @author: 牛哄哄的柯南
 * @date: 2021-02-12 16:45
 */
public class Role implements Serializable {

    private Integer roleId;
    private String roleName;
    private String roleDesc;

    //多对多的关系映射
    private List<User> users;

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    public Integer getRoleId() {
        return roleId;
    }

    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public String getRoleDesc() {
        return roleDesc;
    }

    public void setRoleDesc(String roleDesc) {
        this.roleDesc = roleDesc;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                '}';
    }
}
 
编写 Role 持久层接口
 
IRoleDao：
 
package com.keafmd.dao;
import com.keafmd.domain.Role;
import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: IRoleDao
 * @Description:
 * @author: 牛哄哄的柯南
 * @date: 2021-02-12 19:01
 */

public interface IRoleDao {

    /**
     * 查询所有角色
     * @return
     */
    List<Role> findAll();

}
 
实现的 SQL 语句
 
select u.*,r.id as rid ,r.role_name ,r.role_desc from role r  
left outer join user_role ur on r.id = ur.rid  
left outer join user u on u.id=ur.uid 
 
执行结果：
 
 
 
 
注意：sql语句换行的时候最好在每行的末尾或开头添加空格，这样可以防止合并成一行时发生错误。
 
 
编写映射文件
 
IRoleDao.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.keafmd.dao.IRoleDao">

    <!--定义role表的resultmap-->
    <resultMap id="roleMap" type="role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="user">
            <id column="id" property="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="birthday"></result>
        </collection>
    </resultMap>

    <!--查询所有-->
    <select id="findAll" resultMap="roleMap">
        select u.*,r.id as rid ,r.role_name ,r.role_desc from role r
        left outer join user_role ur on r.id = ur.rid
        left outer join user u on u.id=ur.uid
    </select>

</mapper>
 
测试代码
 
RoleTest：
 
package com.keafmd.test;

import com.keafmd.dao.IRoleDao;
import com.keafmd.dao.IUserDao;
import com.keafmd.domain.Role;
import com.keafmd.domain.User;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: MybatisTest
 * @Description: 测试类，测试crud操作
 * @author: 牛哄哄的柯南
 * @date: 2021-02-08 15:24
 */
public class RoleTest {

    private InputStream in;
    private SqlSession sqlsession;
    private IRoleDao roleDao;

    @Before // 用于在测试方法执行前执行
    public void init()throws Exception{
        //1.读取配置文件,生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        sqlsession = factory.openSession(); //里面写个true，下面每次就不用了写 sqlsession.commit(); 了
        //4.使用SqlSession创建Dao接口的代理对象
        roleDao = sqlsession.getMapper(IRoleDao.class);
    }

    @After // 用于在测试方法执行后执行
    public void destory() throws Exception{
        //提交事务
        sqlsession.commit();
        //6.释放资源
        sqlsession.close();
        in.close();
    }



    /**
     * 查询所有
     * @throws Exception
     */
    @Test
    public void testFindAll() {
        List<Role> roles = roleDao.findAll();
        for (Role role : roles) {
            System.out.println("--------每个角色的信息---------");
            System.out.println(role);
            System.out.println(role.getUsers());
           
        }
    }

}
 
运行结果：
 
2021-02-13 00:05:47,481 349    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2021-02-13 00:05:47,784 652    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 1027007693.
2021-02-13 00:05:47,784 652    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
2021-02-13 00:05:47,791 659    [           main] DEBUG om.keafmd.dao.IRoleDao.findAll  - ==>  Preparing: select u.*,r.id as rid ,r.role_name ,r.role_desc from role r left outer join user_role ur on r.id = ur.rid left outer join user u on u.id=ur.uid
2021-02-13 00:05:47,842 710    [           main] DEBUG om.keafmd.dao.IRoleDao.findAll  - ==> Parameters: 
2021-02-13 00:05:47,869 737    [           main] DEBUG om.keafmd.dao.IRoleDao.findAll  - <==      Total: 4
--------每个角色的信息---------
Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}
[User{id=41, username='老王', sex='男', address='北京', birthday=Tue Feb 27 17:47:08 CST 2018}, User{id=45, username='新一', sex='男', address='北京', birthday=Sun Mar 04 12:04:06 CST 2018}]
--------每个角色的信息---------
Role{roleId=2, roleName='总裁', roleDesc='管理整个公司'}
[User{id=41, username='老王', sex='男', address='北京', birthday=Tue Feb 27 17:47:08 CST 2018}]
--------每个角色的信息---------
Role{roleId=3, roleName='校长', roleDesc='管理整个学校'}
[]
2021-02-13 00:05:47,871 739    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
2021-02-13 00:05:47,872 740    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
2021-02-13 00:05:47,872 740    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 1027007693 to pool.

Process finished with exit code 0
 
实现 User 到 Role 的多对多
 
业务要求
 
 
 
需求：
 当我们查询用户时，可以同时得到用户所包含的角色信息。
 分析：
 相比上面的实现 Role 到 User 多对多，主要变化就是sql语句的变化。
 
 
编写用户实体类
 
User：
 
package com.keafmd.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: User
 * @Description:
 * @author: 牛哄哄的柯南
 * @date: 2021-02-08 15:16
 */

public class User implements Serializable {
    private Integer id;
    private String username;
    private String sex;
    private String address;
    private Date birthday;

    //多对多的关系映射，一个用户可以具备多个角色
    private List<Role> roles;

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer 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 String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                ", birthday=" + birthday +
                '}';
    }
}
 
编写 User持久层接口
 
IUserDao：
 
package com.keafmd.dao;

import com.keafmd.domain.User;

import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: IUserDao
 * @Description: 用户的持久层接口
 * @author: 牛哄哄的柯南
 * @date: 2021-02-06 19:29
 */

public interface IUserDao {
    /**
     * 查询所有用户，同时获取到用户下所有账户的信息
     * @return
     */
    List<User> findAll();

}
 
实现的 SQL 语句
 
   select u.*,r.id as rid ,r.role_name ,r.role_desc from user u 
   left outer join user_role ur on u.id = ur.uid 
   left outer join role r on r.id=ur.rid 
 
执行结果：
 
 
编写映射文件
 
IUserDao.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.keafmd.dao.IUserDao">

    <!--定义User的resultMap-->
    <resultMap id="userMap" type="user">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="address" column="address"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
        <!--配置角色集合的映射-->
        <collection property="roles" ofType="role">
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="role_desc"></result>
        </collection>

    </resultMap>

    <!--配置查询所有-->
    <select id="findAll" resultMap="userMap">
        select u.*,r.id as rid ,r.role_name ,r.role_desc from user u
        left outer join user_role ur on u.id = ur.uid
        left outer join role r on r.id=ur.rid

    </select>

</mapper>
 
测试代码
 
UserTest ：
 
package com.keafmd.test;

import com.keafmd.dao.IUserDao;
import com.keafmd.domain.User;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: MybatisTest
 * @Description: 测试类，测试crud操作
 * @author: 牛哄哄的柯南
 * @date: 2021-02-08 15:24
 */
public class UserTest {

    private InputStream in;
    private SqlSession sqlsession;
    private IUserDao userDao;

    @Before // 用于在测试方法执行前执行
    public void init()throws Exception{
        //1.读取配置文件,生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        sqlsession = factory.openSession(); //里面写个true，下面每次就不用了写 sqlsession.commit(); 了
        //4.使用SqlSession创建Dao接口的代理对象
        userDao = sqlsession.getMapper(IUserDao.class);
    }

    @After // 用于在测试方法执行后执行
    public void destory() throws Exception{
        //提交事务
        sqlsession.commit();
        //6.释放资源
        sqlsession.close();
        in.close();
    }



    /**
     * 查询所有
     * @throws Exception
     */
    @Test
    public void testFindAll() {
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println("--------每个用户的信息---------");
            System.out.println(user);
            System.out.println(user.getRoles());
        }
    }

}
 
运行结果：
 
2021-02-13 00:17:32,971 422    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2021-02-13 00:17:33,275 726    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 1027007693.
2021-02-13 00:17:33,275 726    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
2021-02-13 00:17:33,280 731    [           main] DEBUG om.keafmd.dao.IUserDao.findAll  - ==>  Preparing: select u.*,r.id as rid ,r.role_name ,r.role_desc from user u left outer join user_role ur on u.id = ur.uid left outer join role r on r.id=ur.rid
2021-02-13 00:17:33,319 770    [           main] DEBUG om.keafmd.dao.IUserDao.findAll  - ==> Parameters: 
2021-02-13 00:17:33,343 794    [           main] DEBUG om.keafmd.dao.IUserDao.findAll  - <==      Total: 10
--------每个用户的信息---------
User{id=41, username='老王', sex='男', address='北京', birthday=Tue Feb 27 17:47:08 CST 2018}
[Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}, Role{roleId=2, roleName='总裁', roleDesc='管理整个公司'}]
--------每个用户的信息---------
User{id=42, username='update', sex='男', address='XXXXXXX', birthday=Mon Feb 08 19:37:31 CST 2021}
[]
--------每个用户的信息---------
User{id=43, username='小二王', sex='女', address='北京', birthday=Sun Mar 04 11:34:34 CST 2018}
[]
--------每个用户的信息---------
User{id=45, username='新一', sex='男', address='北京', birthday=Sun Mar 04 12:04:06 CST 2018}
[Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}]
--------每个用户的信息---------
User{id=50, username='Keafmd', sex='男', address='XXXXXXX', birthday=Mon Feb 08 15:44:01 CST 2021}
[]
--------每个用户的信息---------
User{id=51, username='update DAO', sex='男', address='XXXXXXX', birthday=Tue Feb 09 11:31:38 CST 2021}
[]
--------每个用户的信息---------
User{id=52, username='Keafmd DAO', sex='男', address='XXXXXXX', birthday=Tue Feb 09 11:29:41 CST 2021}
[]
--------每个用户的信息---------
User{id=53, username='Keafmd laset insertid 1', sex='男', address='XXXXXXX', birthday=Fri Feb 12 20:53:46 CST 2021}
[]
--------每个用户的信息---------
User{id=54, username='Keafmd laset insertid 2 auto', sex='男', address='XXXXXXX', birthday=Fri Feb 12 21:02:12 CST 2021}
[]
2021-02-13 00:17:33,345 796    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
2021-02-13 00:17:33,346 797    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3d36e4cd]
2021-02-13 00:17:33,346 797    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 1027007693 to pool.

Process finished with exit code 0
 
 
 
以上就是Mybatis的多表关联查询（多对多）的全部内容。
 
 
看完如果对你有帮助，感谢点赞支持！
 如果你是电脑端的话，看到右下角的 “一键三连” 了吗，没错点它[哈哈]
 
 
加油！
 
共同努力！
 
Keafmd

1.关系表的数据操作
 
（1）一对多表关系的数据的添加修改
 
 
①学院表信息的插入：
 
 
 
常规方法是写个视图函数，在视图函数里添加插入数据的逻辑代码。但是这样的话——你得访问此视图函数对应的接口才能添加成功！岂不麻烦~
 所以，本博主推出另一种简单的方法——如下图：直接执行插入数据的逻辑代码即可！（Tab键可自动补全代码哦！！！）
 
 
 
②学生表信息的插入（使用常规视图插入数据）
 
from django.http import HttpResponse

from .models import Department,Student,Course,Stu_detail
def add_user(request):

    #1.根据模型类层面的属性进行数据的添加            属性赋值的方法
    # 因为我们在模型类有定义了一个department的属性, 而这个属性对象的类型必须是department表的类实例对象
    d = Department.objects.get(d_id=1)                    #department表的实例对象
    Student.objects.create(s_name="小明",department=d)    #外键department的字段值必须department表的类实例对象

    #2.根据数据库层面的字段名进行数据的添加
    # 需要注意的是外键(查看学生表发现外键这个字段会自动在模型类定义的属性后面加个_id：department_id)的值必须是关联表中已经存在的值.
    Student.objects.create(s_name="小红", department_id=2)

    return HttpResponse("插入数据成功！")
 
③观察可知插入成功：
 
 
（2）表关联对象的访问：
 
①基操——普通方式
 

 
 
②进阶——正向查询
 
（注意点：凡是在模型类定义阶段设置了外键的属性，对应生成数据表时都会在其后加上_id。如果想单纯获取这个值，可以就数据库层面查询，使用.此属性_id即可）
 
 
 
正向查询：Student的模型类中我们有定义department的属性,所以当我们去访问的时候,可以直接通过student.department的形式去找到某个学生所属学院的实例对象，进而查询其所属学院的所有信息。
 由此发出灵魂拷问：
 如果我们也希望在在访问某个学院的实例对象的学生的时候该怎么访问呢???
 这就用到了接下来要讲的——反向查询！！！
 
 
 
③终极版——反向查询
 
 
 
反向查询：如果模型Student有一个ForeignKey（会自动给对应的Department类添加一个反向查询的属性！），那么该ForeignKey 所指的模型Department实例可以通过一个管理器回到前面有ForeignKey的模型Studnet的所有实例。默认情况下，这个管理器的名字为student_set（可以在对应的表关联API中通过设置related_name的值来自定义），其中student是源模型的小写名称。
  
 拓展：两个表关联的API（OneToOne,Foreignkey,ManyToMany）在谁那，通过谁去查询另一个表的信息就是正向查询；反之就是反向查询。
 注意：只限一对多以及多对多；一对一没有_set属性，无法使用！！！
 
 
 
 
拓展：
 
 
 
可以在定义时设置related_name 参数来覆盖student_set的名称！
 
 
 
 
③.1 终极版——反向查询的一些常用方法
 
注意：只限一对多以及多对多；一对一没有_set属性，无法使用！！！
 
from django.http import HttpResponse

from .models import Department,Student,Course,Stu_detail

def add_user(request):

    d = Department.objects.get(d_id=1)                     #学院表中北大的实例
    d3 = Department.objects.get(d_id=3)                    #学院表中中科的实例

    # create()方法：新建数据
    d.student_set.create(s_name="小王")     #在北大院系下新建一个学生表信息

    # add()方法：修改已经存在的数据（注意：通过实例）
    s3 = Student.objects.get(s_id=2)        #将s_id为2的学生的院系从北大换到中科
    d3.student_set.add(s3)

    return HttpResponse("插入数据成功！")
 
原始表中数据：
 访问上述视图函数对应接口后的数据：
 
 
 
④一对一表信息的访问
 
（注意:一对一表关系中使用不了反向查询！！！）
 
from django.http import HttpResponse

from .models import Department,Student,Course,Stu_detail


def add_user(request):
    s1 = Student.objects.get(s_id=1)  # 获得一个学生的实例对象
    # 注意：一对一关系的话，反向查询不能使用。所以添加数据只能如下：
    Stu_detail.objects.create(Student=s1, age=18, phone=123456)

    print(s1.stu_detail)
    print(dir(s1.stu_detail))  # 会发现没有反向查询_set的属性！
    print(s1.stu_detail.age)  # 只能进行数据查询，不能添加！

    # 获取某个学生详情信息，正向查询查出其姓名（先正向查询到其Student实例对象，再获取s_name属性值）
    d = Stu_detail.objects.get(id=1)
    print(d.Student)
    print(d.Student.s_name)

    return HttpResponse("插入数据成功！")
 
输出：
 
Stu_detail<age=18,phone=123456>
['DoesNotExist', 'MultipleObjectsReturned', 'Student', 'Student_id', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_check_column_name_clashes', '_check_field_name_clashes', '_check_fields', '_check_id_field', '_check_index_together', '_check_indexes', '_check_local_fields', '_check_long_column_names', '_check_m2m_through_same_relationship', '_check_managers', '_check_model', '_check_model_name_db_lookup_clashes', '_check_ordering', '_check_property_name_related_field_accessor_clashes', '_check_single_primary_key', '_check_swappable', '_check_unique_together', '_do_insert', '_do_update', '_get_FIELD_display', '_get_next_or_previous_by_FIELD', '_get_next_or_previous_in_order', '_get_pk_val', '_get_unique_checks', '_meta', '_perform_date_checks', '_perform_unique_checks', '_save_parents', '_save_table', '_set_pk_val', '_state', 'age', 'check', 'clean', 'clean_fields', 'date_error_message', 'delete', 'from_db', 'full_clean', 'get_deferred_fields', 'id', 'objects', 'phone', 'pk', 'prepare_database_save', 'refresh_from_db', 'save', 'save_base', 'serializable_value', 'unique_error_message', 'validate_unique']
18
Student<s_id=1,s_name=小明>
小明
 
 
⑤多对多表信息的操作
 
第一部分：数据的添加及关联：
 
首先，课程表中添加数据：
 
from django.http import HttpResponse

from .models import Department,Student,Course,Stu_detail


def add_user(request):
    Course.objects.create(c_name="python")
    Course.objects.create(c_name="java")
    Course.objects.create(c_name="web前端")
    Course.objects.create(c_name="c++")

    return HttpResponse("插入数据成功！")
 

 此时，学生表也有了，下面要做的就是通过中间表将两个表关联起来！
 

 然后，关联表：
 
from django.http import HttpResponse

from .models import Department,Student,Course,Stu_detail

def add_user(request):
    s1 = Student.objects.get(s_id=1)        #小明
    s2 = Student.objects.get(s_id=2)        #小红
    c1 = Course.objects.get(c_id=1)         #python
    #1.数据库中已存在的数据       将学生表和课程表通过Django自动生成的中间表联系起来
    s1.course.add(c1)
    #2.数据库中没有的数据          将学生小红与新建的课程"人工智能"联系起来
    s2.course.create(c_name="人工智能")

    return HttpResponse("插入数据成功！")
 
没有执行之前Django自动生成的中间表是空的：
 
 执行之后Django自动生成的中间表：
 
 
第二部分：指定数据的删除及全部删除
 
from django.http import HttpResponse

from .models import Department,Student,Course,Stu_detail


def add_user(request):
    s1 = Student.objects.get(s_id=1)        #小明
    s2 = Student.objects.get(s_id=2)        #小红
    c1 = Course.objects.get(c_id=1)         #python
    s1.course.remove(c1)                #删除小明同学的课程python

    s2.course.clear()                   #删除小红同学的所有课程

    return HttpResponse("插入数据成功！")
 
 
（注意对于所有类型的关联字段，add()、create()、remove()和clear()都会马上更新数据库。换句话说，在关联的任何一端，都不需要再调用save()方法）
 
❤️可以扫码关注本人公众号——任何问题都可在公众号提问（定时有专人解答）；并且不定时更新干货文。欢迎关注哦！❤️
 

一、前言
 
下面的讲解都基于三张表：student（学生表）、course（课程表）、student_course（学生课程中间表）；
 
功能描述：有多个学生和多门课程，一个学生可以选修多门课程。
 
 
它们的表结构如下：
 

 student 学生表
 
字段
说明
id
学生id
student_name
学生的姓名
course
学生选修的课程（多对多）

 course 课程表
 
字段
说明
id
课程id
course_name
课程名
 

 student_course 学生课程中间表
 
字段
说明
id
中间表id
student_id
学生id
course_id
课程id
 


 
文章目录
 
一、前言
二、创建多对多关系表
1. 自动创建
2. 手动创建
  
三、多对多的使用
1. 前期准备
2. 添加多对多数据及关系
1）创建单个新数据并建立关系
2）创建多个新数据并建立关系
3）多对多建立关系add和set的区别
   
3. 删除多对多数据及关系
1）仅删除关系
2）删除关系并删除数据
   
4. 修改多对多数据及关系
5. 查询多对多数据及关系
1. 正向查询
2. 反向查询
  
 

 
 
二、创建多对多关系表
 
1. 自动创建
 
1）通过django的ORM迁移功能可以方便自动的建立多对多关系：
 
class Course(models.Model):
    id = models.AutoField(primary_key=True)
    course_name = models.CharField(max_length=100)

    class Meta:
        db_table = 'course'
class Student(models.Model):
    id = models.AutoField(primary_key=True)
    student_name = models.CharField(max_length=100)
    course = models.ManyToManyField(to=Course)
 
 
2）在项目目录下，依次执行如下迁移命令：
 
python manage.py makemigrations
python manage.py migrate
 
 
3）迁移成功的话，就可以在数据库中看到这三张表了：
 
 
 
2. 手动创建
 
删除student表的manyTomany字段，然后手动创建中间表的orm模型即可：
 
class Course(models.Model):
    id = models.AutoField(primary_key=True)
    course_name = models.CharField(max_length=100)

    class Meta:
        db_table = 'course'


class Student(models.Model):
    id = models.AutoField(primary_key=True)
    student_name = models.CharField(max_length=100)


    class Meta:
        db_table = 'student'


class StudentAndCourse(models.Model):
    id = models.AutoField(primary_key=True)
    student = models.ForeignKey(to=Student, on_delete=models.DO_NOTHING)
    course = models.ForeignKey(to=Course, on_delete=models.DO_NOTHING)

    class Meta:
        db_table = 'student_and_course'
 
 
三、多对多的使用
 
1. 前期准备
 
我们先为学生表创建一个学生，姓名为:曲鸟 ，学生ID为：1：
 
 
 
2. 添加多对多数据及关系
 
1）创建单个新数据并建立关系
 
添加一个名为语文的课程并与曲鸟建立多对多的关系：
 
student=Student.objects.get(id=1)  # 先通过学生id找到曲鸟这个学生
student.course.create(course_name="语文")  # 创建名为语文的课程并建立关系
 
 
通过上面的代码可以看出，只要student是模型的Student对象，就可以直接创建数据并建立关系，所以将之前查询学生的代码：
 
student=Student.objects.get(id=1)  # 先通过学生id找到曲鸟这个学生
 
 
改为下面这样也是可以的：
 
student=Student.objects.filter(id=1).first()  # 先通过学生id找到曲鸟这个学生
 
 
当然，新创建一个学生再新建课程进行关联也是可以的：
 
student=Student.objects.create(student_name="张三")  # 创建名为张三的学生
student.course.create(course_name="数学")  # 创建名为数学的课程并建立关系
 
 
2）创建多个新数据并建立关系
 
如果直接使用批量添加数据（bulk_create）方法，是无法建立多对多的关系的。
 
如果非要批量创建并建立关系的话，可以再批量创建数据的时候指定主键值，然后通过set方法进行关联：
 
student = Student.objects.filter(id=1).first()
set_list = []
a = 7
for name in ['体育', '美术']:
    set_list.append(Course(course_name=name, id=a))  # 手动指定id
    a += 1
aa = student.course.bulk_create(set_list)  # 返回给aa的是一个列表，里面的元素为Course对象
student.course.set(aa)  # 通过set方法进行关联关系的建立
 
 
3）多对多建立关系add和set的区别
 
3.1 add
 
add接收一个Model对象，用于在原来存在的关系上进行单条多对多关系的建立 （如果add的多对多关系原来已经存在了，则保持不变）：
 
student = Student.objects.get(id=1)  # 先通过学生id找到曲鸟这个学生
course = Course.objects.get(id=7)  # 查询id=7的课程
student.course.add(course)
 
 
如果想基于原来存在的关系，批量增加新的多对多关系，则可以这样写：
 
student = Student.objects.get(id=1)  # 先通过学生id找到曲鸟这个学生
course = Course.objects.all()  # 查询所有课程
student.course.add(*course)
 
 
3.2 set
 
set接收一个List，List里面的元素为Model对象，用于多条记录的多对多关系建立 （如果已经存在了多对多关系，则会删除原来的关系，重新进行建立）：
 
student = Student.objects.get(id=1)  # 先通过学生id找到曲鸟这个学生
course = Course.objects.all()  # 查询所有课程
student.course.set(course)
 
 
3. 删除多对多数据及关系
 
1）仅删除关系
 
1.1 删除单个关系
 
student = Student.objects.get(id=1)  # 先通过学生id找到曲鸟这个学生
course=student.course.get(id=7)
student.course.remove(course)
 
 
1.2 删除部分关系
 
student = Student.objects.get(id=1)  # 先通过学生id找到曲鸟这个学生
course = student.course.filter(id__in=[6, 7])
student.course.remove(*course)
 
 
1.3 删除所有关系
 
student = Student.objects.get(id=1)  # 先通过学生id找到曲鸟这个学生
student.course.clear()
 
 
2）删除关系并删除数据
 
2.1 删除单个
 
    student = Student.objects.get(id=1)  # 先通过学生id找到曲鸟这个学生
    student.course.filter(id=6).delete()
 
2.2 删除部分
 
student.course.filter(id__in=[6, 7]).delete()
 
2.3 删除所有
 
student.course.all().delete()
 
 
4. 修改多对多数据及关系
 
可以通过上面讲的新增关系和删除关系相结合进行修改的操作。
 
 
5. 查询多对多数据及关系
 
1. 正向查询
 
查询所有
 
student.course.all()
 
 
因为它就是model对象，所以所有model使用的ORM关键字都可以使用例如：filter、values等，这里不再举例。
 
 
2. 反向查询
 
例如想通过课程去查有哪些学生选修了，在查询时加入set关键字即可：
 
course=Course.objects.get(id=1)
data=course.student_set.all()  #加入set关键字
print(data)
 
 
输出结果
 
<QuerySet [<Student: Student object (1)>]>
 
 
注：对于上面讲的增加、修改、删除中，也同样可以使用反向查询进行操作