Spring Bootフレームワークを用いて、シンプルなレンタル管理システムを開発する課題です。


SpringBootコース

テンプレートエンジン(thymeleaf)

レンタル管理システムを作ろう

ここでは、先ほど作成したユーザー管理機能の仕組みと処理の流れを3層アーキテクチャ（プレゼンテーション層、ビジネス層、データアクセス層）に沿って詳しく説明します。

## シナリオ1: ユーザー一覧表示

ユーザーがブラウザ（ChromeやSafariなど）で`localhost:8080/users`にアクセスした際の処理の流れを追ってみましょう。

```mermaid
sequenceDiagram
    actor ユーザー
    participant ブラウザ
    participant Controller as プレゼンテーション<br>UserController
    participant Service as サービス<br>UserService
    participant Repository as データアクセス<br>UserRepository
    participant DB as Database
    
    ユーザー->>ブラウザ: /usersにアクセス
    ブラウザ->>+Controller: GET /users
    Controller->>+Service: getAllUsers()
    Service->>+Repository: findAll()
    Repository->>+DB: SELECT
    DB-->>-Repository: 結果セット
    Repository-->>-Service: List<User>
    Service-->>-Controller: List<User>
    Controller->>Controller: モデルにユーザーリストを追加
    Controller-->>-ブラウザ: user_list.htmlを返す
    ブラウザ-->>ユーザー: ユーザー一覧画面を表示
```

ユーザー一覧表示機能はシンプルな造りになっています。
まずは、**どのクラスが、3層のうち、どの層に該当し、どんな順番で動いているのか**流れを意識できるようにしましょう。

### 1. リクエスト受付 (プレゼンテーション層)

ブラウザから`/users`へのGETリクエストが発生すると、ルーティング機能によって`UserController`の`listUsers`メソッドが呼び出されます。

```java~UserController
@GetMapping
public String listUsers(Model model) {
    model.addAttribute("users", userService.getAllUsers());
    return "user_list";
}
```

このメソッドは以下の処理を行います：
- `userService.getAllUsers()`を呼び出してユーザー一覧データを取得
- 取得したデータを`users`という名前でモデルに追加
- `user_list`というビュー名を返す

### 2. ビジネスロジックの実行 (ビジネス層)

コントローラーから呼び出された`UserService`の`getAllUsers`メソッドが処理を実行します。

```java~UserService
public List<User> getAllUsers() {
    return userRepository.findAll();
}
```

今回、このメソッドはリポジトリの`findAll`メソッドを呼び出すだけですが、将来的により複雑なビジネスロジック（ユーザーの権限により表示内容をフィルタリングする、など）を追加することができます。

### 3. データベースアクセス (データアクセス層)

サービスから呼び出された`UserRepository`の`findAll`メソッドがデータベースからユーザー情報を取得します。

```java~UserRepository
@Select("SELECT * FROM users")
List<User> findAll();
```

このメソッドはMyBatisの`@Select`アノテーションを使って、SQLクエリを`H2データベース`に対して実行し、結果を`User`オブジェクトのリストとして返します。

### 4. レスポンス生成 (プレゼンテーション層)

最終的に、コントローラーが返した`user_list`というビュー名を元に、Spring BootはThymeleafテンプレートエンジンを使って`user_list.html`を表示します。
このテンプレート内では、モデルに追加された`users`を使ってユーザー一覧を表示します。

```html~user_list
<tbody>
    <tr th:each="user : ${users}">
        <td th:text="${user.name}"></td>
        <td th:text="${user.email}"></td>
        <td>
            <a th:href="@{/users/delete/{id}(id=${user.id})}" 
               onclick="return confirm('削除しますか？')">削除</a>
        </td>
    </tr>
</tbody>
```

### 一覧表示の処理フロー

1. ブラウザ: `/users`へのGETリクエスト
2. **プレゼンテーション層**：`UserController.listUsers()`メソッド実行
3. **ビジネス層**：`UserService.getAllUsers()`メソッド実行  
4. **データアクセス層**：`UserRepository.findAll()`メソッド実行
---
5. **データアクセス層**→**ビジネス層**：ユーザーのリストを返却
6. **ビジネス層**→**プレゼンテーション層**：ユーザーのリストを返却
7. **プレゼンテーション層**：`user-list.html`テンプレートにデータを渡してレンダリング
8. ブラウザ：HTML表示


