SpringDataJPAでOceanBase Cloudに接続するサンプルプログラム

本記事では、SpringDataJPAフレームワークとOceanBase Cloudを使用して、テーブルの作成、データの挿入、クエリなどの基本的な操作を実現するアプリケーションの構築方法を紹介します。

クリックしてjava-oceanbase-springdatajpaサンプルプロジェクトをダウンロード

前提条件

• OceanBase Cloudデータベースアカウントに登録し、クラスタインスタンスとOceanBase CloudのOracleモードテナントを作成していること。詳細については、クラスタインスタンスの作成およびテナントの作成をご参照ください。
• JDK 1.8とMavenをインストール済みであること。
• IntelliJ IDEAをインストール済みであること。

操作手順

1. OceanBase Cloudの接続文字列を取得します。
2. java-oceanbase-springdatajpa プロジェクトをIDEAにインポートします。
3. java-oceanbase-springdatajpa プロジェクトのデータベース接続情報を変更します。
4. java-oceanbase-springdatajpa プロジェクトを実行します。

ステップ１：OceanBase Cloudの接続文字列を取得する

1. OceanBase Cloudコンソールにログインします。インスタンスリストページで、対象インスタンスの情報を展開し、対象テナントで、接続 > 接続文字列を取得 を選択します。

   詳細な操作については、接続文字列の取得をご参照ください。

2. 作成済みのOceanBase Cloudに基づいて、以下のURLの該当する情報を入力します。

   説明

   application.yml ファイルにこのURL情報が必要です。

   jdbc:oceanbase://host:port/schema_name?user=$user_name&password=$password&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
   

   パラメータ説明：

   • host：OceanBase Cloudの接続アドレスを提供します。例：t********.********.oceanbase.cloud。

   • port：OceanBase Cloudの接続ポートを提供します。デフォルトは1521です。

   • schema_name：アクセスするSchema名です。

   • user_name：データベースへのアクセスアカウントを提供します。

   • password：アカウントのパスワードを提供します。

   • characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8：追加の接続プロパティです。

     • characterEncoding：データベースURLオプションでサポートされている文字エンコーディングです。デフォルト値はutf8です。
     • useSSL：接続時にSSL/TLSを強制的に使用するかどうかを指定します。デフォルト値はfalseです。
     • serverTimezone：サーバーのタイムゾーンを設定します。デフォルト値は中国標準時です。

その他のURLパラメータの説明については、データベースURLをご参照ください。

ステップ2：java-oceanbase-springdatajpa プロジェクトをIDEAにインポートする

1. IntelliJ IDEA を開き、File > Open... オプションを選択します。

   

2. 表示された Open File or Project ウィンドウで、対応するプロジェクトファイルを選択し、OK をクリックしてプロジェクトファイルのインポートを完了します。

3. IntelliJ IDEAは、プロジェクト内のさまざまなファイルの種類を自動的に認識し、Projectツールウィンドウで、プロジェクトのディレクトリ構造、ファイルリスト、モジュールリスト、依存関係などの情報を確認できます。Projectツールウィンドウは通常、IntelliJ IDEA画面の左側にあり、デフォルトでは開いています。Projectツールウィンドウが閉じている場合は、メニューバーのView > Tool Windows > Projectをクリックするか、ショートカットキーAlt + 1を使用して再表示できます。

   説明

   IntelliJ IDEAでプロジェクトをインポートすると、IntelliJ IDEAはプロジェクト内のpom.xmlファイルを自動的に検出し、ファイルに記述された依存関係に基づいて必要な依存ライブラリを自動的にダウンロードし、それらをプロジェクトに追加します。

4. プロジェクトの状況を確認します。

   

ステップ3：java-oceanbase-springdatajpa プロジェクトのデータベース接続情報を修正する

ステップ1：OceanBase Cloudの接続文字列を取得する の情報に基づいて、application.yml ファイル内のデータベース接続情報を修正します。

例：

• データベースドライバーの名前：com.oceanbase.jdbc.Driver
• OceanBase Cloudの接続アドレスは t5******.********.oceanbase.cloud です。
• アクセスポートは1521を使用します。
• アクセスするスキーマ名は sys です。
• テナントの接続アカウントはoracle001です。
• パスワードは ****** です。

サンプルコードは以下のとおりです：

spring:
  datasource:
    driver-class-name: com.oceanbase.jdbc.Driver
    url: jdbc:oceanbase://t5******.********.oceanbase.cloud:1521/sys?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
    username: oracle001
    password:******
    type: com.alibaba.druid.pool.DruidDataSource

ステップ4：java-oceanbase-springdatajpa プロジェクトを実行する

実行パス

