java 实体字段映射对应的mysql json

现有部门和雇员两个关系表：
数据表之间的对应信息为：

• 一个部门有多个雇员；
• 一个雇员属于一个部门；
• 一个雇员有一个领导；

在简单Java类中实现，要求可以：

• 根据部门信息获得以下内容

• 一个部门的完整信息；
• 一个部门之中所有雇员的完整信息；
• 一个雇员对应的领导信息；

• 根据雇员信息获得以以下内容：

• 一个雇员所在部门的信息；
• 一个雇员对应的领导信息；

步骤：

1. 分别定义Emp、Dept两个实体类
2. 配置所有的关联字段

class Dept {
    private long deptno;
    private String dname;
    private String loc;
    private Emp emps[]; //多个雇员信息

    public Dept(long deptno, String dname, String loc) {
        this.deptno = deptno;
        this.dname = dname;
        this.loc = loc;
    }

    public Emp[] getEmps() {
        return emps;
    }

    public void setEmps(Emp[] emps) {
        this.emps = emps;
    }

    public String getInfo() {
        return "【部门信息】部门编号=" + this.deptno + "、部门名称=" + this.dname + "、部门位置=" + this.loc;
    }
}

class Emp {
    private long empno;
    private String ename;
    private String job;
    private double sal;
    private double comm;
    private Dept dept;  //所属部门
    private Emp mgr;    //所属领导

    public Emp(long empno, String ename, String job, double sal, double comm) {
        this.empno = empno;
        this.ename = ename;
        this.job = job;
        this.sal = sal;
        this.comm = comm;
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public Emp getMgr() {
        return mgr;
    }

    public void setMgr(Emp mgr) {
        this.mgr = mgr;
    }

    public String getInfo() {
        return "【雇员信息】雇员编号=" + this.empno + "、雇员姓名=" + this.ename + "、雇员职位=" + this.job + "、基本工资=" + this.sal + "、佣金" + this.comm;
    }
}

public class JavaDemo {
    public static void main(String[] args) {
        //第一步：根据关系进行类的定义
        //定义处各个的实例化对象，此时并没有任何的关联定义
        Dept dept = new Dept(10, "财务部", "上海");
        Emp empA = new Emp(7369L, "SMITH", "CLERK", 800.00, 0.00);
        Emp empB = new Emp(6867L, "FORD", "MANAGER", 2450, 0.0);
        Emp empC = new Emp(3424L, "KING", "PRESIDENT", 5000.00, 0.0);
        //需要为对象进行关联的设置
        empA.setDept(dept); //设置雇员与部门的关联
        empB.setDept(dept); //设置雇员与部门的关联
        empC.setDept(dept); //设置雇员与部门的关联
        empA.setMgr(empB);  //设置雇员与领导的关联
        empB.setMgr(empC);
        dept.setEmps(new Emp[]{empA, empB, empC});    //部门与雇员的关联
        //第二步：根据关系获取数据
        System.out.println(dept.getInfo());
        for (int x = 0; x < dept.getEmps().length; x++) {
            System.out.println("\t|-" + dept.getEmps()[x].getInfo());
            if (dept.getEmps()[x].getMgr() != null) {
                System.out.println("\t\t|-" + dept.getEmps()[x].getMgr().getInfo());
            }
        }
        System.out.println("----------------------------");
        System.out.println(empB.getDept().getInfo());   //根据雇员获取部门信息
        System.out.println(empB.getMgr().getInfo());    //根据雇员获取领导信息
    }
}

复杂多对多映射

要求实现如下查询功能：

• 可以根据一个用户找到用户对应的所有角色，以及每一个角色对应的权限信息；
• 可以根据一个角色找到该角色下的所有权限，以及拥有此角色的全部用户信息；
• 可以根据一个权限找到具备此权限的所有用户信息。

代码实现：

class Member {
    private String mid;
    private String name;
    private Role roles[];

    public Member(String mid, String name) {
        this.mid = mid;
         = name;
    }

    public Role[] getRoles() {
        return roles;
    }

    public void setRoles(Role[] roles) {
        this.roles = roles;
    }

    public String getInfo() {
        return "【用户信息】id=" + this.mid + "、name=" + ;
    }
}

class Role {
    private long rid;
    private String title;
    private Member members[];
    private Privilege privileges[];

    public Role(long rid, String title) {
        this.rid = rid;
        this.title = title;
    }

