OceanBase
English日本語简体中文
Docs Home
Products
Integrations
Release Notes

Databases

OceanBase DatabaseOceanBase AI DatabaseOceanBase Cloud OceanBase Best Practices

Tools

OceanBase Cloud PlatformOceanBase Migration ServiceOceanBase Developer CenterOceanBase Migration AssessmentOceanBase Admin ToolOceanBase Loader and DumperOceanBase DeployerKubernetes operator for OceanBaseOceanBase Diagnostic Tool OceanBase Binlog ServiceOceanBase DataPilotOceanBase OAgent

Connectors and Middleware

OceanBase Database Proxy OceanBase Connector/C OceanBase Connector/J OceanBase Connector/ODBC OceanBase Connector/NETOceanBase Command-Line Client

Databases

OceanBase DatabaseOceanBase AI DatabaseOceanBase Cloud OceanBase Best Practices

Connectors and Middleware

OceanBase Database Proxy OceanBase Connector/C OceanBase Connector/J OceanBase Connector/ODBC OceanBase Connector/NETOceanBase Command-Line Client

Tools

OceanBase Cloud PlatformOceanBase Migration ServiceOceanBase Developer CenterOceanBase Migration AssessmentOceanBase Admin ToolOceanBase Loader and DumperOceanBase DeployerKubernetes operator for OceanBaseOceanBase Diagnostic Tool OceanBase Binlog ServiceOceanBase DataPilotOceanBase OAgent
OceanBase DatabaseOceanBase Cloud ToolsConnectors and MiddlewareLifecycle Support Policy