1. プロジェクト構造内の src > test > java から TestSpringDataJpaApplicationTests.java ファイルを見つけます。
2. ツールメニューバーで Run > Run... > TestSpringDataJpaApplicationTests.contextLoads を選択するか、右上の緑色の三角形を直接クリックして実行します。
3. IDEAのコンソールを使用して、プロジェクトのログ情報と出力結果を確認します。

実行結果

User{id=4, username='insert4'}
User{id=5, username='insert5'}
User{id=6, username='insert6'}
User{id=7, username='insert7'}
User{id=8, username='insert8'}

プロジェクトコードについて

java-oceanbase-springdatajpa をクリックしてプロジェクトコードをダウンロードします。これは java-oceanbase-springdatajpa という名前の圧縮ファイルです。

解凍すると、java-oceanbase-springdatajpa という名前のフォルダが作成されます。ディレクトリ構造は以下のとおりです：

│--pom.xml
│
├─.idea
│
├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─oceanbase
│  │  │          └─testspringdatajpa
│  │  │              │--TestSpringDataJpaApplication.java
│  │  │              │
│  │  │              ├─dao
│  │  │              │   └─UserRepository.java
│  │  │              │
│  │  │              ├─entity
│  │  │              │   └─User.java
│  │  │              │
│  │  │              └─service
│  │  │                  │--UserService.java
│  │  │                  │
│  │  │                  └─impl
│  │  │                      └─--UserServiceImpl.java
│  │  │
│  │  └─resources
│  │      │--application.yml
│  │      │
│  │      ├─static
│  │      └─templates
│  └─test
│      └─java
│          └─com
│              └─oceanbase
│                  └─testspringdatajpa
│                      └─--TestSpringDataJpaApplicationTests.java
│
└─target

ファイルの説明：

• pom.xml：Mavenプロジェクトの設定ファイルで、プロジェクトの依存関係、プラグイン、ビルドなどの情報が含まれます。
• .idea：IDE（統合開発環境）で使用されるディレクトリで、プロジェクト関連の設定情報を格納します。
• src：プロジェクトのソースコードを格納するディレクトリです。
• main: 主要なソースコードとリソースファイルを格納するディレクトリ。
• java: Javaソースコードを格納するディレクトリ。
• com: Javaパッケージのルートディレクトリ。
• oceanbase: プロジェクトのルートディレクトリ。
• testspringdatajpa：プロジェクトのすべてのJavaクラスを含むJavaパッケージのルートディレクトリ。
• TestSpringDataJpaApplication.java：Spring Bootアプリケーションのエントリクラス。
• dao: データアクセスオブジェクト（Data Access Object）パッケージを格納するディレクトリで、データベースやその他のデータストレージサービスへのアクセスに使用されます。
• UserRepository.java：ユーザーデータアクセスインターフェースで、ユーザーデータの追加、削除、変更、検索操作を定義します。
• entity：エンティティクラスのディレクトリで、データベーステーブルに対応するJavaクラスを格納します。
• User.java：ユーザー永続化オブジェクトで、ユーザーデータテーブルのフィールドをマッピングするために使用されます。
• service：サービスインターフェースのディレクトリで、業務ロジックインターフェースを定義するために使用されます。
• UserService.java：ユーザーサービスインターフェースで、ユーザーデータの操作メソッドを定義します。
• impl：サービス実装のディレクトリで、業務ロジックの実装クラスを格納します。
• UserServiceImpl.java：ユーザーサービスの実装クラスで、UserServiceインターフェースで定義されたメソッドを実装します。
• resources: リソースファイルを格納するディレクトリで、設定ファイルやSQLファイルなどが含まれます。
• application.yml：アプリケーションの設定ファイルで、データベース接続などの情報を設定するために使用されます。
• static：CSSやJavaScriptなどの静的ファイルを格納します。
• templates：HTMLテンプレートなどのテンプレートファイルを格納します。
• test: テストコードとリソースファイルを格納するディレクトリ。
• TestSpringDataJpaApplicationTests.java: Spring Data JPAに関連する機能の実行と検証に使用されるクラスを格納します。
• target: コンパイル済みのClassファイルやJarパッケージなどのファイルを格納するディレクトリ。

pom.xmlコードの紹介

pom.xml 設定ファイルの内容は以下のとおりです：

1. ファイル宣言ステートメント。

   このファイルがXMLファイルであり、使用しているXMLバージョンが 1.0、文字エンコーディング方式が UTF-8 であることを宣言します。

   コード：

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

2. POMの名前空間とPOMモデルバージョンの設定。

3. xmlns を使用して、POMの名前空間を http://maven.apache.org/POM/4.0.0 に指定します。

4. xmlns:xsi を使用して、XMLの名前空間を http://www.w3.org/2001/XMLSchema-instance に指定します。

