Hibernate application development example

This topic introduces how to build an application by using the Hibernate framework and OceanBase Database. It also covers the use of the application for fundamental database operations, including table creation, data insertion, data query, and other basic operations.

Click to download the java-oceanbase-hibernate sample project

Prerequisites

• You have installed OceanBase Database.
• You have installed JDK 1.8 and Maven.
• You have installed IntelliJ IDEA.

Procedure

1. Obtain the connection string of OceanBase Database.
2. Import the java-oceanbase-hibernate project into IntelliJ IDEA.
3. Modify the database connection information in the java-oceanbase-hibernate project.
4. Run the java-oceanbase-hibernate project.

Step 1: Obtain the connection string of OceanBase Database

1. Contact the deployment personnel or administrator of OceanBase Database to obtain the corresponding database connection string.

   obclient -hxx.xx.xx.xx -P2883 -uroot@sys#cluster -p**** -A
   

2. Fill in the corresponding information in the URL based on the deployed OceanBase Database.

   Note

   The URL is required in the hibernate.cfg.xml file.

   jdbc:oceanbase://host:port/schema_name?user=$user_name&password=$password
   

   Parameter description:

   • host: the IP address for connecting to OceanBase Database. For connection through ODP, use the IP address of an ODP. For direct connection, use the IP address of an OBServer node.
   • port: the port for connecting to OceanBase Database. For connection through ODP, the default value is 2883, which can be customized when ODP is deployed. For direct connection, the default value is 2881, which can be customized when OceanBase Database is deployed.
   • schema_name: the name of the schema to be accessed.
   • user_name: specified by the -u parameter. The format is user@tenant#cluster name or username@SERVICE:service name. If you use the user@tenant#cluster name format, the default tenant is sys, and the default administrator user is root. If you directly connect to OceanBase Database, you can omit the cluster name. If you use ODP, you must specify the cluster name.
   • password: the account password.

For more information about URL parameters, see Database URL.

Step 2: Import the java-oceanbase-hibernate project into IntelliJ IDEA

1. Open IntelliJ IDEA and choose File > Open....

   

2. In the Open File or Project window that appears, select the corresponding project file and click OK to import the project file.

3. IntelliJ IDEA automatically identifies various files in the project and displays the project structure, file list, module list, and dependency relationships in the Project tool window. The Project tool window is usually located on the left side of the IntelliJ IDEA interface and is open by default. If it is closed, you can click View > Tool Windows > Project in the menu bar or press the shortcut key Alt + 1 to reopen it.

   Note

   When you import a project using IntelliJ IDEA, it automatically detects the pom.xml file in the project, downloads the required dependency libraries based on the described dependencies in the file, and adds them to the project.

4. View the project.

Step 3: Modify the database connection information in the java-oceanbase-hibernate project

Modify the database connection information in the hibernate.cfg.xml file based on the information obtained in Step 1: Obtain the connection string of OceanBase Database.

Here is an example:

• The name of the database driver is: com.mysql.cj.jdbc.Driver.
• The IP address of the OBServer node is 172.30.xxx.xxx.
• The access port is 2881.
• The name of the schema to be accessed is test.
• The tenant account is root@mysql001. mysql001 is a MySQL user tenant created in OceanBase Database, and root is the username of the mysql001 tenant.
• The password is ******.

Sample code:

<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://172.30.xxx.xxx:2881/test</property>
<property name="hibernate.connection.username">root@mysql001</property>
<property name="hibernate.connection.password">******</property>

Step 4: Run the java-oceanbase-hibernate project

Running path

1. In the project structure, locate the TestHibernate.java file in src > test > java.
2. In the toolbar, choose Run(U) > Run > TestHibernate, or click the green triangle in the upper-right corner to run.
3. View the log information and output results in the IDEA console.

Running result

User{id=2, name='update'}
User{id=3, name='user_insert3'}
User{id=4, name='user_insert4'}
User{id=5, name='user_insert5'}

