【Javaの基礎知識】Spring Boot × MySQL！DB接続からCRUD実装まで解説！

Spring Bootを用いたWebアプリ開発では、データベースとの連携が不可欠です。本記事では、Spring Bootを使用してデータベース接続を行う方法を詳しく解説します。JPA（Java Persistence API）やSpring Data JPAを活用し、効率的にデータベースと連携する方法を学びましょう。

Spring Bootとデータベースの基本

Spring Bootを使用したWebアプリ開発では、データベースとの連携が不可欠です。このセクションでは、Spring Bootとデータベースの関係を理解し、使用する技術の違いについて解説します。

Spring Bootでデータベースを扱うメリット

Spring Bootを使用することで、データベースとの連携が容易になります。従来の手動設定が不要になり、以下のようなメリットがあります。

• 設定ファイル（ application.properties）で簡単にDB設定が可能
• Spring Data JPAを利用することで、SQLの記述が不要になる
• トランザクション管理が容易で、安定したデータ処理が可能

JDBC、JPA、Spring Data JPAの違い

Spring Bootでデータベースを操作する方法には、JDBC、JPA、Spring Data JPAの3つがあります。それぞれの特徴を理解して、適切な技術を選択しましょう。

本記事で使用する環境と前提条件

本記事では、以下の環境を前提として解説します。環境が異なる場合は適宜読み替えてください。

• 開発環境： Windows / macOS / Linux
• Javaバージョン： Java 21
• Spring Bootバージョン： 3.x
• データベース： MySQL 8.0
• ビルドツール： Maven

データベースのセットアップ

Spring BootでWebアプリを開発する際、データベースとの連携をスムーズに行うためには適切なセットアップが必要です。このセクションでは、MySQLのインストール方法、Spring Bootの設定ファイルの記述、データベース接続の確認手順を解説します。

MySQLのインストールと設定

Spring BootアプリでMySQLを使用するためには、データベースのインストールと基本設定を行う必要があります。以下の手順でセットアップを進めてください。

MySQLのインストール

以下の公式サイトからMySQLをダウンロードし、インストールを行います。

• MySQL公式ダウンロードページ

インストール後、MySQLサーバーを起動し、管理ツール（MySQL Workbench など）を使用して接続を確認してください。

MySQLの導入については、「【Javaの基礎知識】DockerでMySQL環境を構築！」の記事を参考にしてください。Dockerを利用することで、MacやWindowsに直接MySQLをインストールすることなく、簡単に環境を構築できます。

Beエンジニア

【Javaの基礎知識】DockerでMySQL環境構築｜Javaから接続する手順

https://www.pmi-sfbac.org/java-practical-03-docker-mysql

Dockerを使えば、Javaに限らずあらゆる環境での開発が簡単になります。ローカル環境にMySQLをインストールせずに、手軽にデータベースを利用できるのも大きなメリットです。本記事では、Java開発向けにDockerを活用したMySQL環境の構築方法を詳しく解説します。DockerでMySQL環境を構築するメリットDockerを活用すれば、MySQL環境を手軽に構築でき、開発やテストの効率が大幅に向上します。ローカル環境に直接MySQLをインストールする必要がなく、環境の違いによるトラブルを回避できるのも大きなメリットです。また、コンテナ化するこ...

MySQLの基本設定

データベースとユーザーを作成し、Spring Bootアプリが接続できるようにします。以下のSQLコマンドを実行してください。

CREATE DATABASE springboot_db;
CREATE USER 'springuser'@'%' IDENTIFIED BY 'root';
GRANT ALL PRIVILEGES ON springboot_db.* TO 'springuser'@'%';
FLUSH PRIVILEGES;

データベースの作成可否を確認します。下記のコマンドでデータベースが作成されていることを確認してください。

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sampledb           |
| springboot_db      |
| sys                |
| todo_db            |
+--------------------+
7 rows in set (0.00 sec)

テーブルの作成

データベースの作成は完了しましたが、データを保存するためのテーブルがまだ存在していません。以下の SQL を実行して、 users テーブルを作成してください。

CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE
);

データの登録

作成したテーブルにテストデータを登録します。

以下の SQL を実行して、データを挿入してください。

INSERT INTO users (name, email) VALUES ('Taro', 'taro@example.com');
INSERT INTO users (name, email) VALUES ('Hanako', 'hanako@example.com');

データ登録の確認

データが正しく登録されたかを確認するために、以下の SQL を実行してください。

