カテゴリー: システム開発

多くの企業がDXを推進する中で、既存のJSP資産を活用しつつ、Spring Bootの高速開発能力を取り入れたいと考えるシステムエンジニアの皆様へ。この記事では、私がブログ編集長として、またシステムエンジニアとしての経験を基に、Spring BootとJSPを効果的に連携させ、モダンなWebアプリケーションを構築するための具体的な手順と実践例を詳述します。

「Spring BootはJAR形式が主流でJSPは相性が悪いのでは？」といった疑問をお持ちの方もいらっしゃるかもしれません。ご安心ください。本記事では、その懸念を解消し、両者のメリットを最大限に引き出すWAR形式でのデプロイ戦略を中心に解説します。

目次

• なぜ今、Spring BootとJSPの連携が必要なのか？
• 前提知識：Spring BootとJSPの基本
• 実践：Spring Boot (WAR) とJSPでWebアプリを構築する手順
• 実践例：WebアプリA (JSPフロント) とWebアプリB (API) の連携
• まとめ：Spring BootとJSPで未来を切り拓く
• 次のステップへ：更なるDX推進のために

なぜ今、Spring BootとJSPの連携が必要なのか？

現代のシステム開発では、迅速な市場投入と高い保守性が求められます。Spring Bootは、その「設定より規約」の思想と豊富なスターターにより、開発効率を飛躍的に向上させます。一方で、多くの企業では長年培ってきたJSPベースの既存システムや、JSP開発に慣れた技術資産が存在します。

これら既存のJSP資産を捨て去ることは、コスト面やリスク面から非現実的な場合が多いです。そこで、Spring Bootのモダンな開発手法と、JSPの既存資産を両立させる連携が、現実的なDX推進の鍵となります。

特に、UI層はJSPで柔軟に表現しつつ、バックエンドのビジネスロジックやAPI連携はSpring Bootの強力な機能で構築するといったハイブリッド戦略は、多くの企業にとって最適な道筋となり得るでしょう。

前提知識：Spring BootとJSPの基本

本記事を最大限に活用していただくために、以下の基本的な知識があると理解が深まります。

• Spring Bootの基礎: 依存性注入（DI）、Webアプリケーション（MVC）、プロジェクト構造の理解。
• JSPの基礎: JSPの構文、EL式、JSTL、サーブレットコンテナでの動作原理。
• Mavenの基礎: `pom.xml`の読み書き、ビルドライフサイクル（`clean`, `package`など）。
• Tomcatの基礎: 環境変数（`CATALINA_HOME`）、デプロイ方法（WARファイル）。

特に、Spring BootがJAR形式で組み込みサーバーを持つのが主流である点と、JSPがサーブレットコンテナ上で動作するView技術である点を踏まえると、両者の連携には工夫が必要であることが理解できるでしょう。

実践：Spring Boot (WAR) とJSPでWebアプリを構築する手順

Spring BootとJSPを連携させる最も安定した方法は、Spring BootアプリケーションをWAR形式でビルドし、外部のTomcatにデプロイすることです。

ステップ1: プロジェクトの初期設定

1. Spring Initializrでプロジェクトを生成:
   • Project: Maven Project
   • Packaging: WAR を選択
   • Dependencies: `Spring Web`, `Tomcat Embed Jasper` (JSPコンパイル用)

   注意: `tomcat-embed-jasper`は、WARパッケージングの場合、`provided`スコープに設定しがちですが、Spring BootアプリケーションとしてJAR実行も視野に入れるなら`compile`スコープのままでOKです。外部Tomcatにデプロイする際、Tomcat側がJSPコンパイル機能を提供するため問題ありません。

2. `pom.xml`の確認:

   生成された`pom.xml`に`packaging`タグが`war`になっていることを確認し、`spring-boot-starter-tomcat`や`tomcat-embed-jasper`が含まれていることを確認します。

   <packaging>war</packaging>
   <!-- ... -->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
       <groupId>org.apache.tomcat.embed</groupId>
       <artifactId>tomcat-embed-jasper</artifactId>
   </dependency>
   