FAQ

1. Connection timeout

If you encounter a connection timeout, you can configure the connection timeout parameter in the JDBC URL:

jdbc:mysql://host:port/database?connectTimeout=30000&socketTimeout=60000

2. Character set issues

To ensure correct character encoding, set the appropriate character set parameter in the JDBC URL:

jdbc:mysql://host:port/database?characterEncoding=utf8&useUnicode=true

3. SSL connection

To enable an SSL connection to OceanBase Database, add the following parameter to the JDBC URL:

jdbc:mysql://host:port/database?useSSL=true&requireSSL=true

4. Special characters in username or password

If the username or password contains special characters (such as #), you need to URL-encode them:

String encodedPassword = URLEncoder.encode(password, "UTF-8");

Project code

Click java-oceanbase-hibernate to download the project code, which is a compressed package named java-oceanbase-hibernate.zip.

After decompressing it, you will find a folder named java-oceanbase-hibernate. The directory structure is as follows:

│--pom.xml
│
├─.idea
├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─oceanbase
│  │  │          ├─dao
│  │  │          │   └─--UserDao.java
│  │  │          │
│  │  │          └─pojo
│  │  │              └─--User.java
│  │  │
│  │  └─resources
│  │      │--hibernate.cfg.xml
│  │      │
│  │      └─com
│  │          └─oceanbase
│  │              └─pojo
│  │                  └─--User.hbm.xml
│  │
│  └─test
│      └─java
│          └─--TestHibernate.java
│
└─target

File description:

• pom.xml: the configuration file of the Maven project, which contains the dependencies, plugins, and build information of the project.
• .idea: the directory used by the integrated development environment (IDE) to store project-related configuration information.
• src: the directory where the source code of the project is stored.
• main: the directory where the main source code and resource files are stored.
• java: the directory where the Java source code is stored.
• com: the root directory where the Java packages are stored.
• oceanbase: the root directory where the project is stored.
• dao: the directory where the data access object (DAO) packages are stored. These packages are used to access the database or other data storage services.
• UserDao.java: the user data access object, which is used to perform operations such as adding, deleting, modifying, and querying user data.
• User.java: the user persistence object, which is used to map the fields of the user data table.
• pojo: the plain old Java object (POJO) that corresponds to the database table. It is used to map the database table or other data storage structures.
• resources: the directory where the resource files, such as configuration files and SQL files, are stored.
• hibernate.cfg.xml: the configuration file of Hibernate, which is used to configure the basic parameters and set the data source.
• User.hbm.xml: the mapping file of the user persistence object, which is used to define the mapping relationship between the user persistence object and the user data table.
• test: the directory where the test code and resource files are stored.
• TestHibernate.java: the Java class that stores the test code for Hibernate.
• target: the directory where the compiled Class files and Jar packages are stored.

Introduction to pom.xml

The content of the pom.xml configuration file is as follows:

1. Declaration statement.

   Declare this file to be an XML file that uses XML standard 1.0 and character encoding UTF-8.

   Sample code:

   <?xml version="1.0" encoding="UTF-8"?>
   

2. Configure the namespaces and the POM model version.

   1. Use xmlns to set the POM namespace to http://maven.apache.org/POM/4.0.0.
   2. Use xmlns:xsi to set the XML namespace to http://www.w3.org/2001/XMLSchema-instance.
   3. Use xsi:schemaLocation to set the POM namespace to http://maven.apache.org/POM/4.0.0, and the URI of the corresponding XSD file to http://maven.apache.org/xsd/maven-4.0.0.xsd.
   4. Use <modelVersion> to set the POM model version used by the POM file to 4.0.0.

   Sample code:

   <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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
   </project>
   

3. Configure basic information.

   1. Use <groupId> to specify the project identifier as com.oceanbase.
   2. Use <artifactId> to specify the project dependency as java-oceanbase-hibernate.
   3. Use <version> to specify the project version as 1.0-SNAPSHOT.

   Sample code:

    <groupId>com.oceanbase</groupId>
    <artifactId>java-oceanbase-hibernate</artifactId>
    <version>1.0-SNAPSHOT</version>
   

4. Use <build> to define the build process of the project.

   1. Use <plugins> to specify the plugins configured for the project.
   2. Use <plugin> to specify that the project is configured with one plugin.
   3. Use <groupId> to specify the project identifier as org.apache.maven.plugins.
   4. Use <artifactId> to specify the project dependency as maven-compiler-plugin.
   5. Use <configuration> to specify the parameters of the configured plugin.
   6. Use <source> to specify the source code version of the compiler as 8.
   7. Use <target> to specify the target code version of the compiler as 8.

   Sample code:

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
   

5. Use <dependencies> to define the components on which the project depends.

   1. Specify the group identifier of the dependency as com.oceanbase, the artifact name as oceanbase-client, and the version as 2.4.2.

      Sample code:

          <dependencies>
          <dependency>
              <groupId>com.oceanbase</groupId>
              <artifactId>oceanbase-client</artifactId>
              <version>2.4.2</version>
          </dependency>
          </dependencies>
      

   2. Specify the test architecture of the dependency as junit, the name as junit, and the version as 4.13.

      Sample code:

          <dependencies>
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.13</version>
          </dependency>
          </dependencies>
      

   3. Specify the architecture of the dependency as org.hibernate, the core library as hibernate-core, and the version as 5.2.17.Final.

      Sample code:

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

   4. Specify the architecture of the dependency as org.hibernate, the data source library as hibernate-c3p0, and the version as 5.2.17.Final.

      Sample code:

      <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.2.17.Final</version>
        </dependency>
      </dependencies>
      

Introduction to User.hbm.xml

The User.hbm.xml file is a Hibernate mapping file that maps a Java object to a database table.

The code in the User.hbm.xml file mainly consists of the following parts:

1. File declaration statement.

   This statement declares the file as an XML file using XML version 1.0 and character encoding UTF-8. It also specifies the DTD version and location of the Hibernate mapping file, setting the DTD document type to hibernate-mapping, the version to 3.0, the language to EN, and the URL of the file to http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd

   Sample code:

   <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE hibernate-mapping PUBLIC
           "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
           "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
   

2. Configure the mapping file.

   Define a Hibernate mapping file to map the User entity class to the test_hibernate_mysql database table.

   1. Use the package attribute to specify the Java package in the mapping file as com.oceanbase.pojo.
   2. Use the class tag to map data in the data table, specifying the Java class name as User with the name attribute and the database table name as test_hibernate_mysql with the table attribute.
   3. Use id to define the primary key attribute, specifying the member variable of the User Java class as id with the name attribute and the database field name as USER_ID with the column attribute.
   4. Use generator to define the primary key generation strategy, specifying the type of the primary key generator as sequence with the class attribute, the sequence name in the database as SQ_USER with the param element, the USER_NAME column in the database table with the name attribute, and the data type of the attribute as a string.

   Sample code:

   <hibernate-mapping package="com.oceanbase.pojo">
   <class name="User" table="test_hibernate_mysql">
       <!-- Configure primary key generation strategy -->
       <id name="id" column="USER_ID">
           <generator class="sequence">
               <param name="sequence">SQ_USER</param>
           </generator>
       </id>
       <!-- Configuration Tables and Properties -->
       <property name="name" column="USER_NAME" type="string"/>
   </class>
   </hibernate-mapping>
   

Introduction to hibernate.cfg.xml

The hibernate.cfg.xml file is a configuration file for Hibernate, used to configure the runtime environment and database connection parameters for Hibernate.

The code in the hibernate.cfg.xml file mainly includes the following parts:

1. Declaration statement.

   This statement declares the file as an XML file using XML version 1.0 and character encoding UTF-8. It also specifies the DTD version and location for the Hibernate configuration file, setting the DTD document type to hibernate-configuration, version 3.0, language EN, and the URL to http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd.

   Sample code:

   <?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">
   

2. Configure the configuration parameter.

   In the root element, the element is used to set up the Hibernate session factory, which is responsible for creating and managing session objects. The session factory includes configurations for the database driver class name, URL, username, and password, connection pool parameters, database dialect, SQL output and formatting, automatic creation of database tables, current session context, batch processing, and second-level caching.

   1. Configure database information.

      This section configures the parameters for connecting Hibernate to the database, including the driver class name, URL, username, and password for the database connection.

      • Use hibernate.connection.driver_class to specify the database driver as com.mysql.cj.jdbc.Driver for connecting to OceanBase Database.
      • Use hibernate.connection.url to specify the database URL, which includes the database address, port number, and database name.
      • Use hibernate.connection.username to specify the username for connecting to the database.
      • Use hibernate.connection.password to specify the password for connecting to the database.

      Sample code:

          <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
          <property name="hibernate.connection.url">jdbc:oceanbase://host:port/schema_name</property>
          <property name="hibernate.connection.username">user_name</property>
          <property name="hibernate.connection.password">******</property>
      

   2. Configure connection pool information.

      This section configures the connection pool parameters used by Hibernate. It specifies the connection pool as C3P0, with parameters including the maximum and minimum number of connections, timeout, maximum idle time, number of cached Statement objects, idle connection test time, number of connections acquired at once, and connection validation method.

      Note

      The following parameters are for reference only and do not represent a complete list of supported parameters. For more detailed parameter information, please refer to the relevant documentation.

      • Use hibernate.connection.provider_class to specify the connection pool as C3P0, used for managing the creation and release of database connections.
      • Use hibernate.c3p0.max_size to specify the maximum number of connections in the connection pool as 60.
      • Use hibernate.c3p0.min_size to specify the minimum number of connections in the connection pool as 30.
      • Use hibernate.c3p0.checkoutTimeout to specify the timeout for obtaining a connection in the connection pool as 30000 milliseconds.
      • Use hibernate.c3p0.timeout to specify the maximum idle time in the connection pool as 2000 milliseconds; connections exceeding this time will be closed.
      • Use hibernate.c3p0.max_statements to specify the maximum number of cached SQL statements in the connection pool as 100.
      • Use hibernate.c3p0.idle_test_period to specify the idle connection detection period in the connection pool as 3000 milliseconds.
      • Use hibernate.c3p0.acquire_increment to specify the increment of connections when the connection pool dynamically expands as 3.
      • Use hibernate.c3p0.validate to specify the connection validation method as true.

      Sample code:

      <property name="hibernate.connection.provider_class">org.hibernate.c3p0.internal.C3P0ConnectionProvider</property>
      <property name="hibernate.c3p0.max_size">60</property>
      <property name="hibernate.c3p0.min_size">30</property>
      <property name="hibernate.c3p0.checkoutTimeout">30000</property>
      <property name="hibernate.c3p0.timeout">20000</property>
      <property name="hibernate.c3p0.max_statements">100</property>
      <property name="hibernate.c3p0.idle_test_period">3000</property>
      <property name="hibernate.c3p0.acquire_increment">3</property>
      <property name="hibernate.c3p0.validate">true</property>
      

   3. Configure SQL interaction information. This section configures the information for Hibernate to interact with the database, including the database dialect, SQL printing and formatting, automatic table creation, current session context, batch processing size, cache usage, and loading of mapping files.

      • Use dialect to specify the database dialect as MySQL 5.7, ensuring compatibility with the specific database.
      • Use hibernate.show_sql to set whether to print the SQL statements generated by Hibernate on the console.
      • Use hibernate.format_sql to set whether to format the printed SQL statements.
      • Use hbm2ddl.auto to set whether to automatically create tables.
      • Use current_session_context_class to specify the current session context at the thread level.
      • Use hibernate.jdbc.batch_size to set the batch processing size.
      • Use hibernate.cache.use_second_level_cache to set whether to enable second-level caching.
      • Specify the mapping file to be loaded as com/oceanbase/pojo/User.hbm.xml.

      Sample code:

        <property name="dialect">org.hibernate.dialect.MySQL57Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hbm2ddl.auto">create</property>
        <property name="current_session_context_class">thread</property>
        <property name="hibernate.jdbc.batch_size">10</property>
        <property name="hibernate.cache.use_second_level_cache">false</property>
        <mapping resource="com/oceanbase/pojo/User.hbm.xml"/>
      

Introduction to UserDao.java

The UserDao.java file uses a Session object to implement the operations of adding, deleting, modifying, and querying user data through the user data access object (DAO) class.

The UserDao.java file contains the following parts:

1. Import other classes and interfaces.

   Declare that the current file contains the following interfaces and classes:

   • User class: used to operate on user objects.
   • Session class: used to interact with the database.
   • SessionFactory class: used to create Session instances.
   • Transaction class: used to manage database transactions.
   • Configuration class: used to load the Hibernate configuration file.
   • Query class: used to execute query operations.
   • List interface: used to operate on query result sets.

   Sample code:

   import com.oceanbase.pojo.User;
   import org.hibernate.Session;
   import org.hibernate.SessionFactory;
   import org.hibernate.Transaction;
   import org.hibernate.cfg.Configuration;
   import org.hibernate.query.Query;
   import java.util.List;
   

2. Define the UserDao class.

The UserDao class is a data access object used to perform persistence operations on user objects. This class encapsulates a series of methods related to database interactions, enabling operations such as adding, deleting, modifying, and querying user objects. By calling the methods in the UserDao class, you can easily interact with the database to perform persistence operations.

1. Initialize the UserDao class instance.

   Use an object initialization block to initialize the Session object during the class instantiation process.

   First, create a Configuration object and call the configure method to read the Hibernate configuration file (hibernate.cfg.xml). Then, call the buildSessionFactory method to create a SessionFactory object. Finally, call the openSession method to create a Session object and assign it to the session variable.

   Sample code:

   private Session session;
   {
       Configuration cfg = new Configuration().configure();
       // Create SessionFactory
       SessionFactory sessionFactory = cfg.buildSessionFactory();
       session = sessionFactory.openSession();
   } //Read the hibernate.cfg.xml file
   

2. Set the user information corresponding to the specified ID.

   The selectUserById method queries the user information corresponding to the specified ID.

   Use the get method of the session object to obtain the User record corresponding to the specified ID from the database and store it in the user variable.

   Sample code:

   public User selectUserById(int ID) {
       User user = session.get(User.class, ID);
       return user;
   }
   

3. Retrieve user information based on the username.

   The selectUserbyName method queries the user information corresponding to the specified username. First, define a Hibernate Query Language (HQL) statement to query the user data with the specified name. The table name is test_hibernate_mysql, the table alias is u, and the query field name is name. Use the createQuery method of the Session object to create a Query object and pass the HQL statement and entity class as parameters. Use the setParameter method of the Query object to set the query parameters, where 0 indicates the parameter position and name indicates the parameter value. Use the list method of the Query object to execute the query and convert the query results to a list of User objects.

   Sample code:

   public List<User> selectUserbyName(String name) {
     String sql = "FROM test_hibernate_mysql u WHERE u.name =?";
     Query<User> query = session.createQuery(sql, User.class);
     query.setParameter(0, name);
     List<User> users = query.list();
     return users;
   }
   

4. Query all user data.

   The selectUser method implements a method to query all user data. Define an SQL statement to query all user data. Use the createNativeQuery method of the Session object to create a Query object and pass the SQL statement as a parameter. Then, use the addEntity method to add the User entity class to the query, so that the query results can be converted to a list of User objects. Use the getResultList method of the Query object to execute the query and convert the query results to a list of User objects.

   Sample code:

   public List<User> selectUser() {
       String sql = "SELECT * FROM test_hibernate_mysql";
       Query<User> query = session.createNativeQuery(sql).addEntity(User.class);
       List<User> users = query.getResultList();
       return users;
   }
   

5. Insert user data.

   The insertUser method inserts user information. Specify a User type parameter user to pass in the user object to be inserted. Call the beginTransaction method of the Hibernate Session to create a transaction object and save it in the beginTransaction variable. Use the save method to save the user object to the database. Call the getTransaction method of the Session object to obtain the current transaction and call the commit method to commit the transaction, persisting the previous operations to the database and returning the result of the insert operation.

   Sample code:

   public int insertUser(User user) {
       // open transaction
       Transaction beginTransaction = session.beginTransaction();
       session.save(user);
       session.getTransaction().commit();
       return 1;
   }
   

6. Delete user data.

   The deleteUserById method deletes the user record corresponding to the specified ID from the database. Specify an integer parameter id to pass in the ID of the user to be deleted. Call the beginTransaction method of the Hibernate Session to start a new transaction. Use the get method to obtain the corresponding user object based on the specified user ID and entity class type (User.class). Use the delete method to delete the user object. Call the getTransaction method of the Session object to obtain the current transaction and call the commit method to commit the transaction, persisting the user information to the database and returning the result of the delete operation.

   Sample code:

   public int deleteUserById(int id) {
       // open transaction
       session.beginTransaction();
       User user = session.get(User.class, id);
       session.delete(user);
       session.getTransaction().commit();
       return 1;
   }
   

7. Modify user data.

   The updateUserById method updates the corresponding user information. Specify a User type parameter user to specify the user data to be updated. Call the beginTransaction method of the Session object to start a transaction. Use the get method of the Session object to obtain the corresponding User object based on the user ID. Use the merge method of the Session object to merge the passed-in User object with the obtained User object, updating the passed-in user data to the database. Call the getTransaction method of the Session object to obtain the current transaction and call the commit method to commit the transaction, returning the result of the modify operation.

   Sample code:

   public int updateUserById(User user) {
       // open transaction
       session.beginTransaction();
       User user1 = session.get(User.class, user.getId());
       session.merge(user);
       session.getTransaction().commit();
       return 1;
   }
   

Introduction to User.java

The User.java file performs CRUD operations on user data through the Session object by using a Data Access Object (DAO) class.

The code in the User.java file is divided into the following sections:

1. Import other classes.

   Declare that the current file uses JPA annotations to configure the mapping between the related classes and the database table:

   • Column annotation: specifies the mapping between the attributes of the entity class and the columns of the database table.
   • Entity annotation: specifies the mapping between the database table and the entity class.
   • GeneratedValue annotation: specifies that the value of the attribute is automatically generated.
   • GenerationType annotation: specifies the primary key generation strategy.
   • Id annotation: specifies the unique identifier attribute.
   • Table annotation: specifies the name of the table corresponding to the entity class.

   Sample code:

   import javax.persistence.Column;
   import javax.persistence.Entity;
   import javax.persistence.GeneratedValue;
   import javax.persistence.GenerationType;
   import javax.persistence.Id;
   import javax.persistence.Table;
   

2. Map the database table.

   Map the database table to the entity class, and specify the table name of the entity class as test_hibernate_mysql.

   Sample code:

   @Entity
   @Table(name = "test_hibernate_mysql")
   

3. Define the User class.

   The User class is used to map the test_hibernate_mysql table in the database.

   1. Define two attributes, id and name. Use annotations to specify the mapping between the id and name attributes of the User class and the columns of the database table. Use the @Id annotation to specify the id attribute as the primary key. Use the @GeneratedValue annotation to specify the sequence generation strategy for the primary key. Use the @Column annotation to specify the mapping between the attributes and the columns of the database table. The id attribute stores the user ID, and the name attribute stores the username.

      Sample code:

      @Id
      @GeneratedValue(strategy = GenerationType.SEQUENCE)
      @Column(name = "user_id")
      private int id;
      
      @Column(name = "user_name")
      private String name;
      

   2. Creates a User object.

      Define two constructors for the User class to create a User object. Define an empty constructor for Hibernate query operations. Define a constructor with parameters to initialize the id and name attributes.

      Sample code:

      public User() {
      }
      
      public User(int id, String name) {
          this.id = id;
          this.name = name;
      }
      

   3. Gets and sets the id and name values.

      Define four methods in the User class to obtain and set the id and name attribute values. The getId method is used to obtain the id value. The setId method is used to set the id value. The getName method is used to obtain the username name value. The setName method is used to set the username name value.

      Sample code:

      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;
      }
      

   4. Return the string representation of the User object.

      Override the toString method in the User class to return the string representation of the User object. Define @Override to override the method with the same name in the parent class. Define the toString method to return the string representation of the User object. Concatenate strings to format the values of the id and name attributes into a string and return it to the caller User.

      Sample code:

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