    public Privilege[] getPrivileges() {
        return privileges;
    }

    public void setPrivileges(Privilege[] privileges) {
        this.privileges = privileges;
    }

    public Member[] getMembers() {
        return members;
    }

    public void setMembers(Member[] members) {
        this.members = members;
    }

    public String getInfo() {
        return "【角色信息】id=" + this.rid + "、title=" + this.title;
    }
}

class Privilege {
    private long pid;
    private String title;
    private Role role;

    public Privilege(long pid, String title) {
        this.pid = pid;
        this.title = title;
    }

    public Role getRole() {
        return role;
    }

    public void setRole(Role role) {
        this.role = role;
    }

    public String getInfo() {
        return "【权限信息】id=" + this.pid + "、title=" + this.title;
    }
}

//一个用户可以拥有多个角色，一个角色可能有多个用户
//一个角色可以拥有多个权限
public class JavaDemo {
    public static void main(String[] args) {
        //第一步：根据结构设置对象信息
        Member memA = new Member("mldn-a", "张三");
        Member memB = new Member("mldn-b", "李四");
        Role roleA = new Role(1L, "系统配置");
        Role roleB = new Role(2L, "备份管理");
        Role roleC = new Role(3L, "人事管理");
        Privilege privilegeA = new Privilege(1000L, "系统初始化");
        Privilege privilegeB = new Privilege(1001L, "系统还原");
        Privilege privilegeC = new Privilege(1002L, "系统环境修改");
        Privilege privilegeD = new Privilege(2000L, "备份员工数据");
        Privilege privilegeE = new Privilege(2001L, "备份部门数据");
        Privilege privilegeF = new Privilege(2002L, "备份公文数据");
        Privilege privilegeG = new Privilege(3000L, "增加员工");
        Privilege privilegeH = new Privilege(3001L, "编辑员工");
        Privilege privilegeI = new Privilege(3002L, "浏览员工");
        Privilege privilegeJ = new Privilege(3003L, "员工离职");
        //增加角色与权限的对应关系
        roleA.setPrivileges(new Privilege[]{privilegeA, privilegeB, privilegeC});
        roleB.setPrivileges(new Privilege[]{privilegeD, privilegeE, privilegeF});
        roleC.setPrivileges(new Privilege[]{privilegeG, privilegeH, privilegeI, privilegeJ});
        //增加权限与角色对应
        privilegeA.setRole(roleA);
        privilegeB.setRole(roleA);
        privilegeC.setRole(roleA);
        privilegeD.setRole(roleB);
        privilegeE.setRole(roleB);
        privilegeF.setRole(roleB);
        privilegeG.setRole(roleC);
        privilegeH.setRole(roleC);
        privilegeI.setRole(roleC);
        privilegeJ.setRole(roleC);
        //增加用户与角色的对应关系
        memA.setRoles(new Role[]{roleA, roleB});
        memB.setRoles(new Role[]{roleA, roleB, roleC});
        roleA.setMembers(new Member[]{memA, memB});
        roleB.setMembers(new Member[]{memA, memB});
        roleC.setMembers(new Member[]{memB});
        //第二步：根据要求获取数据
        System.out.println("-----------根据用户查找信息----------");
        System.out.println(memB.getInfo());
        for (int x = 0; x < memB.getRoles().length; x++) {
            System.out.println("\t|-" + memB.getRoles()[x].getInfo());
            for (int y = 0; y < memB.getRoles()[x].getPrivileges().length; y++) {
                System.out.println("\t\t|-" + memB.getRoles()[x].getPrivileges()[y].getInfo());
            }
        }
        System.out.println("-----------根据角色查找信息----------");
        System.out.println(roleB.getInfo());
        System.out.println("\t|- 浏览此角色下的所有权限信息");
        for (int x = 0; x < roleB.getPrivileges().length; x++) {
            System.out.println("\t\t|-" + roleB.getPrivileges()[x].getInfo());
        }
        System.out.println("\t|- 浏览此角色下的所有用户信息");
        for (int x = 0; x < roleB.getMembers().length; x++) {
            System.out.println("\t\t|-" + roleB.getMembers()[x].getInfo());
        }
        System.out.println("-----------根据权限查找信息----------");
        System.out.println(privilegeA.getInfo());
        for (int x = 0; x < privilegeA.getRole().getMembers().length; x++) {
            System.out.println("\t|-" + privilegeA.getRole().getMembers()[x].getInfo());
        }
    }
}