Java初心者のためのSpring Boot MVC入門ガイド

By /

はい、承知いたしました。
Java初心者のためのSpring Boot MVC入門ガイドを、約5000語の詳細な説明を含む記事として作成します。

Java初心者のためのSpring Boot MVC入門ガイド

はじめに

こんにちは！この記事は、「Javaの基本的な文法は学んだけれど、次に何をすればいいかわからない」「Webアプリケーション開発に挑戦してみたい」と考えているJava初心者のための、Spring Boot MVC入門ガイドです。

現代のWebアプリケーション開発において、Javaは依然として非常に強力な選択肢です。その中でも、Spring BootはJava開発の世界に革命をもたらしました。かつてSpring Frameworkは設定が複雑で学習コストが高いと言われていましたが、Spring Bootの登場により、誰でも迅速かつ簡単に、堅牢なWebアプリケーションを構築できるようになりました。

なぜSpring Bootなのか？

  • 驚くほどの簡単さ: Spring Bootは「設定より規約（Convention over Configuration）」という思想に基づいています。開発者が面倒な設定ファイルを書かなくても、一般的な規約に従うだけでアプリケーションが動作するように設計されています。
  • 組み込みサーバー: 従来、JavaでWebアプリケーションを動かすには、TomcatなどのWebサーバーを別途インストールし、そこにアプリケーションを配置（デプロイ）する必要がありました。Spring BootはTomcatなどのサーバーを内蔵しているため、特別な準備なしにアプリケーションを単体で実行できます。
  • 豊富なエコシステム: Spring Bootは、データベースアクセス、セキュリティ、テストなど、Webアプリケーション開発に必要なあらゆる機能を「スターター」と呼ばれる依存関係を追加するだけで簡単に導入できます。

この記事では、Spring BootのMVC（Model-View-Controller）パターンに焦点を当て、環境構築から始まり、簡単なWebアプリケーションを実際に手を動かしながら作成していくことで、その仕組みと楽しさを体験していただくことを目的としています。

さあ、一緒にSpring Bootの世界への第一歩を踏み出しましょう！

第1章: 環境構築

何事もまずは準備から。Webアプリケーション開発を始めるために必要なツールを揃えましょう。

必要なツール

  1. JDK (Java Development Kit): Javaプログラムをコンパイルし、実行するための基本的な開発キットです。この記事では、長期サポート（LTS）版である Java 17 を使用することを推奨します。まだインストールしていない場合は、Adoptium (旧AdoptOpenJDK)などからご自身のOSに合ったものをインストールしてください。インストール後、環境変数 JAVA_HOME の設定と、PATH に JAVA_HOME/bin を追加する作業を忘れずに行いましょう。

    コマンドプロンプトやターミナルで以下のコマンドを実行し、バージョン情報が表示されればOKです。
    bash
    java -version
    javac -version

  2. IDE (統合開発環境): コードを書くための高機能なエディタです。Java開発では IntelliJ IDEA が非常に人気があり、強力なコーディング支援機能を提供してくれます。無償で利用できる Community Edition で十分ですので、JetBrainsの公式サイトからダウンロードしてインストールしましょう。

  3. ビルドツール (Maven/Gradle): プロジェクトの依存関係（ライブラリ）の管理や、プロジェクトのビルド（実行可能な形式に変換すること）を自動化してくれるツールです。Spring BootではMavenかGradleのどちらかを選べますが、この記事では広く使われている Maven を使用します。Maven自体を個別にインストールする必要はありません。後述するSpring Initializrがプロジェクトに含めてくれますし、IntelliJ IDEAにも内蔵されています。

Spring Initializrを使ったプロジェクトの作成

