SpringBoot 连接 OceanBase 数据库示例程序

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

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

SpringBoot 连接 OceanBase 数据库示例程序（Oracle 模式）

前提条件

您已安装 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：提供租户的连接账户。ODP 连接方式的常用格式有两种：用户名@租户名#集群名 或者 集群名:租户名:用户名；直连方式格式：用户名@租户名。
- password：提供账户密码。
- useSSL=false&useUnicode=true&characterEncoding=utf-8：为额外的连接属性。
  - useSSL：强制连接时是否使用 SSL/TLS。默认值：false。
  - useUnicode：指定字符的编码、解码格式。默认值：true。
  - characterEncoding：支持数据库 URL 选项的字符编码。默认值：utf8。
  - socketTimeout：定义了网络 Socket 超时（SO_TIMEOUT），以毫秒为单位。值为 0 时将禁用此超时。

更多 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.oceanbase.jdbc.Driver
OBServer 节点的 IP 地址为 10.10.10.1。
访问端口使用的是 2881。
需要访问的 Schema 名称为 sys。
租户的连接账户是 sys@xyoracle。xyoracle 是在 OceanBase 数据库中创建的一个 Oracle 模式的用户租户，sys 是租户 xyoracle 的用户名称。
密码是 ******。

示例代码如下：

spring.datasource.driverClassName=com.oceanbase.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://10.10.10.1:2881/sys?useSSL=false&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=sys@xyoracle
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.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=******

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

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

}

前提条件

您已安装 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：提供租户的连接账户。ODP 连接方式的常用格式有两种：用户名@租户名#集群名 或者 集群名:租户名:用户名；直连方式格式：用户名@租户名。
- password：提供账户密码。
- useSSL=false&useUnicode=true&characterEncoding=utf-8：为额外的连接属性。
  - useSSL：强制连接时是否使用 SSL/TLS。默认值：false。
  - useUnicode：指定字符的编码、解码格式。默认值：true。
  - characterEncoding：支持数据库 URL 选项的字符编码。默认值：utf8。
  - socketTimeout：定义了网络 Socket 超时（SO_TIMEOUT），以毫秒为单位。值为 0 时将禁用此超时。

更多 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.oceanbase.jdbc.Driver
OBServer 节点的 IP 地址为 10.10.10.1。
访问端口使用的是 2881。
需要访问的 Schema 名称为 sys。
租户的连接账户是 sys@xyoracle。xyoracle 是在 OceanBase 数据库中创建的一个 Oracle 模式的用户租户，sys 是租户 xyoracle 的用户名称。
密码是 ******。

示例代码如下：

spring.datasource.driverClassName=com.oceanbase.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://10.10.10.1:2881/sys?useSSL=false&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=sys@xyoracle
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 代码介绍

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

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

代码如下：

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

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

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

}

前提条件

说明

操作步骤

说明

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

说明

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

说明

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

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

运行路径

运行结果

项目代码介绍

pom.xml 代码介绍

说明

application.properties 代码介绍

UserDaoImpl.java 文件介绍

UserDao.java 文件介绍

User.java 文件介绍

TestSpringbootApplication.java 文件介绍

TestSpringbootApplicationTests.java 文件介绍

完整的代码展示

相关文档

SpringBoot 连接 OceanBase 数据库示例程序

前提条件

说明

操作步骤

说明

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

说明

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

说明

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

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

运行路径

运行结果

项目代码介绍

pom.xml 代码介绍

说明

application.properties 代码介绍

UserDaoImpl.java 文件介绍

UserDao.java 文件介绍

User.java 文件介绍

TestSpringbootApplication.java 文件介绍

TestSpringbootApplicationTests.java 文件介绍

完整的代码展示

相关文档

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

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

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

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

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

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