SpringBatch を使用して OB Cloud データベースに接続するサンプルプログラム

本ドキュメントでは、SpringBatch フレームワークと OB Cloud データベースを使用してアプリケーションを構築し、テーブルの作成、データの挿入、データのクエリなどの基本操作を実装する方法について説明します。

      java-oceanbase-springbatch サンプルプロジェクトをダウンロード
  </a>

• OB Cloud データベースアカウントを登録し、クラスタインスタンスと MySQL互換モード のテナントを作成していること。詳細は、クラスタインスタンスの作成 および テナントの作成 をご参照ください。
• JDK 1.8 および Maven がインストールされていること。
• IntelliJ IDEA がインストールされていること。

手順

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

手順 1：OB Cloud データベースの接続文字列を取得する

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

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

2. 作成済みの OB Cloud データベースに基づいて、以下の URL の対応する情報を入力します。

   説明

   application.properties ファイルでこの URL 情報が必要になります。

   jdbc:oceanbase://host:port/schema_name?user=$user_name&password=$password&characterEncoding=utf-8
   

   パラメータの説明：

   • host：OB Cloud データベースの接続アドレスを指定します。例：t********.********.oceanbase.cloud。
   • port：OB Cloud データベースの接続ポートを指定します。デフォルトは 3306 です。
   • schema_name：アクセスする Schema 名を指定します。
   • user_name：データベースにアクセスするアカウントを指定します。
   • password：アカウントのパスワードを指定します。
   • characterEncoding：文字エンコーディングを指定します。

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

手順 2：java-oceanbase-springbatch プロジェクトを 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-springbatch プロジェクト内のデータベース接続情報を変更する

手順 1：OB Cloud データベースの接続文字列を取得する の情報に基づいて、application.properties ファイル内のデータベース接続情報を変更します。

例：

• データベースドライバ名は com.mysql.cj.jdbc.Driver です。
• OB Cloud データベースの接続アドレスは t5******.********.oceanbase.cloud です。
• アクセスポートは 3306 を使用します。
• アクセスする Schema 名は test です。
• テナントの接続アカウントは mysql001 です。
• パスワードは ****** です。

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

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://t********.********.oceanbase.cloud:3306/test?characterEncoding=utf-8
spring.datasource.username=mysql001
spring.datasource.password=******

spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

spring.batch.job.enabled=false

logging.level.org.springframework=INFO
logging.level.com.example=DEBUG

手順 4：java-oceanbase-springbatch プロジェクトを実行する

• AddDescPeopleWriterTest.java ファイルを実行します。

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

  people_desc 表中的数据：
  PeopleDESC [name=John, age=25, desc=This is John with age 25]
  PeopleDESC [name=Alice, age=30, desc=This is Alice with age 30]
  Batch Job execution completed.
  

• AddPeopleWriterTest.java ファイルを実行します。

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

  people 表中的数据：
  People [name=zhangsan, age=27]
  People [name=lisi, age=35]
  Batch Job execution completed.
  

よくある質問

1. 接続タイムアウト

接続タイムアウトの問題が発生した場合は、JDBC URL で接続タイムアウトのパラメータを設定できます：

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

2. 文字セットの問題

正しい文字エンコーディングを確保するために、JDBC URL で正しい文字セットのパラメータを設定します：

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

3. SSL 接続

OB Cloud データベースとの SSL 接続を有効にするには、JDBC URL に以下のパラメータを追加します：

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

4. アカウントパスワード内の特殊文字

ユーザー名またはパスワードに特殊文字（# など）が含まれている場合は、URL エンコードを行う必要があります：

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

プロジェクトコードの紹介

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

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

│  pom.xml
│
├─.idea
│
├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─oceanbase
│  │  │          └─example
│  │  │              └─batch
│  │  │                  │──BatchApplication.java
│  │  │                  │
│  │  │                  ├─config
│  │  │                  │   └─BatchConfig.java
│  │  │                  │
│  │  │                  ├─model
│  │  │                  │   ├─People.java
│  │  │                  │   └─PeopleDESC.java
│  │  │                  │
│  │  │                  ├─processor
│  │  │                  │   └─AddPeopleDescProcessor.java
│  │  │                  │
│  │  │                  └─writer
│  │  │                      ├─AddDescPeopleWriter.java
│  │  │                      └─AddPeopleWriter.java
│  │  │
│  │  └─resources
│  │      └─application.properties
│  │
│  └─test
│      └─java
│          └─com
│              └─oceanbase
│                  └─example
│                      └─batch
│                          ├─config
│                          │   └─BatchConfigTest.java
│                          │
│                          ├─processor
│                          │   └─AddPeopleDescProcessorTest.java
│                          │
│                          └─writer
│                              ├─AddDescPeopleWriterTest.java
│                              └─AddPeopleWriterTest.java
│
└─target

ファイルの説明：

• pom.xml：Maven プロジェクトの設定ファイルであり、プロジェクトの依存関係、プラグイン、ビルドなどの情報が含まれています。
• .idea：IDE（統合開発環境）で使用されるディレクトリであり、プロジェクト関連の設定情報を保存するために使用されます。
• src：通常、プロジェクト内でソースコードを格納するディレクトリを表すために使用されます。
• main: 主要なソースコードとリソースファイルを格納するディレクトリです。
• java: Java ソースコードを格納するディレクトリです。
• com.oceanbase.example.batch: パッケージ名です。
• BatchApplication.java：アプリケーションのエントリクラスであり、アプリケーションのメインメソッドが含まれています。
• config：設定クラスのフォルダであり、アプリケーションの設定クラスが含まれています。
• BatchConfig.java：アプリケーションの設定クラスであり、アプリケーションのプロパティや動作を設定するために使用されます。
• model：モデルクラスのフォルダであり、アプリケーションのデータモデルクラスが含まれています。
• People.java：人物データモデルクラスです。
• PeopleDESC.java：人物 DESC データモデルクラスです。
• processor：プロセッサクラスのフォルダであり、アプリケーションのプロセッサクラスが含まれています。
• AddPeopleDescProcessor.java：人物 DESC 情報を追加するプロセッサクラスです。
• writer：ライタークラスのフォルダであり、アプリケーションのライタークラスが含まれています。
• AddDescPeopleWriter.java：人物 DESC 情報を書き込むライタークラスです。
• AddPeopleWriter.java：人物情報を書き込むライタークラスです。
• resources：リソースフォルダであり、アプリケーションの設定ファイルやその他の静的リソースファイルが含まれています。
• application.properties：アプリケーションの設定ファイルであり、アプリケーションのプロパティを設定するために使用されます。
• test: テストコードとリソースファイルを格納するディレクトリです。
• BatchConfigTest.java：アプリケーション設定クラスのテストクラスです。
• AddPeopleDescProcessorTest.java：人物 DESC 追加プロセッサのテストクラスです。
• AddDescPeopleWriterTest.java：人物 DESC 情報を書き込むライターのテストクラスです。
• AddPeopleWriterTest.java：人物情報を書き込むライターのテストクラスです。
• target: コンパイル後の Class ファイルや Jar パッケージなどのファイルを格納するディレクトリです。

