Connect to OceanBase Database from SpringBoot Application

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

Download the java-oceanbase-springboot sample project

Prerequisites

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

Procedure

1. Obtain the connection information of OceanBase Database.
2. Import the java-oceanbase-springboot project into IntelliJ IDEA.
3. Modify the database connection information in the java-oceanbase-springboot project.
4. Run the java-oceanbase-springboot project.

Step 1: Obtain the connection information of OceanBase Database

1. Contact the deployment personnel or administrator of OceanBase Database to obtain the corresponding database connection information.

   obclient -hxx.xx.xx.xx -P2883 -uroot@sys#cluster -p**** -A
   

2. Fill in the URL below based on the OceanBase Database that has been deployed.

   Note

   The URL is required in the application.properties file.

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

   Parameter description:

   • host: the IP address for connecting to OceanBase Database. For connection through ODP, use the IP address of an ODP. For direct connection, use the IP address of an OBServer node.

   • port: the port for connecting to OceanBase Database. For connection through ODP, the default value is 2883, which can be customized when ODP is deployed. For direct connection, the default value is 2881, which can be customized when OceanBase Database is deployed.

   • schema_name: the name of the schema to be accessed.

   • user_name: the username specified after the -u parameter. The format is username@tenant name#cluster name or username@SERVICE:service name. If you use the format username@tenant name#cluster name, the default tenant is sys and the default administrator is root. When you use direct connection, you can omit the cluster name. However, when you use connection through ODP, you must specify the cluster name. The username and password of the account must have the privilege to access the specified schema.

   • password: the password of the account.

   • useSSL=false&useUnicode=true&characterEncoding=utf-8: the additional connection properties.

     • useSSL: specifies whether to use SSL/TLS for forced connections. Default value: false.
     • useUnicode: specifies the encoding and decoding format for characters. Default value: true.
     • characterEncoding: specifies the character encoding supported by the database URL option. Default value: utf8.

For more information about URL parameters, see Database URL.

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

1. Start IntelliJ IDEA and choose File > Open....

   

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

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

   Note

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

4. View the project.

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

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

Here is an example:

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

Sample code:

spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://10.10.10.1:2881/test?useSSL=false&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root@mysq001
spring.datasource.password=******

Step 4: Run the java-oceanbase-springboot project

Running path

1. In the project structure, locate the src > test > java path and find the TestSpringbootApplicationTests.java file.
2. From the toolbar, choose Run(U) > Run > TestSpringbootApplicationTests or simply click the green triangle in the upper right corner.
3. In the console of IntelliJ IDEA, view the project logs and output results.

Running result

test_springboot delete successfully!
test_springboot create successfully!
user = User{id=2, name='update'}
User{id=2, name='update'}
User{id=3, name='insert3'}
User{id=4, name='insert4'}
User{id=5, name='insert5'}
User{id=6, name='insert6'}
User{id=7, name='insert7'}
User{id=8, name='insert8'}
User{id=9, name='insert9'}
User{id=10, name='insert10'}

FAQ

1. Connection timeout

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

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

2. Character set issue

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

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

3. SSL connection

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

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

4. Special characters in account name or password

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

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

Project code introduction

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

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

│--pom.xml
│
├─.idea
├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─oceanbase
│  │  │          └─testspringboot
│  │  │              │--TestSpringbootApplication.java
│  │  │              │
│  │  │              ├─dao
│  │  │              │  │--UserDao.java
│  │  │              │  │
│  │  │              │  └─impl
│  │  │              │      └─--UserDaoImpl.java
│  │  │              │
│  │  │              └─entity
│  │  │                  └─--User.java
│  │  │
│  │  └─resources
│  │      └─--application.properties
│  │
│  └─test
│      └─java
│          └─com
│              └─oceanbase
│                  └─testspringboot
│                      └─--TestSpringbootApplicationTests.java
│
└─target

File description:

• pom.xml: the configuration file of the Maven project, which contains the dependencies, plugins, and build details of the project.
• .idea: the directory used for storing project-related configuration information in the Integrated Development Environment (IDE).
• src: a directory that is generally used to store the source code of a project.
• main: a directory that stores the main source code and resource files.
• java: a directory that stores the Java source code.
• com: the root directory that stores the Java package.
• oceanbase: the root directory that stores the project.
• testspringboot: the root directory of the Java package, which contains all the Java classes of the project.
• TestSpringbootApplication.java: the main class of the project, which contains the main method.
• dao: a directory that stores the Data Access Object (DAO) packages for accessing databases or other data storage services.
• UserDao.java: the user DAO, which is used for performing CRUD operations on user data.
• impl: a directory that stores the implementations of the DAO interfaces.
• UserDaoImpl.java: the implementation class of the user DAO interface.
• entity: a directory that stores the entity classes, which are the Java classes corresponding to the database tables.
• User.java: the persistent object of users, which is used for mapping the fields of the user data table.
• resources: a directory that stores the resource files, such as configuration files and SQL files.
• application.properties: the configuration file of the project, which is used for configuring the properties and parameters of the application.
• test: a directory that stores the test code and resource files.
• TestSpringbootApplicationTests.java: a Java class that stores the test code for Spring Boot.
• target: a directory that stores the compiled class files and JAR packages.

Introduction to pom.xml

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

1. Declaration statement.

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

   Sample code:

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

2. Configure the namespaces and the POM model version.

   1. Use xmlns to specify the POM namespace as http://maven.apache.org/POM/4.0.0.
   2. Use xmlns:xsi to specify the XML namespace as http://www.w3.org/2001/XMLSchema-instance.
   3. Use xsi:schemaLocation to specify the POM namespace as http://maven.apache.org/POM/4.0.0, and the URI of the corresponding XSD file as https://maven.apache.org/xsd/maven-4.0.0.xsd.
   4. Use <modelVersion> to specify the POM model version as 4.0.0.

   Sample code:

   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
   </project>
   

3. Configure the parent information.

   1. Use <groupId> to specify the parent group ID as org.springframework.boot.
   2. Use <artifactId> to specify the parent artifact ID as spring-boot-starter-parent.
   3. Use <version> to specify the parent version as 2.7.11.
   4. Use relativePath to indicate that the parent path is empty.

   Sample code:

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

4. Configure basic information.

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

   Sample code:

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

5. Configure the Java version.

   Specify the Java version for the project as 1.8.

   Sample code:

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

6. Configure core dependencies.

   1. Specify the dependency group ID as org.springframework.boot, the artifact ID as spring-boot-starter, and the dependency library contains component dependencies that are supported by default in Spring Boot, including web, data processing, security, and test features.

      Sample code:

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

   2. Specify the dependency group ID as org.springframework.boot, the artifact ID as spring-boot-starter-jdbc, and the dependency allows you to use JDBC-related features provided by Spring Boot, such as connection pools and data source configurations.

      Sample code:

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

   3. Specify the dependency group ID as org.springframework.boot, the artifact ID as spring-boot-starter-test, and the scope as test. The dependency allows you to use test 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 group ID as com.oceanbase, the artifact ID as oceanbase-client, and the version as 2.4.3. The dependency allows you to use client features provided by OceanBase Database, such as connection, query, and transaction.

      Sample code:

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

7. Configure the Maven plugin.

   Specify the dependency group ID as org.springframework.boot, and the artifact ID as spring-boot-maven-plugin. The plugin is used to package a Spring Boot application into an executable JAR or WAR file, and you can run the file directly.

   Sample code:

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

application.properties code

The application.properties file configures the data source for the Spring Boot application and specifies the driver class name, URL, username, and password required to connect to OceanBase Database. With these configurations, the application can connect to and operate OceanBase Database.

• The value of spring.datasource.driverClassName is set to com.oceanbase.jdbc.Driver, which specifies the database driver for connecting to OceanBase Database.

• The value of spring.datasource.url is the URL for connecting to the database.

• The value of spring.datasource.username is the username for connecting to the database.

• The value of spring.datasource.password is the password for connecting to the database.

  Sample code:

  spring.datasource.driverClassName=com.oceanbase.jdbc.Driver
  spring.datasource.url=jdbc:oceanbase://host:port/schema_name?useSSL=false&useUnicode=true&characterEncoding=utf-8
  spring.datasource.username=user_name
  spring.datasource.password=******
  

Introduction to UserDaoImpl.java

The UserDaoImpl.java file uses a JdbcTemplate object to execute SQL statements for inserting, deleting, updating, and querying data in the user table.

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

1. Reference other classes and interfaces.

   Declare the package name of the current file as com.oceanbase.testspringboot.dao.impl, which contains the following interfaces and classes:

   • UserDao: the interface for implementing the methods defined in the UserDao interface.
   • User: a class for passing and storing user data.
   • Autowired: a annotation for injecting the JdbcTemplate object into this class to execute SQL statements.
   • BeanPropertyRowMapper: a class for mapping the query result set from the database into a list of Java objects.
   • JdbcTemplate: a class for executing SQL statements and handling database access.
   • Repository: a annotation used to mark the Spring Data repository component.
   • List: an interface for operating on the query result collection.

   Sample code:

   import com.oceanbase.testspringboot.dao.UserDao;
   import com.oceanbase.testspringboot.entity.User;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.jdbc.core.BeanPropertyRowMapper;
   import org.springframework.jdbc.core.JdbcTemplate;
   import org.springframework.stereotype.Repository;
   import java.util.List;
   

2. Define the UserDaoImpl class.

   Use the Repository annotation to specify the Bean name of this class as userDao, and use the JdbcTemplate object to insert, delete, update, and query data in the User table by executing SQL statements.

   1. Insert user information.

      Call the insert method of the JdbcTemplate object to insert the ID and name of a user into the test_springboot table in the database. The method then returns a boolean value that indicates the result of the insertion operation.

      Sample code:

      @Autowired
          private JdbcTemplate jdbcTemplate; //Jdbc connection tool class
          @Override
          public boolean insertUser(User user) {
              String sql = "insert into test_springboot(id,name)values(?,?)";
              Object[] params = {user.getId(), user.getName()};
              return jdbcTemplate.update(sql, params) > 0;
          }
      

   2. Delete user information.

      Call the delete method of the JdbcTemplate object to delete a user from the database based on the user ID. The method then returns a boolean value that indicates the result of the deletion operation.

      Sample code:

      @Override
      public boolean deleteById(Long id) {
          String sql = "delete from test_springboot where id=?";
          Object[] params = {id};
          return jdbcTemplate.update(sql, params) > 0;
      }
      

   3. Update user information.

      Call the update method of the JdbcTemplate object to update the name of a user in the test_springboot table in the database based on the user ID. The method then returns a boolean value that indicates the result of the update operation.

      Sample code:

      @Override
      public boolean updateUser(User user) {
          String sql = "update test_springboot set name=? where id=?";
          Object[] params = {user.getName(), user.getId()};
          return jdbcTemplate.update(sql, params) > 0;
      }
      

   4. Query user information.

      Use the JdbcTemplate object to execute an SQL query statement to query the user record with the specified ID from the test_springboot table. Then, use the BeanPropertyRowMapper class to map the query result set to a Java object. The method returns the query result object.

      Sample code:

      @Override
      public User selectUserById(Long id) {
          String sql = "select * from test_springboot where id=?";
          Object[] params = new Object[]{id};
          return jdbcTemplate.queryForObject(
                  sql,
                  params,
                  new BeanPropertyRowMapper<>(User.class));
      }
      

   5. Query all user information.

      Call the query method of the JdbcTemplate object to query all users from the database and map the query result to a list of User objects, which is then returned.

      Sample code:

      @Override
      public List<User> selectAllUsers() {
          String sql = "select * from test_springboot";
          return jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
      }
      

UserDao.java file introduction

The UserDao.java file uses the UserDao interface to define methods for operating user data.

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

1. Reference other classes and interfaces.

   Declare the name of the package to which the current file belongs as package com.oceanbase.testspringboot.dao, which contains the following interfaces and classes:

   • User class: used to pass and store user data.
   • List interface: used to operate the query result set.

   Sample code:

   import com.oceanbase.testspringboot.entity.User;
   import java.util.List;
   

2. Define the UserDao interface.

   Use the UserDao interface to define methods for operating user data. The methods include inserting user information, deleting user information, updating user information, querying user information by user ID, and querying all user information.

   Sample code:

   public interface UserDao {
       boolean insertUser(User user);
       boolean deleteById(Long id);
       boolean updateUser(User user);
       User selectUserById(Long id);
       List<User> selectAllUsers();
   }
   

User.java file introduction

The User.java file defines the User class to represent a user object.

1. Declare the User object. Declare the User class to contain two private fields: id and name. Also, provide a no-argument constructor. Operate user information by setting and getting the values of the id and name fields.

   Sample code:

   private Long id;
   private String name;
   
   public User() {
   }
   

2. Create a User object. Define the parameterized constructor of the User class to create a User object with specified id and name values.

   Sample code:

   public User(Long id, String name) {
       this.id = id;
       this.name = name;
   }
   

3. Get and set the id and name values. Define four methods in the User class to get and set the values of the id and name attributes. The getId method is used to get the id value, and the setId method is used to set the id value. The getName method is used to get the username name. The setName method is used to set the username name.

   Sample code:

   public Long getId() {
       return id;
   }
   
   public void setId(Long id) {
       this.id = id;
   }
   
   public String getName() {
       return name;
   }
   
   public void setName(String name) {
       this.name = name;
   }
   

4. Return the string representation of the User object.

   Rewrite the toString method in the User class to return the string representation of the User object. Annotate the method with @Override to override the same-named method in the parent class. Define the toString method to return the string representation of the User object. Concatenating the values of the id and name attributes, format them into a string, and return the string to the caller User object.

   Sample code:

   @Override
   public String toString() {
       return "User{" +
               "id=" + id +
               ", name='" + name + '\'' +
               '}';
   }
   

Introduction to TestSpringbootApplication.java

The TestSpringbootApplication.java file starts a Spring Boot application by using the UserDao interface.

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

1. Define classes and interfaces.

   Specify the package name of the current file as com.oceanbase.testspringboot and include the following interfaces and classes:

   • SpringApplication class: used to start a Spring Boot application.
   • @SpringBootApplication annotation: indicates that this class is the entry point of the Spring Boot application.

   Sample code:

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

2. Define the TestSpringbootApplication class.

   Identify this class as the entry class of the Spring Boot application by using the SpringBootApplication annotation. You can call the run method of the SpringApplication class to start the Spring Boot application.

   Sample code:

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

Introduction to TestSpringbootApplicationTests.java

The TestSpringbootApplicationTests.java file starts a Spring Boot application by using the UserDao interface.

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

1. Reference other classes and interfaces.

   Declare the current file to belong to the com.oceanbase.testspringboot package, which contains the following interfaces and classes:

   • UserDao interface: implements the methods defined in the UserDao interface.
   • User class: used to pass and store user data.
   • Test annotation: identifies a test method.
   • Autowired annotation: injects a JdbcTemplate object into the class for executing SQL statements.
   • SpringBootTest annotation: identifies the class as a Spring Boot test class.
   • JdbcTemplate class: used to execute SQL statements and handle database access.
   • List interface: used to operate on the query result set.

   Sample code:

   import com.oceanbase.testspringboot.dao.UserDao;
   import com.oceanbase.testspringboot.entity.User;
   import org.junit.jupiter.api.Test;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.test.context.SpringBootTest;
   import org.springframework.jdbc.core.JdbcTemplate;
   import java.util.List;
   
   

2. Define the TestSpringbootApplicationTests class.

   Use the SpringBootTest annotation to identify the class for testing features in a Spring Boot application. Use the UserDao and JdbcTemplate objects to perform CRUD operations on user data and output the results.

   1. Define objects.

      Use the @Autowired annotation to automatically inject the UserDao and JdbcTemplate objects.

      Sample code:

      @Autowired
      private UserDao userDao;
      @Autowired
      private JdbcTemplate jdbcTemplate; 
      

   2. Define the contextLoads method.

      Use the contextLoads method as the specific implementation of the test method.

      1. Drop the test_springboot table.

         Use the jdbcTemplate.execute method to execute the drop table test_springboot SQL statement and drop the test_springboot table.

         Sample code:

         try {
               jdbcTemplate.execute("drop table test_springboot");
               System.out.println("test_springboot delete successfully!");
             } 
         

      2. Create the test_springboot table.

         Use the jdbcTemplate.execute method to execute the create table test_springboot (id int primary key, name varchar(50)) SQL statement and create a test_springboot table that contains the id and name fields.

         Sample code:

         catch (Exception ignore) {
         
                 } finally {
                     jdbcTemplate.execute("create table test_springboot (" +
                             "id int primary key," +
                             "name varchar(50))");
                     System.out.println("test_springboot create successfully!");
                 }
         

      3. Insert data.

         Use the userDao.insertUser method to insert 10 user data records into the test_springboot table. The id field ranges from 1 to 10, and the name field stores values of `"insert" + i'.

         Sample code:

         for (int i = 1; i <= 10; i++) {
             userDao.insertUser(new User((long) i, "insert" + i));
         }
         

      4. Delete data.

         Use the userDao.deleteById method to delete the user data record whose id is 1.

         Sample code:

           userDao.deleteById(1L);
         

      5. Update data.

         Use the userDao.updateUser method to update the user data record whose id is 2. Change the value of the name field to update.

         Sample code:

         userDao.updateUser(new User(2L, "update"));
         

      6. Query data.

         Use the userDao.selectUserById method to query the user data record whose id is 2 and print the query result.

         Sample code:

         User user = userDao.selectUserById(2L);
         System.out.println("user = " + user);
         

      7. Query all data.

         Use the userDao.selectAllUsers method to query all user data records in the test_springboot table and print the query result.

         Sample code:

         List<User> userList = userDao.selectAllUsers();
         userList.forEach(System.out::println);
         

Complete code

<?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-springboot</name>
    <description>Demo project for Spring Boot</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>
    </dependencies>

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

</project>

  spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
  spring.datasource.url=jdbc:oceanbase://host:port/schema_name?useSSL=false&useUnicode=true&characterEncoding=utf-8
  spring.datasource.username=user_name
  spring.datasource.password=******

package com.oceanbase.testspringboot.dao.impl;

import com.oceanbase.testspringboot.dao.UserDao;
import com.oceanbase.testspringboot.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate; //Jdbc connection tool class

    @Override
    public boolean insertUser(User user) {
        String sql = "insert into test_springboot(id,name)values(?,?)";
        Object[] params = {user.getId(), user.getName()};
        return jdbcTemplate.update(sql, params) > 0;
    }

    @Override
    public boolean deleteById(Long id) {
        String sql = "delete from test_springboot where id=?";
        Object[] params = {id};
        return jdbcTemplate.update(sql, params) > 0;
    }

    @Override
    public boolean updateUser(User user) {
        String sql = "update test_springboot set name=? where id=?";
        Object[] params = {user.getName(), user.getId()};
        return jdbcTemplate.update(sql, params) > 0;
    }

    @Override
    public User selectUserById(Long id) {
        String sql = "select * from test_springboot where id=?";
        Object[] params = new Object[]{id};
        return jdbcTemplate.queryForObject(
                sql,
                params,
                new BeanPropertyRowMapper<>(User.class));
    }

    @Override
    public List<User> selectAllUsers() {
        String sql = "select * from test_springboot";
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
    }
}

package com.oceanbase.testspringboot.dao;

import com.oceanbase.testspringboot.entity.User;

import java.util.List;


public interface UserDao {
    boolean insertUser(User user);

    boolean deleteById(Long id);

    boolean updateUser(User user);

    User selectUserById(Long id);

    List<User> selectAllUsers();
}

package com.oceanbase.testspringboot.entity;


public class User {
    private Long id;
    private String name;

    public User() {
    }

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

package com.oceanbase.testspringboot;

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

@SpringBootApplication
public class TestSpringbootApplication {

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

package com.oceanbase.testspringboot;

import com.oceanbase.testspringboot.dao.UserDao;
import com.oceanbase.testspringboot.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

@SpringBootTest
class TestSpringbootApplicationTests {
    @Autowired
    private UserDao userDao;
    @Autowired
    private JdbcTemplate jdbcTemplate; //Jdbc connection tool class

    @Test
    void contextLoads() {
        try {
            // Use the execute() method to execute SQL statements and delete the user table test_springboot
            jdbcTemplate.execute("drop table test_springboot");
            System.out.println("test_springboot delete successfully!");
        } catch (Exception ignore) {

        } finally {
            // Use the execute() method to execute SQL statements and create user table tests_ user
            jdbcTemplate.execute("create table test_springboot (" +
                    "id int primary key," +
                    "name varchar(50))");
            System.out.println("test_springboot create successfully!");
        }
        //UserDao userDao=new UserDaoImpl();

        //ApplicationContext ioc=new ApplicationContext("/appli");`
        //add
        for (int i = 1; i <= 10; i++) {
            userDao.insertUser(new User((long) i, "insert" + i));
        }
        //delete
        userDao.deleteById(1L);
        //update
        userDao.updateUser(new User(2L, "update"));
        //selectUserById
        User user = userDao.selectUserById(2L);
        System.out.println("user = " + user);
        //query all users
        List<User> userList = userDao.selectAllUsers();
        userList.forEach(System.out::println);
    }

}

References

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