How do I write a simple JPQL query using Hibernate?

By Wayan in Hibernate 0 Comment

To write a simple JPQL (Java Persistence Query Language) query using Hibernate, follow these steps:

Example: Basic JPQL Query

For example, consider we have an entity: Employee

package org.kodejava.hibernate;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "employee")
public class Employee {
    @Id
    private Long id;
    private String name;
    private String department;
    private Double salary;

    // Getters and setters
}

1. Write the JPQL Query

A JPQL query allows you to query entities in an object-oriented way. For instance, fetching employees with a salary greater than 50000:

String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > :salary";

2. Using EntityManager to Execute the Query

You need to use the EntityManager to create and execute a JPQL query. Here is how you can do it:

package org.kodejava.hibernate;

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;
import jakarta.persistence.TypedQuery;
import java.util.List;

public class JPQLExample {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("persistence-unit-name");
        EntityManager em = emf.createEntityManager();

        try {
            em.getTransaction().begin();

            // JPQL query
            String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > :salary";

            // TypedQuery to avoid type casting
            TypedQuery<Employee> query = em.createQuery(jpqlQuery, Employee.class);
            query.setParameter("salary", 50000.0);

            // Executing the query and fetching the results
            List<Employee> employees = query.getResultList();

            // Display the result
            for (Employee employee : employees) {
                System.out.println("Employee: " + employee.getName() + ", Salary: " + employee.getSalary());
            }

            em.getTransaction().commit();
        } finally {
            em.close();
            emf.close();
        }
    }
}

Explanation of the Code

  1. JPQL Query:
    • "SELECT e FROM Employee e WHERE e.salary > :salary" is the JPQL query.
    • e is an alias for the entity. Employee
    • :salary is a named parameter.
  2. EntityManager:
    • The EntityManager is used to create queries and execute them.
    • The createQuery() method takes the JPQL query string and the result type.
  3. TypedQuery:
    • A TypedQuery is preferred for type safety and avoids casting the result.
  4. Parameter Binding:
    • setParameter() binds the value to the named parameter in the JPQL query.
  5. Fetching Results:
    • getResultList() fetches the results as a list of entities matching the query condition.

Additional Notes

  • JPQL uses the entity and its fields, not the database table or column names.
  • Make sure your is correctly configured with the persistence unit name. persistence.xml

This is how you write and execute a simple JPQL query with Hibernate.

How do I configure Hibernate with an H2 in-memory database?

By Wayan in Hibernate 0 Comment

Configuring Hibernate with an H2 in-memory database is quite straightforward. Below is a guide for configuring Hibernate with an H2 database in a Spring Boot or standalone Jakarta EE project.

Configuration for Hibernate with H2 in-memory database

1. Add Dependencies

Ensure you have the necessary dependencies in your project. For a Maven project, include the following in your pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

If you’re using Jakarta EE without Spring, you can directly include:

<!-- Hibernate ORM -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.4.4.Final</version>
</dependency>

<!-- H2 Database -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

2. Configure application.yml or application.properties (if using Spring Boot)

For application.properties:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

For application.yml:

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password: 
  jpa:
    database-platform: org.hibernate.dialect.H2Dialect
  h2:
    console:
      enabled: true

3. Standalone Hibernate Configuration (Non-Spring)

Create a hibernate.cfg.xml file in the resources folder:

<!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>
        <!-- JDBC Database connection settings -->
        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
        <property name="hibernate.connection.url">jdbc:h2:mem:testdb</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password"></property>

        <!-- Dialect -->
        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>

        <!-- Show SQL -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hibernate.hbm2ddl.auto">create-drop</property>
    </session-factory>
</hibernate-configuration>

4. Entity Classes

Define your Hibernate/JPA entity classes. An example:

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private int age;

    // Getters and Setters
}

5. H2 Console (Optional, Spring Boot only)