pom.xml コードの紹介

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

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

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

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

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

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

   1. xmlns を使用して、POM の名前空間を http://maven.apache.org/POM/4.0.0 に指定します。
   2. xmlns:xsi を使用して、XML 名前空間を http://www.w3.org/2001/XMLSchema-instance に指定します。
   3. xsi:schemaLocation を使用して、POM の名前空間を http://maven.apache.org/POM/4.0.0 に指定し、POM の XSD ファイルの場所を https://maven.apache.org/xsd/maven-4.0.0.xsd に指定します。
   4. <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>
   </project>
   

3. 親プロジェクトの情報を設定します。

   1. <groupId> を使用して、親プロジェクトの識別子を org.springframework.boot に指定します。
   2. <artifactId> を使用して、親プロジェクトの依存関係を spring-boot-starter-parent に指定します。
   3. <version> を使用して、親プロジェクトのバージョン番号を 2.7.11 に指定します。
   4. relativePath を使用して、親プロジェクトのパスが空であることを示します。

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

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

4. 基本情報を設定します。

   1. <groupId> を使用して、プロジェクトの識別子を com.oceanbase に指定します。
   2. <artifactId> を使用して、プロジェクトの依存関係を java-oceanbase-springboot に指定します。
   3. <version> を使用して、プロジェクトのバージョン番号を 0.0.1-SNAPSHOT に指定します。
   4. description を使用して、プロジェクト情報を Demo project for Spring Batch として紹介します。

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

    <groupId>com.oceanbase</groupId>
    <artifactId>java-oceanbase-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>java-oceanbase-springbatch</name>
    <description>Demo project for Spring Batch</description>
   

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

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

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

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

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

   1. 依存関係が属する組織を org.springframework.boot、名前を spring-boot-starter に指定します。この依存関係により、Spring Boot がデフォルトでサポートするコンポーネントの依存関係を使用でき、Web、データ処理、セキュリティ、Test などの機能をサポートします。

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

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

   2. 依存関係が属する組織を org.springframework.boot、名前を spring-boot-starter-jdbc に指定します。この依存関係により、接続プールやデータソース設定など、Spring Boot が提供する JDBC 関連機能を使用できます。

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

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-jdbc</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.oceanbase、名前を oceanbase-client、バージョン番号を 2.4.12 に指定します。この依存関係により、接続、クエリ、トランザクションなど、OceanBase が提供するクライアント機能を使用できます。

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

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

   5. 依存関係が属する組織を org.springframework.boot、名前を spring-boot-starter-batch に指定します。この依存関係により、Spring Boot が提供するバッチ処理機能を使用できます。

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

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

   6. 依存関係が属する組織を 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>
      

   7. 依存関係が属する組織を org.apache.tomcat、名前を tomcat-jdbc に指定します。この依存関係により、接続プールの設定、接続の取得と解放、接続の管理など、Tomcat が提供する JDBC 接続プール機能を使用できます。

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

      <dependency>
          <groupId>org.apache.tomcat</groupId>
          <artifactId>tomcat-jdbc</artifactId>
      </dependency>
      

   8. 依存関係が属するテストフレームワークを junit、名前を junit、バージョン番号を 4.10、スコープを test に指定します。この依存関係により、JUnit 単体テストの依存関係の設定を追加できます。

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

      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.10</version>
          <scope>test</scope>
      </dependency>
      

   9. 依存関係が属する組織を javax.activation、名前を javax.activation-api、バージョン番号を 1.2.0 に指定します。この依存関係により、Java Activation Framework（JAF）ライブラリを導入できます。

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

      <dependency>
          <groupId>javax.activation</groupId>
          <artifactId>javax.activation-api</artifactId>
          <version>1.2.0</version>
      </dependency>
      

   10. 依存関係が属する組織を jakarta.persistence、名前を jakarta.persistence-api、バージョン番号を 2.2.3 に指定します。この依存関係により、Jakarta Persistence API の依存関係の設定を追加できます。 コードは以下の通りです：

       <dependency>
           <groupId>jakarta.persistence</groupId>
           <artifactId>jakarta.persistence-api</artifactId>
           <version>2.2.3</version>
       </dependency>
       

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

   依存関係が属する組織を org.springframework.boot、名前を spring-boot-maven-plugin に指定します。このプラグインは、Spring Boot アプリケーションを実行可能な JAR パッケージまたは WAR パッケージにパッケージ化し、直接実行できるようにするために使用されます。

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
   

application.properties ファイルの紹介

application.properties ファイルは、データベース接続やその他の関連するパラメータを設定するために使用されます。例えば、データベースドライバ、接続 URL、ユーザー名、パスワードなどです。また、JPA（Java Persistence API）や Spring Batch に関する設定、ログレベルの設定も含まれています。

1. データベース接続設定。

   • spring.datasource.driver を使用して、データベースドライバを com.mysql.cj.jdbc.Driver に指定し、OB Cloud データベースとの接続を確立するために使用します。
   • spring.datasource.url を使用して、データベースに接続する URL を指定します。
   • spring.datasource.username を使用して、データベースに接続するユーザー名を指定します。
   • spring.datasource.password を使用して、データベースに接続するパスワードを指定します。

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

   spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
   spring.datasource.url=jdbc:oceanbase://host:port/schema_name?characterEncoding=utf-8
   spring.datasource.username=user_name
   spring.datasource.password=******
   