OceanBase Cloud

  • Product Updates & Announcements
    • What's new
      • Release notes for 2026
      • Release notes for 2025
      • Release notes for 2024
      • Release history
    • Product announcements
      • Notice of underlying component upgrades for OceanBase Cloud database proxy clusters on Alibaba Cloud
      • AI Service Model Launch and Delisting Notice
      • Data development module deprecation notice
      • Optimization of Backup and Restore commercialization strategy
      • Database proxy billing update
      • AWS instance pricing adjustment
      • Billing notice for limited-time free OMS instances
      • Notice of cross-AZ data transfer billing adjustments (OceanBase Cloud on AWS)
  • Product Introduction
    • Overview
    • Management mode and scenarios
    • Core features
      • High availability with cross-cloud active-active architecture
      • High availability with cross-cloud primary-standby databases
      • Data backup and restore
      • Multi-layer online scaling and on-demand adjustment
    • Deployment modes
    • Product specifications
    • Product billing
      • Overview
      • Instance billing
        • Alibaba Cloud instance billing
        • Huawei Cloud instance billing
        • AWS instance billing
        • Google Cloud instance billing
        • Azure instance billing
      • Backup and restore billing
      • SQL audit billing
      • Migrations billing
      • Database proxy billing
      • Binlog service billing
      • Read-only replica billing
      • AI model billing
    • Supported database versions
  • Get Started
    • Quick start with Flagship Edition
    • Create a Flagship Edition cluster instance
    • Create a tenant
    • Use the database
  • Work with DBaaS Instances
    • Work with flagship edition instances
      • Overview
      • Create an instance
        • Overview
        • Create via OceanBase Cloud official website
        • Create via AWS Marketplace
        • Create via GCP Marketplace
        • Create via Huawei Cloud Marketplace
        • Create via Alibaba Cloud Marketplace
        • Create via Azure Marketplace
      • Connect to an instance
        • Configure network connection
          • Overview
          • Connect using a public IP address
          • Connect using Azure Private Link
          • Connect using Google Cloud Private Service Connect
          • Connect using Huawei Cloud VPC Endpoint
          • Connect using a Huawei Cloud peering connection
          • Connect using AWS PrivateLink
          • Connect using AWS VPC peering
          • Connect using Alibaba Cloud VPC
        • MySQL compatible mode
          • Connect with clients
            • Connect to OceanBase Cloud by using Client ODC
            • Connect to OceanBase Cloud by using a MySQL client
            • Connect to OceanBase Cloud by using OBClient
          • Connect with drivers
            • Java
              • Connect to OceanBase Cloud using SpringBoot
              • SpringBatch sample application for connecting to OceanBase Cloud
              • spring-jdbc
              • SpringDataJPA sample application for connecting to OceanBase Cloud
              • Hibernate application development with OceanBase Cloud
              • Sample program for connecting to OceanBase Cloud
              • connector-j
              • Use TestContainers to connect to and use OceanBase Cloud
            • Python
              • Connect to OceanBase Cloud using mysqlclient
              • Connect to OceanBase Cloud using PyMySQL
              • Use the MySQL-connector-python driver to connect to and use OceanBase Cloud
              • Use SQLAlchemy to connect to an OceanBase Cloud database
              • Connect to an OceanBase Cloud database using Django
              • Connect to an OceanBase Cloud database by using peewee
            • C
              • Use MySQL Connector/C to connect to OceanBase Cloud
            • Go
              • Connect to OceanBase Cloud using the Go-SQL-Driver/MySQL driver
              • Connect to OceanBase Cloud using GORM
            • PHP
              • Use the EXT driver to connect to OceanBase Cloud
              • Connect to OceanBase Cloud by using the MySQLi driver
              • Use the PDO driver to connect to OceanBase Cloud
            • Rust
              • Rust application example for connecting to OceanBase Cloud
              • SeaORM example for connecting to OceanBase Cloud
            • Ruby
              • ActiveRecord sample application for OceanBase Cloud
              • Connect to OceanBase Cloud by using mysql2
              • Connect to OceanBase Cloud by using Sequel
          • Use database connection pool
            • Database connection pool configuration
            • Connect to OceanBase Cloud by using a Tomcat connection pool
            • Connect to OceanBase Cloud by using a C3P0 connection pool
            • Connect to OceanBase Cloud by using a Proxool connection pool
            • Connect to OceanBase Cloud by using a HikariCP connection pool
            • Connect to OceanBase Cloud by using a DBCP connection pool
            • Connect to OceanBase Cloud by using Commons Pool
            • Connect to OceanBase Cloud by using a Druid connection pool
        • Oracle compatible mode
          • Connect with clients
            • Connect to OceanBase Cloud by using OBClient
            • Connect to OceanBase Cloud by using Client ODC
          • Connect with drivers
            • Java
              • Connect to OceanBase Cloud using OceanBase Connector/J
              • Connect to OceanBase Cloud by using Spring Boot
              • SpringBatch application example for connecting to OceanBase Cloud
              • Connect to OceanBase Cloud using Spring JDBC
              • Connect to OceanBase Cloud by using Spring Data JPA
              • Connect to OceanBase Cloud by using Hibernate
              • Use MyBatis to connect to OceanBase Cloud
              • Use JFinal to connect to OceanBase Cloud
            • Python
              • Python Driver for Oracle Mode
            • C/C++
              • Connect to OceanBase Cloud using OceanBase Connector/C
              • Connect to OceanBase Cloud using OceanBase Connector/ODBC
              • Use SqlSugar to connect to OceanBase Cloud
          • Use database connection pool
            • Database connection pool configuration
            • Sample program that uses a Tomcat connection pool to connect to OceanBase Cloud
            • C3P0 connection pool connects to OceanBase Cloud
            • Connect to OceanBase Cloud using Proxool connection pool
            • Sample program that uses HikariCP to connect to OceanBase Cloud
            • Use DBCP connection pool to connect to OceanBase Cloud
            • Connect to OceanBase Cloud by using Commons Pool
            • Connect to OceanBase Cloud by using a Druid connection pool
        • KV compatible mode
          • Connect to a cluster by using the OBKV-HBase client
      • Developer guide
        • MySQL compatible mode
          • Plan database objects
            • Create a database
            • Create a table group
            • Create a table
            • Create an index
            • Create an external table
          • Write data
            • Insert data
            • Update data
            • Delete data
            • Replace data
            • Generate test data in batches
          • Read data
            • Single-table queries
            • Join tables
              • INNER JOIN queries
              • FULL JOIN queries
              • LEFT JOIN queries
              • RIGHT JOIN queries
              • Subqueries
              • Lateral derived tables
            • Use operators and functions in queries
              • Use arithmetic operators in queries
              • Use numerical functions in queries
              • Use string concatenation operators in queries
              • Use string functions in queries
              • Use datetime functions in queries
              • Use aggregate functions in queries
              • Use NULL-related functions in queries
              • Use the CASE conditional operator in queries
              • Use the SELECT ... FOR UPDATE statement to lock query results
              • Use the SELECT ... LOCK IN SHARE MODE statement to lock query results
            • Use a DBLink in queries
            • Set operations
          • Manage transactions
            • Overview
            • Start a transaction
            • Savepoints
              • Mark a savepoint
              • Roll back a transaction to a savepoint
              • Release a savepoint
            • Commit a transaction
            • Roll back a transaction
        • Oracle compatible mode
          • Plan database objects
            • Create a table group
            • Create a table
            • Create an index
            • Create an external table
          • Write data
            • Insert data
            • Update data
            • Delete data
            • Replace data
            • Generate test data in batches
          • Read data
            • Single-table queries
            • Join tables
              • INNER JOIN queries
              • FULL JOIN queries
              • LEFT JOIN queries
              • RIGHT JOIN queries
              • Subqueries
              • Lateral derived tables
            • Use operators and functions in queries
              • Use arithmetic operators in queries
              • Use numerical functions in queries
              • Use string concatenation operators in queries
              • Use string functions in queries
              • Use datetime functions in queries
              • Use aggregate functions in queries
              • Use CASE functions in queries
            • Use a DBLink in queries
            • Set operations
          • Manage transactions
            • Overview
            • Start a transaction
            • Savepoints
              • Mark a savepoint
              • Roll back a transaction to a savepoint
            • Commit a transaction
            • Roll back a transaction
        • KV compatible mode
          • OBKV-Table Java development guide
          • Table data operation examples
            • Insert data with OBKV-Table
            • Query data with OBKV-Table
            • Update data with OBKV-Table
            • Delete data with OBKV-Table
          • Table Java development
            • Connect to an instance by using the OBKV-Table Java client
          • HBase data operation examples
            • OBKV-HBase application development overview
            • OBKV-HBase data operation examples
      • Manage instances
        • Manage instances
          • View the instance list
          • Instance workbench overview
          • Stop and start instances
          • Unit migration
        • Manage tenants
          • Tenant overview
          • Create a tenant
          • Modify tenant specifications
          • Modify tenant names
          • Add an endpoint
          • Resource isolation
            • Overview
            • Manage resource groups
              • Create a resource group
              • View a resource group
              • Edit a resource group
              • Delete a resource group
            • Manage isolation rules
              • Create an isolation rule
              • View isolation rules
              • Edit an isolation rule
              • Delete a quarantine rule
          • Modify primary zone
          • Modify the maximum number of connections for a tenant proxy
          • Enable the AI function built-in AI models
          • Monitor tenant performance
            • Overview
            • View performance and SQL monitoring details
            • View transaction monitoring details
            • View storage and cache monitoring details
            • View Binlog service monitoring
            • Customize a monitoring dashboard for a tenant
          • Diagnostics
            • View performance monitoring data
            • Real-time diagnostics
              • SQL diagnostics
                • Top SQL
                • Slow SQL
                • Suspicious SQL
                • High-risk SQL
                • SQL details
              • Session management
                • Session management
              • Optimization management
                • Manage active outlines
                • View optimization history
              • SQL audit
          • Manage tenant parameters
            • Manage tenant parameters
            • Parameters for tenants
            • Parameter template overview
          • Delete a tenant
          • Manage databases and accounts
            • Create accounts
            • Manage accounts
            • Create a database (MySQL compatible mode)
            • Manage databases (MySQL compatible mode)
        • Monitor instance performance
          • Overview
          • Monitor the performance of databases in an instance
          • Monitor multidimensional metrics of an instance
          • Monitor the performance of hosts in an instance
          • Monitor database proxy
          • Monitor database proxy hosts
          • Monitor cross-cloud network performance
          • Customize a monitoring dashboard for an instance
        • Manage major compactions
          • Initiate a major compaction
          • View compaction records
          • Update time for compactions
        • Manage instance parameters
          • Manage parameters
          • Parameters for cluster instances
        • Change instance configurations
          • Set compute auto-scaling
          • Set storage auto-scaling
          • View history of configuration changes
          • Change configuration
          • Switch the deployment mode
        • Manage standby instances
          • Overview
          • Create a standby instance
          • Create a cross-cloud standby instance
          • Primary-standby instance workspace
          • Configure a primary-standby synchronization strategy
          • Configure global endpoint
          • Enable automatic forwarding of standby write requests
          • Primary-standby instance switchover
          • Initiate failover
          • Detach a standby instance
          • Release a standby instance
        • Release an instance
        • Database proxy
          • Overview
          • Manage database proxy
          • Direct load
        • Manage alerts
          • Overview
          • Manage alert rules
            • Create an alert rule
            • View an alert rule
            • Edit an alert rule
            • Delete an alert rule
          • View alert history
          • Manage alert templates
            • Create an alert template
            • View an alert template
            • Edit an alert template
            • Copy an alert rule template
            • Delete an alert template
          • Manage muting rules
            • Create an alert muting rule
            • View an alert muting rule
            • Edit an alert muting rule
            • Delete an alert muting rule
          • Manage alert notification templates
            • Create an alert notification template
            • View an alert notification template
            • Edit an alert notification template
            • Copy an alert notification template
            • Delete an alert notification template
          • Manage alert contacts
            • Add an alert contact
            • Add an alert contact group
            • View an alert contact
            • Edit an alert contact
            • Delete an alert contact
            • Obtain a webhook URL
          • Monitoring metrics for alerts
        • Backup and restore
          • Overview
          • Backup strategy
          • Initiate a backup immediately
          • Data backup
          • Initiate a restore
          • Data restore
          • Restore data from the instance recycle bin
        • Diagnostics
          • View performance monitoring data
          • Capacity diagnostics
          • One-click diagnostics
            • Initiate one-click diagnostics
            • View one-click diagnostic report
              • Exceptions
              • Real-time diagnostics
              • Optimization suggestions
              • Capacity management
              • Security management
          • Real-time diagnostics
            • SQL diagnostics
              • Top SQL
              • Slow SQL
              • Suspicious SQL
              • High-risk SQL
              • SQL details
              • SQL monitoring metrics list
            • Session management
              • Session management
            • Request analysis
              • Request analysis
          • Root cause diagnostics
            • Exception handling
            • Enable system autonomy
          • SQL audit
          • Materialized view analysis
          • Optimization center
            • Optimization suggestions
            • Manage active outlines
            • SQL review
            • View the optimization history
        • Manage read-only replicas
          • Overview
          • Instance read-only replicas
            • Add a read-only replica to an instance
            • View read-only replicas of an instance
            • Manage read-only replicas of an instance
            • Delete a read-only replica of an instance
          • Tenant read-only replicas
            • Add a read-only replica to a tenant
            • View read-only replicas of a tenant
            • Manage read-only replicas of a tenant
            • Delete a read-only replica of a tenant
        • Manage tags
        • Manage JVM-dependent services
      • Data source management
        • Overview of data source management
        • Manage data sources
        • User privileges
          • User privileges for compatibility assessment
          • User privileges for data migration
          • User privileges for performance assessment
          • User privileges for data archiving
          • User privileges for data cleanup
        • Connect via private network
          • AWS
          • Huawei Cloud
          • Alibaba Cloud
          • Azure
          • Private IP address segments
        • Connect via public network
          • AWS
          • Huawei Cloud
          • Alibaba Cloud
          • Azure
      • Data lifecycle management
        • Archive data
        • Clean up data
      • Manage recycle bin
        • Instance recycle bin
        • Manage databases and tables in recycle bin
          • Overview
          • Instance-level recycle bin
          • Tenant-level recycle bin
    • Work with transactional instances
      • Overview
      • Create an instance
        • Overview
        • Create via OceanBase Cloud official website
        • Create via AWS Marketplace
        • Create via GCP Marketplace
        • Create via Huawei Cloud Marketplace
        • Create via Alibaba Cloud Marketplace
        • Create via Azure Marketplace
      • Connect to an instance
        • MySQL compatible mode
          • Overview
          • Get connection string
            • Overview
            • Connect to a database by using AWS PrivateLink
            • Access the database by using an Azure private network connection
            • Connect using AWS VPC peering
            • Connect using Google Cloud Private Service Connect
            • Connect using Huawei Cloud VPC Endpoint
            • Connect using Alibaba Cloud VPC
            • Connect using a public IP address
            • Connect using a Huawei Cloud peering connection
          • Connect with clients
            • Connect to OceanBase Cloud by using Client ODC
            • Connect to OceanBase Cloud by using a MySQL client
            • Connect to OceanBase Cloud by using OBClient
          • Connect with drivers
            • Java
              • Connect to OceanBase Cloud using SpringBoot
              • SpringBatch sample application for connecting to OceanBase Cloud
              • spring-jdbc
              • SpringDataJPA sample application for connecting to OceanBase Cloud
              • Hibernate application development with OceanBase Cloud
              • Sample program for connecting to OceanBase Cloud
              • connector-j
              • Use TestContainers to connect to and use OceanBase Cloud
            • Python
              • Connect to OceanBase Cloud using mysqlclient
              • Connect to OceanBase Cloud using PyMySQL
              • Use the MySQL-connector-python driver to connect to and use OceanBase Cloud
              • Use SQLAlchemy to connect to an OceanBase Cloud database
              • Connect to an OceanBase Cloud database using Django
              • Connect to an OceanBase Cloud database by using peewee
            • C
              • Use MySQL Connector/C to connect to OceanBase Cloud
            • Go
              • Connect to OceanBase Cloud using the Go-SQL-Driver/MySQL driver
              • Connect to OceanBase Cloud using GORM
            • PHP
              • Use the EXT driver to connect to OceanBase Cloud
              • Connect to OceanBase Cloud by using the MySQLi driver
              • Use the PDO driver to connect to OceanBase Cloud
            • Rust
              • Rust application example for connecting to OceanBase Cloud
              • SeaORM example for connecting to OceanBase Cloud
            • ruby
              • ActiveRecord sample application for OceanBase Cloud
              • Connect to OceanBase Cloud by using mysql2
              • Connect to OceanBase Cloud by using Sequel
          • Use database connection pool
            • Database connection pool configuration
            • Connect to OceanBase Cloud by using a Tomcat connection pool
            • Connect to OceanBase Cloud by using a C3P0 connection pool
            • Connect to OceanBase Cloud by using a Proxool connection pool
            • Connect to OceanBase Cloud by using a HikariCP connection pool
            • Connect to OceanBase Cloud by using a DBCP connection pool
            • Connect to OceanBase Cloud by using Commons Pool
            • Connect to OceanBase Cloud by using a Druid connection pool
        • Oracle compatible mode
          • Overview
          • Get connection string
            • Overview
            • Connect to a database by using AWS PrivateLink
            • Access a database by using an Azure private network connection
            • Connect using AWS VPC peering
            • Connect using Google Cloud Private Service Connect
            • Connect using Huawei Cloud VPC Endpoint
            • Connect using a public IP address
          • Connect with clients
            • Connect to OceanBase Cloud by using OBClient
            • Connect to OceanBase Cloud by using Client ODC
          • Connect with drivers
            • Java
              • Connect to OceanBase Cloud using OceanBase Connector/J
              • Connect to OceanBase Cloud by using Spring Boot
              • SpringBatch application example for connecting to OceanBase Cloud
              • Connect to OceanBase Cloud using Spring JDBC
              • Connect to OceanBase Cloud by using Spring Data JPA
              • Connect to OceanBase Cloud by using Hibernate
              • Use MyBatis to connect to OceanBase Cloud
              • Use JFinal to connect to OceanBase Cloud
            • Python
              • Python Driver for Oracle Mode
            • C
              • Connect to OceanBase Cloud using OceanBase Connector/C
              • Connect to OceanBase Cloud using OceanBase Connector/ODBC
              • Use SqlSugar to connect to OceanBase Cloud
          • Use database connection pool
            • Database connection pool configuration
            • Sample program that uses a Tomcat connection pool to connect to OceanBase Cloud
            • C3P0 connection pool connects to OceanBase Cloud
            • Connect to OceanBase Cloud using Proxool connection pool
            • Sample program that uses HikariCP to connect to OceanBase Cloud
            • Use DBCP connection pool to connect to OceanBase Cloud
            • Connect to OceanBase Cloud by using Commons Pool
            • Connect to OceanBase Cloud by using a Druid connection pool
      • Developer guide
        • MySQL compatible mode
          • Plan database objects
            • Create a database
            • Create a table group
            • Create a table
            • Create an index
            • Create an external table
          • Write data
            • Insert data
            • Update data
            • Delete data
            • Replace data
            • Generate test data in batches
          • Read data
            • Single-table queries
            • Join tables
              • INNER JOIN queries
              • FULL JOIN queries
              • LEFT JOIN queries
              • RIGHT JOIN queries
              • Subqueries
              • Lateral derived tables
            • Use operators and functions in queries
              • Use arithmetic operators in queries
              • Use numerical functions in queries
              • Use string concatenation operators in queries
              • Use string functions in queries
              • Use datetime functions in queries
              • Use type conversion functions in queries
              • Use aggregate functions in queries
              • Use NULL-related functions in queries
              • Use the CASE conditional operator in queries
              • Use the SELECT ... FOR UPDATE statement to lock query results
              • Use the SELECT ... LOCK IN SHARE MODE statement to lock query results
            • Use a DBLink in queries
            • Set operations
          • Manage transactions
            • Overview
            • Start a transaction
            • Savepoints
              • Mark a savepoint
              • Roll back a transaction to a savepoint
              • Release a savepoint
            • Commit a transaction
            • Roll back a transaction
        • Oracle compatible mode
          • Plan database objects
            • Create a table group
            • Create a table
            • Create an index
            • Create an external table
          • Write data
            • Insert data
            • Update data
            • Delete data
            • Replace data
            • Generate test data in batches
          • Read data
            • Single-table queries
            • Join tables
              • INNER JOIN queries
              • FULL JOIN queries
              • LEFT JOIN queries
              • RIGHT JOIN queries
              • Subqueries
              • Lateral derived tables
            • Use operators and functions in queries
              • Use arithmetic operators in queries
              • Use numerical functions in queries
              • Use string concatenation operators in queries
              • Use string functions in queries
              • Use datetime functions in queries
              • Use type conversion functions in queries
              • Use aggregate functions in queries
              • Use NULL-related functions in queries
              • Use CASE functions in queries
              • Use the SELECT ... FOR UPDATE statement to lock query results
            • Use a DBLink in queries
            • Set operations
          • Manage transactions
            • Overview
            • Start a transaction
            • Savepoints
              • Mark a savepoint
              • Roll back a transaction to a savepoint
            • Commit a transaction
            • Roll back a transaction
      • Manage instances
        • Manage instances
          • View the instance list
          • Instance overview
          • Stop and restart instances
          • Unit migration
        • Manage tenants
          • Tenant overview
          • Create a tenant
          • Modify tenant specifications
          • Modify tenant names
          • Add an endpoint
          • Resource isolation
            • Overview
            • Manage resource groups
              • Create a resource group
              • View a resource group
              • Edit a resource group
              • Delete a resource group
            • Manage isolation rules
              • Create an isolation rule
              • View isolation rules
              • Edit an isolation rule
              • Delete a quarantine rule
          • Modify primary zone
          • Modify the maximum number of connections for a tenant proxy
          • Enable the AI function built-in AI models
          • Monitor tenant performance
            • Overview
            • View performance and SQL monitoring details
            • View transaction monitoring details
            • View storage and cache monitoring details
            • View Binlog service monitoring
            • Customize a monitoring dashboard for a tenant
          • Diagnostics
            • Real-time diagnostics
              • SQL diagnostics
                • Top SQL
                • Slow SQL
                • Suspicious SQL
                • High-risk SQL
              • SQL audit
          • Manage tenant parameters
            • Manage tenant parameters
            • Parameters for tenants
            • Parameter template overview
          • Delete a tenant
          • Manage databases and accounts
            • Create accounts
            • Manage accounts
            • Create a database (MySQL compatible mode)
            • Manage databases (MySQL compatible mode)
        • Monitor instance performance
          • Overview
          • Monitor the performance of databases in an instance
          • Monitor multidimensional metrics of an instance
          • Monitor the performance of hosts in an instance
          • Monitor database proxy
          • Monitor database proxy hosts
          • Monitor cross-cloud network performance
          • Customize a monitoring dashboard for an instance
        • Manage major compactions
          • Initiate a major compaction
          • View compaction records
          • Update time for compactions
        • Manage instance parameters
          • Manage parameters
          • Parameters for cluster instances
        • Change instance configurations
          • Set storage auto-scaling
          • View history of configuration changes
          • Change configuration
          • Switch the deployment mode
        • Manage standby instances
          • Overview
          • Create a standby instance
          • Create a cross-cloud standby instance
          • View details of primary and standby instances
          • Configure global endpoint
          • Enable automatic forwarding for write requests of standby databases
          • Primary-standby instance switchover
          • Initiate failover
          • Detach a standby instance
          • Release a standby instance
        • Release an instance
        • Database proxy
          • Overview
          • Manage database proxy
          • Direct load
        • Manage alerts
          • Overview
          • Manage alert rules
            • Create an alert rule
            • View an alert rule
            • Edit an alert rule
            • Delete an alert rule
          • View alert history
          • Manage alert templates
            • Create a trigger condition template
            • View an alert template
            • Edit an alert template
            • Copy an alert rule template
            • Delete an alert template
          • Manage muting rules
            • Create an alert muting rule
            • View an alert muting rule
            • Edit an alert muting rule
            • Delete an alert muting rule
          • Manage alert notification templates
            • Create an alert notification template
            • View an alert notification template
            • Edit an alert notification template
            • Copy an alert notification template
            • Delete an alert notification template
          • Manage alert contacts
            • Add an alert contact
            • Add an alert contact group
            • View an alert contact
            • Edit an alert contact
            • Delete an alert contact
            • Obtain a webhook URL
          • Monitoring metrics for alerts
        • Backup and restore
          • Overview
          • Backup strategy
          • Initiate a backup immediately
          • Data backup
          • Initiate a restore
          • Data restore
          • Restore data from the instance recycle bin
        • Diagnostics
          • View performance monitoring data
          • Capacity diagnostics
          • One-click diagnostics
            • Initiate one-click diagnostics
            • View one-click diagnostic report
              • Exceptions
              • Real-time diagnostics
              • Optimization suggestions
              • Capacity management
              • Security management
          • Real-time diagnostics
            • SQL diagnostics
              • Top SQL
              • Slow SQL
              • Suspicious SQL
              • High-risk SQL
              • SQL details
              • SQL monitoring metrics list
            • Session management
              • Session management
            • Request analysis
              • Request analysis
          • Root cause diagnostics
            • Exception handling
            • Enable system autonomy
          • SQL audit
          • Materialized view analysis
          • Optimization center
            • Optimization suggestions
            • Manage active outlines
            • SQL review
            • View the optimization history
        • Manage read-only replicas
          • Overview
          • Instance read-only replicas
            • Add a read-only replica to an instance
            • View read-only replicas of an instance
            • Manage read-only replicas of an instance
            • Delete a read-only replica of an instance
          • Tenant read-only replicas
            • Add a read-only replica to a tenant
            • View read-only replicas of a tenant
            • Manage read-only replicas of a tenant
            • Delete a read-only replica of a tenant
        • Manage tags
        • Manage JVM-dependent services
      • Data source management
        • Connect via private network
          • Google Cloud
        • Connect via public network
          • Google Cloud
      • Overview of data source management
      • Data lifecycle management
        • Overview
        • Archive data
        • Clean up data
        • Data archiving configurations
      • Manage recycle Bin
        • Instance recycle bin
        • Manage databases and tables in recycle bin
          • Overview
          • Instance-level recycle bin
          • Tenant-level recycle bin
    • Work with analytical instances
      • Overview
      • Core features
      • Connect to an instance
        • Overview
        • Get connection string
          • Overview
          • Connect using AWS PrivateLink
          • Connect using Huawei Cloud VPC Endpoint
          • Connect using a public IP address
        • Connect with clients
          • Connect to OceanBase Cloud by using Client ODC
          • Connect to OceanBase Cloud by using a MySQL client
          • Connect to OceanBase Cloud by using OBClient
        • Connect with drivers
          • Java
            • Connect to OceanBase Cloud by using Spring Boot
            • Connect to OceanBase Cloud by using Spring Batch
            • Connect to OceanBase Cloud by using Spring Data JDBC
            • Connect to OceanBase Cloud by using Spring Data JPA
            • Connect to OceanBase Cloud by using Hibernate
            • Connect to OceanBase Cloud by using MyBatis
            • Connect to OceanBase Cloud using MySQL Connector/J
          • Python
            • Connect to OceanBase Cloud by using mysqlclient
            • Connect to OceanBase Cloud by using PyMySQL
            • Connect to OceanBase Cloud using MySQL Connector/Python
          • C
            • Connect to OceanBase Cloud using MySQL Connector/C
          • Go
            • Connect to OceanBase Cloud using Go-SQL-Driver/MySQL
          • PHP
            • Connect to OceanBase Cloud using PHP
        • Use database connection pool
          • Database connection pool configuration
          • Connect to OceanBase Cloud by using a Tomcat connection pool
          • Connect to OceanBase Cloud by using a C3P0 connection pool
          • Connect to OceanBase Cloud by using a Proxool connection pool
          • Connect to OceanBase Cloud by using a HikariCP connection pool
          • Connect to OceanBase Cloud by using a DBCP connection pool
          • Connect to OceanBase Cloud by using Commons Pool
          • Connect to OceanBase Cloud by using a Druid connection pool
      • Create an instance
      • Data table design
        • Table overview
        • Best practices
          • Unit 1: Best practices for optimizing storage structures and query performance
          • Unit 2: Best practices for creating special indexes
      • Export data
      • OceanBase data processing
      • Query acceleration
        • Statistics
        • Materialized views for query acceleration
        • Select a query parallelism level
      • Manage instances
        • Instance overview
        • Change configuration
        • Set storage auto-scaling
        • Modify primary zone
        • Manage parameters
        • Backup and restore
          • Backup overview
          • Backup strategies
          • Immediate backup
          • Data Backup
          • Initiate restore
          • Data restore
        • Monitor instance performance
          • Overview
          • Monitor the performance of databases in an instance
          • Monitor the performance of hosts in an instance
        • Manage major compactions
          • Initiate a major compaction
          • View compaction records
          • Update time for compactions
        • Database proxy
          • Overview
          • Manage database proxy
          • Direct load
        • Manage alerts
          • Overview
          • Manage alert rules
            • Create an alert rule
            • View an alert rule
            • Edit an alert rule
            • Delete an alert rule
          • View alert history
          • Manage alert templates
            • Create a trigger condition template
            • View an alert template
            • Edit an alert template
            • Copy an alert template
            • Delete an alert template
          • Manage muting rules
            • Create an alert muting rule
            • View an alert muting rule
            • Edit an alert muting rule
            • Delete an alert muting rule
          • Manage alert notification templates
            • Create an alert notification template
            • View an alert notification template
            • Edit an alert notification template
            • Copy an alert notification template
            • Delete an alert notification template
          • Manage alert contacts
            • Add an alert contact
            • Add an alert contact group
            • View an alert contact
            • Edit an alert contact
            • Delete an alert contact
            • Obtain a webhook URL
          • Monitoring metrics for alerts
        • Diagnostics
          • View performance monitoring data
          • Capacity diagnostics
          • Real-time diagnostics
            • SQL diagnostics
              • Top SQL
              • Slow SQL
              • Suspicious SQL
              • High-risk SQL
              • SQL details
              • SQL monitoring metrics list
            • Session management
              • Session management
            • Optimization management
              • Manage active outlines
              • View the optimization history
            • Request analysis
              • Request analysis
        • Stop and restart instances
        • Release instances
        • Manage databases and accounts
          • Create and manage accounts
          • Create a database
          • Manage databases
        • Manage tags
      • Overview of data source management
      • Data lifecycle management
        • Archive data
        • Clean up data
      • Performance diagnosis and tuning
        • Use the DBMS_XPLAN package for performance diagnostics
        • Use the GV$SQL_PLAN_MONITOR view for performance analysis
        • Views related to AP performance analysis
      • Performance testing
      • Product integration
      • Manage recycle Bin
        • View instance recycle bin
        • Manage databases and tables in recycle bin
          • Overview
          • Instance recycle bin
    • Work with Key-Value instances
      • Try out Key-Value instances
        • Create an instance
        • Create a tenant
        • Create an account for a database user
        • OBKV HBase data operation examples
      • Use Table model
        • Create an instance
        • Manage instances
          • Manage instances
            • View the instance list
            • Instance overview
            • Stop and restart instances
            • Release an instance
          • Manage tenants
            • Create a tenant
            • Modify tenant specifications
            • Modify tenant names
            • Delete a tenant
            • Tenant overview
            • Resource isolation
              • Overview
              • Manage resource groups
                • Create a resource group
                • View a resource group
                • Edit a resource group
                • Delete a resource group
              • Manage isolation rules
                • Create an isolation rule
                • View isolation rules
                • Edit an isolation rule
                • Delete a quarantine rule
            • Monitor tenant performance
              • Overview
              • View performance and SQL monitoring details
              • View transaction monitoring details
              • View storage and cache monitoring details
              • OBKV-Table
              • Customize a monitoring dashboard for a tenant
            • Diagnostics
              • Top SQL
            • Manage tenant parameters
              • Manage tenant parameters
              • Parameters for tenants
            • Manage databases and accounts
              • Create and manage accounts
              • Create a database
              • Manage databases
            • Modify primary zone
          • Monitor instance performance
            • Overview
            • Monitor the performance of databases in an instance
            • Monitor multi-dimensional metrics of an instance
            • Monitor the performance of hosts in a cluster
            • Customize monitoring dashboards for an instance
          • Manage major compactions
            • Initiate major compactions
            • View compaction records
            • Update time for compactions
          • Manage instance parameters
            • Parameter management overview
            • Parameters for cluster instances
          • Change instance configurations
            • Set storage auto-scaling
            • View history of configuration changes
            • Change configuration
            • Switch the deployment mode
          • Database proxy
            • Overview
            • Manage database proxy
          • Manage alerts
            • Overview
            • Manage alert rules
              • Create an alert rule
              • View an alert rule
              • Edit an alert rule
              • Delete an alert rule
            • View alert history
            • Manage alert templates
              • Trigger condition template management
              • Create an alert template
              • View an alert template
              • Edit an alert template
              • Copy an alert template
              • Delete an alert template
            • Manage muting rules
              • Create an alert muting rule
              • View an alert muting rule
              • Edit an alert muting rule
              • Delete an alert muting rule
            • Manage alert contacts
              • Add an alert contact
              • Add an alert contact group
              • View an alert contact
              • Edit an alert contact
              • Delete an alert contact
              • Obtain a webhook URL
            • Monitoring metrics for alerts
          • Backup and restore
            • Backup overview
            • Backup strategies
            • Immediate backup
            • Data backup
            • Initiate restore
            • Data restore
          • Diagnostics
            • View performance monitoring data
            • Top SQL
            • Capacity diagnostics
            • Request analysis
          • Manage recycle Bin
            • View instance recycle bin
            • Manage databases and tables in recycle bin
              • Overview
              • Instance-level recycle bin
              • Tenant-level recycle bin
          • Manage tags
      • Use HBase model
        • OBKV-HBase Overview
        • Create an instance
        • Develop in HBase model
          • Connect to an instance by using the OBKV-HBase client
        • Manage instances
          • Manage instances
            • View the instance list
            • Instance overview
            • Stop and restart instances
            • Release an instance
          • Manage tenants
            • Create a tenant
            • Modify tenant specifications
            • Modify tenant names
            • Delete a tenant
            • Tenant overview
            • Resource isolation
              • Overview
              • Manage resource groups
                • Create a resource group
                • View a resource group
                • Edit a resource group
                • Delete a resource group
              • Manage isolation rules
                • Create an isolation rule
                • View isolation rules
                • Edit an isolation rule
                • Delete a quarantine rule
            • Monitor tenant performance
              • Overview
              • View performance and SQL monitoring details
              • View transaction monitoring details
              • View storage and cache monitoring details
              • OBKV-HBase
              • Customize a monitoring dashboard for a tenant
            • Diagnostics
              • Top SQL
            • Manage tenant parameters
              • Manage tenant parameters
              • Parameters for tenants
            • Manage databases and accounts
              • Create and manage accounts
              • Create a database
              • Manage databases
            • Modify primary zone
          • Monitor instance performance
            • Overview
            • Monitor the performance of databases in an instance
            • Monitor multi-dimensional metrics of an instance
            • Monitor the performance of hosts in a cluster
            • Customize monitoring dashboards for an instance
          • Manage major compactions
            • Initiate major compactions
            • View compaction records
            • Update time for compactions
          • Manage instance parameters
            • Parameter management overview
            • Parameters for cluster instances
          • Change instance configurations
            • Set storage auto-scaling
            • View history of configuration changes
            • Change configuration
            • Switch the deployment mode
          • Database proxy
            • Overview
            • Manage database proxy
          • Manage alerts
            • Overview
            • Manage alert rules
              • Create an alert rule
              • View an alert rule
              • Edit an alert rule
              • Delete an alert rule
            • View alert history
            • Manage alert templates
              • Trigger condition template management
              • Create an alert template
              • View an alert template
              • Edit an alert template
              • Copy an alert template
              • Delete an alert template
            • Manage muting rules
              • Create an alert muting rule
              • View an alert muting rule
              • Edit an alert muting rule
              • Delete an alert muting rule
            • Manage alert contacts
              • Add an alert contact
              • Add an alert contact group
              • View an alert contact
              • Edit an alert contact
              • Delete an alert contact
              • Obtain a webhook URL
            • Monitoring metrics for alerts
          • Backup and restore
            • Backup overview
            • Backup strategies
            • Immediate backup
            • Data backup
            • Initiate restore
            • Data restore
          • Diagnostics
            • View performance monitoring data
            • Top SQL
            • Capacity diagnostics
            • Request analysis
          • Manage recycle Bin
            • View instance recycle bin
            • Manage databases and tables in recycle bin
              • Overview
              • Instance-level recycle bin
              • Tenant-level recycle bin
          • Manage tags
        • Overview of data source management
        • Performance test
      • Connect Key-Value instances
        • Overview
        • Connect using Huawei Cloud VPC Endpoint
        • Connect using a public IP address
  • Use BYOC instances
    • Prepare BYOC instance quotas
    • Create a BYOC instance
    • Connect to an instance
      • Connect in MySQL mode
        • Connect with a client
          • Connect to OceanBase Cloud using the desktop ODC
          • Connect to OceanBase Cloud using the MySQL client
          • Connect to OceanBase Cloud by using OBClient
        • Connect with a driver or ORM framework
          • Java
            • Sample application for connecting to OceanBase Cloud using Spring Boot
            • Sample application for connecting to OceanBase Cloud using Spring Batch
            • spring-jdbc
            • Sample application for connecting to OceanBase Cloud using Spring Data JPA
            • Connect to OceanBase Cloud using Hibernate
            • Sample application for connecting to OceanBase Cloud using MyBatis
            • connector-j
            • Connect to OceanBase Cloud using Testcontainers Java
          • Python
            • Connect to OceanBase Cloud using mysqlclient
            • Connect to OceanBase Cloud using PyMySQL
            • Connect to OceanBase Cloud using MySQL Connector/Python
            • Example program for connecting to OceanBase Cloud using SQLAlchemy
            • Connect to OceanBase Cloud using Django
            • Sample program for connecting to OceanBase Cloud using Peewee
          • C
            • Connect to OceanBase Cloud by using MySQL Connector/C
          • Go
            • Example program for connecting to OceanBase Cloud using Go-SQL-Driver/MySQL
            • Example program for connecting to OceanBase Cloud using GORM
          • PHP
            • Example program for connecting to OceanBase Cloud using the EXT driver
            • Connect to OceanBase Cloud by using the MySQLi driver
            • Connect to OceanBase Cloud using the PDO driver
          • Rust
            • Connect to OceanBase Cloud using Rust
            • Sample application for connecting to OceanBase Cloud using SeaORM
          • Ruby
            • Example program for connecting to OceanBase Cloud database using ActiveRecord
            • Connect to OceanBase Cloud using mysql2
            • Example program for connecting to OceanBase Cloud using Sequel
        • Use connection pools
          • Database connection pool configuration
          • Connect to OceanBase Database with Druid in a Tomcat application
          • Connect to OceanBase Database by using a C3P0 connection pool
          • Sample program for connecting to OceanBase Database using a Proxool connection pool
          • Connect to OceanBase Database by using the HikariCP connection pool
          • Connect to OceanBase Database by using a DBCP connection pool
          • Connect to OceanBase Database by using Commons Pool
          • Sample program for connecting to OceanBase Database using a Druid connection pool
      • Connect in Oracle mode
        • Connect with a client
          • Connect to OceanBase Cloud using OBClient
          • Connect to OceanBase Cloud using the desktop ODC
        • Connect with a driver or ORM framework
          • Java
            • Sample application for connecting to OceanBase Cloud using OceanBase Connector/J
            • Connect to OceanBase Cloud using Spring Boot
            • Sample application for connecting to OceanBase Cloud using Spring Batch
            • Connect to OceanBase Cloud by using Spring JDBC
            • Connect to OceanBase Cloud using Spring Data JPA
            • Connect to OceanBase Cloud using Hibernate
            • Sample application for connecting to OceanBase Cloud using MyBatis
            • Connect to OceanBase Cloud using JFinal
          • Python
            • Python Driver Oracle Mode
          • C/C++
            • Connect to OceanBase Cloud using OceanBase Connector/C
            • Sample program for connecting to OceanBase Cloud using OceanBase Connector/ODBC
            • Sample application for connecting to OceanBase Cloud using SqlSugar
        • Use connection pools
          • Database connection pool configuration
          • Connect to OceanBase Database with Druid in a Tomcat application
          • Connect to OceanBase Cloud by using a C3P0 connection pool
          • Sample application for connecting to OceanBase Cloud using a Proxool connection pool
          • Connect to OceanBase Cloud by using HikariCP connection pool
          • Connect to OceanBase Cloud by using a DBCP connection pool
          • Connect to OceanBase Cloud by using Commons Pool
          • Sample program for connecting to OceanBase Cloud using a Druid connection pool
      • Connect in KV mode
        • Connect to a cluster by using the OBKV-HBase client
    • Manage instances
      • Manage instances
        • View the instance list
        • Instance workspace overview
        • Stop and start an instance
        • Migrate resource units
      • Manage tenants
        • Tenant workspace
        • Create a tenant
        • Modify tenant specifications
        • Change the tenant name
        • Add an endpoint
        • Modify the primary zone
        • Monitor tenant performance
          • Tenant monitoring overview
          • Monitor performance and SQL
          • Monitor transactions
          • Monitor storage and cache
          • Monitor the Binlog service
          • Customize monitoring dashboards for tenants
        • Manage parameters
          • Manage tenant parameters
          • Parameter list description
          • Parameter template description
        • Delete a tenant
        • Manage databases and accounts
          • Create an account
          • Manage accounts
          • Create a database (MySQL only)
          • Manage databases (MySQL only)
      • Monitor instance performance
        • Instance monitoring overview
        • Monitor the performance of databases in a cluster
        • Monitor multi-dimensional metrics of a cluster
        • Monitor the performance of hosts in a cluster
        • Database proxy monitoring details
        • Database proxy host monitoring details
        • Customize monitoring dashboards for instances
      • Major compaction
        • Initiate a major compaction
        • View major compaction records
        • Modify the major compaction time
      • Manage instance parameters
        • Parameter management
        • Parameter list description
      • Change instance configurations
        • View the configuration change history of a cluster instance
        • Change instance configurations (pay-as-you-go)
      • Manage standby instances
        • Create a standby instance
        • Primary and standby instance workspaces
        • Set a primary/standby synchronization strategy
      • Release an instance
      • Database proxy
        • Database proxy overview
        • Manage database proxies
      • Manage alerts
        • Manage alerts
        • Manage alert rules
          • Create an alert rule
          • View an alert rule
          • Edit an alert rule
          • Delete an alert rule
        • View alert history
        • Manage trigger condition templates
          • Create a trigger condition template
          • View a trigger condition template
          • Edit a trigger condition template
          • Copy a trigger condition template
          • Delete a trigger condition template
        • Manage muting rules
          • Create an alert muting rule
          • View an alert muting rule
          • Edit an alert muting rule
          • Delete an alert muting rule
        • Manage notification templates
          • Create an alert notification template
          • View an alert notification template
          • Edit an alert notification template
          • Copy an alert notification template
          • Delete an alert notification template
        • Manage alert contacts
          • Add an alert contact
          • Add an alert contact group
          • View an alert contact
          • Edit an alert contact
          • Delete an alert contact
          • Get a webhook URL
        • Monitoring metrics for custom alerts
      • Backup and restore
        • Backup and restore overview
        • Modify a backup strategy
        • Perform an immediate backup
        • Initiate restore
      • Manage read-only replicas
        • Read-only replica overview
        • Instance read-only replicas
          • Add a read-only replica to an instance
          • View information about read-only replicas of an instance
          • Manage the specifications of read-only replicas
          • Delete a read-only replica of an instance
        • Tenant read-only replicas
          • Add a read-only replica for a tenant
          • View information about tenant read-only replicas
          • Modify tenant read-only replicas
          • Delete tenant read-only replicas
      • Manage tags
      • Manage JVM environment dependency services
    • Manage the recycle bin
      • Instance recycle bin
  • AI Features
    • AI services
      • Overview of AI service
      • Quick start
      • Manage AI API keys
      • Use AI models
      • Use Claude Code with OceanBase MaaS
      • Use Codex CLI and Codex App with OceanBase MaaS
      • Use the memory feature
      • AI APIs
        • Access guide
        • AI service APIs
          • AI API list
          • Anthropic compatible APIs
            • List Anthropic models
            • Create a message
            • Create a message (default base URL)
          • OpenAI compatible APIs
            • List models
            • Create chat completion
            • Create embedding
            • Rerank
            • Reranks
            • Create response
          • Vertex AI compatible APIs
            • Generate content
            • Stream generate content
          • Image and video generation APIs
            • Create an image generation task
            • Create a video generation task
            • Retrieve task status
          • Image model APIs
            • gpt-image-2 text-to-image
            • gpt-image-2 image editing
            • gemini-3-pro-image text-to-image
            • gemini-3-pro-image image-to-image / image editing
          • OpenAI compatible batches and files APIs
            • Upload file
            • List files
            • Retrieve file
            • Delete file
            • Get file content
            • Get file content (POST)
            • Create batch
            • List batches
            • openai-compatible-apis
            • Retrieve batch (POST)
            • Cancel batch
          • Memory APIs
            • listSpaces - Paginated list of memory spaces
            • createSpace - Create a memory space
            • getSpace - Get details of a specified memory space
            • updateSpace - Update the name and description of a space
            • deleteSpace - Delete a space
            • extractMemories - Extract memories from dialogue messages
            • listMemories - List memories in a space
            • addMemory - Add a memory directly
            • getMemory - Retrieve a single memory
            • updateMemory - Update a single memory
            • deleteMemory - Delete a single memory
            • distillMemory - Distill experiences from conversations
            • searchExperiences - Search for experiences
            • getExperience - Retrieve a single experience
            • deleteExperience - Delete a single experience
            • feedbackExperiences - Submit feedback on experiences
            • setExperienceObsolescence - Set the obsolete status of an experience
            • combinedSearch - Combined search for memories and experiences
    • OceanBase OAgent
      • What is OceanBase OAgent?
      • Quick start with OceanBase OAgent
      • Configure a channel
      • Set skills
      • View OceanBase OAgent token usage
  • Migrations
    • Data migration and import solutions
    • Data assessment and migration quick start
    • Assess compatibility
      • Overview
      • Perform online assessment
      • Perform offline assessment
      • Manage compatibility assessment tasks
        • View a compatibility assessment task
        • View and download a compatibility assessment report
        • Stop a compatibility assessment task
        • Delete a compatibility assessment task
      • Obtain files for upload
      • Configure PrivateLink
      • Add an IP address to an allowlist
    • Data source management
      • Create a data source
      • Manage data sources
      • User privileges
        • User privileges for compatibility assessment
        • User privileges for data migration
        • User privileges for performance assessment
        • User privileges for data archiving
        • User privileges for data cleanup
      • Connect via private network
        • AWS
        • Huawei Cloud
        • Alibaba Cloud
        • Azure
        • Private IP address range
      • Connect via public network
        • AWS
        • Huawei Cloud
        • Alibaba Cloud
        • Azure
      • Connect via VPC peering
        • Configure an AWS data service peering connection
        • Configure a Huawei Cloud data service peering connection
        • Configure an Alibaba Cloud data service peering connection
        • Configure a Google Cloud data service peering connection
    • Migrate data
      • Overview
      • Migrations specification
      • Purchase a data migration instance
      • Migrate data from a MySQL database to the MySQL-compatible mode of OceanBase Database
      • Migrate data from OceanBase Database in MySQL-compatible mode to a MySQL database
      • Data migration between tenants of OceanBase Database in the same compatibility mode
      • Migrate data between OceanBase database tenants of different compatibility modes
      • Migrate data from an Oracle database to an Oracle-compatible tenant of OceanBase Database
      • Migrate data from an Oracle-compatible tenant of OceanBase Database to an Oracle database
      • Configure a two-way synchronization task
      • Migrate data from OceanBase Database to Kafka
      • Migrate data from a TiDB database to the MySQL-compatible mode of OceanBase Database
      • Migrate incremental data from OceanBase Database in MySQL-compatible mode to TiDB Database
      • Migrate data from a PostgreSQL database to OceanBase Database
      • Migrate incremental data from OceanBase Database to PostgreSQL Database
      • Migrate data from a Lindorm/HBase database to the HBase API compatible mode of OceanBase Database
      • Migrate incremental data from OceanBase Database in HBase API compatibility mode to a Lindorm/HBase database
      • Migrate data from OceanBase Database to RocketMQ
      • Migrate data from OceanBase Database to DataHub
      • Migrate data from OceanBase Database in MySQL mode to ADB
      • Migrate data from PolarDB-X 2.0 to OceanBase Database in MySQL mode
      • Manage data migration tasks
        • View details of a data migration task
        • Rename a data migration task
        • View and modify migration objects
        • View and modify migration parameters
        • Configure alert monitoring
        • Manage data migration tasks by using tags
        • Intelligent diagnosis
        • Start, stop, and resume a data migration task
        • Clone a data migration task
        • Terminate and release a data migration task
      • Features
        • Custom DML/DDL configurations
        • DDL synchronization scope
        • Use SQL conditions to filter data
        • Rename a migration object
        • Set an incremental synchronization timestamp
        • Instructions on schema migration
        • Configure and modify matching rules
        • Wildcard rules
        • Import migration objects
        • Download conflict data
        • Change a topic
        • Column filtering
        • Data formats
        • Partition settings
      • Authorize an Alibaba Cloud account
      • SQL statements for querying table objects
      • Online DDL tools
      • Create a trigger
      • Modify the log level of a self-managed PostgreSQL instance
      • Supported DDL statements for synchronization and their limitations
        • DDL synchronization from Aurora MySQL DB clusters to MySQL-compatible tenants of OceanBase Database
        • DDL synchronization from MySQL-compatible tenants of OceanBase Database to Aurora MySQL DB clusters
        • DDL synchronization between MySQL-compatible tenants of OceanBase Database
        • DDL synchronization from Oracle databases to Oracle-compatible tenants of OceanBase Database
        • DDL synchronization from Oracle-compatible tenants of OceanBase Database to Oracle databases
        • DDL synchronization between Oracle-compatible tenants of OceanBase Database
        • DDL synchronization from OceanBase databases to Kafka instances
    • Data subscription
      • Create a data subscription task
      • Manage data subscription tasks
        • View details of a data subscription task
        • Configure subscription information
        • Modify the name of a data subscription task
        • View and modify subscription objects
        • View data subscription parameters
        • Set up data subscription alerts
        • Start, stop, and resume data subscription tasks
        • Clone a data subscription task
        • Release a data subscription task
      • Manage private connections for data subscriptions
      • Configure consumer subscription
      • Message formats
    • Data validation
      • Overview
      • Create a data validation task
      • Manage data validation tasks
        • View details of a data validation task
        • View and modify validation objects
        • View and modify validation parameters
        • Manage data validation tasks with tags
        • Start, pause, and resume data validation tasks
        • Clone a data validation task
        • Release a data validation task
      • Features
        • Import validation objects
        • Rename the validation object
        • Filter objects by using SQL conditions
        • Configure the matching rules for the validation object
    • Assess performance
      • Overview
      • Obtain traffic files from a database instance
      • Create a full performance assessment task
      • Create an SQL file parsing task
      • Create an SQL file replay task
      • Manage performance assessment tasks
        • View the details of a performance assessment task
        • View a performance assessment report
        • Retry and stop a performance assessment task
        • Delete a performance assessment task
      • Obtain a database instance
      • Create an access key
    • Import data
      • Import data
      • Direct load
      • Supported file formats and encoding formats for Data Import
      • Sample data introduction
    • Binlog service
      • Overview
      • Purchase the Binlog service
      • Manage Binlog service
        • View details of the Binlog service
        • Change configuration
        • Modify the auto-scaling strategy for storage space
        • Modify the elasticity strategy for compute units
        • Disable the Binlog service
    • Upgrade assistant
  • Security
    • OceanBase Cloud account settings
      • Manage personal account information
      • Multi-factor authentication
      • Organization authentication
        • Enable organization authentication
        • Configure IdP
      • Manage AccessKeys
      • Time zone settings
      • Account message subscriptions
      • Manage cloud marketplace accounts
      • Account audit
    • Organizations and projects
      • Overview
      • Manage organization information
      • Project management
        • Manage projects
        • Cross-project bidirectional authorization
        • Authorize a cloud account for BYOC
        • Manage object storage configurations
        • Manage log service configurations
        • Subscribe to project messages
      • Manage members
      • Permissions for roles
      • Cost management
        • Overview
        • Cost details
        • Manage cost units
      • Operation audit
    • Database accounts and privileges
      • Account privileges
      • Authorize cloud vendor accounts
      • AWS KMS key management
      • Support access control
    • Security and encryption
      • Set allowlist groups
      • SSL encryption
      • Transparent Data Encryption (TDE)
    • Monitoring dashboard
    • Events
    • Support plans
      • Overview of OceanBase Cloud support plans
      • Subscribe to and manage support plans
  • SQL Console
    • Overview
    • Access SQL Console
    • SQL editing and execution
    • PL compilation
    • Result set editing
    • Execution analysis
    • Database object management
      • Create a table
      • Create a view
      • Create a function
      • Create a stored procedure
      • Create a program package
      • Create a trigger
      • Create a type
      • Create a sequence
      • Create a synonym
    • Session variable management
    • Functional keys in SQL Console
  • Integrations
    • Overview
    • Schema evolution
      • Liquibase
      • Flyway
    • Data ingestion
      • Canal
      • dbt
      • Debezium
      • Flink
      • Glue
      • Informatica Cloud
      • Kafka
      • Maxwell
      • SeaTunnel
      • DataWorks
      • NiFi
    • SQL development
      • DataGrip
      • DBeaver
      • Navicat
      • TablePlus
    • Orchestration
      • DolphinScheduler
      • Linkis
      • Airflow
    • Visualization
      • Grafana
      • Power BI
      • Quick BI
      • Superset
      • Tableau
    • Observability
      • Datadog
      • Prometheus
    • Database management
      • Bytebase
    • AI
      • LlamaIndex
      • Dify
      • LangChain
      • Tongyi Qianwen
      • OpenAI
      • n8n
      • Trae
      • SpringAI
      • Cline
      • Cursor
      • Continue
      • Toolbox
      • CamelAI
      • Firecrawl
      • Hugging Face
      • Ollama
      • Google Gemini
      • Cloudflare Workers AI
      • Qoder
      • OpenCode
      • Claude Code
      • GitHub Copilot
      • Codex
      • Jina AI
      • Augment Code
      • Claude Code
      • Kiro
    • Development tools
      • Cloudflare Workers
      • Vercel
  • Best practices
    • Best practices for achieving high availability through cross-cloud active-active deployment
    • High availability through cross-cloud primary-standby databases (1:1)
    • High availability through cross-cloud primary-standby databases (1:n)
    • High host CPU usage
    • Best practices for read/write splitting in OceanBase Cloud
    • Best practices for migrating data from AWS RDS to OceanBase Cloud
  • References
    • System architecture
    • System management
    • Database object management
    • Database design and specification constraints
    • SQL reference
    • System views
    • Parameters and system variables
    • Error codes
    • Performance tuning
    • Open API References
      • Overview of Open APIs
      • Service endpoints
      • Using API
      • Open APIs
        • Cluster management
          • DescribeInstances
          • DescribeInstance
          • CreateInstance
          • DeleteInstance
          • ModifyInstanceName
          • describe-node-options
          • StopCluster
          • StartCluster
          • ModifyInstanceSpec
          • DescribeInstanceTopology
          • DescribeReadonlyInstances
          • CreateReadonlyInstance
          • ModifyReadonlyInstanceSpec
          • ModifyReadonlyInstanceDiskSize
          • ModifyReadonlyInstanceNodeNum
          • DeleteReadonlyInstance
          • DescribeInstanceAvailableRoZones
          • DescribeInstanceParameters
          • UpdateInstanceParameters
          • DescribeInstanceParametersHistory
          • ModifyInstanceTagList
          • ModifyInstanceNodeNum
          • DescribeInstanceAnomalyEvents
          • DescribeOasClusterAnomalySqlList
          • DescribeOasClusterSlowSQLList
          • DescribeInstanceSqlAuditServiceInfo - Query SQL Audit Service Information
          • DescribeProxyClusterForInstance - Query ODP clusters associated with an instance
          • SwitchoverInstance - Perform a primary/standby switchover
          • DisconnectStandbyInstance - Detach a standby instance
        • Tenant management
          • DescribeTenants
          • DescribeTenant
          • CreateTenants
          • DeleteTenants
          • ModifyTenantName
          • ModifyTenant
          • ModifyTenantUserDescription
          • ModifyTenantUserStatus
          • GetTenantCreateConstraints
          • ModifyTenantPrimaryZone
          • GetTenantCreateCpuConstraints
          • GetTenantCreateMemConstraints
          • GetTenantModifyCpuConstraints
          • GetTenantModifyMemConstraints
          • CreateTenantSecurityIpGroup
          • DescribeTenantSecurityIpGroups
          • ModifyTenantSecurityIpGroup
          • DeleteTenantSecurityIpGroup
          • BatchKillProcessList
          • DescribeProcessStatsComposition
          • DescribeTenantAvailableRoZones
          • ModifyTenantReadonlyReplica
          • DescribeTenantParameters
          • UpdateTenantParameters
          • DescribeTenantParametersHistory
          • ModifyTenantTagList
          • DescribeTenantSqlAuditServiceInfo - Query SQL Audit Service Information for a Tenant
          • DescribeCharset
        • Tenant user management
          • CreateTenantUser
          • DescribeTenantUsers
          • DeleteTenantUsers
          • ModifyTenantUserPassword
          • ModifyTenantUserRoles
        • Database management
          • CreateDatabase
          • DescribeDatabases
          • DeleteDatabases
          • ModifyDatabaseUserRoles
          • DescribeTableSchema
          • DescribeTimeZone
          • ModifyDatabaseDescription
        • Backup and restore
          • DescribeDataBackupSet
          • DescribeRestorableTenants
          • ModifyBackupStrategy
          • CreateTenantRestoreTask
          • CreateDataBackupTask
          • DescribeOneDataBackupSet
          • CreateBackupSetDownloadLink - Create a backup set download link
          • DeleteBackupSetDownloadTask - Delete a backup set download task
          • DescribeBackupSetDownloadLink - Query a backup set download link
          • DescribeBackupStrategy - Query backup strategy
        • Database proxy management
          • ModifyOdpClusterSpec
        • Connection management
          • CreateTenantAddress
          • CreateTenantSingleTunnelSLBAddress
          • DeleteTenantAddress
          • DescribeTenantAddress
          • ModifyTenantAddressPort
          • ModifyTenantAddressDomainPrefix
          • ConfirmPrivatelinkConnection
          • DescribeTenantPrivateLink
          • DeletePrivatelinkConnection
          • CreatePrivatelinkService
          • ConnectPrivatelinkService
          • AddPrivatelinkServiceUser
          • DescribeTenantAddressInfo - Query Tenant Address Information
          • CreateReadonlyPrivatelink
          • CreateReadwritePrivatelink
          • DescribeTenantPublicAddress
        • Data source management
          • ListDataSources - List data sources
          • CreateDataSource - Create a data source
          • DeleteDataSource - Delete a data source
        • OMS project management
          • DescribeProject - Query project details
          • CreateProject - Create a project
          • DeleteProject - Delete a project
          • DescribeProjectSteps - Query project steps
          • StartProject - Start a project
          • StopProject - Stop a project
          • ResumeProject - Resume a project
          • ReleaseProject - Release project resources
          • UpdateProjectConfig - Update project configuration
          • ListProjectModifyRecords - List project modification records
          • CreateProjectModifyRecords - Create modification records (add or remove tables)
          • CancelProjectModifyRecord - Cancel a modification record
          • RetryProjectModifyRecords - Retry a modification
          • StopProjectModifyRecords - Terminate a modification
          • GetModifyRecord - Query modification record details
          • DescribeTransferMapping - Query transfer object mappings
        • Monitoring management
          • DescribeTenantMetrics
          • DescribeMetricsData
          • CreatePrometheusIntegration - Create a Prometheus Monitoring Integration
          • DeletePrometheusIntegration - Delete Prometheus Monitoring Integration
          • ListPrometheusIntegration - Query Prometheus Monitoring Integration List
          • DescribeNodeMetrics
        • Diagnostic management
          • DescribeOasTopSQLList
          • DescribeOasAnomalySQLList
          • DescribeOasSlowSQLList
          • DescribeOasSQLText
          • DescribeSqlAudits
          • DescribeOutlineBinding
          • DescribeSampleSqlRawTexts
          • DescribeSQLTuningAdvices
          • DescribeOasSlowSQLSamples
          • DescribeOasSQLTrends
          • DescribeOasSQLPlanGroup
          • DescribeRcaRecord
          • DescribeTopSQLComparision
          • DescribeSessionStatsGroupBySqlId
          • DescribeIndexes
          • DescribeOasHighRiskSQL
        • Security management
          • CreateSecurityIpGroup
          • DescribeSecurityIpGroups - Query cluster allowlist groups
          • DescribeInstanceSSL
          • ModifyInstanceSSL
          • DescribeTenantEncryption
          • ModifyTenantEncryption
          • ModifySecurityIps
          • DeleteSecurityIpGroup
          • DescribeTenantSecurityConfigs
          • DescribeInstanceSecurityConfigs
        • Tag management
          • DescribeTags
          • CreateTags
          • UpdateTag
          • DeleteTag
        • Historical event management
          • DescribeOperationEvents
        • AI service management
          • CreateAIServiceAPIKey
          • DeleteAIServiceAPIKey
          • ListAIServiceAPIKeys
        • OpenAPI catalog
          • ListOpenApis - List OpenAPIs
          • DescribeOpenApi - Query OpenAPI details
      • Open API FAQ
      • Differences between ApsaraDB for OceanBase APIs and OceanBase Cloud APIs
    • Download OBClient
      • Download OBClient
      • Download OceanBase Connector/J
      • Download client ODC
      • Download OceanBase Connector/ODBC
      • Download OBClient Libs
    • Performance Tests
      • OLTP performance test: Sysbench benchmark
      • OLAP performance test: TPC-H benchmark
      • OLTP performance test: TPC-C benchmark
    • Metrics References
      • CMS metric compatibility
      • Prometheus monitoring metrics
      • Cluster database
      • Cluster hosts
      • Binlog service
      • Cross-cloud network channel connection
      • Performance and SQL
      • Transactions
      • Storage and caching
      • Proxy database
      • Proxy host
    • ODC User Guide
      • What is ODC?
        • What is ODC?
        • Limitations
      • Quick start
        • Client ODC
          • Overview
          • Install Client ODC
          • Use Client ODC
        • Web ODC
          • Overview
          • Use Web ODC
      • Data source management
        • Create a data source
        • Data sources and project collaboration
        • Database O&M
          • Session management
          • Global variable management
          • Recycle bin management
      • SQL development
        • Edit and execute SQL statements
        • Perform PL compilation and debugging
        • Edit and export the result set of an SQL statement
        • Execution analysis
        • Generate test data
        • System settings
        • Database objects
          • Table objects
            • Overview
            • Create a table
          • View objects
            • Overview
            • Create a view
            • Manage views
          • Materialized view objects
            • Overview
            • Create a materialized view
            • Manage materialized views
          • Function objects
            • Overview
            • Create a function
            • Manage functions
          • Stored procedure objects
            • Overview
            • Create a stored procedure
            • Manage stored procedures
          • Sequence objects
            • Overview
            • Create a sequence
            • Manage sequences
          • Package objects
            • Overview
            • Create a program package
            • Manage program packages
          • Trigger objects
            • Overview
            • Create a trigger
            • Manage triggers
          • Type objects
            • Overview
            • Create a type
            • Manage types
          • Synonym objects
            • Overview
            • Create a synonym
            • Manage synonyms
      • Import and export
        • Import schemas and data
        • Export schemas and data
      • Database change management
        • User permission management
          • Users and roles
          • Automatic authorization
          • User permission management
        • Project collaboration management
        • Risk levels, risk identification rules, and approval processes
        • SQL check specifications
        • SQL window specification
        • Database change management
        • Batch database change management
        • Online schema changes
        • Synchronize shadow tables
        • Schema comparison
      • Data lifecycle management
        • Partitioning plan management
          • Manage partitioning plans
          • Set partitioning strategies
          • Examples
        • SQL plan task
      • Data desensitization and auditing
        • Desensitize data
        • Operation records
      • Notification management
        • Overview
        • View notification records
        • Manage notification channel
          • Create a notification channel
          • View, edit, and delete a notification channel
          • Configure a custom channel
        • Manage notification rules
      • Best practices
        • Tips for SQL development
        • Explore ODC team workspaces
        • Understanding real-time SQL diagnostics for OceanBase AP
        • OceanBase historical database solutions
        • ODC SQL check for automatic identification of high-risk operations
        • Manage and modify sharded databases and tables via ODC
        • Data masking and control practices
        • Enterprise-level control and collaboration: Safeguard every database change
    • Data development
      • Overview
      • Workspace management
      • Worksheet management
      • Compute node pool management
      • Workflow management
      • Dashboard management
      • Manage Git repositories
      • SQL development
        • SQL editing and execution
        • Result set editing
        • Execution analysis
        • Database object management
          • Create a table
          • Create a view
          • Create a function
          • Create a stored procedure
        • Session variable management
        • Git integration
      • Sample datasets
      • Data development terms
  • Manage Billing
    • Access billing
    • View bills
      • View orders
      • View transaction details
    • View monthly bills
    • View payment details
    • Manage AI service billing
      • Usage monitoring
      • View API key records
      • Rate limits & quotas
    • Payment method
      • Bank remittances and claims
      • Use vouchers for payment
    • View invoices
  • Legal Agreements
    • OceanBase Cloud Services Agreement
    • AI Service Addendum
    • Service Level Agreement
    • OceanBase Data Processing Addendum
    • Service Level Agreement for OceanBase Cloud Migration Service
    • Historical agreements
      • Service Level Agreement for OceanBase Cloud Migration Service (Released March 20, 2026)

