Mappings of JPA Object Inheritance relationships

In JPA, there are three ing policies for Object Inheritance relationships: Table per class, table per subclass, and table_per_class.

 

1. Single Table inheritance Policy

Single-Table inheritance policy. Parent-class entities and sub-class entities share a database table. In the table, a column is used to identify fields to differentiate entities of different classes. The procedure is as follows:

A. Add the following annotation under the @ entity annotation of the parent class object:

@ Inheritance (Strategy = inheritancetype. single_table)
@ Discriminatorcolumn (name = "identifying field column names ")
@ Discriminatorvalue (column value of the parent entity identification field)

 

B. Add the following annotation under the @ entity annotation of the subclass object:

@ Discriminatorvalue (column value of the field to be recognized by the subclass object)

 

 

Defines a parent class

 

Java code

1. @ Entity
2. @ Inheritance (Strategy = inheritancetype. single_table)
3. @ Table (name = "window_file ")
4. @ Discriminatorcolumn (name = "discriminator", discriminatortype = discriminatortype. String, length = 30)
5. @ Discriminatorvalue ("windowfile ")
6. Public class windowfile {
8. @ ID
9. @ Generatedvalue (Strategy = generationtype. Auto)
10. Private integer ID;
12. @ Basic
13. @ Column (name = "name ")
14. Private string name;
16. @ Basic
17. @ Column (name = "type ")
18. Private string type;
20. @ Basic
21. @ Column (name = "date ")
22. Private date;
23. // Omit Get Set
24. }

 

And then define two subclasses.

 

Java code

1. @ Entity
2. @ Discriminatorvalue ("folder ")
3. Public class folder extends windowfile {
5. @ Basic
6. @ Column (name = "file_count ")
7. Private integer filecount;
8. // Omit Get Set
9. }

 

Java code

1. @ Entity
2. @ Discriminatorvalue ("document ")
3. Public class document extends windowfile {
5. @ Basic
6. @ Column (name = "size ")
7. Private string size;
8. // Omit Get Set
9. }

 

Different discriminator columns are used to differentiate Parent and Child entities.

 

The actual table structure is as follows:

Window_file discriminator, ID, name, date, type, size, file_count

 

When you use a windowfile object, the actual table field is discriminator = 'windowfile', and the size and file_count are always empty.

When the folder object is used, discriminator = 'folder', size is always empty, and file_count is the actual value.

Similarly, document is similar to folder.

 

2. Joined Policy

 

The parent object and the child object correspond to different tables in the database respectively. The child object table only has its extended special attributes, and the public attributes of the parent class are stored in the parent class Object ing table. Specific Practices:

 

 

 

@ Inheritance (Strategy = inheritancetype. Joined)

 

Special descriptions are not required for subclass objects.

 

 

Java code

1. @ Entity
2. @ Table (name = "t_animal ")
3. @ Inheritance (Strategy = inheritancetype. Joined)
4. Public class animal {
6. @ ID
7. @ Column (name = "ID ")
8. @ Generatedvalue (Strategy = generationtype. Auto)
9. Private integer ID;
11. @ Column (name = "name ")
12. Private string name;
14. @ Column (name = "color ")
15. Private string color;
16. // Omit Get Set
17. }

 

Java code

1. @ Entity
2. @ Table (name = "t_bird ")
3. @ Primarykeyjoincolumn (name = "bird_id ")
4. Public class bird extends animal {
6. @ Column (name = "Speed ")
7. Private string speed;
8. // Omit Get Set
9. }

 

Java code

1. @ Entity
2. @ Table (name = "t_dog ")
3. @ Primarykeyjoincolumn (name = "dog_id ")
4. Public class dog extends animal {
6. @ Column (name = "Legs ")
7. Private integer legs;
8. // Omit Get Set
9. }

 

 

The actual table structure is as follows:

T_animal ID, color, name

T_bird speed, bird (both a foreign key and a primary key)

T_dog legs, dog_id (both foreign key and primary key)

 

3. table_per_class policy:

 

Table_per_class policy. each class of the parent class Object corresponds to a table in the database, and all attributes, including attributes inherited from the parent class object, are saved in the Child class table. Specific Practices:

You only need to add the following annotation under the @ entity annotation of the parent class object:

@ Inheritance (Strategy = inheritancetype. table_per_class)

 

Java code

1. @ Entity
2. @ Inheritance (Strategy = inheritancetype. table_per_class)
3. @ Table (name = "t_vehicle ")
4. Public class vehicle {// base class
6. @ ID
7. // @ Generatedvalue
8. @ Column (name = "ID ")
9. Private integer ID;
11. @ Column (name = "Speed ")
12. Private integer speed; // speed
13. // Omit Get Set
14. }

 

Java code

1. @ Entity
2. @ Table (name = "t_car ")
3. Public class car extends vehicle {
5. @ Column (name = "engine ")
6. Private string engine; // Engine
7. // Omit Get Set
8. }

 

Once this policy is used, auto generator and identity generator cannot be used, that is, the primary key value cannot be automatically generated by the database.

 

The actual table structure is as follows:

T_vehicle ID, speed

T_car ID, speed, engine

Address: http://www.360doc.com/content/13/0710/15/203871_298949089.shtml