MENU
  1. ホーム
  2. Java
  3. Spring BootでのRESTful API開発方法：基本から応用まで徹底解説

Spring BootでのRESTful API開発方法：基本から応用まで徹底解説

Java

Spring Bootは、JavaでのWebアプリケーション開発を迅速かつシンプルに行うためのフレームワークです。特にRESTful APIの開発においては、少ない設定で効率的に動作する点が大きな特徴です。本記事では、Spring Bootを使ってRESTful APIを開発するための基本的な手順から、実際のエンドポイント作成、データベース接続、セキュリティ設定などを詳しく解説します。初心者にもわかりやすく、ステップバイステップで進めることで、Javaを使ったWeb API開発を確実に理解できる内容となっています。

目次
  1. RESTful APIの基本概念
    1. RESTの6つの原則
    2. なぜRESTが選ばれるのか
  2. Spring Bootとは
    1. Spring Bootの特徴
    2. Spring BootがAPI開発で選ばれる理由
  3. 開発環境の準備
    1. 1. Java開発キット（JDK）のインストール
    2. 2. IDE（統合開発環境）のインストール
    3. 3. MavenまたはGradleの設定
    4. 4. Spring Initializrの使用
  4. 初めてのSpring Bootプロジェクトの作成
    1. Spring Initializrを使用したプロジェクト作成
    2. プロジェクトのインポート
    3. Spring Bootアプリケーションの起動
  5. RESTful APIの基本エンドポイントの作成
    1. コントローラーの作成
    2. GETメソッド
    3. POSTメソッド
    4. PUTメソッド
    5. DELETEメソッド
    6. 実行とテスト
  6. データベース接続とエンティティの定義
    1. 1. データベースの設定
    2. 2. エンティティの定義
    3. 3. リポジトリの作成
    4. 4. コントローラーでのデータベース操作
  7. エラーハンドリングとバリデーション
    1. 1. エラーハンドリング
    2. 2. データのバリデーション
    3. 3. エラーハンドリングとバリデーションのまとめ
  8. セキュリティ対策
    1. 1. Spring Securityの導入
    2. 2. 基本認証の設定
    3. 3. JWT（JSON Web Token）による認証
    4. 4. まとめ
  9. Swaggerを使ったAPIドキュメントの生成
    1. 1. Swaggerの依存関係の追加
    2. 2. Swaggerの設定
    3. 3. APIエンドポイントの自動ドキュメント化
    4. 4. カスタムドキュメントの追加
    5. 5. まとめ
  10. テストの実装
    1. 1. テスト環境の設定
    2. 2. コントローラーの単体テスト
    3. 3. リポジトリの単体テスト
    4. 4. 統合テスト
    5. 5. まとめ
  11. APIのデプロイ方法
    1. 1. JARファイルの作成
    2. 2. クラウド環境へのデプロイ
    3. 3. Dockerを使ったデプロイ
    4. 4. まとめ
  12. まとめ

RESTful APIの基本概念


REST（Representational State Transfer）は、Webサービスのアーキテクチャスタイルの一つで、シンプルで柔軟なインターフェースを提供するために設計されています。RESTful APIは、このRESTアーキテクチャの原則に従って作成されたAPIであり、HTTPプロトコルを使用してクライアントとサーバー間の通信を行います。

RESTの6つの原則


RESTful APIは、以下の6つの基本原則に基づいて構築されます：

  1. クライアント・サーバーアーキテクチャ：クライアントとサーバーが独立して動作し、クライアントがサーバーからリソースを取得します。
  2. ステートレス性：サーバーは各リクエストを独立したものとして処理し、リクエスト間で状態を保持しません。
  3. キャッシュ可能性：レスポンスはキャッシュできるように設計され、効率的なデータの再利用が可能です。
  4. 統一インターフェース：すべてのリソースは一貫したインターフェースでアクセスされるべきです。
  5. 階層構造のシステム：クライアントは、サーバーの階層を通じてリソースにアクセスしますが、各階層が別々に扱われます。
  6. コードオンデマンド（任意）：必要に応じて、サーバーはクライアントに実行可能なコードを送信することができます。

なぜRESTが選ばれるのか


RESTはシンプルでありながら柔軟な設計を提供し、リソース指向のアプローチにより、さまざまなクライアント（モバイルアプリ、ブラウザ、IoTデバイスなど）と簡単に連携できる点が特徴です。また、HTTPプロトコルをそのまま使用するため、既存のWeb技術とスムーズに統合でき、スケーラブルでメンテナンス性が高いシステムを構築するのに適しています。

Spring Bootとは


Spring Bootは、Javaの人気フレームワークであるSpring Frameworkを基に構築されており、複雑な設定を自動化することで開発者の負担を軽減し、迅速な開発をサポートするフレームワークです。従来のJava開発では、各種設定や依存関係の管理に多くの時間が費やされましたが、Spring Bootは「設定より規約」というアプローチでこれらを簡略化します。

Spring Bootの特徴

  1. 自動構成：Spring Bootは、多くの一般的な設定を自動的に行うため、設定ファイルの作成や複雑な設定が不要です。
  2. スタンドアロンアプリケーション：Spring Bootで作成されたアプリケーションは、組み込みのTomcatサーバーなどを利用して、単独で実行可能なJARファイルとしてパッケージ化されます。
  3. 依存関係の管理：Spring BootはMavenやGradleを使用し、プロジェクトで必要な依存関係を簡単に管理できます。Spring Initializrなどのツールを使用することで、プロジェクトに必要なライブラリを迅速に導入可能です。
  4. マイクロサービスのサポート：Spring Bootは軽量であり、マイクロサービスアーキテクチャにも適しているため、柔軟なシステム設計が可能です。