5. xsi:schemaLocation を使用して、POMの名前空間を http://maven.apache.org/POM/4.0.0、POMのXSDファイルの場所を https://maven.apache.org/xsd/maven-4.0.0.xsd と指定します。

6. <modelVersion> 要素を使用して、このPOMファイルで使用するPOMモデルバージョンを 4.0.0 と指定します。

コード：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>

3. 親要素情報の設定。

4. <groupId> を使用して、親要素の識別子を org.springframework.boot と指定します。

5. <artifactId> を使用して、親要素の依存関係を spring-boot-starter-parent と指定します。

6. <version> を使用して、親要素のバージョン番号を 2.7.0 と指定します。

7. relativePath を使用して、親要素のパスが空であることを示します。

コード：

 <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.7.0</version>
     <relativePath/>
 </parent>

4. 基本情報の設定。

5. <groupId> を使用して、プロジェクト識別子を com.oceanbase と指定します。

6. <artifactId> を使用して、プロジェクトの識別子を java-oceanbase-springdatajpa と指定します。

7. <version> を使用して、プロジェクトのバージョン番号を 0.0.1-SNAPSHOT と指定します。

8. description を使用して、プロジェクト情報を Demo project for Spring Boot と紹介します。

コード：

 <groupId>com.oceanbase</groupId>
 <artifactId>java-oceanbase-springdatajpa</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>java-oceanbase-springdatajpa</name>
 <description>Demo project for Spring Boot</description>

5. Javaバージョンを設定します。

   プロジェクトで使用するJavaバージョンを1.8に指定します。

   コード：

     <properties>
         <java.version>1.8</java.version>
     </properties>
   

6. コア依存関係を設定します。

   1. 依存関係の所属組織をorg.springframework.boot、名前をspring-boot-starter-data-jpaに指定します。この依存ライブラリには、JPAを使用したデータアクセスに必要な依存関係と設定が含まれており、Spring Boot Starter Data JPAはSpring Bootのスターターです。

      コード：

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-jpa</artifactId>
      </dependency>
      

   2. 依存関係の所属組織をorg.springframework.boot、名前をspring-boot-starter-webに指定します。この依存ライブラリには、Spring Bootを使用したWeb開発に必要な依存関係と設定が含まれており、Spring Bootのスターターです。

      コード：

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      

   3. 依存関係の所属組織をorg.springframework.boot、名前をspring-boot-starter-test、作用範囲をtestに指定します。この依存関係により、JUnit、Mockito、Hamcrestなど、Spring Bootが提供するテストフレームワークとツールを使用できます。

      コード：

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
          <scope>test</scope>
      </dependency>
      

   4. 依存関係の所属組織をcom.alibaba、名前をdruid、バージョン番号を1.2.8に指定します。この依存関係により、Druidライブラリを使用して、データベース接続の取得と解放を管理・最適化できます。

      コード：

      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.2.8</version>
      </dependency>
      

   5. 依存関係の所属組織をcom.oceanbase、名前をoceanbase-client、バージョン番号を2.4.3に指定します。この依存関係により、OceanBaseが提供するクライアント機能（接続、クエリ、トランザクションなど）を使用できます。

      コード：

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

7. Mavenプラグインを設定します。

   依存関係の所属組織をorg.springframework.boot、名前をspring-boot-maven-pluginに指定します。このプラグインは、Spring Bootアプリケーションを実行可能なJARパッケージまたはWARパッケージにパッケージ化し、直接実行するために使用されます。他のプラグインやツールとの競合を避けるため、ビルドプロセスでLombok依存関係を追加します。

   コード：

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
   

application.ymlコードの紹介

application.yml ファイルは、Spring Bootアプリケーションの設定ファイルであり、いくつかの重要なパラメータが含まれています。アプリケーションのコンテキストパス、リスニングポート番号、データベース接続情報、およびJPA関連のプロパティを設定します。

application.yml ファイルのコードは、主に以下の部分で構成されています：

• Server 部分

  • servlet：Servlet関連のプロパティを設定するために使用されます。
  • context-path：アプリケーションのコンテキストパスを testspringdatajpa と指定します。
  • port：アプリケーションがリスニングするポート番号を8890と指定します。

  コード：

  server:
  servlet:
      context-path: /testspringdatajpa
  port: 8890
  

