SpringBootを使用してOceanBase Cloudデータベースに接続するサンプルプログラム

本ドキュメントでは、SpringBootフレームワークとOceanBase Cloudデータベースを使用してアプリケーションを構築し、テーブルの作成、データの挿入、データのクエリなどの基本操作を実装する方法について説明します。

      java-oceanbase-springboot サンプルプロジェクトをダウンロード
  </a>

• OceanBase Cloudデータベースのアカウントを登録し、クラスタインスタンスとMySQL互換モードのテナントを作成していること。詳細は、クラスタインスタンスの作成 およびテナントの作成をご参照ください。
• JDK 1.8およびMavenをインストールしていること。
• IntelliJ IDEAをインストールしていること。

操作手順

1. OceanBase Cloudデータベースの接続情報を取得します。
2. java-oceanbase-springboot プロジェクトをIDEAにインポートします。
3. java-oceanbase-springboot プロジェクト内のデータベース接続情報を変更します。
4. java-oceanbase-springboot プロジェクトを実行します。

操作手順1：OceanBase Cloudデータベースの接続情報の取得

1. OB Cloudクラウドデータベースコンソールにログインします。インスタンス一覧ページで対象インスタンスの情報を展開し、対象テナントの下で 接続 > 接続文字列を取得 を選択します。

   詳細な操作については、接続文字列の取得をご参照ください。

2. 作成済みのOceanBase Cloudデータベースに基づいて、以下のURLに対応する情報を入力します。

   説明

   application.properties ファイルでこのURL情報が必要になります。

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

   パラメータの説明：

   • host：OceanBase Cloudデータベースの接続アドレスを指定します。例：t********.********.oceanbase.cloud。

   • port：OceanBase Cloudデータベースの接続ポートを指定します。デフォルトは3306です。

   • schema_name：アクセスするSchema名を指定します。

   • user_name：データベースにアクセスするアカウントを指定します。

   • password：アカウントのパスワードを指定します。

   • useSSL=false&useUnicode=true&characterEncoding=utf-8：追加の接続属性です。

     • useSSL：接続時に SSL/TLS を強制的に使用するかどうかを指定します。デフォルト値：false。
     • useUnicode：文字のエンコードおよびデコード形式を指定します。デフォルト値：true。
     • characterEncoding：データベースURLオプションでサポートされる文字エンコーディングを指定します。デフォルト値：utf8。

URLパラメータの詳細については、データベースURLをご参照ください。

操作手順2：java-oceanbase-springboot プロジェクトのIDEAへのインポート

1. IntelliJ IDEA を開き、File > Open... オプションを選択します。

2. ポップアップ表示される Open File or Project ウィンドウで、対応するプロジェクトファイルを選択し、OK をクリックしてプロジェクトファイルのインポートを完了します。

3. IntelliJ IDEAはプロジェクト内の各種ファイルを自動的に認識し、Project ツールウィンドウでプロジェクトのディレクトリ構造、ファイルリスト、モジュールリスト、依存関係などの情報を確認できます。Project ツールウィンドウは通常、IntelliJ IDEAインターフェースの左端にあり、デフォルトで開いています。Project ツールウィンドウが閉じている場合は、メニューバーの View > Tool Windows > Project をクリックするか、ショートカットキー Alt + 1 を使用して再度開くことができます。

   説明

   IntelliJ IDEAを使用してプロジェクトをインポートすると、IntelliJ IDEAはプロジェクト内のpom.xmlファイルを自動的に検出し、ファイルに記述された依存関係に基づいて必要な依存ライブラリを自動的にダウンロードしてプロジェクトに追加します。

4. プロジェクトの状況を確認します。

操作手順3：java-oceanbase-springboot プロジェクト内のデータベース接続情報の変更

手順1：OceanBase Cloudデータベースの接続情報の取得 の情報に基づいて、application.properties ファイル内のデータベース接続情報を変更します。

例：

• データベースドライバ名：com.mysql.cj.jdbc.Driver
• OceanBase Cloudデータベースの接続アドレス：t5******.********.oceanbase.cloud
• アクセスポート：3306
• アクセスするSchema名：test
• テナントの接続アカウント：mysql001
• パスワード：******

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

spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:oceanbase://t5******.********.oceanbase.cloud:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=mysql001
spring.datasource.password=******

操作手順4：java-oceanbase-springboot プロジェクトの実行