Spring BootがAPI開発で選ばれる理由


Spring Bootは、RESTful APIの開発において特に強力なツールです。理由として、以下が挙げられます：

  • シンプルな開発プロセス：自動構成と組み込みサーバーにより、最小限の設定で迅速にAPIを構築できます。
  • 高い拡張性：Spring Frameworkの強力なエコシステムにより、セキュリティ、データベース接続、バッチ処理など、あらゆる機能を容易に統合できます。
  • 大規模なコミュニティとサポート：Spring Bootは広く使用されており、ドキュメントやサポートも充実しています。そのため、問題解決が容易で、安定した開発が可能です。

開発環境の準備


Spring BootでRESTful APIを開発するためには、いくつかの基本的なツールや環境を設定する必要があります。ここでは、必要な開発環境を整える手順について説明します。

1. Java開発キット（JDK）のインストール


Spring BootはJavaで構築されているため、まずJDKをインストールする必要があります。最新バージョンのJDKは、公式のOracleまたはOpenJDKサイトからダウンロード可能です。バージョンはSpring Bootの推奨バージョンに合わせ、通常はJava 11以上が推奨されます。

JDKのインストール手順（Windows/Mac/Linux）

  1. Oracleの公式サイトにアクセスし、最新のJDKをダウンロード。
  2. インストーラを実行して、画面の指示に従いインストール。
  3. コマンドラインまたはターミナルでjava -versionを入力し、インストールが成功したか確認。

2. IDE（統合開発環境）のインストール


Spring Bootプロジェクトの開発には、効率的にコーディングできる統合開発環境（IDE）が不可欠です。以下のIDEがよく使用されます：

  • IntelliJ IDEA：Spring Bootと親和性が高く、公式のサポートも充実しています。
  • Eclipse：プラグインを利用してSpring Bootプロジェクトを簡単に管理可能。
  • Visual Studio Code：軽量で、拡張機能を追加することでSpring Boot開発にも対応可能。

IntelliJ IDEAのインストール手順

  1. IntelliJの公式サイトからCommunity Edition（無料版）をダウンロード。
  2. インストーラを実行し、指示に従ってインストール。
  3. Spring Bootのプラグインが標準で含まれているので、設定は不要。

3. MavenまたはGradleの設定


Spring Bootの依存関係を管理するために、MavenまたはGradleを使用します。Mavenは特にSpringプロジェクトでよく使われるツールです。これらのツールを使用して、必要なライブラリやフレームワークを自動的に取得できます。

Mavenのインストール手順

  1. Apache Mavenの公式サイトから最新バージョンをダウンロード。
  2. ダウンロードしたファイルを解凍し、環境変数にパスを設定。
  3. コマンドラインでmvn -versionを入力し、インストールが成功したか確認。

4. Spring Initializrの使用


Spring Bootプロジェクトを簡単に作成するには、Spring Initializrを使用します。これは、Webベースのツールで、必要な依存関係を選択してプロジェクトの雛形を生成します。

Spring Initializrの使用手順

  1. Spring Initializrにアクセス。
  2. ProjectでMavenを選択し、LanguageでJavaを選択。
  3. Spring Bootのバージョンを選び、依存関係に「Spring Web」を追加。
  4. 「Generate Project」をクリックして、プロジェクトファイルをダウンロード。
  5. ダウンロードしたプロジェクトをIDEで開きます。

これで、Spring BootでRESTful APIを開発するための基本的な環境が整います。次のステップでは、実際にSpring Bootプロジェクトを作成して、RESTエンドポイントを実装していきます。

初めてのSpring Bootプロジェクトの作成


Spring Bootを使ったRESTful APIの開発を始めるために、まずは基本的なプロジェクトを作成します。このセクションでは、Spring Initializrを使用して最初のSpring Bootプロジェクトを構築する手順を説明します。Spring Initializrは、依存関係や設定を自動化し、効率的にプロジェクトをスタートできる便利なツールです。

Spring Initializrを使用したプロジェクト作成


Spring Initializrは、Webベースで簡単にプロジェクトを生成できるツールです。以下の手順で、Spring Bootを使ったプロジェクトを作成します。

プロジェクト作成手順

  1. Spring Initializrにアクセス：https://start.spring.io。
  2. Project：Maven Projectを選択（Mavenを使わない場合はGradleも選択可能）。
  3. Language：Javaを選択します。
  4. Spring Boot Version：安定した最新のバージョンを選択（通常、デフォルトで設定されています）。
  5. Project Metadataを設定します。
  • Group：プロジェクトのグループID（例：com.example）。
  • Artifact：プロジェクト名（例：restapi-demo）。
  • Name：プロジェクトの名前。
  • Description：プロジェクトの簡単な説明を入力。
  • Package：com.example.restapiのように設定します。
  1. Dependencies：Add Dependenciesボタンをクリックし、必要な依存関係を追加します。
  • Spring Web：RESTful APIを開発するために必要なWeb関連のライブラリ。
  1. すべての設定が完了したら、画面右下のGenerateボタンをクリックしてプロジェクトをダウンロードします。

プロジェクトのインポート


Spring Initializrで生成されたプロジェクトを、IDEにインポートして開発を開始します。ここではIntelliJ IDEAを使用したインポート手順を説明します。

