SpringBatchでOceanBase Cloudに接続するサンプルプログラム|OceanBase Cloud|ドキュメント|OceanBaseマニュアル

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

      クリックしてjava-oceanbase-springbatchサンプルプロジェクトをダウンロード
  </a>
  <!-- <a role='video' href='https://obbusiness-private.oss-cn-shanghai.aliyuncs.com/video-center/video/video/07%20java-ob-springbatch_e07.mp4'>
      
      SpringBatchでOceanBaseデータベースに接続するサンプルプログラム（Oracleモード）
  </a> -->

前提条件

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

説明

このドキュメントでコードを実行するために使用したツールはIntelliJ IDEA 2021.3.2 (Community Edition)です。個人の好みに応じて、適切なツールを選択してサンプルコードを実行することもできます。

操作手順

説明

本記事で示す操作手順は、Windows環境に基づいています。他のOS環境やコンパイラを使用している場合は、操作手順が若干異なる場合があります。

OceanBase Cloudの接続文字列を取得します。
java-oceanbase-springbatch プロジェクトをIDEAにインポートします。
java-oceanbase-springbatch プロジェクトのデータベース接続情報を修正します。
java-oceanbase-springbatch プロジェクトを実行します。

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

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

詳細な操作については、接続文字列の取得をご参照ください。
作成済みのOceanBase Cloudに基づいて、以下のURLに対応する情報を入力します。

OceanBase CloudのOracleモードへの接続URL例：
```
jdbc:oceanbase://$host:$port/$schema_name?user=$user_name&password=$password
```
パラメータ説明：
- $host：OceanBase Cloudの接続アドレスを指定します。例：t********.********.oceanbase.cloud
- $port：OceanBase Cloudの接続ポートを指定します。デフォルトは1521です。
- $schema_name：アクセスするスキーマ名です。
- $user_name：データベースにアクセスするアカウントを指定します。
- $password：アカウントのパスワードを指定します。
URLパラメータの詳細については、データベースURLをご参照ください。

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

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

説明

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

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

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

例：

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

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

spring.datasource.driver-class-name=com.oceanbase.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://t5******.********.oceanbase.cloud:1521/sys?characterEncoding=utf-8
spring.datasource.username=oracle001
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 から AddPeopleWriterTest.java ファイルを見つけます。
2. ツールメニューバーで Run > Run... > AddPeopleWriterTest.testWrite を選択するか、右上の 緑色の三角形 を直接クリックして実行します。
3. IDEAのコンソールでプロジェクトのログ情報と出力結果を確認します。
```
people テーブルのデータ：
People [name=zhangsan, age=27]
People [name=lisi, age=35]
Batch Job execution completed.
```

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

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: Javaパッケージのルートディレクトリ。
oceanbase: プロジェクトのルートディレクトリ。
example: プロジェクトのルートディレクトリ。
batch: プロジェクトのメインパッケージ名。
BatchApplication.java：アプリケーションのエントリクラスで、mainメソッドが含まれます。
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 ファイルを変更することもできます。

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

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

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

コード：
```
<?xml version="1.0" encoding="UTF-8"?>
```
POMの名前空間とPOMモデルバージョンを設定します。
xmlns を使用して、POMの名前空間を http://maven.apache.org/POM/4.0.0 に指定します。
xmlns:xsi を使用して、XMLの名前空間を http://www.w3.org/2001/XMLSchema-instance に指定します。
xsi:schemaLocation を使用して、POM の名前空間を http://maven.apache.org/POM/4.0.0、POM の XSD ファイルの場所を https://maven.apache.org/xsd/maven-4.0.0.xsd に指定します。
<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>

親要素情報を設定します。
<groupId> を使用して、親要素の識別子を org.springframework.boot と指定します。
<artifactId> を使用して、親要素の依存関係を spring-boot-starter-parent と指定します。
<version> を使用して、親要素のバージョン番号を 2.7.11 と指定します。
relativePath を使用して、親要素のパスが空であることを示します。

コード：

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

基本情報を設定します。
<groupId> を使用して、プロジェクト識別子を com.oceanbase と指定します。
<artifactId> を使用して、プロジェクトの依存関係を java-oceanbase-springboot と指定します。
<version> を使用して、プロジェクトのバージョン番号を 0.0.1-SNAPSHOT と指定します。
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>

Javaバージョンの設定

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

コード：
```
  <properties>
      <java.version>1.8</java.version>
  </properties>
```
コア依存関係の設定
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.3に指定します。この依存関係により、OceanBaseが提供するクライアント機能（接続、クエリ、トランザクションなど）を利用できます。
  
  コード：