• Spring 部分

  • datasource：データソース関連のプロパティ、すなわちデータベース接続情報を設定するために使用されます。

    • driver-class-name：データベースドライバーのクラス名を com.oceanbase.jdbc.Driver と指定します。
    • url：データベースの接続URLを指定します。これには、データベースのアドレス、ポート番号、データベース名などの情報が含まれます。
    • username：データベースに接続するユーザー名を指定します。
    • password：データベースに接続するパスワードを指定します。
    • type：データソースとしてDruid接続プールを使用することを指定します。

    コード：

    spring:
    datasource:
        driver-class-name: com.oceanbase.jdbc.Driver
        url: jdbc:oceanbase://host:port/schema_name?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
        username: user_name
        password: ******
        type: com.alibaba.druid.pool.DruidDataSource
    

  • JPA 部分

    • hibernate：Hibernate関連のプロパティを設定するために使用されます。
      • ddl-auto：Hibernateが起動時にデータベース構造を自動更新するモードを update と指定します。
      • show-sql：コンソールにSQLステートメントを出力するかどうかを指定します。値は true です。
      • format-sql：出力されるSQLステートメントをフォーマットするかどうかを指定します。値は true です。
    • open-in-view：Open-in-View モードを有効にするかどうかを指定します。値は false です。

    コード：

    jpa:
        hibernate:
        ddl-auto: update
        show-sql: true
        format-sql: true
        open-in-view: false
    

userRepository.javaファイルの紹介

userRepository.java ファイルは、DAOインターフェースを通じて、ユーザーエンティティ（User）に対するデータベース操作メソッドを定義するために使用されます。SQLステートメントとHQLステートメントを使用したカスタムの更新およびクエリメソッドが含まれています。

userRepository.java ファイルのコードは、主に以下の部分で構成されています：

1. 他のクラスとインターフェースのインポート。

   このファイルには以下のインターフェースとクラスが含まれていることを宣言します：

   • User クラス：サービスクラスでユーザーオブジェクトを操作および処理するために使用されます。
   • JpaRepository インターフェース：このインターフェースを継承することで、基本的なCRUD操作メソッドを取得します。
   • Modifying アノテーション：変更操作を行うメソッドをマークするために使用されます。
   • Query アノテーション：カスタムクエリメソッドを定義するために使用されます。
   • Param アノテーション：メソッドパラメータをクエリステートメント内のパラメータにマッピングするために使用されます。
   • Repository アノテーション：DAOインターフェースをSpringのリポジトリコンポーネントとしてマークするために使用されます。

   コード：

   import com.oceanbase.testspringdatajpa.entity.User;
   import org.springframework.data.jpa.repository.JpaRepository;
   import org.springframework.data.jpa.repository.Modifying;
   import org.springframework.data.jpa.repository.Query;
   import org.springframework.data.repository.query.Param;
   import org.springframework.stereotype.Repository;
   

2. UserRepository インターフェースを定義します。

   UserRepository インターフェースは、ユーザーデータへのアクセスに使用されます。Springの Repository コンポーネントとしてマークされ、bean の名前は userRepository と指定されています。

   1. @Query アノテーションでSQLステートメントを指定し、nativeQuery = true を使用してネイティブSQLステートメントを実行します。
   2. @Modifying アノテーションを使用してカスタム更新メソッドを定義し、ネイティブSQLステートメントを使用して更新操作を行います。
   3. @Query アノテーションでHQL（Hibernate Query Language）ステートメントを指定し、@Param アノテーションを使用してメソッドパラメータをHQLステートメント内のパラメータにマッピングします。

   コード：

   @Repository("userRepository")
   public interface UserRepository extends JpaRepository<User, Integer> {
   
       @Query(value = "update test_springdatajpa_2 set username=?1 where id=?2", nativeQuery = true)
       @Modifying
       int updateById(String name, String id);
   
       @Query("SELECT u FROM User u WHERE u.username = :username")
       User findUser(@Param("username") String username);
   }
   

User.javaファイルの紹介

User.java ファイルは、ユーザーオブジェクトを表すUserクラスを定義します。

User.java ファイルのコードは、主に以下の部分で構成されています：

1. 他のクラスのインポート。 javax.persistence.*：javax.persistence パッケージ内のすべてのクラスをインポートするために使用されます。javax.persistence はJava Persistence API（JPA）の標準パッケージであり、オブジェクト関係マッピング（ORM）を行うための一連のインターフェースとアノテーションを提供します。

   コード：

   import javax.persistence.*;
   

2. User オブジェクトの定義。 JPAアノテーションを使用して、エンティティクラスとテーブルのマッピング関係を識別します。これには、テーブル名、主キー、フィールド名などが含まれます。 @Entity アノテーションを使用してこのクラスをエンティティクラスとしてマークし、@Table アノテーションで対応するデータベーステーブル名を指定します。@Id アノテーションでエンティティクラスの主キーをマークし、@GeneratedValue アノテーションで主キーの生成戦略を指定します。@Column アノテーションは、フィールド名と制約条件を指定するために使用されます。このクラスには id と username の2つのプロパティがあり、それぞれユーザーの一意の識別子とユーザー名を表します。また、空の User オブジェクトを作成するためのデフォルトコンストラクタも提供されています。

   コード：

   @Entity
   @Table(name = "test_springdatajpa_2")
   public class User {
       @Id
       @GeneratedValue(strategy = GenerationType.TABLE)
       @Column(name = "id", nullable = false)
       private Integer id;
   
       @Column(name = "username")
       private String username;
   
       public User() {
       }
   }
   