Download PDF

Document Feedback
  1. Documentation Center
  2. OceanBase Cloud

Sample application for connecting to OceanBase Cloud using Spring Batch

Last Updated:2026-11-11 03:39:33

Prerequisites
Procedure
Step 1: Obtain the OceanBase Cloud database connection string
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
Sample project overview
Introduction to pom.xml code
Introduction to the application.properties file
Introduction to the BatchApplication.java file
Introduction to the BatchConfig.java file
Introduction to the People.java file
Introduction to the PeopleDESC.java file
Introduction to the AddPeopleDescProcessor.java file
Introduction to the AddDescPeopleWriter.java file
Introduction to the AddPeopleWriter.java file
Introduction to the BatchConfigTest.java file
Introduction to the AddPeopleDescProcessorTest.java file
Introduction to the AddDescPeopleWriterTest.java file
Introduction to the AddPeopleWriterTest.java file
Complete sample code
References

This topic describes how to build an application using the Spring Batch framework and OceanBase Cloud to perform basic operations such as creating tables, inserting data, and querying data.

Download the sample project

Prerequisites

  • You have registered an OceanBase Cloud account and created a cluster instance and an OceanBase Cloud tenant in Oracle-compatible mode. For more information, see Create a cluster instance and Create a tenant.
  • 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 that suits your personal preference to run the sample code.

