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")指明子类表相对于父类表外键的名称。

  • 相关阅读:
    .NET5都来了,你还不知道怎么部署到linux?最全部署方案,总有一款适合你
    一款基于.NET Core的认证授权解决方案-葫芦藤1.0开源啦
    开源项目葫芦藤:IdentityServer4的实现及其运用
    MySQL大表优化方案
    Sec-Fetch-*请求头,了解下?
    前端开发快速入门
    从零开始打造专属钉钉机器人
    打造钉钉事件分发平台之钉钉审批等事件处理
    React中的高阶组件
    浏览器本地存储方案
  • 原文地址:https://www.cnblogs.com/bhlsheji/p/5138273.html
Copyright © 2011-2022 走看看