Connect to OceanBase Database by using SpringBatch|V4.3.5|OceanBase Database| docs|Distributed Database

This topic introduces how to build an application by using the SpringBatch framework and OceanBase Database. It also covers the use of the application for fundamental database operations, including table creation, data insertion, data query, and other basic operations.

Download the java-oceanbase-springbatch sample project

Prerequisites

You have installed OceanBase Database.
You have installed JDK 1.8 and Maven.
You have installed IntelliJ IDEA.

Note

The tool used to run the sample code in this topic is IntelliJ IDEA 2021.3.2 (Community Edition). You can also choose a tool of your preference to run the sample code.

Procedure

Note

The steps outlined in this topic are for the Windows environment. If you are using a different operating system or compiler, the steps may vary slightly.

Obtain the connection string of OceanBase Database.
Import the java-oceanbase-springbatch project into IntelliJ IDEA.
Modify the database connection information in the java-oceanbase-springbatch project.
Run the java-oceanbase-springbatch project.

Step 1: Obtain the connection string of OceanBase Database

Contact the deployment personnel or administrator of OceanBase Database to obtain the corresponding database connection string.
```
obclient -hxx.xx.xx.xx -P2883 -uroot@sys#cluster -p**** -A
```
Fill in the URL below based on the OceanBase Database that has been deployed.

Note

The URL is required in the application.properties file.
```
jdbc:oceanbase://host:port/schema_name?user=$user_name&password=$password&characterEncoding=utf-8
```
Parameter description:
- host: the IP address for connecting to OceanBase Database. For connection through ODP, use the IP address of an ODP. For direct connection, use the IP address of an OBServer node.
- port: the port for connecting to OceanBase Database. For connection through ODP, the default value is 2883, which can be customized when ODP is deployed. For direct connection, the default value is 2881, which can be customized when OceanBase Database is deployed.
- schema_name: the name of the schema to be accessed.
- user_name: the username specified after the -u parameter. The value of the username is in the format of username@tenant name#cluster name or username@SERVICE:service name. When you use the format username@tenant name#cluster name, the default tenant is sys and the default administrator is root. The cluster name can be omitted when you connect directly to the database, but it is required when you connect through ODP.
- password: the password of the account.
- characterEncoding: the character encoding.

For more information about URL parameters, see Database URL.

Step 2: Import the `java-oceanbase-springbatch` project into IntelliJ IDEA

Start IntelliJ IDEA and choose File > Open....
In the Open File or Project window, select the project files and click OK to import the files.
IntelliJ IDEA automatically recognizes the files and displays the directory structure, file list, module list, dependency relationships, and other details of the project in the Project window. The Project window is usually positioned on the left side of the IntelliJ IDEA interface and is generally open by default. If the Project window is closed, you can reopen it by choosing View > Tool Windows > Project in the menu bar or by using the shortcut Alt + 1.

Note

When you import a project using IntelliJ IDEA, it will automatically detect the pom.xml file in the project, download the required dependency libraries based on the described dependencies in the file, and add them to the project.
View the project.

springbatch

Step 3: Modify the database connection information in the `java-oceanbase-springbatch` project

Modify the database connection information in the application.properties file based on the information obtained in Step 1: Obtain the connection string of OceanBase Database.

Here is an example:

The name of the database driver is: com.mysql.cj.jdbc.Driver.
The IP address of the OBServer node is 10.10.10.1.
The port is 2881.
The name of the database to be accessed is test.
The tenant account is root@mysql001, where mysql001 is a MySQL user tenant created in OceanBase Database, and root is the username of the mysql001 tenant.
The password is ******.

Sample code:

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://10.10.10.1:2881/test?characterEncoding=utf-8
spring.datasource.username=root@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

Step 4: Run the `java-oceanbase-springbatch` project

Run the AddDescPeopleWriterTest.java file.
1. In the project structure, locate the AddDescPeopleWriterTest.java file under src > test > java.
2. In the toolbar, choose Run > Run... > AddDescPeopleWriterTest.testWrite or simply click the green triangle in the upper-right corner to run it.
3. In the console of IDEA, view the project logs and output results.
```
Data in the people_desc table:
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.
```
Run the AddPeopleWriterTest.java file.
1. In the project structure, locate the AddPeopleWriterTest.java file under src > test > java.
2. In the toolbar, choose Run > Run... > AddPeopleWriterTest.testWrite or simply click the green triangle in the upper-right corner to run it.
3. In the console of IDEA, view the project logs and output results.
```
Data in the people table:
People [name=zhangsan, age=27]
People [name=lisi, age=35]
Batch Job execution completed.
```

FAQ

1. Connection timeout

If a connection timeout occurs, you can specify the connection timeout parameter in the JDBC URL:

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

2. Character set

To ensure correct character encoding, set the character set parameter in the JDBC URL:

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

3. SSL connection