IntelliJ IDEAでのインポート手順

  1. IntelliJ IDEAを起動し、File > Openを選択します。
  2. ダウンロードしたプロジェクトのディレクトリを選択し、Openをクリック。
  3. Mavenプロジェクトの場合、自動的に依存関係が解決され、プロジェクトがセットアップされます（必要に応じてインターネットに接続して依存関係をダウンロード）。

Spring Bootアプリケーションの起動


プロジェクトがインポートできたら、Spring Bootアプリケーションを起動します。Spring Bootのメインクラスには、@SpringBootApplicationアノテーションが付与されており、このクラスがエントリーポイントとなります。

アプリケーションの起動手順

  1. プロジェクト内のsrc/main/javaフォルダに移動し、メインクラス（通常DemoApplication.java）を探します。
  2. クラスファイルを開き、クラス名の横にある「Run」ボタンをクリックします。これでアプリケーションが実行され、組み込みのTomcatサーバーが起動します。
  3. ブラウザでhttp://localhost:8080にアクセスし、Spring Bootが正常に動作していることを確認します。

これで、Spring Bootの基本プロジェクトが作成され、ローカルサーバー上で動作する準備が整いました。次のステップでは、実際にRESTful APIのエンドポイントを作成していきます。

RESTful APIの基本エンドポイントの作成


Spring Bootを使用して、RESTful APIの基本的なエンドポイントを作成していきます。ここでは、HTTPの主要なメソッドであるGET、POST、PUT、DELETEを使って、データの取得、作成、更新、削除を行うエンドポイントを実装する方法を説明します。

コントローラーの作成


Spring BootでRESTful APIのエンドポイントを作成する際は、コントローラークラスを作成して、リクエストを処理します。コントローラーには@RestControllerアノテーションを付け、各エンドポイントに対応するメソッドを定義します。

サンプルコントローラーの作成


以下のような基本的なコントローラークラスを作成します。このクラスでは、シンプルな「Todo」リソースを扱います。

@RestController
@RequestMapping("/api/todos")
public class TodoController {

    private List<Todo> todos = new ArrayList<>();

    // GETリクエスト: 全てのTodoを取得
    @GetMapping
    public List<Todo> getAllTodos() {
        return todos;
    }

    // GETリクエスト: IDに基づいて特定のTodoを取得
    @GetMapping("/{id}")
    public Todo getTodoById(@PathVariable int id) {
        return todos.stream().filter(todo -> todo.getId() == id).findFirst().orElse(null);
    }

    // POSTリクエスト: 新しいTodoを作成
    @PostMapping
    public Todo createTodo(@RequestBody Todo todo) {
        todo.setId(todos.size() + 1);
        todos.add(todo);
        return todo;
    }

    // PUTリクエスト: IDに基づいてTodoを更新
    @PutMapping("/{id}")
    public Todo updateTodo(@PathVariable int id, @RequestBody Todo updatedTodo) {
        Todo existingTodo = todos.stream().filter(todo -> todo.getId() == id).findFirst().orElse(null);
        if (existingTodo != null) {
            existingTodo.setName(updatedTodo.getName());
            existingTodo.setCompleted(updatedTodo.isCompleted());
        }
        return existingTodo;
    }

    // DELETEリクエスト: IDに基づいてTodoを削除
    @DeleteMapping("/{id}")
    public String deleteTodoById(@PathVariable int id) {
        todos.removeIf(todo -> todo.getId() == id);
        return "Todo with ID " + id + " has been deleted.";
    }
}

GETメソッド


GETリクエストは、サーバーからデータを取得するために使用されます。この例では、@GetMappingアノテーションを使い、以下の2つのGETエンドポイントを定義しています：

  • /api/todos：すべてのTodoリストを取得する。
  • /api/todos/{id}：指定したIDのTodoを取得する。

POSTメソッド


POSTリクエストは、サーバーに新しいリソースを作成するために使用されます。@PostMappingアノテーションを使い、新しいTodoを作成するエンドポイントを定義します。リクエストボディに送信されたデータを@RequestBodyで受け取り、リストに追加します。

PUTメソッド


PUTリクエストは、既存のリソースを更新するために使用されます。@PutMappingアノテーションを使って、特定のTodoを更新するエンドポイントを定義します。IDで指定されたリソースを検索し、更新されたデータに置き換えます。

DELETEメソッド


DELETEリクエストは、サーバーからリソースを削除するために使用されます。@DeleteMappingアノテーションを使い、指定したIDのTodoを削除するエンドポイントを定義します。

実行とテスト


これらのエンドポイントを作成した後、Spring Bootアプリケーションを起動して、ブラウザやPostmanなどのツールを使ってリクエストを送信し、動作を確認できます。例えば、以下のようなリクエストを送ることで、APIの動作をテストできます：

  • GET http://localhost:8080/api/todos
  • POST http://localhost:8080/api/todos（リクエストボディに新しいTodoデータを含める）
  • PUT http://localhost:8080/api/todos/{id}（既存のTodoデータを更新）
  • DELETE http://localhost:8080/api/todos/{id}（Todoを削除）

これで、Spring Bootを使った基本的なRESTful APIのエンドポイントが完成しました。次のステップでは、データベースとの連携を行い、より実用的なAPIを作成していきます。

データベース接続とエンティティの定義


RESTful APIを本格的に構築するには、データベースを使ってリソースを永続化することが重要です。Spring Bootでは、データベースとのやり取りを簡単に行うために、JPA（Java Persistence API）を利用します。このセクションでは、データベース接続の設定とエンティティの定義方法について説明します。

