Java >> Java tutorial >  >> Tag >> hibernate

Dvale Mange Til Mange Tutorial

hibernate

Introduktion:

I dette selvstudium lærer vi at definere og bruge en mange-til-mange-entitetstilknytning ved hjælp af Hibernate @ManyToMany annotation.

Kontekstopbygning:

For at følge med i denne vejledning, lad os sige, at vi har to enheder - Medarbejder og Kvalifikation:

Som vi ved, kan én medarbejder flere kvalifikationer. Der kan også være N antal medarbejdere med en bestemt kvalifikation. Det betyder klart, at medarbejderen og Kvalifikation enheder deler et Mange-til-Mange-forhold .

Maven-afhængigheder:

Lad os i vores POM først sikre, at vi har de nødvendige afhængigheder:

<dependencies>
    ...
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.4.0.Final</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.13</version>
    </dependency>
    ...
</dependencies>

Vi kan altid finde ud af den seneste tilgængelige version på Maven Central. Vi bruger også MySQL database til denne øvelse.

Databaseopsætning:

At repræsentere en MangeTilMange forening, skal vi mindst bruge tre databasetabeller. Så lad os sige, at vi har nedenstående ERD-diagram, der repræsenterer vores database:

Lad os også oprette vores borde:

CREATE TABLE employee (
    emp_id INT(15) NOT NULL AUTO_INCREMENT,
    first_name VARCHAR(20) DEFAULT NULL,
    last_name  VARCHAR(20) DEFAULT NULL,
    PRIMARY KEY (emp_id)
);
 
CREATE TABLE qualification (
    qualification_id INT(15) NOT NULL AUTO_INCREMENT,
    title VARCHAR(20) DEFAULT NULL,
    PRIMARY KEY (qualification_id)
);
 
CREATE TABLE employee_qualification (
    emp_id INT(15) NOT NULL,
    qualification_id INT(15) NOT NULL,
    PRIMARY KEY (emp_id, qualification_id),
    CONSTRAINT employee_qualification_empIdFk 
      FOREIGN KEY (emp_id) REFERENCES employee(emp_id),
    CONSTRAINT employee_qualification_qualIdFk 
     FOREIGN KEY (qualification_id) REFERENCES qualification (qualification_id)
);

Oprettelse af enheder:

Nu hvor vi har vores databaseopsætning klar, lad os først oprette modelklassen – Medarbejder : 

@Entity
@Table(name = "Employee")
public class Employee { 
    // ...
  
    @ManyToMany(cascade = { CascadeType.ALL })
    @JoinTable(
        name = "Employee_Qualification", 
        joinColumns = { @JoinColumn(name = "emp_id") }, 
        inverseJoinColumns = { @JoinColumn(name = "qualification_id") }
    )
    Set<Qualification> qualifications = new HashSet<>();
    
    ...
}

En Mange-til-Mange forening har to sider – den ejende og den omvendte/henvisende side . Den faktiske fysiske tilknytning til databasen er angivet på ejersiden af ​​forholdet . Her, medarbejder er ejerenheden, og derfor har vi brugt @JoinTable annotation for at definere den faktiske fysiske databasekortlægning. @JoinTable annotation definerer vores employee_qualification deltage i tabellen .

@JoinColumn annotation angiver den kolonne, der skal bruges til at forbinde tabellerne. Vi har også nævnt det qualification_id ville være den omvendte sammenføjningskolonne. Det betyder simpelthen, at det refererer til den omvendte side af forholdet, som er vores Kvalifikation klasse.

Lad os nu definere vores Kvalifikation enhedsklasse:

@Entity
@Table(name = "Qualification")
public class Qualification {    
    // ...  
  
    @ManyToMany(mappedBy = "qualifications")
    private Set<Employee> employees = new HashSet<>();
     
    ...
}

Siden Kvalifikation klasse er referencen eller den omvendte side af associationen, har vi brugt mappedBy attribut for at henvise til dens ejerside (Medarbejder ).

Som vi kan se, har vi også brugt @ManyToMany annotering i begge vores enheder.

Brug af Many-To-Many Association:

I vores main() metode, kan vi teste ovenstående kortlægning:

//In our MainApp class
public static void main(String[] args) {
    Session session = null;    
    try {
        SessionFactory factory = new Configuration()
          .configure().buildSessionFactory();
        session = factory.openSession();
        Transaction tranx = session.beginTransaction();
 
        Employee james = new Employee(1001, "James", "Allen");
        Employee selena = new Employee(1002, "Selena", "Gomez");
        
        Set<Employee> employees = new HashSet<>();
        employees.add(james);
        employees.add(selena);
        
        Qualification masters = 
          new Qualification(8787, "Masters Degree");
        masters.setEmployees(employees);     
        
        session.save(masters);
        tranx.commit();
    } catch(Exception e) {
        e.printStackTrace();
    }
    finally {
        if(session != null)
            session.close();
    }
 
}

Ved udførelse af ovenstående kode ville vores testdata være blevet indsat i vores medarbejder , kvalifikation og employee_qualification borde.

Konklusion:

I denne mini-tutorial så vi på, hvordan man etablerer en ManyToMany JPA forening. Vi har brugt JPA-annoteringer over de almindelige gamle XML-konfigurationer, da de er mere bekvemme at bruge og bliver mere og mere populære.

Java tag