☕

Gradle で Tomcat を自動管理！開発コンテナで実現する Java Web 開発

に公開
Docker
Gradle
Java
Tomcat
dev container
tech

はじめに

Java で Web アプリを開発する際、多くの開発者が環境構築の複雑さに直面します。JDK のバージョン管理、Gradle や Maven といったビルドツールの設定、そして Tomcat や Jetty といったアプリケーションサーバーの準備。チーム全員がこれらの環境を寸分違わず揃えるのは、手間のかかる作業です。

もし、リポジトリをクローンして VS Code で開くだけで、誰でも同じサーバー実行環境が手に入るとしたらどうでしょうか？

この記事では、そのモダンな解決策として「開発コンテナ (Dev Containers)」と「Gradle Cargo 2026 Plugin」を組み合わせたプロジェクト gradle-cargo-2026 を紹介します。さらに、mise や SDKMAN! といったバージョンマネージャーを開発コンテナ内で効果的に共存させる方法も解説します。このアプローチを使えば、Java のバージョン管理からアプリケーションサーバーの起動まで、開発に必要なすべてを Gradle タスク一つで完結させることができます。面倒な手作業での環境構築は、もう必要ありません。

gradle-cargo-2026 プロジェクト

このアイデアをすぐに試せるように、設定済みの開発コンテナプロジェクト gradle-cargo-2026 を用意しました。次の GitHub リポジトリで公開しています。

ローカルで使えるようにするには次のようにします。

curl -L -o dcfwd-main.zip https://github.com/hiro345g/dcfwd/archive/refs/heads/main.zip
unzip dcfwd-main.zip
mv dcfwd-main/gradle-cargo-2026 .
rm -rf dcfwd-main dcfwd-main.zip

このプロジェクトの核心は次の点にあります。

  • Gradle でアプリケーションサーバーも管理

この実現には Codehaus Cargo を利用しています。Cargo というと Rust のパッケージマネージャーを思い浮かべるかもしれませんが、Java では別物です。これを使うと、Tomcat のダウンロード、配置、起動、停止といった一連の作業が簡単にできるようになります。これを Gradle でタスクとして簡単に使えると自動化ができるようになります。

そのためのプラグインとして gradle-cargo-plugin がありました。有名だったのですが、現在メンテナンスがされていなくて、GitHub の Issue でも反応がない状態となっています。また、Gradle 9 では、このプラグインがそのままでは動作しなくなっています。

筆者は、これを使っていて、Gradle 9 でも使えるようにしたかったので、個人的にフォークして修正して使っていました。使えるようになると、やはり Maven のリポジトリに登録した方が使いやすいので、gradle-cargo-2026-plugin で公開するところまで対応しました。

せっかく、公開までしたので、動作確認も兼ねて、本記事の執筆にあたって利用してみました。やはり、Maven のリポジトリにあると、Gradle から簡単に利用可能となっていいですね。

プロジェクトの構成

gradle-cargo-2026 プロジェクトの構成は次のようになっています。

gradle-cargo-2026/
├── .devcontainer/ ... 開発コンテナ用設定ファイル
│   ├── compose.yaml
│   └── devcontainer.json
├── README.md
├── sample/ ... webapp001 開発時に使う設定ファイルのサンプル
└── webapp001/ ... Tomcat 用 Web アプリのプロジェクトフォルダ
    ├── README.md
    ├── build.gradle
    ├── gradle/
    │   ├── libs.versions.toml
    │   └── wrapper/
    ├── gradle.properties
    ├── gradlew*
    ├── gradlew.bat
    ├── settings.gradle
    └── src/
        ├── dev/
        │   └── context.xml
        └── main/
            ├── java/
            └── webapp/

この開発コンテナの「コア」となるのは、.devcontainer フォルダにある二つの設定ファイルと、webapp001 の build.gradle です。

設定ファイル 説明
devcontainer.json 開発コンテナの基本的な設定や、コンテナ作成後の追加コマンドを定義
compose.yaml Docker Compose の設定ファイルで、コンテナのイメージやボリューム（データの永続化）などを定義
build.gradle アプリのビルド、依存関係の管理、そして Cargo プラグインによるサーバー制御を定義

これらのファイルが連携することで、クリーンで再現性の高い開発環境が実現されます。

設定の解説