Introduction to TestHibernate.java

The TestHibernate.java file demonstrates the basic database operations of Hibernate by performing insert, delete, update, and query operations on the UserDao object.

Perform the following steps to configure the TestHibernate.java file:

1. Import other classes and interfaces.

   Declare the classes and interfaces related to the current file, including UserDao, User, Session, SessionFactory, Configuration, etc.

   • UserDao class: used to perform database operations related to users.
   • User class: used to operate user objects.
   • Session class: used to perform session operations with the database.
   • SessionFactory class: used to create Session objects.
   • Configuration class: used to configure Hibernate.
   • SessionImpl class: used to obtain the underlying JDBC connection.
   • Test annotation: used to mark test methods.
   • IOException class: used to handle I/O exceptions.
   • Connection class: used to obtain a JDBC connection.
   • SQLException class: used to handle SQL exceptions.
   • List class: used to store the query result set.
   • UUID class: used to generate a unique identifier.

   Sample code:

   import com.oceanbase.dao.UserDao;
   import com.oceanbase.pojo.User;
   import org.hibernate.Session;
   import org.hibernate.SessionFactory;
   import org.hibernate.cfg.Configuration;
   import org.hibernate.internal.SessionImpl;
   import org.junit.Test;
   import java.io.IOException;
   import java.sql.Connection;
   import java.sql.SQLException;
   import java.util.List;
   import java.util.UUID;
   