To establish an SSL connection with OceanBase Database, add the following parameter to the JDBC URL:

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

4. Special characters in account name or password

If the username or password contains special characters such as #, URL-encode it:

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

Notice

When you use MySQL Connector/J 8.x, make sure that the account name and password do not contain the number sign (#). Otherwise, a connection error may occur.

Project code introduction

Click java-oceanbase-springbatch to download the project code, which is a compressed package named java-oceanbase-springbatch.

After decompressing it, you will find a folder named java-oceanbase-springbatch. The directory structure is as follows:

│  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

File description:

pom.xml: the configuration file of the Maven project, which contains the dependencies, plugins, and build details of the project.
.idea: the directory used by the Integrated Development Environment (IDE) to store project-related configuration information.
src: a directory that is generally used to store the source code of the project.
main: the directory that stores the main source code and resource files.
java: the directory that stores the Java source code.
com.oceanbase.example.batch: the package name.
BatchApplication.java: the entry class of the application, which contains the main method of the application.
config: the folder that stores the configuration classes of the application.
BatchConfig.java: the configuration class of the application, which is used to configure the attributes and behaviors of the application.
model: the folder that stores the model classes of the application.
People.java: the personnel data model class.
PeopleDESC.java: the personnel DESC data model class.
processor: the folder that stores the processor classes of the application.
AddPeopleDescProcessor.java: the processor class that is used to add personnel DESC information.
writer: the folder that stores the writer classes of the application.
AddDescPeopleWriter.java: the writer class that is used to write personnel DESC information.
AddPeopleWriter.java: the writer class that is used to write personnel information.
resources: the resource folder that stores the configuration files and other static resource files of the application.
application.properties: the configuration file of the application, which is used to configure the attributes of the application.
test: the directory that stores the test code and resource files.
BatchConfigTest.java: the test class of the application configuration class.
AddPeopleDescProcessorTest.java: the test class of the processor for adding personnel DESC information.
AddDescPeopleWriterTest.java: the test class of the writer for writing personnel DESC information.
AddPeopleWriterTest.java: the test class of the writer for writing personnel information.
target: the directory that stores compiled class files and JAR packages.

Introduction to pom.xml

Note

If you just want to verify the sample, you can use the default code without modification. You can also modify the pom.xml file based on your needs.

The content of the pom.xml configuration file is as follows:

Declaration statement.

Declare this file to be an XML file that uses XML version 1.0 and character encoding UTF-8.

Sample code:
```
<?xml version="1.0" encoding="UTF-8"?>
```
Configure namespaces and the POM model version.
1. Use xmlns to specify the POM namespace as http://maven.apache.org/POM/4.0.0.
2. Use xmlns:xsi to specify the XML namespace as http://www.w3.org/2001/XMLSchema-instance.
3. Use xsi:schemaLocation to specify the POM namespace as http://maven.apache.org/POM/4.0.0, and the location of the POM XSD file as https://maven.apache.org/xsd/maven-4.0.0.xsd.
4. Use the <modelVersion> element to specify the POM model version used by the POM file as 4.0.0.
Sample code:
```
 <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>
```
Configure the parent information.
1. Use <groupId> to specify the parent identifier as org.springframework.boot.
2. Use <artifactId> to specify the parent dependency as spring-boot-starter-parent.
3. Use <version> to specify the parent version as 2.7.11.
4. Use relativePath to indicate that the parent path is empty.
Sample code:
```
 <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.7.11</version>
     <relativePath/>
 </parent>
```
Configure basic information.
1. Use <groupId> to specify the project identifier as com.oceanbase.
2. Use <artifactId> to specify the project dependency as java-oceanbase-springboot.
3. Use <version> to specify the project version as 0.0.1-SNAPSHOT.
4. Use description to describe the project as Demo project for Spring Batch.
Sample code:
```
 <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>
```
Configure the Java version.

Specify the Java version used by the project as 1.8.

Sample code:
```
  <properties>
      <java.version>1.8</java.version>
  </properties>
```
Configure core dependencies.
1. Specify the group as org.springframework.boot and the name as spring-boot-starter. With this dependency, you can access the component dependencies supported by Spring Boot by default, including Web, data processing, security, and test features.
  
  Sample code:
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
```
2. Specify the group as org.springframework.boot and the name as spring-boot-starter-jdbc. With this dependency, you can access the JDBC features provided by Spring Boot, such as connection pools and data source configurations.
  
  Sample code:
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
```
3. Specify the group as org.springframework.boot, the name as spring-boot-starter-test, and the scope as test. With this dependency, you can access the test framework and tools provided by Spring Boot, such as JUnit, Mockito, and Hamcrest.
  
  Sample code:
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
```
4. Specify the group as com.oceanbase, the name as oceanbase-client, and the version as 2.4.12. With this dependency, you can access the client features provided by OceanBase, such as connection, query, and transaction.
  
  Sample code:
```
    <dependency>
        <groupId>com.oceanbase</groupId>
        <artifactId>oceanbase-client</artifactId>
        <version>2.4.12</version>
    </dependency>
```
5. Specify the group as org.springframework.boot, the name as spring-boot-starter-batch, and the scope as test. With this dependency, you can access the batch processing feature provided by Spring Boot.
  
  Sample code:
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
</dependency>
```
6. Specify the group as org.springframework.boot, the name as spring-boot-starter-data-jpa, and the scope as test. With this dependency, you can access the necessary dependencies and configurations for data access using JPA. Spring Boot Starter Data JPA is a Spring Boot starter.
  
  Sample code:
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
```
7. Specify the group as org.apache.tomcat, the name as tomcat-jdbc, and the scope as test. With this dependency, you can access the JDBC connection pool feature provided by Tomcat, including connection pool configuration, connection acquisition and release, and connection management.
  
  Sample code:
```
<dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-jdbc</artifactId>
</dependency>
```
8. Specify the test architecture as junit, the name as junit, and the version as 4.10, and the scope as test. With this dependency, you can configure JUnit unit test dependencies.
  
  Sample code:
```
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.10</version>
    <scope>test</scope>
</dependency>
```
9. Specify the group as javax.activation, the name as javax.activation-api, and the version as 1.2.0. With this dependency, you can introduce the Java Activation Framework (JAF) library.
  
  Sample code:
```
<dependency>
    <groupId>javax.activation</groupId>
    <artifactId>javax.activation-api</artifactId>
    <version>1.2.0</version>
</dependency>
```
10. Specify the group as jakarta.persistence, the name as jakarta.persistence-api, and the version as 2.2.3. With this dependency, you can configure the Jakarta Persistence API dependency.
  
  Sample code:
```
<dependency>
    <groupId>jakarta.persistence</groupId>
    <artifactId>jakarta.persistence-api</artifactId>
    <version>2.2.3</version>
</dependency>
```
Configure the Maven plugin.

Specify the group as org.springframework.boot and the name as spring-boot-maven-plugin. This plugin is used to package a Spring Boot application into an executable JAR or WAR file.

Sample code:

Introduction to application.properties

The application.properties file is used to configure database connections and other related settings, such as the database driver, connection URL, username, and password. It also includes configurations for Java Persistence API (JPA) and Spring Batch, as well as settings for log levels.

Database connection configuration.
- The spring.datasource.driver parameter is set to com.mysql.cj.jdbc.Driver to connect to OceanBase Database.
- The spring.datasource.url parameter specifies the URL for connecting to the database.
- The spring.datasource.username parameter specifies the username for connecting to the database.
- The spring.datasource.password parameter specifies the password for connecting to the database.
Sample code:
```
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 configuration.
- The spring.jpa.show-sql parameter specifies whether to log SQL statements. If set to true, SQL statements are logged.
- The spring.jpa.hibernate.ddl-auto parameter specifies the DDL operation behavior of Hibernate. Here, it is set to update, indicating that the database schema will be automatically updated when the application starts.
Sample code:
```
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
```
Spring Batch configuration:

The spring.batch.job.enabled parameter specifies whether to enable Spring Batch jobs. Here, it is set to false, indicating that batch processing jobs will not be automatically executed.

Sample code:
```
spring.batch.job.enabled=false
```
Note

In Spring Batch, the spring.batch.job.enabled attribute controls the execution behavior of batch jobs.
- If spring.batch.job.enabled=true (the default value), all defined batch jobs will automatically run when the Spring Boot application starts. This means that Spring Batch will automatically discover and execute all defined jobs upon application startup.
- If spring.batch.job.enabled=false, automatic execution of batch jobs is disabled. This is typically used in development or test environments, or when you want to manually control job execution. If set to false, jobs will not automatically run upon application startup. Instead, you can manually trigger them using other methods such as REST interfaces or command lines.
In summary, setting spring.batch.job.enabled=false helps you avoid automatically running jobs upon application startup, providing greater flexibility over when batch jobs are executed.
Log configuration:
- The logging.level.org.springframework parameter specifies the log level for the Spring framework as INFO.
- The logging.level.com.example parameter specifies the log level for custom application code as DEBUG.
Sample code:
```
logging.level.org.springframework=INFO
logging.level.com.example=DEBUG
```

Introduction to BatchApplication.java

The BatchApplication.java file is the entry file of the Spring Boot application.

The code in the BatchApplication.java file consists of the following parts:

Reference other classes and interfaces.

Declare that the current file contains the following interfaces and classes:
- SpringApplication class: used to start the Spring Boot application.
- SpringBootApplication annotation: used to mark the class as the entry point of the Spring Boot application.
Sample code:
```
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
```
Define the BatchApplication class.

Mark the BatchApplication class with the @SpringBootApplication annotation to indicate that it is the entry point of the Spring Boot application. The BatchApplication class defines a static main method as the entry point of the application. In this method, it uses the SpringApplication.run method to start the Spring Boot application. It also defines a method named runBatchJob to run batch processing jobs.

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

        public void runBatchJob() {
        }
    }