なぜこの開発コンテナで、面倒な環境構築なしに Java の Web アプリを開発できるのでしょうか。その秘密は .devcontainer/devcontainer.json、compose.yaml と build.gradle の設定にあります。

devcontainer.json: 開発コンテナ作成後の自動セットアップ

.devcontainer/devcontainer.json ファイルは、開発コンテナの起動動作を細かく制御します。特に重要なのが postCreateCommand プロパティです。これは、コンテナが作成され、初期化された後に自動で実行されるコマンドを定義します。

.devcontainer/devcontainer.json
{
  "name": "gradle-cargo-2026",
  "dockerComposeFile": "./compose.yaml",
  "service": "gradle-cargo-2026",
  "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
  "postCreateCommand": "/bin/bash /workspaces/gradle-cargo-2026/sample/to-dvc-env.sh; sudo chown -R node:node /home/node/.local/state/mise",
  "customizations": {
    "vscode": {
      "settings": {
        "terminal.integrated.defaultProfile.linux": "bash"
      },
      "extensions": [
        "ms-azuretools.vscode-containers",
        "docker.docker",
        "eamodio.gitlens",
        "donjayamanne.githistory",
        "mhutchie.git-graph"
      ]
    }
  }
}

この postCreateCommand では、いくつかの重要な設定が行われています。実行しているコマンドは次のとおりです。

/bin/bash /workspaces/gradle-cargo-2026/sample/to-dvc-env.sh
sudo chown -R node:node /home/node/.local/state/mise

to-dvc-env.sh は、Java プロジェクトのビルドに必要な設定ファイル（例えば .classpath や .project など）を sample ディレクトリから webapp001 ディレクトリへコピーするためのシェルスクリプトを実行します。これにより、VS Code が Java プロジェクトとして適切に認識し、開発をスムーズに進めるための準備が整います。

sudo chown で mise 用のフォルダの所有者を node ユーザーにしています。mise は、ユーザーのホームディレクトリ配下の特定のパスに設定やキャッシュを保存します。

今回用意した開発コンテナ内では通常 node ユーザーで作業を行います。ここで、開発コンテナ用のマウント指定により、自動的にディレクトリが用意される場合に、この所有者が node ユーザーでない場合があります。

そのままでは mise が正常に動作しなくなってしまうので、このコマンドで、mise の状態管理ディレクトリである /home/node/.local/state/mise の所有者を確実に node ユーザーにしておきます。

こうすることで、mise が期待通りに動作するための権限問題を解決しています。

これらの自動化された設定により、開発者は手動でこれらの煩雑な初期設定を行うことなく、すぐに開発作業に取り掛かることができます。

compose.yaml: ツールの永続化

compose.yaml では、開発環境で使うツール (SDKMAN! や mise) のデータを Docker の名前付きボリュームに保存する設定を行っています。これにより、一度インストールしたツールは開発コンテナを再作成しても消えることがなく、常に同じ環境を維持できます。

.devcontainer/compose.yaml
name: gradle-cargo-2026
services:
  gradle-cargo-2026:
    image: hiro345g/dvc:jdk-202601
    container_name: gradle-cargo-2026
    hostname: gradle-cargo-2026
    tty: true
    user: 1000:1000
    volumes:
      # gradle-cargo-2026 の Docker Compose プロジェクト用フォルダを
      # /workspaces/gradle-cargo-2026 にバインドマウント
      - type: bind
        source: ..
        target: /workspaces/gradle-cargo-2026
      # mise 用フォルダを Docker ボリュームへマウント
      - type: volume
        source: share-mise
        target: /home/node/.local/share/mise
      # mise trust の情報を保存するフォルダを Docker ボリュームへマウント
      - type: volume
        source: state-mise
        target: /home/node/.local/state/mise
      # SDKMAN! 用の保存するフォルダを Docker ボリュームへマウント
      - type: volume
        source: sdkman
        target: /usr/local/sdkman
      # gradle-cargo-2026 内での /home/node/workspace を Docker ボリュームへマウント
      - type: volume
        source: home-node-workspace
        target: /home/node/workspace
    networks:
      dvc-net:

volumes:
  share-mise:
    name: gradle-cargo-2026-share-mise
  state-mise:
    name: gradle-cargo-2026-state-mise
  sdkman:
    name: gradle-cargo-2026-sdkman
  home-node-workspace:
    name: gradle-cargo-2026-home-node-workspace

