持久层上多态表现的三种策略 & oo数据库设计

 

 

 

 

 

策略1:One table per subclass 

java 代码     (超类)

1. @Entity  
2. @Table(name="tb_person")   
3. @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)   
4. public class Person implements Serializable{   
5.        
6.     Integer id;   
7.        
8.     @Id  
9.     @Column(name="id")   
10.     public Integer getId() {   
11.         return id;   
12.     }   
13.     public void setId(Integer id) {   
14.         this.id = id;   
15.     }   
16. }  

 

java 代码 (子类1)

1. @Entity  
2. @Table(name="tb_individual")   
3. public class Individual extends Person {   
4.        
5.     String firstName;   
6.     String lastName;   
7.        
8.     @Column(name="firstname")   
9.     public String getFirstName() {   
10.         return firstName;   
11.     }   
12.     public void setFirstName(String firstName) {   
13.         this.firstName = firstName;   
14.     }   
15.     @Column(name="lastname")   
16.     public String getLastName() {   
17.         return lastName;   
18.     }   
19.     public void setLastName(String lastName) {   
20.         this.lastName = lastName;   
21.     }   
22. }  

 

java 代码 (子类2)

1. @Entity  
2. @Table(name="tb_corporation")   
3. public class Corporation extends Person{   
4.   
5.     String registerationNumber;   
6.     String name;   
7.        
8.     @Column(name="name")   
9.     public String getName() {   
10.         return name;   
11.     }   
12.     public void setName(String name) {   
13.         this.name = name;   
14.     }   
15.     @Column(name="registeration_number")   
16.     public String getRegisterationNumber() {   
17.         return registerationNumber;   
18.     }   
19.     public void setRegisterationNumber(String registerationNumber) {   
20.         this.registerationNumber = registerationNumber;   
21.     }   
22. }  

从结构上来看这是一种依赖性比较强的数据库结构，3张表之间本身是独立的。而它们之间的关系却需要手动维护。

java 代码

1. From Person  

这条查询语句返回的结果是3张表的集合 Person+Individual+Corporation。 但是值得商榷的是这个query语句会查询3个数据库，效率问题会是以后一个比较明显的问题。

java 代码

1. From Corporation   

这条查询语句返回的结果就是1张表的内容 Corporation  

 

策略2： Single table per class hierarchy

java 代码

1. @Entity  
2. @Table(name="tb_right")   
3. @Inheritance(strategy=InheritanceType.SINGLE_TABLE)   
4. @DiscriminatorColumn(name="RIGHT_TYPE"  
5.     ,discriminatorType=DiscriminatorType.STRING)   
6.     @DiscriminatorValue("RIGHT_SUPER")   
7. public class Right {   
8.     Integer id;   
9.     String name;   
10.        
11.     @Column(name="right_id")   
12.     @GeneratedValue  
13.     @Id  
14.     public Integer getId() {   
15.         return id;   
16.     }   
17.     public void setId(Integer id) {   
18.         this.id = id;   
19.     }   
20.     @Column(name="right_name")   
21.     public String getName() {   
22.         return name;   
23.     }   
24.     public void setName(String name) {   
25.         this.name = name;   
26.     }   
27. }  

java 代码

1. @Entity  
2. @Table(name="tb_right")   
3. @DiscriminatorValue("LEASE_SUB")   
4. public class Lease extends Right {   
5.        
6.     String leaseName;   
7.     @Column(name="lease_name")   
8.     public String getLeaseName() {   
9.         return leaseName;   
10.     }   
11.     public void setLeaseName(String leaseName) {   
12.         this.leaseName = leaseName;   
13.     }   
14.        
15. }   

java 代码

1. @Entity  
2. @Table(name="tb_right")   
3. @DiscriminatorValue("PROPERTY_SUB")   
4. public class Property extends Right {   
5.        
6.     String name;   
7.        
8.     @Column(name="property_name")   
9.     public String getName() {   
10.         return name;   
11.     }   
12.     public void setName(String name) {   
13.         this.name = name;   
14.     }   
15.        
16. }  

这种结构把一个继承树全部移植到一张表内，通过一个字段来标识。相对而言，任何填加，修改，删除的操作都针对于一张表而言，在速度上有一定的优势，但是由于通过一个字段来体现多态，结构局限性比较大。而且维护的成本也比较高！违反了OO的高内聚，低偶合的原则。

java 代码

1. From Right  

查询出来的结果是表tb_right的全部内容！

java 代码

1. From Lease  

查询出来的结果是表tb_right中字段right_type为Lease_sub的所有字段！

java 代码

1. From Property  

查询出来的结果是表tb_right中字段right_type为Property_sub的所有字段！

 策略3：字段共享策略

java 代码

1. @Entity  
2. @Inheritance(strategy=InheritanceType.JOINED)   
3. @Table(name="tb_estate")   
4. public class Estate implements Serializable{   
5.   
6.     Integer id;   
7.     String description;   
8.        
9.     @Column(name="description")   
10.     public String getDescription() {   
11.         return description;   
12.     }   
13.     public void setDescription(String description) {   
14.         this.description = description;   
15.     }   
16.     @Id  
17.     @GeneratedValue  
18.     @Column(name="id")   
19.     public Integer getId() {   
20.         return id;   
21.     }   
22.     public void setId(Integer id) {   
23.         this.id = id;   
24.     }      
25. }  

java 代码

1. @Entity  
2. @Table(name="tb_build")   
3. @PrimaryKeyJoinColumn(name="id")   
4. public class Building extends Estate {   
5.        
6.     String address;   
7.        
8.     @Column(name="address")   
9.     public String getAddress() {   
10.         return address;   
11.     }   
12.     public void setAddress(String address) {   
13.         this.address = address;   
14.     }   
15. }  

java 代码

1. @Entity  
2. @Table(name="tb_land")   
3. @PrimaryKeyJoinColumn(name="id")   
4. public class Land extends Estate {   
5.   
6.     String landName;   
7.        
8.     @Column(name="land_name")   
9.     public String getLandName() {   
10.         return landName;   
11.     }   
12.     public void setLandName(String landName) {   
13.         this.landName = landName;   
14.     }   
15. }