1. データベースの設定


まず、Spring Bootアプリケーションをデータベースに接続するための設定を行います。Spring Bootは自動的に多くのデータベースをサポートしており、一般的にはMySQLやH2などのデータベースが使われます。今回は、H2（インメモリデータベース）を使った例を紹介します。

依存関係の追加


Spring BootプロジェクトにH2データベースとJPAを追加するため、pom.xmlに以下の依存関係を追加します。

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

データベースの設定（`application.properties`）


次に、アプリケーションの設定ファイルでデータベース接続を構成します。src/main/resources/application.propertiesに以下の設定を追加します。

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

これで、H2データベースがSpring Bootアプリケーションに組み込まれ、開発環境で使えるようになります。http://localhost:8080/h2-consoleでH2コンソールにもアクセス可能です。

2. エンティティの定義


データベース上で管理するリソースをエンティティとして定義します。エンティティは、JPAを使ってデータベースのテーブルとマッピングされるJavaクラスです。ここでは、Todoエンティティを例にして説明します。

Todoエンティティの作成


以下のようにTodoクラスを作成し、@Entityアノテーションを付けます。このクラスがデータベース上のテーブルとしてマッピングされます。

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Todo {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private boolean completed;

    // コンストラクタ、ゲッター、セッター
    public Todo() {}

    public Todo(String name, boolean completed) {
        this.name = name;
        this.completed = completed;
    }

    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 boolean isCompleted() {
        return completed;
    }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }
}

@Idアノテーションは、このフィールドがテーブルのプライマリキーであることを示します。また、@GeneratedValueアノテーションでIDが自動生成されることを指定しています。

3. リポジトリの作成


エンティティとデータベースのやり取りを管理するために、JPAリポジトリを作成します。Spring Data JPAを使用することで、データベース操作をシンプルに記述できます。Todoエンティティのリポジトリインターフェースを作成します。

TodoRepositoryの作成


以下のように、JpaRepositoryを拡張したリポジトリインターフェースを作成します。これにより、基本的なCRUD操作を自動的に提供することができます。

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

public interface TodoRepository extends JpaRepository<Todo, Long> {
}

このTodoRepositoryインターフェースをコントローラーで使用することで、データベース操作を簡単に行うことができます。

4. コントローラーでのデータベース操作


作成したTodoRepositoryをコントローラーに注入し、エンドポイントでデータベースにアクセスできるようにします。

TodoControllerでのデータベース利用


以下のように、リポジトリを使ってデータを操作するAPIを作成します。

@RestController
@RequestMapping("/api/todos")
public class TodoController {

    private final TodoRepository todoRepository;

    public TodoController(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }

    // GETリクエスト: 全てのTodoを取得
    @GetMapping
    public List<Todo> getAllTodos() {
        return todoRepository.findAll();
    }

    // POSTリクエスト: 新しいTodoを作成
    @PostMapping
    public Todo createTodo(@RequestBody Todo todo) {
        return todoRepository.save(todo);
    }

    // PUTリクエスト: Todoを更新
    @PutMapping("/{id}")
    public Todo updateTodo(@PathVariable Long id, @RequestBody Todo updatedTodo) {
        return todoRepository.findById(id)
            .map(todo -> {
                todo.setName(updatedTodo.getName());
                todo.setCompleted(updatedTodo.isCompleted());
                return todoRepository.save(todo);
            }).orElseThrow(() -> new ResourceNotFoundException("Todo not found"));
    }

    // DELETEリクエスト: Todoを削除
    @DeleteMapping("/{id}")
    public void deleteTodoById(@PathVariable Long id) {
        todoRepository.deleteById(id);
    }
}

このように、JPAリポジトリを利用することで、データベースと連携したRESTful APIの実装が簡単に行えます。次のステップでは、エラーハンドリングやデータのバリデーションについて解説します。

エラーハンドリングとバリデーション


RESTful APIを開発する際、クライアントからのリクエストデータが不正であった場合や、処理中にエラーが発生した場合に適切なレスポンスを返すことが重要です。Spring Bootでは、エラーハンドリングとバリデーションを簡単に実装できます。このセクションでは、エラーハンドリングとリクエストデータのバリデーション方法を説明します。

1. エラーハンドリング


Spring Bootでは、@ExceptionHandlerアノテーションを使用して、特定の例外が発生した際にカスタムレスポンスを返すエラーハンドラーを定義することができます。これにより、APIが一貫したエラーレスポンスを返すことが可能になります。

カスタム例外クラスの作成


まず、リソースが見つからなかった場合に使用するカスタム例外クラスを作成します。

public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

コントローラーで例外をスロー


データが見つからない場合に、このカスタム例外をスローするようにコントローラーで設定します。

@PutMapping("/{id}")
public Todo updateTodo(@PathVariable Long id, @RequestBody Todo updatedTodo) {
    return todoRepository.findById(id)
        .map(todo -> {
            todo.setName(updatedTodo.getName());
            todo.setCompleted(updatedTodo.isCompleted());
            return todoRepository.save(todo);
        }).orElseThrow(() -> new ResourceNotFoundException("Todo not found with id " + id));
}

例外を処理するエラーハンドラーの作成


次に、例外がスローされた際に、適切なレスポンスを返すエラーハンドラーを作成します。ここでは、@ControllerAdviceを使用してグローバルなエラーハンドラーを設定します。

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ResponseEntity<String> handleResourceNotFoundException(ResourceNotFoundException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
    }
}