2. JPA 設定。

   • spring.jpa.show-sql を使用して、ログに SQL 文を表示するかどうかを指定します。true に設定すると、SQL 文が表示されます。
   • spring.jpa.hibernate.ddl-auto を使用して、Hibernate の DDL 操作の動作を指定します。ここでは update に設定し、アプリケーションの起動時にデータベース構造を自動的に更新することを示します。

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

   spring.jpa.show-sql=true
   spring.jpa.hibernate.ddl-auto=update
   

3. Spring Batch 設定：

   spring.batch.job.enabled を使用して、Spring Batch ジョブを有効にするかどうかを指定します。ここでは false に設定し、バッチジョブの自動実行を無効にすることを示します。

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

   spring.batch.job.enabled=false
   

   説明

   Spring Batch において、spring.batch.job.enabled プロパティの役割は、バッチジョブの実行動作を制御することです。

   • spring.batch.job.enabled=true (デフォルト値)：Spring Boot アプリケーションの起動時に、定義されたすべてのバッチジョブを自動的に実行することを示します。つまり、アプリケーションの起動時に、Spring Batch は定義されたすべてのジョブを自動的に検出して実行します。
   • spring.batch.job.enabled=false：バッチジョブの自動実行を無効にすることを示します。これは通常、開発環境やテスト環境、またはジョブの実行を手動で制御したい場合に使用されます。false に設定すると、アプリケーションの起動時にジョブは自動的に実行されず、他の方法（REST インターフェース、コマンドラインなど）で手動でジョブをトリガーできます。

   要約すると、spring.batch.job.enabled=false を設定することで、アプリケーションの起動時にジョブが自動的に実行されるのを防ぎ、バッチジョブを実行するタイミングを制御するための柔軟性を高めることができます。

4. ログ設定：

   • logging.level.org.springframework を使用して、Spring フレームワークのログレベルを INFO に指定します。
   • logging.level.com.example を使用して、アプリケーションのカスタムコードのログレベルを DEBUG に指定します。

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

   logging.level.org.springframework=INFO
   logging.level.com.example=DEBUG
   

BatchApplication.java ファイルの紹介

BatchApplication.java ファイルは、Spring Boot アプリケーションのエントリファイルです。

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

1. 他のクラスとインターフェースの参照。

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

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

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

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

2. BatchApplication クラスの定義。

   @SpringBootApplication アノテーションを使用して、BatchApplication クラスを Spring Boot アプリケーションのエントリとしてマークします。BatchApplication クラスでは、アプリケーションのエントリポイントとして静的な main メソッドを定義しています。このメソッド内で、SpringApplication.run メソッドを使用して Spring Boot アプリケーションを起動します。さらに、バッチジョブを実行するための runBatchJob という名前のメソッドを定義しています。

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

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

BatchConfig.java ファイルの紹介

BatchConfig.java ファイルは、バッチジョブのステップ、リーダー、プロセッサ、ライターなどのコンポーネントを設定するために使用されます。

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

1. 他のクラスとインターフェースの参照。

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

   • People クラス：データベースから読み取った人物情報を格納するために使用されます。
   • PeopleDESC クラス：人物情報を変換または処理した後の説明情報を格納するために使用されます。
   • AddPeopleDescProcessor クラス：読み取った People オブジェクトを PeopleDESC オブジェクトに変換する、ItemProcessor インターフェースの実装クラスです。
   • AddDescPeopleWriter クラス：PeopleDESC オブジェクトをターゲットの場所に書き込む、ItemWriter インターフェースの実装クラスです。
   • Job インターフェース：バッチジョブを表します。
   • Step インターフェース：ジョブ内のステップを表します。
   • EnableBatchProcessing アノテーション：Spring Batch の設定アノテーションであり、Spring Batch 処理機能を有効にして設定するために使用されます。
   • JobBuilderFactory クラス：ジョブを作成および設定するために使用されます。
   • StepBuilderFactory クラス：ステップを作成および設定するために使用されます。
   • RunIdIncrementer クラス：Spring Batch の実行 ID（Run ID）インクリメンタであり、ジョブを実行するたびに実行 ID を増やすために使用されます。
   • ItemProcessor インターフェース：読み取ったアイテムを処理または変換するために使用されます。
   • ItemReader インターフェース：データソースからアイテムを読み取るために使用されます。
   • ItemWriter インターフェース：処理または変換されたアイテムを指定されたターゲットの場所に書き込むために使用されます。
   • JdbcCursorItemReader クラス：データベースからデータを読み取り、カーソル結果セットを返すために使用されます。
   • Autowired アノテーション：依存関係の注入を行うために使用されます。
   • Bean アノテーション：Bean を作成および設定するために使用されます。
   • ComponentScan アノテーション：コンポーネントスキャンを行うパッケージまたはクラスを指定するために使用されます。
   • Configuration アノテーション：クラスを設定クラスとしてマークするために使用されます。
   • EnableAutoConfiguration アノテーション：Spring Boot の自動設定を有効にするために使用されます。
   • SpringBootApplication アノテーション：このクラスを Spring Boot アプリケーションのエントリとしてマークするために使用されます。
   • DataSource インターフェース：データベース接続を表すために使用されます。

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

   import com.oceanbase.example.batch.model.People;
   import com.oceanbase.example.batch.model.PeopleDESC;
   import com.oceanbase.example.batch.processor.AddPeopleDescProcessor;
   import com.oceanbase.example.batch.writer.AddDescPeopleWriter;
   import org.springframework.batch.core.Job;
   import org.springframework.batch.core.Step;
   import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
   import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
   import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
   import org.springframework.batch.core.launch.support.RunIdIncrementer;
   import org.springframework.batch.item.ItemProcessor;
   import org.springframework.batch.item.ItemReader;
   import org.springframework.batch.item.ItemWriter;
   import org.springframework.batch.item.database.JdbcCursorItemReader;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.ComponentScan;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.jdbc.core.BeanPropertyRowMapper;
   
   import javax.sql.DataSource;
   