実行パス

1. プロジェクト構造の src > test > java から TestSpringbootApplicationTests.java ファイルを見つけます。
2. ツールメニューバーで Run > Run > TestSpringbootApplicationTests を選択するか、右上の緑色の三角形を直接クリックして実行します。
3. 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'}

よくある質問

1. 接続タイムアウト

接続タイムアウトの問題が発生した場合は、JDBC URLで接続タイムアウトパラメータを設定できます：

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

2. 文字セットの問題

正しい文字エンコーディングを確保するために、JDBC URLで正しい文字セットパラメータを設定します：

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

3. SSL接続

OceanBase CloudデータベースとのSSL接続を有効にするには、JDBC URLに以下のパラメータを追加します：

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

4. アカウントパスワード内の特殊文字

ユーザー名またはパスワードに特殊文字（#など）が含まれている場合は、URLエンコードを行う必要があります：

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

プロジェクトコードの紹介

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 設定ファイルの内容は以下の通りです：

1. ファイル宣言文。

このファイルがXMLファイルであることを宣言し、使用するXMLバージョンは 1.0、文字エンコーディング方式は UTF-8 です。

コードは以下の通りです：

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

2. POMの名前空間とPOMモデルのバージョンを設定します。

3. xmlns を使用して、POMの名前空間を http://maven.apache.org/POM/4.0.0 に指定します。

4. xmlns:xsi を使用して、XML名前空間を http://www.w3.org/2001/XMLSchema-instance に指定します。

5. xsi:schemaLocation を使用して、POMの名前空間を http://maven.apache.org/POM/4.0.0 に指定し、POMのXSDファイルの場所を https://maven.apache.org/xsd/maven-4.0.0.xsd に指定します。

6. <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>

3. 親プロジェクトの情報を設定します。

4. <groupId> を使用して、親プロジェクトの識別子を org.springframework.boot に指定します。

5. <artifactId> を使用して、親プロジェクトの依存関係を spring-boot-starter-parent に指定します。

6. <version> を使用して、親プロジェクトのバージョン番号を 2.7.11 に指定します。

7. relativePath を使用して、親プロジェクトのパスが空であることを示します。

コードは以下の通りです：

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

4. 基本情報を設定します。

5. <groupId> を使用して、プロジェクトの識別子を com.oceanbase に指定します。

6. <artifactId> を使用して、プロジェクトの依存関係を java-oceanbase-springboot に指定します。

7. <version> を使用して、プロジェクトのバージョン番号を 0.0.1-SNAPSHOT に指定します。

8. 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>

5. Javaバージョンを設定します。

プロジェクトで使用するJavaバージョンを1.8に指定します。

コードは以下の通りです：

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

6. コア依存関係を設定します。

7. 依存関係が属する組織を org.springframework.boot、名前を spring-boot-starter に指定します。この依存ライブラリには、Spring Bootがデフォルトでサポートするコンポーネントの依存関係が含まれており、Web、データ処理、セキュリティ、Testなどの機能をサポートします。

コードは以下の通りです：

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

2. 依存関係が属する組織を org.springframework.boot、名前を spring-boot-starter-jdbc に指定します。この依存関係により、接続プールやデータソース設定など、Spring Bootが提供するJDBC関連機能を使用できます。

コードは以下の通りです：

    ```xml
    <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が提供するテストフレームワークとツールを使用できます。

コードは以下の通りです：

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

test ```

4. 依存関係が属する組織を com.oceanbase、名前を oceanbase-client、バージョン番号を 2.4.3 に指定します。この依存関係により、接続、クエリ、トランザクションなど、OceanBaseが提供するクライアント機能を使用できます。

コードは以下の通りです：

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

7. 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 Cloudデータベースへの接続に必要なドライバクラス名、URL、ユーザー名、パスワードを指定します。これらの設定により、アプリケーションはOceanBase Cloudデータベースに接続して操作できます。

• spring.datasource.driverClassName を使用して、データベースドライバを com.oceanbase.jdbc.Driver に指定し、OceanBase Cloudデータベースとの接続を確立するために使用します。
• 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 ファイルのコードは、主に以下の要素で構成されています：

1. 他のクラスとインターフェースの参照。

現在のファイルが属するパッケージ名を com.oceanbase.testspringboot.dao.impl として宣言し、以下のインターフェースとクラスを含みます：

