streamalism.org

1. Úvod

V tomto rýchlom návode sa rýchlo pozrieme na to, ako @ManyToMany na určenie tohto typu vzťahov v režime dlhodobého spánku je možné použiť anotáciu.

2. Typický príklad

Začnime jednoduchým diagramom vzťahov medzi entitami - ktorý zobrazuje asociáciu mnohých medzi dvoma entitami zamestnanec a projekt:

V tomto scenári akýkoľvek zamestnanec je možné priradiť k viacerým projektom a projekt môže pre ňu pracovať viac zamestnancov, čo vedie k spojeniu medzi mnohými.

Máme zamestnanec stôl s zamestnanecké ID ako jeho primárny kľúč a a projekt stôl s project_id ako jeho primárny kľúč. Spojovacia tabuľka zamestnanec_projekt je tu potrebné na spojenie oboch strán.

3. Nastavenie databázy

Predpokladajme, že máme už vytvorenú databázu s názvom spring_hibernate_many_to_many.

Musíme tiež vytvoriť zamestnanec a projekt stoly spolu s zamestnanec_projekt spojiť stôl s zamestnanecké ID a project_id ako cudzie kľúče:

CREATE TABLE `employee` (` employee_id` int (11) NOT NULL AUTO_INCREMENT, `first_name` varchar (50) DEFAULT NULL,` last_name` varchar (50) DEFAULT NULL, PRIMARY KEY (`employee_id`)) ENGINE = InnoDB AUTO_INCREMENT = 17 VÝCHOZÍ CHARSET = utf8; CREATE TABLE `project` (` project_id` int (11) NOT NULL AUTO_INCREMENT, `title` varchar (50) DEFAULT NULL, PRIMARY KEY (` project_id`)) ENGINE = InnoDB AUTO_INCREMENT = 18 DEFAULT CHARSET = utf8; CREATE TABLE `employee_project` (` employee_id` int (11) NOT NULL, `project_id` int (11) NOT NULL, PRIMARY KEY (` employee_id`, `project_id`), KEY` project_id` (`project_id`), CONSTRAINT` employee_project_ibfk_1` FOREIGN KEY (`employee_id`) REFERENCES` employee` (`employee_id`), CONSTRAINT` employee_project_ibfk_2` FOREIGN KEY (`project_id`) REFERENCES` project` (`project_id`)) ENGINE = InnoDB DEFAULT CHAR 

Po nastavení databázy bude ďalším krokom príprava závislostí Maven a konfigurácia režimu dlhodobého spánku. Informácie o tejto téme nájdete v článku Sprievodca režimom Hibernate4 s jarou

4. Modelové triedy

Modelové triedy Zamestnanec a Projekt je potrebné vytvoriť s anotáciami JPA:

@Entity @Table (name = "Employee") verejná trieda Employee {// ... @ManyToMany (cascade = {CascadeType.ALL}) @JoinTable (name = "Employee_Project", joinColumns = {@JoinColumn (name = "employee_id) ")}, inverseJoinColumns = {@JoinColumn (name =" project_id ")}) Nastaviť projekty = nový HashSet (); // štandardný konštruktor / getre / setre}

@Entity @Table (name = "Projekt") verejná trieda Projekt {// ... @ManyToMany (mappedBy = "projects") súkromná sada zamestnancov = nová HashSet (); // štandardné konštruktory / getre / setre}

Ako vidíme, obaja Zamestnanec triedy a Projekt triedy na seba odkazujú, čo znamená, že spojenie medzi nimi je obojsmerné.

Aby sme zmapovali asociáciu mnohých proti mnohým, používame @ManyToMany, @JoinTable a @JoinColumn anotácie. Pozrime sa na ne bližšie.

The @ManyToMany anotácia sa v obidvoch triedach používa na vytvorenie vzájomného vzťahu medzi entitami.

Toto združenie má dve strany, t.j. vlastniacu stranu a inverznú stranu. V našom príklade je vlastniaca strana Zamestnanec takže spojovacia tabuľka je špecifikovaná na strane, ktorá ju vlastní, pomocou @JoinTable anotácia v Zamestnanec trieda. The @JoinTable sa používa na definovanie tabuľky spojenia / odkazu. V takom prípade to je Zamestnanec_Projekt.

The @JoinColumn anotácia sa používa na určenie stĺpca spojenia / prepojenia s hlavnou tabuľkou. Tu je stĺpec spojenia zamestnanecké ID a project_id je stĺpec inverzného spojenia od Projekt je na opačnej strane vzťahu.

V Projekt triedy, mappedBy atribút sa používa v @ManyToMany anotácia označujúca, že zamestnancov zbierka je mapovaná projektov zbierka na strane vlastníka.

5. Exekúcia

Aby sme videli anotáciu typu many-to-many v akcii, môžeme napísať nasledujúci test JUnit:

verejná trieda HibernateManyToManyAnnotationMainIntegrationTest {private static SessionFactory sessionFactory; relácia súkromnej relácie; // ... @Test public void givenData_whenInsert_thenCreatesMtoMrelationship () {String [] employeeData = {"Peter Oven", "Allan Norman"}; Reťazec [] projectData = {"IT projekt", "Sieťový projekt"}; Nastaviť projekty = nový HashSet (); pre (String proj: projectData) {projects.add (nový Project (proj)); } for (String emp: employeeData) {Employee employee = new Employee (emp.split ("") [0], emp.split ("") [1]); assertEquals (0, employee.getProjects (). size ()); employee.setProjects (projects); session.persist (zamestnanec); assertNotNull (zamestnanec); }} @Test public void givenSession_whenRead_thenReturnsMtoMdata () {@SuppressWarnings ("nezaškrtnuté") List employeeList = session.createQuery ("FROM Employee") .list (); assertNotNull (employeeList); pre (Zamestnanec zamestnanec: employeeList) {assertNotNull (employee.getProjects ()); }} // ...}

Vidíme vzťah medzi mnohými medzi dvoma entitami vytvorenými v databáze: zamestnanec, projekta zamestnanec_projekt tabuľky so vzorovými údajmi predstavujúcimi vzťah.

6. Záver

V tomto tutoriáli sme videli, ako vytvoriť mapovania pomocou poznámok typu Hibernate typu many to many, čo je v porovnaní s vytváraním súborov mapovania XML pohodlnejší náprotivok.

Zdrojový kód tohto tutoriálu nájdete na GitHub.