2. BatchConfig クラスの定義。

   これはシンプルな Spring Batch バッチジョブです。データの読み取り、処理、書き込み方法を定義し、これらのステップを 1 つのジョブとしてカプセル化します。Spring Batch のアノテーションと自動設定機能を使用し、設定クラス内の各 @Bean メソッドを通じて対応するコンポーネントインスタンスを作成し、step1 でこれらのコンポーネントを使用してデータの読み取り、処理、書き込みを完了できます。

   • @Configuration を使用して、このクラスが設定クラスであることを示します。
   • @EnableBatchProcessing を使用して Spring Batch の処理機能を有効にします。このアノテーションは、JobRepository や JobLauncher などの必要な bean を自動的に作成します。
   • @SpringBootApplication を使用して、Spring Boot アプリケーションのメインクラスアノテーションとして機能し、Spring Boot アプリケーションの起動ポイントとなります。
   • @ComponentScan を使用してコンポーネントスキャンを行うパッケージを指定し、Spring にこのパッケージおよびサブパッケージ内のすべてのコンポーネントをスキャンして登録するように指示します。
   • @EnableAutoConfiguration を使用して、Spring Boot アプリケーションのインフラストラクチャを自動的に設定します。

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

    @Configuration
    @EnableBatchProcessing
    @SpringBootApplication
    @ComponentScan("com.oceanbase.example.batch.writer")
    @EnableAutoConfiguration
    public class BatchConfig {
    }
   

   1. @Autowired アノテーションの定義。

      @Autowired アノテーションを使用して、JobBuilderFactory、StepBuilderFactory、および DataSource を BatchConfig クラスのメンバ変数に注入します。JobBuilderFactory はジョブ（Job）を作成および設定するためのファクトリクラスであり、StepBuilderFactory はステップ（Step）を作成および設定するためのファクトリクラスであり、DataSource はデータベース接続を取得するためのインターフェースです。

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

      @Autowired
      private JobBuilderFactory jobBuilderFactory;
      
      @Autowired
      private StepBuilderFactory stepBuilderFactory;
      
      @Autowired
      private DataSource dataSource;
      

   2. @Bean アノテーションの定義。

      @Bean アノテーションを使用して、バッチジョブのリーダー、プロセッサ、ライター、ステップ、およびジョブを作成するためのいくつかのメソッドを定義します。

      • peopleReader メソッドを使用して ItemReader コンポーネントインスタンスを作成します。このコンポーネントは JdbcCursorItemReader を使用してデータベース内の People オブジェクトデータを読み取ります。データソース dataSource を設定し、データベースの行を People オブジェクトにマッピングする RowMapper を設定し、SQL クエリ文を SELECT * FROM people に設定します。

      • addPeopleDescProcessor メソッドを使用して ItemProcessor コンポーネントインスタンスを作成します。このコンポーネントは AddPeopleDescProcessor を使用して People オブジェクトを処理し、変換された PeopleDESC オブジェクトを返します。

      • addDescPeopleWriter メソッドを使用して ItemWriter コンポーネントインスタンスを作成します。このコンポーネントは AddDescPeopleWriter を使用して PeopleDESC オブジェクトをターゲットの場所に書き込みます。

      • step1 メソッドを使用して Step コンポーネントインスタンスを作成します。このステップの名前は step1 であり、stepBuilderFactory.get を通じてステップビルダーを取得し、リーダーを ItemReader コンポーネントに、プロセッサを ItemProcessor コンポーネントに、ライターを ItemWriter コンポーネントに設定し、chunk サイズを 10 に設定し、最後に build を呼び出して設定が完了した Step を構築して返します。

      • importJob メソッドを使用して Job コンポーネントインスタンスを作成します。このジョブの名前は importJob であり、jobBuilderFactory.get を通じてジョブビルダーを取得し、インクリメンタを RunIdIncrementer に設定し、ジョブ flow の最初のステップを Step に設定し、最後に build を呼び出して設定が完了した Job を構築して返します。

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

        @Bean
        public ItemReader<People> peopleReader() {
            JdbcCursorItemReader<People> reader = new JdbcCursorItemReader<>();
            reader.setDataSource((javax.sql.DataSource) dataSource);
            reader.setRowMapper(new BeanPropertyRowMapper<>(People.class));
            reader.setSql("SELECT * FROM people");
            return reader;
        }
        
        @Bean
        public ItemProcessor<People, PeopleDESC> addPeopleDescProcessor() {
            return new AddPeopleDescProcessor();
        }
        
        @Bean
        public ItemWriter<PeopleDESC> addDescPeopleWriter() {
            return new AddDescPeopleWriter();
        }
        
        @Bean
        public Step step1(ItemReader<People> reader, ItemProcessor<People, PeopleDESC> processor,
                        ItemWriter<PeopleDESC> writer) {
            return stepBuilderFactory.get("step1")
                    .<People, PeopleDESC>chunk(10)
                    .reader(reader)
                    .processor(processor)
                    .writer(writer)
                    .build();
        }
        
        @Bean
        public Job importJob(Step step1) {
            return jobBuilderFactory.get("importJob")
                    .incrementer(new RunIdIncrementer())
                    .flow(step1)
                    .end()
                    .build();
        }
        

People.java ファイルの紹介

People.java ファイルは、人物の情報を表す People クラスのデータモデルを作成します。このクラスには、2 つのプライベートメンバ変数 name と age、および対応する getter と setter メソッドが含まれています。最後に、オブジェクトの情報を出力するために toString メソッドをオーバーライドします。ここで、name は人物の名前を表し、age は人物の年齢を表します。getter と setter メソッドを使用して、これらのプロパティの値を取得および設定できます。

このクラスの役割は、バッチプログラムの入力と出力に対してデータを格納および受け渡す方法を提供することです。バッチ処理の読み取りおよび書き込み操作では、People オブジェクトを使用してデータを格納し、setter メソッドでデータを設定し、getter メソッドでデータを取得します。

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

    public class People {
        private String name;
        private int age;

            // getters and setters

        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "People [name=" + name + ", age=" + age + "]";
        }
        // Getters and setters
    }

PeopleDESC.java ファイルの紹介