3. id と name の値の取得と設定。 このエンティティクラスには、パラメータ付きコンストラクタが提供されており、エンティティクラスオブジェクトを作成して id と username プロパティを初期化するために使用されます。 id と name プロパティの値を取得および設定するための4つのメソッドが定義されています。

   • getId メソッドは id 値を取得するために使用されます。
   • setId メソッドは id 値を設定するために使用されます。
   • getName メソッドは、ユーザー名 name の値を取得するために使用されます。
   • setName メソッドは、ユーザー名 name の値を設定するために使用されます。

   コード：

   
   public User(Integer id, String username) {
       this.id = id;
       this.username = username;
   }
   
   public Integer getId() {
       return id;
   }
   
   public void setId(Integer id) {
       this.id = id;
   }
   
   public String getUsername() {
       return username;
   }
   
   public void setUsername(String username) {
       this.username = username;
   }
   

4. User オブジェクトの文字列表現を返す。

   User クラスの toString メソッドをオーバーライドして、User オブジェクトの文字列表現を返すために使用します。 @Override を定義して、親クラスの同名メソッドをオーバーライドします。toString メソッドを定義して、User オブジェクトの文字列表現を返すために使用します。文字列連結を使用して、id と name プロパティの値を文字列としてフォーマットし、呼び出し元の User に返します。

   コード：

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

UserServiceImpl.javaファイルの紹介

UserServiceImpl.java ファイルは、JPAを使用してデータベースを操作し、ユーザーデータの追加、削除、変更、検索を行います。

UserServiceImpl.java ファイルのコードは、主に以下の部分で構成されています：

1. 他のクラスとインターフェースのインポート。

   このファイルには以下のインターフェースとクラスが含まれていることを宣言します：

   • UserRepository クラス：サービスクラスでデータアクセスオブジェクト（DAO）に定義されたメソッドを注入および呼び出すために使用されます。
   • User クラス：サービスクラスでユーザーオブジェクトを操作および処理するために使用されます。
   • UserService クラス：他のクラスでサービスクラスに定義されたメソッドを注入および呼び出すために使用されます。
   • Autowired アノテーション：依存オブジェクトの自動注入を行うために使用されます。
   • Page クラス：ページネーションクエリ結果をカプセル化するために使用されます。
   • PageRequest クラス：ページネーションリクエストオブジェクトを作成するために使用されます。
   • Pageable インターフェース：ページネーションリクエストを定義するためのインターフェースです。
   • Sort クラス：ソートルールを定義するために使用されます。
   • Service アノテーション：クラスをサービスクラスとしてマークするために使用されます。
   • Transactional アノテーション：トランザクションメソッドをマークするために使用されます。
   • Iterator クラス：コレクションを走査するために使用されます。
   • Optional クラス：NULLの可能性のあるオブジェクトを処理するために使用されます。

   コード：

   import com.oceanbase.testspringdatajpa.dao.UserRepository;
   import com.oceanbase.testspringdatajpa.entity.User;
   import com.oceanbase.testspringdatajpa.service.UserService;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.data.domain.Page;
   import org.springframework.data.domain.PageRequest;
   import org.springframework.data.domain.Pageable;
   import org.springframework.data.domain.Sort;
   import org.springframework.stereotype.Service;
   import org.springframework.transaction.annotation.Transactional;
   
   import java.util.Iterator;
   import java.util.Optional;
   