Procedure

Note

The procedure described in this topic is based on the Windows environment. If you are using a different operating system or compiler, the steps may vary slightly.

  1. Obtain the connection string for the OceanBase Cloud database.
  2. Import the java-oceanbase-springbatch project into IntelliJ IDEA.
  3. Modify the database connection information in the java-oceanbase-springbatch project.
  4. Run the java-oceanbase-springbatch project.

Step 1: Obtain the OceanBase Cloud database connection string

  1. Log in to the OceanBase Cloud console. On the instance list page, expand the target instance's information, and under the target tenant, select Connect > Get connection string.

    For more detailed operations, see Obtain a connection string.

  2. Fill in the corresponding information in the URL below based on your created OceanBase Cloud database.

    Example URL for connecting to an OceanBase Cloud database in Oracle-compatible mode:

    jdbc:oceanbase://$host:$port/$schema_name?user=$user_name&password=$password
    

    Parameter description:

    • $host: The connection address for the OceanBase Cloud database, for example, t********.********.oceanbase.cloud.
    • $port: The connection port for the OceanBase Cloud database, default is 1521.
    • $schema_name: The name of the schema to access.
    • $user_name: The account for accessing the database.
    • $password: The password for the account.

    For more information about URL parameters, see Database URL.

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

  1. Open IntelliJ IDEA and select File > Open....

  2. In the Open File or Project window, select the corresponding project file and click OK to import it.

  3. IntelliJ IDEA automatically recognizes the various files in the project. In the Project tool window, you can view the project's directory structure, file list, module list, dependencies, and other information. The Project tool window is usually located on the far left side of the IntelliJ IDEA interface and is open by default. If the Project tool window is closed, you can reopen it by clicking View > Tool Windows > Project in the menu bar or using the shortcut key Alt + 1.

    Note

    When importing a project with IntelliJ IDEA, it automatically detects the pom.xml file in the project, downloads the required dependency libraries based on the dependencies described in the file, and adds them to the project.

  4. View the project.

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 OceanBase Cloud connection string.