```
    <dependency>
        <groupId>com.oceanbase</groupId>
        <artifactId>oceanbase-client</artifactId>
        <version>2.4.3</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>
```
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に関する設定、およびログレベルの設定も含まれています。

データベース接続の設定。
- spring.datasource.driver を使用して、データベースドライバーを com.oceanbase.jdbc.Driver と指定します。これはOceanBase Cloudとの接続を確立するために使用されます。
- spring.datasource.url を使用して、データベース接続用のURLを指定します。
- spring.datasource.username を使用して、データベース接続用のユーザー名を指定します。
- spring.datasource.password を使用して、データベース接続用のパスワードを指定します。
コード：
```
spring.datasource.driver-class-name=com.oceanbase.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 を使用して、ログにSQLステートメントを表示するかどうかを指定します。true に設定するとSQLステートメントが表示されます。
- spring.jpa.hibernate.ddl-auto を使用して、HibernateのDDL操作動作を指定します。ここでは update に設定しており、アプリケーション起動時にデータベース構造を自動的に更新します。
コード：
```
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
```
Spring Batchの設定：

spring.batch.job.enabled を使用して、Spring Batchジョブを有効にするかどうかを指定します。ここでは false に設定し、Spring Batchジョブを無効にします。

コード：
```
spring.batch.job.enabled=false
```
ログの設定：
- 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 ファイルのコードは、主に以下の部分で構成されています：

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

このファイルには以下のインターフェースとクラスが含まれていることを宣言します：
- SpringApplication クラス：Spring Bootアプリケーションを起動するために使用されます。
- SpringBootApplication アノテーション：このクラスをSpring Bootアプリケーションのエントリーとしてマークするために使用されます。
コード：
```
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
```
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 ファイルのコードは、主に以下の部分で構成されています：

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

このファイルには以下のインターフェースとクラスが含まれていることを宣言します：
- 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;
```
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 ファイルは、ItemProcessor インターフェースを実装する AddPeopleDescProcessor というクラスを定義しており、People オブジェクトを PeopleDESC オブジェクトに変換するために使用されます。

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

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

このファイルには以下のインターフェースとクラスが含まれていることを宣言します：
- People クラス：データベースから読み取った人員情報を格納するために使用されます。
- PeopleDESC クラス：人員情報を変換または処理した後の説明情報を格納するために使用されます。
- ItemProcessor インターフェース：読み取ったアイテムを処理または変換するために使用されます。
コード：
```
import com.oceanbase.example.batch.model.People;
import com.oceanbase.example.batch.model.PeopleDESC;
import org.springframework.batch.item.ItemProcessor;
```
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 ファイルのコードは、主に以下の部分で構成されています：

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

このファイルには以下のインターフェースとクラスが含まれていることを宣言します：
- 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;
```
AddDescPeopleWriter クラスの定義。
1. @Autowired アノテーションを使用して JdbcTemplate インスタンスを自動注入し、データ書き込み時にこのインスタンスを使用してデータベース操作を実行します。
  
  コード：
```
    @Autowired
    private JdbcTemplate jdbcTemplate;
```
2. write メソッド内で、渡された List<? extends PeopleDESC> を走査し、各 PeopleDESC オブジェクトを順次取り出します。まず、既存の people_desc テーブルを削除するために、SQL ステートメント DROP TABLE people_desc を実行します。次に、id、name、age、description の4列を含む people_desc テーブルを作成するために、SQL ステートメント CREATE TABLE people_desc (id INT PRIMARY KEY, name VARCHAR2(255), age INT, description VARCHAR2(255)) を実行します。その後、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 ファイルのコードは、主に以下の部分で構成されています：

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

このファイルには以下のインターフェースとクラスが含まれていることを宣言します：
- 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;
```
AddPeopleWriter クラスの定義。
1. @Autowired アノテーションを使用して JdbcTemplate インスタンスを自動注入し、データ書き込み時にこのインスタンスを使用してデータベース操作を実行します。
  
  コード：
```
    @Autowired
    private JdbcTemplate jdbcTemplate;
```
2. write メソッドでは、渡された List<? extends People> を走査し、各 People オブジェクトを順次取り出します。まず、既存の people テーブルを削除するために、SQL ステートメント DROP TABLE people を実行します。次に、name と age の2つの列を含む people テーブルを作成するために、SQL ステートメント CREATE TABLE people (name VARCHAR2(255), age INT) を実行します。その後、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 ファイルのコードは、主に以下の部分で構成されています：

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