リクエストをプレゼンテーション層が受け取り、データアクセス層まで処理が流れていき、また戻っていく、一連の流れはイメージできたでしょうか？

## シナリオ2: 新規ユーザー登録

次に、新規ユーザー登録の処理の流れを見てみましょう。

### 1-1. 新規登録フォームを、はじめて表示した時のフロー

これは、「新規ユーザー登録」のリンクをはじめてクリックした時のフローです。
```mermaid
sequenceDiagram
    actor ユーザー
    participant ブラウザ
    participant Controller as UserController
    
    ユーザー->>ブラウザ: 新規ユーザー登録リンクをクリック
    ブラウザ->>+Controller: GET /users/new
    Controller->>Controller: new User()を作成
    Controller->>Controller: モデルに空のUserオブジェクトを追加
    Controller-->>-ブラウザ: user_form.htmlを返す
    ブラウザ-->>ユーザー: ユーザー登録フォームを表示
```
この時は、データベースの情報を必要としていない為、Controllerだけで解決しています。
ソースコードの解説も確認していきましょう。

### 1-2. 登録フォーム表示
ユーザーが「/users/new」にアクセスすると、`UserController`の`showCreateForm`メソッドが呼び出されます。

```java~UserController
@GetMapping("/new")
public String showCreateForm(Model model) {
    model.addAttribute("user", new User());
    return "user_form";
}
```

このメソッドは新しい空の`User`オブジェクトをモデルに追加し、`user_form`テンプレートを返します。

### 2-1. 新規登録フォームに、必要事項を入力し、送信した時のフロー
これは、「新規ユーザーの情報」を全て入力し、登録ボタンを押したときのフローです。

```mermaid
sequenceDiagram
    actor ユーザー
    participant ブラウザ
    participant Controller as UserController
    participant Service as UserService
    participant Repository as UserRepository
    participant DB as Database
    
    ユーザー->>ブラウザ: フォームに入力して送信
    ブラウザ->>+Controller: POST /users {name, email}
    Controller->>Controller: @ModelAttributeでUserオブジェクトにバインド
    Controller->>+Service: saveUser(user)
    Service->>+Repository: insert(user)
    Repository->>+DB: INSERT
    DB-->>-Repository: 実行結果
    Repository-->>-Service: void
    Service-->>-Controller: void
    Controller-->>-ブラウザ: redirect:/users
    ブラウザ->>ブラウザ: /usersへリダイレクト
    ブラウザ-->>ユーザー: ユーザー一覧画面を表示（更新済み）
```

今回は、`H2データベース`に保存が必要なため、データアクセス層まで処理が流れていきます。入力データを`User`というオブジェクト単位で送っているようなイメージで、ソースコードの解説も確認していきましょう。

### 2-2. ユーザー入力と送信

ユーザーがフォームに情報を入力して送信すると、「/users」へのPOSTリクエストが発生し、`UserController`の`createUser`メソッドが呼び出されます。

```java~UserController
@PostMapping
public String createUser(@ModelAttribute User user) {
    userService.saveUser(user);
    return "redirect:/users";
}
```

`@ModelAttribute`アノテーションによって、フォームから送信されたデータが自動的に`User`オブジェクトにバインドされます。

### 2-3. ビジネスロジックの実行

コントローラーから呼び出された`UserService`の`saveUser`メソッドが処理を実行します。

```java~UserService
public void saveUser(User user) {
    userRepository.insert(user);
}
```

### 2-4. データベースアクセス

サービスから呼び出された`UserRepository`の`insert`メソッドがユーザー情報をデータベースに保存します。

```java~UserRepository
@Insert("INSERT INTO users (name, email) VALUES (#{name}, #{email})")
void insert(User user);
```

### 2-5. リダイレクトとユーザー一覧表示