2. Define the testHibernate method. The testHibernate method contains the basic operations of insert, delete, update, and query. Create a UserDao object, loop to insert five user records. Call the insertUser method to insert user data. Call the deleteUserById method to delete user data with the ID of 1. Call the updateUserById method to update user data with the ID of 2. Call the selectUser method to query all user data. Traverse the query results and print them to the console.

   Sample code:

   public class TestHibernate {
       @Test
       public void testHibernate() throws SQLException, IOException {
           UserDao userDao = new UserDao();
           for (int i = 1; i <= 5; i++) {
               userDao.insertUser(new User(i, "user_insert" + i));
           }
           int deleteUserById = userDao.deleteUserById(1);
           int update = userDao.updateUserById(new User(2, "update"));
           List<User> users = userDao.selectUser();
           users.forEach(System.out::println);
       }
   }
   

Complete code

<?xml version="1.0" encoding="UTF-8"?>
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.oceanbase</groupId>
    <artifactId>java-oceanbase-hibernate</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.27</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.17.Final</version>
        </dependency>
        <!-- Hibernate c3p0 connection pool-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.2.17.Final</version>
        </dependency>

    </dependencies>

</project>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.oceanbase.pojo">
    <class name="User" table="test_hibernate_mysql">
        <!-- Configure primary key generation strategy -->
        <id name="id" column="USER_ID">
            <generator class="sequence">
                <param name="sequence">SQ_USER</param>
            </generator>
        </id>
        <!-- Configuration Tables and Properties -->
        <property name="name" column="USER_NAME" type="string"/>
    </class>
