详解CRMPLMSCMMES 与 ERP 的关联及概念

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了详解CRMPLMSCMMES 与 ERP 的关联及概念相关的知识，希望对你有一定的参考价值。

先用一张图来简单解释各个系统在企业层级中的位置，下面附上各系统的解释：

 

CRM

（Customer Relationship Management，客户关系管理）

企业为提高核心竞争力，利用相应的信息技术以及互联网技术来协调企业与顾客间在销售、营销和服务上的交互，从而提升其管理方式，向客户提供创新式的个性化的客户交互和服务的过程。其最终目标是吸引新客户、保留老客户以及将已有客户转为忠实客户，增加市场份额。

CRM的实施目标是通过全面提升企业业务流程的管理来降低企业成本，通过提供更快速和周到的优质服务来吸引和保持更多的客户。作为一种新型管理机制，CRM极大地改善了企业与客户之间的关系，实施于企业的市场营销、销售、服务与技术支持等与客户相关的领域。CRM系统可以及时获取客户需求和为客户提供服务使企业减少“软”成本。

PLM

（Product Life Cycle Management，产品生命周期管理）

PLM是一种应用于在单一地点的企业内部、分散在多个地点的企业内部，以及在产品研发领域具有协作关系的企业之间的，支持产品全生命周期的信息的创建、管理、分发和应用的一系列应用解决方案，它能够集成与产品相关的人力资源。

PLM包含了PDM（Product Data Management，产品数据管理）的全部内容，PDM功能是PLM中的一个子集。但是PLM又强调了对产品生命周期内跨越供应链的所有信息进行管理和利用的概念，这是与PDM的本质区别。

SCM

（Supply chain management，供应链管理）

供应链管理是一种集成的管理思想和方法，它执行供应链中从供应商到最终用户的物流的计划和控制等职能。从单一的企业角度来看，SCM围绕核心企业，通过改善上、下游供应链关系，整合和优化供应链中的信息流、物流、资金流，以获得企业的竞争优势。

供应链系统可以优化产品成本与价值，它主要为企业的制造服务。SCM主要通过信息手段，对供应的各个环节中的各种物料、资金、信息等资源进行计划、调度、调配、控制与利用，形成用户、零售商、分销商、制造商、采购供应商的全部供应过程的功能整体。

MES

（Manufacturing Execution System，生产过程执行系统）

MES系统是一套面向制造企业车间执行层的生产信息化管理系统。MES可以为企业提供包括制造数据管理、计划排程管理、生产调度管理、库存管理、质量管理、人力资源管理、工作中心/设备管理、工具工装管理、采购管理、成本管理、项目看板管理、生产过程控制、底层数据集成分析、上层数据集成分解等管理模块，为企业打造一个扎实、可靠、全面、可行的制造协同管理平台。

MES能通过信息传递对从订单下达到产品完成的整个生产过程进行优化管理。当工厂发生实时事件时，MES能对此及时做出反应、报告，并用当前的准确数据对它们进行指导和处理。这种对状态变化的迅速响应使MES能够减少企业内部没有附加值的活动，有效地指导工厂的生产运作过程，从而使其既能提高工厂及时交货能力，改善物料的流通性能，又能提高生产回报率。

ERP

（Enterprise Resource Planning，企业资源计划）

ERP是一种主要面向制造行业进行物质资源、资金资源和信息资源集成一体化管理的企业信息管理系统。ERP 是一个以管理会计 为核心可以提供跨地区、跨部门、甚至跨公司整合实时信息的企业管理软件。针对物资资源管理（物流）、人力资源管理（人流）、财务资源管理（财流）、信息资源管理（信息流）集成一体化的企业管理软件。

ERP具有整合性、系统性、灵活性、实时控制性等显著特点。ERP 系统的供应链管理思想对企业提出了更高的要求，是企业在信息化社会、在知识经济时代繁荣发展的核心管理模式。

CRM与ERP的区别与联系

ERP只解决了制造企业的运营计划层，就是生产订单的编制、下发，和结果录入。管的是一头一尾，具体功能表现为生产订单的计划数量、完工数量，没有精细的管理过程。虽然有车间管理，但也只是记录。

CRM解决了精细的过程管理需求，详细获取业务过程中的每一个数值。特别是客户管理这一环的过程信息，从客户线索阶段到转化的每一环都涵盖。

如果要让CRM和ERP数据共通，产生关系的话，除了要提前了解他们的端口是否可以共通之外，还能借助一些头部软件厂商进行定制部署，比如像Microsoft Dynamics这样的CRM+ERP的一站式解决方案，不仅可以360°记录客户管理过程，生产数据也可以一并与客户数据整合，将管理进一步精细化。并且，Microsoft Dynamics内置了全球排名第一的商业智能套件Power BI，可以分析所有数据，可视化呈现，辅助企业进行决策。

更多详情可以在优文途新官网直接获取试用，感受一下ERP和CRM的不同解决方案，以及一站式解决方案可以带来的更多管理优势。

PLM与ERP的区别与联系

PLM用于对与产品有关的全部信息进行管理，包括零件信息、配置信息、图片文件、结构信息、权限信息等；

