SpringBootサンプルプログラム|OceanBaseデータベース|ドキュメント|OceanBaseマニュアル

本記事では、SpringBootフレームワークとOceanBaseデータベースを使用して、テーブルの作成、データの挿入、クエリなどの基本的な操作を実現するアプリケーションの構築方法を紹介します。

クリックしてjava-oceanbase-springbootサンプルプロジェクトをダウンロード

前提条件

OceanBaseデータベースがインストール済みであること。
JDK 1.8とMavenがインストール済みであること。
IntelliJ IDEAがインストール済みであること。

説明

この記事でコードを実行するために使用したツールは、IntelliJ IDEA 2021.3.2 (Community Edition)バージョンです。ご自身の好みに合わせて、適切なツールを選択してサンプルコードを実行することも可能です。

操作手順

説明

本記事で示されている操作手順は、Windows環境に基づいています。他のOS環境やコンパイラを使用している場合は、操作手順が若干異なる場合があります。

OceanBaseデータベースへの接続情報を取得します。
java-oceanbase-springbootプロジェクトをIDEAにインポートします。
java-oceanbase-springbootプロジェクトのデータベース接続情報を修正します。
java-oceanbase-springbootプロジェクトを実行します。

ステップ1：OceanBaseデータベース接続情報を取得する

OceanBaseデータベースのデプロイ担当者または管理者に連絡して、対応するデータベース接続情報を取得します。
```
obclient -hxx.xx.xx.xx -P2883 -uroot@sys#cluster -p**** -A
```
デプロイ済みのOceanBaseデータベースに基づいて、以下のURLの対応する情報を入力します。

説明

application.propertiesファイルには、このURL情報が必要です。
```
jdbc:mysql://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：アクセスするスキーマ名です。
- 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を参照してください。

ステップ2：`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

ステップ3：`java-oceanbase-springboot` プロジェクトのデータベース接続情報を修正する

ステップ1：OceanBaseデータベース接続情報に記載されている情報に基づいて、application.propertiesファイル内のデータベース接続情報を修正します。

例：

データベースドライバーの名前：com.mysql.cj.jdbc.Driver
OBServerノードのIPアドレスは10.10.10.1です。
アクセスポートは2881を使用します。
アクセスするスキーマ名はtestです。
テナントの接続アカウントはroot@mysq001です。mysql001はOceanBaseデータベースで作成されたMySQLモードのユーザーテナントであり、rootはテナントmysql001のユーザー名です。
パスワードは ****** です。

サンプルコードは以下のとおりです：

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

ステップ4：`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と指定します。この依存関係により、JUnit、Mockito、HamcrestなどのSpring Bootが提供するテストフレームワークとツールを使用できます。
  
  コードは以下のとおりです：
```
<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:mysql://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の2つのプライベートフィールドを含み、パラメータなしのコンストラクタメソッドを提供することを宣言します。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プロパティの値を取得および設定するために使用される4つのメソッドを定義します。 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))を実行し、idとnameの2つのフィールドを含むtest_springbootという名前のテーブルを作成します。
    
    コードは以下のとおりです：
```
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);
    }

}