ステップ2: JSPファイルの配置と設定

1. JSPファイルの配置:

   従来のWebアプリケーションと同様に、JSPファイルは`src/main/webapp/WEB-INF/jsp/`ディレクトリ以下に配置します。このパスは、TomcatがWARファイルを展開した際にJSPファイルを認識できる標準的な場所です。

   src
   └── main
       └── webapp
           └── WEB-INF
               └── jsp
                   └── welcome.jsp
           └── index.html (または他の静的ファイル)
   

2. `application.properties`の設定:

   Spring BootにJSPの場所を教えるために、`src/main/resources/application.properties`にビューリゾルバーの設定を追加します。

   spring.mvc.view.prefix=/WEB-INF/jsp/
   spring.mvc.view.suffix=.jsp
   

ステップ3: コントローラの作成

JSPを表示するための簡単なSpring MVCコントローラを作成します。

package com.example.mywebapp.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class ViewController {

    @GetMapping("/welcome")
    public String showWelcomePage() {
        return "welcome"; // src/main/webapp/WEB-INF/jsp/welcome.jsp を解決
    }
}

ステップ4: WARファイルのビルドとデプロイ

1. WARファイルのビルド:

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

   mvn clean package
   

   `target/`ディレクトリに`your-app-name.war`が生成されます。

2. Tomcatへのデプロイ:

   生成されたWARファイルを、インストール済みのTomcatの`%CATALINA_HOME%\webapps`ディレクトリにコピーします。

3. Tomcatの起動:

   Tomcatを起動または再起動します。

   cd %CATALINA_HOME%\bin
   shutdown.bat # 必要であれば
   startup.bat
   

   これにより、TomcatがWARファイルを自動的に展開し、アプリケーションがデプロイされます。

4. 動作確認:

   ブラウザで`http://localhost:8080/あなたのWARファイル名（.warを除く）/welcome` にアクセスし、JSPページが表示されることを確認します。

実践例：WebアプリA (JSPフロント) とWebアプリB (API) の連携

ここからは、Spring Boot (WAR) のWebアプリAと、独立したAPIであるSpring Boot (JAR) のWebアプリBを連携させる具体的な実践例です。

WebアプリB (JAR) の準備 (ポート8081で動作)

WebアプリBは、Spring Boot (JAR) で構築し、Gemini APIと連携するRESTful APIとして動作させます。WebアプリAとのポート競合を避けるため、デフォルトの8080ポートではなく、例えば8081ポートを使用します。

1. プロジェクト作成: `spring-boot-starter-web`, `com.google.generativeai:java-genai` を依存関係に持つJARプロジェクトとして作成。
2. ポート設定: `src/main/resources/application.properties` に `server.port=8081` と `google.gemini.api-key=YOUR_API_KEY` を設定。
3. API実装: Gemini API呼び出しロジックを持つ`GeminiApiService`と、JSON形式のリクエスト/レスポンスPOJO、そしてそれらを利用する`GeminiController` (`@RequestMapping(“/api/gemini”)`) を実装。
4. ビルドと起動: `mvn clean package` でJARを生成し、`java -jar target/your-api-service.jar` で起動。

WebアプリA (WAR) からWebアプリBへの同期呼び出し

WebアプリAは、ユーザーからのリクエストを受け取り、JSPで表示するだけでなく、WebアプリBのAPIを同期的に呼び出し、その結果をJSPに渡す役割を担います。