ERP是一种管理生产中的各种资源与流程的集成技术，它主要包括：主生产计划、物料需求计划、采购需求计划、财务系统管理、库存管理等。

PLM的目的在于通过对生产过程和生产过程进行有效的管理，从设计的源头上对产品进行质量的控制，从而达到“开源”和“生钱”的目的，从而减少直接成本，为企业提供技术力量，缩短产品的寿命，从而提升企业的核心竞争能力；ERP旨在“节流”和“省钱”，旨在通过对企业的资源进行有效的管理，从而减少生产成本，提高生产效率。

PLM体系提倡创新，专注于产品的开发与开发，目的在于提高利润，推动产品和工艺的革新，使"杰出"的产品迅速占据市场；ERP系统的重点在于控制，它通过对可视化的要求进行管理，并通过对企业经营活动的控制来达到对财务的影响。

SCM与ERP的区别与联系

SCM和ERP是相辅相成的，但却在完全不同的两个领域发挥作用。

ERP是一种资产型的体系，它经常被当作资产来反映在资产负债表中，并在销售费用中进行摊销。

SCM是一种自然的体系，它的业务范围、业务的复杂程度、以及供应链的长度都会使 SCM系统的执行和维护费用大幅上升，因此， SCM的成本应该被纳入到企业的损益表中。

ERP与SCM是用于满足规则制定者的双重需求所产生的工具。

ERP系统能够有效地优化企业的经营和经营过程，使企业的信息得到统一的管理，从而使企业具有相对于“遵从规则”的交易优势。“规则制定者”们利用这种力量来制定和修改规则，以不同的方式强迫那些遵循规则的人遵循它们。SCM是一种用于“统治”供应链中规则制定者的工具。

MES与ERP的区别与联系

ERP的核心是财务，即从财务的角度来规划企业的资源，而相应的模块也是围绕着财务来展开的，最后的管理数据也会被汇总到财务报告中。

MES的核心是生产，即产品质量，准时交货，设备使用，流程控制等。

与MES相比， ERP的管理范围更广，而MES的管理更精细。

生产资源是ERP管理的一部分，它还包括生产计划、数据收集、质量管理、物料管理等功能，因此很容易与MES系统混淆。

但是ERP的管理范围主要集中在工作中心，MES可以对各个生产过程进行更加精细的控制，并对各个生产过程进行任务下达、执行控制、数据采集和现场调度。ERP要实现过程层次的管理，就必须进行个性化的开发。

SSH：Hibernate框架（七种关联关系映射及配置详解）

概念

 

       基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。

 

分类


         技术分享

            

        关联关系分为上述七种，但是由于相互之间有各种关系，可以简化，例如：多对一与一对多映射，只是侧重的角度不对而已。

 

映射技巧

 

       映射技巧是小编写映射文件的过程，总结的经典内容，总共分为四步，咋看不是特别易懂，但是效果很好。下面我们以实例看技巧。

 

（1）写注释

         格式为：？属性，表达的是本对象与？的？关系。

         解释：在写映射文件之前先写注释，将问号的地方填上相应的内容。例如：<!-- group属性，表达的是本对象（User）与Group的多对一的关系-->

 

（2）写映射的框架（拷模版）

 

多对一

<many-to-one name=“” class=“” column=“”/>

一对多

（Set）

<set name="">

        <key column=""></key>

        <one-to-many class=""/>

</set>

多对多

（Set）

<set name="" table="">

        <key column=""></key>

        <many-to-many class="" column=""/>

</set>

 

 

（3）填空

          填空，就是将映射的框架信息，填写完成，完成映射文件。

          ? name属性：属性名（注释中的第1问号）
          ? class属性：关联的实体类型（注释中的第2个问号）
          ? column属性：
               ○ <many-to-one column="..">：一般可以写成属性名加Id后缀，如属性为group，则column值写成groupId。
               ○ 一对多中的<key column="..">：从关联的对方（对方是多对一）映射中把column值拷贝过来。 
               ○ 多对多中的<key column=“..”>：一般可以写成本对象的名加Id后缀，如本对象名为User，则写为userId。
               ○ 多对多中的<many-to-many column=“..”>：一般可以写为关联对象的名称加Id后缀。
 

（4）完成

          将映射文件添加到hibernate.hbm.xml中，这个相信大家都知道为什么。

      

          我们后面所有关联映射的博文都使用此映射技巧来写映射文件，明白之后，速度会非常快。

 

 

 

（一）多对一关联映射
 

映射原理

 

 

       多的一端维护关联关系，在“多”的一端加入一个外键，指向“一”的一端。多的一端持有一的一端的引用，即在“多”的一端加外键，指向“一”的一端。

 

实例

 

       比如，多个用户属于同一组，我们从对象模型和关系模型两个角度来分析一下这个例子，如下：
技术分享

      从上图可以看出，对象模型具有方向性，通过用户（User）可以看到组（Group），但是不能反过来。用户和组各对应一张数据库表，聚合关系需要一个外键（groupid）来表示，最后生成的表如下所示：

技术分享

 