networks:
  dvc-net:
    name: gradle-cargo-2026-net

この設定は、mise と Docker で始める開発環境構築 2025年10月版 で紹介したテクニックと同じです。これで、mise でインストールしたツールや SDKMAN! でインストールした Java のバージョンなどが永続化されるため、環境の再現性が高まります。

なお、開発コンテナについては自分で作成した開発コンテナ用のイメージを使っています。イメージは Docker Hub で公開していて、次の GitHub で公開しているコードを使ってイメージを作成しています。

ベースが mcr.microsoft.com/devcontainers/typescript-node の開発コンテナ用イメージで、便利なフィーチャーも組み合わせてあります。詳細は GitHub のプロジェクトにある README.md を参照してください。

build.gradle: Gradle によるサーバー制御の自動化

このプロジェクトの webapp001/build.gradle がアプリ開発におけるコア部分となります。ここで Gradle Cargo 2026 Plugin を利用して、Tomcat サーバーの管理を自動化しています。

webapp001/build.gradle
plugins {
    alias(libs.plugins.cargo)
    id 'war'
}

// (リポジトリや依存関係の定義)
// ...

cargo {
    containerId = 'tomcat10x'
    port = 8080

    deployable {
        context = 'ROOT'
    }

    local {
        homeDir = installTomcat.outputs.files.singleFile
        outputFile = file("$homeDir/logs/server.log")
    }
}


task installTomcat(type: Copy) {
    from { zipTree(configurations.tomcat.singleFile) }
    into "$buildDir/tomcat-home"
    // (ファイルパスの調整処理)
    // ...
}

afterEvaluate {
    cargoStartLocal.dependsOn installTomcat
    cargoRedeployLocal.dependsOn assemble
}

この設定についてポイントとなる点を表にしました。

設定のポイント 説明
plugins{alias(libs.plugins.cargo)} io.github.hiro345g.cargo-2026 のバージョン 1.0.0 を有効化
cargo { ... } Cargo プラグインの設定ブロック
installTomcat タスク dependencies で定義した Tomcat をインストールするカスタムタスク
cargoStartLocal.dependsOn ... cargoStartLocal タスクが installTomcat タスクに依存することを定義

plugins { alias(libs.plugins.cargo) } は、gradle/libs.version.toml にエリアスが指定されていて、[plugins] の cargo に指定されたものが実体となります。

cargo { ... } は、Cargo プラグインの設定をするブロックで、containerId、port、deployable.context、local.homeDir を指定しています。

containerId には使用するコンテナを指定します。ここで指定している tomcat10x は Tomcat 10 系を使うことを意味しています。指定する値は CodeHaus Cargo のサイトを参照しています。Tomcat 10.x については https://codehaus-cargo.github.io/cargo/Tomcat+10.x.html に説明があります。

port には Tomcat が HTTP 接続を待機するポート番号を指定します。ここでは 8080 と Tomcat のデフォルト値なので指定しなくても良いのですが、明示的に設定があると使用ポート番号がわかりやすくなるので、設定してあります。これで、Tomcat が起動してから HTTP で 8080 ポートへ接続できるようになります。

deployable.context には Web アプリをデプロイするパスを指定します。ここではルートパス（/）を意味する ROOT を指定します。

local.homeDir には Tomcat をインストールするディレクトリを指定します。ここでは installTomcat タスクの出力先を指定します。また、ログ出力先を "$homeDir/logs/server.log" と指定します。

他にも指定可能なプロパティはあります。詳細は https://github.com/hiro345g/gradle-cargo-2026-plugin?tab=readme-ov-file#extension-properties に説明があります。

installTomcat タスクは、gradle/libs.version.toml で指定されている tomcat のバージョンと対応する zip ファイルをダウンロードし、ビルドディレクトリ内に展開するカスタムタスクです。

cargoStartLocal.dependsOn installTomcat は、サーバーを起動するタスクである cargoStartLocal について、これが実行される前に、必ず installTomcat タスクが実行されるという依存関係を定義しています。

cargoRedeployLocal.dependsOn assemble は、ローカルに Web アプリをデプロイするタスクである cargoRedeployLocal について、これが実行される前に、必ず assemble タスクが実行されて、コードのコンパイルがされるという依存関係を定義しています。