SELECT * FROM users;

このコマンドを実行し、 users テーブルにデータが登録されていることを確認してください。

mysql> SELECT * FROM users;
+----+--------+--------------------+
| id | name   | email              |
+----+--------+--------------------+
|  1 | Taro   | taro@example.com   |
|  2 | Hanako | hanako@example.com |
+----+--------+--------------------+
2 rows in set (0.00 sec)

Spring BootとMySQLの連携に必要な設定（pom.xml）

Spring Boot で MySQL に接続するために、Maven の依存関係を設定します。以下のコードを pom.xml に追加してください。

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version> <!-- バージョンを指定 -->
    <scope>runtime</scope>
</dependency>

Mavenの依存関係を更新

上記の変更を反映するために、以下のコマンドを実行してください。

mvn clean install

また、Eclipse を使用している場合は、プロジェクトの右クリックメニューから [Maven] → [Update Project] を実行してください。

application.properties の設定方法

Spring Bootでデータベースに接続するには、 application.properties または application.yml に接続情報を記述します。

MySQL用の設定

以下の設定を src/main/resources/application.properties に追加してください。
※ 「 src/main/resources/」配下に対象のファイルが存在しない場合は作成してください。

spring.datasource.url=jdbc:mysql://localhost:3306/springboot_db?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect
logging.level.org.springframework.jdbc=DEBUG
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.springframework.transaction=TRACE

下三行は、データベースとの接続を確認するために「ログレベルを DEBUG に変更して、データベース接続の詳細ログを出す」設定です。

MySQL接続用の依存関係を追加

Spring Boot で MySQL に接続するために、Maven の依存関係を設定します。以下のコードを pom.xml に追加してください。

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version> <!-- バージョンを指定 -->
    <scope>runtime</scope>
</dependency>

Mavenの依存関係を更新

上記の変更を反映するために、Eclipse上で以下の操作を行ってください。

1. プロジェクトを右クリック
2. 「Maven」 → 「Update Project...」 を選択
3. 「Force Update of Snapshots/Releases」にチェックを入れる
4. 「OK」をクリック
5. 必要に応じて Eclipse を再起動

依存関係が正しく更新されると、 pom.xml に追加した mysql-connector-java が認識され、エラーが解消されます。

エントリポイントの作成

Spring Boot アプリを実行するために、エントリポイントとなるクラス Application.java を作成します。

以下のコードを src/main/java/com/example/demo/Application.java に記述してください。

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {
    @Value("${spring.datasource.url:NOT_SET}")
    private String dataSourceUrl;

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

    @Bean
    CommandLineRunner checkDatabaseConnection() {
        return args -> System.out.println("✅ Database URL: " + dataSourceUrl);
    }
}

アプリケーションの起動と確認

以下のコマンドを実行し、アプリケーションを起動します。

mvn spring-boot:run

アプリの起動後、コンソールに以下のメッセージが表示されることを確認してください。

✅ Database URL: jdbc:mysql://localhost:3306/springboot_db?serverTimezone=UTC

このメッセージが表示されれば、 application.properties の設定が正しく適用され、Spring Boot が DataSource を自動設定したことを確認できます。

設定が適用されていない場合の確認

もし NOT_SET と表示される場合は、 application.properties が正しく読み込まれていない可能性があります。 その場合、以下の点を確認してください。

• application.properties のファイルが正しいディレクトリに配置されているか
• spring.datasource.url の記述ミスがないか
• アプリケーションの再起動を試す

上記の確認を行い、正しく設定されていることを確認してください。

Spring Bootの実行方法とmvn spring-boot:runの仕組み

通常、データベースに接続する際は、データベース接続用のクラスを作成し、手動で設定を行う必要があります。

しかし、Spring Boot には「Spring Boot Auto Configuration」という仕組みがあり、 application.properties に接続情報を記述するだけで、Spring Boot が自動的に DataSource を設定してくれます。

つまり、通常なら開発者が手動で DataSource の設定を行うところを、Spring Boot が 「DataSourceConfig.java はもう不要！」 と判断し、自動で適用してくれるのです。

Spring Bootの実行手順

アプリケーションを起動するには、以下のコマンドを実行します。

mvn spring-boot:run

このコマンドを実行すると、Spring Boot は以下の処理を行います。

