相对的一对多和多对一，hibernate很伤神

时间 2019-12-04

原文原文链接

导读

最近公司在作这样的一个业务，由我来设计数据库，其中有有一个需求，根据原型图设计数据库，这也是我第一次独立设计数据库，因涉及公司的机密，只能展现部分原型图：前端

一、如图是项目的原型图，每一个项目都是一条记录，于是，这能够设计成独立的项目表
算法

二、当点击红框中的“人员”，就会出现一个弹框，弹框如图所示。spring

这是项目人员，天然关联对应项目。不一样的项目可能有不一样的人员。于是，这能够设计成一张项目人员表。表中的字段确定有“人员类型”，好比业务员，业务部经理等。外键天然是项目主键。一个项目可能会有多条记录，好比说业务员一条记录，业务部经理一条记录等。因此，对于项目而言，这是一对多的关系，是什么意思呢？一个项目在项目人员表有多条记录；但对于项目人员来讲，这是多对一的关系，多条项目人员的记录对着一个项目。如图所示：数据库

生成数据表结构是有Java代码生成的，于是，代码以下：编程

/**
 * Created By zby on 15:00 2018/12/25
 * 项目人员
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
@Entity
@Table(name = "zq_project_person")
public class ProjectPerson extends BaseObj {

    /**
     * 人员类型
     */
    @Enumerated(EnumType.STRING)
    @Column(name = "person_type")
    private PersonTypeEnum personType;

    /**
     * 人员的ids，存储人员的编号
     */
    @Column(name = "ids")
    private String ids;

    /**
     * 选择时间
     */
    @Column(name = "op_time")
    private Date opTime;

    /**
     * 项目
     */
    @ManyToOne
    @JoinColumn(name = "project_id")
    private Project project;

}

人员类型是枚举，代码以下：数组

/**
 * Created By zby on 9:43 2018/12/27
 */
public enum PersonTypeEnum implements TitleEnum {
    PERSON_TYPE_SALESMAN("业务员"),
    PERSON_TYPE_SALESMAN_MANAGER("业务部经理"),
    PERSON_TYPE_DESIGNER("设计师"),
    PERSON_TYPE_DESIGNER_MANAGER("设计部经理"),
    PERSON_TYPE_PROJECT_SUPERVISION("工程监理"),
    PERSON_TYPE_ENGINEERING_MANAGER("工程部经理");

    。。。

一对多和多对一

一和多的概念

经过以上的分析，咱们知道一对多和多对一的关系。这个“一”和“多”。究竟是什么是 “一”，什么又是“多”呢？在实际的项目中，咱们多问几个为何，成长也会特别的快。不要怕问，也许，人家可能没时间回答你，或许，人家惧怕把你教会了。这样，也要问，不问就永远不知道。ide

“一”针对“一个点”来讲，就像是spring中的aop（Aspect Oriented Programming）编程同样。spring框自己就是以算法驱动为开发，但咱们在使用它时，通常是以业务驱动为开发的。既然是业务处理，天然涉及到业务的诸多流程，好比，专门将JVM中的瞬时态的对象转化为数据库的持久态的字段值、或将数据库的持久态的字段值转化为瞬时态的Java对象的dao（data access object）层；专门处理数据库事务相关的事务层（service层）；专门处理接受前端数据和返回前端数据的控制层（controller层）。ui

咱们单单只考虑其中的一个业务流程，即数据库的事务层（service层）。这就是一个点，也就是aop须要考虑的一个点。aop的配置文件以下所示：spa

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd"
       default-lazy-init="true">

    <!-- =================================================================== -->
    <!-- AOP: Configuration and Aspects    @TODO:事务缩小范围到 固定的 名字                                  -->
      <!-- 采用 ant风格的编写方式， 一个 * 表示至少有0个字母，两个 ** 表示至少有0个目录                        -->
    <!-- =================================================================== -->
    <aop:config>
        <aop:advisor id="managerTxOne" advice-ref="txAdvice" pointcut="execution(* *..service.*Service.*(..))"
                     order="0"/>
    </aop:config>

    <tx:annotation-driven/>

    <!-- 开启AOP监听 只对当前配置文件有效 -->
    <aop:aspectj-autoproxy expose-proxy="true"/>