これらの設定により、開発者は Tomcat がインストールされているかどうかを気にする必要がありません。Gradle がすべて自動で準備してくれます。

その他にも、Tomcat の起動、停止用に start、stop タスクを用意しています。また、Tomcat をデバッグモードで起動、それを停止ができるように start-debug、stop-debug タスクを用意しています。

Gradle のタスク

Gradle を使うにあたっては、どんなタスクがあるのか、どういった依存関係にあるのかを確認する方法を知っておくと役に立ちます。

対応しているタスクの一覧を表示するには tasks タスクを実行します。

./gradlew tasks

次に、cargo 関連のタスクの部分だけ抽出して提示しておきます。

node ➜ /workspaces/gradle-cargo-2026/webapp001 $ ./gradlew  tasks
（略）
Deployment tasks
----------------
cargoConfigureLocal - Configures the local container.
cargoDeployRemote - Deploys a deployable to remote container.
cargoRedeployLocal - Redeploys a deployable on local container.
cargoRedeployRemote - Redeploys a deployable to remote container.
cargoRunLocal - Starts the container, deploys a deployable and waits for the user to press CTRL + C to stop.
cargoStartLocal - Starts the container, deploys a deployable and then do other tasks (for example, execute tests).
cargoStopLocal - Stops local container.
cargoUndeployRemote - Undeploys a deployable from remote container.
start - Starts the container, deploys a deployable and then do other tasks (for example, execute tests).
start-debug - Starts the container, deploys a deployable and then do other tasks (for example, execute tests).
stop - Stops local container.
stop-debug - Stops local container.
（略）

Gradle では、あるタスクを実行すると、自動で依存関係にあるタスクも実行されます。その情報を確認する方法はいくつかありますが、単純なのは --dry-run オプションを指定することです。

このオプションを使って、例えば start タスクが依存するタスクを確認すると、次のようになります。

node ➜ /workspaces/gradle-cargo-2026/webapp001 $ ./gradlew start --dry-run
Reusing configuration cache.
:installTomcat SKIPPED
:compileJava SKIPPED
:processResources SKIPPED
:classes SKIPPED
:war SKIPPED
:start SKIPPED

BUILD SUCCESSFUL in 483ms
Configuration cache entry reused.

この結果から、start タスクは次の順にタスクが実行されることがわかります。

  1. installTomcat
  2. compileJava
  3. processResources
  4. classes
  5. war
  6. start

最初に Tomcat がインストールされ、Java プログラムのコンパイル、リソースの処理、クラスファイルの処理、war ファイルの作成という順で処理が実行されています。そして、最後に war ファイルがローカルデプロイされた状態で Tomcat が起動します。

使い方

アプリ開発環境の準備

それでは、実際にこの開発コンテナを使ってみましょう。次の3ステップで開発環境が準備できます。

  1. 開発コンテナ用イメージのプル
  2. 開発コンテナの起動
  3. SDKMAN! による Java バージョンの設定

開発コンテナ用イメージのプルは飛ばすこともできますが、時間がかかるのでターミナルで先に実行しておくと良いです。

docker image pull hiro345g/dvc:jdk-202601

イメージのプルができたら、gradle-cargo-2026 のフォルダを VS Code で開きます。Reopen in Container の通知が表示されたら、これをクリックします。

すると、.devcontainer/devcontainer.json の設定に従って開発コンテナ用のイメージがビルドされます。それから自動で開発コンテナーが起動し、これをアタッチした VS Code の画面が表示されます。

開発コンテナのターミナルを開くと /workspace/gradle-cargo-2026 がカレントとなるはずです。cd コマンドで webapp001 ディレクトリへ移動して作業を進めます。次の例では確実に目的のディレクトリへ移動するために絶対パスを使っていますが cd webapp001 でも大丈夫なはずです。

cd /workspace/gradle-cargo-2026/webapp001

webapp001 ディレクトリには次の .sdkmanrc ファイルが置かれています。

java=17.0.17-tem

開発コンテナのターミナルを開いたら、sdk env を実行すると、SDKMAN! がこのファイルを自動で読み込み、指定されたバージョンの Java を有効にします。指定された JDK がインストールされていない場合は自動でインストールして有効にします。