Spring Bootの最大の魅力の一つが、プロジェクトの雛形を簡単に作成できる Spring Initializr という公式ツールです。Webサイトにアクセスして、必要な設定を選ぶだけでプロジェクトのzipファイルが手に入ります。

  1. start.spring.ioにアクセスします。

  2. プロジェクトの設定を選択します。

    • Project: Maven Project を選択します。
    • Language: Java を選択します。
    • Spring Boot: デフォルトで選択されている最新の安定版（SNAPSHOTやM1などが付いていないもの）で問題ありません。
    • Project Metadata:
      • Group: 会社や組織のドメインを逆にしたものが一般的です。例: com.example
      • Artifact: プロジェクト（アプリケーション）の名前です。例: gs-spring-boot-mvc
      • Name: Artifactと同じで構いません。
      • Description: プロジェクトの説明です。例: Getting Started with Spring Boot MVC
      • Package name: GroupとArtifactを組み合わせた、Javaのパッケージ名です。例: com.example.gsspringbootmvc
    • Packaging: Jar を選択します。これにより、アプリケーションを単独で実行可能なファイルとしてパッケージングできます。
    • Java: インストールしたJDKのバージョン（この記事では 17）を選択します。

  3. Dependencies（依存関係）を追加します。
    画面右側の「ADD DEPENDENCIES…」ボタンをクリックして、以下の3つを検索し、追加します。

    • Spring Web: Spring MVCを使い、Webアプリケーションを構築するための必須ライブラリです。組み込みのTomcatサーバーも含まれています。
    • Thymeleaf: テンプレートエンジンです。サーバーサイドで動的にHTMLを生成するために使用します。JavaのコードとHTMLデザインを綺麗に分離できます。
    • Spring Boot DevTools: 開発を便利にするためのツールです。コードを変更して保存すると自動的にアプリケーションが再起動するなど、開発効率を大幅に向上させてくれます。

  4. プロジェクトを生成します。
    すべての設定が終わったら、画面下部の「GENERATE」ボタンをクリックします。プロジェクトのzipファイル（例: gs-spring-boot-mvc.zip）がダウンロードされます。

  5. IDEでプロジェクトを開きます。

    • ダウンロードしたzipファイルを任意の場所に解凍します。
    • IntelliJ IDEAを起動し、「Open」を選択します。
    • 先ほど解凍したプロジェクトのフォルダを選択して開きます。
    • 初回はMavenが依存関係ライブラリをダウンロードするため、少し時間がかかります。右下のプログレスバーが完了するまで待ちましょう。

これで、開発の準備は完了です！

第2章: Spring Bootプロジェクトの構造

IDEでプロジェクトを開くと、多くのファイルやフォルダが自動的に生成されているのがわかります。ここでは、特に重要なものについて見ていきましょう。

gs-spring-boot-mvc
├── .mvn
├── mvnw
├── mvnw.cmd
├── pom.xml <-- Mavenの設定ファイル (最重要)
├── src
│ ├── main
│ │ ├── java
│ │ │ └── com
│ │ │ └── example
│ │ │ └── gsspringbootmvc
│ │ │ └── GsSpringBootMvcApplication.java <-- アプリケーションの起動クラス
│ │ └── resources
│ │ ├── application.properties <-- アプリケーションの設定ファイル
│ │ ├── static <-- CSS, JavaScript, 画像など静的ファイル
│ │ └── templates <-- HTMLテンプレートファイル (Thymeleaf用)
│ └── test
│ └── java
│ └── com
│ └── example
│ └── gsspringbootmvc
│ └── GsSpringBootMvcApplicationTests.java
└── target

  • pom.xml: Mavenのプロジェクト設定ファイルです。このプロジェクトがどのようなライブラリに依存しているか（Dependencies）、プロジェクトをどのようにビルドするか、といった情報がXML形式で記述されています。先ほどSpring Initializrで追加した「Spring Web」や「Thymeleaf」の情報もここに記載されています。

    xml
    <!-- pom.xml の一部 -->
    <dependencies>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
    </dependency>
    <!-- ... -->
    </dependencies>
    spring-boot-starter-* という名前の依存関係がSpring Bootのスターターです。これ一つを追加するだけで、関連する多数のライブラリが自動的に導入されます。

  • src/main/java: 私たちが書くJavaのソースコードを置く場所です。

  • GsSpringBootMvcApplication.java: このアプリケーションのメインクラスであり、実行の起点（エントリーポイント）です。中身を見てみましょう。

    “`java
    package com.example.gsspringbootmvc;

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

    @SpringBootApplication
    public class GsSpringBootMvcApplication {

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

    }
    ``mainメソッドがある、見慣れたJavaのクラスですね。ここで重要なのが@SpringBootApplication` というアノテーションです。

    アノテーションとは？
    @ で始まる記述で、クラスやメソッドに「印」を付けて特別な意味を持たせる機能です。@SpringBootApplication は、Spring Bootアプリケーションであることを示す魔法のようなアノテーションで、実際には以下の3つのアノテーションをまとめたものです。
    * @Configuration: このクラスが設定情報を持つことを示します。
    * @EnableAutoConfiguration: Spring Bootの自動設定機能を有効にします。クラスパスにあるライブラリなどから判断して、必要な設定を自動的に行ってくれます。
    * @ComponentScan: このクラスと同じパッケージ、およびそのサブパッケージ内にある @Component, @Controller, @Service などのアノテーションが付いたクラスを自動的に探し出し、Springの管理対象（Bean）として登録します。

  • src/main/resources: 設定ファイルやWebページ用のファイルを置く場所です。

    • application.properties: アプリケーション全体の設定を記述するファイルです。例えば、サーバーのポート番号を変更したり、データベースの接続情報を書いたりします。
    • static: CSSファイル、JavaScriptファイル、画像ファイルなど、内容が変化しない静的なリソースを置くディレクトリです。
    • templates: Thymeleafが使用するHTMLテンプレートファイルを置くディレクトリです。ここに置かれたHTMLファイルは、サーバーサイドで動的に内容を書き換えてからユーザーに返されます。

  • src/test/java: アプリケーションのテストコードを置く場所です。

