SpringBoot 连接 OceanBase 数据库示例程序

功能适用性

SpringBoot 适用于 OceanBase 数据库 MySQL 和 Oracle 模式。本文档仅提供 MySQL 模式示例。

本文将介绍如何使用 SpringBoot 框架和 OceanBase 数据库构建一个应用程序，实现创建表、插入数据和查询数据等基本操作。

点击下载 java-oceanbase-springboot 示例工程

前提条件

您已安装 OceanBase 数据库。
您已安装 JDK 1.8 和 Maven。
您已安装 IntelliJ IDEA。

说明

本文档运行代码使用的工具是 IntelliJ IDEA 2021.3.2 (Community Edition) 版本，您也可以根据个人喜好选择适合自己的工具运行示例代码。

操作步骤

说明

本文中给出的操作步骤是基于 Windows 环境生成。如果您使用的是其他操作系统环境或编译器，那么操作步骤可能会略有不同。

获取 OceanBase 数据库连接信息。
导入 java-oceanbase-springboot 项目到 IDEA 中。
修改 java-oceanbase-springboot 项目中的数据库连接信息。
运行 java-oceanbase-springboot 项目。

步骤一：获取 OceanBase 数据库连接信息

联系 OceanBase 数据库部署人员或者管理员获取相应的数据库连接信息。
```
obclient -hxx.xx.xx.xx -P2883 -uroot@sys#cluster -p**** -A
```
根据已部署的 OceanBase 数据库填写下面 URL 的对应信息。

说明

在 application.properties 文件中需要这里的 URL 信息。
```
jdbc:oceanbase://host:port/schema_name?user=$user_name&password=$password&useSSL=false&useUnicode=true&characterEncoding=utf-8
```
参数说明：
- host：提供 OceanBase 数据库连接 IP。ODP 连接方式使用的是一个 ODP 地址；直连方式使用的是 OBServer 节点的 IP 地址。
- port：提供 OceanBase 数据库连接端口。ODP 连接的方式默认是 2883，在部署 ODP 时可自定义；直连方式默认是 2881，在部署 OceanBase 数据库时可自定义。
- schema_name：需要访问的 Schema 名称。
- user_name：通过 -u 参数指定，格式为 用户@租户#集群名称 或 用户名@SERVICE:服务名。使用格式 用户@租户#集群名称 时，默认租户为 sys，管理员用户为 root。直连数据库时可省略集群名称，ODP 连接时则需要填写。
- password：提供账户密码。
- useSSL=false&useUnicode=true&characterEncoding=utf-8：为额外的连接属性。
  - useSSL：强制连接时是否使用 SSL/TLS。默认值：false。
  - useUnicode：指定字符的编码、解码格式。默认值：true。
  - characterEncoding：支持数据库 URL 选项的字符编码。默认值：utf8。

更多 URL 参数说明信息，请参见数据库 URL。

步骤二：导入 `java-oceanbase-springboot` 项目到 IDEA 中

打开 IntelliJ IDEA，选择 File > Open... 选项。
在弹出的 Open File or Project 窗口中，选择对应的项目文件，单击 OK 完成项目文件导入。
IntelliJ IDEA 将会自动识别项目中的各类文件，并在 Project 工具窗口中，可以查看项目的目录结构、文件列表、模块列表、依赖关系等信息。Project 工具窗口通常位于 IntelliJ IDEA 界面的最左侧，默认情况下是打开的。如果 Project 工具窗口被关闭了，可以通过点击菜单栏中的 View > Tool Windows > Project 或者使用快捷键 Alt + 1 来重新打开它。

说明

当使用 IntelliJ IDEA 导入项目时，IntelliJ IDEA 会自动检测项目中的 pom.xml 文件，并根据文件中描述的依赖关系自动下载所需的依赖库，并将它们添加到项目中。
查看项目情况。

springboot

步骤三：修改 `java-oceanbase-springboot` 项目中的数据库连接信息

根据 步骤一：获取 OceanBase 数据库连接信息 中的信息修改 application.properties 文件中的数据库连接信息。