sdk env

実行例は次のようになります。ここでは JDK のバージョンを確認するために java -version も実行しています。

$ sdk env

Using java version 17.0.17-tem in this shell.
$ java -version
openjdk version "17.0.17" 2025-10-21
OpenJDK Runtime Environment Temurin-17.0.17+10 (build 17.0.17+10)
OpenJDK 64-Bit Server VM Temurin-17.0.17+10 (build 17.0.17+10, mixed mode, sharing)

以上で、準備作業はおしまいです。

Tomcat の起動と停止

Tomcat を起動するには、webapp001 ディレクトリで start タスクを実行します。

./gradlew start

このコマンド一つで、Gradle は以下の処理をすべて自動で行います。build.gradle で、cargoStartLocal タスクは installTomcat タスクに依存する定義をしたことを思い出してください。

  • Tomcat 10 のダウンロードとインストール (installTomcat タスク)
  • Java ソースコードのコンパイル
  • WAR (Web Application Archive) ファイルの作成
  • Tomcat の起動と WAR ファイルのデプロイ (start タスク)

Tomcat が起動したらアプリの動作確認をするために、http://localhost:8080 へアクセスします。

Web ブラウザで http://localhost:8080 にアクセスしてください。index.jsp の内容が表示されます。

Hello JSP!

Apache Tomcat/10.1.49

    java.vm.name: OpenJDK 64-Bit Server VM
    java.vm.vendor: Eclipse Adoptium
    java.vm.version: 17.0.17+8

開発コンテナをアタッチした VS Code のターミナルから curl を使って確認することもできます。

$ curl -L -v http://localhost:8080/
*   Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080
> GET / HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/8.5.0
> Accept: */*
>
< HTTP/1.1 200
< Set-Cookie: JSESSIONID=...; Path=/; HttpOnly
< Content-Type: text/html;charset=UTF-8
< Content-Length: 213
< Date: ...
<
<html>
<body>
<p>Hello JSP!</p>
<p>Apache Tomcat/10.1.49</p>
<ul>
    <li>java.vm.name: OpenJDK 64-Bit Server VM</li>
    <li>java.vm.vendor: Eclipse Adoptium</li>
    <li>java.vm.version: 17.0.17-tem</li>
</ul>
</body>
</html>

サーバーを停止するには、以下のコマンドを実行します。

./gradlew stop

なお、Tomcat 関連のログを確認する場合は次のファイルを調べます。これらのログは開発時にも確認することになるので、パスを覚えておくようにしましょう。

パス 説明
./build/tomcat-home/logs/server.log Tomcat 自体のログ
/tmp/cargo/conf/logs/*.txt Web アプリへのアクセスログ

VS Code 用の開発環境

Tomcat の起動と停止ができるようになったら、VS Code を使った開発をしてみましょう。

まず、開発コンテナのターミナルで次のコマンドを実行してワークスペースファイルを用意します。

cp /workspace/gradle-cargo-2026/sample/webapp001.code-workspace \
   /workspace/gradle-cargo-2026/webapp001/

ワークスペースファイルを使って VS Code を起動します。

code /workspace/gradle-cargo-2026/webapp001/webapp001.code-workspace

これで、webapp001 を開発するための VS Code の画面が表示され、必要な拡張機能の自動インストールの許可を求める通知が表示されます。許可すると、ここに含まれる Gradle 用の拡張機能がインストールされます。すると、Gradle の設定ファイルが自動で認識されて Gradle の Java プロジェクトとして扱われるようになります。

以上で、開発環境の用意が終わりました。これで、Web アプリの開発ができます。

webapp001 アプリの開発

それでは、webapp001 アプリケーションの具体的な開発サイクル（デプロイ、動作確認、デバッグ）を見ていきましょう。

アプリの再デプロイ (ホットデプロイ)

./gradlew start で一度 Tomcat を起動した後は、コードを修正するたびにサーバーを再起動するのは非効率です。Gradle Cargo 2026 Plugin は、アプリケーションのホットデプロイ（サーバーを停止せずにアプリケーションを更新すること）をサポートしています。

例えば、src/main/webapp/index.jsp を修正したとします。その変更を稼働中の Tomcat に反映させるには、以下のコマンドを実行します。

./gradlew cargoRedeployLocal

このコマンドは、war ファイルを再ビルドし、Tomcat に再デプロイします。これにより、サーバーを停止することなく、最新のコード変更を確認できます。

アプリの動作確認

http://localhost:8080/app にアクセスすると、ServletApp.java プログラムの実行結果が表示されます。

$ curl -L -v http://localhost:8080/app
*   Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080
> GET /app HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/8.5.0
> Accept: */*
>
< HTTP/1.1 200
< Content-Type: text/html;charset=utf-8
< Content-Length: 78
< Date: ...
<
<html><body>
<p>Hello, webapp001</p>
Apache Tomcat/10.1.49
</body></html>