```

Introduction to BatchConfig.java

The BatchConfig.java file is used to configure the components of a batch processing job, such as steps, readers, processors, and writers.

The code in the BatchConfig.java file mainly includes the following sections:

Reference other classes and interfaces.

Declare the current file to contain the following interfaces and classes:
- People class: used to store the personnel information read from the database.
- PeopleDESC class: used to store the description information of the personnel information after conversion or processing.
- AddPeopleDescProcessor class: used to convert the read People object into a PeopleDESC object. This class is the implementation class of the ItemProcessor interface.
- AddDescPeopleWriter class: used to write the PeopleDESC object to the target location. This class is the implementation class of the ItemWriter interface.
- Job interface: represents a batch processing job.
- Step interface: represents a step in a job.
- EnableBatchProcessing annotation: a configuration annotation in Spring Batch for enabling and configuring the Spring Batch processing feature.
- JobBuilderFactory class: used to create and configure jobs.
- StepBuilderFactory class: used to create and configure steps.
- RunIdIncrementer class: the run ID (Run ID) auto-incrementer of Spring Batch. It is used to increase the run ID each time when the job is run.
- ItemProcessor interface: used to process or convert read items.
- ItemReader interface: used to read items from the data source.
- ItemWriter interface: used to write the processed or converted items to a specified target location.
- JdbcCursorItemReader class: used to read data from the database and return a cursor result set.
- Autowired annotation: used for dependency injection.
- Bean annotation: used for creating and configuring beans.
- ComponentScan annotation: used to specify the package or class to be scanned for components.
- Configuration annotation: used to mark a class as a configuration class.
- EnableAutoConfiguration annotation: used to enable the automatic configuration of Spring Boot.
- SpringBootApplication annotation: used to mark a class as the entry of a Spring Boot application.
- DataSource interface: used to represent a database connection.
Sample code:
```
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;
```
Define the BatchConfig class.

This is a simple Spring Batch job. It defines the methods for reading, processing, and writing data, and encapsulates these methods into a job. By using the annotations and automatic configuration feature of Spring Batch, you can create component instances by configuring the @Bean methods in the configuration class, and use these component instances in step1 to read, process, and write data.
- Use @Configuration to indicate that this class is a configuration class.
- Use @EnableBatchProcessing to enable the Spring Batch processing feature. This annotation will automatically create necessary beans such as JobRepository and JobLauncher.
- Use @SpringBootApplication to indicate the main class of a Spring Boot application. It is the startup point of the Spring Boot application.
- Use @ComponentScan to specify the package to be scanned for components. This tells Spring to scan and register all components in this package and its subpackages.
- Use @EnableAutoConfiguration to enable the automatic configuration of the infrastructure of a Spring Boot application.
Sample code:
```
 @Configuration
 @EnableBatchProcessing
 @SpringBootApplication
 @ComponentScan("com.oceanbase.example.batch.writer")
 @EnableAutoConfiguration
 public class BatchConfig {
 }