プロジェクトの骨格が理解できたところで、いよいよコードを書いていきましょう。

第3章: はじめてのWebアプリケーション “Hello, World!”

理論よりも実践です。まずはブラウザに「Hello, World!」と表示する簡単なWebページを作ってみましょう。この過程で、Spring MVCの基本的な考え方である MVCパターン を学びます。

MVC (Model-View-Controller) パターンとは？

MVCは、アプリケーションの役割を以下の3つに分割して開発を進める設計パターンです。役割分担をすることで、コードの見通しが良くなり、メンテナンス性が向上します。

  • Model: アプリケーションのデータや、そのデータを扱うビジネスロジック（処理）を担当します。例えば、「ユーザー情報」や「商品をカートに追加する処理」などがこれにあたります。
  • View: ユーザーに見える部分、つまりユーザーインターフェース（UI）を担当します。Webアプリケーションでは主にHTMLがこれにあたります。ViewはModelから受け取ったデータを画面に表示する役割を持ちます。
  • Controller: ユーザーからのリクエスト（「このページが見たい」「このボタンを押した」など）を受け取り、それに応じてModelに処理を依頼し、その結果をどのViewを使って表示するかを決定する、いわば司令塔の役割を果たします。

Spring MVCにおける処理の流れ
1. ユーザーがブラウザから特定のURLにアクセスする（リクエスト）。
2. DispatcherServlet（Spring MVCの中心的なサーブレット）がリクエストを受け取る。
3. DispatcherServletは、どのControllerのどのメソッドがこのURLを処理すべきかを判断し、処理を依頼する。
4. Controllerは、必要に応じてModel（やService）に処理を依頼し、データを取得する。
5. Controllerは、Modelから受け取ったデータと、表示に使用するViewの名前をDispatcherServletに返す。
6. DispatcherServletは、指定されたView（Thymeleafテンプレート）にデータを渡し、最終的なHTMLの生成を依頼する。
7. 生成されたHTMLがユーザーのブラウザに返される（レスポンス）。

この流れを意識しながら、実際にControllerとViewを作成していきましょう。

1. Controllerの作成

まず、ユーザーからのリクエストを受け付けるControllerクラスを作成します。

  1. IntelliJ IDEAの左側のプロジェクトビューで、src/main/java/com/example/gsspringbootmvc パッケージを右クリックし、「New」→「Package」を選択します。
  2. パッケージ名として controller と入力し、Enterキーを押します。
  3. 今作成した controller パッケージを右クリックし、「New」→「Java Class」を選択します。
  4. クラス名として HelloController と入力し、Enterキーを押します。

生成された HelloController.java ファイルに、以下のコードを記述してください。

“`java
package com.example.gsspringbootmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller // ① このクラスがControllerであることを示すアノテーション
public class HelloController {

// ② /hello というURLへのGETリクエストをこのメソッドにマッピング
@GetMapping("/hello")
public String hello(Model model) {
    // ③ Viewに渡すデータをModelオブジェクトに追加
    model.addAttribute("message", "Hello, Spring Boot MVC!");
    // ④ 表示するViewの名前を返す (この場合は "hello.html")
    return "hello";
}

// 例： /greet?name=Taro のようにクエリパラメータを受け取る場合
@GetMapping("/greet")
public String greet(@RequestParam(name = "name", required = false, defaultValue = "World") String name, Model model) {
    model.addAttribute("message", "Hello, " + name + "!");
    return "greet"; // greet.html を表示
}

}
“`