Example:

  • The database driver name is: com.oceanbase.jdbc.Driver.
  • The OceanBase Cloud connection address is t5******.********.oceanbase.cloud.
  • The access port is 1521.
  • The name of the schema to access is sys.
  • The tenant connection account is oracle001.
  • The password is ******.

Sample code:

spring.datasource.driver-class-name=com.oceanbase.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://t5******.********.oceanbase.cloud:1521/sys?characterEncoding=utf-8
spring.datasource.username=oracle001
spring.datasource.password=******

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

spring.batch.job.enabled=false

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

Step 4: Run the java-oceanbase-springbatch project

  • Run the AddDescPeopleWriterTest.java file.

    1. Locate the AddDescPeopleWriterTest.java file in the src > test > java directory of the project structure.
    2. In the toolbar menu, select Run > Run... > AddDescPeopleWriterTest.testWrite, or directly click the green triangle in the upper-right corner to run it.
    3. View the project's log information and output results through IDEA's console.
    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. Locate the AddPeopleWriterTest.java file in the src > test > java directory of the project structure.
    2. In the toolbar menu, select Run > Run... > AddPeopleWriterTest.testWrite, or directly click the green triangle in the upper-right corner to run it.
    3. View the project's log information and output results through IDEA's console.
    Data in the people table:
    People [name=zhangsan, age=27]
    People [name=lisi, age=35]
    Batch Job execution completed.
    