1. `RestTemplate`のBean定義: WebアプリAのメインクラスに`RestTemplate`のBeanを定義します。
2. POJOのコピー: WebアプリBで定義した`GeminiRequest`と`GeminiResponse`のPOJOクラスを、WebアプリAのプロジェクトにもコピーします。
3. APIクライアントサービスの作成: `WebBClientService`を作成し、`RestTemplate`を使用してWebアプリBのAPI (`http://localhost:8081/api/gemini/generate`) を呼び出すメソッドを実装します。WebアプリAの`application.properties`に`webb.api.url=http://localhost:8081`を設定します。
4. JSP表示コントローラの修正: ユーザーのリクエストを受け取るコントローラを実装し、その中で`WebBClientService`を呼び出し、取得したレスポンスデータをJSPにモデル属性として渡します。
5. JSPでの表示: JSP内でEL式などを使って、コントローラから渡されたデータを表示します。

これにより、ブラウザ（①非同期）→WebアプリA（②同期）→WebアプリB（③同期）→Gemini API（④同期）→WebアプリB（③同期）→WebアプリA（②非同期）→ブラウザというデータフローが実現できます。

まとめ：Spring BootとJSPで未来を切り拓く

本記事では、Spring Bootの高速開発とJSPの既存資産活用を両立させる、WAR形式でのデプロイ戦略を解説しました。JAR形式でのJSP利用の難しさを乗り越え、外部Tomcatを利用することで、安定したJSPベースのUIと、Spring Bootの強力なバックエンド処理を組み合わせることが可能です。

WebアプリA（WAR）とWebアプリB（JAR）という二層構造は、マイクロサービスアーキテクチャの第一歩とも言え、それぞれの責務を明確に分離することで、開発効率とメンテナンス性を高めます。これにより、既存システムを活かしつつ、AI連携のようなモダンな技術を取り入れるDX戦略を強力に推進できるでしょう。

次のステップへ：更なるDX推進のために

この実践ガイドが、あなたのSpring BootとJSPを用いた開発の一助となれば幸いです。次のステップとして、以下を検討してみてはいかがでしょうか。

• 認証・認可の導入: Spring Securityを用いたセキュリティ機能の追加。
• エラーハンドリングの強化: グローバルなエラーハンドリングや、APIのエラーレスポンスの標準化。
• フロントエンド技術の導入: JSPから、ReactやVue.jsといったSPAフレームワークへの移行検討。
• テストコードの拡充: 単体テスト、結合テスト、E2Eテストの導入。

疑問点や更なるご相談があれば、いつでもお声がけください。

この記事が皆様のDX推進とサイトトラフィック増加に貢献することを願っております。

関連情報:

• Spring Boot 公式サイト
• JavaServer Pages (JSP) 仕様
• Google Gemini API (Vertex AI)

この記事が役に立ったと感じたら、ぜひSNSでのシェアやブックマークをお願いいたします！

目次

• MVP開発環境がなぜ今、重要なのか？
• MVP開発環境構築のための前提知識
• 【実践】MVP開発環境を構築する5ステップ
• MVP開発を成功させるための実践例と注意点
• まとめ：最小投資で最大のリターンを

MVP開発環境がなぜ今、重要なのか？

現代のIT業界は変化のスピードが極めて速く、顧客のニーズも多様化しています。このような環境下で、従来のウォーターフォール型開発のように何ヶ月もかけて大規模なシステムを構築し、満を持してリリースする手法はリスクが高くなっています。なぜなら、開発中に市場のニーズが変化したり、競合が先に同様のサービスを投入したりする可能性があるからです。

MVP開発は、そうしたリスクを最小限に抑えつつ、アイデアの検証と市場適合性を迅速に確認するためのアプローチです。最小限の機能（MVP）を開発し、素早くユーザーに提供することで、早期にフィードバックを得て、次の開発サイクルへと活かすことができます。このアサイクルを繰り返すことで、無駄な開発を減らし、本当に求められる製品へと成長させることが可能になります。

効率的なMVP開発を実現するためには、そのための開発環境が不可欠です。時間とコストを抑え、柔軟かつ迅速に開発・テスト・デプロイが行える環境こそが、現代のビジネス成功の鍵を握ります。