</hibernate-mapping>

<?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>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://host:port/schema_name</property>
        <property name="hibernate.connection.username">user_name</property>
        <property name="hibernate.connection.password">******</property>
        <property name="hibernate.connection.provider_class">org.hibernate.c3p0.internal.C3P0ConnectionProvider</property>
        <property name="hibernate.c3p0.max_size">60</property>
        <property name="hibernate.c3p0.min_size">30</property>

        <property name="hibernate.c3p0.checkoutTimeout">30000</property>
        <property name="hibernate.c3p0.timeout">20000</property>

        <property name="hibernate.c3p0.max_statements">100</property>
        <property name="hibernate.c3p0.idle_test_period">3000</property>
        <property name="hibernate.c3p0.acquire_increment">3</property>
        <property name="hibernate.c3p0.validate">true</property>

        <property name="dialect">org.hibernate.dialect.MySQL57Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hbm2ddl.auto">create</property>
        <property name="current_session_context_class">thread</property>
        <property name="hibernate.jdbc.batch_size">10</property>
        <property name="hibernate.cache.use_second_level_cache">false</property>
        <mapping resource="com/oceanbase/pojo/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

package com.oceanbase.dao;

import com.oceanbase.pojo.User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;

import java.util.List;


public class UserDao {
    private Session session;
    {
        Configuration cfg = new Configuration().configure();
        // Create SessionFactory
        SessionFactory sessionFactory = cfg.buildSessionFactory();
        session = sessionFactory.openSession();
    } //Read the hibernate.cfg.xml file
//    private Session session = HibernateUtil.getSession();