コードの解説です。
* ① @Controller: このアノテーションを付けることで、Springはこのクラスを「Webリクエストを処理するController」として認識します。
* ② @GetMapping("/hello"): HTTPのGETメソッドによる /hello というパス（URL）へのリクエストを、直後にある hello() メソッドに紐付ける（マッピングする）アノテーションです。つまり、ユーザーが http://localhost:8080/hello にアクセスすると、このメソッドが実行されます。
* ③ model.addAttribute(...): Model は、ControllerからViewへデータを渡すための箱のようなものです。addAttribute("キー", "値") の形式で、好きなデータを詰め込むことができます。ここでは、message というキーで "Hello, Spring Boot MVC!" という文字列をModelに入れています。
* ④ return "hello";: このメソッドが返す文字列は、表示するViewの名前です。Spring Bootは、ここで返された "hello" という名前に基づいて、src/main/resources/templates/ ディレクトリの中から hello.html というファイルを探しに行きます。

greet メソッドも追加しました。これは @RequestParam を使ってURLのクエリパラメータ（?以降の部分）を受け取る例です。http://localhost:8080/greet?name=Taro のようにアクセスすると、name 変数に "Taro" が入ります。

2. View (Thymeleafテンプレート) の作成

次に、Controllerから渡されたデータを表示するためのHTMLファイルを作成します。

  1. プロジェクトビューで src/main/resources/templates ディレクトリを右クリックし、「New」→「HTML File」を選択します。
  2. ファイル名として hello.html と入力し、Enterキーを押します。

生成された hello.html ファイルに、以下のコードを記述してください。

“`html





Hello Page

Spring Boot MVC Sample


“`

  • xmlns:th="http://www.thymeleaf.org": HTMLタグの中でThymeleafの特殊な属性（th:で始まるもの）を使うためのおまじないです。
  • th:text="${message}": これがThymeleafの魔法です。p タグの中身を、${...} の中の式の結果で置き換えます。${message} は、Controllerで model.addAttribute("message", ...) として設定した値、つまり "Hello, Spring Boot MVC!" を参照しています。このHTMLがサーバーで処理されると、この部分は <p>Hello, Spring Boot MVC!</p> に変換されます。

同様に、greet.html も作成しておきましょう。

greet.html
“`html





Greet Page

Greeting


“`

3. アプリケーションの実行と確認

いよいよアプリケーションを実行します。

  1. プロジェクトビューで GsSpringBootMvcApplication.java を見つけます。
  2. main メソッドの横にある緑色の再生ボタン（▶）をクリックし、「Run ‘GsSpringBootMvcApplication.main()’」を選択します。
  3. IDEの下部にあるコンソールにログが流れ始め、最後に「…Tomcat started on port(s): 8080 (http)…」のようなメッセージが表示されれば、起動成功です。

Webブラウザを開き、以下のURLにアクセスしてみてください。

  • http://localhost:8080/hello
    • 画面に「Hello, Spring Boot MVC!」と表示されるはずです。
  • http://localhost:8080/greet
    • 画面に「Hello, World!」と表示されるはずです。（defaultValueが使われています）
  • http://localhost:8080/greet?name=Taro
    • 画面に「Hello, Taro!」と表示されるはずです。

おめでとうございます！これであなたは、Spring Boot MVCを使ったWebアプリケーション開発者としての第一歩を踏み出しました。

DevToolsの便利さを体験
ここで、HelloController.java の hello メソッド内のメッセージを "こんにちは、Spring Boot!" に変更してファイルを保存してみてください。IDEのコンソールを見ると、アプリケーションが自動的に再起動するのがわかります。ブラウザをリロードするだけで、変更が反映されているはずです。これがSpring Boot DevToolsのライブリロード機能です。

第4章: リクエストとレスポンスを深く理解する

Webアプリケーションの基本は、ユーザーからのリクエストを受け取り、適切なレスポンスを返すことです。ここでは、様々なリクエストの受け取り方を見ていきましょう。

1. パス変数 (@PathVariable)

URLの一部をパラメータとして受け取ることができます。例えば、ユーザーIDを指定してユーザー情報を表示するような場合に便利です。

HelloController に以下のメソッドを追加してください。

java
// /users/123 のようなURLを処理
@GetMapping("/users/{id}")
public String getUserProfile(@PathVariable String id, Model model) {
model.addAttribute("userId", id);
return "userProfile"; // userProfile.html を表示
}

  • @GetMapping("/users/{id}"): URLパスの一部を {} で囲むことで、そこが可変であることを示します。
  • @PathVariable String id: メソッドの引数に @PathVariable を付けることで、{id} の部分に入力された値（この例では "123"）が id 変数に代入されます。