Sample project overview

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

After decompressing it, you will get 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 for the Maven project, containing information such as project dependencies, plugins, and build settings.
  • .idea: A directory used by the IDE (Integrated Development Environment) to store project-related configuration information.
  • src: Typically denotes the directory that holds the project's source code.
  • main: The directory for storing the main source code and resource files.
  • java: The directory for storing Java source code.
  • com: The root directory for Java packages.
  • oceanbase: The root directory for the project.
  • example: The root directory for the project.
  • batch: The main package name of the project.
  • BatchApplication.java: The entry class of the application, containing the main method.
  • config: The folder for configuration classes, containing the application's configuration classes.
  • BatchConfig.java: The application's configuration class, used to configure some properties and behaviors of the application.
  • model: The folder for model classes, containing the application's data model classes.
  • People.java: A personnel data model class.
  • PeopleDESC.java: A personnel DESC data model class.
  • processor: The folder for processor classes, containing the application's processor classes.
  • AddPeopleDescProcessor.java: A processor class for adding personnel DESC information.
  • writer: The folder for writer classes, containing the application's writer classes.
  • AddDescPeopleWriter.java: A writer class for writing personnel DESC information.
  • AddPeopleWriter.java: A writer class for writing personnel information.
  • resources: The resource folder, containing the application's configuration files and other static resource files.
  • application.properties: The application's configuration file, used to configure application properties.
  • test: The directory for storing test code and resource files.
  • BatchConfigTest.java: The test class for the application's configuration class.
  • AddPeopleDescProcessorTest.java: The test class for the add-personnel-desc processor.
  • AddDescPeopleWriterTest.java: The test class for the writer that writes personnel DESC information.
  • AddPeopleWriterTest.java: The test class for the writer that writes personnel information.
  • target: The directory for storing compiled class files, JAR packages, and other files.