```
1. Define the @Autowired annotation.
  
  Use the @Autowired annotation to inject JobBuilderFactory, StepBuilderFactory, and DataSource into the member variables of the BatchConfig class. JobBuilderFactory is a factory class for creating and configuring jobs, and StepBuilderFactory is a factory class for creating and configuring steps. DataSource is an interface for obtaining a database connection.
  
  Sample code:
```
@Autowired
private JobBuilderFactory jobBuilderFactory;

@Autowired
private StepBuilderFactory stepBuilderFactory;

@Autowired
private DataSource dataSource;
```
2. Define the @Bean annotation.
  
  Use the @Bean annotation to define several methods for creating the readers, processors, writers, steps, and jobs of a batch processing job.
  - Use the peopleReader method to create an ItemReader component instance. This component reads the People object data from the database by using JdbcCursorItemReader. Set the data source to dataSource, set the RowMapper to map database rows to People objects, and set the SQL query statement to SELECT * FROM people.
  - Use the addPeopleDescProcessor method to create an ItemProcessor component instance. This component processes the People object by using AddPeopleDescProcessor and returns the PeopleDESC object.
  - Use the addDescPeopleWriter method to create an ItemWriter component instance. This component writes the PeopleDESC object to the target location by using AddDescPeopleWriter.
  - Use the step1 method to create a Step component instance. The step is named step1. Use stepBuilderFactory.get to obtain the step builder. Set the reader to the ItemReader component, set the processor to the ItemProcessor component, set the writer to the ItemWriter component, set the chunk size to 10, and then call build to build and return the configured Step.
  - Use the importJob method to create a Job component instance. The job is named importJob. Use jobBuilderFactory.get to obtain the job builder. Set the incrementer to RunIdIncrementer. Set the initial step of the job flow to Step. Then call build to build and return the configured Job.
    
    Sample code:
```
@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 file introduction