PeopleDESC.java ファイルは、人物の情報を表すために使用される PeopleDESC クラスのデータモデルを作成します。PeopleDESC クラスには、name、age、desc、および id の 4 つのプロパティがあり、それぞれ人物の名前、年齢、説明、および識別子を表します。このクラスには、プロパティの値にアクセスして設定するための対応する getter と setter メソッドが含まれています。名前、年齢、説明を含むクラスの文字列表現を返すために toString メソッドをオーバーライドします。

People クラスと同様に、PeopleDESC クラスもバッチプログラムの入力と出力でデータを格納および受け渡すために使用されます。

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

    public class PeopleDESC {
        private String name;
        private int age;
        private String desc;
        private int id;

        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

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

        public String getDesc() {
            return desc;
        }

        public void setDesc(String desc) {
            this.desc = desc;
        }

        public int getId() {
            return id;
        }

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

        @Override
        public String toString() {
            return "PeopleDESC [name=" + name + ", age=" + age + ", desc=" + desc + "]";
        }
    }

AddPeopleDescProcessor.java ファイルの紹介

AddPeopleDescProcessor.java ファイルは、AddPeopleDescProcessor という名前のクラスを定義し、ItemProcessor インターフェースを実装して、People オブジェクトを PeopleDESC オブジェクトに変換するために使用されます。

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

1. 他のクラスとインターフェースの参照。

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

   • People クラス：データベースから読み取った人物情報を格納するために使用されます。
   • PeopleDESC クラス：人物情報を変換または処理した後の説明情報を格納するために使用されます。
   • ItemProcessor インターフェース：読み取ったアイテムを処理または変換するために使用されます。

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

   import com.oceanbase.example.batch.model.People;
   import com.oceanbase.example.batch.model.PeopleDESC;
   import org.springframework.batch.item.ItemProcessor;
   

2. AddPeopleDescProcessor クラスの定義。

   ItemProcessor インターフェースの AddPeopleDescProcessor クラスは、People オブジェクトを PeopleDESC オブジェクトに変換するために使用され、バッチ処理プロセスにおける入力データの処理ロジックを実装します。

   このクラスの process メソッドでは、まず PeopleDESC オブジェクト desc を作成し、次に item パラメータを通じて People オブジェクトのプロパティ（name と age）を取得し、これらのプロパティを desc オブジェクトに設定します。同時に、desc オブジェクトの desc プロパティにも値を割り当てます。割り当てのロジックは、People オブジェクトのプロパティに基づいて説明情報を生成することです。最後に、処理された PeopleDESC オブジェクトを返します。

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

   public class AddPeopleDescProcessor implements ItemProcessor<People, PeopleDESC> {
       @Override
       public PeopleDESC process(People item) throws Exception {
           PeopleDESC desc = new PeopleDESC();
           desc.setName(item.getName());
           desc.setAge(item.getAge());
           desc.setDesc("This is " + item.getName() + " with age " + item.getAge());
           return desc;
       }
   }
   

AddDescPeopleWriter.java ファイルの紹介

AddDescPeopleWriter.java ファイルは、ItemWriter インターフェースの AddDescPeopleWriter クラスを実装し、People オブジェクトをデータベースに書き込むために使用されます。

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

1. 他のクラスとインターフェースの参照。

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

   • PeopleDESC クラス：人物情報を変換または処理した後の説明情報を格納するために使用されます。
   • ItemWriter インターフェース：処理または変換されたアイテムを指定されたターゲットの場所に書き込むために使用されます。
   • Autowired アノテーション：依存関係の注入を行うために使用されます。
   • JdbcTemplate クラス：SQL 文を実行するメソッドを提供します。
   • List インターフェース：クエリ結果セットを操作するために使用されます。

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

   import com.oceanbase.example.batch.model.PeopleDESC;
   import org.springframework.batch.item.ItemWriter;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.jdbc.core.JdbcTemplate;
   
   import java.util.List;
   

2. AddDescPeopleWriter クラスの定義。

   1. @Autowired アノテーションを使用して JdbcTemplate インスタンスを自動的に注入し、データを書き込む際にこのインスタンスを使用してデータベース操作を実行します。

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

          @Autowired
          private JdbcTemplate jdbcTemplate;
      

   2. write メソッドでは、渡された List<? extends PeopleDESC> を反復処理し、各 PeopleDESC オブジェクトを順番に取り出します。まず、SQL 文 DROP TABLE people_desc を実行して、すでに存在する可能性のある people_desc という名前のテーブルを削除します。次に、SQL 文 CREATE TABLE people_desc (id INT PRIMARY KEY, name VARCHAR2(255), age INT, description VARCHAR2(255)) を実行して、people_desc という名前のテーブルを作成します。このテーブルには id、name、age、および description の 4 つの列が含まれます。続いて、SQL 文 INSERT INTO people_desc (id, name, age, description) VALUES (?, ?, ?, ?) を使用して、各 PeopleDESC オブジェクトのプロパティ値をそれぞれ people_desc テーブルに挿入します。

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

          @Override
          public void write(List<? extends PeopleDESC> items) throws Exception {
              // 先删除可能存在的表
              jdbcTemplate.execute("DROP TABLE people_desc");
              // 建表语句
              String createTableSql = "CREATE TABLE people_desc (id INT PRIMARY KEY, name VARCHAR2(255), age INT, description VARCHAR2(255))";
              jdbcTemplate.execute(createTableSql);
              for (PeopleDESC item : items) {
                  String sql = "INSERT INTO people_desc (id, name, age, description) VALUES (?, ?, ?, ?)";
                  jdbcTemplate.update(sql, item.getId(), item.getName(), item.getAge(), item.getDesc());
              }
          }
      

AddPeopleWriter.java ファイルの紹介

AddPeopleWriter.java ファイルは、ItemWriter インターフェースの AddDescPeopleWriter クラスを実装し、PeopleDESC オブジェクトをデータベースに書き込むために使用されます。

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