登録処理が完了すると、コントローラーは「/users」へのリダイレクトを返し、ブラウザは自動的にユーザー一覧ページにリダイレクトされます。その後、上記の「ユーザー一覧表示」の処理フローが実行されます。

### 新規登録の処理フロー

1. ブラウザ: `/users/new`へのGETリクエスト
2. **プレゼンテーション層**：`UserController.showCreateForm()`メソッド実行
3. **プレゼンテーション層**：`user_form.html`テンプレートに空のUserオブジェクトを渡してレンダリング
4. ブラウザ：ユーザーがフォームに情報を入力して送信（`/users`へのPOSTリクエスト）
5. **プレゼンテーション層**：`UserController.createUser()`メソッド実行
6. **ビジネス層**：`UserService.saveUser()`メソッド実行
7. **データアクセス層**：`UserRepository.insert()`メソッド実行
8. **プレゼンテーション層**：`/users`へリダイレクト
9. ブラウザ：`/users`へリダイレクト（一覧表示の処理フローが再度実行される）

## シナリオ3: ユーザー削除

ユーザー削除の処理の流れは、新規登録のフローと似ています。
違いとしては、**入力情報をオブジェクトに格納し、データアクセス層まで運ぶ**フローではなく、
削除処理は**入力パラメータのidを、データアクセス層まで運ぶ**フローになります。
そのことを意識しながら、ソースコードの解説を確認してみてください。

### 1. 削除リンクのクリック

ユーザー一覧ページで削除リンクがクリックされると、「/users/delete/{id}」へのGETリクエストが発生し、`UserController`の`deleteUser`メソッドが呼び出されます。

```java~UserController
@GetMapping("/delete/{id}")
public String deleteUser(@PathVariable Integer id) {
    userService.deleteUser(id);
    return "redirect:/users";
}
```

`@PathVariable`アノテーションによって、URLのパス変数`{id}`の値が`id`パラメータに渡されます。

### 2. ビジネスロジックの実行

コントローラーから呼び出された`UserService`の`deleteUser`メソッドが処理を実行します。

```java~UserService
public void deleteUser(Integer id) {
    userRepository.delete(id);
}
```

### 3. データベースアクセス

サービスから呼び出された`UserRepository`の`delete`メソッドが指定されたIDのユーザー情報をデータベースから削除します。

```java~UserRepository
@Delete("DELETE FROM users WHERE id = #{id}")
void delete(Integer id);
```

### 4. リダイレクトとユーザー一覧表示

削除処理が完了すると、コントローラーは「/users」へのリダイレクトを返し、ブラウザは自動的にユーザー一覧ページにリダイレクトされます。

### 削除の処理フロー

1. ブラウザ: `/users/delete/{id}`へのGETリクエスト
2. **プレゼンテーション層**：`UserController.deleteUser()`メソッド実行
3. **ビジネス層**：`UserService.deleteUser()`メソッド実行
4. **データアクセス層**：`UserRepository.delete()`メソッド実行
5. **プレゼンテーション層**：`/users`へリダイレクト
6. ブラウザ：`/users`へリダイレクト（一覧表示の処理フローが再度実行される）

## まとめ

ユーザー管理機能は、3層アーキテクチャに沿って以下のように実装してきました。

1. **プレゼンテーション層**（`UserController`）
   - ユーザーからのリクエストを受け付ける
   - 必要に応じてビジネス層を呼び出す
   - 適切なビューを返却またはリダイレクトする

2. **ビジネス層**（`UserService`）
   - コントローラーからの要求に応じて処理を実行
   - データアクセス層を呼び出してデータの取得や操作を行う
   - （現状はシンプルだが、将来的に複雑なビジネスロジックを追加できる）

3. **データアクセス層**（`UserRepository`）
   - データベースとのやり取りを担当
   - SQL文を実行し、結果を適切な形で返す

このように、3層アーキテクチャによってシステムの各部分の役割が明確に分離されます。
各層は独立して動作するため、例えばデータベースの種類を変更したい場合はデータアクセス層のみを修正すれば良く、他の層に影響を与えることなく変更が可能、というメリットを持った実装ができました。

7. ユーザー管理機能 | 処理の流れの確認