The mapping relationship of hibernate learning

One, hibernate many-to-one association mapping: is the "many" at the end of the foreign key, pointing to the one end.

For example, multiple students corresponding to a class, a number of users corresponding to a level, etc., are many-to-one relationship.

　　

1. "Many" end entities add variables and Getter,setter methods that refer to "one" end entities.

For example, multiple students corresponding to a class, in the student entity class joined: Private Grade Grade;

2, "Multi" end configuration file, the label settings in Student.hbm.xml: <many-to-one name= "Grade" column= "Gradeid" ></many-to-one>

Two, hibernate one-way primary Key Association mapping: Just let the two entities of the primary key, you do not need to add extra fields.

For example, a student corresponding to a social security number, a student corresponding to an account information, etc., are one-to-one correlation mapping.

　　

1, the person entity to hold the Idcard reference. Add attributes to the person entity: Private Idcard Idcard;

2, person side maintenance relationship, so need to focus on the person's configuration file, Person.hbm.xml popular, that is, the ID of the person is both the primary key and the foreign key.

so you need to modify the ID tag in person: In layman's terms, tell the ID of the person to associate with the ID in which entity. The foreign generation strategy here obtains the identity of the associated object,whichis the object associated with it in the property tag .

<id name= "id" >    <generator class= "foreign" >        <param name= "Property" >idCard</param>    </generator></id>

3. Add the tag of the association relationship in Person.hbm.xml: <one-to-one name= "Idcard" constrained= "true" ><one-to-one/>

the one-to-one tag here indicates how hibernate loads its associated objects, which, by default, load the relational field values according to the primary key, and load the associated objects based on the primary key of the peer. the constrained= "True" here indicates the ID primary key of the current person, or a foreign key, and a FOREIGN KEY constraint statement is generated, referring to the ID primary key of the Idcard at the corresponding end. Note: The foreign mapping strategy preserves the associated objects while saving the person object, also known as Idcard, and has cascading relationships between them. However, conversely, it is not possible, that is, if only the Idcard object is saved, the person object is not saved, because the relationship is maintained on the person side, and Idcard does not know the existence of the person at all. Primary Key Association mapping has drawbacks and is poorly maintained.

Three, hibernate two-way one-to-one correlation mapping: Some requirements require from one end can be traced to the other end, from the other end can be found at this end, you need two-way correlation mapping.

For example, want to according to the person's information to find his account information, also want to based on the account information to find out which person's information and so on.

　　

1, modify the object model, add a reference to the person in the Idcard.java entity, adding the attribute: Private person person, (in the Person.java entity also has Idcard reference OH)

2, modify the IdCard.hbm.xml file, add one-to-one tag.

<one-to-one name= "Person"/>

Note The 1:one-to-one tag does not affect storage, it only affects loading, does not modify the database, that is, no fields are added, and Many-to-one modifies the database, adding a field.

Note 2: Understand the crawl strategy: fetch= "Select" Controls the order in which data is fetched.

Four, one-way single-to-one unique foreign Key association mappings: A pair of primary key association is not good maintenance, with foreign key association object is better. Principle: Many-to-one special case.

For example, it is also the case of person and Idcard.

1, Person.java is the entity has the Idcard reference, namely joins the attribute: private Idcard Idcard;idcard.java does not have the person reference.

2, configuration files: IdCard.hbm.xml are common attributes. Person.hbm.xml's primary key generation strategy needs to change: change back to:

<generator class= "native"/>

Use the label Many-to-one and unique: <many-to-one name= "Idcard" unique= "true"/>, which limits the uniqueness of the many end.

　　Note: You need to save the Idcard first. otherwise error.

Five, two-way single-to-one unique foreign key association: if there is a requirement, you can also establish a two-way foreign key association.

1. Add a reference to the corresponding end in person and Idcard, that is, add the corresponding attribute.

2, Person.hbm.xml and Example (iv), modify the IdCard.hbm.xml file, add one-to-one tags: <one-to-one name= "Person" property-ref= "Idcard" ></one-to-one>.