MVP開発環境構築のための前提知識

具体的な手順に入る前に、MVP開発環境を理解するためのいくつかの前提知識を押さえておきましょう。

1. MVP (Minimum Viable Product) とは

「最小限の実行可能な製品」という意味で、コアとなる機能に絞り込み、ユーザーに価値を提供できる最低限の製品を指します。目的は、ユーザーからのフィードバックを早期に収集し、製品の改善や方向性の検証を行うことです。

2. アジャイル開発とDevOps

MVP開発は、アジャイル開発手法と密接に関連しています。短い開発サイクルを繰り返し、計画・設計・実装・テストを高速で回します。また、DevOps（Development & Operations）の概念、つまり開発と運用の連携を密にすることで、ソフトウェアの迅速なリリースと安定稼働を目指します。

3. コンテナ技術 (Docker)

開発環境と本番環境の差異をなくし、移植性を高めるために必須となる技術です。Dockerはアプリケーションとその実行に必要なものすべて（コード、ランタイム、システムツール、ライブラリなど）をコンテナという形でパッケージ化し、どの環境でも同じように動作することを保証します。

4. CI/CDパイプライン

継続的インテグレーション（CI）と継続的デリバリー（CD）の略で、コードの変更が自動的にビルド、テストされ、デプロイされる一連の自動化されたプロセスを指します。これにより、手動によるミスを減らし、市場への投入スピードを劇的に向上させます。

【実践】MVP開発環境を構築する5ステップ

ここからが本題です。システムエンジニアとしての知見に基づき、実践的なMVP開発環境の構築手順をステップバイステップで解説します。

ステップ1：コア技術スタックの選定

MVP開発では、開発速度と将来性を考慮した技術選定が重要です。ここでは、現代のWebアプリケーション開発で非常に人気のある組み合わせを例に挙げます。

• バックエンド: Spring Boot (Java)
• フロントエンド: JSP/Thymeleaf (サーバーサイドレンダリング) または React/Vue.js (SPA)
• データベース: MySQL/PostgreSQL
• コンテナ化: Docker

Spring Bootは、素早い開発を可能にするフレームワークであり、豊富なスターターや自動設定機能が魅力です。JSPは既存の技術資産を活用できる点で優位ですが、新規開発ではThymeleafやJavaScriptフレームワークも有力な選択肢です。この記事では、既存資産を活かす可能性も考慮し、JSPをバックエンド技術として扱います。

ステップ2：開発環境のセットアップ (Eclipse/Docker Desktop)

開発者は慣れたIDE（統合開発環境）でコードを記述します。Docker Desktopをインストールすることで、ローカルPC上で本番に近い環境を再現できます。

1. Eclipse IDEのインストール: Java開発に広く使われるIDEです。Spring Tool Suite (STS) を利用するとSpring Boot開発がさらにスムーズになります。
2. Mavenのインストール: プロジェクトのビルドと依存関係管理に使います。Eclipseに統合されているものも利用できますが、コマンドラインからの実行もできるように別途インストールしPATHを通しておくと良いでしょう。
3. Docker Desktopのインストールと起動: Dockerの公式ウェブサイトからダウンロードし、PCにインストールして起動しておきます。これにより、ローカルでDockerコンテナを扱えるようになります。

前提知識：Docker環境が正常に動作し、docker run hello-worldなどのコマンドが実行できることを確認しておきましょう。

ステップ3：アプリケーションのコンテナ化 (DockerfileとWAR)

Spring BootアプリケーションをWAR形式でビルドし、それをTomcatが動作するDockerイメージに格納します。これにより、本番環境とほぼ同じ形式でアプリケーションを実行できます。