Introduction to pom.xml code

Note

If you just want to verify the example, use the default code without modification. You can also modify the pom.xml file according to your needs as described below.

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

  1. The file declaration statement.

    Declares that this file is an XML file, using XML version 1.0 and character encoding UTF-8.

    Code:

    <?xml version="1.0" encoding="UTF-8"?>
    
  2. Configure the POM namespace and 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, http://maven.apache.org/POM/4.0.0, and the location of its XSD file, https://maven.apache.org/xsd/maven-4.0.0.xsd.
    4. Use the <modelVersion> element to specify the POM model version used by this POM file as 4.0.0.

    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>
    
  3. Configure 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.

    Code:

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

    1. Use <groupId> to set the group ID to com.oceanbase.
    2. Use <artifactId> to set the artifact ID to java-oceanbase-springboot.
    3. Use <version> to specify the project version as 0.0.1-SNAPSHOT.
    4. Use description to introduce the project information as Demo project for Spring Batch.

    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>
    
  5. 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>
    
  6. Configure core dependencies.

    1. Specify the dependency's organization as org.springframework.boot and its name as spring-boot-starter. This dependency allows you to use the component dependencies supported by Spring Boot by default, including features for web, data processing, security, and testing.

      Sample code:

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter</artifactId>
      </dependency>
      
    2. Specify the dependency's organization as org.springframework.boot and its name as spring-boot-starter-jdbc. This dependency enables you to use JDBC-related features provided by Spring Boot, such as connection pooling and data source configuration.

      Sample code:

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-jdbc</artifactId>
      </dependency>
      
    3. Specify the dependency's organization as org.springframework.boot and its name as spring-boot-starter-test, with a scope of test. This dependency allows you to use the testing frameworks 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 dependency's organization as com.oceanbase, its name as oceanbase-client, and its version as 2.4.3. This dependency enables you to use 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.3</version>
          </dependency>
      
    5. Specify the dependency's organization as org.springframework.boot and its name as spring-boot-starter-batch. This dependency enables you to use batch processing features provided by Spring Boot.

      Sample code:

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-batch</artifactId>
      </dependency>
      
    6. Specify the dependency's organization as org.springframework.boot and its name as spring-boot-starter-data-jpa. This dependency enables you to use 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 dependency's organization as org.apache.tomcat and its name as tomcat-jdbc. This dependency enables you to use 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 dependency's test architecture as junit, name as junit, version as 4.10, and scope as test. This dependency is used to add configuration for the JUnit unit test dependency.

      Sample code:

      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.10</version>
          <scope>test</scope>
      </dependency>
      
    9. Specify the dependency's organization as javax.activation, name as javax.activation-api, and version as 1.2.0. This dependency is used to 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 dependency's organization as jakarta.persistence, name as jakarta.persistence-api, and version as 2.2.3. This dependency is used to add configuration for the Jakarta Persistence API. Sample code:

      <dependency>
          <groupId>jakarta.persistence</groupId>
          <artifactId>jakarta.persistence-api</artifactId>
          <version>2.2.3</version>
      </dependency>
      
  7. Configure Maven plugins.

    Specify the dependency's organization as org.springframework.boot and name as spring-boot-maven-plugin. This plugin is used to package Spring Boot applications into executable JAR or WAR packages that can be run directly.

    Sample code:

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

Introduction to the application.properties file

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

  1. Database connection configuration.

    • Use spring.datasource.driver to specify the database driver as com.oceanbase.jdbc.Driver, which is used to establish a connection with OceanBase Cloud.
    • Use spring.datasource.url to specify the URL for connecting to the database.
    • Use spring.datasource.username to specify the username for connecting to the database.
    • Use spring.datasource.password to specify the password for connecting to the database.

    Sample code:

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

    • Use spring.jpa.show-sql to specify whether to display SQL statements in the logs. Setting it to true means SQL statements will be displayed.
    • Use spring.jpa.hibernate.ddl-auto to specify the DDL operation behavior of Hibernate. Here it is set to update, meaning the database schema is automatically updated when the application starts.

    Sample code:

    spring.jpa.show-sql=true
    spring.jpa.hibernate.ddl-auto=update
    
  3. Spring Batch configuration:

    Use the spring.batch.job.enabled property to specify whether to enable Spring Batch jobs. Set this property to false to disable Spring Batch jobs.

    Sample code:

    spring.batch.job.enabled=false
    
  4. Logging configuration:

    • Use the logging.level.org.springframework property to set the log level for the Spring framework to INFO.
    • Use the logging.level.com.example property to set the log level for application custom code to DEBUG.

    Sample code:

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

Introduction to the BatchApplication.java file

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

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

  1. References to other classes and interfaces.

    Declare that this file contains the following interfaces and classes:

    • SpringApplication class: used to start a Spring Boot application.
    • SpringBootApplication annotation: used to mark this class as the entry point of the Spring Boot application.

    Sample code:

        import org.springframework.boot.SpringApplication;
        import org.springframework.boot.autoconfigure.SpringBootApplication;
    
  2. Definition of the BatchApplication class.

    Use the @SpringBootApplication annotation to mark the BatchApplication class as the entry point of the Spring Boot application. Define a static main method in the BatchApplication class as the application's entry point. In this method, use the SpringApplication.run method to start the Spring Boot application. Also define a method named runBatchJob to run the batch processing job.

    Sample code:

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

Introduction to the BatchConfig.java file

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

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

  1. References to other classes and interfaces.

    Declare that this file contains the following interfaces and classes:

    • People class: used to store the personnel information read from the database.
    • PeopleDESC class: used to store the descriptive information after converting or processing the personnel information.
    • AddPeopleDescProcessor class: implements the ItemProcessor interface and converts the read People objects into PeopleDESC objects.
    • AddDescPeopleWriter class: implements the ItemWriter interface and writes the PeopleDESC objects to the target location.
    • Job interface: represents a batch processing job.
    • Step interface: represents a step in a job.
    • EnableBatchProcessing annotation: a Spring Batch configuration annotation used to enable and configure the Spring Batch processing feature.
    • JobBuilderFactory class: used to create and configure jobs.
    • StepBuilderFactory class: used to create and configure steps.
    • RunIdIncrementer class: an auto-incrementer for the run ID (Run ID) of Spring Batch, used to increase the run ID each time a job is executed.
    • ItemProcessor interface: used to process or convert the read items.
    • ItemReader interface: used to read items from a 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 to create and configure beans.
    • ComponentScan annotation: used to specify the package or class for component scanning.
    • Configuration annotation: used to mark a class as a configuration class.
    • EnableAutoConfiguration annotation: used to enable automatic configuration of Spring Boot.
    • SpringBootApplication annotation: used to mark this class as the entry point 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;
    
  2. Define the BatchConfig class.

    This is a simple Spring Batch job. It defines how data is read, processed, and written, and encapsulates these steps into a job. Using Spring Batch annotations and auto-configuration, you can create corresponding component instances through the various @Bean methods in the configuration class, and use these components in step1 to complete data reading, processing, and writing.

    • The @Configuration annotation indicates that this class is a configuration class.
    • The @EnableBatchProcessing annotation enables the Spring Batch processing feature. It automatically creates necessary beans, such as JobRepository and JobLauncher.
    • The @SpringBootApplication annotation is used for the main class of a Spring Boot application and serves as the startup point of the application.
    • The @ComponentScan annotation specifies the package for component scanning, telling Spring to scan and register all components in this package and its subpackages.
    • The @EnableAutoConfiguration annotation enables the infrastructure for automatic configuration of the 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, StepBuilderFactory is a factory class for creating and configuring steps, and 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.

      The @Bean annotation is used to define several methods for creating the reader, processor, writer, step, and job of the batch processing job.

      • The peopleReader method creates an instance of the ItemReader component. This component uses JdbcCursorItemReader to read People object data from the database. Set the data source dataSource, configure the RowMapper to map database rows to People objects, and set the SQL query statement to SELECT * FROM people.

      • The addPeopleDescProcessor method creates an instance of the ItemProcessor component. This component uses AddPeopleDescProcessor to process People objects and returns them converted into PeopleDESC objects.

      • The addDescPeopleWriter method creates an instance of the ItemWriter component. This component uses AddDescPeopleWriter to write PeopleDESC objects to the target location.

      • The step1 method creates an instance of the Step component with the name step1. It obtains the step builder through stepBuilderFactory.get, sets the reader as the ItemReader component, the processor as the ItemProcessor component, the writer as the ItemWriter component, sets the chunk size to 10, and finally calls build to construct and return the configured Step.

      • The importJob method creates an instance of the Job component with the name importJob. It obtains the job builder through jobBuilderFactory.get, sets the incrementer as RunIdIncrementer, sets the initial step of the job's flow as Step, and finally calls build to construct 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();
        }
        

Introduction to the People.java file

The People.java file defines a data model for the People class, which represents a person's information. The 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. Here, name represents the person's name, and age represents the person's age. These attributes can be accessed and modified using the getter and setter methods.

This class serves as a way to store and pass data for input and output in the batch processing program. In batch processing read and write operations, People objects are used to store data, set data using the setter method, and retrieve data using the getter method.

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
    }

Introduction to the PeopleDESC.java file

The PeopleDESC.java file defines a data model for the PeopleDESC class, which represents a person's information. The PeopleDESC class has four attributes: name, age, desc, and id, representing the person's name, age, description, and identifier, respectively. The class includes corresponding getter and setter methods to access and set 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 pass data in the input and output of the batch processing program.

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

Introduction to the AddPeopleDescProcessor.java file

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

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

  1. References to other classes and interfaces.

    Declare that this 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 converting or processing personnel information.
    • ItemProcessor interface: used to process or convert the read items.

    Code:

    import com.oceanbase.example.batch.model.People;
    import com.oceanbase.example.batch.model.PeopleDESC;
    import org.springframework.batch.item.ItemProcessor;
    
  2. Definition of the AddPeopleDescProcessor class.

    The AddPeopleDescProcessor class, which implements the ItemProcessor interface, is used to convert People objects into PeopleDESC objects, implementing the processing logic for input data during batch processing.

    In the process method of this class, first create a PeopleDESC object named desc. Then, obtain the properties (name and age) of the People object through the item parameter and set these properties to the desc object. Also, assign a value to the desc property of the desc object. The assignment logic generates a descriptive string based on the properties of the People object. Finally, return the processed PeopleDESC object.

    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 the AddDescPeopleWriter.java file

The AddDescPeopleWriter.java file defines AddDescPeopleWriter, which implements ItemWriter<PeopleDESC> and writes PeopleDESC objects to the database.

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

  1. References to other classes and interfaces.

    Declare that this file contains the following interfaces and classes:

    • PeopleDESC class: used to store descriptive information after converting or processing personnel information.
    • 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.
    • List interface: used to operate on query result sets.

    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;
    
  2. Definition of the AddDescPeopleWriter class.

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

      Sample code:

          @Autowired
          private JdbcTemplate jdbcTemplate;
      
    2. In the write method, iterate through the passed List<? extends PeopleDESC> and retrieve each PeopleDESC object in sequence. First, execute the SQL statement DROP TABLE people_desc to drop any existing table named people_desc. 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 {
              // Delete any existing tables first.
              jdbcTemplate.execute("DROP TABLE people_desc");
              // CREATE TABLE Statement
              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 the AddPeopleWriter.java file

The AddPeopleWriter.java file defines AddPeopleWriter, which implements ItemWriter<People> and writes People objects to the database.

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

  1. References to other classes and interfaces.

    Declare that this file contains the following interfaces and classes:

    • The People class: used to store personnel information read from the database.
    • The ItemWriter interface: used to write processed or transformed items to a specified target location.
    • The Autowired annotation: used for dependency injection.
    • The JdbcTemplate class: provides methods for executing SQL statements.
    • The Component annotation: used to mark this class as a Spring component.
    • The List interface: used to manipulate query result sets.

    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;
    
  2. Definition of the AddPeopleWriter class.

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

      Sample code:

          @Autowired
          private JdbcTemplate jdbcTemplate;
      
    2. In the write method, iterate through the passed List<? extends People> and retrieve each People object in sequence. First, execute the SQL statement DROP TABLE people to drop any existing table named people. Then, execute the SQL statement CREATE TABLE people (name VARCHAR2(255), age INT) to create a table named people with two columns: name and age. 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 any existing tables first.
          jdbcTemplate.execute("DROP TABLE people");
          // CREATE TABLE Statement
          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 the BatchConfigTest.java file

The BatchConfigTest.java file is a test class using JUnit to test job configurations for Spring Batch.

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

  1. References to other classes and interfaces.

    Declares that this file contains the following interfaces and classes:

    • Assert class: used to assert test results.
    • Test annotation: used to mark test methods.
    • RunWith annotation: used to specify the test runner.
    • Job interface: represents a batch processing job.
    • JobExecution class: used to represent the execution of a batch processing job.
    • JobParameters class: used to represent the parameters of a batch processing job.
    • JobParametersBuilder class: used to build the parameters for a batch processing job.
    • JobLauncher interface: used to start a batch processing job.
    • Autowired annotation: used for dependency injection.
    • SpringBootTest annotation: used to specify the test class as a Spring Boot test.
    • SpringRunner class: used to specify the test runner as SpringRunner.

    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 org.springframework.batch.core.BatchStatus;
    
  2. Definition of the BatchConfigTest class.

    By using the SpringBootTest annotation and the SpringRunner runner, you can perform integration testing for Spring Boot. In the testJob method, use the JobLauncherTestUtils utility class to start a batch processing job and use assertions to verify the job's execution status.

    1. Use the @Autowired annotation to automatically inject an instance of JobLauncherTestUtils.

      Code:

      @Autowired
      private JobLauncherTestUtils jobLauncherTestUtils;
      
    2. Use the @Test annotation to mark the testJob method as a test method. In this method, first create a JobParameters object, then use the jobLauncherTestUtils.launchJob method to start the batch processing job, and use the Assert.assertEquals method to assert that the job's execution status is COMPLETED.

      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 an instance of JobLauncher.

      Code:

      @Autowired
      private JobLauncher jobLauncher;
      
    4. Use the @Autowired annotation to automatically inject an instance of Job.

      Code:

      @Autowired
      private Job job;
      
    5. Defined an inner class named JobLauncherTestUtils to assist in launching the batch processing job. Within this class, a launchJob method is defined to start the batch processing job. In this method, the jobLauncher.run method is used to launch the job and return its execution result.

      Sample code:

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

Introduction to the AddPeopleDescProcessorTest.java file

The AddPeopleDescProcessorTest.java file is a test class that uses JUnit to test job configurations in Spring Batch.

The code in the AddPeopleDescProcessorTest.java file mainly includes the following parts:

  1. References to other classes and interfaces.

    Declares that this file contains the following interfaces and classes:

    • People class: used to store personnel information read from the database.
    • PeopleDESC class: used to store description information after converting or processing personnel information.
    • Test annotation: used to mark test methods.
    • RunWith annotation: used to specify the test runner.
    • Autowired annotation: used for dependency injection.
    • SpringBootTest annotation: used to specify the test class as a Spring Boot test.
    • SpringRunner 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.jupiter.api.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
  2. Definition of the AddPeopleDescProcessorTest class.

    Performs integration testing for Spring Boot by using the SpringBootTest annotation and the SpringRunner runner.

    1. Automatically injects an instance of AddPeopleDescProcessor using the @Autowired annotation.

      Sample code:

      @Autowired
      private AddPeopleDescProcessor processor;
      
    2. Marks the testProcess method as a test method using the @Test annotation. In this method, first create a People object, then process the object using the processor.process method, and assign the result to a PeopleDESC object.

      Sample code:

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

Introduction to the AddDescPeopleWriterTest.java file

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

The code in the AddDescPeopleWriterTest.java file mainly includes the following parts:

  1. References to other classes and interfaces.

    Declares that this file contains the following interfaces and classes:

    • PeopleDESC class: used to store the description information after converting or processing personnel information.
    • Assert class: used to assert test results.
    • Test annotation: used to mark a test method.
    • RunWith annotation: used to specify the test runner.
    • Autowired annotation: used for dependency injection.
    • SpringBootTest annotation: used to specify that the test class is a Spring Boot test.
    • JdbcTemplate class: provides methods for executing SQL statements.
    • SpringRunner class: used to specify the test runner as SpringRunner.
    • ArrayList class, used to create an empty list.
    • List interface: used to operate on query result sets.

    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;
    
  2. Define the AddDescPeopleWriterTest class.

    Use the SpringBootTest annotation and the SpringRunner runner to perform integration testing for Spring Boot.

    1. Use @Autowired to inject instances. Use the @Autowired annotation to automatically inject instances of AddPeopleDescProcessor and JdbcTemplate.

      Sample code:

      @Autowired
      private AddDescPeopleWriter writer;
      @Autowired
      private JdbcTemplate jdbcTemplate;
      
    2. Use @Test to test data insertion and output. 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 it. Then use the writer.write method to write the data in the list to the database. Next, use jdbcTemplate to execute a query statement, retrieve data from the people_desc table, and use assertion statements to verify the correctness of the data. Finally, output the query results to the console and print a message indicating the job has completed.

      1. Insert data into the people_desc table. First, create an empty PeopleDESC object list named peopleDescList. Then create two PeopleDESC objects named desc1 and desc2, and set their attribute values respectively. 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 get the number of records in the people_desc table and assign the result to the variable count. Finally, use the Assert.assertEquals method to assert whether the value of count equals 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 the data in the people_desc table. First, 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 like rs.getInt and rs.getString to retrieve field values from the query result set and set them into a newly created PeopleDESC object. Add each newly created PeopleDESC object to a result list named resultDesc. Then print a prompt line Data in the people_desc table:. Use a for loop to iterate through each PeopleDESC object in the resultDesc list and print its content using System.out.println. Finally, print a message indicating the job has 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("Data in the people_desc table:");
        for (PeopleDESC desc : resultDesc) {
           System.out.println(desc);
        }
        
        // Output information after the job is completed
        System.out.println("Batch Job execution completed.");
        

Introduction to the AddPeopleWriterTest.java file

The AddPeopleWriterTest.java file is a test class that uses JUnit to test the write logic of AddPeopleWriter.

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

  1. References to other classes and interfaces.

    Declare that this file contains the following interfaces and classes:

    • People class: used to store personnel information read from the database.
    • Test annotation: used to mark test methods.
    • RunWith annotation: used to specify the test runner.
    • Autowired annotation: used for dependency injection.
    • SpringBootApplication annotation: used to mark this class as the entry point of a Spring Boot application.
    • SpringBootTest annotation: used to specify the test class as a Spring Boot test.
    • ComponentScan annotation: used to specify the package or class for component scanning.
    • JdbcTemplate class: provides methods for executing SQL statements.
    • SpringRunner class: used to specify the test runner as SpringRunner.
    • ArrayList class, used to create an empty list.
    • List interface: used to operate on query result sets.

    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;
    
  2. Definition of the AddPeopleWriterTest class.

    Use the SpringBootTest annotation and the SpringRunner runner to perform integration testing with Spring Boot, and use the @ComponentScan annotation to specify the package path to scan.

    1. Inject instances using @Autowired. Use the @Autowired annotation to automatically inject instances of addPeopleWriter and JdbcTemplate.

      Code:

      @Autowired
      private AddPeopleWriter addPeopleWriter;
      @Autowired
      private JdbcTemplate jdbcTemplate;
      
    2. Use @Test to test data insertion and output.

      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 properties. Next, add these two People objects to the peopleList list. After that, call the write method of addPeopleWriter, passing peopleList as a parameter to write these People objects to the database.

        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 from the people table. First, use JdbcTemplate to execute a query statement SELECT * FROM people and process the query results using a lambda expression. In the lambda expression, use the rs.getString and rs.getInt methods to retrieve field values from the query result set and set them into a newly created People object. Add each newly created People object to a result list named result. Then, print a prompt line Data in the people table:. Next, use a for loop to iterate through each People object in the result list and print the content of each object using System.out.println. Finally, print a message indicating the job has completed.

        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("Data in the people table:");
           for (People person : result) {
               System.out.println(person);
           }
        
           // Output information after the job is completed
           System.out.println("Batch Job execution completed.");
        

Complete sample 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.oceanbase.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://host:port/schema_name?characterEncoding=utf-8
spring.datasource.username=user_name
spring.datasource.password=

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

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

#
logging.level.org.springframework=INFO
logging.level.com.example=DEBUG
package com.oceanbase.example.batch;

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

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

    public void runBatchJob() {
    }
}

package com.oceanbase.example.batch.config;

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

import javax.sql.DataSource;
//import javax.activation.DataSource;

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

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Autowired
    private DataSource dataSource; // Use the default dataSource provided by Spring Boot's 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 {
        // Delete any existing tables first.
        jdbcTemplate.execute("DROP TABLE people_desc");
        // CREATE TABLE Statement
        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 {
        // Delete any existing tables first.
        jdbcTemplate.execute("DROP TABLE people");
        // CREATE TABLE Statement
        String createTableSql = "CREATE TABLE people (name VARCHAR2(255), age INT)";
        jdbcTemplate.execute(createTableSql);
        for (People item : items) {
            String sql = "INSERT INTO people (name, age) VALUES (?, ?)";
            jdbcTemplate.update(sql, item.getName(), item.getAge());
        }
    }
}

package com.oceanbase.example.batch.config;

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

import org.springframework.batch.core.BatchStatus;

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

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

        JobExecution jobExecution = jobLauncherTestUtils.launchJob(jobParameters);

        Assert.assertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());
    }

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private Job job;

    private class JobLauncherTestUtils {
        public JobExecution launchJob(JobParameters jobParameters) throws Exception {
            return jobLauncher.run(job, jobParameters);
        }
    }
}
package com.oceanbase.example.batch.processor;

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

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

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

        PeopleDESC desc = processor.process(people);

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

package com.oceanbase.example.batch.writer;

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

import java.util.ArrayList;
import java.util.List;

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

    @Test
    public void testWrite() throws Exception {

        // 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 the 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 information after the job is completed
        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 results
        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 information after the job is completed
        System.out.println("Batch Job execution completed.");
    }
}

References

For more information about OceanBase Connector/J, see OceanBase JDBC Driver

Previous topic

Connect to OceanBase Cloud using Spring Boot
Last

Next topic

Connect to OceanBase Cloud by using Spring JDBC
Next
on this page
Prerequisites
Procedure
Step 1: Obtain the OceanBase Cloud database connection string
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
Sample project overview
Introduction to pom.xml code
Introduction to the application.properties file
Introduction to the BatchApplication.java file
Introduction to the BatchConfig.java file
Introduction to the People.java file
Introduction to the PeopleDESC.java file
Introduction to the AddPeopleDescProcessor.java file
Introduction to the AddDescPeopleWriter.java file
Introduction to the AddPeopleWriter.java file
Introduction to the BatchConfigTest.java file
Introduction to the AddPeopleDescProcessorTest.java file
Introduction to the AddDescPeopleWriterTest.java file
Introduction to the AddPeopleWriterTest.java file
Complete sample code
References