作用：

      当我拿到用户时直接就可以拿到用户的组，hibernate在访问多的一端时，可以自动的加载关联对象。对于用户（User）来说，它的关联对象是组（group）。

 

      上面都是多对一关联映射的基本原理，以及相应的实例，下面我们看一下代码：

 

 代码

User类

[java] view plaincopy技术分享技术分享
 
 
  1. public class User {  
  2.     private int id;  
  3.     private String name;  
  4.     private Group group;  
  5.           
  6.     public int getId() {  
  7.         return id;  
  8.     }  
  9.     public void setId(int id) {  
  10.         this.id = id;  
  11.     }  
  12.     public String getName() {  
  13.         return name;  
  14.     }  
  15.     public void setName(String name) {  
  16.         this.name = name;  
  17.     }  
  18.     public Group getGroup() {  
  19.         return group;  
  20.     }  
  21.     public void setGroup(Group group) {  
  22.         this.group = group;  
  23.     }  
  24. }  

Group类

[java] view plaincopy技术分享技术分享
 
 
  1. public class Group {  
  2.     private int id;  
  3.     private String name;  
  4.     public int getId() {  
  5.         return id;  
  6.     }  
  7.     public void setId(int id) {  
  8.         this.id = id;  
  9.     }  
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.     public void setName(String name) {  
  14.         this.name = name;  
  15.     }  

User.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="User" table="t_user">  
  7.         <id name="id">  
  8.             <generator class="native"></generator>  
  9.         </id>  
  10.         <property name="name"></property>  
  11.         <!-- group属性，表达的是本对象与Group的多对一的关系-->  
  12.         <many-to-one name="group" class="Group" column="groupid"></many-to-one>  
  13.         <!-- 解释：  
  14.             多对一关系标签：  
  15.             <many-to-one name=“” class=“” column=“”/>  
  16.               
  17.             1、第1个问号：group是User类的属性，对应于name属性名  
  18.             2、第2个问号：class表达的是本对象(User)与Group的关系  
  19.             3、第3个问号：column是属性名+Id  
  20.             当我们写完注释之后，我们直接拷贝问号的对应关系即可。  
  21.          -->  
  22.     </class>  
  23. </hibernate-mapping>  

 Group.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class name="com.liang.hibernate.Group" table="t_group">  
  7.         <id name="id">  
  8.             <generator class="native"></generator>  
  9.         </id>  
  10.         <property name="name"></property>  
  11.     </class>  
  12. </hibernate-mapping>  

 

生成的表结构，与上面的分析的关系模型一样：
          技术分享

 

      项目中，多对一关联映射是最常见的映射，但它是Hibernate的关联映射中最简单的一种映射关系。

 

 

 

（二）一对一单向关联映射

 

 

映射原理

 

      两个实体对象之间是一对一的关联映射，即一个对象只能与另外唯一的一个对象相对应。例如：一个人(Person)只有一张身份证(IdCard)。我们看一下这个例子的对象模型，如下图所示：

 

对象模型

 

       技术分享

        从上图中可以看出：

        1、一个人只有一张身份证，唯一的一个身份证号，对象之间是一对一的关系；

        2、人(Person)持有身份证(IdCard)的引用，所以，两个对象关系维护由person端决定。

        从对象模型映射成关系模型，有两种方式：主键关联和唯一外键关联，我们继续看下面的内容。

 

分类： 

 

 主键关联：

 

        1、两个实体对象的主键一样，以表明它们之间的一一对应关系；

        2、不需要多余的外键字段来维护关系，仅通过主键来关联，即Person的主键要依赖IdCard的主键，他们共用一个主键值。

        以上两点恰与唯一外键关联相反。

 

 主键关联的关系模型

技术分享

 Person.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="Person" table="t_person">  
  7.         <id name="id">  
  8.         <!-- 采用foreign生成策略，forgeign会取得另外一个关联对象的标识 -->  
  9.             <generator class="foreign" >  
  10.                 <param name="property">idCard</param>  
  11.             </generator>  
  12.         </id>  
  13.         <property name="name"></property>  
  14.         <!--   
  15.             one-to-one指示hibernate如何加载其关联对象，默认根据主键加载  
  16.             也就是拿到关系字段值，根据对端的主键来加载关联对象  
  17.               
  18.             constrained="true"表示约束，当前主键（person的主键）还是一个外键  
  19.             参照了对端的主键（IdCard的主键），也就是会生成外键约束语句  
  20.          -->  
  21.          <!-- idCard属性，表达的是本对象与IdCard的一对一关系。 -->  
  22.         <one-to-one name="idCard" class="IdCard"  constrained="true"></one-to-one>  
  23.     </class>  
  24. </hibernate-mapping>  

生成的表结构以及测试数据：

技术分享技术分享

 

唯一外键关联：

 

       1、两个实体对象用一个外键来关联，以表表明对象之间的关系。

       2、其实它是多对一关联映射的特例，多的一端加上唯一的限制之后，用来表示一对一的关联关系。

       所以它采用多对一的标签来映射，如下所示：

[html] view plaincopy技术分享技术分享
 
 
  1. <!-- 采用<mang-to-one>标签来映射，指定多的一端unique为true,  
  2.     这样就限制了多的一端的多重性为一，就是这样来映射的。  
  3. -->  
  4. <many-to-one name="" unique="true"></many-to-one>  

唯一外键的关系模型

技术分享

Person.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="Person" table="t_person">  
  7.         <id name="id">  
  8.             <generator class="native" ></generator>  
  9.         </id>  
  10.         <property name="name"></property>  
  11.         <!-- 由于它是一对一的唯一外键关联，它是多对一关联的特例，注释可以直接写成多对一关联-->  
  12.         <!-- idCard属性，表达的是本对象与IdCard的多对一关系。 -->  
  13.         <many-to-one name="idCard" class="IdCard" column="idCardId" unique="true"></many-to-one>      
  14.     </class>  
  15. </hibernate-mapping>  

生成的表结构以及测试数据：

 技术分享技术分享

 

其他相同代码如下：

Person

[java] view plaincopy技术分享技术分享
 
 
  1. public class Person {  
  2.     private int id;  
  3.     private String name;  
  4.     private IdCard idCard;  
  5.       
  6.     public IdCard getIdCard() {  
  7.         return idCard;  
  8.     }  
  9.     public void setIdCard(IdCard idCard) {  
  10.         this.idCard = idCard;  
  11.     }  
  12.     public int getId() {  
  13.         return id;  
  14.     }  
  15.     public void setId(int id) {  
  16.         this.id = id;  
  17.     }  
  18.     public String getName() {  
  19.         return name;  
  20.     }  
  21.     public void setName(String name) {  
  22.         this.name = name;  
  23.     }  
  24. }  

IdCard

[java] view plaincopy技术分享技术分享
 
 
  1. public class IdCard {  
  2.     private int id;  
  3.     private String cardNo;  
  4.     public int getId() {  
  5.         return id;  
  6.     }  
  7.     public void setId(int id) {  
  8.         this.id = id;  
  9.     }  
  10.     public String getCardNo() {  
  11.         return cardNo;  
  12.     }  
  13.     public void setCardNo(String cardNo) {  
  14.         this.cardNo = cardNo;  
  15.     }  
  16. }  

IdCard.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="IdCard" table="t_idCard">  
  7.         <id name="id">  
  8.             <generator class="native"></generator>  
  9.         </id>  
  10.         <property name="cardNo"></property>  
  11.     </class>  
  12. </hibernate-mapping>  

建议

 

由于一对一主键关联映射具有以下两个缺点：

      1、灵活性差，没有办法改成多对一关联映射，不能应变多变的需求；

      2、必须先保存关联对象IdCard，之后才能保持Person；

所以，在映射一对一单向关联映射时，我们采用唯一外键关联映射。

 

 

（三）一对一双向关联映射

 

上面我们介绍了一对一的单向关联映射，单向是指只能从人（Person）这端加载身份证端（IdCard），但是反过来，不能从身份证端加载人得信息。如图所示：

      技术分享

      关键原因在于对象模型具有方向性：

单向：一端只能加载另一端，不能反过来。

双向：两端都可以加载另一端。

 

      问题来了：如何我们想从身份证端（IdCard）加载人（Person），怎么办呢？

      下面我们开始介绍一对一的双向关联映射。

 

 映射原理

 

       双向关联映射与单向关联映射的原理是一样的，双向关联映射并不影响存储，只影响加载。所以，双向关联映射和单向关联映射的关系模型是一样的即数据库的表结构是一样的，只是IdCard的实体类和配置文件（IdCard.hbm.xml）发生了一点点变化。

 

 对象模型

 

           技术分享

 

 从上图中可以看出：

        1、一个人只有一张身份证，唯一的一个身份证号，对象之间是一对一的关系；

        2、两个对象得关系维护还是由person端决定（因为关系只能由一端维护主键，否则关系就乱了）。

 

       根据上面的对象模型，我们可以看到Person端没有变化，但是要在IdCard端加上Person的引用，例如Person和IdCard实体类如下。

Person

[html] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2.   
  3. public class Person {  
  4.     private int id;  
  5.     private String name;  
  6.     private IdCard idCard;  
  7.       
  8.     public IdCard getIdCard() {  
  9.         return idCard;  
  10.     }  
  11.     public void setIdCard(IdCard idCard) {  
  12.         this.idCard = idCard;  
  13.     }  
  14.     public int getId() {  
  15.         return id;  
  16.     }  
  17.     public void setId(int id) {  
  18.         this.id = id;  
  19.     }  
  20.     public String getName() {  
  21.         return name;  
  22.     }  
  23.     public void setName(String name) {  
  24.         this.name = name;  
  25.     }  
  26. }  

 IdCard

[java] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2.   
  3. public class IdCard {  
  4.     private int id;  
  5.     private String cardNo;  
  6.     private Person person;  
  7.       
  8.     public Person getPerson() {  
  9.         return person;  
  10.     }  
  11.     public void setPerson(Person person) {  
  12.         this.person = person;  
  13.     }  
  14.     public int getId() {  
  15.         return id;  
  16.     }  
  17.   
  18.     public void setId(int id) {  
  19.         this.id = id;  
  20.     }  
  21.     public String getCardNo() {  
  22.         return cardNo;  
  23.     }  
  24.     public void setCardNo(String cardNo) {  
  25.         this.cardNo = cardNo;  
  26.     }  
  27. }  

 

     无论是单向关联映射还是双向关联映射，他们都属于一对一关联映射，只是他们主键的生成策略不同，分为主键关联映射和唯一外键关联映射。

     由于它们都属于一对一关联映射，所以，Hibernate封装双向关联映射时，主键关键映射和唯一外键关联映射的加载策略一样，都采用的是一对一<one-to-one name=""></one-to-one>，只是属性设置不一致，所以，下面我们分开来看IdCard的配置文件。

 

分类：

 

主键关联映射

 

     同一对一单向关联映射类似，主键关联即利用主键进行关联，关联主键的值相同。下面我们看一下映射文件：

 

IdCard.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="IdCard" table="t_idCard">  
  7.         <id name="id">  
  8.             <generator class="native"></generator>  
  9.         </id>  
  10.         <property name="cardNo"></property>  
  11.         <!-- 怎么加载对象，抓取策略：join联合查询（默认），select:一条条的查询 -->  
  12.         <one-to-one name="person" class="Person" fetch="join"></one-to-one>  
  13.     </class>  
  14. </hibernate-mapping>  

Person.hbm.xml，同一对一单向主键关联映射一样

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="Person" table="t_person">  
  7.         <id name="id">  
  8.         <!-- 采用foreign生成策略，forgeign会取得关联对象的标识 -->  
  9.             <generator class="foreign" >  
  10.                 <param name="property">idCard</param>  
  11.             </generator>  
  12.         </id>  
  13.         <property name="name"></property>  
  14.         <!--   
  15.             one-to-one指示hibernate如何加载其关联对象，默认根据主键加载  
  16.             也就是拿到关系字段值，根据对端的主键来加载关联对象  
  17.               
  18.             constrained="true"表示，当前主键（person的主键）还是一个外键  
  19.             参照了对端的主键（IdCard的主键），也就是会生成外键约束语句  
  20.          -->  
  21.         <one-to-one name="idCard" class="IdCard" constrained="true"></one-to-one>  
  22.     </class>  
  23. </hibernate-mapping>  

生成的表结构

 技术分享

 

唯一外键关联映射

    

       一对一双向关联映射的外键关联映射也与一对一单向关联映射的外键关联映射类似，在其一对一的指向端(Person)存在一个唯一外键，该唯一外键与被指向端(IdCard)相关联，关联主键的值相同。下面我们看一下映射文件：
 

IdCard.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="IdCard" table="t_idCard">  
  7.         <id name="id">  
  8.             <generator class="native"></generator>  
  9.         </id>  
  10.         <property name="cardNo"></property>  
  11.         <!-- 一对一唯一外键关联双向采用<one-to-one>标签来映射，必须指定<one-to-one>  
  12.             标签中的property-ref属性为关系字段的名称  
  13.          -->  
  14.         <one-to-one name="person" class="Person" property-ref="idCard"></one-to-one>  
  15.     </class>  
  16. </hibernate-mapping>  

Person.hbm.xml，同一对一单向唯一外键关联映射一样

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="Person" table="t_person">  
  7.         <id name="id">  
  8.             <generator class="native" ></generator>  
  9.         </id>  
  10.         <property name="name"></property>  
  11.         <!-- 由于它是一对一的唯一外键关联，它是多对一关联的特例，注释可以直接写成多对一关联-->  
  12.         <!-- idCard属性，表达的是本对象与IdCard的多对一关系。 -->  
  13.         <many-to-one name="idCard" class="IdCard" column="idCardId" unique="true"></many-to-one>      
  14.     </class>  
  15. </hibernate-mapping>  

生成的表结构

        技术分享

 

对比

 

       一对一单向和双向关联映射的区别正是对象模型和关系模型的区别之一。

对象模型：有方向性。它到底是单向还是双向是由对象模型决定的即配置文件决定。

关系模型：没有方向性或者说是双向的。从任何一端都可以加载另一端。

 

下载

 

         以上内容，只证明了一对一双向关联映射不影响存储即没有改变表结构，但不能证明关联是双向的，需要写相应的测试用例，我们以源码的形式给大家。源码下载

 

 总结

 

       一对一双向关联映射并不是必须的，是由需求下决定的。如果没有这样的需求，用户也没有要求，系统也不需要，就没有必要建立双向的关联映射。

 

（四）一对多关联映射

映射原理

 

 

      一对多关联映射和多对一关联映射的映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。关联关系都是由多端维护，只是在写映射时发生了变化。

 

多对一和一对多的区别

 

         多对一和一对多的区别在于维护的关系不同：

（1）多对一：多端维护一端的关系，在加载多端时，可以将一端加载上来。

（2）一对多：一端维护多端的关系，在加载一端时，可以将多端加载上来。

 

分类

 

一对多单向关联映射

 

对象模型

          技术分享

      从对象模型中，我们可以看出，Group持有User的一个引用。由于是单向关联，所以数据在加载Group时，会把User加载上来，但是User并不知道Group的存在。

 

      我们先看一下Group和User的实体，以及映射文件。

Group

[java] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2. import java.util.Set;  
  3. public class Group {  
  4.     private int id;  
  5.     private String name;  
  6.     private Set users;  
  7.       
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.     public void setId(int id) {  
  12.         this.id = id;  
  13.     }  
  14.     public String getName() {  
  15.         return name;  
  16.     }  
  17.     public void setName(String name) {  
  18.         this.name = name;  
  19.     }  
  20.     public Set getUsers() {  
  21.         return users;  
  22.     }  
  23.     public void setUsers(Set users) {  
  24.         this.users = users;  
  25.     }  
  26. }  

User

[java] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2.   
  3. public class User {  
  4.     private int id;  
  5.     private String name;  
  6.   
  7.     public int getId() {  
  8.         return id;  
  9.     }  
  10.     public void setId(int id) {  
  11.         this.id = id;  
  12.     }  
  13.     public String getName() {  
  14.         return name;  
  15.     }  
  16.     public void setName(String name) {  
  17.         this.name = name;  
  18.     }  
  19. }  

User.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class name="com.liang.hibernate.User" table="t_user">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name"/>  
  11.     </class>  
  12. </hibernate-mapping>  

Group.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <class name="com.liang.hibernate.Group" table="t_group">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name"/>  
  11.         <!-- users属性，表达的是本对象与User的一对多的关系 -->  
  12.         <set name="users">  
  13.              <!--当前表（Group）的主键-->  
  14.             <key column="groupid"/>  
  15.             <one-to-many class="com.liang.hibernate.User"/>  
  16.         </set>  
  17.     </class>  
  18. </hibernate-mapping>  

生成的表结构和测试数据
技术分享技术分享

缺点

 

1）因为多端User不知道Group的存在（也就是User不维护与Group的关系），所以在保存User时，关系字段groupId为null，如果该字段设置为非空，则将无法保存数据。

2）因为User不维护关系，而Group维护关系，Group就会发出多余的update语句，保证Group和User有关系，这样加载Group时才把该Users对应的用户加载上来。

 

一对多双向关联映射

 

对象模型

           技术分享

        双向关联映射对比单向关联映射，对象的加载方向由单向变成了双向。

 

我们看一下Group和User的实体，映射文件

Group

[java] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2.   
  3. import java.util.Set;  
  4.   
  5. public class Group {  
  6.     private int id;  
  7.     private String name;  
  8.     private Set users;  
  9.   
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13.     public void setId(int id) {  
  14.         this.id = id;  
  15.     }  
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.     public void setName(String name) {  
  20.         this.name = name;  
  21.     }  
  22.     public Set getUsers() {  
  23.         return users;  
  24.     }  
  25.     public void setUsers(Set users) {  
  26.         this.users = users;  
  27.     }  
  28. }  

User

[java] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2.   
  3. public class User {  
  4.     private int id;  
  5.     private String name;  
  6.     private Group groups;  
  7.     public int getId() {  
  8.         return id;  
  9.     }  
  10.     public void setId(int id) {  
  11.         this.id = id;  
  12.     }  
  13.     public String getName() {  
  14.         return name;  
  15.     }  
  16.     public void setName(String name) {  
  17.         this.name = name;  
  18.     }  
  19.     public Group getGroups() {  
  20.         return groups;  
  21.     }  
  22.     public void setGroups(Group groups) {  
  23.         this.groups = groups;  
  24.     }  
  25. }  

Group.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="Group" table="t_group">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name"/>  
  11.         <!-- 影响控制反转：inverse="false",多的一端维护关系，让一的一端失效 -->  
  12.         <set name="users" inverse="true">  
  13.             <key column="groupid" not-null="true"/>  
  14.             <one-to-many class="User"/>  
  15.         </set>  
  16.     </class>  
  17. </hibernate-mapping>  

User.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="User" table="t_user">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name"/>  
  11.         <!-- groups属性，表达的是本对象与Group的多对一的关系 -->  
  12.         <many-to-one name="groups" class="Group" column="groupid"/>  
  13.     </class>  
  14. </hibernate-mapping>  

生成的表和测试数据

技术分享技术分享

 

一对多双向关联的映射方式：
 1）在一的一端的集合上采用<key>标签，在多的一端加入一个外键
 2）在多的一端采用<many-to-one>标签

注意：<key>标签和<many-to-one>标签加入的字段保持一直，否则会产生数据混乱。

inverse属性：

         inverse属性可以用在一对多和多对多双向关联上，inverse属性默认为false，为false表示本端维护关系，如果inverse为true，则本端不能维护关系，会交给另一端维护关系，本端失效。所以一对多关联映射我们通常在多的一端维护关系，让一的一端失效，所以设置为inverse为true。

注意：inverse属性，只影响数据的存储，也就是持久化。

 

目的

 

       一对多双向关联映射的目的主要是为了解决一对多单向关联的缺陷而不是需求驱动的。

（五）多对多关联映射

 

 

映射原理

 

 

     不论是单向关联还是双向关联都是通过第三张表，将两个表中的主键放到第三张做一个关联。用第三张表来解决可能会造成数据冗余的问题。

 

举例

 

一个用户（User）对多个角色（Role），一个角色对多个用户。

 

分类

 

单向的多对多关联映射（单向User--->Role）

 

对象模型

              技术分享

关系模型

            技术分享

 

实例

      下面我们看一下实体类和映射文件的代码。

User

[java] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2.   
  3. import java.util.Set;  
  4.   
  5. public class User {  
  6.     private int id;  
  7.     private String name;  
  8.       
  9.     private Set roles;  
  10.       
  11.     public int getId() {  
  12.         return id;  
  13.     }  
  14.     public void setId(int id) {  
  15.         this.id = id;  
  16.     }  
  17.     public Set getRoles() {  
  18.         return roles;  
  19.     }  
  20.     public void setRoles(Set roles) {  
  21.         this.roles = roles;  
  22.     }  
  23.     public String getName() {  
  24.         return name;  
  25.     }  
  26.     public void setName(String name) {  
  27.         this.name = name;  
  28.     }  
  29.       
  30. }  

Role

[java] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2.   
  3. public class Role {  
  4.     private int id;  
  5.     private String name;  
  6.       
  7.     public int getId() {  
  8.         return id;  
  9.     }  
  10.     public void setId(int id) {  
  11.         this.id = id;  
  12.     }  
  13.     public String getName() {  
  14.         return name;  
  15.     }  
  16.     public void setName(String name) {  
  17.         this.name = name;  
  18.     }  
  19. }  

User.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="User" table="t_user">  
  7.         <id name="id">  
  8.             <generator class="native"></generator>  
  9.         </id>  
  10.         <property name="name"></property>  
  11.         <!-- roles属性，表达的是本对象（User）与Role的多对多的关系 -->    
  12.         <set name="roles" table="t_user_role">  
  13.             <!--当前表（User）的主键-->  
  14.             <key column="user_id"></key>  
  15.             <many-to-many class="Role" column="role_id"></many-to-many>  
  16.         </set>  
  17.     </class>  
  18. </hibernate-mapping>  

Role.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="Role" table="t_role">  
  7.         <id name="id">  
  8.             <generator class="native"></generator>  
  9.         </id>  
  10.         <property name="name"></property>  
  11.     </class>  
  12. </hibernate-mapping>  

生成的表结构和测试数据

技术分享技术分享

 

       多对多关联映射，在实体类中，跟一对多关联映射一样，也是用集合来表示的。<set>标签中用table属性重命名中间表名称，<key>标签定义当前表的主键，用<many-to-many>标签来关联另一张表。

 

双向的多对多关联映射（双向User<--->Role）

 

 

对象模型

             技术分享

关系模型

 

       同上

 

实例

      

     下面我们看一下实体类和映射文件的代码。

User

[html] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2. import java.util.Set;  
  3.   
  4. public class User {  
  5.     private int id;  
  6.     private String name;  
  7.       
  8.     private Set roles;  
  9.       
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13.     public void setId(int id) {  
  14.         this.id = id;  
  15.     }  
  16.     public Set getRoles() {  
  17.         return roles;  
  18.     }  
  19.     public void setRoles(Set roles) {  
  20.         this.roles = roles;  
  21.     }  
  22.     public String getName() {  
  23.         return name;  
  24.     }  
  25.     public void setName(String name) {  
  26.         this.name = name;  
  27.     }  
  28.       
  29. }  

Role

[java] view plaincopy技术分享技术分享
 
 
  1. package com.liang.hibernate;  
  2. import java.util.Set;  
  3. public class Role {  
  4.     private int id;  
  5.     private String name;  
  6.     private Set users;  
  7.       
  8.     public Set getUsers() {  
  9.         return users;  
  10.     }  
  11.     public void setUsers(Set users) {  
  12.         this.users = users;  
  13.     }  
  14.     public int getId() {  
  15.         return id;  
  16.     }  
  17.     public void setId(int id) {  
  18.         this.id = id;  
  19.     }  
  20.     public String getName() {  
  21.         return name;  
  22.     }  
  23.     public void setName(String name) {  
  24.         this.name = name;  
  25.     }  
  26. }  

User.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="User" table="t_user">  
  7.         <id name="id">  
  8.             <generator class="native"></generator>  
  9.         </id>  
  10.         <property name="name"></property>  
  11.         <!-- roles属性，表达的是本对象(User)与Role的多对多的关系 -->    
  12.         <set name="roles" table="t_user_role">  
  13.             <!--当前表（User）的主键-->  
  14.             <key column="user_id"></key>  
  15.             <many-to-many class="Role" column="role_id"></many-to-many>  
  16.         </set>  
  17.     </class>  
  18. </hibernate-mapping>  

Role.hbm.xml

[html] view plaincopy技术分享技术分享
 
 
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="Role" table="t_role">  
  7.         <id name="id">  
  8.             <generator class="native"></generator>  
  9.         </id>  
  10.         <property name="name"></property>  
  11.         <!-- users属性，表达的是本对象(Role)与User的多对多的关系 -->    
  12.         <set name="users" table="t_user_role">  
  13.             <!--当前表（Role）的主键-->                  
  14.             <key column="role_id"></key>  
  15.             <many-to-many class="User" column="user_id"></many-to-many>  
  16.         </set>  
  17.     </class>  
  18. </hibernate-mapping>  

生成的表结构和测试数据

技术分享技术分享

 

      多对多双向关系中，User和Role的映射文件相同，值得注意的是生成的中间表名称必须一样，生成中间表的字段必须一样。

 

总结

 

      多对多关联映射到此就结束了，经过对一对多关联映射的学习，相对而言，多对多关联映射变得非常的简单了，非常像一对多关联映射的变体。

 

      Hibernate是一个对象关系映射框架，当然从分层的角度看，我们也说它是数据持久层的框架。

      我们从上一句话可以看出Hibernate的核心：面向对象、关系映射以及数据持久化。前面两个概念很容易理解，而对于“数据持久化”，就是将数据或者某物体，永久的保存起来。现实生活中的例子有很多，例如：鲜肉冷藏，水果做成罐头，而对于编程而言就是将数据保存在文件或磁盘以及数据库中。下面我们再看一下Hibernate的核心对象：

 

核心对象

         技术分享

     上面这幅图反馈给我们的信息有很多，能否读懂这幅图可以从侧面反映你对Hibernate理解的水平。下面我们说几条：

1、Hibernate有俩个主要的配置文件：（Hibernate.cfg.xml和xxx.hbm.xml）

2、Hibernate有五个或六个接口：Configuration、SessionFactory、Session、Transaction、Query和Criteria。

3、Hibernate的执行原理，看上图的箭头即可。

4、Session对象是通过SessionFactory构建的，这是Hibernate创建Session的两种方式之一。

。。。。。。

 

      由于内容太多，我们暂时就列这么多，就不再一一列举了。下面我们再详细的介绍映射的分类。

 

分类

       

        技术分享

      在Hibernate系列的起初，我将关系映射分为了以上四种，现在来看关系映射其实就两种，甚至一种。

 

1、从对象的加载方向上分为单向和双向两种。

      单向和双向只影响数据的加载，并不影响数据的存储。不论是一对一，一对多还是多对多，单向和双向生成的数据库表是一样，单向和双向的不同是由对象模型决定的。

 

2、从对象的映射关系上分为一对多和多对一两种，它们又是从不同角度说的，所以也可以说是一种。

      一对一关联映射是多对一关联映射的特例，只是在“多”的一端加上唯一的限制之后，用来表示一对一的关联关系。

      多对多关联映射是一对多关联映射的特例，它们呢都是使用集合来表示多的关系，用<key>标签定义当前表的主键。

     当然它们既有联系也有区别，区别就不再一一列举了，系列博文中已经详细的介绍了各自的联系与区别。



 

      Hibernate是一个对象关系映射框架，当然从分层的角度看，我们也说它是数据持久层的框架。

      我们从上一句话可以看出Hibernate的核心：面向对象、关系映射以及数据持久化。前面两个概念很容易理解，而对于“数据持久化”，就是将数据或者某物体，永久的保存起来。现实生活中的例子有很多，例如：鲜肉冷藏，水果做成罐头，而对于编程而言就是将数据保存在文件或磁盘以及数据库中。下面我们再看一下Hibernate的核心对象：

 

核心对象

         技术分享

     上面这幅图反馈给我们的信息有很多，能否读懂这幅图可以从侧面反映你对Hibernate理解的水平。下面我们说几条：

1、Hibernate有俩个主要的配置文件：（Hibernate.cfg.xml和xxx.hbm.xml）

2、Hibernate有五个或六个接口：Configuration、SessionFactory、Session、Transaction、Query和Criteria。

3、Hibernate的执行原理，看上图的箭头即可。

4、Session对象是通过SessionFactory构建的，这是Hibernate创建Session的两种方式之一。

。。。。。。

 

      由于内容太多，我们暂时就列这么多，就不再一一列举了。下面我们再详细的介绍映射的分类。

 

分类

       

        技术分享

      在Hibernate系列的起初，我将关系映射分为了以上四种，现在来看关系映射其实就两种，甚至一种。

 

1、从对象的加载方向上分为单向和双向两种。

      单向和双向只影响数据的加载，并不影响数据的存储。不论是一对一，一对多还是多对多，单向和双向生成的数据库表是一样，单向和双向的不同是由对象模型决定的。

 

2、从对象的映射关系上分为一对多和多对一两种，它们又是从不同角度说的，所以也可以说是一种。

      一对一关联映射是多对一关联映射的特例，只是在“多”的一端加上唯一的限制之后，用来表示一对一的关联关系。

      多对多关联映射是一对多关联映射的特例，它们呢都是使用集合来表示多的关系，用<key>标签定义当前表的主键。

     当然它们既有联系也有区别，区别就不再一一列举了，系列博文中已经详细的介绍了各自的联系与区别。


















以上是关于详解CRMPLMSCMMES 与 ERP 的关联及概念的主要内容，如果未能解决你的问题，请参考以下文章

新闻鲁泰化学ERP项目开展集成测试

灰色关联分析法详解及python实践

灰色关联分析法详解及python实践

SSH：Hibernate框架（七种关联关系映射及配置详解）

工作亮点鲁泰化学ERP项目开展集成测试工作

项目管理(PJM)与Sage X3 ERP的集成应用