これにより、ResourceNotFoundExceptionがスローされた場合、クライアントに404エラーとエラーメッセージが返されます。

2. データのバリデーション


Spring Bootでは、javax.validationパッケージを使用して、リクエストデータのバリデーションを簡単に行えます。@Validアノテーションを使用することで、リクエストボディに対する自動バリデーションが可能です。

バリデーションルールの定義


エンティティクラスにバリデーションアノテーションを追加して、データの制約を定義します。以下は、Todoクラスにバリデーションを追加した例です。

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;

@Entity
public class Todo {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank(message = "Name is mandatory")
    @Size(max = 100, message = "Name should not exceed 100 characters")
    private String name;

    private boolean completed;

    // コンストラクタ、ゲッター、セッター
}

@NotBlankはフィールドが空でないことを保証し、@Sizeは文字列の長さを制限します。

コントローラーでバリデーションを適用


次に、コントローラーで@Validアノテーションを使い、リクエストデータのバリデーションを適用します。バリデーションに失敗した場合、自動的に400 Bad Requestレスポンスが返されます。

@PostMapping
public ResponseEntity<Todo> createTodo(@Valid @RequestBody Todo todo) {
    Todo savedTodo = todoRepository.save(todo);
    return ResponseEntity.ok(savedTodo);
}

バリデーションエラーハンドリングのカスタマイズ


バリデーションエラーのレスポンスをカスタマイズしたい場合は、MethodArgumentNotValidExceptionをキャッチしてカスタムレスポンスを返すことができます。

@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<Map<String, String>> handleValidationExceptions(MethodArgumentNotValidException ex) {
    Map<String, String> errors = new HashMap<>();
    ex.getBindingResult().getFieldErrors().forEach(error -> 
        errors.put(error.getField(), error.getDefaultMessage()));
    return new ResponseEntity<>(errors, HttpStatus.BAD_REQUEST);
}

これにより、バリデーションエラーが発生した際、エラーの詳細なフィールド名とメッセージが含まれたJSONレスポンスが返されます。

3. エラーハンドリングとバリデーションのまとめ

  • Spring Bootのエラーハンドリングは、@ExceptionHandlerと@ControllerAdviceを使うことで、シンプルに一貫したエラーレスポンスを提供できます。
  • データのバリデーションは、@ValidアノテーションとJPAのバリデーションアノテーションを使用して、リクエストデータの品質を保証します。
  • バリデーションエラーのカスタムレスポンスを作成することで、APIの使用者にわかりやすいエラーメッセージを提供することができます。

これで、エラーハンドリングとバリデーションの基本的な実装が完了しました。次のステップでは、セキュリティ対策について解説します。

セキュリティ対策


RESTful APIを公開する際、適切なセキュリティ対策を講じることが非常に重要です。Spring Bootでは、Spring Securityを使用して、APIの認証と認可を簡単に実装できます。このセクションでは、基本的なセキュリティ設定から、JWT（JSON Web Token）を使用したトークンベースの認証方法までを解説します。

1. Spring Securityの導入


Spring Bootプロジェクトにセキュリティ機能を追加するため、spring-boot-starter-security依存関係を追加します。これにより、基本的なセキュリティ機能がプロジェクトに組み込まれます。

依存関係の追加


pom.xmlに以下の依存関係を追加します。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

これで、Spring SecurityとJWTライブラリがプロジェクトに追加されます。

2. 基本認証の設定


Spring Bootでは、Spring Securityを導入するとデフォルトですべてのエンドポイントが認証を要求するようになります。デフォルトの設定ではBasic認証が有効になっており、簡単なユーザー認証を行うことができます。Spring Securityの設定は、WebSecurityConfigurerAdapterクラスを拡張することでカスタマイズ可能です。

セキュリティ設定クラスの作成


以下のように、セキュリティ設定クラスを作成してエンドポイントのアクセス制限を設定します。

import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()  // CSRFを無効化（APIの場合は無効化することが多い）
            .authorizeRequests()
            .antMatchers("/api/todos/**").authenticated()  // 認証が必要なエンドポイント
            .anyRequest().permitAll()  // その他は認証不要
            .and()
            .httpBasic();  // Basic認証を使用
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

この設定では、/api/todosにアクセスするためには認証が必要となり、その他のエンドポイントは自由にアクセスできます。また、httpBasic()を使用してBasic認証を有効にしています。

3. JWT（JSON Web Token）による認証


よりセキュリティが高く、スケーラブルなAPIを構築するために、JWTを使ったトークンベースの認証を導入することが一般的です。JWTは、ユーザーがログイン時に発行され、その後のリクエストでトークンを使用して認証を行います。

JWTの生成と検証


JWTトークンを生成するために、認証情報に基づいてトークンを発行し、APIリクエストにトークンを含めて認証を行います。

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

public class JwtTokenUtil {

    private static final String SECRET_KEY = "mySecretKey";

    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 86400000))  // 1日後に期限切れ
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }

    public String getUsernameFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }
}

このクラスでは、トークンの生成と、トークンからユーザー名を取得するメソッドを定義しています。

JWTフィルターの作成


JWTトークンを各リクエストから検証するためのフィルターを作成します。このフィルターは、リクエストに含まれるトークンを確認し、正当なものであれば認証を通します。

import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtRequestFilter extends OncePerRequestFilter {

    private final JwtTokenUtil jwtTokenUtil;

    public JwtRequestFilter(JwtTokenUtil jwtTokenUtil) {
        this.jwtTokenUtil = jwtTokenUtil;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        String authorizationHeader = request.getHeader("Authorization");

        String username = null;
        String jwt = null;

        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtTokenUtil.getUsernameFromToken(jwt);
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            // 認証処理を行う
        }

        chain.doFilter(request, response);
    }
}

このフィルターは、HTTPリクエストのヘッダーにあるJWTを確認し、トークンが有効であればユーザーを認証します。

セキュリティ設定でフィルターを適用


最後に、JWTフィルターをセキュリティ設定に適用します。

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final JwtRequestFilter jwtRequestFilter;

    public SecurityConfig(JwtRequestFilter jwtRequestFilter) {
        this.jwtRequestFilter = jwtRequestFilter;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests().anyRequest().authenticated()
            .and()
            .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

この設定により、JWTフィルターがリクエストごとに適用され、トークンの認証が行われます。

4. まとめ


Spring Bootでは、Spring Securityを使用して簡単にセキュリティ対策を施すことができます。Basic認証やJWTを使ったトークンベースの認証により、APIの保護が強化され、ユーザー認証と認可を効率的に行うことが可能です。セキュリティ設定をしっかりと構築することで、APIの安全性と信頼性が向上します。次のステップでは、APIドキュメントの自動生成について説明します。

Swaggerを使ったAPIドキュメントの生成


RESTful APIを開発する際、APIの使い方を開発者や利用者に明確に伝えるためにドキュメントが必要です。Spring Bootでは、Swaggerを使用してAPIのドキュメントを自動的に生成できます。Swaggerは、APIのエンドポイントやリクエスト形式、レスポンス形式などをわかりやすく表示するツールで、インタラクティブなUIを提供します。このセクションでは、Swaggerをプロジェクトに導入し、APIドキュメントを自動生成する方法を説明します。

1. Swaggerの依存関係の追加


SwaggerをSpring Bootプロジェクトに追加するために、springdoc-openapi-uiというライブラリを使用します。これをpom.xmlに追加します。

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-ui</artifactId>
    <version>1.5.13</version>
</dependency>

この依存関係を追加すると、Spring BootでSwagger UIを利用できるようになります。

2. Swaggerの設定


Swaggerは、プロジェクトに追加するだけで自動的にAPIエンドポイントをドキュメント化しますが、より詳細な設定を行いたい場合は、専用の設定クラスを作成することも可能です。

ただし、基本的な使用では設定クラスは不要で、Swaggerが自動的にアプリケーションのエンドポイントを検出し、ドキュメントを生成します。

Swagger UIへのアクセス


Spring Bootアプリケーションを起動した後、ブラウザでhttp://localhost:8080/swagger-ui.htmlにアクセスすると、Swagger UIの画面にアクセスできます。ここには、APIの各エンドポイントやその詳細が自動的に表示されます。

Swagger UIの画面では、以下の情報が提供されます：

  • エンドポイントの一覧：定義されているすべてのAPIエンドポイントを一覧で表示。
  • エンドポイントの詳細：各エンドポイントのリクエストメソッド（GET、POST、PUT、DELETEなど）、リクエストパラメータ、レスポンス形式。
  • インタラクティブな操作：APIリクエストを直接Swagger UIから送信し、レスポンスを確認できる機能。

3. APIエンドポイントの自動ドキュメント化


Swaggerは、Spring Bootのコントローラーに定義されたエンドポイントを自動的にドキュメント化します。例えば、以下のようなTodoControllerのエンドポイントがSwagger UIで表示されます。

@RestController
@RequestMapping("/api/todos")
public class TodoController {

    @GetMapping
    public List<Todo> getAllTodos() {
        // 全てのTodoを取得
    }

    @PostMapping
    public Todo createTodo(@RequestBody Todo todo) {
        // Todoを作成
    }

    @PutMapping("/{id}")
    public Todo updateTodo(@PathVariable Long id, @RequestBody Todo todo) {
        // Todoを更新
    }

    @DeleteMapping("/{id}")
    public void deleteTodoById(@PathVariable Long id) {
        // Todoを削除
    }
}

これらのエンドポイントがSwaggerによってドキュメント化され、エンドポイントの詳細情報が表示されるようになります。リクエストの形式やレスポンスのサンプルも自動生成され、非常に見やすくなります。

4. カスタムドキュメントの追加


Swaggerを利用してAPIの詳細な説明を加えるために、コントローラーメソッドにアノテーションを追加してカスタムドキュメントを作成することができます。@Operationや@ApiResponseなどのアノテーションを使って、APIの説明をより詳細に記述できます。

例：カスタムドキュメントの追加

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;

@RestController
@RequestMapping("/api/todos")
public class TodoController {

    @Operation(summary = "Get all todos", description = "Returns a list of all todos")
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "Found the todos"),
        @ApiResponse(responseCode = "404", description = "No todos found")
    })
    @GetMapping
    public List<Todo> getAllTodos() {
        return todoRepository.findAll();
    }

    @Operation(summary = "Create a new todo", description = "Creates a new todo item")
    @PostMapping
    public Todo createTodo(@RequestBody Todo todo) {
        return todoRepository.save(todo);
    }
}

このようにアノテーションを使って、各エンドポイントの説明やレスポンスコードなどを詳しく記述できます。

5. まとめ


Swaggerを利用することで、RESTful APIのドキュメントを自動的に生成し、簡単に利用者へ提供することができます。これにより、開発者や利用者はAPIの使用方法を直感的に理解でき、エンドポイントのテストも容易になります。Swagger UIは、APIをインタラクティブに操作できる強力なツールとして、開発プロセスを効率化し、保守性を向上させます。次のステップでは、APIのテストについて解説します。