2. UserServiceImpl クラスは、UserService インターフェースで宣言されたメソッドを実装しています。

   UserRepository を依存注入することで、データベースへのアクセスを実現します。具体的には、ユーザーデータの挿入、削除、更新、およびクエリのメソッドを実装し、ページネーションクエリをサポートしています。@Transactional アノテーションを使用してトランザクションサポートを有効にし、データベース操作がトランザクション内で実行されることを保証します。

   1. UserRepository プロパティの構築。 プライベートな UserRepository プロパティを定義し、コンストラクタに @Autowired アノテーションを使用して依存注入を行います。コンストラクタで UserRepository 依存関係を注入し、userRepository プロパティを使用してユーザーデータにアクセスおよび操作します。

      コード：

      private final UserRepository userRepository;
      
      @Autowired
      public UserServiceImpl(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
      

   2. ユーザーデータの挿入。 insertUser メソッドは User オブジェクトをパラメータとして受け取り、UserRepository の save メソッドを呼び出して、ユーザーオブジェクトをデータベースに保存します。

      コード：

      @Override
      public void insertUser(User user) { userRepository.save(user); }
      

   3. ユーザーデータの削除。 deleteUser メソッドでは、UserRepository の existsById メソッドを呼び出して、指定されたIDのユーザーが存在するかどうかを判断します。存在する場合は削除操作を行い、存在しない場合はそのまま返します。

      コード：

      @Override
      public void deleteUser(Integer id) {
          if (!userRepository.existsById(id)) {
              return;
          }
      }
      

   4. ユーザーデータの更新。 updateUser メソッドでは、UserRepository の save メソッドを呼び出して、ユーザーオブジェクトをデータベースに保存し、更新操作を実装します。同時に、更新操作が成功したことを示す整数値 1 を返します。 また、ユーザー名と id に基づいてユーザーデータを更新するメソッドもあります。これは UserRepository の updateById メソッドを呼び出して更新操作を実装し、更新結果を返します。

      コード：

      @Override
      public int updateUser(User user) {
          userRepository.save(user);
          return 1;
      }
      
      //update based on name and id
      @Override
      public int updateUserById(String name, String id) {
          return userRepository.updateById(name, id);
      }
      

   5. ユーザーデータのクエリ。

      1. ID に基づいてユーザーデータをクエリします。 selectUserById メソッドでは、UserRepository の findById メソッドを呼び出してユーザーデータを取得し、結果を Optional オブジェクトに格納します。次に、Optional の orElse メソッドを呼び出して Optional オブジェクト内の値を取得し、それを user 変数に代入します。最後に、クエリしたユーザーオブジェクトを返します。
      2. ユーザー名に基づいてユーザーデータをクエリします。 selectUserByName メソッドでは、UserRepository の findUser メソッドを呼び出してユーザー名に基づいてユーザーデータをクエリし、クエリしたユーザーオブジェクトを直接返します。

      コード：

      @Override
      public User selectUserById(Integer id) {
          Optional<User> optional = userRepository.findById(id);
          User user = optional.orElse(null);
          return user;
      }
      @Override
      public User selectUserByName(String username) {
          return userRepository.findUser(username);
      }
      

   6. すべてのユーザーデータのページネーションクエリ。 selectUserAll メソッドでは、Sort オブジェクトを作成してソート規則を指定し、Pageable オブジェクトを作成してページネーションパラメータを指定します。その後、UserRepository の findAll メソッドを呼び出してユーザーデータをクエリし、Page オブジェクトを返します。さらに、Page オブジェクトの iterator メソッドを呼び出して、ユーザーデータのイテレーターを取得します。最後に、ユーザーデータのイテレーターを返します。

      コード：

      @Override
      public Iterator<User> selectUserAll(Integer pageNum, Integer pageSize) {
          Sort sort = Sort.by(Sort.Direction.ASC, "id");
          Pageable pageable = PageRequest.of(pageNum, pageSize, sort);
          Page<User> users = userRepository.findAll(pageable);
          Iterator<User> userIterator = users.iterator();
          return userIterator;
      }
      

UserService.javaファイルの紹介

UserService.java ファイルは、JPAを使用してデータベースを操作し、ユーザーデータの追加、削除、更新、クエリを行います。

UserService.java ファイルのコードは、主に以下の部分で構成されています：

1. 他のクラスとインターフェースのインポート。

   このファイルには以下のクラスが含まれていることを宣言します：

   • User クラス：サービスクラスでユーザーオブジェクトを操作および処理するために使用されます。
   • Iterator クラス：コレクションを走査するために使用されます。

   コード：

   import com.oceanbase.testspringdatajpa.entity.User;
   
   import java.util.Iterator;
   

2. UserService インターフェースの定義。 UserService インターフェースを通じて、ユーザーデータの挿入、削除、更新、クエリを行うメソッドを定義します。以下のメソッドとクラスが含まれます：

   • insertUser メソッド：ユーザーデータを挿入するために使用されます。

   • deleteUser メソッド：ユーザーデータを削除するために使用されます。

   • updateUser メソッド：ユーザーデータを更新するために使用されます。

   • updateUserById メソッド：id に基づいてユーザーの name を変更するために使用されます。

   • selectUserById メソッド：id に基づいてユーザーデータをクエリするために使用されます。

   • selectUserByName メソッド：ユーザー名に基づいてユーザーデータをクエリするために使用されます。

   • selectUserAll メソッド：すべてのユーザーデータをページネーションクエリするために使用されます。

   • User クラス：サービスクラスでユーザーオブジェクトを操作および処理するために使用されます。

   • Iterator クラス：コレクションを走査するために使用されます。

   コード：

   public interface UserService {
       void insertUser(User user);
   
       void deleteUser(Integer id);
   
       int updateUser(User user);
   
       int updateUserById(String name, String id);
   
       User selectUserById(Integer id);
   
       User selectUserByName(String username);
       Iterator<User> selectUserAll(Integer pageNum, Integer pageSize);
   }
   

TestSpringDataJpaApplication.javaファイルの紹介

TestSpringDataJpaApplication.java ファイルは、Spring Bootアプリケーションを起動および設定するために使用されます。

TestSpringDataJpaApplication.java ファイルのコードは、主に以下の部分で構成されています：

1. クラスとインターフェースの定義。 このファイルには以下のクラスが含まれていることを宣言します：

• SpringApplication クラス：Spring Bootアプリケーションを起動するために使用されます。
• @SpringBootApplication アノテーション：Spring Bootアプリケーションのエントリクラスをマークするために使用されます。

**コード：**

```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
```

2. TestSpringDataJpaApplication クラスの定義。 @SpringBootApplication アノテーションを使用してSpring Bootアプリケーションのエントリクラスをマークし、main メソッド内で SpringApplication.run メソッドを呼び出してアプリケーションを起動します。

   コード：

   @SpringBootApplication
   public class TestSpringDataJpaApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(TestSpringDataJpaApplication.class, args);
       }
   }
   