    <!-- 配置各个方法的权限，以get list search 开头的都是只读权限 -->
    <tx:advice id="txAdvice">
        <tx:attributes>
            <!--得到单个对象-->
            <tx:method name="get*" read-only="true"/>
            <!--列表对象-->
            <tx:method name="list*" read-only="true"/>
            <!--搜索分页对象-->
            <tx:method name="search*" read-only="true"/>

            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    
</beans>

咱们注意上面的<aop:config> 。。。</aop:config>这段代码，其实就是配置的设置这个点。这个是处理全部以service结尾的。设计

于是，再说说咱们数据的库的 “一”，这是针对一条记录来讲的，好比上文说到的项目表中有不少项目，咱们单单举出来编号为167的项目，那么，这就是 “一”。“多”咱们针对的是当前数据表中涉及到外键字段的记录的条数。好比在项目人员表中，外键名为project_id的项目编号等于167的有不少条记录。那么，这就是“多”。

一对多和多对一的理论示例

因此，一和多之间，并不是绝对的关系，只是相对来讲。就像咱们初中学过的运动间的相对关系。什么是静止的，什么是运动的？咱们坐在车箱里，相对于窗外的行道树，咱们是运动的。相对于车子，咱们就是静止的。因此，也有句话，叫作日行不动八万里。万物就是这样，没有绝对的关系。于是，在实际的项目中，咱们遇到了太多的一对多（多对一）的关系，好比：

项目和项目人员就是一个典型的一对多和多对一的关系。由于上文提到了，就再也不赘述。
项目和项目阶段也是一对多和多对一的关系。一个项目从执行到竣工，确定有不少的阶段，每一个阶段的执行时间、阶段名称、涉及到的人等。于是，这也是一对多的关系。因此，在项目阶段表中相同项目编号的记录至少零条。
评论表和用户、文章也是一对多和多对一的关系。好比我在思否写了篇文章，当其余用户登陆了，假设评论个人文章，一个用户能够评论屡次一篇文章，一个用户也能够评论个人多篇文章。因此，在评论表中，一个用户的记录至少零条，一个用户的文章的记录数至少零条。
同一张表中也能够存在一对多的关系。如文章类型这张表，文章类型确定有父类型。在这张表中，父类型至少有零条记录数。如栏目，栏目确定有父类型，父栏目下面有子栏目，父栏目的记录至少有零条。
根据4所说的，一个文章类型下面有多篇文章，这也是典型的一对多；一个栏目下面有多个内容，这也是典型的一对多。
。。。再有的话，欢迎评论。

以项目人员为示例

业务需求

咱们只有点击选择人员，才将数据保存到数据库中，可是，咱们仍是要将人员类型按照顺序展现出来。于是，咱们须要考虑的是，判断数据库中是否存在某种人员类型，好比业务员类型，业务部经理类型。

存在，就把数据表的对象取出来，而后填充到集合容器中。
不存在，咱们就要把数据库中不存在的人员类型填充到集合容器中。

算法思想：

在作项目以前，咱们须要考虑算法，不然，作出来的东西虽然没错，但不是业务所须要的。

咱们从数据库中取出当前项目下的项目人员的记录，即 List<ProjectPerson> projectList = projectPersonDao.listProjectPersons(projectId);
咱们获取枚举对象的数组，而后遍历枚举集合，即 for (PersonTypeEnum obj : PersonTypeEnum.class.getEnumConstants())；
设置一个开关，true 表示数据存在该枚举对象，false 表示数据库不存在该枚举对象，即 boolean objInProjectPerson = false;
再遍历projectList ，获取项目人员的对象，拿到人员类型的对象，与枚举对象进行比较，若是相等，就objInProjectPerson置为true，而后挑出内循环。
判断objInProjectPerson状态，若是未false，就将人员类型的对象设置为当前枚举对象。
最后，经过 projectPersonList.sort(Comparator<? super E> c)方法进行排序。由于方法形参的是Comparator接口，于是，咱们须要一方法内部类的方式实现排序。

方法实现

经过上文的算法设计，咱们编写实现方法：

@Override
    public Result<List<ProjectPerson>> listProjectPersons(Long projectId) {
//        【1】步骤一
        List<ProjectPerson> projectList = projectPersonDao.listProjectPersons(projectId);
        List<ProjectPerson> projectPersonList = new ArrayList<>();
        Class<PersonTypeEnum> clz = PersonTypeEnum.class;
        //        【2】步骤二
        for (PersonTypeEnum obj : clz.getEnumConstants()) {
            //        【3】步骤三
            boolean objInProjectPerson = false;
            for (ProjectPerson projectPerson : projectList) {
                //        【4】步骤四
                if (obj.equals(projectPerson.getPersonType())) {
                    projectPerson.setSort(obj.ordinal());
                    objInProjectPerson = true;
                    projectPersonList.add(projectPerson);
                    break;
                }
            }
            //        【5】步骤五
            if (!objInProjectPerson) {
                ProjectPerson projectPerson = new ProjectPerson();
                projectPerson.setPersonType(obj);
                projectPerson.setSort(obj.ordinal());
                projectPersonList.add(projectPerson);
            }
        }
        //        【6】步骤6
        projectPersonList.sort(new Comparator<ProjectPerson>() {
            @Override
            public int compare(ProjectPerson firstProjectPerson, ProjectPerson secondProjectPerson) {
                return firstProjectPerson.getSort() - secondProjectPerson.getSort();
            }
        });
        return ResultUtil.buildSuccess(projectPersonList);
    }

总结

咱们在开发过程当中和，要分明白什么时候以业务驱动为开发对象，什么时候以算法驱动为开发对象。这样，作一个有条理的人，你就会得到更多的知识。