映射实体关联关系

约定不等于承诺〃 2022-07-13 18:51 324阅读 0赞

映射一对一关联

有两种方法，一种按照外键映射，一种按照主键映射。

1.按照外键映射

  1.         一个类中有两个一对一关联。
  3. class A{
  4. id;
  5. name;
  6. B home;
  7. B company;
  8. }
  9. class B{
  10. string address;
  11. string  street;A a;
  12. }
  14. A表
  15. id
  16. name
  17. home_id//指向B表中的id，外键
  18. company_id//指向B表中的id，外键
  20. B表
  21. address
  22. street
  23. id

A映射文件：

  1. <many-to-one
  2. name="home"
  3. class="B"
  4. column="home_id"
  6. />
  7. <many-to-one
  8. name="company"
  9. class="B"
  10. column="company_id"
  11. unique="true"//保证唯一 
  12. cascsde="all"
  13. />

B映射文件：

  1. <one-to-one //只能使用一次，所以要映射两次的话，把B定义为抽象类，用两个类继承，让后再每个类中用one-to-one
  2. name="a"
  3. class="A"
  4. property-ref="home"
  5. />

2.按照主键映射

  1.   只有一个一对一关联。
  3. class A{
  4. id;name
  5. B b;
  6. }
  7. class B{
  8. id 
  9. address;A a
  10. }
  12. A表
  13. id
  14. name
  15. //这两个表共享主键，id是一样的
  16. B表
  17. id//作为主键的同时，作为外键参照A表
  18. address

A映射文件：

  1. <one-to-one name="b"
  2. class="B"
  3. cascade="true"
  4. />

B映射文件：

  1. <id>
  2. <generator class="foreign">//OID要用foreign策略
  3. <param name="property">a</param>
  4. </generator>
  5. </id>
  6. <one-to-one name="a"
  7. class="A"
  8. constrained="true"//表示主键id同时作为外键参照A表
  9. />

映射单向多对多关联

  1. class A{//这两个类是多对多关系
  2. id 
  3. name；Set BS = new HashSet();
  4. }
  5. class B{
  6. id
  7. address
  8. }

要建立一个中间表

  1. A表
  2. id
  3. name
  4. B表
  5. id
  6. address
  8. A_B表
  9. A_id//A_id和B_id作为联合主键，A_id作为A表的外键，B_id作为B表的外键
  10. B_id

A映射文件：

  1. <set
  2. name="BS"
  3. table="A_B"
  4. cascade="save-update"
  5. lazy="true"
  6. >
  7. <key column="A_id">
  8. <many-to-many column="B_id" class="B"/>
  9. </set>

也可以用list:

  1. <list
  2. name="BS"
  3. table="A_B"
  4. cascade="save-update"
  5. lazy="true"
  6. >
  7. <key column="A_id"><list-index column="索引字段">
  8. <many-to-many column="B_id" class="B"/>
  9. </list>

映射双向多对多关联关系

  1.    双向多对多必须把一端的inverse为true。inverse为true一段可以使用<set>,<bag>。inverse为false的一端，可以使用<set>,<list>,<map>,<idbag>。

1.关联两端使用元素

  1. class A{
  2. id
  3. name
  4. set BS
  5. }
  6. class B{
  7. id
  8. adress
  9. set AS
  10. }//表和单向多对多一样

A映射文件：

  1. <set
  2. name="BS"
  3. table="A_B"
  4. cascade="save-update"
  5. lazy="true"
  6. >
  7. <key column="A_id">
  8. <many-to-many column="B_id" class="B"/>
  9. </set>

B映射文件

  1. <set
  2. name="AS"
  3. table="A_B"
  4. inverse="true"
  5. cascade="save-update"
  6. lazy="true"
  7. >
  8. <key column="B_id">
  9. <many-to-many column="A_id" class="A"/>
  10. </set>

2.inverse为true的一端使用bag

  1.     为什么Inverse为true的那端不能使用list,map之类的呢：因为这些元素有排序。
  3.     如果两个类都是list集合，而没有inverse的那端可以更新索引，有inverse的那端不能同步更新索引，所以如果索引变化了就不会同步更新，就出问题。
  5.      如果在inverse那端勒种定义的是list，那么就是用bag元素，<bag>和<idbag>的区别是：都允许放重复对象，都不支持索引位置排序，<idbag>要求连接表中一定要有代理主键，<bag>没有这个要求，<bag>一般用于一对多或多对多的inverse端。
  9. <bag
  10. name="AS"
  11. table="A_B"
  12. cascade="save-update"
  13. lazy="true"
  14. >
  15. <key column="B_id">
  16. <many-to-many column="A_id" class="A"/>
  17. </bag>

3.使用组件类集合

  1.     两个多对多的类可以使用一个组件类型的类，来实现多对多，而不是用主键当外键关联两个类的表。
  3. calss A{
  4. id 
  5. name
  6. set ab//A_B类型
  7. }
  8. class B{
  9. id
  10. adress
  11. Set ba//A_B类型
  12. }
  13. class A_B{//使用组件关联两个多对多的类
  14. A a
  15. B b
  16. name
  17. }
  19. A表
  20. id
  21. name
  22. B表
  23. id
  24. address
  25. A_B表//表中所有字段作为联合主键
  26. A_id//外键
  27. B_id//外键
  28. name

A映射文件：

  1. <set
  2. name="ab"
  3. table="A_B"
  4. cascade=""
  5. lazy=""
  6. >
  7. <key column="A_id">
  8. <composite-element class="A_B">
  9. <parent name="a">
  10. <many-to-one name="b" class="B" column='B_id">
  11. <property>
  12. </composite>
  13. </set>

B的映射文件：

  1. <set
  2. name="ba"
  3. table="A_B"
  4. cascade=""
  5. lazy="" inverse="true"
  6. >
  7. <key column="B_id">
  8. <composite-element class="A_B">
  9. <parent name="b">
  10. <many-to-one name="a" class="A" column='A_id">
  11. <property>
  12. </composite>
  13. </set>

4.把多对多关联分解为两个一对多关联

  1.       在组件类型中添加OID，可以打一个多对多拆成两个一对多。

A映射文件:

  1. <set
  2. name="ab"
  3. cascade=""
  4. lazy="" inverse="true"//一对多，一这边最好要加inverse="true"
  5. >
  6. <key column="A_id">
  7. <one-to-many class="A_B">
  8. </set>

B映射文件：

  1. <set
  2. name="ba"
  3. cascade=""
  4. lazy="" inverse="true"//一对多，一这边最好要加inverse="true"
  5. >
  6. <key column="B_id">
  7. <one-to-many class="A_B">
  8. </set>

因为A_B现在有OID了，所以有映射文件：

  1. <class  name="" table>
  2. <id>
  3. <property>
  4. <many-to-one name="a" column="A_id" class="A"/>
  5. <many-to-one name="b" column="B_id" class="B"/>
  6. </class>

发表评论

表情：
评论列表 （有 0 条评论，324人围观）

还没有评论，来说两句吧...

相关阅读