示例如下：

数据库驱动的名称为：com.mysql.cj.jdbc.Driver
OBServer 节点的 IP 地址为 10.10.10.1。
访问端口使用的是 2881。
需要访问的 Schema 名称为 test。
租户的连接账户是 root@mysq001。mysql001 是在 OceanBase 数据库中创建的一个 MySQL 模式的用户租户，root 是租户 mysql001 的用户名称。
密码是 ******。

示例代码如下：

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

步骤四：运行 `java-oceanbase-hibernate` 项目

运行路径

在项目结构中找到 src > test > java 中找到 TestSpringbootApplicationTests.java 文件。
在工具菜单栏中选择 运行(U) > 运行 > TestSpringbootApplicationTests，或直接单击右上角绿色三角形运行。
通过 IDEA 的控制台来查看项目的日志信息和输出结果。

运行结果

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

项目代码介绍

点击 java-oceanbase-springboot 下载项目代码，这是一个名为 java-oceanbase-springboot 的压缩包。

解压后，得到一个名为 java-oceanbase-springboot 的文件夹。目录结构如下所示：

│--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

文件说明：

pom.xml：Maven 项目的配置文件，包含了项目的依赖、插件、构建等信息。
.idea：IDE（集成开发环境）中使用的目录，用于存储项目相关的配置信息。
src：通常用于表示项目中存放源代码的目录。
main: 存放主要的源代码和资源文件的目录。
java: 存放 Java 源代码的目录。
com: 存放 Java 包的根目录。
oceanbase: 存放项目的根目录。
testspringboot：Java 包的根目录，包含了项目的所有 Java 类。
TestSpringbootApplication.java：项目的主类，包含了 main 方法。
dao: 存放数据访问对象（Data Access Object）包，用于访问数据库或其他数据存储服务。
UserDao.java：用户数据访问对象，用于操作用户数据的增删改查等操作。
impl：DAO 接口的实现目录。
UserDaoImpl.java：用户 DAO 接口的实现类。
entity：实体类的目录，用于存放与数据库表对应的 Java 类。
User.java：用户持久化对象，用于映射用户数据表的字段。
resources: 存放资源文件的目录，如配置文件、SQL 文件等。
application.properties：项目的配置文件，用于配置应用程序的属性和参数。
test: 存放测试代码和资源文件的目录。
TestSpringbootApplicationTests.java: 存放测试 springboot 的 Java 类。
target: 存放编译后的 Class 文件、Jar 包等文件的目录。

pom.xml 代码介绍

说明

如果您只是想验证示例，那么请使用默认代码，无需修改。您也可以按照以下讲解，根据自己的需求修改 pom.xml 文件。

pom.xml 配置文件内容如下：

文件声明语句。

声明本文件是一个 XML 文件，使用的 XML 版本是 1.0，字符编码方式是 UTF-8。

代码如下：
```
<?xml version="1.0" encoding="UTF-8"?>
```
配置 POM 的命名空间和 POM 模型版本。
1. 通过 xmlns 指定 POM 的命名空间为 http://maven.apache.org/POM/4.0.0。
2. 通过 xmlns:xsi 指定 XML 命名空间为 http://www.w3.org/2001/XMLSchema-instance。
3. 通过 xsi:schemaLocation 指定 POM 的命名空间为 http://maven.apache.org/POM/4.0.0，并指定 POM 的 XSD 文件的位置为 https://maven.apache.org/xsd/maven-4.0.0.xsd。
4. 通过 <modelVersion> 元素指定该 POM 文件使用的 POM 模型版本为 4.0.0。
代码如下：
```
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
</project>
```
配置父项信息。
1. 通过 <groupId> 指定父项标识为 org.springframework.boot。
2. 通过 <artifactId> 指定父项依赖为 spring-boot-starter-parent。
3. 通过 <version> 指定父项的版本号为 2.7.11。
4. 通过 relativePath 表示父项的路径为空。
代码如下：
```
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.7.11</version>
 <relativePath/> 
```
配置基本信息。
1. 通过 <groupId> 指定项目标识为 com.oceanbase。
2. 通过 <artifactId> 指定项目依赖为 java-oceanbase-springboot。
3. 通过 <version> 指定项目的版本号为 0.0.1-SNAPSHOT。
4. 通过 description 介绍项目信息为 Demo project for Spring Boot。
代码如下：
```
 <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>
```
配置 java 版本。