コードを修正してから cargoRedeployLocal タスクを実行し、動作確認すると変更が反映されます。

アプリのデバッグ

次に、ブレークポイントを設定してアプリケーションをデバッグする方法を見ていきましょう。

デバッグモードの Tomcat 起動と停止

アプリケーションをデバッグするには、Tomcat をデバッグモードで起動する必要があります。このプロジェクトでは、そのためのカスタムタスク start-debug と stop-debug を build.gradle に用意しています。

start-debug タスクは、デバッガーが接続するためのポート (この例では 5005) を開けて Tomcat を起動します。

./gradlew start-debug

なお、停止する際は stop-debug タスクを指定します。

./gradlew stop-debug

VS Code でデバッグ

VS Code でデバッグするには、デバッグモードで起動している Tomcat へ、VS Code からデバッガーをアタッチします。

具体的な手順は次のようになります。ここではすでに Tomcat にアプリはデプロイされていて、デバッグモードで起動しているとします。

  1. VS Code でデバッグするプログラムのファイルを開く
  2. VS Code の「実行とデバッグ」画面を表示
  3. ブレークポイントの設定
  4. デバッグの開始
  5. 動作確認

VS Code のアクティビティバーで「エクスプローラー」のアイコンをクリックし、ファイルの一覧を表示します。ここでは、Servlet.java をデバッグすることにして、src/main/java/internal/dev/ServletApp.java ファイルを開きます。

それから、VS Code のアクティビティバーで「実行とデバッグ」のアイコンをクリックし、「実行とデバッグ」の画面を表示します。

続いて、エディタ画面に表示されている Servlet.java 内の doGet メソッドを探します。メソッドを見つけたら、その行番号の左側をクリックしてブレークポイントを設定します。赤い丸印が表示されれば設定完了です。

VS Code のプライマリ サイドバーの「実行とデバッグ」画面の上部に、ドロップダウンリストがあります。そこから「Debug」を選択し、緑色の再生ボタン ▶️ をクリックします。すると、VS Code のデバッグコンソールが有効になり、デバッグが開始されます。

このとき指定する Debug というデバッグ用の構成は、webapp001.code-workspace の launch で設定してあるものです。

{
    // 略
    "launch": {
        "version": "0.2.0",
        "configurations": [
            {
                // `./gradlew start-debug` 後に接続すること
                "type": "java",
                "name": "Debug",
                "request": "attach",
                "hostName": "localhost",
                "port": 5005
            }
        ]
    }
}

ここでデバッグ対象としている ServletApp は web.xml により /app パスにマッピングされています。このパスに対応する URL へアクセスするとデバッグができます。

具体的には curl コマンドか Web ブラウザで http://localhost:8080/app にアクセスします。

curl -L -v http://localhost:8080/app

リクエストがサーブレットに到達すると、VS Code は ServletApp.java に設定したブレークポイントで実行を一時停止します。

これにより、変数の値を確認したり、ステップ実行でコードの動きを追ったりすることができます。

VS Code の画面上部にあるデバッグ用のアイコンメニューにあるアイコンなどを使って処理を続行させたり停止させたりできます。プライマリ サイドバーで変数の値を確認したり、スタックの状態を確認できます。

デバッグを終了するには、VS Code の画面上部にあるデバッグ用のアイコンメニューの中から「切断」をクリックします。それから、Tomcat を停止します。

./gradlew stop-debug

Java プロジェクト用設定ファイル

ここまできちんと説明していませんが、VS Code で使われる Java プロジェクト用設定ファイルのサンプルが sample フォルダにあります。これらは、元々は Eclipse IDE 用の設定ファイルですが、VS Code の拡張機能（Language Support for Java by Red Hat）も内部でこれらを参照して、ライブラリのパスやコンパイルルールを管理しています。