1. 他のクラスとインターフェースの参照。

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

   • People クラス：データベースから読み取った人物情報を格納するために使用されます。
   • ItemWriter インターフェース：処理または変換されたアイテムを指定されたターゲットの場所に書き込むために使用されます。
   • Autowired アノテーション：依存関係の注入を行うために使用されます。
   • JdbcTemplate クラス：SQL 文を実行するメソッドを提供します。
   • Component アノテーション：このクラスを Spring コンポーネントとしてマークするために使用されます。
   • List インターフェース：クエリ結果セットを操作するために使用されます。

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

   import com.oceanbase.example.batch.model.People;
   import org.springframework.batch.item.ItemWriter;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.jdbc.core.JdbcTemplate;
   import org.springframework.stereotype.Component;
   
   import java.util.List;
   

2. AddPeopleWriter クラスの定義。

   1. @Autowired アノテーションを使用して JdbcTemplate インスタンスを自動的に注入し、データを書き込む際にこのインスタンスを使用してデータベース操作を実行します。

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

          @Autowired
          private JdbcTemplate jdbcTemplate;
      

   2. write メソッドでは、渡された List<? extends People> を反復処理し、各 People オブジェクトを順番に取り出します。まず、SQL 文 DROP TABLE people を実行して、すでに存在する可能性のある people という名前のテーブルを削除します。次に、SQL 文 CREATE TABLE people (name VARCHAR2(255), age INT) を実行して、people という名前のテーブルを作成します。このテーブルには name と age の 2 つの列が含まれます。続いて、SQL 文 INSERT INTO people (name, age) VALUES (?, ?) を使用して、各 People オブジェクトのプロパティ値をそれぞれ people テーブルに挿入します。

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

      @Override
      public void write(List<? extends People> items) throws Exception {
          // 先删除可能存在的表
          jdbcTemplate.execute("DROP TABLE people");
          // 建表语句
          String createTableSql = "CREATE TABLE people (name VARCHAR2(255), age INT)";
          jdbcTemplate.execute(createTableSql);
          for (People item : items) {
              String sql = "INSERT INTO people (name, age) VALUES (?, ?)";
              jdbcTemplate.update(sql, item.getName(), item.getAge());
          }
      }
      

BatchConfigTest.java ファイルの紹介

BatchConfigTest.java ファイルは、JUnit を使用してテストを行うクラスであり、Spring Batch のジョブ設定をテストするために使用されます。

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

1. 他のクラスとインターフェースの参照。

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

   • Assert クラス：テスト結果をアサートするために使用されます。
   • Test アノテーション：テストメソッドをマークするために使用されます。
   • RunWith アノテーション：テストランナーを指定するために使用されます。
   • Job インターフェース：バッチジョブを表します。
   • JobExecution クラス：バッチジョブの実行を表すために使用されます。
   • JobParameters クラス：バッチジョブのパラメータを表すために使用されます。
   • JobParametersBuilder クラス：バッチジョブのパラメータを構築するために使用されます。
   • JobLauncher インターフェース：バッチジョブを起動するために使用されます。
   • Autowired アノテーション：依存関係の注入を行うために使用されます。
   • SpringBootTest アノテーション：テストクラスを Spring Boot テストとして指定するために使用されます。
   • SpringRunner クラス：テストランナーを SpringRunner に指定するために使用されます。

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

   import org.junit.Assert;
   import org.junit.jupiter.api.Test;
   import org.junit.runner.RunWith;
   import org.springframework.batch.core.Job;
   import org.springframework.batch.core.JobExecution;
   import org.springframework.batch.core.JobParameters;
   import org.springframework.batch.core.JobParametersBuilder;
   import org.springframework.batch.core.launch.JobLauncher;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.test.context.SpringBootTest;
   import org.springframework.test.context.junit4.SpringRunner;
   
   import javax.batch.runtime.BatchStatus;
   import java.util.UUID;
   

2. BatchConfigTest クラスの定義。

   SpringBootTest アノテーションと SpringRunner ランナーを使用することで、Spring Boot の統合テストを行うことができます。testJob メソッドでは、JobLauncherTestUtils 補助クラスを使用してバッチジョブを起動し、アサーションを使用してジョブの実行状態を検証します。

   1. @Autowired アノテーションを使用して JobLauncherTestUtils インスタンスを自動的に注入します。

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

      @Autowired
      private JobLauncherTestUtils jobLauncherTestUtils;
      

   2. @Test アノテーションを使用して testJob メソッドをテストメソッドとしてマークします。このメソッドでは、まず JobParameters オブジェクトを作成し、次に jobLauncherTestUtils.launchJob メソッドを使用してバッチジョブを起動し、Assert.assertEquals メソッドを使用してジョブの実行状態が COMPLETED であることをアサートします。

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

      @Test
      public void testJob() throws Exception {
          JobParameters jobParameters = new JobParametersBuilder()
                  .addString("jobParam", "paramValue")
                  .toJobParameters();
      
          JobExecution jobExecution = jobLauncherTestUtils.launchJob(jobParameters);
      
          Assert.assertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());
      }
      

   3. @Autowired アノテーションを使用して JobLauncher インスタンスを自動的に注入します。

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

      @Autowired
      private JobLauncher jobLauncher;
      

   4. @Autowired アノテーションを使用して Job インスタンスを自動的に注入します。

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

      @Autowired
      private Job job;
      

   5. バッチジョブの起動を補助するために、JobLauncherTestUtils という名前の内部クラスを定義します。このクラスでは、バッチジョブを起動するための launchJob メソッドを定義しています。このメソッドでは、jobLauncher.run メソッドを使用してジョブを起動し、ジョブの実行結果を返します。

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

      private class JobLauncherTestUtils {
          public JobExecution launchJob(JobParameters jobParameters) throws Exception {
              return jobLauncher.run(job, jobParameters);
          }
      }
      

AddPeopleDescProcessorTest.java ファイルの紹介

AddPeopleDescProcessorTest.java ファイルは、JUnit を使用してテストを行うクラスであり、Spring Batch のジョブ設定をテストするために使用されます。

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