TestSpringDataJpaApplicationTests.javaファイルの紹介

TestSpringDataJpaApplicationTests.java ファイルは、Spring Bootアプリケーションを起動および設定するために使用されます。

TestSpringDataJpaApplicationTests.java ファイルのコードは、主に以下の部分で構成されています：

1. 他のクラスとインターフェースのインポート。 このファイルには以下のクラスが含まれていることを宣言します：

• User クラス：サービスクラスでユーザーオブジェクトを操作および処理するために使用されます。
• UserService クラス：他のクラスで注入し、サービスクラスで定義されたメソッドを呼び出すために使用されます。
• @Test アノテーション：テストメソッドをマークするために使用されます。
• Autowired アノテーション：依存オブジェクトを自動注入するために使用されます。
• @SpringBootTest アノテーション：Spring Bootアプリケーションをテストするために使用されます。
• Iterator クラス：コレクションを走査するために使用されます。

**コード：**

```java
import com.oceanbase.testspringdatajpa.entity.User;
import com.oceanbase.testspringdatajpa.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Iterator;
```

2. UserService メソッドの定義。 Spring Bootアプリケーション内の UserService サービスの各メソッドをテストするために使用されます。UserService 依存関係を注入し、各メソッドを呼び出してユーザーデータの挿入、削除、更新、およびクエリ機能をテストし、関連する結果を出力します。

3. @Autowired アノテーションによる依存性注入。 UserService インターフェースの実装クラスを userService 変数に自動注入します。

   コード：

   @Autowired
   private UserService userService;
   

4. contextLoads メソッドを使用してテストします。

   1. ユーザーデータを挿入します。 for ループを使用し、userService の insertUser メソッドを呼び出して、10件のユーザーデータを挿入します。

   コード：

     ```java
     for (int i = 1; i <= 10; i++) {
         userService.insertUser(new User(i, "insert" + i));
     }
     ```
   

   2. ユーザーデータを削除します。 userService の deleteUser メソッドを呼び出し、idが1のユーザーデータを削除します。

   コード：

     ```java
     userService.deleteUser(1);
     ```
   

   3. ユーザーデータを変更します。 userService の updateUser メソッドを呼び出し、idが2のユーザーデータを更新します。

   コード：

     ```java
     userService.updateUser(new User(2, "update"));
     ```
   

   4. ユーザーデータをクエリします。
   • userService の selectUserById メソッドを呼び出し、idに基づいてユーザーデータをクエリし、結果を user 変数に代入します。user オブジェクトを出力します。
   • userService の selectUserByName メソッドを呼び出し、ユーザー名に基づいてユーザーデータをクエリし、結果を userByName 変数に代入します。userByName オブジェクトを出力します。

   コード：

     ```java
     User user = userService.selectUserById(2);
     System.out.println("user = " + user);
     User userByName = userService.selectUserByName("insert");
     System.out.println("userByName = " + userByName);
     ```
   

   5. ユーザーデータをページネーションでクエリします。 userService の selectUserAll メソッドを呼び出し、すべてのユーザーデータをページネーションでクエリし、結果を userIterator 変数に代入します。forEachRemaining メソッドを使用して userIterator をイテレーションし、各ユーザーオブジェクトを出力します。

   コード：

     ```java
     Iterator<User> userIterator = userService.selectUserAll(0, 5);
     userIterator.forEachRemaining(System.out::println);
     ```
   

全コード表示

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.oceanbase</groupId>
    <artifactId>java-oceanbase-springdatajpa</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>java-oceanbase-springdatajpa</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>

        <dependency>
            <groupId>com.oceanbase</groupId>
            <artifactId>oceanbase-client</artifactId>
            <version>2.4.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

