java - ¿Qué es @JoinColumn y cómo se usa en Hibernate?

postgresql jpa

Question

He estado leyendo mucho sobre @JoinColumn pero todavía no entiendo la idea.

Tabla de pacientes

CREATE TABLE patient (
patient_id BIGINT NOT NULL,
first_name VARCHAR(255) NOT NULL,
last_name VARCHAR(255) NOT NULL,
PRIMARY KEY(patient_id));

Tabla de vehículos

CREATE TABLE vehicles (
patient_id BIGINT NOT NULL,
vehicle_id BIGINT NOT NULL,
vehicle_manufacturer VARCHAR(255),
PRIMARY KEY (vehicle_id),
CONSTRAINT patienthasmanyvehicle FOREIGN KEY(patient_id) REFERENCES patient(patient_id));

Clase de paciente

@OneToMany(mappedBy = "patient")
private Collection<Vehicle> patientVehicles = new ArrayList<Vehicle>();

Clase de vehículo

@ManyToOne
@JoinColumn(name="patient_id")
private Patient patient;

Estoy confundido sobre cómo parte la clase Vehículo, cuál es la relación entre

Vehicle Class ---- Entity
@JoinColumn(name="patient_id") ---- annotation
private Patient patient ----field

¿Eso dice? La entidad del vehículo tiene una clave externa para la entidad del paciente llamada patient_id . Agregue el ID_paciente como una columna en la tabla Entidad del vehículo

¿El parámetro de nombre de JoinColumn siempre debe ser una Clave externa o Clave primaria?

He estado leyendo esto pero todavía estoy confundido. JPA JoinColumn vs mappedBy

Answer 1

¿Por qué el patient_id (columna generada que es un FK) en la Tabla del vehículo no tiene ningún valor cuando ejecuto mi código?

Todo @JoinColumn hace @JoinColumn es especificar una columna para unirse a una asociación de entidad o colección de elementos. Como ha hecho que @JoinColumn asociado con el objeto de clase Paciente, es por eso que se crea una clave externa en la tabla Paciente.

Para obtener más información, consulte https://docs.jboss.org/hibernate/jpa/2.1/api/javax/persistence/JoinColumn.html

Answer 2

Clase de vehículo ---- Entidad @JoinColumn (name = "patient_id") ---- anotación privada Paciente paciente ---- campo

El código anterior generará una columna patient_id (una clave foránea) en la clase de Vehículo que apuntará a la clave primaria de la Clase de paciente.

MappedBy: este atributo nos dice que esta relación será administrada por la clase Vehicle. Ejemplo. Si insertamos un vehículo, se inyectarán dos SQL si el tipo de cascada es todo / guardar. 1st SQL inyectará detalles en la tabla del paciente y 2nd SQL inyectará detalles del vehículo en la tabla del vehículo con la columna patient_id de la columna Vehicle apuntando a la tupla del paciente insertada.

Answer 3

La columna de unión se declara con la anotación @JoinColumn que se parece a la anotación @Column. Tiene uno más parámetros llamados referencedColumnName. Este parámetro declara la columna en la entidad de destino que se usará para la unión.

En una relación bidireccional, uno de los lados (y solo uno) tiene que ser el propietario: el propietario es responsable de la actualización de la (s) columna (s) de asociación. Para declarar a un lado como no responsable de la relación, se utiliza el atributo mappedBy. mappedBy se refiere al nombre de propiedad de la asociación en el lado del propietario.

Aquí está el código de muestra:

EntityOne :
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "TEST_ID")
private EntityTwo entityTwo;
EntityTwo :
// bi-directional many-to-one association to EntityOne Here TEST_ID is the Primary key
@OneToMany(mappedBy = "entityTwo")
private List<EntityOne> entityOne;

Answer 4

Una asociación unidireccional a través de una tabla de unión

@Entity
class Patient {
@OneToMany
private Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
}
@Entity
class Vehicle {
}

Una asociación bidireccional a través de una tabla de unión.

@Entity
class Patient {
@OneToMany
private Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
}
@Entity
class Vehicle {
@ManyToOne(fetch = FetchType.LAZY)
private Patient patient;
}

Una asociación unidireccional a través de una clave externa

@Entity
class Patient {
@OneToMany
@JoinColumn
private Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
}
@Entity
class Vehicle {
}

Una asociación bidireccional a través de una clave externa

@Entity
class Patient {
@OneToMany(mappedBy = "patient")
private Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
}
@Entity
class Vehicle {
@ManyToOne(fetch = FetchType.LAZY)
private Patient patient;
}

Una asociación bidireccional a través de una clave foránea con una especificación de nombre de columna foránea

@Entity
class Patient {
@OneToMany(mappedBy = "patient")
private Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
}
@Entity
class Vehicle {
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name="patient_id")
private Patient patient;
}

Este es el punto de partida básico del uso de @JoinColumn .

Para verificar que la clave externa ( patient_id en la tabla del Vehicle ) esté realmente asignada en la tabla de pacientes, puede usar @JoinColumn(nullable = false)

@Entity
class Vehicle {
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name="patient_id", nullable = false)
private Patient patient
}