1. Spring BootプロジェクトのWAR化:

   pom.xmlの<packaging>をwarに変更し、spring-boot-starter-tomcatおよびtomcat-embed-jasperのスコープをprovidedに設定します。

   メインアプリケーションクラス（例: MyJspWebappNeoApplication.java）をSpringBootServletInitializerを継承するように変更し、configureメソッドをオーバーライドします。

   JSPファイルはsrc/main/webapp/WEB-INF/jsp/配下に配置します。

2. WARファイルのビルド:

   プロジェクトのルートディレクトリでコマンドラインからmvn clean installを実行し、targetフォルダにWARファイル（例: my-jsp-webapp-neo-0.0.1-SNAPSHOT.war）を生成します。

3. Dockerfileの作成:

   プロジェクトのルートに以下の内容でDockerfileを作成します。これにより、TomcatイメージをベースにWARファイルをデプロイしたアプリケーションイメージがビルドされます。

   
   # ベースイメージとしてTomcat 10 (Java 17) を使用
   FROM tomcat:10-jdk17-temurin
   
   # Dockerイメージ作成者の情報（任意）
   LABEL maintainer="your.email@example.com"
   
   # ビルドされたWARファイルをTomcatのwebappsディレクトリにコピー
   # ファイル名は実際のWARファイル名に合わせてください (例: my-jsp-webapp-neo-0.0.1-SNAPSHOT.war)
   COPY target/my-jsp-webapp-neo-0.0.1-SNAPSHOT.war /usr/local/tomcat/webapps/my-jsp-webapp-neo.war
   
   # Tomcatのデフォルトポート8080を公開
   EXPOSE 8080
               

ステップ4：データベースのコンテナ化 (Docker Compose)

アプリケーションとデータベースの複数のコンテナを効率的に管理するために、Docker Composeを使用します。

1. docker-compose.ymlの作成:

   プロジェクトのルートに以下の内容でdocker-compose.ymlファイルを作成します。これにより、アプリケーションコンテナとMySQLコンテナを同時に定義・起動できます。

   
   version: '3.8'
   
   services:
     app:
       build: .
       ports:
         - "8080:8080"
       depends_on:
         - db
       environment:
         # アプリケーションがDBに接続するための設定（application.propertiesに相当）
         SPRING_DATASOURCE_URL: jdbc:mysql://db:3306/your_database?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Tokyo
         SPRING_DATASOURCE_USERNAME: your_user
         SPRING_DATASOURCE_PASSWORD: your_password
   
     db:
       image: mysql:8.0
       container_name: my-app-mysql
       environment:
         MYSQL_ROOT_PASSWORD: root_password
         MYSQL_DATABASE: your_database
         MYSQL_USER: your_user
         MYSQL_PASSWORD: your_password
       volumes:
         - db_data:/var/lib/mysql
       ports:
         - "3307:3306" # ホストから3307ポートでアクセス
   
   volumes:
     db_data:
               

   注意：your_database, your_user, your_password, root_password はご自身の設定に合わせてください。

2. Docker環境の起動:

   docker-compose.ymlがあるディレクトリでコマンドラインからdocker compose up -dを実行します。これにより、アプリケーションコンテナとMySQLコンテナが同時に起動します。

   アプリケーションはhttp://localhost:8080/my-jsp-webapp-neo/helloでアクセス可能です。

ステップ5：JUnitによるテストとCI/CDパイプラインの導入

コードの品質を保証し、開発プロセスを自動化するために、JUnitテストとCI/CDパイプラインを導入します。

1. JUnitテストの実装:

   src/test/java/com/example/myjspwebapp/配下にHelloWorldControllerTest.javaのようなテストクラスを作成し、コントローラーの動作を検証する単体テストを記述します。

   
   package com.example.myjspwebapp;
   
   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.test.web.servlet.MockMvc;
   
   import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
   import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
   import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.view;
   import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.model;
   import static org.hamcrest.Matchers.containsString;
   
   @WebMvcTest(HelloWorldController.class)
   public class HelloWorldControllerTest {
   
       @Autowired
       private MockMvc mockMvc;
   
       @Test
       public void testHelloPage() throws Exception {
           mockMvc.perform(get("/hello"))
               .andExpect(status().isOk())
               .andExpect(view().name("hello"))
               .andExpect(model().attribute("message", containsString("Hello World")));
       }
   }
               

   テストはEclipseから「Run As」>「JUnit Test」で実行できるほか、コマンドラインからmvn testでも実行できます。