server:
  servlet:
    context-path: /testspringdatajpa
  port: 8890

spring:
  datasource:
    driver-class-name: com.oceanbase.jdbc.Driver
    url: jdbc:oceanbase://host:port/schema_name?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
    username: user_name
    password: ******
    type: com.alibaba.druid.pool.DruidDataSource
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    format-sql: true
    open-in-view: false

package com.oceanbase.testspringdatajpa.dao;

import com.oceanbase.testspringdatajpa.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;


@Repository("userRepository")
public interface UserRepository extends JpaRepository<User, Integer> {
    //Custom repository handwritten SQL, placeholder value transfer form
    @Query(value = "update test_springdatajpa_2 set username=?1 where id=?2", nativeQuery = true)
    @Modifying
    int updateById(String name, String id);

    //SPEL expression, hql syntax
    @Query("SELECT u FROM User u WHERE u.username = :username")
    User findUser(@Param("username") String username);//Mapping parameter username to database field username
}

package com.oceanbase.testspringdatajpa.entity;

import javax.persistence.*;

@Entity
@Table(name = "test_springdatajpa_2")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.TABLE)

    @Column(name = "id", nullable = false)
    private Integer id;

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

    public User() {
    }

    public User(Integer id, String username) {
        this.id = id;
        this.username = username;
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

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

package com.oceanbase.testspringdatajpa.service.impl;

import com.oceanbase.testspringdatajpa.dao.UserRepository;
import com.oceanbase.testspringdatajpa.entity.User;
import com.oceanbase.testspringdatajpa.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Iterator;
import java.util.Optional;


@Transactional
@Service("userService")
public class UserServiceImpl implements UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserServiceImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }


    //insert
    @Override
    public void insertUser(User user) { userRepository.save(user); }

    //delete
    @Override
    public void deleteUser(Integer id) {
        if (!userRepository.existsById(id)) {
            return;
        }
    }

    //update
    @Override
    public int updateUser(User user) {
        userRepository.save(user);
        return 1;
    }

    //update based on name and id
    @Override
    public int updateUserById(String name, String id) {
        return userRepository.updateById(name, id);
    }

    // select one user
    @Override
    public User selectUserById(Integer id) {
        Optional<User> optional = userRepository.findById(id);
        User user = optional.orElse(null);
        return user;
    }

    //query user based on username
    @Override
    public User selectUserByName(String username) {
        return userRepository.findUser(username);
    }


    @Override
    public Iterator<User> selectUserAll(Integer pageNum, Integer pageSize) {
        //By passing parameters to this method, physical pagination can be achieved, which is very simple.
        Sort sort = Sort.by(Sort.Direction.ASC, "id");
        Pageable pageable = PageRequest.of(pageNum, pageSize, sort);
        Page<User> users = userRepository.findAll(pageable);
        Iterator<User> userIterator = users.iterator();
        return userIterator;
    }
}

package com.oceanbase.testspringdatajpa.service;

import com.oceanbase.testspringdatajpa.entity.User;

import java.util.Iterator;



public interface UserService {
    //insert
    void insertUser(User user);

    //delete
    void deleteUser(Integer id);

    //update
    int updateUser(User user);

    //customize SQL and modify name based on id
    int updateUserById(String name, String id);

    //select one user
    User selectUserById(Integer id);

    //customize SQL to query users based on username
    User selectUserByName(String username);

    //query all users
    Iterator<User> selectUserAll(Integer pageNum, Integer pageSize);
}

package com.oceanbase.testspringdatajpa;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;



@SpringBootApplication
public class TestSpringDataJpaApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestSpringDataJpaApplication.class, args);
    }

}

package com.oceanbase.testspringdatajpa;

import com.oceanbase.testspringdatajpa.entity.User;
import com.oceanbase.testspringdatajpa.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Iterator;


@SpringBootTest
class TestSpringDataJpaApplicationTests {
    @Autowired
    private UserService userService;

    @Test
    void contextLoads() {
        //insert
        for (int i = 1; i <= 10; i++) {
            userService.insertUser(new User(i, "insert" + i));
        }
        //delete
        userService.deleteUser(1);
        //update
        userService.updateUser(new User(2, "update"));
        //selectUserById
        User user = userService.selectUserById(2);
        System.out.println("user = " + user);
        //selectUserByName
        User userByName = userService.selectUserByName("insert");
        System.out.println("userByName = " + userByName);
        //query all users
        Iterator<User> userIterator = userService.selectUserAll(0, 5);
        userIterator.forEachRemaining(System.out::println);
    }
}

関連ドキュメント

OceanBase Connector/Jの詳細については、OceanBase JDBCドライバをご参照ください。