JPA-to-many, many-to-use

A, @ OneToOne relational mapping

JPA use @OneToOne to mark the one to one relationship.

Entity People: users.

Entity Address: home address.

People and Address is one to one relationship.

Here are described two ways JPA -one relationships.

One is through the foreign key (primary key of an entity associated with another entity through a foreign key);

Another is to hold one to one relationship between the two entities through an association table.

 

1, by way of a foreign key

people 表（id，name，sex，birthday，address_id）

address 表（id，phone，zipcode，address）

 

People.java

 

1. @Entity
2. public class People {
4.     @Id
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
6.     @Column(name = "id", nullable = false)
7.     private Long id;//id
9.     @Column(name = "name", nullable = true, length = 20)
10.     String name Private; // Name
12.     @Column(name = "sex", nullable = true, length = 1)
13.     String Sex Private; // Sex
15.     @Column(name = "birthday", nullable = true)
16.     Timestamp Birthday Private; // Date of Birth
18.     @OneToOne (Cascade = CascadeType.ALL) // People are maintenance side of the relationship, when deleting people, will cascade delete address
19.     @JoinColumn (name =  "address_id", the referencedColumnName =  "id") // people in address_id address field in the reference table id field
20.     Address address Private; // address
22. }

Entity's primary key is generally used for the associated foreign key. At this time, if the primary key as a foreign key do not want, you need to set referencedColumnName properties. Of course, here associated entity (Address) primary key id is used as a primary key, so referencedColumnName = where the first row 20 is  "id" may actually be omitted.

 

 

Address.java

 

1. @Entity
2. public class Address {
4.     @Id
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
6.     @Column(name = "id", nullable = false)
7.     private Long id;//id
9.     @Column(name = "phone", nullable = true, length = 11)
10.     String Phone Private; // phone
12.     @Column(name = "zipcode", nullable = true, length = 6)
13.     String zipcode Private; // zip code
15.     @Column(name = "address", nullable = true, length = 100)
16.     String address Private; // address
18.     // If you do not inquire People According Address cascade, can comment
19. //    @OneToOne(mappedBy = "address", cascade = {CascadeType.MERGE, CascadeType.REFRESH}, optional = false)
20. //    private People people;
21. }

 

2, to hold one to one relationship through the associated table.

people 表（id，name，sex，birthday）