対応するView (userProfile.html) も作成しましょう。

src/main/resources/templates/userProfile.html
“`html





User Profile

User Profile

表示しているユーザーのIDは です。


“`

アプリケーションを再起動（またはDevToolsによる自動再起動）後、http://localhost:8080/users/123 にアクセスしてみてください。「表示しているユーザーのIDは 123 です。」と表示されます。

2. フォームからのデータ受け取り (@PostMapping)

Webアプリケーションでは、ユーザーがフォームに入力したデータを受け取ることが頻繁にあります。これにはHTTPのPOSTメソッドが使われます。

ここでは、名前を入力するフォームを表示し、送信された名前を使って挨拶する、という一連の流れを実装してみましょう。

ステップ1: フォームを表示するためのControllerメソッド (GET)

HelloController に、フォーム画面を表示するためのメソッドを追加します。

java
// /form というURLへのGETリクエストでフォーム画面を表示
@GetMapping("/form")
public String showForm() {
return "form"; // form.html を表示
}
これは単純に form.html を表示するだけの簡単なメソッドです。

ステップ2: フォームのHTMLを作成 (form.html)

src/main/resources/templates に form.html を作成します。

“`html





Input Form

名前を入力してください





“`

  • <form th:action="@{/submit}" method="post">: フォームの送信先を /submit に、送信方法を post に指定しています。th:action="@{...}" はThymeleafの記法で、安全なURLを生成します。
  • <input type="text" name="name">: name 属性が重要です。ここで指定した "name" が、サーバー側でデータを受け取る際のキーになります。

ステップ3: フォームのデータを受け取るためのControllerメソッド (POST)

HelloController に、/submit へのPOSTリクエストを処理するメソッドを追加します。

java
// /submit というURLへのPOSTリクエストを処理
@PostMapping("/submit")
public String handleSubmit(@RequestParam String name, Model model) {
model.addAttribute("name", name);
return "result"; // result.html を表示
}

  • @PostMapping("/submit"): POSTメソッドによる /submit へのリクエストをマッピングします。
  • @RequestParam String name: GETのクエリパラメータと同様に @RequestParam を使ってフォームのデータを受け取ることができます。HTMLの input タグの name 属性と、引数名 name が一致しているため、値が自動的にマッピングされます。

ステップ4: 結果を表示するHTMLを作成 (result.html)

src/main/resources/templates に result.html を作成します。

“`html





Result

送信結果

こんにちは、 さん！

戻る

“`

動作確認
1. http://localhost:8080/form にアクセスします。
2. 入力欄に自分の名前（例: “鈴木”）を入力し、「送信」ボタンをクリックします。
3. URLが /submit に変わり（ブラウザ上では見えないかもしれません）、画面に「こんにちは、鈴木 さん！」と表示されれば成功です。

このように、@GetMapping でフォーム画面を見せ、@PostMapping でそのデータを受け取って処理する、というのがWebアプリケーションの基本的なパターンのひとつです。

第5章: Modelとデータの扱い

小規模なアプリケーションではControllerに処理を書いても問題ありませんが、アプリケーションが大きくなるにつれて、Controllerは太り、見通しが悪くなっていきます。

そこで Service層 を導入し、ビジネスロジックをControllerから分離します。

Controllerの役割: HTTPリクエストを受け取り、レスポンスを返すことに専念する。
Serviceの役割: アプリケーションのビジネスロジック（本来の目的である処理）を担当する。

1. Serviceクラスの作成

  1. com.example.gsspringbootmvc パッケージ配下に service パッケージを作成します。
  2. service パッケージ内に GreetingService というJavaクラスを作成します。

GreetingService.java
“`java
package com.example.gsspringbootmvc.service;

import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service // ① このクラスがService層のコンポーネントであることを示す
public class GreetingService {

/**
 * 挨拶メッセージを作成する
 * @param name 名前
 * @return 挨拶メッセージ
 */
public String createGreetingMessage(String name) {
    if (name == null || name.isEmpty()) {
        name = "World";
    }
    return "Hello, " + name + " from Service!";
}

/**
 * ユーザーリストを取得する (ダミーデータ)
 * @return ユーザー名のリスト
 */
public List<String> getUserList() {
    List<String> userList = new ArrayList<>();
    userList.add("佐藤");
    userList.add("鈴木");
    userList.add("高橋");
    return userList;
}

}
“`

  • ① @Service: このアノテーションを付けることで、Springはこのクラスを「ビジネスロジックを担当するServiceコンポーネント」として認識し、管理対象（Bean）とします。