テストの実装


RESTful APIを開発する際には、適切なテストを行うことで、APIの正確性や信頼性を確保することが重要です。Spring Bootでは、JUnitを使用した単体テストや統合テストを簡単に実装できます。このセクションでは、RESTful APIのテストをどのように実装するかを解説します。

1. テスト環境の設定


Spring Bootには、テストフレームワークとしてJUnitが標準で組み込まれています。テストを効率的に実行するため、spring-boot-starter-test依存関係が必要です。プロジェクトにこの依存関係が含まれていない場合は、pom.xmlに追加します。

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

この依存関係には、JUnitやMockito、Spring Testなど、テストに必要なツールが含まれています。

2. コントローラーの単体テスト


まず、コントローラーの単体テストを実装します。単体テストでは、Springのコンテキスト全体を起動せず、個々のコンポーネントのみをテストします。@WebMvcTestアノテーションを使用して、コントローラーをテストします。

TodoControllerのテストの作成


以下は、TodoControllerのエンドポイントに対する単体テストの例です。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(TodoController.class)
public class TodoControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGetAllTodos() throws Exception {
        mockMvc.perform(get("/api/todos")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.length()").value(0));  // 初期状態では空のリスト
    }

    @Test
    public void testCreateTodo() throws Exception {
        String todoJson = "{\"name\":\"New Todo\",\"completed\":false}";

        mockMvc.perform(post("/api/todos")
                .content(todoJson)
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("New Todo"))
                .andExpect(jsonPath("$.completed").value(false));
    }
}

このテストでは、MockMvcを使用してコントローラーのエンドポイントに対してリクエストを送り、レスポンスの内容を検証しています。get("/api/todos")では、全てのTodoを取得し、ステータスコード200（OK）を確認します。また、post("/api/todos")では、新しいTodoを作成し、その結果を検証しています。

3. リポジトリの単体テスト


次に、リポジトリの単体テストを行います。データベースとのやり取りが正しく行われているかを確認するために、インメモリデータベースを使ってテストを実施します。

TodoRepositoryのテストの作成


以下は、TodoRepositoryの単体テストの例です。

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;

import java.util.List;

@DataJpaTest
public class TodoRepositoryTest {

    @Autowired
    private TodoRepository todoRepository;

    @Test
    public void testSaveAndFindAll() {
        // 新しいTodoを作成
        Todo todo = new Todo("Test Todo", false);
        todoRepository.save(todo);

        // 全てのTodoを取得
        List<Todo> todos = todoRepository.findAll();
        assertThat(todos).hasSize(1);
        assertThat(todos.get(0).getName()).isEqualTo("Test Todo");
    }

    @Test
    public void testDelete() {
        // 新しいTodoを作成
        Todo todo = new Todo("Test Todo", false);
        todoRepository.save(todo);

        // Todoを削除
        todoRepository.delete(todo);

        // 全てのTodoを取得
        List<Todo> todos = todoRepository.findAll();
        assertThat(todos).isEmpty();
    }
}

このテストでは、JPAリポジトリの基本的な動作（保存、取得、削除）を検証しています。@DataJpaTestを使うことで、テスト中にインメモリデータベースが自動的に使用されます。

4. 統合テスト


統合テストでは、アプリケーション全体を通しての動作確認を行います。Springのコンテキスト全体を起動し、複数のコンポーネント間の相互作用を検証します。@SpringBootTestを使って、アプリケーションの実際の動作をテストします。

統合テストの作成


以下は、TodoControllerの統合テストの例です。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@SpringBootTest
public class TodoControllerIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGetAllTodos() throws Exception {
        mockMvc.perform(get("/api/todos")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.length()").value(0));
    }
}

このテストは、アプリケーション全体を起動し、実際の動作を検証します。@SpringBootTestを使用することで、全てのSpringコンポーネントが起動され、実際のAPIの動作を確認できます。

5. まとめ


Spring Bootでは、JUnitを使ってRESTful APIのテストを簡単に実装できます。単体テストでは、個々のコンポーネントの正確性を確認し、統合テストでは、アプリケーション全体の動作を検証します。テストを充実させることで、APIの信頼性が向上し、リリース後の問題を未然に防ぐことが可能です。次のステップでは、APIのデプロイ方法について解説します。

APIのデプロイ方法


Spring Bootで開発したRESTful APIをローカル環境で動作させただけでなく、実際の本番環境にデプロイする必要があります。Spring Bootは、スタンドアロンのJARファイルとしてアプリケーションをパッケージ化でき、さまざまな環境に簡単にデプロイできます。このセクションでは、Spring Bootアプリケーションのデプロイ方法を解説します。

1. JARファイルの作成


Spring Bootアプリケーションをデプロイする前に、まずJARファイルとしてパッケージ化します。MavenまたはGradleを使用してプロジェクトをビルドし、実行可能なJARファイルを生成します。

Mavenでのビルド手順


プロジェクトのルートディレクトリで以下のコマンドを実行し、JARファイルを作成します。

mvn clean package

このコマンドを実行すると、targetディレクトリに<project-name>.jarという名前の実行可能なJARファイルが生成されます。

2. クラウド環境へのデプロイ


Spring Bootアプリケーションは、さまざまなクラウドプラットフォームにデプロイ可能です。ここでは、代表的なクラウドサービスであるHerokuとAWS Elastic Beanstalkへのデプロイ方法を紹介します。