2. CI/CDパイプラインの導入 (GitHub Actionsの例):

   プロジェクトをGitHubリポジトリにプッシュし、リポジトリのルートに.github/workflows/main.ymlファイルを作成します。これにより、コードがプッシュされるたびに自動でビルド、テスト、Dockerイメージのビルドが実行されます。

   
   name: Spring Boot CI/CD Pipeline for MVP
   
   on:
     push:
       branches:
         - main # mainブランチへのプッシュをトリガー
   
   jobs:
     build-and-test:
       runs-on: ubuntu-latest
   
       steps:
         - name: Checkout code
           uses: actions/checkout@v4
   
         - name: Set up JDK 17
           uses: actions/setup-java@v4
           with:
             java-version: '17'
             distribution: 'temurin'
             cache: maven
   
         - name: Build with Maven and run unit tests
           run: mvn -B clean install # WARビルドとJUnitテストを実行
   
         - name: Build Docker image (for app)
           run: |
             docker build -t my-jsp-webapp-neo:${{ github.sha }} .
             docker tag my-jsp-webapp-neo:${{ github.sha }} my-jsp-webapp-neo:latest
   
         # (オプション) Docker Hubなどのレジストリへプッシュする場合は以下のコメントアウトを外す
         # - name: Log in to Docker Hub
         #   uses: docker/login-action@v3
         #   with:
         #     username: ${{ secrets.DOCKER_USERNAME }}
         #     password: ${{ secrets.DOCKER_PASSWORD }}
         # - name: Push Docker image
         #   run: |
         #     docker push my-jsp-webapp-neo:${{ github.sha }}
         #     docker push my-jsp-webapp-neo:latest
   
         - name: Upload WAR artifact
           uses: actions/upload-artifact@v4
           with:
             name: my-jsp-webapp-neo-war
             path: target/*.war
               

   この設定により、コード変更がGitHubにプッシュされるたびに、自動でビルドとテストが実行され、成功すればDockerイメージがビルドされます。これにより、MVP開発における品質保証と迅速なフィードバックループが実現します。

まとめ：最小投資で最大のリターンを

本記事では、MVP開発を加速させるための開発環境構築の全体像を、具体的なステップと実践例を交えて解説しました。

「Eclipse/Spring Boot」による迅速なアプリケーション開発から、「Docker」による本番環境に限りなく近いローカル環境の再現、そして「JUnit」による品質保証と「CI/CDパイプライン」による自動化まで、一連の流れを理解いただけたかと思います。

MVP開発は、単にコストを抑えるだけでなく、市場のニーズを素早く捉え、真に価値ある製品を生み出すための戦略です。このガイドを参考に、あなたのアイデアを高速で形にし、市場での成功を掴み取るための第一歩を踏み出してください。

次の行動を促す

この記事があなたのMVP開発の助けになったなら幸いです。ぜひ、以下の行動を通じて、さらなる学習と実践を深めてください。

• この記事で紹介した手順を実際に試し、あなた自身のMVP開発環境を構築してみましょう。
• GitHubリポジトリでコードをフォークし、独自の機能を開発してみてください。
• 本サイトでは、Spring BootやDockerに関するより詳細な技術記事も公開しています。

Twitter (X) で @[あなたのTwitterアカウント名] をフォローして、最新の技術情報や開発のヒントを受け取りましょう！
この記事をSNSでシェアして、あなたの開発コミュニティにも貢献してください。