Step 1: Create new maven project ‘hibernate-postgres-hello-world’.
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-postgres-hello-world</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>
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>javax.persistence-api</artifactId>
<version>2.2</version>
</dependency>
</dependencies>
</project>
Step 3: Define Employee class.
Employee.java
package com.sample.app.entity;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
@Entity
@Table(name = "employees")
public class Employee {
@Id
private int id;
private String firstName;
private String lastName;
private String designation;
private int age;
public Employee() {
}
public Employee(int id, String firstName, String lastName, String designation, int age) {
super();
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.designation = designation;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getDesignation() {
return designation;
}
public void setDesignation(String designation) {
this.designation = designation;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Entity class specifies that the class is an entity. Entity class follow java bean conventions.
a. @jakarta.persistence.Entity annotation is used to mark a class as an entity.
b. @jakarta.persistence.Table annotation explicitly specifies the table name
c. @jakarta.persistence.Id marks the property which defines the entity’s identifier.
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" />
</session-factory>
</hibernate-configuration>
hibernate.cfg.xml file defines the Hibernate configuration information.
a. The connection.driver_class, connection.url, connection.username and connection.password property elements define JDBC connection information. All the tutorials use Postgres database, so the values of these properties are all specific to running Postgres in your computer.
b. The dialect property specifies the particular SQL variant (org.hibernate.dialect.PostgreSQLDialect) with which Hibernate will work with.
c. The hbm2ddl.auto property enables automatic generation of database schemas like tables.
d. <mapping> element add persistent classes to the configuration.
Step 5: Define HelloWorld class.
HelloWorld.java
package com.sample.app;
import java.io.IOException;
import java.net.URISyntaxException;
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;
public class HelloWorld {
private static SessionFactory sessionFactory = buildSessionFactory();
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[]) throws ClassNotFoundException, IOException, URISyntaxException {
Employee emp1 = new Employee(1, "Krishna", "G", "Senior Software Developer", 26);
Employee emp2 = new Employee(2, "Shreyas", "Desai", "Team Manager", 35);
Employee emp3 = new Employee(3, "Piyush", "Rai", "Senior Software Developer", 26);
Employee emp4 = new Employee(4, "Maruti", "Borker", "Software Developer", 26);
Session session = sessionFactory.openSession();
session.beginTransaction();
session.persist(emp1);
session.persist(emp2);
session.persist(emp3);
session.persist(emp4);
session.getTransaction().commit();
session.close();
}
}
SessionFactory: It is a factory for org.hibernate.Session instances. Since creation of SessionFactory instance is a costly operation, Application should have only one instance of SessionFactory for a given database. SessionFactory maintain a secondary cache across all the session maintained by this.
Session: session represents the main runtime interface between a Java application and Hibernate. It is a single-threaded, short-lived object conceptually modeling a "Unit of Work". The primary purpose of the Session is to offer create, read, and delete operations for instances of mapped entity classes.
Total project structure looks like below.
Run HelloWorld application. You will see below messages in the console.
Aug 08, 2022 4:27:18 PM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate ORM core version 6.1.2.Final
Aug 08, 2022 4:27:18 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH10001002: Using built-in connection pool (not intended for production use)
Aug 08, 2022 4:27:18 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001005: Loaded JDBC driver class: org.postgresql.Driver
Aug 08, 2022 4:27:18 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001012: Connecting with JDBC URL [jdbc:postgresql://127.0.0.1:5432/test]
Aug 08, 2022 4:27:18 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001001: Connection properties: {password=****, user=postgres}
Aug 08, 2022 4:27:18 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001003: Autocommit mode: false
Aug 08, 2022 4:27:18 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl$PooledConnections <init>
INFO: HHH10001115: Connection pool size: 20 (min=1)
Aug 08, 2022 4:27:19 PM org.hibernate.engine.jdbc.dialect.internal.DialectFactoryImpl logSelectedDialect
INFO: HHH000400: Using dialect: org.hibernate.dialect.PostgreSQLDialect
Hibernate:
drop table if exists employees cascade
Aug 08, 2022 4:27:19 PM org.hibernate.resource.transaction.backend.jdbc.internal.DdlTransactionIsolatorNonJtaImpl getIsolatedConnection
INFO: HHH10001501: Connection obtained from JdbcConnectionAccess [org.hibernate.engine.jdbc.env.internal.JdbcEnvironmentInitiator$ConnectionProviderJdbcConnectionAccess@41dc0598] 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.
Aug 08, 2022 4:27:19 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: SQL Warning Code: 0, SQLState: 00000
Aug 08, 2022 4:27:19 PM org.hibernate.engine.jdbc.spi.SqlExceptionHelper$StandardWarningHandler logWarning
WARN: table "employees" does not exist, skipping
Hibernate:
create table employees (
id integer not null,
age integer not null,
designation varchar(255),
firstName varchar(255),
lastName varchar(255),
primary key (id)
)
Aug 08, 2022 4:27:19 PM org.hibernate.resource.transaction.backend.jdbc.internal.DdlTransactionIsolatorNonJtaImpl getIsolatedConnection
INFO: HHH10001501: Connection obtained from JdbcConnectionAccess [org.hibernate.engine.jdbc.env.internal.JdbcEnvironmentInitiator$ConnectionProviderJdbcConnectionAccess@3e4e4c1] 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.
Aug 08, 2022 4:27:19 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
employees
(age, designation, firstName, lastName, id)
values
(?, ?, ?, ?, ?)
Hibernate:
insert
into
employees
(age, designation, firstName, lastName, id)
values
(?, ?, ?, ?, ?)
Hibernate:
insert
into
employees
(age, designation, firstName, lastName, id)
values
(?, ?, ?, ?, ?)
Hibernate:
insert
into
employees
(age, designation, firstName, lastName, id)
values
(?, ?, ?, ?, ?)
Login to postgresql test database and query employees table to confirm the same.
test=# select * from employees; id | age | designation | firstname | lastname ----+-----+---------------------------+-----------+---------- 1 | 26 | Senior Software Developer | Krishna | G 2 | 35 | Team Manager | Shreyas | Desai 3 | 26 | Senior Software Developer | Piyush | Rai 4 | 26 | Software Developer | Maruti | Borker
You can download complete working application from this link.
No comments:
Post a Comment