Herokuへのデプロイ


Herokuは、シンプルにアプリケーションをクラウドにデプロイできるプラットフォームです。以下は、HerokuにSpring Bootアプリケーションをデプロイする手順です。

  1. Heroku CLIのインストール：Herokuの公式サイトからCLIをインストールします。
  2. Herokuにログイン：以下のコマンドでHerokuにログインします。
   heroku login
  1. Gitリポジトリの初期化：プロジェクトディレクトリでGitリポジトリを初期化します。
   git init
  1. Herokuアプリケーションの作成：
   heroku create
  1. コードのデプロイ：
   git add .
   git commit -m "initial commit"
   git push heroku master

これで、アプリケーションがHerokuにデプロイされ、HerokuのURLからアクセス可能になります。

AWS Elastic Beanstalkへのデプロイ


AWS Elastic Beanstalkは、AWS上で簡単にアプリケーションをデプロイできるサービスです。

  1. AWS CLIのインストール：AWS CLIをインストールし、AWSアカウントで設定を行います。
  2. Elastic Beanstalkの初期化：プロジェクトディレクトリで以下のコマンドを実行し、Elastic Beanstalkの環境を設定します。
   eb init
  1. Elastic Beanstalk環境の作成：
   eb create
  1. アプリケーションのデプロイ：
   eb deploy

これで、AWS Elastic Beanstalk上にSpring Bootアプリケーションがデプロイされ、アクセス可能になります。

3. Dockerを使ったデプロイ


Spring BootアプリケーションをDockerコンテナにパッケージ化してデプロイする方法も広く利用されています。Dockerを使用することで、どの環境でも一貫してアプリケーションを動作させることができます。

Dockerfileの作成


以下のようにDockerfileを作成し、Spring BootアプリケーションをDockerイメージとしてビルドします。

# ベースイメージの指定
FROM openjdk:11-jre-slim

# JARファイルをコンテナにコピー
COPY target/myapp.jar /app.jar

# アプリケーションの実行
ENTRYPOINT ["java", "-jar", "/app.jar"]

Dockerイメージのビルドと実行


以下のコマンドを実行して、Dockerイメージをビルドし、コンテナとして実行します。

docker build -t myapp .
docker run -p 8080:8080 myapp

これで、Dockerコンテナ内でSpring Bootアプリケーションが動作し、http://localhost:8080でアクセスできるようになります。

4. まとめ


Spring Bootアプリケーションは、さまざまな環境に柔軟にデプロイできます。HerokuやAWS Elastic Beanstalk、Dockerを利用することで、迅速に本番環境へアプリケーションを展開することが可能です。デプロイの選択肢は多岐にわたり、プロジェクトやチームの要件に応じて最適な方法を選びましょう。

まとめ


本記事では、Spring Bootを使ったRESTful APIの開発方法について、基本的なエンドポイントの作成から、データベース接続、セキュリティ対策、Swaggerを使ったドキュメント生成、APIのテスト、そして本番環境へのデプロイまで、幅広く解説しました。Spring Bootは、シンプルかつ強力なフレームワークで、効率的にAPIを構築し、拡張性のあるアプリケーションを開発できます。適切なセキュリティやテストを行い、安定したAPIを構築することで、信頼性の高いサービスを提供できるようになります。

Java
java Web開発 REST API Spring Boot

コメント

コメントする

目次
  1. RESTful APIの基本概念
    1. RESTの6つの原則
    2. なぜRESTが選ばれるのか
  2. Spring Bootとは
    1. Spring Bootの特徴
    2. Spring BootがAPI開発で選ばれる理由
  3. 開発環境の準備
    1. 1. Java開発キット（JDK）のインストール
    2. 2. IDE（統合開発環境）のインストール
    3. 3. MavenまたはGradleの設定
    4. 4. Spring Initializrの使用
  4. 初めてのSpring Bootプロジェクトの作成
    1. Spring Initializrを使用したプロジェクト作成
    2. プロジェクトのインポート
    3. Spring Bootアプリケーションの起動
  5. RESTful APIの基本エンドポイントの作成
    1. コントローラーの作成
    2. GETメソッド
    3. POSTメソッド
    4. PUTメソッド
    5. DELETEメソッド
    6. 実行とテスト
  6. データベース接続とエンティティの定義
    1. 1. データベースの設定
    2. 2. エンティティの定義
    3. 3. リポジトリの作成
    4. 4. コントローラーでのデータベース操作
  7. エラーハンドリングとバリデーション
    1. 1. エラーハンドリング
    2. 2. データのバリデーション
    3. 3. エラーハンドリングとバリデーションのまとめ
  8. セキュリティ対策
    1. 1. Spring Securityの導入
    2. 2. 基本認証の設定
    3. 3. JWT（JSON Web Token）による認証
    4. 4. まとめ
  9. Swaggerを使ったAPIドキュメントの生成
    1. 1. Swaggerの依存関係の追加
    2. 2. Swaggerの設定
    3. 3. APIエンドポイントの自動ドキュメント化
    4. 4. カスタムドキュメントの追加
    5. 5. まとめ
  10. テストの実装
    1. 1. テスト環境の設定
    2. 2. コントローラーの単体テスト
    3. 3. リポジトリの単体テスト
    4. 4. 統合テスト
    5. 5. まとめ
  11. APIのデプロイ方法
    1. 1. JARファイルの作成
    2. 2. クラウド環境へのデプロイ
    3. 3. Dockerを使ったデプロイ
    4. 4. まとめ
  12. まとめ