1. 他のクラスとインターフェースの参照。

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

   • People クラス：データベースから読み取った人物情報を格納するために使用されます。
   • PeopleDESC クラス：人物情報を変換または処理した後の説明情報を格納するために使用されます。
   • Assert クラス：テストにおける期待される結果と実際の結果が一致するかどうかを検証するために使用されます。
   • Test アノテーション：テストメソッドをマークするために使用されます。
   • RunWith アノテーション：テストランナーを指定するために使用されます。
   • Autowired アノテーション：依存関係の注入を行うために使用されます。
   • SpringBootTest アノテーション：テストクラスを Spring Boot テストとして指定するために使用されます。
   • SpringRunner クラス：テストランナーを SpringRunner に指定するために使用されます。

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

   import com.oceanbase.example.batch.model.People;
   import com.oceanbase.example.batch.model.PeopleDESC;
   import org.junit.Assert;
   import org.junit.jupiter.api.Test;
   import org.junit.runner.RunWith;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.test.context.SpringBootTest;
   import org.springframework.test.context.junit4.SpringRunner;
   

2. AddPeopleDescProcessorTest クラスの定義。

   SpringBootTest アノテーションと SpringRunner ランナーを使用することで、Spring Boot の統合テストを行います。

   1. @Autowired アノテーションを使用して AddPeopleDescProcessor インスタンスを自動的に注入します。

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

      @Autowired
      private AddPeopleDescProcessor processor;
      

   2. @Test アノテーションを使用して testProcess メソッドをテストメソッドとしてマークします。このメソッドでは、まず People オブジェクトを作成し、次に processor.process メソッドを使用してそのオブジェクトを処理し、結果を PeopleDESC オブジェクトに割り当てます。

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

      @Test
      public void testProcess() throws Exception {
      People people = new People();
      people.setName("John");
      people.setAge(25);
      
      PeopleDESC desc = processor.process(people);
      }
      

AddDescPeopleWriterTest.java ファイルの紹介

AddDescPeopleWriterTest.java ファイルは、JUnit を使用してテストを行うクラスであり、AddDescPeopleWriter の書き込みロジックをテストするために使用されます。

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

1. 他のクラスとインターフェースの参照。

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

   • PeopleDESC クラス：人物情報を変換または処理した後の説明情報を格納するために使用されます。
   • Assert クラス：テスト結果をアサートするために使用されます。
   • Test アノテーション：テストメソッドをマークするために使用されます。
   • RunWith アノテーション：テストランナーを指定するために使用されます。
   • Autowired アノテーション：依存関係の注入を行うために使用されます。
   • SpringBootTest アノテーション：テストクラスを Spring Boot テストとして指定するために使用されます。
   • JdbcTemplate クラス：SQL 文を実行するメソッドを提供します。
   • SpringRunner クラス：テストランナーを SpringRunner に指定するために使用されます。
   • ArrayList クラス：空のリストを作成するために使用されます。
   • List インターフェース：クエリ結果セットを操作するために使用されます。

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

   import com.oceanbase.example.batch.model.PeopleDESC;
   import org.junit.Assert;
   import org.junit.jupiter.api.Test;
   import org.junit.runner.RunWith;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.test.context.SpringBootTest;
   import org.springframework.jdbc.core.JdbcTemplate;
   import org.springframework.test.context.junit4.SpringRunner;
   
   import java.util.ArrayList;
   import java.util.List;
   

2. AddDescPeopleWriterTest クラスの定義。

   SpringBootTest アノテーションと SpringRunner ランナーを使用することで、Spring Boot の統合テストを行います。

   1. @Autowired を使用してインスタンスを注入します。 @Autowired アノテーションを使用して AddPeopleDescProcessor および JdbcTemplate インスタンスを自動的に注入します。

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

      @Autowired
      private AddDescPeopleWriter writer;
      @Autowired
      private JdbcTemplate jdbcTemplate;
      

   2. @Test を使用してデータの挿入と出力をテストします。 @Test アノテーションを使用して testWrite メソッドをテストメソッドとしてマークします。このメソッドでは、まず空の peopleDescList リストを作成し、リストに 2 つの PeopleDESC オブジェクトを追加します。次に writer.write メソッドを使用してリスト内のデータをデータベースに書き込みます。続いて jdbcTemplate を使用してクエリ文を実行し、people_desc テーブルのデータを取得し、アサーション文を使用してデータの正確性を検証します。最後に、クエリ結果をコンソールに出力し、ジョブの実行が完了したという情報を出力します。

      1. people_desc テーブルにデータを挿入します。 まず、空の PeopleDESC オブジェクトリスト peopleDescList を作成します。次に、2 つの PeopleDESC オブジェクト desc1 と desc2 を作成し、それぞれのプロパティ値を設定します。desc1 と desc2 を peopleDescList リストに追加します。続いて writer の write メソッドを呼び出し、peopleDescList 内のオブジェクトをデータベースの people_desc テーブルに書き込みます。その後、JdbcTemplate を使用してクエリ文 SELECT COUNT(*) FROM people_desc を実行し、people_desc テーブルのレコード数を取得して、結果を変数 count に割り当てます。最後に Assert.assertEquals メソッドを使用してアサートを行い、count の値が 2 に等しいかどうかを検証します。

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

            List<PeopleDESC> peopleDescList = new ArrayList<>();
            PeopleDESC desc1 = new PeopleDESC();
            desc1.setId(1);
            desc1.setName("John");
            desc1.setAge(25);
            desc1.setDesc("This is John with age 25");
            peopleDescList.add(desc1);
            PeopleDESC desc2 = new PeopleDESC();
            desc2.setId(2);
            desc2.setName("Alice");
            desc2.setAge(30);
            desc2.setDesc("This is Alice with age 30");
            peopleDescList.add(desc2);
            writer.write(peopleDescList);
         
            String selectSql = "SELECT COUNT(*) FROM people_desc";
            int count = jdbcTemplate.queryForObject(selectSql, Integer.class);
            Assert.assertEquals(2, count);
         

      2. people_desc テーブルのデータを出力します。 まず、JdbcTemplate を使用してクエリ文 SELECT * FROM people_desc を実行し、lambda 式を使用してクエリ結果を処理します。lambda 式では、rs.getInt、rs.getString などのメソッドを使用してクエリ結果セットのフィールド値を取得し、そのフィールド値を新しく作成した PeopleDESC オブジェクトに設定します。新しく作成した各 PeopleDESC オブジェクトを結果リスト resultDesc に追加します。その後、プロンプトメッセージ people_desc 表中的数据： を 1 行出力し、for ループを使用して resultDesc リスト内の各 PeopleDESC オブジェクトを反復処理し、System.out.println を使用して各オブジェクトの内容を出力します。最後に、ジョブの実行が完了したという情報を出力します。

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

         List<PeopleDESC> resultDesc = jdbcTemplate.query("SELECT * FROM people_desc", (rs, rowNum) -> {
            PeopleDESC desc = new PeopleDESC();
            desc.setId(rs.getInt("id"));
            desc.setName(rs.getString("name"));
            desc.setAge(rs.getInt("age"));
            desc.setDesc(rs.getString("description"));
            return desc;
         });
         
         System.out.println("people_desc 表中的数据：");
         for (PeopleDESC desc : resultDesc) {
            System.out.println(desc);
         }
         
         // 输出作业执行完成后的信息
         System.out.println("Batch Job execution completed.");
         