2. ControllerからServiceを呼び出す (DI)

次に、HelloController から今作成した GreetingService を利用するように修正します。ここで登場するのが DI (Dependency Injection: 依存性の注入) というSpringの非常に重要な概念です。

簡単に言うと、「あるクラスが必要とする別のクラスのインスタンスを、自分で new するのではなく、外部（Springコンテナ）から与えてもらう」仕組みです。これにより、クラス間の結合度が下がり、テストしやすく、変更に強いコードになります。

HelloController.java を以下のように修正してください。

“`java
// … (package, import文は省略)
import com.example.gsspringbootmvc.service.GreetingService;
import org.springframework.beans.factory.annotation.Autowired;
// …

@Controller
public class HelloController {

// ① DI (依存性の注入)
private final GreetingService greetingService;

@Autowired // ② コンストラクタインジェクション
public HelloController(GreetingService greetingService) {
    this.greetingService = greetingService;
}

// ... (他のメソッドは省略)

// greetメソッドをServiceを使うように変更
@GetMapping("/greet")
public String greet(@RequestParam(name = "name", required = false) String name, Model model) {
    // ③ Serviceのメソッドを呼び出す
    String message = greetingService.createGreetingMessage(name);
    model.addAttribute("message", message);
    return "greet";
}

// ユーザーリストを表示するメソッドを追加
@GetMapping("/users")
public String listUsers(Model model) {
    List<String> users = greetingService.getUserList();
    model.addAttribute("users", users);
    return "userList"; // userList.html を表示
}

}
“`

  • ① private final GreetingService greetingService;: GreetingService のインスタンスを保持するフィールドを宣言します。final を付けることで、一度注入されたら変更されないことを保証します。
  • ② @Autowired とコンストラクタ: コンストラクタに @Autowired を付けることで、SpringがこのControllerのインスタンスを生成する際に、自動的に管理対象となっている GreetingService のインスタンスを探して引数に渡してくれます。これをコンストラクタインジェクションと呼び、現在推奨されているDIの方法です。
  • ③ greetingService.createGreetingMessage(name): Controller内では、注入されたServiceのメソッドを呼び出すだけでよくなりました。挨拶メッセージを生成する具体的なロジックはServiceクラスに隠蔽されています。

3. リストデータをViewで表示

Serviceから受け取ったリストデータを、Thymeleafを使って画面に表示してみましょう。

src/main/resources/templates に userList.html を作成します。

“`html





User List

ユーザー一覧

名前
Taro Yamada


“`

  • th:each="user : ${users}": これがThymeleafの繰り返し構文です。Controllerから渡されたリスト（model.addAttribute("users", ...) で設定したもの）を、一件ずつ取り出して user という変数に入れ、<tr> タグをリストの要素数だけ繰り返します。
  • <td th:text="${user}">...</td>: ループの各回で、現在の user 変数の中身（”佐藤”, “鈴木”, …）を <td> タグのテキストとして表示します。

動作確認
1. http://localhost:8080/greet?name=Spring にアクセスし、「Hello, Spring from Service!」と表示されることを確認します。
2. http://localhost:8080/users にアクセスし、表形式でユーザーの一覧が表示されることを確認します。

これで、ControllerとServiceの役割分担、そしてリストデータの表示方法をマスターしました。

第6章: データベース連携の第一歩 (H2 Database)

Webアプリケーションの多くは、データを永続化するためにデータベースを必要とします。Spring Bootは Spring Data JPA という非常に強力な機能を提供しており、驚くほど簡単にデータベース操作を実装できます。

ここでは、セットアップが不要なインメモリデータベースである H2 Database を使って、ユーザー情報を保存・取得する機能を実装してみましょう。

1. 必要な依存関係の追加

pom.xml を開き、<dependencies> タグ内に以下の2つの依存関係を追加します。

“`xml


org.springframework.boot
spring-boot-starter-data-jpa


com.h2database
h2
runtime

“`

  • spring-boot-starter-data-jpa: Spring Data JPAを使うためのスターターです。これには、JPAの標準仕様やその実装であるHibernateなどが含まれています。
  • h2: H2 DatabaseのJDBCドライバです。