指定项目使用的 Java 版本为 1.8。

代码如下：
```
  <properties>
      <java.version>1.8</java.version>
  </properties>
```
配置核心依赖。
1. 指定依赖项所属的组织为 org.springframework.boot，名称为 spring-boot-starter，该依赖库包含了 Spring Boot 默认支持的组件依赖，支持 Web、数据处理、安全、Test 等功能。
  
  代码如下：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
```
2. 指定依赖项所属的组织为 org.springframework.boot，名称为 spring-boot-starter-jdbc，通过该依赖可以使用 Spring Boot 提供的 JDBC 相关功能，如连接池、数据源配置等。
  
  代码如下：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
```
3. 指定依赖项所属的组织为 org.springframework.boot，名称为 spring-boot-starter-test，作用范围为 test，通过该依赖可以使用 Spring Boot 提供的测试框架和工具，如 JUnit、Mockito、Hamcrest 等。
  
  代码如下：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
```
4. 指定依赖项所属的组织为 com.oceanbase，名称为 oceanbase-client，版本号为 2.4.3，通过该依赖可以使用 OceanBase 提供的客户端功能，如连接、查询、事务等。
  
  代码如下：
```
    <dependencies>
    <dependency>
        <groupId>com.oceanbase</groupId>
        <artifactId>oceanbase-client</artifactId>
        <version>2.4.3</version>
    </dependency>
    </dependencies>
```
配置 Maven 插件。

指定依赖项所属的组织为 org.springframework.boot，名称为 spring-boot-maven-plugin，该插件用于将 Spring Boot 应用程序打包成可执行的 JAR 包或 WAR 包，并且可以直接运行。

代码如下：
```
 <build>
     <plugins>
         <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
     </plugins>
 </build>
```

application.properties 代码介绍

application.properties 文件配置了 Spring Boot 应用程序的数据源，指定了连接 OceanBase 数据库所需的驱动类名、URL、用户名和密码。通过这些配置，应用程序可以连接并操作 OceanBase 数据库。

通过 spring.datasource.driverClassName 指定数据库驱动程序为 com.oceanbase.jdbc.Driver，用于与 OceanBase 数据库建立连接。
通过 spring.datasource.url 指定连接数据库的 URL。
通过 spring.datasource.username 指定连接数据库的用户名。

通过 spring.datasource.password 指定连接数据库的密码。

代码如下：

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

UserDaoImpl.java 文件介绍

UserDaoImpl.java 文件通过使用 JdbcTemplate 对象执行 SQL 语句，实现了对 User 表的插入、删除、更新和查询操作。

UserDaoImpl.java 文件的代码主要包括以下几个部分：

引用其他类和接口。

声明当前文件所属的包名为 com.oceanbase.testspringboot.dao.impl，包含以下接口和类：
- UserDao 接口：用于实现了 UserDao 接口中定义的方法。
- User 类：用于传递和存储用户数据。
- Autowired 注解：将 JdbcTemplate 对象注入到该类中，用于执行 SQL 语句。
- BeanPropertyRowMapper 类：用于将数据库查询结果映射为 Java 对象。
- JdbcTemplate 类：用于执行 SQL 语句和处理数据库访问。
- Repository 注解：标记 Spring 的仓库组件，用于数据访问。
- List 接口：用于操作查询结果集合。
代码如下：
```
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;
```
定义 UserDaoImpl 类。

通过使用 Repository 注解指定该类的 Bean 名称为 userDao，并使用 JdbcTemplate 对象执行 SQL 语句，实现了对 User 表的插入、删除、更新和查询操作。
1. 插入用户信息。
  
  通过调用 JdbcTemplate 对象的 insert 方法，将用户的 ID 和姓名插入到数据库中的 test_springboot 表中，并根据插入操作的结果返回相应的布尔值。
  
  代码如下：
```
@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. 删除用户信息。
  
  通过调用 JdbcTemplate 对象的 delete 方法，根据用户的 ID 删除数据库中的用户信息，并根据删除操作的结果返回相应的布尔值。
  
  代码如下：
```
@Override
public boolean deleteById(Long id) {
    String sql = "delete from test_springboot where id=?";
    Object[] params = {id};
    return jdbcTemplate.update(sql, params) > 0;
}
```
3. 更新用户信息。
  
  通过调用 JdbcTemplate 对象的 update 方法，将用户的姓名更新到数据库中的 test_springboot 表中指定 ID 的记录，并根据更新操作的结果返回相应的布尔值。
  
  代码如下：
```
@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. 查询用户信息。
  
  通过使用 JdbcTemplate 对象执行 SQL 查询语句，从名为 test_springboot 的表中查询指定 ID 的用户记录，并使用 BeanPropertyRowMapper 进行结果映射。返回查询结果对象。
  
  代码如下：
```
@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. 查询所有用户信息。
  
  通过调用 JdbcTemplate 对象的 query 方法，查询数据库中的所有用户信息，并将查询结果映射为 User 类型的对象列表返回。
  
  代码如下：
```
@Override
public List<User> selectAllUsers() {
    String sql = "select * from test_springboot";
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
}
```

UserDao.java 文件介绍

UserDao.java 文件通过 UserDao 接口用于定义对用户数据的操作方法。

UserDao.java 文件的代码主要包括以下几个部分：

引用其他类和接口。

声明当前文件所属的包名为 package com.oceanbase.testspringboot.dao，包含以下接口和类：
- User 类：用于传递和存储用户数据。
- List 接口：用于操作查询结果集合。
代码如下：
```
import com.oceanbase.testspringboot.entity.User;
import java.util.List;
```
定义 UserDao 接口。

通过使用 UserDao 接口，定义对用户数据的操作方法。包括插入用户信息、删除用户信息、更新用户信息、根据用户 ID 查询用户信息以及查询所有用户信息等方法。

代码如下：
```
public interface UserDao {
    boolean insertUser(User user);
    boolean deleteById(Long id);
    boolean updateUser(User user);
    User selectUserById(Long id);
    List<User> selectAllUsers();
}
```

User.java 文件介绍

User.java 文件通过定义 User 类用于表示用户对象。

声明 User 对象。声明 User 类包含 id 和 name 两个私有字段，并提供了一个无参构造方法。通过设置和获取 id 和 name 字段的值来操作用户信息。

代码如下：
```
private Long id;
private String name;

public User() {
}
```
创建 User 对象。定义 User 类的带参构造方法，用于创建一个具有指定 id 和 name 的 User 对象。

代码如下：
```
public User(Long id, String name) {
    this.id = id;
    this.name = name;
}
```
获取和设置 id 和 name 值。定义 User 类中的四个方法，用于获取和设置 id 和 name 属性的值。 getId 方法用于获取 id 值，setId 方法用于设置 id 值。getName 方法用于获取用户名 name 的值。setName 方法用于设置用户名 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;
}
```
返回 User 对象的字符串表示形式。

重写 User 类中的 toString 方法，用于返回 User 对象的字符串表示形式。定义 @Override 覆盖父类中的同名方法。定义 toString 方法，用于返回 User 对象的字符串表示形式。通过字符串拼接，将 id 和 name 属性的值格式化为一个字符串，返回给调用者 User。

代码如下：
```
@Override
public String toString() {
    return "User{" +
            "id=" + id +
            ", name='" + name + '\'' +
            '}';
}
```

TestSpringbootApplication.java 文件介绍

TestSpringbootApplication.java 文件通过 UserDao 接口用于启动 Spring Boot 应用程序。

TestSpringbootApplication.java 文件的代码主要包括以下几个部分：

定义类和接口。

声明当前文件所属的包名为 com.oceanbase.testspringboot，包含以下接口和类：
- SpringApplication 类：用于启动 Spring Boot 应用程序。
- @SpringBootApplication 注解：用于指示该类是 Spring Boot 应用程序的入口点。
代码如下：
```
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
```
定义 TestSpringbootApplication 类。

使用 SpringBootApplication 注解标识该类是一个 Spring Boot 应用程序的入口类。通过调用 SpringApplication 类的 run 方法，可以启动 Spring Boot 应用程序。

代码如下：
```
@SpringBootApplication
public class TestSpringbootApplication {

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

TestSpringbootApplicationTests.java 文件介绍

TestSpringbootApplicationTests.java 文件通过 UserDao 接口用于启动 Spring Boot 应用程序。

TestSpringbootApplicationTests.java 文件的代码主要包括以下几个部分：

引用其他类和接口。

声明当前文件所属的包名为 com.oceanbase.testspringboot，包含以下接口和类：
- UserDao 接口：用于实现了 UserDao 接口中定义的方法。
- User 类：用于传递和存储用户数据。
- Test 注解：用于标识测试方法。
- Autowired 注解：将 JdbcTemplate 对象注入到该类中，用于执行 SQL 语句。
- SpringBootTest 注解：用于标识该类是一个 Spring Boot 的测试类。
- JdbcTemplate 类：用于执行 SQL 语句和处理数据库访问。
- List 接口：用于操作查询结果集合。
代码如下：
```
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;
```
定义 TestSpringbootApplicationTests 类。

使用 SpringBootTest 注解标识测试 Spring Boot 应用程序中的功能。通过使用 UserDao 和 JdbcTemplate 对象，对用户数据进行增删改查操作，并输出结果。
1. 定义对象。
  
  使用 Autowired 注解自动注入 UserDao 和 JdbcTemplate 对象。
  
  代码如下：
```
@Autowired
private UserDao userDao;
@Autowired
private JdbcTemplate jdbcTemplate; 
```
2. 定义 contextLoads 方法。
  
  使用 contextLoads 方法作为测试方法的具体实现。
  1. 删除 test_springboot 表。
    
    使用 jdbcTemplate.execute 方法执行 SQL 语句 drop table test_springboot，删除名为 test_springboot 的表。
    
    代码如下：
```
try {
      jdbcTemplate.execute("drop table test_springboot");
      System.out.println("test_springboot delete successfully!");
    } 
```
  2. 创建 test_springboot 表。
    
    使用 jdbcTemplate.execute 方法执行 SQL 语句 create table test_springboot (id int primary key, name varchar(50))，创建名为 test_springboot 的表，包含 id 和 name 两个字段。
    
    代码如下：
```
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. 插入数据。
    
    使用 userDao.insertUser 方法向 test_springboot 表中插入 10 条用户数据，id 从 1 到 10，name 为 "insert" + i。
    
    代码如下：
```
for (int i = 1; i <= 10; i++) {
    userDao.insertUser(new User((long) i, "insert" + i));
}
```
  4. 删除数据。
    
    使用 userDao.deleteById 方法删除 id 为 1 的用户数据。
    
    代码如下：
```
  userDao.deleteById(1L);
```
  5. 更新数据。
    
    使用 userDao.updateUser 方法更新 id 为 2 的用户数据，将 name 修改为 update。
    
    代码如下：
```
userDao.updateUser(new User(2L, "update"));
```
  6. 查询数据。
    
    使用 userDao.selectUserById 方法查询 id 为 2 的用户数据，并将结果打印输出。
    
    代码如下：
```
User user = userDao.selectUserById(2L);
System.out.println("user = " + user);
```
  7. 查询所有数据。
    
    使用 userDao.selectAllUsers 方法查询 test_springboot 表中的所有用户数据，并将结果打印输出。
    
    代码如下：
```
List<User> userList = userDao.selectAllUsers();
userList.forEach(System.out::println);
```

完整的代码展示

pom.xml

application.properties

UserDaoImpl.java

UserDao.java

User.java

TestSpringbootApplication.java

TestSpringbootApplicationTests.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-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);
    }

}