* `UserDao` インターフェース：UserDaoインターフェースで定義されたメソッドを実装するために使用されます。
* `User` クラス：ユーザーデータの受け渡しと保存に使用されます。

• Autowired アノテーション：JdbcTemplateオブジェクトをこのクラスに注入し、SQL文の実行に使用します。
  • BeanPropertyRowMapper クラス：データベースのクエリ結果をJavaオブジェクトにマッピングするために使用されます。
  • JdbcTemplate クラス：SQL文の実行とデータベースアクセスの処理に使用されます。
  • Repository アノテーション：データアクセスに使用されるSpringのリポジトリコンポーネントをマークします。
  • List インターフェース：クエリ結果セットの操作に使用されます。

コードは以下の通りです：

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

2. UserDaoImpl クラスの定義。

Repository アノテーションを使用してこのクラスの Bean 名を userDao に指定し、JdbcTemplate オブジェクトを使用してSQL文を実行することで、User テーブルに対する挿入、削除、更新、クエリ操作を実装します。

1. ユーザー情報の挿入。

JdbcTemplate オブジェクトの insert メソッドを呼び出すことで、ユーザーのIDと名前をデータベース内の test_springboot テーブルに挿入し、挿入操作の結果に基づいて対応するブール値を返します。

コードは以下の通りです：

    ```java
    @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に基づいてデータベース内のユーザー情報を削除し、削除操作の結果に基づいて対応するブール値を返します。

コードは以下の通りです：

    ```java
        @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のレコードに更新し、更新操作の結果に基づいて対応するブール値を返します。

コードは以下の通りです：

    ```java
        @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 を使用して結果をマッピングします。クエリ結果オブジェクトを返します。

コードは以下の通りです：

    ```java
        @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型のオブジェクトリストにマッピングして返します。

コードは以下の通りです：

    ```java
        @Override

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

UserDao.java ファイルの紹介

UserDao.java ファイルは、UserDaoインターフェースを通じてユーザーデータに対する操作メソッドを定義するために使用されます。

UserDao.java ファイルのコードは、主に以下の要素で構成されています：

1. 他のクラスとインターフェースの参照。

現在のファイルが属するパッケージ名を package com.oceanbase.testspringboot.dao として宣言し、以下のインターフェースとクラスを含みます：

* `User` クラス：ユーザーデータの受け渡しと保存に使用されます。
* `List` インターフェース：クエリ結果セットの操作に使用されます。

コードは以下の通りです：

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

2. UserDao インターフェースの定義。

UserDao インターフェースを使用して、ユーザーデータに対する操作メソッドを定義します。これには、ユーザー情報の挿入、ユーザー情報の削除、ユーザー情報の更新、ユーザーIDに基づくユーザー情報のクエリ、およびすべてのユーザー情報のクエリなどのメソッドが含まれます。

コードは以下の通りです：

```java
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 クラスを定義することでユーザーオブジェクトを表すために使用されます。

1. User オブジェクトの宣言。 User クラスが id と name の2つのプライベートフィールドを含むことを宣言し、引数なしのコンストラクタを提供します。id と name フィールドの値を設定および取得することで、ユーザー情報を操作します。

コードは以下の通りです：

```java
private Long id;
private String name;

public User() {
}
```

2. User オブジェクトの作成。 指定された id と name を持つ User オブジェクトを作成するために使用される、User クラスの引数付きコンストラクタを定義します。

コードは以下の通りです：

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

3. id と name の値の取得と設定。 id と name 属性の値を取得および設定するために使用される、User クラス内の4つのメソッドを定義します。 getId メソッドは id 値の取得に使用され、setId メソッドは id 値の設定に使用されます。getName メソッドはユーザー名 name の値の取得に使用されます。setName メソッドはユーザー名 name の値の設定に使用されます。

コードは以下の通りです：

```java
public Long getId() {
    return id;
}

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

public String getName() {
    return name;
}

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

4. User オブジェクトの文字列表現の返却。

User クラスの toString メソッドをオーバーライドし、User オブジェクトの文字列表現を返すために使用します。 @Override を定義して、親クラスの同名メソッドをオーバーライドします。toString メソッドを定義し、User オブジェクトの文字列表現を返すために使用します。文字列の連結により、id と name 属性の値を文字列としてフォーマットし、呼び出し元に User を返します。

コードは以下の通りです：

    ```java
        @Override

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

