不使用外键，尝试多对多查询

我的上两篇博客总结了一下不使用外键的优缺点

但是我还没试过，今天尝试了一下，用难一点的多对多关系实验

---

一：工具：

　　springboot

　　mybatis

　　mysql

二：材料：

　　五张表：

　　　　user--用户表

　　　　role--角色表

　　　　permission--权限表

　　　　user-role表

　　　　permission-role表

　　其中，user-role表和permission-role表是意义上的中间表，就是没有外键的，其他三张是基本表

sql语句：

/*
Navicat MySQL Data Transfer

Source Server         : root
Source Server Version : 50549
Source Host           : localhost:3306
Source Database       : shiro

Target Server Type    : MYSQL
Target Server Version : 50549
File Encoding         : 65001

Date: 2018-05-30 14:42:06
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for permission
-- ----------------------------
DROP TABLE IF EXISTS `permission`;
CREATE TABLE `permission` (
  `pid` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL DEFAULT '',
  `url` varchar(255) DEFAULT '',
  PRIMARY KEY (`pid`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of permission
-- ----------------------------
INSERT INTO `permission` VALUES ('1', 'add', '');
INSERT INTO `permission` VALUES ('2', 'delete', '');
INSERT INTO `permission` VALUES ('3', 'edit', '');
INSERT INTO `permission` VALUES ('4', 'query', '');

-- ----------------------------
-- Table structure for permission_role
-- ----------------------------
DROP TABLE IF EXISTS `permission_role`;
CREATE TABLE `permission_role` (
  `rid` int(11) NOT NULL,
  `pid` int(11) NOT NULL,
  KEY `idx_rid` (`rid`),
  KEY `idx_pid` (`pid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of permission_role
-- ----------------------------
INSERT INTO `permission_role` VALUES ('1', '1');
INSERT INTO `permission_role` VALUES ('1', '2');
INSERT INTO `permission_role` VALUES ('1', '3');
INSERT INTO `permission_role` VALUES ('1', '4');
INSERT INTO `permission_role` VALUES ('2', '1');
INSERT INTO `permission_role` VALUES ('2', '4');

-- ----------------------------
-- Table structure for role
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
  `rid` int(11) NOT NULL AUTO_INCREMENT,
  `rname` varchar(255) NOT NULL DEFAULT '',
  PRIMARY KEY (`rid`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of role
-- ----------------------------
INSERT INTO `role` VALUES ('1', 'admin');
INSERT INTO `role` VALUES ('2', 'customer');

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `uid` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) NOT NULL DEFAULT '',
  `password` varchar(255) NOT NULL DEFAULT '',
  PRIMARY KEY (`uid`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'admin', '123');
INSERT INTO `user` VALUES ('2', 'demo', '123');

-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
  `uid` int(11) NOT NULL,
  `rid` int(11) NOT NULL,
  KEY `idx_uid` (`uid`),
  KEY `idx_rid` (`rid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user_role
-- ----------------------------
INSERT INTO `user_role` VALUES ('1', '1');
INSERT INTO `user_role` VALUES ('2', '2');

这里补充一下，两张中间表我既没有设外键，也没有设置主键

因为我觉得，用外键时，他们都是联合主键，现在我把外键去了，主键给谁都不对，如果另设一个属性作为主键我觉得也没必要

这里大家有建议欢迎提出，我也是第一次这样做，或许我觉得没必要的地方还是有必要的。

三：直接使用mybatis逆向工程生成bean和mapper

 

 

四：如何表示多对多关系？

　　我的上两篇博客中提到了，如果放弃外键，那么需要自己手动维护表与表之间的关联关系。

　　比如说，User实体类中应该有一个roles的集合，而Role实体类里也应该有一个users的集合。

　　但在数据库表中，user表和role表并没有相应的属性。因为多对多要通过中间表关联嘛。可惜，中间表user-role和这两表没有任何联系。至少现在是这样的。

　　那么，怎么搞？

　　要roles集合，我就给你呗！

　　在User实体类中加上下面这个不就行了，联系不就有了，找的时候set进去不ok了嘛

 private Set<Role> roles = new HashSet<>(); 

　　这样真的好吗？

　　不好吧！上面已经说过，所有的bean和mapper都是mybatis逆向工程自动生成。等哪天，我数据库表一变，比如某些表加个其他属性，我又重新逆向工程生成全部bean和mapper，我又之前忘记了在这张表加了个什么，那张表加了什么，东西很难回去了，这就麻烦了。

　　所以，建议：

　　　　创建包装类，包装实体类，再在包装类增加其他属性

public class UserVo extends User {

    private Set<Role> roles = new HashSet<>();

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

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

　　这样，不管实体类怎么变化，包装类就继承你，什么也不用另外变化

　　同理，其他也这样弄

-----------------------------------------分割线---------------------------------------------

　　等等，这里，我先捋一下关系

　　user和role多对多

　　permission和role多对多

　　意思是说：

　　　　user里要有roles集合；

　　　　role里要有users集合，role里还要有permissions集合；

　　　　permission里要有roles集合；

　　关键的地方来了，我在User实体类里不能放  Set<Role> roles = new HashSet<>() 

　　为什么？

　　我是要在roles里取到permissions或者users的，那样写代码大概是 user.getRoles().......getPermissions()

　　这是逼我在Role实体类里加一个 private Set<Permission> permissions= new HashSet<>()  啊，这不是上面刚说的不能这样写的吗？

　　怎么办？

　　我能放一个实体类作为泛型的类型，为什么不能放一个包装类作为泛型的类型，两者本质没有任何区别！

　　User实体类的包装类：

public class UserVo extends User {

    private Set<RoleVo> roleVos = new HashSet<>();

    public UserVo() {
    }

    public Set<RoleVo> getRoleVos() {
        return roleVos;
    }

    public void setRoleVos(Set<RoleVo> roleVos) {
        this.roleVos = roleVos;
    }

    @Override
    public String toString() {
        return "UserVO{" +
                "uid=" + super.getUid() +
                ", username=" + super.getUsername() +
                ", password=" + super.getPassword() +
                ", roleVos.size=" + roleVos.size() +
                '}';
    }
}

　　Role实体类的包装类

public class RoleVo extends Role {

    private Set<PermissionVo> permissionVos = new HashSet<>();

    private Set<UserVo> userVos = new HashSet<>();

    public Set<PermissionVo> getPermissionVos() {
        return permissionVos;
    }

    public void setPermissionVos(Set<PermissionVo> permissionVos) {
        this.permissionVos = permissionVos;
    }

    public Set<UserVo> getUserVos() {
        return userVos;
    }

    public void setUserVos(Set<UserVo> userVos) {
        this.userVos = userVos;
    }

    @Override
    public String toString() {
        return "RoleVo{" +
                "rid=" + super.getRid() +
                ", rname=" + super.getRname() +
                ", permissionVos=" + permissionVos +
                ", userVos.size=" + userVos.size() +
                '}';
    }
}

　　Permission实体类的包装类

public class PermissionVo extends Permission {

    private Set<RoleVo> roleVos = new HashSet<>();

    public Set<RoleVo> getRoleVos() {
        return roleVos;
    }

    public void setRoleVos(Set<RoleVo> roleVos) {
        this.roleVos = roleVos;
    }

    @Override
    public String toString() {
        return "PermissionVo{" +
                "pid=" + super.getPid() +
                ", pname=" + super.getName() +
                ", url=" + super.getUrl() +
                ", roleVos.size=" + roleVos.size() +
                '}';
    }
}

 五：实现需求：

　　查询一个用户，并把当前用户拥有的角色和角色所具有的权限一并查出

　　@Test
    public void fun() {
        // 创建三个包装类
        UserVo userVo = new UserVo();
        RoleVo roleVo = null;
        PermissionVo permissionVo = null;

        // 根据用户uid查询用户
        User user = userMapper.selectByPrimaryKey(1);

        // 装配user属性-- id, username, password，还有一个roleVos在下面
        BeanUtils.copyProperties(user, userVo);

        // 通过user的 uid 查询中间表 user-role表
        UserRoleExample userRoleExample = new UserRoleExample();
        userRoleExample.createCriteria().andUidEqualTo(user.getUid());
        // 得到该用户的角色集合
        List<UserRole> userRoles = userRoleMapper.selectByExample(userRoleExample);
        // 遍历角色集合
        for (UserRole userRole : userRoles) {
            // 通过角色rid, 查询role表中对应的每一个角色
            Role role = roleMapper.selectByPrimaryKey(userRole.getRid());

            // 装配roleVo属性 -- rid, rname，还有一个permissionVos在下面
            roleVo = new RoleVo();
            BeanUtils.copyProperties(role, roleVo);

            // 又通过每一个role的rid，查询中间表 permission_role 表
            PermissionRoleExample permissionRoleExample = new PermissionRoleExample();
            permissionRoleExample.createCriteria().andRidEqualTo(role.getRid());
            // 得到该角色具有的权限集合
            List<PermissionRole> permissionRoles =
                    permissionRoleMapper.selectByExample(permissionRoleExample);
            // 遍历权限集合
            for (PermissionRole permissionRole : permissionRoles) {
                // 通过permission的pid，查询 permission表 对应的权限
                Permission permission = permissionMapper.selectByPrimaryKey(permissionRole.getPid());

                // 装配permissionVo属性 -- pid, name, url, roleVos
                permissionVo = new PermissionVo();
                BeanUtils.copyProperties(permission, permissionVo);
                permissionVo.getRoleVos().add(roleVo);

                // 装配roleVo里的permissionVos
                roleVo.getPermissionVos().add(permissionVo);
            }
            // 装配userVo属性roleVos
            userVo.getRoleVos().add(roleVo);
        }
        System.out.println(userVo);
        System.out.println(roleVo);
        System.out.println(permissionVo);
    }

　　结果：

　　UserVO{
        uid=1, 
        username=admin, 
        password=123, 
        roleVos.size=1
    }

    RoleVo{
        rid=1, 
        rname=admin,
        permissionVos=[
            PermissionVo{pid=4, pname=query, url=, roleVos.size=1}, 
            PermissionVo{pid=2, pname=delete, url=, roleVos.size=1}, 
            PermissionVo{pid=1, pname=add, url=, roleVos.size=1}, 
            PermissionVo{pid=3, pname=edit, url=, roleVos.size=1}
        ], 
        userVos.size=0
    }

    PermissionVo{
        pid=4, 
        pname=query, 
        url=, 
        roleVos.size=1
    }

---

小小总结一下：

　　1. 别看上面实现的代码挺多的，去掉注释也就30行左右，只要不绕进去，逻辑还是不难的（废话）

　　2.善用包装类

　　3.注意看三个包装类的toString方法，有些我是只给打印长度的，比如roleVos.size()，为什么，全部打印出来会死循环，好好想想为什么