Hibernate を使用して OceanBase Cloud クラウドデータベースに接続するサンプルプログラム

<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://t5******.********.oceanbase.cloud:3306/test</property>
<property name="hibernate.connection.username">mysql001</property>
<property name="hibernate.connection.password">******</property>

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

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

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

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

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

│--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

```java
<?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>
</project>

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

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

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

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

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

    <?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. マッピングファイルの設定。

Hibernate マッピングファイルを定義し、`User` という名前のエンティティクラスを `test_hibernate_mysql` という名前のデータベーステーブルにマッピングします。
1. `package` 属性を使用して、マッピングファイル内の Java パッケージを `com.oceanbase.pojo` に指定します。
2. `class` タグを使用してデータテーブル内のデータをマッピングし、`name` 属性で Java クラス名を `User` に、`table` 属性でデータベーステーブル名を `test_hibernate_mysql` に指定します。
3. `id` を使用して主キー属性を定義し、`name` 属性で Java クラス `User` のメンバ変数を `id` に、`column` 属性でデータベースフィールド名を `USER_ID` に指定します。
4. `generator` を使用して主キー生成戦略を定義し、`class` 属性で主キー生成器のタイプを `sequence` に、`param` 要素でデータベース内のシーケンス名を `SQ_USER` に指定し、`name` 属性でこの属性がデータベーステーブルの `USER_NAME` 列に対応することを指定し、この属性のデータ型を文字列に指定します。

**コードは以下の通りです：**

    ```xml
    <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>
    ```

### hibernate.cfg.xml コードの紹介

`hibernate.cfg.xml` ファイルは Hibernate の設定ファイルであり、Hibernate の実行環境やデータベース接続パラメータを設定するために使用されます。

`hibernate.cfg.xml` ファイルのコードは主に以下の部分で構成されています：

1. ファイル宣言文。

このファイルが XML ファイルであり、使用する XML バージョンが `1.0`、文字エンコーディングが `UTF-8` であることを宣言します。同時に、Hibernate 設定ファイルの DTD バージョンと場所を指定し、DTD ドキュメントタイプを `hibernate-configuration`、バージョンを 3.0、言語を EN、ファイルが存在する URL を `http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd` に指定します。

**コードは以下の通りです：**

```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
    ```

2. `configuration` パラメータの設定。

<hibernate-configuration> ルート要素内で <session-factory> 要素を使用して Hibernate のセッションファクトリを設定し、セッションオブジェクトの作成と管理に使用します。セッションファクトリには、データベース接続のドライバクラス名、URL、ユーザー名とパスワード、接続プールの関連パラメータ、データベースダイアレクト、SQL 出力とフォーマット、データベーステーブルの自動作成、現在のセッションコンテキスト、バッチ処理、二次キャッシュなどの設定が含まれます。

1. データベース情報の設定。

Hibernate とデータベース接続のパラメータを設定します。これには、データベース接続のドライバクラス名、URL、ユーザー名、パスワードが含まれます。

      * `hibernate.connection.driver_class` を使用してデータベースドライバを `com.mysql.cj.jdbc.Driver` に指定し、OceanBase Cloud との接続を確立するために使用します。
      * `hibernate.connection.url` 要素を使用してデータベースの URL を指定します。これには、データベースのアドレス、ポート番号、データベース名などの情報が含まれます。
      * `hibernate.connection.username` 要素を使用してデータベース接続のユーザー名を指定します。
      * `hibernate.connection.password` 要素を使用してデータベース接続のパスワードを指定します。

**コードは以下の通りです：**

```xml
          <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>

  * `hibernate.connection.provider_class` を使用して接続プールを C3P0 に指定し、データベース接続の作成と解放を管理するために使用します。
  * `hibernate.c3p0.max_size` を使用して接続プールの最大接続数を 60 に指定します。
  * `hibernate.c3p0.min_size` を使用して接続プールの最小接続数を 30 に指定します。
  * `hibernate.c3p0.checkoutTimeout` を使用して接続プールが接続を取得するタイムアウト時間を 30000 ミリ秒に指定します。
  * `hibernate.c3p0.timeout` を使用して接続プールの最大アイドル時間を 2000 ミリ秒に指定し、この時間を超えると閉じられます。
  * `hibernate.c3p0.max_statements` を使用して接続プールにキャッシュされる最大 SQL 文の数を 100 に指定します。
  * `hibernate.c3p0.idle_test_period` を使用して接続プール内のアイドル接続の検出周期を 3000 ミリ秒に指定します。
  * `hibernate.c3p0.acquire_increment` を使用して接続プールが動的に増加する際の接続数の増分を 3 に指定します。
  * `hibernate.c3p0.validate` を使用して接続プールの接続時の検証を true に指定します。

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

  ```xml
    <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"/>
  ```

* `User` クラス：ユーザーオブジェクトの操作に使用されます。
* `Session` クラス：データベースとの対話に使用されます。
* `SessionFactory` クラス：Session インスタンスの作成に使用されます。
* `Transaction` クラス：データベーストランザクションの管理に使用されます。
* `Configuration` クラス：Hibernate の設定ファイルの読み込みに使用されます。
* `Query` クラス：クエリ操作の実行に使用されます。
* `List` インターフェース：クエリ結果セットの操作に使用されます。

```java
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;
```

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

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

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

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

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

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

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

* `Column` アノテーション：エンティティクラスの属性とデータベーステーブルの列の対応関係を識別するために使用されます。
* `Entity` アノテーション：データベース内のテーブルをマッピングするために使用されます。
* `GeneratedValue` アノテーション：当該属性値が自動生成されることを示すために使用されます。
* `GenerationType` アノテーション：主キー生成戦略を指定するために使用されます。
* `Id` アノテーション：一意の識別属性を指定するために使用されます。
* `Table` アノテーション：エンティティクラスに対応するテーブル名を示すために使用されます。

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

```java
@Entity
@Table(name = "test_hibernate_mysql")
```

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

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

  ```java
  public User() {
  }

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

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

  ```java
  @Override
  public String toString() {
      return "User{" +

* `UserDao` クラス：ユーザーに関連するデータベース操作の実行に使用されます。
* `User` クラス：ユーザーオブジェクトの操作に使用されます。
* `Session` クラス：データベースとのセッション操作に使用されます。
* `SessionFactory` クラス：Session オブジェクトの作成に使用されます。
* `Configuration` クラス：Hibernate の設定に使用されます。
* `SessionImpl` クラス：基盤となる JDBC 接続の取得に使用されます。
* `Test` アノテーション：テストメソッドのマークに使用されます。
* `IOException` クラス：IO 例外の処理に使用されます。
* `Connection` クラス：JDBC 接続の取得に使用されます。
* `SQLException` クラス：SQL 例外の処理に使用されます。
* `List` クラス：クエリ結果セットの保存に使用されます。
* `UUID` クラス：一意の識別子の生成に使用されます。

```java
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;
```

```java
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);
        }
        }
```