TestSpringbootApplication.java ファイルの紹介

TestSpringbootApplication.java ファイルは、UserDao インターフェースを通じてSpring Bootアプリケーションを起動するために使用されます。

TestSpringbootApplication.java ファイルのコードは、主に以下の要素で構成されています：

1. クラスとインターフェースの定義。

現在のファイルが属するパッケージ名を com.oceanbase.testspringboot として宣言し、以下のインターフェースとクラスを含みます：

* `SpringApplication` クラス：Spring Bootアプリケーションの起動に使用されます。
* `@SpringBootApplication` アノテーション：このクラスがSpring Bootアプリケーションのエントリポイントであることを示すために使用されます。

コードは以下の通りです：

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

2. TestSpringbootApplication クラスの定義。

SpringBootApplicationアノテーションを使用して、このクラスがSpring Bootアプリケーションのエントリクラスであることを示します。SpringApplicationクラスのrunメソッドを呼び出すことで、Spring Bootアプリケーションを起動できます。

コードは以下の通りです：

```java
@SpringBootApplication
public class TestSpringbootApplication {

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

TestSpringbootApplicationTests.java ファイルの紹介

TestSpringbootApplicationTests.java ファイルは、UserDao インターフェースを通じてSpring Bootアプリケーションを起動するために使用されます。

TestSpringbootApplicationTests.java ファイルのコードは、主に以下の部分で構成されています：

1. 他のクラスとインターフェースの参照。

現在のファイルが属するパッケージ名を com.oceanbase.testspringboot として宣言し、以下のインターフェースとクラスを含みます：

* `UserDao` インターフェース：UserDaoインターフェースで定義されたメソッドを実装するために使用されます。
* `User` クラス：ユーザーデータの受け渡しと保存に使用されます。
* `Test` アノテーション：テストメソッドを識別するために使用されます。

• Autowired アノテーション：JdbcTemplateオブジェクトをこのクラスに注入し、SQL文の実行に使用します。
  • SpringBootTest アノテーション：このクラスがSpring Bootのテストクラスであることを識別するために使用されます。
  • JdbcTemplate クラス：SQL文の実行とデータベースアクセスの処理に使用されます。
  • List インターフェース：クエリ結果セットの操作に使用されます。

コードは以下の通りです：

```java
import com.oceanbase.testspringboot.dao.UserDao;
import com.oceanbase.testspringboot.entity.User;

import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.jdbc.core.JdbcTemplate; import java.util.List;

```

2. TestSpringbootApplicationTests クラスの定義。

SpringBootTest アノテーションを使用して、Spring Bootアプリケーション内の機能をテストすることを示します。UserDao および JdbcTemplate オブジェクトを使用して、ユーザーデータに対する追加、削除、変更、クエリ操作を実行し、結果を出力します。

1. オブジェクトの定義。

Autowired アノテーションを使用して、UserDao および JdbcTemplate オブジェクトを自動的に注入します。

コードは以下の通りです：

    ```java
    @Autowired

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

2. contextLoads メソッドの定義。

contextLoads メソッドをテストメソッドの具体的な実装として使用します。

1. test_springboot テーブルの削除。

jdbcTemplate.execute メソッドを使用してSQL文 drop table test_springboot を実行し、test_springboot という名前のテーブルを削除します。

コードは以下の通りです：

      ```java
      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 という名前のテーブルを作成します。

コードは以下の通りです：

      ```java
      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 となります。

コードは以下の通りです：

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

4. データの削除。

userDao.deleteById メソッドを使用して、id が1のユーザーデータを削除します。

コードは以下の通りです：

      ```java
        userDao.deleteById(1L);
      ```

5. データの更新。

userDao.updateUser メソッドを使用して、id が2のユーザーデータを更新し、name を update に変更します。

コードは以下の通りです：

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

6. データのクエリ。

userDao.selectUserById メソッドを使用して、id が2のユーザーデータをクエリし、結果を出力します。

コードは以下の通りです：

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

7. すべてのデータのクエリ。

userDao.selectAllUsers メソッドを使用して、test_springboot テーブル内のすべてのユーザーデータをクエリし、結果を出力します。

コードは以下の通りです：

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

完全なコードの表示

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

<build>
    <plugins>
        <plugin>

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

    }

関連情報

OceanBase Connector/Jの詳細については、OceanBase JDBCドライバをご参照ください。