　　Note: The Property-ref attribute in the one-to-one tag must be specified as the name of the relationship field.

Six, hibernate unidirectional one-to-many association mappings: let one end of the maintenance of relations, and many-to-one mapping principle is the same, are at the end of a number of a foreign key point to one end;

The difference is that the maintenance relationship differs:

• Many-to-one maintenance relationship: Multi-point-to-one relationship, if the maintenance of a multi-point-to-one relationship, then the loading of one end of a side will be loaded at the end of A;
• One-to-many maintenance relationship: a point-to-many relationship, if you maintain a point-many relationship, then load one end of the time will be loaded at the end of many.

For example, there are many students in a class.

1, Classes.java and Student.java each have two common attribute ID and name. Add a new attribute in classes: private Set students;

2, the mapping file modification: Classes.hbm.xml In addition to the normal attribute, add the set map:

　　

<set name= "Students" >    <key column= "Classesid" ></key>    <one-to-many class= " Com.juyahong.hibernate.Student "/></set>

Note 1: One end of the "I" maintains the relationship.

Note 2:session.save (student), Session.save (classes), saves student and classes objects. You can save the data successfully, but you need to issue an extra UPDATE statement to maintain the relationship.

Seven, hibernate two-way one-to-many association mappings: let the one end to maintain the relationship.

The main problem is solving a one-to-many-way association defect rather than demand-driven.

　　

1. Add the classes reference in the Student.java entity class. Private Classes Classes;

2, Student.hbm.xml Add many-to-one tag: <many-to-one name= "Classes" column= "Classesid"/>. Classes.hbm.xml in the example (vi) on the basis of the addition of the reverse attribute inverse (later will maintain the relationship of work to student), that is, one side does not exist foreign keys.

<set name= "Students" inverse= "true" >    <key column= "Classesid" ></key>    <one-to-many class= "Com.juyahong.hibernate.Student"/></set>

Note 1: Save the classes first, then save the student.

Note 2: A one-to-many bidirectional association mapping method:

• Using the key tag on one end of the collection allows you to add a foreign key to one end.
• Use Many-to-one labels on multiple end

Note 3:key labels are consistent with the fields that are added to the Many-to-one label, otherwise data clutter occurs.

Note 4: A one-to-many correlation mapping usually maintains a relationship on a multi-side, which invalidates a single end:

---Inverse reversal property use: Can be used in a one-to-many and many-to-many bidirectional association, the inverse property defaults to False, that is, the local side can maintain the relationship, if the inverse is true, that is to say that the side does not maintain the relationship, to the other end to maintain the relationship, the end of the failure. It is a reversal of the control direction and only affects the storage.

---Cascade is an operational chain reaction (temporarily known).

Eight, hibernate one-way many-to-many association mappings:

For example, the relationship between the student and the curriculum, the relationship between the user and the role is a many-to-many relationship.

　　

　　

　　

1, User.java and Role.java entity class all have two common attribute ID and name, add attribute in User.java, private Set roles;

2. Modify the User.hbm.xml mapping file: Map collection:

<set name= "Roles" table= "T_user_role" >    <key column= "user_id"/> <many-to-many class=        " Com.juyahong.hibernate.Role "column=" role_id "/>    </key></set>

Nine, hibernate bidirectional many-to-many association mappings:

1, add new set of private set users in Role.java;

2, on the basis of example eight, modify the Role.hbm.xml file

　　

<set name= "Users" table= "T_user_role" >    <key column= "role_id"/> <many-to-many class=        " Com.juyahong.hibernate.User "column=" user_id "/>    </key></set>

The above introduces seven kinds of mappings in hibernate (also including the mapping of the primary key and foreign key), in the learning of this piece is mainly able to understand the UML diagram, in these conditions, modify two files, a model class, there is a mapping file.

Transferred from: http://www.cnblogs.com/jyh317/p/3694844.html

The mapping relationship of hibernate learning