AddPeopleWriterTest.java ファイルの紹介

AddPeopleWriterTest.java ファイルは、JUnit を使用してテストを行うクラスであり、AddPeopleWriterTest の書き込みロジックをテストするために使用されます。

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

1. 他のクラスとインターフェースの参照。

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

   • People クラス：データベースから読み取った人物情報を格納するために使用されます。
   • Test アノテーション：テストメソッドをマークするために使用されます。
   • RunWith アノテーション：テストランナーを指定するために使用されます。
   • Autowired アノテーション：依存関係の注入を行うために使用されます。
   • SpringBootApplication アノテーション：このクラスを Spring Boot アプリケーションのエントリとしてマークするために使用されます。
   • SpringBootTest アノテーション：テストクラスを Spring Boot テストとして指定するために使用されます。
   • ComponentScan アノテーション：コンポーネントスキャンを行うパッケージまたはクラスを指定するために使用されます。
   • JdbcTemplate クラス：SQL 文を実行するメソッドを提供します。
   • SpringRunner クラス：テストランナーを SpringRunner に指定するために使用されます。
   • ArrayList クラス：空のリストを作成するために使用されます。
   • List インターフェース：クエリ結果セットを操作するために使用されます。

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

   import com.oceanbase.example.batch.model.People;
   import org.junit.jupiter.api.Test;
   import org.junit.runner.RunWith;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.boot.test.context.SpringBootTest;
   import org.springframework.context.annotation.ComponentScan;
   import org.springframework.jdbc.core.JdbcTemplate;
   import org.springframework.test.context.junit4.SpringRunner;
   
   import java.util.ArrayList;
   import java.util.List;
   

2. AddPeopleWriterTest クラスの定義。

   SpringBootTest アノテーションと SpringRunner ランナーを使用することで、Spring Boot の統合テストを行い、@ComponentScan アノテーションを使用してスキャンするパッケージパスを指定します。

   1. @Autowired を使用してインスタンスを注入します。 @Autowired アノテーションを使用して addPeopleWriter および JdbcTemplate インスタンスを自動的に注入します。

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

      @Autowired
      private AddPeopleWriter addPeopleWriter;
      @Autowired
      private JdbcTemplate jdbcTemplate;
      

   2. @Test を使用してデータの挿入と出力をテストします。

      1. people テーブルにデータを挿入します。 まず、空の People オブジェクトリスト peopleList を作成します。次に、2 つの People オブジェクト person1 と person2 を作成し、それらの名前と年齢プロパティを設定します。続いて、これら 2 つの People オブジェクトを peopleList リストに追加します。その後、addPeopleWriter の write メソッドを呼び出し、peopleList をパラメータとしてこのメソッドに渡し、これらの People オブジェクトをデータベースに書き込みます。

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

            List<People> peopleList = new ArrayList<>();
            People person1 = new People();
            person1.setName("zhangsan");
            person1.setAge(27);
            peopleList.add(person1);
            People person2 = new People();
            person2.setName("lisi");
            person2.setAge(35);
            peopleList.add(person2);
            addPeopleWriter.write(peopleList);
         

      2. people テーブルのデータを出力します。 まず、JdbcTemplate を使用してクエリ文 SELECT * FROM people を実行し、lambda 式を使用してクエリ結果を処理します。lambda 式では、rs.getString および rs.getInt メソッドを使用してクエリ結果セットのフィールド値を取得し、そのフィールド値を新しく作成した People オブジェクトに設定します。新しく作成した各 People オブジェクトを結果リスト result に追加します。次に、プロンプトメッセージ people 表中的数据： を 1 行出力し、for ループを使用して result リスト内の各 People オブジェクトを反復処理し、System.out.println を使用して各オブジェクトの内容を出力します。最後に、ジョブの実行が完了したという情報を出力します。

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

            List<People> result = jdbcTemplate.query("SELECT * FROM people", (rs, rowNum) -> {
                People person = new People();
                person.setName(rs.getString("name"));
                person.setAge(rs.getInt("age"));
                return person;
            });
         
            System.out.println("people 表中的数据：");
            for (People person : result) {
                System.out.println(person);
            }
         
            // 输出作业执行完成后的信息
            System.out.println("Batch Job execution completed.");
         

完全なコードの表示

::: tab pom.xml

<?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.11</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.oceanbase</groupId>
    <artifactId>java-oceanbase-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>java-oceanbase-springbatch</name>
    <description>Demo project for Spring Batch</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.oceanbase</groupId>
            <artifactId>oceanbase-client</artifactId>
            <version>2.4.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>javax.activation-api</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>jakarta.persistence</groupId>
            <artifactId>jakarta.persistence-api</artifactId>
            <version>2.2.3</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

tab application.properties

#configuration database

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://host:port/schema_name?characterEncoding=utf-8
spring.datasource.username=user_name
spring.datasource.password=

# JPA
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

# Spring Batch
spring.batch.job.enabled=false

#
logging.level.org.springframework=INFO
logging.level.com.example=DEBUG

tab BatchApplication.java

package com.oceanbase.example.batch;

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

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

    public void runBatchJob() {
    }
}

tab BatchConfig.java

package com.oceanbase.example.batch.config;

import com.oceanbase.example.batch.model.People;
import com.oceanbase.example.batch.model.PeopleDESC;
import com.oceanbase.example.batch.processor.AddPeopleDescProcessor;
import com.oceanbase.example.batch.writer.AddDescPeopleWriter;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.