このファイルには以下のインターフェースとクラスが含まれていることを宣言します：
- 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;
```
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 ファイルのコードは、主に以下の部分で構成されています：

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

このファイルには以下のインターフェースとクラスが含まれていることを宣言します：
- People クラス：データベースから読み取った人員情報を格納するために使用されます。
- PeopleDESC クラス：人員情報を変換または処理した後の説明情報を格納するために使用されます。
- 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.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;
```
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();
    PeopleDESC desc = processor.process(people);
}
```

AddDescPeopleWriterTest.javaファイルの紹介

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

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

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

このファイルには以下のインターフェースとクラスが含まれていることを宣言します：
- 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;
```
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 テーブル内のデータ： という一行のプロンプトメッセージを出力し、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 ファイルのコードは、主に以下の部分で構成されています：

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

このファイルには以下のインターフェースとクラスが含まれていることを宣言します：
- 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;
```
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 テーブル内のデータ： という一行のメッセージを出力します。その後、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.");
```

全コード表示

pom.xml

application.properties

BatchApplication.java

BatchConfig.java

People.java

PeopleDESC.java

AddPeopleDescProcessor.java

AddDescPeopleWriter.java

AddPeopleWriter.java

BatchConfigTest.java

AddPeopleDescProcessorTest.java

AddDescPeopleWriterTest.java

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

#configuration database

spring.datasource.driver-class-name=com.oceanbase.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

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() {
    }
}

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.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;
//import javax.activation.DataSource;

@Configuration
@EnableBatchProcessing
@SpringBootApplication
@ComponentScan("com.oceanbase.example.batch.writer")
@EnableAutoConfiguration
public class BatchConfig {
    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    .Autowired
    private StepBuilderFactory stepBuilderFactory;

    .Autowired
    private DataSource dataSource;// Spring Bootの自動設定で提供されるデフォルトのdataSourceを使用する

    @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();
    }
}

package com.oceanbase.example.batch.model;

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
}

package com.oceanbase.example.batch.model;

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 + "]";
    }
}

package com.oceanbase.example.batch.processor;

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

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

package com.oceanbase.example.batch.writer;

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;

public class AddDescPeopleWriter implements ItemWriter<PeopleDESC> {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @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());
        }
    }
}

package com.oceanbase.example.batch.writer;

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;

@Component
public class AddPeopleWriter implements ItemWriter<People> {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @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());
        }
    }
}

package com.oceanbase.example.batch.config;

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;

@RunWith(SpringRunner.class)
@SpringBootTest
public class BatchConfigTest {
    @Autowired
    private JobLauncherTestUtils jobLauncherTestUtils;

    @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());
    }

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private Job job;

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

package com.oceanbase.example.batch.processor;

import com.oceanbase.example.batch.model.People;
import com.oceanbase.example.batch.model.PeopleDESC;
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;

@RunWith(SpringRunner.class)
@SpringBootTest
public class AddPeopleDescProcessorTest {
    @Autowired
    private AddPeopleDescProcessor processor;

    @Test
    public void testProcess() throws Exception {
        People people = new People();
  //      people.setName("John");
  //      people.setAge(25);

        PeopleDESC desc = processor.process(people);

//      Assert.assertEquals("John", desc.getName());
//        Assert.assertEquals(25, desc.getAge());
 //       Assert.assertEquals("This is John with age 25", desc.getDesc());
    }
}

package com.oceanbase.example.batch.writer;

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;

@RunWith(SpringRunner.class)
@SpringBootTest
public class AddDescPeopleWriterTest {
    @Autowired
    private AddDescPeopleWriter writer;
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    public void testWrite() throws Exception {

        // people_descテーブルにデータを挿入
        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);

        // people_descテーブルのデータを出力
        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.");
    }
}

package com.oceanbase.example.batch.writer;

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;

@RunWith(SpringRunner.class)
@SpringBootTest
@SpringBootApplication
@ComponentScan("com.oceanbase.example.batch.writer")
public class AddPeopleWriterTest {

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

    @Test
    public void testWrite() throws Exception {
        // 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);

        // クエリして結果を出力
        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.");
    }
}

前提条件

説明

操作手順

説明

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

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

説明

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

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

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

pom.xmlコードの紹介

説明

application.propertiesファイルの紹介

BatchApplication.javaファイルの紹介

BatchConfig.javaファイルの紹介

People.javaファイルの紹介

PeopleDESC.javaファイルの紹介

AddPeopleDescProcessor.javaファイルの紹介

AddDescPeopleWriter.javaファイルの紹介

AddPeopleWriter.javaファイルの紹介

BatchConfigTest.javaファイルの紹介

AddPeopleDescProcessorTest.javaファイルの紹介

AddDescPeopleWriterTest.javaファイルの紹介

AddPeopleWriterTest.javaファイルの紹介

全コード表示

関連ドキュメント

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

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

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