zoukankan      html  css  js  c++  java
  • Hibernate实体对象继承策略

            Hibernate继承策略总共同拥有三种,一种是共用一张表;一种是每一个类一张表,表里面储存子类的信息和父类的信息;另一种是通过表连接的方式。每一个类都有一张表,可是子类相应的表仅仅保存自己的信息,父类相应的表保存父类的信息。它们之间通过子类表和父类表的关联来获取全部的信息。

    第一种方式,即共用一张表:

    Java代码
     收藏代码
    1. @Entity  
    2. @Inheritance(strategy=InheritanceType.SINGLE_TABLE)  
    3. @DiscriminatorColumn(name="discriminator", discriminatorType=DiscriminatorType.STRING)//表示区分不同的对象的字段名  
    4. @DiscriminatorValue("person")//用来表示该对象是何种对象的,即区分器  
    5. public class Parent {  
    6.     private int id;  
    7.     private String name;  
    8.       
    9.     @Id  
    10.     @GeneratedValue  
    11.     public int getId() {  
    12.         return id;  
    13.     }  
    14.     public void setId(int id) {  
    15.         this.id = id;  
    16.     }  
    17.     public String getName() {  
    18.         return name;  
    19.     }  
    20.     public void setName(String name) {  
    21.         this.name = name;  
    22.     }  
    23.   
    24. }  
    25.   
    26. @Entity  
    27. @DiscriminatorValue("child1")  
    28. public class Child1 extends Parent {  
    29.     private String email;  
    30.   
    31.     public String getEmail() {  
    32.         return title;  
    33.     }  
    34.   
    35.     public void setEmail(String email) {  
    36.         this.email = email;  
    37.     }  
    38.   
    39.       
    40. }  
    41.   
    42.   
    43.   
    44. @Entity  
    45. @DiscriminatorValue("child2")  
    46. public class Child2 extends Parent {  
    47.       
    48.     private String address;  
    49.   
    50.     public String getAddress() {  
    51.         return score;  
    52.     }  
    53.   
    54.     public void setAddress(String address) {  
    55.         this.address = address;  
    56.     }  
    57.       
    58. }   

            这样的情况父类和全部子类的全部信息都保存在同一张表里面,通过我们指定的@DiscriminatorColumn相应的@DiscriminatorValue来差别不同的类。 当没有指定@DiscriminatorValue的时候将使用全类名来作为DiscriminatorValue。

     

     

    另外一种策略是每一个类一张表,保存全部信息:

    Java代码
     收藏代码
    1. @Entity  
    2. @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)  
    3. @TableGenerator(        //一个类一张表。最重要的是要保证它们的id由一个生成器产生,@TableGenerator就是为了控制这个的  
    4.         name="t_gen",  
    5.         table="t_gen_table",  
    6.         pkColumnName="t_pk",  
    7.         valueColumnName="t_value",  
    8.         pkColumnValue="person_pk",  
    9.         initialValue=1,  
    10.         allocationSize=1  
    11.         )  
    12. public class Parent {  
    13.     private int id;  
    14.     private String name;  
    15.       
    16.     @Id  
    17.     @GeneratedValue(generator="t_gen", strategy=GenerationType.TABLE)//这个就是用表生成器生成的。用同一个生成器就能够控制它们的id不反复  
    18.     public int getId() {  
    19.         return id;  
    20.     }  
    21.     public void setId(int id) {  
    22.         this.id = id;  
    23.     }  
    24.     public String getName() {  
    25.         return name;  
    26.     }  
    27.     public void setName(String name) {  
    28.         this.name = name;  
    29.     }  
    30.   
    31. }  
    32.   
    33.   
    34. @Entity  
    35. public class Child2 extends Parent {  
    36.       
    37.     private String address;  
    38.   
    39.     public String getAddress() {  
    40.         return score;  
    41.     }  
    42.   
    43.     public void setAddress(String address) {  
    44.         this.address = address;  
    45.     }  
    46.       
    47. }  
    48.   
    49.   
    50. @Entity  
    51. public class Child1 extends Parent {  
    52.     private String email;  
    53.   
    54.     public String getEmail() {  
    55.         return title;  
    56.     }  
    57.   
    58.     public void setEmail(String email) {  
    59.         this.email = email;  
    60.     }  
    61.   
    62.       
    63. }  

     

     

    弟三种方式是採用表连接的方式:

    Java代码
     收藏代码
    1. @Entity  
    2. @Inheritance(strategy=InheritanceType.JOINED)  
    3.   
    4. public class Parent {  
    5.     private int id;  
    6.     private String name;  
    7.       
    8.     @Id  
    9.     @GeneratedValue  
    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.   
    23. }  
    24.   
    25. @Entity  
    26. public class Child2 extends Parent {  
    27.       
    28.     private String address;  
    29.   
    30.     public String getAddress() {  
    31.         return score;  
    32.     }  
    33.   
    34.     public void setAddress(String address) {  
    35.         this.address = address;  
    36.     }  
    37.       
    38. }  
    39.   
    40.   
    41. @Entity  
    42. public class Child1 extends Parent {  
    43.     private String email;  
    44.   
    45.     public String getEmail() {  
    46.         return title;  
    47.     }  
    48.   
    49.     public void setEmail(String email) {  
    50.         this.email = email;  
    51.     }  
    52.   
    53.       
    54. }  

             採用表连接的情况,还是每一个类拥有自己的一张表,仅仅是子类相应的表仅仅保存子类的信息。其父类的信息由父类的表保存。

    当须要获取子类的完整信息时通过表连接的方式连接子类的表和父类的表获取相应信息。

    能够在子类的表上标注@PrimaryKeyJoinColumn(name="foreignKeyName")指明子类表相对于父类表外键的名称。

  • 相关阅读:
    2018 ACM 网络选拔赛 徐州赛区
    2018 ACM 网络选拔赛 焦作赛区
    2018 ACM 网络选拔赛 沈阳赛区
    poj 2289 网络流 and 二分查找
    poj 2446 二分图最大匹配
    poj 1469 二分图最大匹配
    poj 3249 拓扑排序 and 动态规划
    poj 3687 拓扑排序
    poj 2585 拓扑排序
    poj 1094 拓扑排序
  • 原文地址:https://www.cnblogs.com/bhlsheji/p/5138273.html
Copyright © 2011-2022 走看看