The People.java file creates a data model for the People class, representing information about a person. This class contains two private member variables, name and age, along with their corresponding getter and setter methods. The toString method is overridden to print the object's information. The name variable indicates the person's name, and the age variable indicates the person's age. The getter and setter methods are used to obtain and set the values of these attributes.

The purpose of this class is to provide a way to store and transmit data for the input and output of batch jobs. During the read and write operations in batch processing, People objects are used to store data. Data is set using the setter methods and obtained using the getter methods.

Sample code:

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

The PeopleDESC.java file creates a data model for the PeopleDESC class, which is used to represent information about personnel. The PeopleDESC class has four attributes: name, age, desc, and id, which respectively indicate the name, age, description, and identifier of a person. This class contains getter and setter methods for accessing and setting the attribute values. The toString method is overridden to return a string representation of the class, including the name, age, and description.

Similar to the People class, the PeopleDESC class is also used to store and transmit data for the input and output of batch jobs.

Sample code:

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

The AddPeopleDescProcessor.java file defines a class named AddPeopleDescProcessor that implements the ItemProcessor interface. This class is used to convert People objects into PeopleDESC objects.

The code in the AddPeopleDescProcessor.java file is divided into several parts:

Reference other classes and interfaces.

Declare that the current file contains the following interfaces and classes:
- People class: used to store personnel information read from the database.
- PeopleDESC class: used to store descriptive information after the personnel information is converted or processed.
- ItemProcessor interface: used to process or convert read items.
Sample code:
```
import com.oceanbase.example.batch.model.People;
import com.oceanbase.example.batch.model.PeopleDESC;
import org.springframework.batch.item.ItemProcessor;
```
Define the AddPeopleDescProcessor class.

The AddPeopleDescProcessor class that implements the ItemProcessor interface is used to convert People objects into PeopleDESC objects. This implements the logic for processing input data in batch jobs.

In the process method of this class, a PeopleDESC object named desc is created first. Then, the attributes (name and age) of the People object passed in through the item parameter are obtained, and these attributes are set to the desc object. Additionally, the desc attribute of the desc object is also assigned a value. The assignment logic generates a description based on the attributes of the People object. Finally, the processed PeopleDESC object is returned.

Sample code:
```
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;
    }
}
```

Introduction to AddDescPeopleWriter.java

The AddDescPeopleWriter.java file implements the AddDescPeopleWriter class that implements the ItemWriter interface for writing People objects to a database.

The code in the AddDescPeopleWriter.java file consists of the following sections:

Reference other classes and interfaces.

Declare that the current file contains the following interfaces and classes:
- PeopleDESC: a class used to store descriptions after the information of the personnel is converted or processed.
- ItemWriter: an interface used to write processed or converted items to a specified target location.
- Autowired: an annotation used for dependency injection.
- JdbcTemplate: a class that provides methods for executing SQL statements.
- List: an interface used for operating on the query result set.
Sample code:
```
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;
```

Define the AddDescPeopleWriter class.

Use the @Autowired annotation to automatically inject a JdbcTemplate instance, which is used to perform database operations when writing data.

Sample code:
```
    @Autowired
    private JdbcTemplate jdbcTemplate;
```

In the write method, traverse the List<? extends PeopleDESC> that is passed in, and sequentially obtain each PeopleDESC object. First, execute the SQL statement DROP TABLE people_desc to delete a table named people_desc if it exists. Then, execute the SQL statement CREATE TABLE people_desc (id INT PRIMARY KEY, name VARCHAR2(255), age INT, description VARCHAR2(255)) to create a table named people_desc with four columns: id, name, age, and description. Next, use the SQL statement INSERT INTO people_desc (id, name, age, description) VALUES (?, ?, ?, ?) to insert the attribute values of each PeopleDESC object into the people_desc table.

Sample code:

    @Override
    public void write(List<? extends PeopleDESC> items) throws Exception {
        // Drop the table if it exists.
        jdbcTemplate.execute("DROP TABLE people_desc");
        // Statement for creating the table.
        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());
        }
    }

Introduction to AddPeopleWriter.java

The AddPeopleWriter.java file implements the AddDescPeopleWriter class that implements the ItemWriter interface for writing PeopleDESC objects to the database.

The code in the AddPeopleWriter.java file consists of the following sections:

Reference other classes and interfaces.

Declare that the current file contains the following interfaces and classes:
- People class: used to store personnel information read from the database.
- ItemWriter interface: used to write processed or converted items to a specified target location.
- Autowired annotation: used for dependency injection.
- JdbcTemplate class: provides methods for executing SQL statements.
- Component annotation: used to mark the class as a Spring component.
- List interface: used for operating on the query result set.
Sample code:
```
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;
```
Define the AddPeopleWriter class.
1. Use the @Autowired annotation to automatically inject a JdbcTemplate instance for database operations when writing data.
  
  Sample code:
```
    @Autowired
    private JdbcTemplate jdbcTemplate;
```
2. In the write method, traverse the List<? extends People> that is passed in, and sequentially take out each People object. First, execute the SQL statement DROP TABLE people to delete a table named people if it exists. Then, execute the SQL statement CREATE TABLE people (name VARCHAR2(255), age INT) to create a table named people, which contains the name and age columns. Next, use the SQL statement INSERT INTO people (name, age) VALUES (?, ?) to insert the attribute values of each People object into the people table.
  
  Sample code:
```
@Override
public void write(List<? extends People> items) throws Exception {
    // Delete the table if it exists.
    jdbcTemplate.execute("DROP TABLE people");
    // Statement for creating the table.
    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());
    }
}
```

Introduction to BatchConfigTest.java

The BatchConfigTest.java file is a class that uses JUnit for testing the configuration of Spring Batch jobs.

The code in the BatchConfigTest.java file consists of the following sections:

Reference other classes and interfaces.

The current file contains the following interfaces and classes:
- Assert: a class used to assert test results.
- Test: an annotation used to mark test methods.
- RunWith: an annotation used to specify the test runner.
- Job: an interface that represents a batch job.
- JobExecution: a class used to represent the execution of a batch job.
- JobParameters: a class used to represent the parameters of a batch job.
- JobParametersBuilder: a class used to build the parameters of a batch job.
- JobLauncher: an interface used to start a batch job.
- Autowired: an annotation used to perform dependency injection.
- SpringBootTest: an annotation used to specify the test class as a Spring Boot test.
- SpringRunner: a class used to specify the test runner as SpringRunner.
Sample code:
```
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;
```
Define the BatchConfigTest class.

You can perform Spring Boot integration tests by using the SpringBootTest annotation and the SpringRunner runner. In the testJob method, a batch job is started by using the JobLauncherTestUtils utility class, and the job's execution status is verified by using assertions.
1. Use the @Autowired annotation to automatically inject the JobLauncherTestUtils instance.
  
  Sample code:
```
@Autowired
private JobLauncherTestUtils jobLauncherTestUtils;
```
2. Use the @Test annotation to mark the testJob method as a test method. In this method, a JobParameters object is first created, and then the jobLauncherTestUtils.launchJob method is used to start the batch job. The Assert.assertEquals method is used to assert that the job's execution status is COMPLETED.
  
  Sample code:
```
@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. Use the @Autowired annotation to automatically inject the JobLauncher instance.
  
  Sample code:
```
@Autowired
private JobLauncher jobLauncher;
```
4. Use the @Autowired annotation to automatically inject the Job instance.
  
  Sample code:
```
@Autowired
private Job job;
```
5. Define an inner class named JobLauncherTestUtils to assist in starting batch jobs. In this class, define a launchJob method for starting batch jobs. In this method, the jobLauncher.run method is used to start the job, and the job's execution result is returned.
  
  Sample code:
```
private class JobLauncherTestUtils {
    public JobExecution launchJob(JobParameters jobParameters) throws Exception {
        return jobLauncher.run(job, jobParameters);
    }
}
```

Introduction to AddPeopleDescProcessorTest.java

The AddPeopleDescProcessorTest.java file is a class that uses JUnit for testing the Spring Batch job configuration.

The code in the AddPeopleDescProcessorTest.java file consists of the following sections:

Reference other classes and interfaces.

The current file contains the following interfaces and classes:
- People: a class used to store personnel information read from the database.
- PeopleDESC: a class used to store descriptions after the personnel information is converted or processed.
- Assert: a class used to verify whether the expected result and actual result are consistent.
- Test: an annotation used to mark a test method.
- RunWith: an annotation used to specify the test runner.
- Autowired: an annotation used to perform dependency injection.
- SpringBootTest: an annotation used to specify the test class as a Spring Boot test.
- SpringRunner: a class used to specify the test runner as SpringRunner.
Sample code:
```
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;
```
Define the AddPeopleDescProcessorTest class.

Use the SpringBootTest annotation and SpringRunner runner to perform an integrated test of a Spring Boot application.
1. Use the @Autowired annotation to automatically inject an AddPeopleDescProcessor instance.
  
  Sample code:
```
@Autowired
private AddPeopleDescProcessor processor;
```
2. Use the @Test annotation to mark the testProcess method as a test method. In this method, a People object is created first, and then the processor.process method is used to process this object, and the result is assigned to a PeopleDESC object.
  
  Sample code:
```
@Test
public void testProcess() throws Exception {
People people = new People();
people.setName("John");
people.setAge(25);

PeopleDESC desc = processor.process(people);
}
```

Introduction to AddDescPeopleWriterTest.java

The AddDescPeopleWriterTest.java file is a class that uses JUnit for testing the write logic of AddDescPeopleWriter.

The code in the AddDescPeopleWriterTest.java file consists of the following sections:

Reference other classes and interfaces.

The current file contains the following interfaces and classes:
- PeopleDESC: a class used to store the descriptions converted or processed from the personnel information.
- Assert: a class used to assert the test results.
- Test: an annotation used to mark test methods.
- RunWith: an annotation used to specify the test runner.
- Autowired: an annotation used to perform dependency injection.
- SpringBootTest: an annotation used to specify the test class as a Spring Boot test.
- JdbcTemplate: a class that provides methods for executing SQL statements.
- SpringRunner: a class used to specify the test runner as SpringRunner.
- ArrayList: a class used to create an empty list.
- List: an interface used to operate on the query result set.
Sample code:
```
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;
```
Define the AddDescPeopleWriterTest class.

Use the SpringBootTest annotation and the SpringRunner runner to perform an integrated test of Spring Boot.
1. Inject instances using @Autowired. Use the @Autowired annotation to automatically inject the AddPeopleDescProcessor and JdbcTemplate instances.
  
  Sample code:
```
@Autowired
private AddDescPeopleWriter writer;
@Autowired
private JdbcTemplate jdbcTemplate;
```
2. Use @Test to test the insertion and output of data. Use the @Test annotation to mark the testWrite method as a test method. In this method, first create an empty peopleDescList list and add two PeopleDESC objects to the list. Then, call the write method of writer to write the data in the list to the database. Next, use jdbcTemplate to execute a query statement to obtain the data in the people_desc table, and use assertion statements to verify the correctness of the data. Finally, output the query result to the console and output a message indicating that the job has been completed.
  1. Insert data into the people_desc table. First, create an empty list of PeopleDESC objects named peopleDescList. Then, create two PeopleDESC objects named desc1 and desc2, and set their attribute values. Add desc1 and desc2 to the peopleDescList list. Next, call the write method of writer to write the objects in peopleDescList to the people_desc table in the database. Then, use JdbcTemplate to execute a query statement SELECT COUNT(*) FROM people_desc to obtain the number of records in the people_desc table and assign the result to the variable count. Finally, use Assert.assertEquals to verify whether the value of count is equal to 2.
    
    Sample code:
```
   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. Output data in the people_desc table. Use JdbcTemplate to execute a query statement SELECT * FROM people_desc and process the query result using a lambda expression. In the lambda expression, use methods such as rs.getInt and rs.getString to obtain the field values in the result set and set the field values to a newly created PeopleDESC object. Add each newly created PeopleDESC object to a result list named resultDesc. Then, print a prompt message people_desc table data:. Traverse each PeopleDESC object in the resultDesc list using a for loop, and use System.out.println to print the content of each object. Finally, print a message indicating that the job has been completed.
    
    Sample code:
```
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 table data:");
for (PeopleDESC desc : resultDesc) {
   System.out.println(desc);
}

// Output the information after the job is completed.
System.out.println("Batch Job execution completed.");
```

Introduction to AddPeopleWriterTest.java

The AddPeopleWriterTest.java file is a class that uses JUnit for testing the write logic of the AddPeopleWriterTest class.

The code in the AddPeopleWriterTest.java file consists of the following sections:

Reference other classes and interfaces.

Declare the following interfaces and classes in the current file:
- People class: a class used to store the person information read from the database.
- Test annotation: an annotation used to mark test methods.
- RunWith annotation: an annotation used to specify the test runner.
- Autowired annotation: an annotation used to perform dependency injection.
- SpringBootApplication annotation: an annotation used to mark the class as the entry point of a Spring Boot application.
- SpringBootTest annotation: an annotation used to specify the test class as a Spring Boot test.
- ComponentScan annotation: an annotation used to specify the package or class to be scanned for components.
- JdbcTemplate class: a class that provides methods for executing SQL statements.
- SpringRunner class: a class used to specify the test runner as SpringRunner.
- ArrayList class, used to create an empty list.
- List interface: an interface used to operate on the query result set.
Sample code:
```
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;
```
Define the AddPeopleWriterTest class.

Use the SpringBootTest annotation and SpringRunner runner to perform an integration test of a Spring Boot application, and use the @ComponentScan annotation to specify the package path to be scanned.
1. Use @Autowired to inject instances. Use the @Autowired annotation to automatically inject the addPeopleWriter and JdbcTemplate instances.
  
  Sample code:
```
@Autowired
private AddPeopleWriter addPeopleWriter;
@Autowired
private JdbcTemplate jdbcTemplate;
```
2. Use @Test to test the insertion and output of data.
  1. Insert data into the people table. First, create an empty People object list named peopleList. Then, create two People objects named person1 and person2, and set their name and age attributes. Next, add the two People objects to the peopleList list. After that, call the write method of addPeopleWriter, pass peopleList as the method parameter, and write the People objects in peopleList to the database.
    
    Sample code:
```
   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. Output the data in the people table. First, use the JdbcTemplate to execute a query statement SELECT * FROM people and process the query result using a lambda expression. In the lambda expression, use the rs.getString and rs.getInt methods to obtain the field values in the query result set and set the field values to a newly created People object. Add each newly created People object to a result list named result. Next, print a prompt message people table data:. Then, use a for loop to traverse each People object in the result list and use System.out.println to print the content of each object. Finally, print a message indicating that the job has completed execution.
    
    Sample code:
```
   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 table data:");
   for (People person : result) {
       System.out.println(person);
   }

   // Print a message indicating the completion of job execution
   System.out.println("Batch Job execution completed.");
```

Complete code

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.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.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;// Use the default dataSource provided by Spring Boot auto-configuration.

    @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 {
        // Drop the table if it exists.
        jdbcTemplate.execute("DROP TABLE people_desc");
        // Create the table.
        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 {
        // Drop the table if it exists.
        jdbcTemplate.execute("DROP TABLE people");
        // Create the table.
        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 com.oceanbase.example.batch.writer.AddDescPeopleWriter;
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.annotation.Resource;
import javax.batch.runtime.BatchStatus;
import java.util.UUID;

@RunWith(SpringRunner.class)
@SpringBootTest
public class BatchConfigTest {

    @Test
    public void testJob() throws Exception {
        JobParameters jobParameters = new JobParametersBuilder()
                .addString("jobParam", UUID.randomUUID().toString())
                .toJobParameters();

        JobLauncherTestUtils jobLauncherTestUtils = new JobLauncherTestUtils();
        JobExecution jobExecution = jobLauncherTestUtils.launchJob(jobParameters);
        Assert.assertEquals(BatchStatus.COMPLETED.toString(), jobExecution.getStatus().toString());
    }

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

        // Insert data into the people_desc table.
        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);

        // Output data in the people_desc table.
        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("Data in the people_desc table:");
        for (PeopleDESC desc : resultDesc) {
            System.out.println(desc);
        }

        // Output the information after the job is executed.
        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 {
        // Insert data into the people table.
        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);

        // Query and output the result.
        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("Data in the people table:");
        for (People person : result) {
            System.out.println(person);
        }

        // Output the information after the job is executed.
        System.out.println("Batch Job execution completed.");
    }
}

References

For more information about OceanBase Connector/J, see OceanBase Connector/J.

OceanBase

Customer Stories

Documentation

Connect to OceanBase Database by using SpringBatch

Prerequisites

Note

Procedure

Note

Step 1: Obtain the connection string of OceanBase Database

Note

Step 2: Import the `java-oceanbase-springbatch` project into IntelliJ IDEA

Note

Step 3: Modify the database connection information in the `java-oceanbase-springbatch` project

Step 4: Run the `java-oceanbase-springbatch` project

FAQ

1. Connection timeout

2. Character set

3. SSL connection

4. Special characters in account name or password

Notice

Project code introduction

Introduction to pom.xml

Note

Introduction to application.properties

Note

Introduction to BatchApplication.java

Introduction to BatchConfig.java

People.java file introduction

PeopleDESC.java file introduction

AddPeopleDescProcessor.java file introduction

Introduction to AddDescPeopleWriter.java

Introduction to AddPeopleWriter.java

Introduction to BatchConfigTest.java

Introduction to AddPeopleDescProcessorTest.java

Introduction to AddDescPeopleWriterTest.java

Introduction to AddPeopleWriterTest.java

Complete code

References

OceanBase

Customer Stories

Documentation

Connect to OceanBase Database by using SpringBatch

Prerequisites

Note

Procedure

Note

Step 1: Obtain the connection string of OceanBase Database

Note

Step 2: Import the java-oceanbase-springbatch project into IntelliJ IDEA

Note

Step 3: Modify the database connection information in the java-oceanbase-springbatch project

Step 4: Run the java-oceanbase-springbatch project

FAQ

1. Connection timeout

2. Character set

3. SSL connection

4. Special characters in account name or password

Notice

Project code introduction

Introduction to pom.xml

Note

Introduction to application.properties

Note

Introduction to BatchApplication.java

Introduction to BatchConfig.java

People.java file introduction

PeopleDESC.java file introduction

AddPeopleDescProcessor.java file introduction

Introduction to AddDescPeopleWriter.java

Introduction to AddPeopleWriter.java

Introduction to BatchConfigTest.java

Introduction to AddPeopleDescProcessorTest.java

Introduction to AddDescPeopleWriterTest.java

Introduction to AddPeopleWriterTest.java

Complete code

References

Step 2: Import the `java-oceanbase-springbatch` project into IntelliJ IDEA

Step 3: Modify the database connection information in the `java-oceanbase-springbatch` project

Step 4: Run the `java-oceanbase-springbatch` project