To access the H2 console for debugging, enable it as shown in the Spring configuration. By default, the H2 console will be available at `http://localhost:8080/h2-console`. You can login with:

  • JDBC URL: jdbc:h2:mem:testdb
  • Username: sa
  • Password: (leave it blank)

6. Configure EntityManagerFactory or SessionFactory (Standalone)

For standalone Hibernate usage, you can programmatically configure a SessionFactory. An example:

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static final SessionFactory sessionFactory;

    static {
        try {
            sessionFactory = new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

After completing these steps, you will have a working setup with Hibernate and an H2 in-memory database. You can now run your application, and the database schema will be automatically created and dropped upon application startup/shutdown.

How do I use SessionFactory and Session in Hibernate 6?

By Wayan in Hibernate 0 Comment

Hibernate ORM 6 introduces several changes to its API compared to previous versions, especially in how SessionFactory and Session are used due to compliance with Jakarta EE and its updated imports (jakarta.persistence.*).
Here’s a simple guide to using SessionFactory and Session in Hibernate 6:

1. Add Hibernate Dependencies

Make sure to include the Hibernate 6 dependencies in your project. If you’re using Maven, the dependency would look like this:

<dependency>
    <groupId>org.hibernate.orm</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>6.4.4.Final</version>
</dependency>

2. Configure Hibernate

Use or Properties for configuration:hibernate.cfg.xml

Example: hibernate.cfg.xml

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
        <property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
        <property name="hibernate.connection.url">jdbc:postgresql://localhost:5432/your_database</property>
        <property name="hibernate.connection.username">your_username</property>
        <property name="hibernate.connection.password">your_password</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>
</hibernate-configuration>

Alternatively, use Java configuration with Properties:

Properties properties = new Properties();
properties.put("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
properties.put("hibernate.connection.driver_class", "org.postgresql.Driver");
properties.put("hibernate.connection.url", "jdbc:postgresql://localhost:5432/your_database");
properties.put("hibernate.connection.username", "your_username");
properties.put("hibernate.connection.password", "your_password");
properties.put("hibernate.show_sql", "true");
properties.put("hibernate.hbm2ddl.auto", "update");

3. Create a SessionFactory

Starting with Hibernate 6, the SessionFactory should be built using the StandardServiceRegistryBuilder and MetadataSources.

Here’s an example:

Using hibernate.cfg.xml:

package org.kodejava.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;

public class HibernateUtil {

    private static SessionFactory sessionFactory;

    static {
        // Build the ServiceRegistry using hibernate.cfg.xml
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                .configure("hibernate.cfg.xml") // Loads hibernate.cfg.xml by default
                .build();

        try {
            // Build SessionFactory
            sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        } catch (Exception e) {
            StandardServiceRegistryBuilder.destroy(registry);
            throw new ExceptionInInitializerError("SessionFactory build failed: " + e.getMessage());
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void shutdown() {
        getSessionFactory().close();
    }
}

Using Java configuration with Properties:

package org.kodejava.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;

import java.util.Properties;

public class HibernateUtil {

    private static SessionFactory sessionFactory;

    static {
        // Create Hibernate properties
        Properties properties = new Properties();
        properties.put("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
        properties.put("hibernate.connection.driver_class", "org.postgresql.Driver");
        properties.put("hibernate.connection.url", "jdbc:postgresql://localhost:5432/your_database");
        properties.put("hibernate.connection.username", "your_username");
        properties.put("hibernate.connection.password", "your_password");
        properties.put("hibernate.show_sql", "true");
        properties.put("hibernate.hbm2ddl.auto", "update");

        // Build the ServiceRegistry
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                .applySettings(properties)
                .build();

        try {
            // Build SessionFactory
            sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        } catch (Exception e) {
            StandardServiceRegistryBuilder.destroy(registry);
            throw new ExceptionInInitializerError("SessionFactory build failed: " + e.getMessage());
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void shutdown() {
        getSessionFactory().close();
    }
}

4. Use SessionFactory to Get a Session

A Session represents a single unit of work with the database. In Hibernate 6, the usage involves a similar pattern to previous versions.

package org.kodejava.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

public class App {
    public static void main(String[] args) {
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

        // Obtain a session
        try (Session session = sessionFactory.openSession()) {
            // Begin transaction
            session.beginTransaction();

            // Perform operations (e.g., save entities)
            MyEntity entity = new MyEntity();
            entity.setName("Example");
            session.persist(entity);

            // Commit the transaction
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // Shutdown the session factory
            HibernateUtil.shutdown();
        }
    }
}

5. Entity Example

Ensure your entity classes are annotated correctly with Jakarta Persistence annotations (jakarta.persistence.*).

package org.kodejava.hibernate;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class MyEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Key Updates in Hibernate 6

  1. Jakarta Imports: Hibernate moved from javax.persistence.* to jakarta.persistence.*.
  2. Default Configuration: The APIs are adaptive, but the configuration process is largely unchanged.
  3. Session Persistence: The Session.persist(Object) method is preferred over deprecated methods like save(Object).

By following these steps, you can effectively use SessionFactory and Session in Hibernate 6 for your application.

How do I map a Java class to a database table using JPA annotations?

By Wayan in Hibernate, Java Persistence API 0 Comment

To map a Java class to a database table using JPA annotations, you primarily use annotations provided by jakarta.persistence. Here is a step-by-step guide:

Key annotations for mapping:

  1. @Entity
    Marks the class as an entity that is mapped to a table.
  2. @Table (optional)
    Specifies the table name in the database. If omitted, the default table name is the class name.
  3. @Id
    Marks a field as the primary key.
  4. @GeneratedValue (optional)
    Specifies how the primary key value is generated (e.g., AUTO, SEQUENCE).
  5. @Column (optional)
    Represents a column in the table, providing options to customize the name, length, nullable flag, etc.
  6. Additional mapping annotations for relationships:
    For relationships between tables (e.g., one-to-many, many-to-one, etc.), you can use @OneToMany, @ManyToOne, @OneToOne, and @ManyToMany.

Example: Mapping a simple class

Here’s an example of a Java class mapped to a database table using JPA annotations:

package com.example;

import jakarta.persistence.*;

@Entity
@Table(name = "students") // Optional; defaults to "Student"
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Auto-generate primary key
    private Long id;

    @Column(name = "full_name", nullable = false, length = 100)
    private String name;

    @Column(name = "email", unique = true, length = 150)
    private String email;

    @Column(name = "age", nullable = false)
    private int age;

    // Default constructor (needed by JPA)
    public Student() {
    }

    // Constructor with parameters and Getters/Setters
    public Student(String name, String email, int age) {
        this.name = name;
        this.email = email;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", age=" + age +
                '}';
    }
}

Explanation of the example:

  1. @Entity
    Declares the class as an entity tied to a database table.
  2. @Table(name = "students")
    Specifies the table name as students. If omitted, the table name would default to the class name Student.
  3. @Id and @GeneratedValue
    Defines a primary key and specifies how values are generated. Here, GenerationType.IDENTITY lets the database auto-increment the key.
  4. @Column(name = "full_name", nullable = false, length = 100)
    Maps the name property to the full_name column in the table, defines the column as non-nullable, and limits its length to 100 characters.
  5. @Column(name = "email", unique = true, length = 150)
    The email column is set to be unique, ensuring no duplicate email addresses.

Save and persist the entity:

The class can now be used with JPA to persist records in the database. For instance:

Student student = new Student("John Doe", "[email protected]", 25);

EntityManagerFactory emf = Persistence.createEntityManagerFactory("example-pu");
EntityManager em = emf.createEntityManager();

em.getTransaction().begin();
em.persist(student);  // Insert the record into the database
em.getTransaction().commit();

em.close();
emf.close();

Make sure to configure your file with your database connection details. persistence.xml

Maven Dependencies

<dependencies>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>6.4.4.Final</version>
    </dependency>
    <dependency>
        <groupId>jakarta.persistence</groupId>
        <artifactId>jakarta.persistence-api</artifactId>
        <version>3.1.0</version>
    </dependency>
</dependencies>

Maven Central Maven Central

How do I perform basic CRUD operations using Hibernate 6?

By Wayan in Hibernate 0 Comment

Basic CRUD operations with Hibernate 6 involve creating, reading, updating, and deleting records in a database using Hibernate ORM. Hibernate simplifies these operations through its API.

Below is an explanation of each CRUD operation along with corresponding examples:

1. Create (Insert)

To save a new object in the database, you use the persist() or save() method provided by Hibernate.

SessionFactory factory = new Configuration()
                .configure("hibernate.cfg.xml")
                .addAnnotatedClass(Student.class)
                .buildSessionFactory();

try (Session session = factory.openSession()) {
    // Create a new student entity
    Student student = new Student("Jane Doe");

    // Start a transaction
    session.beginTransaction();

    // Save the entity to the database
    session.persist(student);

    // Commit the transaction
    session.getTransaction().commit();

    System.out.println("Student saved successfully with ID: " + student.getId());
} finally {
    factory.close();
}

2. Read (Retrieve)

Hibernate’s get() or find() method is used to retrieve data from the database. You can fetch an object by its primary key.

try (Session session = factory.openSession()) {
    // Start a transaction (optional if only querying)
    session.beginTransaction();

    // Retrieve a student by their primary key (ID)
    int studentId = 1;  // Example ID
    Student retrievedStudent = session.get(Student.class, studentId);

    System.out.println("Retrieved Student: " + retrievedStudent);

    // Commit the transaction
    session.getTransaction().commit();
}

3. Update

To modify an existing object in the database, you first retrieve it, make changes to its fields, and then let Hibernate update it within a transaction.

try (Session session = factory.openSession()) {
    // Start a transaction
    session.beginTransaction();

    // Retrieve the student entity we want to update
    int studentId = 1;  // Example ID
    Student studentToUpdate = session.get(Student.class, studentId);

    // Modify the entity (e.g., update the name)
    if (studentToUpdate != null) {
        studentToUpdate.setName("Updated Name");
    }

    // Hibernate automatically tracks changes and applies them during commit
    session.getTransaction().commit();

    System.out.println("Student updated successfully.");
}

4. Delete

To delete an object, retrieve it first and use the delete() method to remove it from the database.

try (Session session = factory.openSession()) {
    // Start a transaction
    session.beginTransaction();

    // Retrieve the student to delete by their primary key
    int studentId = 1;
    Student studentToDelete = session.get(Student.class, studentId);

    // Delete the entity if it exists
    if (studentToDelete != null) {
        session.delete(studentToDelete);
        System.out.println("Student deleted successfully.");
    }

    // Commit the transaction
    session.getTransaction().commit();
}

Keynotes for Hibernate 6:

  1. Ensure you have the correct Hibernate dependencies in pom.xml (for Maven) or build.gradle (for Gradle).
  2. You must configure hibernate.cfg.xml, including database connection properties and mapping annotated classes.
  3. Always manage your Hibernate Session and SessionFactory carefully, and close them when done to free resources.
  4. Hibernate 6 has slight differences in config (e.g., Jakarta imports). Ensure you’re using the correct versions of annotations and configs (jakarta.persistence instead of javax.persistence).

For the provided code, it already demonstrates correct usage of creating a SessionFactory, opening a Session, performing a transaction for persist(), and closing resources. The same principles apply for all CRUD operations—use beginTransaction(), perform the operation, and commit() the transaction.

Maven Dependencies

<dependencies>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>6.4.4.Final</version>
    </dependency>
</dependencies>

Maven Central

How do I configure hibernate.cfg.xml for a simple application?

By Wayan in Hibernate 0 Comment

To configure hibernate.cfg.xml for a simple Hibernate application, you need to include the essential properties for Hibernate to interact with the database and map your entities.

Below is an example of hibernate.cfg.xml:

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>

        <!-- Database connection settings -->
        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
        <property name="hibernate.connection.url">jdbc:h2:mem:testdb</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password"></property>

        <!-- Hibernate dialect -->
        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>

        <!-- JDBC connection pool settings -->
        <property name="hibernate.c3p0.min_size">5</property>
        <property name="hibernate.c3p0.max_size">20</property>
        <property name="hibernate.c3p0.timeout">300</property>
        <property name="hibernate.c3p0.max_statements">50</property>
        <property name="hibernate.c3p0.idle_test_period">3000</property>

        <!-- Enable Hibernate's automatic table creation -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- Show SQL logs in the console -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>

        <!-- Add entity mappings -->
        <mapping class="org.kodejava.hibernate.Student"/>

    </session-factory>
</hibernate-configuration>

Explanation of the Configuration

  1. Database Connection Settings:
    • hibernate.connection.driver_class: Specifies the JDBC driver class (e.g., org.h2.Driver for an H2 database, com.mysql.cj.jdbc.Driver for MySQL, etc.).
    • hibernate.connection.url: JDBC URL to connect to your database.
    • hibernate.connection.username and hibernate.connection.password: Database credentials.
  2. Dialect:
    • hibernate.dialect: Hibernate’s SQL dialect for the specific database (e.g., H2Dialect, MySQLDialect, PostgreSQLDialect, etc.).
  3. Connection Pool:
    • Configures a simple C3P0 connection pool with properties like min_size, max_size, and timeout.
  4. Schema Management:
    • hibernate.hbm2ddl.auto:
      • create: Creates the schema, destroying any existing data.
      • update: Updates the schema, keeping existing data.
      • validate: Validates the schema without making changes.
      • none: Disables automatic schema management.
  5. SQL Output:
    • hibernate.show_sql: Logs executed SQL statements to the console.
    • hibernate.format_sql: Formats SQL logs for better readability.
  6. Entity Mapping:
    • <mapping class="org.kodejava.hibernate.Student"/>: Maps the Student entity to the database.

Using this Configuration

Place the hibernate.cfg.xml file in the src/main/resources directory (or in the root of your classpath). You can then use it to build a SessionFactory in your application:

SessionFactory factory = new Configuration()
        .configure("hibernate.cfg.xml")  // Load the config file
        .addAnnotatedClass(Student.class)  // Add annotated entity classes
        .buildSessionFactory();

This will allow Hibernate to connect to the database and manage your entities as per the configuration specified.

How do I create my first Hibernate entity using annotations?

By Wayan in Hibernate 0 Comment

To create a basic Hibernate entity using annotations, follow these steps:

1. Add Required Dependencies

Ensure you have added the required dependencies for Hibernate, JPA (jakarta.persistence), and any database (e.g., H2 for testing) in your pom.xml. For example:

<dependencies>
    <!-- Hibernate Core -->
    <dependency>
        <groupId>org.hibernate.orm</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>6.4.4.Final</version>
    </dependency>
    <!-- H2 Database -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <version>2.2.224</version>
        <scope>runtime</scope>
    </dependency>
    <!-- JPA API -->
    <dependency>
        <groupId>jakarta.persistence</groupId>
        <artifactId>jakarta.persistence-api</artifactId>
        <version>3.1.0</version>
    </dependency>
</dependencies>

2. Create an Entity Class

An entity class represents a table in the database and should be annotated with @Entity. For example:

package org.kodejava.hibernate;

import jakarta.persistence.*;

@Entity
@Table(name = "students")  // Maps to a table named 'students'
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // Auto-incremented primary key
    private Long id;

    @Column(name = "name", nullable = false)  // Maps field to a column
    private String name;

    // Default constructor
    public Student() {}

    // Constructor with arguments
    public Student(String name) {
        this.name = name;
    }

    // Getters and setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Explanation of Annotations

  1. @Entity: Marks the class as an entity that maps to a database table.
  2. @Table(name = "table_name"): Specifies the name of the database table (optional). If omitted, the table will use the class name.
  3. @Id: Marks the field as the primary key.
  4. @GeneratedValue(strategy = GenerationType.IDENTITY): Specifies auto-generation of primary key values.
  5. @Column(name = "column_name"): Maps a class field to a specific table column (optional). Omitting this will map the field name to a column with the same name.

3. Specify Entity in Hibernate Configuration

Ensure this entity is configured in your hibernate.cfg.xml file, or programmatically added when building the SessionFactory. In the XML file, include:

<mapping class="org.kodejava.hibernate.Student" />

4. Persist Data Using Hibernate

You can now use Hibernate to perform CRUD operations on this entity. For example, to save a Student:

package org.kodejava.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateApp {
    public static void main(String[] args) {
        // Create a SessionFactory and configure Hibernate
        SessionFactory factory = new Configuration()
                .configure("hibernate.cfg.xml")  // Load the configuration file
                .addAnnotatedClass(Student.class)  // Add annotated class
                .buildSessionFactory();

        // Open session
        try (Session session = factory.openSession()) {
            // Create a new student entity
            Student student = new Student("John Doe");

            // Start a transaction
            session.beginTransaction();

            // Save the student to the database
            session.persist(student);

            // Commit the transaction
            session.getTransaction().commit();

            System.out.println("Student saved successfully with ID: " + student.getId());
        } finally {
            factory.close();  // Close the factory
        }
    }
}

Summary

By using annotations like @Entity, @Table, @Id, and @Column, you can define the structure of your database table directly within the Java entity class. Hibernate simplifies interacting with the database and reduces the amount of boilerplate code involved.

How to Set Up JPOS in a Java Project for ISO 8583 Messaging

By Wayan in jPOS 0 Comment

Setting up JPOS in a Java project to handle ISO 8583 messaging involves configuring a robust library used for financial message processing. Here’s a step-by-step guide to integrate and configure JPOS in your Java project:

Step 1: Setup an ISO 8583 Configuration File

Create an ISO 8583 configuration file (e.g., iso8583.xml) in your project. This file is a mapper for the MTI and data elements. Example configuration:

<jposspace>
    <channel name="channel" class="org.jpos.iso.channel.ASCIIChannel">
        <property name="packager" class="org.jpos.iso.packager.ISO87APackager"/>
        <property name="host" value="127.0.0.1"/>
        <property name="port" value="8000"/>
    </channel>
</jposspace>
  • Use ISO87APackager for standard ISO 8583 (1987) message.
  • Replace the host and port values with appropriate server configurations.

Step 2: Initialize the ISO 8583 Packager

The Packager defines the structure of your ISO 8583 message. Below is an example of initializing an ISO87APackager programmatically:

package org.kodejava.jpos;

import org.jpos.iso.*;
import org.jpos.iso.packager.ISO87APackager;

public class ISO8583Example {
    public static void main(String[] args) {
        try {
            // Instantiate packager
            ISOPackager packager = new ISO87APackager();

            // Create a new ISOMessage
            ISOMsg isoMsg = new ISOMsg();
            isoMsg.setPackager(packager);

            // Set MTI (Message Type Identifier)
            isoMsg.setMTI("0200");

            // Set Data Elements
            isoMsg.set(3, "000000"); // Processing Code
            isoMsg.set(4, "100000"); // Transaction Amount
            isoMsg.set(7, "0605153023"); // Transmission Date & Time
            isoMsg.set(11, "123456"); // Systems Trace Audit Number
            isoMsg.set(41, "12345678"); // Card Acceptor Terminal ID

            // Pack and display message
            byte[] packedMessage = isoMsg.pack();
            System.out.println("Packed Message: " + ISOUtil.hexString(packedMessage));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Step 3: Set Up a Server Socket Listener (Optional)

To process incoming ISO 8583 messages, you will need to attach your channel to a ServerSocket. Here’s a basic example:

package org.kodejava.jpos;

import org.jpos.iso.ISOMsg;
import org.jpos.iso.channel.ASCIIChannel;
import org.jpos.iso.packager.ISO87APackager;
import org.jpos.iso.ISOServer;

public class ISO8583Server {
    public static void main(String[] args) {
        try {
            // Define packager
            ISO87APackager packager = new ISO87APackager();

            // Define ISOChannel
            ASCIIChannel channel = new ASCIIChannel("127.0.0.1", 8000, packager);

            // Set up a server
            ISOServer isoServer = new ISOServer(8000, channel, 50);

            // Attach simple request listener
            isoServer.addISORequestListener((source, m) -> {
                try {
                    // Print the received message
                    System.out.println("Received Message: " + m.toString());

                    // Create response
                    ISOMsg response = (ISOMsg) m.clone();
                    response.setMTI("0210");
                    response.set(39, "00"); // Response code (Success)
                    source.send(response);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                return true;
            });

            // Start server
            new Thread(isoServer).start();
            System.out.println("ISO 8583 Server is running...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Step 4: Understand and Expand Configuration

  • MTIs: Configure different MTI types for request and response (e.g., 0200, 0210).
  • Data Elements: Map fields per ISO 8583 standard or custom configurations (e.g., card number, transaction code, etc.).
  • Listeners: You can add comprehensive ISORequestListeners for different processing scenarios.

Step 5: Test the Setup

You can test the setup by creating a small client application to send messages to your server.

Here’s a basic ISO 8583 client:

package org.kodejava.jpos;

import org.jpos.iso.*;
import org.jpos.iso.channel.ASCIIChannel;
import org.jpos.iso.packager.ISO87APackager;

public class ISO8583Client {
    public static void main(String[] args) {
        try {
            // Define packager
            ISOPackager packager = new ISO87APackager();

            // Define channel (connect to server)
            ASCIIChannel channel = new ASCIIChannel("127.0.0.1", 8000, packager);
            channel.connect();

            // Create an ISO message
            ISOMsg isoMsg = new ISOMsg();
            isoMsg.setPackager(packager);
            isoMsg.setMTI("0200");
            isoMsg.set(3, "000000");
            isoMsg.set(4, "100000");
            isoMsg.set(11, "123456");
            isoMsg.set(41, "12345678");

            // Send a message
            channel.send(isoMsg);

            // Receive response
            ISOMsg response = channel.receive();
            System.out.println("Received Response: " + response.toString());

            // Disconnect
            channel.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Step 6: Debugging/Logging in jPOS

To debug and track requests/responses, configure logging in a log4j.properties file:

log4j.rootLogger=DEBUG, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ISO8601} %-5p [%t] %c{1}:%L - %m%n

Place this configuration in your project’s resources or classpath.

Additional Notes

  1. Documentation: Refer to the official jPOS documentation for advanced usages like persistent queues, transactional processing, etc.
  2. Debugging Tools: Use tools like tcpdump or Wireshark to capture and debug ISO 8583 messages on the network.

This guide gives you a foundational setup for working with jPOS and ISO 8583 messaging. You can build upon this for complex financial applications.

Maven Dependency

<dependency>
    <groupId>org.jpos</groupId>
    <artifactId>jpos</artifactId>
    <version>3.0.0</version>
</dependency>

Maven Central

How do I use reified types with inline functions in Kotlin?

By Wayan in Kotlin 0 Comment

In Kotlin, reified types are used with inline functions to enable type information to be available at runtime. Normally, type parameters in generics are erased at runtime due to type erasure, but reified allows the type to remain available for reflective operations or type-specific logic.

Here are the key points to use reified types with inline functions:

  1. Mark the function as inline: The function must be an inline function for it to use reified types.
  2. Use the reified modifier: The generic type parameter must be marked as reified to prevent type erasure and keep the type information available at runtime.
  3. Call the function without explicitly passing the type: The compiler will infer the type automatically.

Here’s an example that demonstrates using reified types:

Example: Filtering a List Based on Type

inline fun <reified T> List<Any>.filterByType(): List<T> {
    return this.filter { it is T }.map { it as T }
}

fun main() {
    val mixedList: List<Any> = listOf(1, "Hello", 2.5, "World", 42)

    // Use the reified function to filter only Strings
    val strings: List<String> = mixedList.filterByType()
    println(strings) // Output: [Hello, World]

    // Use the reified function to filter only Integers
    val integers: List<Int> = mixedList.filterByType()
    println(integers) // Output: [1, 42]
}

Explanation:

  1. Inline Functions: Inline functions replace the function body at the call site, enabling the type information to persist after type erasure.
  2. Reified Modifier: When you use reified T, you can check the type (it is T) or even fetch its class (T::class) at runtime because the type information is preserved.
  3. Flexible Filtering: In the above example, the filter function dynamically determines the type of each element and includes the matching elements in the resulting list.

When to Use Reified Types

  • When you need access to the type at runtime (e.g., to perform type checking or reflection).
  • When working with generic functions that act differently based on the type parameter.

Note:

  • You can only use reified with inline functions.
  • Avoid overusing inline functions, as they can increase code size due to function duplication at each call site.

How do I apply tail recursion in Kotlin functions for performance optimization?

By Wayan in Kotlin 0 Comment

In Kotlin, you can use tail recursion to optimize recursive functions by preventing stack overflow and enabling a more optimized execution during runtime. A tail-recursive function is one where the recursive call is the last operation performed in the function.

To achieve this, Kotlin provides the tailrec modifier, which instructs the compiler to optimize the recursion into an iterative loop during compilation. This eliminates the need for additional stack frames, making the function more efficient.

Here’s how you can apply tail recursion in Kotlin:

Key Considerations

  1. Recursive Call as the Last Statement
    • The recursive call must be the last executable statement in the function for the tailrec modifier to work.
  2. No Further Computation After Recursive Call
    • If there are operations that need to be performed after the recursive call, the function cannot be optimized as tail-recursive.
  3. Using the tailrec Modifier
    • Explicitly annotate the function with tailrec to enable this optimization.

Example: Factorial Function Using Tail Recursion

Here’s an example of a factorial function using tail recursion:

fun main() {
    println(factorial(5))  // Output: 120
}

tailrec fun factorial(n: Int, acc: Int = 1): Int {
    return if (n == 0) acc else factorial(n - 1, acc * n)
}

Explanation:

  • The base case is when n == 0, where the accumulated value acc is returned.
  • The recursive call factorial(n - 1, acc * n) is performed as the last operation, making the function tail-recursive.
  • The tailrec modifier ensures that this recursive function is optimized into a loop during compilation.

Example: Fibonacci Function Using Tail Recursion

Here’s another example for calculating Fibonacci numbers:

fun main() {
    println(fibonacci(10))  // Output: 55
}

tailrec fun fibonacci(n: Int, a: Int = 0, b: Int = 1): Int {
    return if (n == 0) a else fibonacci(n - 1, b, a + b)
}

Explanation:

  • The base case is when n == 0, where a (the current Fibonacci number) is returned.
  • The recursive call fibonacci(n - 1, b, a + b) is the last operation in the function.

Benefits of Using Tail Recursion

  1. Avoid Stack Overflow: Tail recursion enables Kotlin to optimize recursion into loops, avoiding stack overflow for deep recursion.
  2. Improved Performance: Optimized tail-recursive functions execute more efficiently due to their iterative nature.

Limitations

  • Tail recursion cannot be applied if the recursive call is not the last operation in your function.
  • Functions with additional computations following the recursive call must be refactored if you want to make them tail-recursive.

Keynote

Not all recursive problems are tail-call optimizable. If your problem involves maintaining state across recursive calls where calculations depend on the return value of the recursive function, using a tail-recursive approach might not be feasible. In such cases, consider using iterative approaches or data structures like stacks.