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

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

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

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

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

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

│  pom.xml
│
├─.idea
│
├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─oceanbase
│  │  │          └─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

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

 <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.7.11</version>
     <relativePath/>
 </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>

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

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

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

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

    ```xml
        <dependency>
        <groupId>com.oceanbase</groupId>
        <artifactId>oceanbase-client</artifactId>

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

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

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

    ```xml
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>

    ```xml
    <dependency>
        <groupId>javax.activation</groupId>
        <artifactId>javax.activation-api</artifactId>

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

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

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

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

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

```java

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

        public void runBatchJob() {
        }
        }
```

* `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` インターフェース：データベース接続を表すために使用されます。

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

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

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

    ```java
    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Autowired
    private DataSource dataSource;
    ```

  * `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` を構築して返します。

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

    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
        }

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

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

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

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

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

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

    ```java
    @Autowired

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

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

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

    ```java
    @Autowired

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

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

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

    ```java
    @Autowired

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

    ```java
    @Autowired

    ```java
    @Autowired

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

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

```java
import com.oceanbase.example.batch.model.People;
import com.oceanbase.example.batch.model.PeopleDESC;

    ```java
    @Autowired

    ```java
    @Test

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

```java
import com.oceanbase.example.batch.model.PeopleDESC;

import java.util.ArrayList;

    ```java
    @Autowired

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

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

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

```java
import com.oceanbase.example.batch.model.People;

import java.util.ArrayList;

    ```java
    @Autowired

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

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

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

<build>
    <plugins>
        <plugin>

```

#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

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.