1. pom.xml に記述された依存関係を読み込み、必要なライブラリをダウンロード
2. application.properties の設定を適用し、データベース接続などの環境を自動構成
3. Spring Boot の組み込み Tomcat サーバーを起動し、アプリケーションを実行

実行後の確認

アプリが正常に起動し、データベース接続が成功しているかどうかを確認するには、コンソールログをチェックします。以下のメッセージが表示されていれば、データベース接続が成功しています。

✅ Database URL: jdbc:mysql://localhost:3306/springboot_db?serverTimezone=UTC

もし NOT_SET と表示される場合は、 application.properties の設定が正しく適用されていない可能性があります。その場合は、以下の点を確認してください。

• application.properties のファイルが src/main/resources/ に配置されているか
• spring.datasource.url の記述ミスがないか
• Maven の依存関係を更新したか（「Maven の依存関係を更新」セクションを参照）
• アプリケーションの再起動を試す

上記の確認を行い、正しく設定されていることを確認してください。

JPAとSpring Data JPAの導入

Spring Boot でデータベースを操作する際、JPA（Java Persistence API）と Spring Data JPA を活用することで、データアクセス層を簡単に実装できます。本記事では、JPAの基本概念から、Spring Data JPA を利用した実装方法までを解説します。

JPAとは？基本概念を解説

JPA（Java Persistence API）は、Java のオブジェクトとデータベースのテーブルをマッピングするための標準APIです。JPA を利用することで、SQL を直接記述せずに、Java のオブジェクトを通じてデータの永続化（保存・取得・更新・削除）を行うことができます。

JPA の主な特徴は以下の通りです。

• オブジェクトとリレーショナルデータベース（RDB）のマッピングを容易にする
• エンティティ（ @Entity）を使用して、テーブルを Java クラスとして扱う
• JPQL（Java Persistence Query Language）を使用して、データを操作できる

JPA は単体では利用できず、実装ライブラリ（Hibernate など）と組み合わせて使用されます。Spring Boot では、デフォルトで Hibernate が JPA の実装として使用されます。

ディレクトリ構成

以下のように、各クラスを適切なパッケージに作成します。
※ com.example.demo.entity などのディレクトリは 自分で作成する必要があります。

src/main/java/com/example/demo/
 ├── Application.java
 ├── entity/ 　　　　　　　← ここに作成
 │   ├── User.java
 ├── repository/ 
 │   ├── UserRepository.java
 ├── service/ 
 │   ├── UserService.java
 ├── controller/ 
 │   ├── UserController.java

mkdir -p src/main/java/com/example/demo/entity
mkdir -p src/main/java/com/example/demo/repository
mkdir -p src/main/java/com/example/demo/service
mkdir -p src/main/java/com/example/demo/controller
mkdir -p src/main/java/com/example/demo/config

JPA の利用に必要な Jakarta Persistence の設定

Spring Boot で JPA（Java Persistence API）を利用するには、 jakarta.persistence を適切に設定する必要があります。

pom.xml に JPA の依存関係を追加

まず、Spring Boot の JPA 機能を有効にするために、 spring-boot-starter-data-jpa の依存関係を pom.xml に追加します。

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

この依存関係を追加した後、Maven の依存関係を更新してください。

Maven の依存関係を更新

依存関係を正しく適用するために、Eclipse 上で以下の操作を行います。

1. プロジェクトを右クリック
2. 「Maven」 → 「プロジェクトの更新（Update Project）」 を選択
3. 「Force Update of Snapshots/Releases」にチェックを入れて「OK」 をクリック

Entity クラスの作成方法

JPA を利用するには、データベースのテーブルに対応する「Entity クラス」を作成します。Entity クラスには、 @Entity アノテーションを付与し、フィールドごとにデータベースのカラムを定義します。

以下の例では、「User」テーブルに対応する Entity クラスを作成します。

package com.example.demo.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "users") // ここが重要！
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    // ゲッターとセッター
    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; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

このクラスを作成することで、Spring Boot は「User」テーブルと自動的にマッピングし、データベースとの連携を行います。

Repository インターフェースの作成

JPA でデータベースを操作する際は、リポジトリ（Repository）を作成します。Spring Data JPA を利用すると、標準的な CRUD 操作（保存・取得・更新・削除）を簡単に実装できます。

以下のコードは、User エンティティのデータ操作を行う Repository インターフェースの例です。

package com.example.demo.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.demo.entity.User;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // 必要に応じてカスタムメソッドを定義可能
}

このインターフェースを作成することで、Spring Data JPA が実装クラスを自動生成し、データベース操作を簡単に行うことができます。

Service クラスと Controller でのデータ操作

リポジトリを作成したら、Service クラスと Controller を実装し、実際にデータを操作できるようにします。

Service クラスの作成

Service クラスは、ビジネスロジックを担当し、リポジトリを利用してデータベースとのやり取りを行います。

package com.example.demo.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
}

Controller クラスの作成

Controller クラスでは、REST API を作成し、クライアントからのリクエストに応じてデータを操作できるようにします。

package com.example.demo.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getUsers() {
        return userService.getAllUsers();
    }
}

この Controller を作成すると、 http://localhost:8080/users にアクセスすることで、データベースに登録されている User 一覧を取得できます。

データ取得の確認

Spring Boot アプリが正しくデータベースに接続し、データを取得できるか確認します。

ブラウザで以下の URL にアクセスしてください。

http://localhost:8080/users

正常に動作している場合、以下のような JSON データが表示されます。

[{"id":1,"name":"Taro","email":"taro@example.com"},
{"id":2,"name":"Hanako","email":"hanako@example.com"}]

これは、データベースに保存されている users テーブルのデータが、Spring Boot の REST API を通じて JSON 形式で取得できていることを示しています。

Postman や curl を使用して確認する

ブラウザ以外のツールでもデータが取得できるか確認できます。

✅ Postman を使用する場合

1. Postman を開く
2. http://localhost:8080/users に GET リクエストを送る
3. JSON 形式のデータが返ってくれば成功

✅ curl を使用する場合

ターミナルで以下のコマンドを実行します。

curl -X GET http://localhost:8080/users

同じ JSON データが取得できれば、Spring Boot の REST API が正常に動作していることが確認できます。

[{"id":1,"name":"Taro","email":"taro@example.com"},{"id":2,"name":"Hanako","email":"hanako@example.com"}]

CRUD処理の実装

Spring Boot を使用してデータベースの基本的な CRUD（Create, Read, Update, Delete）処理を実装します。ここでは、ユーザー情報を管理する REST API を作成し、データの登録、取得、更新、削除を行います。

※本記事でのAPIの動作確認は、Postmanを使用しています。Postmanのインストールや基本操作については、以下の記事で詳しく解説していますので、あわせてご覧ください。

Beエンジニア

【初心者向け】Postmanの使い方とAPIテストの始め方を徹底解説！

https://www.pmi-sfbac.org/postman-install-usage

APIの動作確認や開発現場でのテストに欠かせないのが「Postman」というツールです。この記事では、Postmanのインストール方法から基本的な使い方、GETやPOSTなどのリクエストの送信方法まで、APIテストの基礎を初心者向けにわかりやすく解説します。これからAPI開発やWebシステムに携わる方は、ぜひPostmanを活用できるようになりましょう。 API の動作確認（Postman）Spring Boot の REST API が正しく動作しているかを確認するには、Postman というツールを使用すると便利です。Postman とは？Postman は、API のリクエストを簡単に...

Spring Boot におけるパッケージ構成の慣例

Spring Boot では、プロジェクトの規模が大きくなるにつれ、コードを適切に整理するために、パッケージを役割ごとに分割するのが一般的です。以下のような「レイヤードアーキテクチャ」に基づいた構成が推奨されています。

📂 各パッケージの役割

📂 推奨されるディレクトリ構成

以下のように、各クラスを適切なパッケージに整理することで、コードの可読性と保守性を向上させることができます。

springboot-demo/
│── src/
│   ├── main/
│   │   ├── java/com/example/demo/
│   │   │   ├── entity/             # Entityクラス（DBのテーブルと対応）
│   │   │   │   ├── User.java       # Userエンティティクラス
│   │   │   │
│   │   │   ├── repository/         # JPA Repository（DB操作）
│   │   │   │   ├── UserRepository.java
│   │   │   │
│   │   │   ├── service/            # Service（ビジネスロジック）
│   │   │   │   ├── UserService.java
│   │   │   │
│   │   │   ├── controller/         # REST API（CRUDを実装）
│   │   │   │   ├── UserController.java
│   │   │   │
│   │   │   ├── Application.java    # エントリポイント
│   │   │
│   ├── resources/
│   │   ├── application.properties  # DB接続設定
│
│── pom.xml
│── README.md

✅ なぜこの構成が推奨されるのか？

• Spring のコンポーネントスキャン（@ComponentScan）で適切に認識される
• 役割ごとに整理することで、可読性・保守性が向上する
• 実際の開発現場でもこのようにディレクトリを分けるのが一般的
• 規模が大きくなっても影響範囲を把握しやすい

❓「この構成にしないと動かないのか？」

必須ではありませんが、すべてのクラスを com.example.demo にまとめると、コードがカオスになり、長期的にメンテしづらくなります。
最初から適切に分割しておくことで、開発がスムーズに進みます。

この構成を採用することで、スケールしやすい Spring Boot プロジェクトを構築できます！

1. Controller クラスの作成

REST API を作成するために、 UserController クラスを作成します。このクラスでは、データの追加（Create）、取得（Read）、更新（Update）、削除（Delete）を実装します。

package com.example.demo.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    // ✅ ユーザーの新規作成（POST /users）
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    // ✅ 全ユーザー取得（GET /users）
    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    // ✅ ユーザー情報の更新（PUT /users/{id}）
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        return userService.updateUser(id, userDetails);
    }

    // ✅ ユーザー削除（DELETE /users/{id}）
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

REST API では CRUD 操作を HTTP メソッドで表現します。POST でデータの作成（Create）、GET でデータの取得（Read）、PUT でデータの更新（Update）、DELETE でデータの削除（Delete）を行います。このルールに従うことで、直感的に API の役割と使い方を理解できるようになります。

2. Service クラスの作成

Controller から呼び出すビジネスロジックを実装するために、 UserService クラスを作成します。

package com.example.demo.service;

import java.util.List;
import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    // ✅ ユーザーの新規作成
    public User createUser(User user) {
        return userRepository.save(user);
    }

    // ✅ 全ユーザー取得
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    // ✅ ユーザー情報の更新
    public User updateUser(Long id, User userDetails) {
        Optional<User> optionalUser = userRepository.findById(id);
        if (optionalUser.isPresent()) {
            User user = optionalUser.get();
            user.setName(userDetails.getName());
            user.setEmail(userDetails.getEmail());
            return userRepository.save(user);
        }
        throw new RuntimeException("User not found with id: " + id);
    }

    // ✅ ユーザー削除
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

3. Repository クラスの作成

Spring Data JPA を利用してデータベースとのやり取りを行うため、 UserRepository インターフェースを作成します。

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

4. 動作確認

Spring Bootアプリがデータベースと正常に連携しているかを確認します。今回は、Postmanを使った手動テスト でCRUD処理の動作をチェックします。

• ユーザーの新規作成（Create） - POST http://localhost:8080/users
• 全ユーザー取得（Read） - GET http://localhost:8080/users
• ユーザー情報の更新（Update） - PUT http://localhost:8080/users/{id}
• ユーザー削除（Delete） - DELETE http://localhost:8080/users/{id}

JUnitによるテストについて
JUnitを使用すると、プログラムが正しく動作しているかを 自動でコードのテスト が可能です。 Postmanは手動での動作確認ですが、JUnitを導入すれば、アプリが大きくなったときに 自動でエラー検出が可能 になります。ただし、JUnitの導入は初心者には少しハードルが高いため、まずはPostmanでの動作確認だけでOK です。 JUnitについて詳しく知りたい方は、別の機会に改めて解説します。

Postmanを使ってSpring Boot APIをテストする方法

1. GETリクエストでデータを取得

Postmanを開き、新しいリクエストを作成します。

• メソッドを「GET」に設定
  

  

• URLに http://localhost:8080/users を入力
  

  

• 「Send」ボタンをクリック
  

  

• 画面下部のレスポンスにJSONデータが返ってくることを確認
  

  

2. POSTリクエストでデータを追加

• メソッドを「POST」に変更
• URLに http://localhost:8080/users を入力
• 「Body」タブを開き、「raw」→「JSON」を選択
• 以下のようなJSONを入力

{ "name": "Jiro",
"email": "jiro@example.com" }

• 「Send」ボタンを押して、データが追加されたことを確認
  

  

3. PUTリクエストでデータを更新

• メソッドを「PUT」に設定
• URLを http://localhost:8080/users/1 に変更（id=1のユーザーを更新）
• 「Body」タブで以下のJSONを入力

{ "id": 1,
"name": "Taro Updated",
"email": "taro_updated@example.com" }

• 「Send」をクリックして更新を確認
  

  

4. DELETEリクエストでデータを削除

• メソッドを「DELETE」に変更
• URLを http://localhost:8080/users/1 に設定
• 「Send」ボタンをクリックし、データが削除されたことを確認
  

  

削除後の確認方法

削除処理が正しく動作しているか、以下の手順で確認できます。

1. DELETE http://localhost:8080/users/1 を実行
2. GET http://localhost:8080/users を実行し、ID 1 のデータが消えているか確認

ステータスコードの確認ポイント

DELETE リクエストのレスポンスは、基本的にボディなしで返ってくるのが一般的です。そのため、ステータスコードを確認するのが正しい方法です。

よくあるエラーとその対処法

Spring Bootとデータベースを連携させる際、さまざまなエラーが発生する可能性があります。 ここでは、特に頻発するエラーの原因と解決策について解説します。

データベース接続エラーの原因と解決策

Spring Bootアプリを起動した際にデータベース接続エラーが発生することがあります。原因と対処法を確認しましょう。

発生しうるエラー

Cannot load driver class: com.mysql.cj.jdbc.Driver
Access denied for user 'root'@'localhost' (using password: YES)
Communications link failure

原因と解決策

LazyInitializationException の対処法

Spring BootのJPAを使用していると、以下のようなエラーが発生することがあります。

org.hibernate.LazyInitializationException: could not initialize proxy – no Session

原因

これは、エンティティのフィールドが LAZY（遅延読み込み）に設定されており、 データを取得する際にセッションが閉じてしまうことが原因です。

解決策

• 必要なら @Transactional をメソッドに付与する
• @OneToMany(fetch = FetchType.LAZY) を FetchType.EAGER に変更する
• 必要なデータをJPQLで明示的にフェッチする

@Transactional の使い方と注意点

Springの @Transactional は、データベースのトランザクション管理を行うためのアノテーションです。 正しく理解しないと意図しないエラーにつながることがあります。

よくある間違い

• クラスやメソッドに @Transactional を付けていないため、DBの更新が反映されない
• 異なるスコープのメソッド間で @Transactional を使用し、セッションが切れる
• SpringのAOPにより、 private メソッドでは @Transactional が適用されない

正しい使い方

import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Transactional
    public void updateUser(Long id, String newName) {
        User user = userRepository.findById(id).orElseThrow();
        user.setName(newName);
    }
}

注意点

• @Transactional は private メソッドでは動作しない
• デフォルトではロールバックしないので、例外を適切にキャッチする

まとめ

本記事では、Spring Bootを用いたデータベース接続、CRUD処理の実装、エラーハンドリングについて解説しました。 以下に、今回学んだ重要なポイントを整理します。

• Spring Bootでは application.properties にデータベース接続情報を記載することで、手軽にデータベースへ接続できる
• JPAとSpring Data JPAを利用することで、SQLを書かずにデータベース操作が可能 になる
• Postmanを使用することで、手動でAPIの動作確認 ができる
• Spring Bootの組み込み機能（Auto Configuration、Component Scan）により、設定の手間が大幅に削減される
• よくあるエラー（データベース接続エラー、LazyInitializationExceptionなど）の対処法を理解することで、スムーズに開発が進められる

Spring Bootを使いこなすことで、効率的にWebアプリケーションを開発できるようになります。 次のステップへ進み、より実践的な開発を学んでいきましょう。

Spring BootでCRUD実装の基礎を理解できたら、次は実際の運用環境で動かす方法を学んでステップアップしましょう。下記の記事で、Spring Bootアプリの実行環境の整え方とデプロイ手順をわかりやすく解説しています。

👉 【Javaの基礎知識】Spring Bootアプリの実行環境とデプロイ手順

Beエンジニア

【Javaの基礎知識】Spring Bootアプリの実行環境とデプロイ手順

https://www.pmi-sfbac.org/java-practical-11-springboot-deploy

Spring Bootアプリを開発した後、実際に動作させるためにはデプロイと実行の手順を理解することが重要です。本記事では、Spring Bootアプリのデプロイ方法やローカル環境・クラウド環境での実行手順について詳しく解説します。Spring Bootアプリケーションの開発では、ローカル環境での実行が基本ですが、実際にサーバーへデプロイして運用する知識も重要です。本記事では、JARファイルの作成、ローカルおよび本番環境での実行方法、クラウド環境へのデプロイ手順などを解説します。 直接的に自分のアプリ開発環境とは関係ないと思うか...