IntelliJ IDEAを使っている場合、pom.xml を変更すると右上にMavenの再読み込みを促すアイコンが表示されるので、クリックして依存関係をダウンロードしてください。

2. 設定ファイルの編集

src/main/resources/application.properties にH2データベースの設定を追加します。

“`properties

H2 Database Settings

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

H2 Console Settings

spring.h2.console.enabled=true
“`

  • spring.datasource.*: データベースの接続情報を設定しています。jdbc:h2:mem:testdb は、「testdb」という名前のインメモリデータベースに接続することを意味します。
  • spring.h2.console.enabled=true: H2データベースには、ブラウザからデータベースの中身を確認できるコンソール機能があります。これを有効にします。

3. Entityクラスの作成

Entityとは、データベースのテーブルの行に対応するJavaオブジェクトのことです。

  1. com.example.gsspringbootmvc 配下に entity パッケージを作成します。
  2. entity パッケージ内に User クラスを作成します。

User.java
“`java
package com.example.gsspringbootmvc.entity;

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

@Entity // ① このクラスがJPAのエンティティであることを示す
@Table(name = “users”) // ② 対応するテーブル名を指定
public class User {

@Id // ③ プライマリキー（主キー）であることを示す
@GeneratedValue(strategy = GenerationType.IDENTITY) // ④ IDの自動採番戦略
private Long id;

private String name;
private String email;

// Getter, Setter, コンストラクタなど (省略)
// IDEの機能で自動生成してください

// 以下、手動で追加 or IDEで生成
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; }

}
“`

  • ① @Entity: このクラスがデータベースのテーブルとマッピングされるエンティティであることを示します。
  • ② @Table(name = "users"): 対応するテーブル名を明示的に指定します。指定しない場合、クラス名（user）が使われます。
  • ③ @Id: このフィールドがテーブルのプライマリキーであることを示します。
  • ④ @GeneratedValue: プライマリキーの値をどのように生成するかを指定します。IDENTITY は、データベースの自動採番機能に任せる設定です。

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

Repositoryは、データベースに対する操作（CRUD: Create, Read, Update, Delete）を定義するインターフェースです。Spring Data JPAの魔法はここにあります。

  1. com.example.gsspringbootmvc 配下に repository パッケージを作成します。
  2. repository パッケージ内に UserRepository インターフェースを作成します。

UserRepository.java
“`java
package com.example.gsspringbootmvc.repository;

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

@Repository
public interface UserRepository extends JpaRepository {
// これだけで基本的なCRUD操作がすべて利用可能になる！
// (save, findById, findAll, deleteById など)
}
“`

  • JpaRepository<User, Long> を継承するだけで、Spring Data JPAが実行時にこのインターフェースの実装クラスを自動的に生成してくれます。<User, Long> は、このリポジトリが扱うエンティティが User クラスで、そのプライマリキーの型が Long であることを示しています。
  • メソッドを何も定義しなくても、save()（保存）、findById()（IDで一件取得）、findAll()（全件取得）、deleteById()（IDで削除）といった基本的なメソッドがすべて利用可能になります。

5. Service層とController層の実装

最後に、これらを使ってユーザーを登録し、一覧表示する機能を実装します。

UserService.java (新規作成)
service パッケージに UserService クラスを作成します。

“`java
package com.example.gsspringbootmvc.service;

import com.example.gsspringbootmvc.entity.User;
import com.example.gsspringbootmvc.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserService {

private final UserRepository userRepository;

@Autowired
public UserService(UserRepository userRepository) {
    this.userRepository = userRepository;
}

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

public User save(User user) {
    return userRepository.save(user);
}

}
``UserRepository` をDIで注入し、そのメソッドを呼び出すだけのシンプルな実装です。

UserController.java (新規作成)
controller パッケージに UserController クラスを作成します。

“`java
package com.example.gsspringbootmvc.controller;

import com.example.gsspringbootmvc.entity.User;
import com.example.gsspringbootmvc.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;

@Controller
public class UserController {

private final UserService userService;

@Autowired
public UserController(UserService userService) {
    this.userService = userService;
}

// ユーザー一覧画面
@GetMapping("/db/users")
public String listDbUsers(Model model) {
    List<User> userList = userService.findAll();
    model.addAttribute("userList", userList);
    return "db/userList";
}

// ユーザー登録フォーム画面
@GetMapping("/db/users/new")
public String showUserForm(@ModelAttribute User user) {
    return "db/userForm";
}

// ユーザー登録処理
@PostMapping("/db/users/create")
public String createUser(@ModelAttribute User user) {
    userService.save(user);
    return "redirect:/db/users"; // 登録後は一覧画面にリダイレクト
}

}
``
*@ModelAttribute: フォームの入力項目をUserオブジェクトに自動的にマッピング（バインド）してくれます。
*return “redirect:/db/users”;`: 処理後に別のURLにリダイレクトする際の書き方です。これにより、ブラウザのリロードによる二重送信を防ぐことができます。