webapp001 プロジェクト直下に置くファイルは次の2つがあります。

ファイル名 説明
.classpath クラスパス設定ファイル。ソースコードの場所、ビルド後の出力先、依存する外部ライブラリ（JARファイル）やJREのパスを定義
.project プロジェクト構成ファイル。プロジェクト名や、Javaプロジェクトであることを示す性質（Nature）、ビルド時に実行されるビルダーの設定を保持

webapp001/.settings に置くファイルは次の3つがあります。

ファイル名 説明
org.eclipse.jdt.core.prefs Javaコンパイラ設定ファイル。Javaのバージョンや、警告・エラーのしきい値、コードのエンコーディング設定などを保存
org.eclipse.wst.common.component モジュール構成ファイル。主にWebプロジェクトにおいて、どのリソースをWebアプリケーションのどのパスにデプロイするかを定義
org.eclipse.wst.common.project.facet.core.xml プロジェクト・ファセット設定ファイル。プロジェクトの機能（動的Web、Java、JavaScriptなど）とそのバージョンを管理

これらは、開発コンテナで利用するときにそのまま使える内容となっています。ファイル名を実際のものと同じにすると、VS Code の Java プロジェクト用拡張機能が誤動作をするため、対応関係がファイル名から推測できる別名ファイルにしてあります。

また、開発コンテナを使う場合は、これらを自動で使うように devcontainer.json 内で次のコマンドを自動で実行しています。

/bin/bash /workspaces/gradle-cargo-2026/sample/to-dvc-env.sh

これらのファイルの内容に影響がある設定変更をした場合は、sample 内の対応するファイルを置き換える必要があります。

また、開発コンテナを使わないでネイティブな環境の VS Code で、このプロジェクトの開発をする場合は、これらのファイルを自分で用意する必要があります。

VS Code を使う場合の設定ファイルを生成するには、eclipse タスクと eclipseWtp タスクを実行します。

./gradlew eclipse --no-configuration-cache
./gradlew eclipseWtp --no-configuration-cache

このとき、余計なフォルダ bin が作成されたら削除しておきます。

rm -fr ./bin

生成されたファイルについては VS Code に合わせて一部修正が必要です。具体的には次の sed コマンドで置換できます。

sed -i 's%facet="jst.web" version="2.4"%facet="jst.web" version="6.0"%' .settings/org.eclipse.wst.common.project.facet.core.xml
sed -i 's%source-path="src/main/java"%source-path="build/classes/java/main"%' .settings/org.eclipse.wst.common.component
sed -i 's%<classpathentry kind="output" path="bin/default"/>%<classpathentry kind="output" path="build/default"/>%' .classpath
sed -i 's%<classpathentry output="bin/main" kind="src" path="src/main/java">%<classpathentry output="build/classes/java/main" kind="src" path="src/main/java">%' .classpath

まとめ

この記事では、開発コンテナと Gradle Cargo 2026 Plugin を組み合わせることで、Java Web アプリの開発環境構築を劇的に簡素化する方法を紹介しました。この方法には次の3つの利点があります。

  • 再現性の高い環境
  • サーバー管理の自動化対応
  • シンプルなワークフロー

開発コンテナにより、再現性の高い環境が簡単に用意でき、誰でも同じツール、同じバージョンの環境を即座に利用できます。

Docker コンテナより制限が少ないネイティブ環境の Tomcat の管理が、Gradle タスクとして定義されることで自動化対応が可能となっています。ここでは、開発者が Tomcat インストールをしなくても起動用タスクを実行するだけで、自動でインストールできるように設定できました。

また、複雑な環境構築手順を踏まなくても、「開発コンテナを起動して、sdk env コマンドと ./gradlew cargoStartLocal コマンドを実行する」というシンプルなワークフローで、すぐに開発を開始できる環境を用意できました。

このアプローチは、チーム開発の効率を上げるだけでなく、新しいメンバーがプロジェクトに参加する際の障壁を大きく下げてくれます。VS Code を使った Java の Web アプリ開発環境の構築について悩まされている方は、ぜひこの gradle-cargo-2026 プロジェクトを参考に、快適な開発環境を手に入れてください。

Discussion