    public User selectUserById(int ID) {
        User user = session.get(User.class, ID);
        return user;
    }

    public List<User> selectUserbyName(String name) {
        String sql = "FROM test_hibernate_mysql u WHERE u.name =?";
        Query<User> query = session.createQuery(sql, User.class);
        query.setParameter(0, name);
        List<User> users = query.list();
        return users;
    }

    public List<User> selectUser() {
        String sql = "SELECT * FROM test_hibernate_mysql";
        Query<User> query = session.createNativeQuery(sql).addEntity(User.class);
        List<User> users = query.getResultList();
        return users;
    }

    public int insertUser(User user) {
        // open transaction
        Transaction beginTransaction = session.beginTransaction();
        session.save(user);
        session.getTransaction().commit();
        return 1;
    }

    public int deleteUserById(int id) {
        // open transaction
        session.beginTransaction();
        User user = session.get(User.class, id);
        session.delete(user);
        session.getTransaction().commit();
        return 1;
    }

    public int updateUserById(User user) {
        // open transaction
        session.beginTransaction();
        User user1 = session.get(User.class, user.getId());
        session.merge(user);
        session.getTransaction().commit();
        return 1;
    }

}

package com.oceanbase.pojo;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;


@Entity
@Table(name = "test_hibernate_mysql")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    @Column(name = "user_id")
    private int id;

    @Column(name = "user_name")
    private String name;

    public User() {
    }

    public User(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;
    }

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

import com.oceanbase.dao.UserDao;
import com.oceanbase.pojo.User;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.internal.SessionImpl;
import org.junit.Test;

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.UUID;


public class TestHibernate {
    @Test
    public void testHibernate() throws SQLException, IOException {
        UserDao userDao = new UserDao();
        for (int i = 1; i <= 5; i++) {
            userDao.insertUser(new User(i, "user_insert" + i));
        }
        int deleteUserById = userDao.deleteUserById(1);
        int update = userDao.updateUserById(new User(2, "update"));
        List<User> users = userDao.selectUser();
        users.forEach(System.out::println);
    }
}

References

For more information about OceanBase Connector/J, see OceanBase Connector/J.