Viewの作成
templates ディレクトリの下に db ディレクトリを作成し、その中に以下の2つのHTMLファイルを作成します。

db/userList.html
“`html




DB User List

ユーザー一覧 (DB)

新規登録

ID 名前 Email
1 Yamada Taro [email protected]


“`

db/userForm.html
“`html




New User

ユーザー新規登録





``
*th:object=”${user}”: このフォームがuserオブジェクトと紐付いていることを示します。
*th:field=”*{name}”:inputタグをオブジェクトのnameプロパティと紐付けます。id,name,value` 属性をまとめて設定してくれる便利な属性です。

動作確認
1. アプリケーションを起動します。
2. http://localhost:8080/db/users にアクセスします。最初は誰も登録されていないので、テーブルは空です。
3. 「新規登録」リンクをクリックし、http://localhost:8080/db/users/new に移動します。
4. 名前とEmailを入力して「登録」ボタンをクリックします。
5. 一覧画面にリダイレクトされ、今登録したユーザー情報が表示されていれば成功です。

H2コンソールで確認
http://localhost:8080/h2-console にアクセスしてみてください。
* JDBC URLが jdbc:h2:mem:testdb になっていることを確認し、「Connect」ボタンを押します。
* 左のツリーから USERS テーブルを選択し、SELECT * FROM USERS を実行すると、登録したデータがSQLレベルで確認できます。

第7章: 次のステップへ

ここまでで、あなたはSpring Boot MVCの基本的な概念と開発フローを習得しました。しかし、これは広大なSpringの世界の入り口に過ぎません。ここからさらに学ぶべきトピックをいくつか紹介します。

  • バリデーション (入力チェック): ユーザーの入力値が正しい形式か（例: メールアドレスの形式、パスワードの文字数など）をチェックする仕組みです。spring-boot-starter-validation を使い、@NotNull, @Size, @Email などのアノテーションで簡単に実装できます。
  • エラーハンドリング: アプリケーションで予期せぬエラーが発生した際に、ユーザーに分かりやすいエラーページを表示するための仕組みです。@ControllerAdvice や @ExceptionHandler を使って、エラー処理を共通化できます。
  • セキュリティ: ログイン認証や認可（権限管理）など、アプリケーションを不正なアクセスから守るための機能です。Spring Security という非常に強力なフレームワークが提供されており、導入することで堅牢なセキュリティを実装できます。
  • テスト: 品質の高いアプリケーションを作るためにはテストが不可欠です。JUnit 5を使った単体テストや、MockMvcを使ったControllerの結合テストの書き方を学びましょう。
  • 本番用データベース: H2は開発には便利ですが、本番環境ではMySQLやPostgreSQLといった永続的なデータベースを使用します。application.properties の設定を切り替えるだけで、データベースの変更は簡単に行えます。

これらのトピックは、Springの公式ドキュメントや、Baeldungのような質の高い技術ブログ、市販の書籍などで深く学ぶことができます。

おわりに

この記事では、Java初心者の皆さんを対象に、Spring Boot MVCを使ったWebアプリケーション開発の第一歩をガイドしました。環境構築から始まり、MVCの概念、リクエストの処理、Service層によるロジックの分離、そしてSpring Data JPAを使ったデータベース連携まで、一連の流れを体験していただけたかと思います。

Spring Bootは、Javaによるモダンなアプリケーション開発を驚くほどシンプルかつ楽しいものにしてくれます。ここで学んだ知識は、あなたのキャリアにおける強力な武器となるはずです。

しかし、学習の旅はまだ始まったばかりです。ぜひ、興味を持った機能をさらに深掘りしたり、自分だけのオリジナルなアプリケーションを作ってみたりしてください。実際に手を動かして何かを作り上げることが、最も効果的な学習方法です。

この記事が、あなたのSpring Boot学習の助けとなれば幸いです。Happy Coding

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール