【Javaの基礎知識】Spring Boot WebアプリとDB接続、CRUD実装する！

2025年3月13日

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

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

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

Spring Bootでデータベースを扱うメリット
- JDBC、JPA、Spring Data JPAの違い
- 本記事で使用する環境と前提条件
データベースのセットアップ
JPAとSpring Data JPAの導入
API の動作確認（Postman）
CRUD処理の実装
よくあるエラーとその対処法
まとめ

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

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

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

JDBC、JPA、Spring Data JPAの違い

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

技術	特徴	メリット	デメリット
JDBC	標準的なJavaのDBアクセスAPI	低レイヤーで細かい制御が可能	コード量が多くなる
JPA	ORM（オブジェクトリレーショナルマッピング）を提供	エンティティの管理が容易	設定がやや複雑
Spring Data JPA	JPAを簡単に利用できるSpringの拡張機能	SQL記述不要で簡単にCRUD操作が可能	細かいチューニングが難しい

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

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

開発環境： 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環境を構築！

https://www.pmi-sfbac.org/mysql-docker-management

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)

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)

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上で以下の操作を行ってください。

プロジェクトを右クリック
「Maven」 → 「Update Project...」を選択
「Force Update of Snapshots/Releases」にチェックを入れる
「OK」をクリック
必要に応じて 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);
    }
}

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 は以下の処理を行います。

pom.xml に記述された依存関係を読み込み、必要なライブラリをダウンロード
application.properties の設定を適用し、データベース接続などの環境を自動構成
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

src/main/java/com/example/demo/

├── Application.java

├── entity/ 　　　　　　　← ここに作成

│ ├── User.java

├── repository/

│ ├── UserRepository.java

├── service/

│ ├── UserService.java

├── controller/

│ ├── UserController.java

Eclipse でディレクトリを作成する場合

src/main/java/com/example/demo を右クリック
「新規」 → 「パッケージ」を選択
パッケージ名に com.example.demo.entity を入力して作成
同様に repository、service、controller 、configも作成

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>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

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

Maven の依存関係を更新

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

プロジェクトを右クリック
「Maven」 → 「プロジェクトの更新（Update Project）」を選択
「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; }
}

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> {
    // 必要に応じてカスタムメソッドを定義可能
}

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

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

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 を使用する場合

Postman を開く
http://localhost:8080/users に GET リクエストを送る
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"}]

API の動作確認（Postman）

Spring Boot の REST API が正しく動作しているかを確認するには、Postman というツールを使用すると便利です。

Postman とは？

Postman は、API のリクエストを簡単に送信して動作確認ができる無料ツールです。ブラウザやアプリから API にアクセスする前に、個別にテストすることができます。

Postman は、API 開発の現場で広く利用されているツールであり、以下のような場面で特に役立ちます。 

プロジェクトで使う場面

PAPI の動作確認（開発中） 
API にリクエストを直接送信し、レスポンスを確認することで、バックエンドの処理が正常に機能しているかテストできます。 
バグ調査・デバッグ 
アプリのフロントエンドとバックエンドのどちらに問題があるのかを切り分ける際に、Postman を使って API のレスポンスを直接確認することができます。 
フロントエンドチームとの連携 
バックエンドの開発者が API のエンドポイントを Postman で共有することで、フロントエンドの開発者がスムーズにテストできるようになります。 
API のドキュメント作成 & 共有 
Postman では API のリクエストやレスポンスを保存し、チームメンバーと共有することが可能です。API 仕様の管理にも役立ちます。 
自動テスト・CI/CD との統合 
Postman のテスト機能を活用し、CI/CD パイプラインに組み込むことで、API の品質を継続的に検証することができます。

このように、Postman は API 開発において重要な役割を果たすツールです。次に、Postman を使用して Spring Boot の API をテストする方法を解説します。

Postman のインストール方法

Postman 公式サイトからダウンロード＆インストール
起動後、「Skip and go to the app（スキップしてアプリを使う）」を選択（サインアップ不要）
API テストを開始

Postman を使って GET リクエストを送る

Postman を開く
リクエストの種類を GET に設定
URL に http://localhost:8080/users を入力
「Send」ボタンをクリック
以下のような JSON レスポンスが表示されれば成功

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

Postman でデータを登録（POST）

リクエストの種類を POST に変更
URL に http://localhost:8080/users を入力
「Body」タブ → raw を選択し、以下の JSON を入力

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

「Send」ボタンをクリック
登録されたデータがレスポンスに返ってくれば成功

Postman でデータを削除（DELETE）

リクエストの種類を DELETE に変更
URL に http://localhost:8080/users/1 を入力（削除したい ID を指定）
「Send」ボタンをクリック
リクエストが成功すればデータベースから削除される

Postman を活用すれば、Spring Boot の API を手軽にテストできるので、ぜひ試してみてください！

CRUD処理の実装

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

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

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

📂 各パッケージの役割

パッケージ名	役割
controller	API のエンドポイントを提供（REST API）
entity	データベースのテーブルとマッピング（JPA エンティティ）
repository	データベースの操作（Spring Data JPA）
service	ビジネスロジックを処理（データの操作・変換など）
config	設定関連（DB接続設定、CORS設定など）

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

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

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

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

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

}

この API に対して POST リクエストを送信することで、データの追加（Create）、取得（Read）、更新（Update）、削除（Delete）処理が実行可能となります。

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

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

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」ボタンをクリックし、データが削除されたことを確認

削除後の確認方法

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

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

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

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

ステータスコード	意味
204 No Content	削除成功（標準的なレスポンス）
200 OK	削除成功（何かしらのレスポンスがある場合）
404 Not Found	指定したIDのデータが存在しない
500 Internal Server Error	サーバー側のエラー（DBの制約違反など）

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

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

原因と解決策

エラー内容	原因	解決策
Cannot load driver class: com.mysql.cj.jdbc.Driver	MySQLドライバが見つからない	pom.xml にMySQLの依存関係があるか確認依存関係を更新: 「Maven」→「プロジェクトの更新」
Access denied for user	データベースのユーザー名またはパスワードが間違っている	application.properties の spring.datasource.username と spring.datasource.password を確認 MySQLのユーザー設定を修正
Communications link failure	データベースが起動していない	MySQLが起動しているか確認: systemctl status mysql または mysql.server start ポート3306でリスニングしているか確認

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アプリケーションを開発できるようになります。次のステップへ進み、より実践的な開発を学んでいきましょう。

よく読まれている記事

1: 【IT入門】シェルとシェルスクリプトの違いとは？シェルの種類について
IT入門シリーズ 🟢 STEP 1: ITの基礎を知る（ITとは何か？）├─【IT入門】ITとは？仕組みや活用方法をわかりやすく解説├─【IT入門】インターネットとは？仕組み・使い方を ...

2: 【Linuxの基礎知識】Linuxとは？基本概要と仕組みをわかりやすく解説！
「私たちが日々利用しているスマートフォンやインターネット、そしてスーパーコンピュータやクラウドサービス――これらの多くがLinuxの力で動いていることをご存じですか？無料で使えるだけでなく、高い柔軟性 ...

3: 【Shellの基礎知識】Shellスクリプト入門｜初心者が押さえる基本
Shellスクリプト基礎知識（全13記事+2） ├─【Shellの基礎知識】Shellスクリプト入門｜初心者が押さえる基本├─【Shellの基礎知識】変数と特殊変数の使い方｜初心者向け解説├─【She ...

-Java の基礎知識

【Javaの基礎知識】例外処理とエラー対策を徹底解説！

Javaのプログラムでは、エラーが発生すると処理が停止してしまうことがあります。しかし、例外処理を適切に実装すれば、エラーを制御し、安定したプログラムを作成できます。本記事では、Javaの例外処理の基本から実践的なエラー対策までを解説します。もくじ例外処理とは？基本概念を理解しよう例外（Exception）とは？エラー（Error）との違いチェック例外と非チェック例外の違い Javaの例外処理の基本構文 try-catch文の使い方 finallyブロックの役割 throwsとthrowの違い ...

【Javaの基礎知識】JavaFXでGUIアプリ作成入門！基本から実践まで！

JavaFXはJavaでGUIアプリを作成するためのフレームワークです。本記事ではJavaFXの基本的な仕組みから、簡単なGUIアプリの作成手順までを解説します。初心者でも理解しやすいよう、サンプルコードを交えて説明しますので、ぜひ参考にしてください。もくじ JavaFXとは？基本概念を解説 JavaFXの概要 JavaFXの特徴とメリット JavaFXの開発環境を構築する必要なツールのインストール OpenJDK 21のインストール JavaFX SDKの導入 JavaFXプロジェクトの作成 Mai ...

【Javaの基礎知識】JDBCを使ったTodoアプリのDB連携と実装手順

もくじ JDBCとは？基本概念と仕組み JDBCの概要 JDBCの主要コンポーネント JavaアプリからMySQLに接続するTodoアプリの概要と設計✅ 実装済みの機能🔧 仕様 Todoアプリの完成イメージデータベースを作成する MySQLにデータベースを作成データベースを選択するタスク管理用のテーブルを作成テーブルが作成されたか確認サンプルデータを挿入 JDBC接続専用クラスを作成する JDBCを使うための準備データベースと接続するクラスを作成 DAO（Data ...

【Javaの基礎知識】Eclipse＋TomcatでWeb開発環境を構築！

JavaでWebアプリ開発を始めるには、まずEclipseで動的Web環境を構築する必要があります。本記事では、EclipseのインストールからTomcatの設定、Servlet/JSPの動作確認までを初心者向けにわかりやすく解説します。また、Javaのプロジェクト管理ツールであるMavenにも触れ、Mavenを使う場合と使わない場合の環境構築の違いについても解説します。手動でライブラリを管理する方法と、Mavenを活用して依存関係を自動管理する方法を理解し、自分に合った開発環境を選びましょう。「Ma ...

【Javaの基礎知識】最小限の機能で作るJavaFXテキストエディタ

JavaFXを使って、シンプルなエディタアプリを作成する方法を解説します。本記事では、基本的なUI設計からイベント処理の実装まで、実践的なステップを詳しく説明します。初心者でも理解しやすいように、コード付きで解説しているので、ぜひ参考にしてください。もくじエディタアプリの概要本アプリの目的エディタとして実現する機能一覧操作性とUIの要件エディタアプリの全体設計書の構成と設計要素設計方針アプリの主要コンポーネントファイル管理とユーザー設定エディタアプリの使用する全クラス一覧エディタアプリの実装手順メ ...

【Javaの基礎知識】Spring BootでWebアプリを実装する方法