Bedste praksis for mange til mange foreninger med Hibernate og JPA

mange til mange foreninger er en af de mest anvendte foreninger med JPA og Hibernate. Du kan finde masser af eksempler for dem i den virkelige verden, og du kan kortlægge dem med JPA og dvale som en uni – eller tovejs association i dit domæne model.

men du ved sikkert også, at disse kortlægninger giver flere faldgruber. I denne artikel vil jeg vise dig 5 bedste fremgangsmåder, der hjælper dig med at undgå disse faldgruber og implementere effektive kortlægninger. Du vil lære:

1. den mest effektive datatype til din tilknytning
2. hvorfor du har brug for hjælpemetoder til at administrere din tilknytning
3. den rigtige FetchType til en effektiv kortlægning
4. hvornår og hvordan du bruger forespørgselsspecifik hentning
5. Cascadetypen, du bør undgå for enhver pris

Jeg vil ikke dykke ned i detaljerne i en grundlæggende mange-til-mange kortlægning. Hvis du ikke er helt sikker på, hvordan du opretter en sådan kortlægning, kan du tage et kig på mange-til-mange afsnit i min forening kortlægning guide.

den mest effektive datatype til din forening

de fleste udviklere bruger ikke mange tanker om datatypen for en til-mange forening. De vælger bare en java.util.Liste, fordi det er simpelt og ikke udfører nogen kontrol for at undgå dubletter.

det er OK, hvis du implementerer en grundlæggende Java-klasse, eller hvis du modellerer en en-til-mange/mange-til-en-forening. Men du bør aldrig bruge en liste, hvis du modellerer en mange-til-mange forening.

@Entitypublic class Book {// DON'T DO THIS!!!@ManyToMany@JoinTable(name = "book_author", joinColumns = { @JoinColumn(name = "fk_book") }, inverseJoinColumns = { @JoinColumn(name = "fk_author") })private List<Author> authors = new ArrayList<Author>();...}

Hibernate håndtag fjern operationer på mange til mange relationer, der er kortlagt til en java.util.Liste meget ineffektivt.

em = emf.createEntityManager();em.getTransaction().begin();// Get Book entity with 2 Authorsb = em.find(Book.class, 1L);// Remove one of the Authorb.getAuthors().remove(a);em.getTransaction().commit();em.close();

det fjerner først alle poster fra tilknytningstabellen, før det indsætter alle resterende.

09:54:28,876 DEBUG - update Book set title=?, version=? where id=? and version=?09:54:28,878 DEBUG - delete from book_author where fk_book=?09:54:28,882 DEBUG - insert into book_author (fk_book, fk_author) values (?, ?)

Du skal i stedet modellere en mange-til-mange forening som java.util.Indstille.

@Entitypublic class Book {@ManyToMany@JoinTable(name = "book_author", joinColumns = { @JoinColumn(name = "fk_book") }, inverseJoinColumns = { @JoinColumn(name = "fk_author") })private Set<Author> authors = new HashSet<Author>();...}

Hibernate derefter håndterer fjerne operationer på foreningen meget bedre. Det fjerner nu kun de forventede poster fra foreningen og holder de andre uberørte.

10:00:37,709 DEBUG - update Book set title=?, version=? where id=? and version=?10:00:37,711 DEBUG - delete from book_author where fk_book=? and fk_author=?

hvorfor du har brug for hjælpemetoder til at styre din tilknytning

Tovejsassociationer er kortlagt til en enhedsattribut i begge ender af relationerne. Så i det foregående eksempel har du en forfatterattribut på Bogenheden og en bogattribut på Forfatterenheden. Det gør implementeringen af en JPKL eller Kriterieforespørgsel meget behagelig, fordi du kan bruge disse attributter til at definere en JOIN-klausul.

men at tilføje eller fjerne en forening bliver mere kompliceret. Du skal altid udføre ændringen i begge ender af foreningen. Hvis du f.eks. vil føje en bog til Forfatter, skal du føje den til attributten bøger for Forfatterenheden, og du skal også tilføje den forfatter, som forfatterne tilskriver på Bogenheden. Ellers indeholder din nuværende persistenskontekst inkonsekvente data, som du vil bruge indtil slutningen af din nuværende transaktion.

Book b = new Book();b.setTitle("Hibernate Tips - More than 70 solutions to common Hibernate problems");em.persist(b);Author a = em.find(Author.class, 1L);a.getBooks().add(b);b.getAuthors().add(a);

Utility metoder på din forfatter og bog enheder gør opdatering og fjernelse meget lettere. Inden for disse metoder udfører du de nødvendige operationer på begge enheder.

@Entitypublic class Author {@ManyToMany(mappedBy = "authors")private Set<Book> books = new HashSet<Book>();...public void addBook(Book book) {this.books.add(book);book.getAuthors().add(this);}public void removeBook(Book book) {this.books.remove(book);book.getAuthors().remove(this);}}

den rigtige FetchType til en effektiv kortlægning