Using @joinTable annotation, we can customize the join table name and join column names.
Example
@Entity
@Table(name = "employee")
public class Employee {
@Id
@Column(name = "employee_id")
private int id;
private String name;
@ManyToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE })
@JoinTable(
name = "employee_project_mapping",
joinColumns = @JoinColumn(name = "emp_id", referencedColumnName = "employee_id"),
inverseJoinColumns = @JoinColumn(name = "pjt_id", referencedColumnName = "project_id"))
private List<Project> projects = new ArrayList<>();
..........
..........
}
@Entity
@Table(name = "project")
public class Project {
@Id
@Column(name="project_id")
private int projectId;
private String projectName;
@ManyToMany(mappedBy = "projects")
private List<Employee> employees = new ArrayList<>();
...........
...........
}
Above snippet generates following DDL definitions.
create table employee (
employee_id integer not null,
name varchar(255),
primary key (employee_id)
)
create table employee_project_mapping (
emp_id integer not null,
pjt_id integer not null
)
create table project (
project_id integer not null,
projectName varchar(255),
primary key (project_id)
)
alter table if exists employee_project_mapping
add constraint FKo1qrdansu82fsocur172swkcq
foreign key (pjt_id)
references project
Hibernate:
alter table if exists employee_project_mapping
add constraint FK3p214rl2mniyl9e3qrg1klkm5
foreign key (emp_id)
references employee
Find the below working application.
Step 1: Create new maven project ‘hibernate-customize-join-table-name’.
Step 2: Update pom.xml with maven dependencies.
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.sample.app</groupId>
<artifactId>hibernate-customize-join-table-name</artifactId>
<version>1</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>15</java.version>
<maven.compiler.source>${java.version}</maven.compiler.source>
<maven.compiler.target>${java.version}</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>42.4.1</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>6.1.2.Final</version>
</dependency>
</dependencies>
</project>
Step 3: Define entity classes.
Project.java
package com.sample.app.entity;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.Table;
@Entity
@Table(name = "project")
public class Project {
@Id
@Column(name="project_id")
private int projectId;
private String projectName;
public Project() {
}
public Project(int projectId, String projectName) {
this.projectId = projectId;
this.projectName = projectName;
}
@ManyToMany(mappedBy = "projects")
private List<Employee> employees = new ArrayList<>();
public int getProjectId() {
return projectId;
}
public void setProjectId(int projectId) {
this.projectId = projectId;
}
public String getProjectName() {
return projectName;
}
public void setProjectName(String projectName) {
this.projectName = projectName;
}
public List<Employee> getEmployees() {
return employees;
}
public void setEmployees(List<Employee> employees) {
this.employees = employees;
}
@Override
public int hashCode() {
return Objects.hash(projectId);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Project other = (Project) obj;
return projectId == other.projectId;
}
@Override
public String toString() {
return "Project [projectId=" + projectId + ", projectName=" + projectName + "]";
}
}
Employee.java
package com.sample.app.entity;
import java.util.ArrayList;
import java.util.List;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.JoinTable;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.Table;
@Entity
@Table(name = "employee")
public class Employee {
@Id
@Column(name = "employee_id")
private int id;
private String name;
@ManyToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE })
@JoinTable(
name = "employee_project_mapping",
joinColumns = @JoinColumn(name = "emp_id", referencedColumnName = "employee_id"),
inverseJoinColumns = @JoinColumn(name = "pjt_id", referencedColumnName = "project_id"))
private List<Project> projects = new ArrayList<>();
public Employee() {
}
public Employee(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Project> getProjects() {
return projects;
}
public void setProjects(List<Project> projects) {
this.projects = projects;
}
public void addProject(Project project) {
projects.add(project);
project.getEmployees().add(this);
}
public void removeProject(Project project) {
projects.remove(project);
project.getEmployees().remove(this);
}
@Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + "]";
}
}
Step 4: Create hibernate.cfg.xml file under src/main/resources folder.
hibernate.cfg.xml
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database Connection settings -->
<property name="connection.driver_class">org.postgresql.Driver</property>
<property name="connection.url">jdbc:postgresql://127.0.0.1:5432/test</property>
<property name="connection.username">postgres</property>
<property name="connection.password">postgres</property>
<!-- Enable the logging of all the generated SQL statements to the console -->
<property name="show_sql">true</property>
<!-- Format the generated SQL statement to make it more readable, -->
<property name="format_sql">true</property>
<!-- Hibernate will put comments inside all generated SQL statements to
hint what’s the generated SQL trying to do -->
<property name="use_sql_comments">false</property>
<!-- This property makes Hibernate generate the appropriate SQL for the
chosen database. -->
<property name="dialect">org.hibernate.dialect.PostgreSQLDialect</property>
<!-- Drop and re-create the database schema on startup -->
<property name="hbm2ddl.auto">create</property>
<!-- mappings for annotated classes -->
<mapping class="com.sample.app.entity.Employee" />
<mapping class="com.sample.app.entity.Project" />
</session-factory>
</hibernate-configuration>
Step 5: Define main application class.
App.java
package com.sample.app;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import com.sample.app.entity.Employee;
import com.sample.app.entity.Project;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
public class App {
private static SessionFactory sessionFactory = buildSessionFactory();
private static <T> List<T> loadAllData(Class<T> clazz, Session session) {
final CriteriaBuilder builder = session.getCriteriaBuilder();
final CriteriaQuery<T> criteria = builder.createQuery(clazz);
criteria.from(clazz);
return session.createQuery(criteria).getResultList();
}
private static SessionFactory buildSessionFactory() {
try {
if (sessionFactory == null) {
StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder()
.configure("hibernate.cfg.xml").build();
Metadata metaData = new MetadataSources(standardRegistry).getMetadataBuilder().build();
sessionFactory = metaData.getSessionFactoryBuilder().build();
}
return sessionFactory;
} catch (Throwable ex) {
throw new ExceptionInInitializerError(ex);
}
}
public static void main(String args[]) {
try (Session session = sessionFactory.openSession()) {
session.beginTransaction();
Employee emp = new Employee(1, "Krishna");
emp.addProject(new Project(11, "Chat server"));
emp.addProject(new Project(12, "Intelligent Sync"));
session.persist(emp);
session.flush();
session.getTransaction().commit();
List<Employee> employees = loadAllData(Employee.class, session);
for (Employee emp1 : employees) {
System.out.println(emp1);
List<Project> projects = emp.getProjects();
for(Project pjt: projects) {
System.out.println(pjt);
}
}
}
}
}
Total project structure looks like below.
Run App.java, you will see below messages in the console.
Sep 12, 2022 2:15:27 PM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate ORM core version 6.1.2.Final
Sep 12, 2022 2:15:27 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH10001002: Using built-in connection pool (not intended for production use)
Sep 12, 2022 2:15:27 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001005: Loaded JDBC driver class: org.postgresql.Driver
Sep 12, 2022 2:15:27 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001012: Connecting with JDBC URL [jdbc:postgresql://127.0.0.1:5432/test]
Sep 12, 2022 2:15:27 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001001: Connection properties: {password=****, user=postgres}
Sep 12, 2022 2:15:27 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001003: Autocommit mode: false
Sep 12, 2022 2:15:27 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl$PooledConnections <init>
INFO: HHH10001115: Connection pool size: 20 (min=1)
Sep 12, 2022 2:15:27 PM org.hibernate.engine.jdbc.dialect.internal.DialectFactoryImpl logSelectedDialect
INFO: HHH000400: Using dialect: org.hibernate.dialect.PostgreSQLDialect
Hibernate:
alter table if exists employee_project_mapping
drop constraint if exists FKo1qrdansu82fsocur172swkcq
Sep 12, 2022 2:15:28 PM org.hibernate.resource.transaction.backend.jdbc.internal.DdlTransactionIsolatorNonJtaImpl getIsolatedConnection
INFO: HHH10001501: Connection obtained from JdbcConnectionAccess [org.hibernate.engine.jdbc.env.internal.JdbcEnvironmentInitiator$ConnectionProviderJdbcConnectionAccess@2a334bac] for (non-JTA) DDL execution was not in auto-commit mode; the Connection 'local transaction' will be committed and the Connection will be set into auto-commit mode.
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: SQL Warning Code: 0, SQLState: 00000
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: relation "employee_project_mapping" does not exist, skipping
Hibernate:
alter table if exists employee_project_mapping
drop constraint if exists FK3p214rl2mniyl9e3qrg1klkm5
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: SQL Warning Code: 0, SQLState: 00000
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: relation "employee_project_mapping" does not exist, skipping
Hibernate:
drop table if exists employee cascade
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: SQL Warning Code: 0, SQLState: 00000
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: table "employee" does not exist, skipping
Hibernate:
drop table if exists employee_project_mapping cascade
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: SQL Warning Code: 0, SQLState: 00000
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: table "employee_project_mapping" does not exist, skipping
Hibernate:
drop table if exists project cascade
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: SQL Warning Code: 0, SQLState: 00000
Sep 12, 2022 2:15:28 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: table "project" does not exist, skipping
Hibernate:
create table employee (
employee_id integer not null,
name varchar(255),
primary key (employee_id)
)
Sep 12, 2022 2:15:28 PM org.hibernate.resource.transaction.backend.jdbc.internal.DdlTransactionIsolatorNonJtaImpl getIsolatedConnection
INFO: HHH10001501: Connection obtained from JdbcConnectionAccess [org.hibernate.engine.jdbc.env.internal.JdbcEnvironmentInitiator$ConnectionProviderJdbcConnectionAccess@47ac613b] for (non-JTA) DDL execution was not in auto-commit mode; the Connection 'local transaction' will be committed and the Connection will be set into auto-commit mode.
Hibernate:
create table employee_project_mapping (
emp_id integer not null,
pjt_id integer not null
)
Hibernate:
create table project (
project_id integer not null,
projectName varchar(255),
primary key (project_id)
)
Hibernate:
alter table if exists employee_project_mapping
add constraint FKo1qrdansu82fsocur172swkcq
foreign key (pjt_id)
references project
Hibernate:
alter table if exists employee_project_mapping
add constraint FK3p214rl2mniyl9e3qrg1klkm5
foreign key (emp_id)
references employee
Sep 12, 2022 2:15:28 PM org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
Hibernate:
insert
into
employee
(name, employee_id)
values
(?, ?)
Hibernate:
insert
into
project
(projectName, project_id)
values
(?, ?)
Hibernate:
insert
into
project
(projectName, project_id)
values
(?, ?)
Hibernate:
insert
into
employee_project_mapping
(emp_id, pjt_id)
values
(?, ?)
Hibernate:
insert
into
employee_project_mapping
(emp_id, pjt_id)
values
(?, ?)
Hibernate:
select
e1_0.employee_id,
e1_0.name
from
employee e1_0
Employee [id=1, name=Krishna]
Project [projectId=11, projectName=Chat server]
Project [projectId=12, projectName=Intelligent Sync]
Query the database to confirm DDL.
test=# \d+ employee;
Table "public.employee"
Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description
-------------+------------------------+-----------+----------+---------+----------+-------------+--------------+-------------
employee_id | integer | | not null | | plain | | |
name | character varying(255) | | | | extended | | |
Indexes:
"employee_pkey" PRIMARY KEY, btree (employee_id)
Referenced by:
TABLE "employee_project_mapping" CONSTRAINT "fk3p214rl2mniyl9e3qrg1klkm5" FOREIGN KEY (emp_id) REFERENCES employee(employee_id)
Access method: heap
test=#
test=#
test=#
test=# \d+ project;
Table "public.project"
Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description
-------------+------------------------+-----------+----------+---------+----------+-------------+--------------+-------------
project_id | integer | | not null | | plain | | |
projectname | character varying(255) | | | | extended | | |
Indexes:
"project_pkey" PRIMARY KEY, btree (project_id)
Referenced by:
TABLE "employee_project_mapping" CONSTRAINT "fko1qrdansu82fsocur172swkcq" FOREIGN KEY (pjt_id) REFERENCES project(project_id)
Access method: heap
test=#
test=#
test=#
test=# \d+ employee_project_mapping
Table "public.employee_project_mapping"
Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description
--------+---------+-----------+----------+---------+---------+-------------+--------------+-------------
emp_id | integer | | not null | | plain | | |
pjt_id | integer | | not null | | plain | | |
Foreign-key constraints:
"fk3p214rl2mniyl9e3qrg1klkm5" FOREIGN KEY (emp_id) REFERENCES employee(employee_id)
"fko1qrdansu82fsocur172swkcq" FOREIGN KEY (pjt_id) REFERENCES project(project_id)
Access method: heap
Query tables to confirm the data.
test=# SELECT * FROM employee;
employee_id | name
-------------+---------
1 | Krishna
(1 row)
test=#
test=#
test=# SELECT * FROM project;
project_id | projectname
------------+------------------
11 | Chat server
12 | Intelligent Sync
(2 rows)
test=#
test=#
test=# SELECT * FROM employee_project_mapping;
emp_id | pjt_id
--------+--------
1 | 11
1 | 12
(2 rows)
You can download this application from this link.
Previous Next Home
No comments:
Post a Comment