address 表 (id，phone，zipcode，address）

people_address (people_id，address_id)

People only need to create two entities and Address

 

People.java

 

1. @Entity
2. public class People {
4.     @Id
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
6.     @Column(name = "id", nullable = false)
7.     private Long id;//id
9.     @Column(name = "name", nullable = true, length = 20)
10.     String name Private; // Name
12.     @Column(name = "sex", nullable = true, length = 1)
13.     String Sex Private; // Sex
15.     @Column(name = "birthday", nullable = true)
16.     Timestamp Birthday Private; // Date of Birth
18.     @OneToOne (Cascade = CascadeType.ALL) // People are maintenance side of the relationship
19.     @JoinTable(name = "people_address",
20.             joinColumns = @JoinColumn(name="people_id"),
21.             = inverseJoinColumns  @JoinColumn (name =  "address_id")) // save the relationship by one to one association table
22.     Address address Private; // address
24. }

 

Address.java

constant

 

Two, @ OneToMany and @ManyToOne

Entity Author: Author.

Entities Article: article.

Author and Article are many relationship (two-way). Then the JPA , the bidirectional association represents how many do?

JPA use @OneToMany and @ManyToOne to identify many of the bidirectional association. One end (the Author) using @OneToMany, multiterminal (Article This article was) used @ManyToOne.

In the JPA specification, two-way-to-many relationship is maintained by many-fold (Article). That is many-fold (Article) for the maintenance of the relationship end, responsible for relations CRUD. One end (the Author) was end relationship is maintained, the relationship can not be maintained.

One end (Author) @OneToMany annotated using mappedBy = "author" attribute indicates that the relationship is maintained Author end.

Multiport (Article) @JoinColumn and annotated using @ManyToOne properties author, @ ManyToOne Article show a multiport, @ JoinColumn set associated field (foreign key) in the article table.

 

Author.java

 

1. @Entity
2. public class Author {
4.     @Id  // primary key
5.     @GeneratedValue (at Strategy = GenerationType.IDENTITY)  // self-growth strategy
6.     private Long id; //id
8.     The @NotEmpty (the Message =  "Name can not be empty")
9.     @Size(min=2, max=20)
10.     @Column(nullable = false, length = 20)
11.     String name Private; // Name
13.     @OneToMany(mappedBy = "author",cascade=CascadeType.ALL,fetch=FetchType.LAZY)
14.     // cascading save, update, delete, refresh; lazy loading. When you delete a user, that user will cascade delete all articles
15.     Annotated entity classes // mappedBy have to end the relationship is maintained
16.      // mappedBy = "author" in author is author of properties Article
17.     List Private <Article This article was> articleList; // list of articles
20. }

 

Article.java

 

1. @Entity
2. public class Article {
5.     @Id
6.     @GeneratedValue (at Strategy = GenerationType.IDENTITY)  // self-growth strategy
7.     @Column(name = "id", nullable = false)
8.     private Long id;
10.     The @NotEmpty (the Message =  "Title can not be empty")
11.     @Size(min = 2, max = 50)
12.     The @Column (= Nullable  to false, length =  50)  // mapped to fields, values can not be empty
13.     private String title;
15.     @Lob   // large objects, mapping MySQL types of Long Text
16.     The @basic (FETCH = FetchType.LAZY)  // lazy loading
17.     The @NotEmpty (the Message =  "can not be empty")
18.     @Size(min = 2)
19.     The @Column (= Nullable  to false)  // mapped to fields, values can not be empty
20.     String Content Private; // text of the article content
23.     The @ManyToOne (Cascade CascadeType.MERGE = {,} CascadeType.REFRESH, = optional to false) // optional attribute optional = false, indicates author can not be empty. Delete posts, without affecting the user
24.     @JoinColumn (name = "the author_id") // article table provided in the associated field (foreign key)
25.     Author author Private; // belongs author
28. }

 

Finally generated table structure

article 表(id，title，conten，author_id)

author 表(id，name)

 

Third, many-@ManyToMany

Entity User: the user.

Entity Authority: authority.

Users and permissions are many relationship. A user can have multiple permissions, permission may also have a lot of users.

JPA is used to annotate @ManyToMany many relationship, maintained by an association table. The association table table name default: the main table name + underscore + from the table name. (Primary table refers to the relationship table corresponding to the end of the maintenance, from the table refers to the relationship table corresponding to the end of maintenance). This association table has only two foreign key field, pointing to the main table and the ID table ID. Name field defaults to: the main table name + underscore + primary key column names in the primary table, from the table name + underscore + from the primary key column names in the table.

 

It should be noted:

1, generally do not set many relationships cascading save, delete cascade, cascading updates and other operations.

2, you can specify one of the casual relationship maintenance for the end, in this example, I specify User to maintain relationships end, so as to generate the association table name: field user_authority, the associated table is: user_id and authority_id.

3, by binding many relationship relationship maintenance terminal to complete, i.e., to bind many relationship by User.setAuthorities (authorities). Relationship can not be maintained end binding relationship that Game is not binding relationship.

4, released by the many relationships end relationship maintenance is done, i.e. to release many relationship by Player.getGames (). Remove (game). Relationships are maintained end can not lift the relationship, that relationship can not be lifted Game.

5, and if the User Authority has been bound-many relationship, you can not delete Authority, the need to lift the relationship between the User, you can delete Authority. User can delete it directly, because the User is the relationship between the maintenance end, when you delete User, User will first lift the relationship and the Authority, and then delete Authority.

 

User.java

 

1. @Entity
2. public class User {
4.     @Id
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
6.     private Long id;
8.     The @NotEmpty (the Message =  "account can not be blank")
9.     @Size(min=3, max=20)
10.     @Column(nullable = false, length = 20, unique = true)
11.     String username Private;  // user account that uniquely identifies when the user logs on
13.     The @NotEmpty (the Message =  "password can not be blank")
14.     @Size(max=100)
15.     @Column(length = 100)
16.     private String password;  // When Password
18.     @ManyToMany
19.     @JoinTable(name = "user_authority",joinColumns = @JoinColumn(name = "user_id"),
20.     inverseJoinColumns = @JoinColumn(name = "authority_id"))
21.     // 1, relationship maintenance end, many relationships and is responsible for binding to lift
22.     // 2, @ JoinTable annotation name attribute specifies the name of the associated table, joinColumns specify the name of the foreign key, related to relationship maintenance terminal (User)
23.     // 3, inverseJoinColumns specify the name of the foreign key relationships are maintained to be associated end (Authority)
24.     // 4, in fact, can not use @JoinTable annotation, the default name generated based association table name + underscore + exemplar exemplar from the name,
25.     // table that is named user_authority
26.     // associated foreign key to the main table name: the name of the primary table underlined + + primary table primary key column names, i.e. user_id
27.     // linked to the foreign key table name: the name of the attribute for the associated primary table from + + underlined primary key column name of the table, i.e. authority_id
28.     // end of main table is maintained corresponding to the relationship table, the relationship is maintained from the end of the table corresponding to the table
29.     private List<Authority> authorityList;
31. }

Note: As stated in the comment, lines 20-21 @JoinTable above may be omitted, the default may be generated

 

Authority.java

 

1. @Entity
2. public class Authority {
4.     @Id
5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
6.     private Integer id;
8.     @Column(nullable = false)
9.     String name Private;  // name rights
11.     @ManyToMany(mappedBy = "authorityList")
12.     private List<User> userList;
14. }

 

Add test

 

1. @SpringBootTest
2. @RunWith(SpringRunner.class)
3. public class UserRepositoryTest {
6.     @Autowired
7.     private UserRepository userRepository;
9.     @Autowired
10.     private AuthorityRepository authorityRepository;
12.     @Test
13.     public void saveAuthority() {
14.         Authority authority = new Authority();
15.         authority.setId(1);
16.         authority.setName("ROLE_ADMIN");
17.         authorityRepository.save(authority);
18.     }
20.     @Test
21.     public void saveUser() {
22.         User user = new User();
23.         user.setUsername("admin");
24.         user.setPassword("123456");
25.         Authority authority = authorityRepository.findById(1).get();
26.         List<Authority> authorityList = new ArrayList<>();
27.         authorityList.add(authority);
28.         user.setAuthorList(authorityList);
29.         userRepository.save(user);
30.     }
32. }

Permission to run saveAuthority add a record,

Then add a user record saveUser run, at the same time, user_authority table automatically inserts a row

 

Delete test

delete users

 

1. @SpringBootTest
2. @RunWith(SpringRunner.class)
3. public class UserRepositoryTest {
6.     @Autowired
7.     private UserRepository userRepository;
9.     @Test
10.     public void deleteUser() {
11.         userRepository.deleteById(1L);
12.     }
14. }

user to delete a record in the table, while user_authority can cascade to delete a record

 

 

Reference: http: //www.cnblogs.com/luxh/archive/2012/05/30/2527123.html

 

 

Updated again

Which @OneToMany and @ManyToOne most used and would add here

 

About Cascade, we must note that in the end to maintain the relationship, that One end.

Such as author and article, the author is One, the article is the Many; articles and reviews, the article is One, comments are Many.

cascade = CascadeType.ALL One can only write in the end, only change Many One end of the end, are not allowed to alter Many One end side.

In particular deleted because ALL included in the update, delete.

If you delete a comment, just put the article deleted, and that the operator who. So, be careful when in use. One end must be used.

For example

One end

 

 

Many 端