Struts-2-quick-guide
基本的なMVCアーキテクチャ
- [。underline] #M＃* odel * [。underline] #V＃* iew * [。underline] #C＃* ontrollerまたは *MVC は一般的に呼ばれているように、ソフトウェア設計パターンですWebアプリケーションの開発用。 モデルビューコントローラーパターンは、次の3つの部分で構成されています-
- モデル-データの維持を担当するパターンの最低レベル。
- 表示-データのすべてまたは一部をユーザーに表示します。
- Controller -モデルとビュー間の相互作用を制御するソフトウェアコード。
MVCは、アプリケーションロジックをユーザーインターフェイスレイヤーから分離し、懸念の分離をサポートするため、人気があります。 ここで、コントローラはアプリケーションに対するすべてのリクエストを受信し、モデルと連携してビューに必要なデータを準備します。 ビューは、コントローラーによって準備されたデータを使用して、最終的な提示可能な応答を生成します。 MVC抽象化は、次のようにグラフィカルに表現できます。
Struts MVC、title = "Struts MVC"
モデル
モデルは、アプリケーションのデータの管理を担当します。 ビューからの要求に応答し、コントローラーからの指示にも応答して、それ自体を更新します。
景色
これは、データを提示するというコントローラーの決定によってトリガーされる、特定の形式でのデータの提示を意味します。 これらは、JSP、ASP、PHPなどのスクリプトベースのテンプレートシステムであり、AJAXテクノロジーとの統合が非常に簡単です。
コントローラー
コントローラーは、ユーザー入力に応答し、データモデルオブジェクトで相互作用を実行します。 コントローラーは入力を受け取り、入力を検証してから、データモデルの状態を変更するビジネスオペレーションを実行します。
*Struts2* はMVCベースのフレームワークです。 今後の章では、Struts2内でMVC方法論をどのように使用できるかを見てみましょう。Struts 2-概要
*Struts2* は、MVCデザインパターンに基づく人気のある成熟したWebアプリケーションフレームワークです。 Struts2は、Struts 1の新しいバージョンではなく、Strutsアーキテクチャの完全な書き直しです。Webworkフレームワークは当初Strutsフレームワークをベースとして開始され、その目標は、開発者がWeb開発を容易にするためにStrutsに基づいて強化および改善されたフレームワークを提供することでした。
しばらくして、WebworkフレームワークとStrutsコミュニティが手を組み、有名なStruts2フレームワークを作成しました。
Struts 2フレームワークの機能
Struts2を検討することを強制するかもしれないすばらしい特徴のいくつかはここにあります-
- * POJOフォームとPOJOアクション*-Struts2は、Strutsフレームワークの不可欠な部分であったアクションフォームを廃止しました。 Struts2では、任意のPOJOを使用してフォーム入力を受け取ることができます。 同様に、任意のPOJOをActionクラスとして表示できるようになりました。
- タグのサポート-Struts2は、開発者がより少ないコードを書くことを可能にするフォームタグと新しいタグを改善しました。
- * AJAXサポート*-Struts2はWeb2.0テクノロジーによる引き継ぎを認識し、AJAXタグを作成することで製品にAJAXサポートを統合しました。この機能は標準のStruts2タグに非常に似ています。
- 簡単な統合-Spring、Tiles、SiteMeshなどの他のフレームワークとの統合は、Struts2で利用できるさまざまな統合により簡単になりました。
- テンプレートのサポート-テンプレートを使用してビューを生成するためのサポート。
- プラグインのサポート-Struts2のコア動作は、プラグインを使用することで強化および拡張できます。 Struts2には多くのプラグインが利用可能です。
- プロファイリング-Struts2は、アプリケーションをデバッグおよびプロファイルするための統合プロファイリングを提供します。 これに加えて、Strutsは組み込みのデバッグツールの助けを借りて統合デバッグも提供します。
- タグの変更が簡単-Struts2のタグマークアップは、Freemarkerテンプレートを使用して微調整できます。 これには、JSPまたはJavaの知識は必要ありません。 タグを変更するには、HTML、XML、CSSの基本的な知識があれば十分です。
- 少ない設定を促進-Struts2は、さまざまな設定にデフォルト値を使用することで少ない設定を促進します。 Struts2によって設定されたデフォルト設定から逸脱しない限り、何かを構成する必要はありません。
- View Technologies -Struts2は、複数の表示オプション（JSP、Freemarker、Velocity、XSLT）を強力にサポートしています。
上記のリストは Struts 2 のトップ10機能であり、エンタープライズ対応のフレームワークとして機能します。
Struts 2のデメリット
Struts 2には優れた機能のリストが付属していますが、現在のバージョンにはいくつかの制限があります。Struts2にはさらに改善が必要です。 主な点のいくつかがリストされています-
- 大きな学習曲線-MVCをStrutsで使用するには、標準のJSP、サーブレットAPI、および大規模で精巧なフレームワークに慣れる必要があります。
- 不十分なドキュメント-標準のサーブレットおよびJSP APIと比較して、Strutsのオンラインリソースは少なく、多くの初めてのユーザーは、オンラインのApacheドキュメントが混乱し、整理が行き届いていないことに気付きます。
- 透明度が低い-Strutsアプリケーションでは、通常のJavaベースのWebアプリケーションよりも背後で多くのことが行われているため、フレームワークを理解するのが難しくなります。
最後に、優れたフレームワークは、多くの異なる種類のアプリケーションがそれを利用できる一般的な動作を提供する必要があります。
*Struts 2* は、最高のWebフレームワークの1つであり、リッチインターネットアプリケーション（RIA）の開発に広く使用されています。Struts 2-環境設定
最初のタスクは、最小限のStruts 2アプリケーションを実行することです。 この章では、Struts 2で作業を開始するための開発環境を準備する方法について説明します。
すでにマシンにJDK（5 +）、Tomcat、Eclipseがインストールされていると思います。 これらのコンポーネントがインストールされていない場合は、ファーストトラックで指定された手順に従ってください-
ステップ1-Java Development Kit（JDK）のセットアップ
最新バージョンのSDKは、OracleのJavaサイト-https://www.oracle.com/technetwork/java/javase/downloads/indexl[Java SE Downloads]からダウンロードできます。 ダウンロードしたファイルにJDKをインストールする手順があります。指定された手順に従ってセットアップをインストールおよび構成します。 最後に、PATHおよびJAVA_HOME環境変数を設定して、javaおよびjavacを含むディレクトリ、通常はそれぞれjava_install_dir/binおよびjava_install_dirを参照します。
Windowsを実行していて、SDKをC：\ jdk1.5.0_20にインストールしている場合、C：\ autoexec.batファイルに次の行を入力する必要があります。
set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20または、Windows NT/2000/XPで-
- [マイコンピュータ]を右クリックし、[プロパティ]、[詳細設定]、[環境変数]の順に選択します。 次に、PATH値を更新し、[OK]ボタンを押します。
- Unix（Solaris、Linuxなど）では、SDKが/usr/local/jdk1.5.0_20にインストールされており、Cシェルを使用する場合、次を.cshrcファイルに追加します。
Unix（Solaris、Linuxなど）では、SDKが/usr/local/jdk1.5.0_20にインストールされており、Cシェルを使用する場合、次を.cshrcファイルに追加します。
setenv PATH/usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME/usr/local/jdk1.5.0_20または、Borland JBuilder、Eclipse、IntelliJ IDEA、Sun ONE Studioなどの統合開発環境（IDE）を使用する場合は、簡単なプログラムをコンパイルおよび実行して、IDEがJavaをインストールした場所を認識していることを確認します。そうでない場合は、 IDEの特定のドキュメント。
ステップ2-Apache Tomcatのセットアップ
Tomcatの最新バージョンはhttps://tomcat.apache.org/からダウンロードできます。 インストールをダウンロードしたら、バイナリ配布物を便利な場所に解凍します。
たとえば、WindowsのC：\ apache-tomcat-6.0.33、またはLinux/Unixの/usr/local/apachetomcat-6.0.33で、これらの場所を指すCATALINA_HOME環境変数を作成します。
Windowsマシンで次のコマンドを実行してTomcatを起動するか、startup.batをダブルクリックします。
%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-6.0.33\bin\startup.batTomcatはUnix（Solaris、Linuxなど）マシンで次のコマンドを実行することで起動できます-
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-6.0.33/bin/startup.sh正常に起動した後、Tomcatに含まれているデフォルトのWebアプリケーションは、 http：//localhost：8080/ にアクセスして利用できます。 すべてがうまくいけば、それは次の結果を表示する必要があります-
Tomcatの構成と実行に関する詳細情報は、Tomcat Webサイト（https://tomcat.apache.org/）だけでなく、ここに含まれているドキュメントにも記載されています。
Tomcatは、Windowsマシンで次のコマンドを実行することで停止できます-
%CATALINA_HOME%\bin\shutdown
or
C:\apache-tomcat-5.5.29\bin\shutdownTomcatは、Unix（Solaris、Linuxなど）マシンで次のコマンドを実行することで停止できます-
$CATALINA_HOME/bin/shutdown.sh
or
/usr/local/apache-tomcat-5.5.29/bin/shutdown.shステップ3-Eclipse（IDE）のセットアップ
このチュートリアルのすべての例は、Eclipse IDEを使用して記述されています。 お使いのマシンにEclipseの最新バージョンがインストールされていることをお勧めします。
Eclipseをインストールするにはhttps://www.eclipse.org/downloads/から最新のEclipseバイナリをダウンロードします。 インストールをダウンロードしたら、バイナリ配布物を便利な場所に解凍します。
たとえば、WindowsのC：\ eclipse、またはLinux/Unixの/usr/local/eclipseで、最後にPATH変数を適切に設定します。 Eclipseは、Windowsマシンで次のコマンドを実行することで起動できます。または、eclipse.exeをダブルクリックするだけで起動できます
%C:\eclipse\eclipse.exeEclipseは、Unix（Solaris、Linuxなど）マシンで次のコマンドを実行することで起動できます-
$/usr/local/eclipse/eclipse正常に起動した後、すべてが正常であれば、次の結果が表示されます-
ステップ4-Struts2ライブラリのセットアップ
これで問題がなければ、Struts2フレームワークのセットアップに進むことができます。 以下は、Struts2をダウンロードしてマシンにインストールする簡単な手順です。
- Struts2をWindowsにインストールするか、Unixにインストールするかを選択してから、次のステップに進み、Windows用の.zipファイルとUnix用の.tzファイルをダウンロードします。
- [[1]]
- このチュートリアルを書いている時点で、 struts-2.0.14-all.zip をダウンロードしました。ダウンロードしたファイルを解凍すると、C：\ struts-2.2.3内のディレクトリ構造が次のようになります。
2番目のステップは、任意の場所でzipファイルを抽出することです。Windows7マシンの c：\ フォルダーに struts-2.2.3-all.zip をダウンロードして抽出し、すべてのjarファイルを Cに入れます。 ：\ struts-2.2.3 \ lib 。 CLASSPATH変数を適切に設定してください。そうしないと、アプリケーションの実行中に問題が発生します。
Struts 2-アーキテクチャ
高レベルから見ると、Struts2はpull-MVC（またはMVC2）フレームワークです。 Struts2のModel-ViewControllerパターンは、次の5つのコアコンポーネントで実装されています-
行動
インターセプター
バリュースタック/OGNL
結果/結果タイプ
テクノロジーを見る
*Struts 2* は、一部のオーバーラップはありますが、アクションがコントローラーではなくモデルの役割を果たす従来のMVCフレームワークとは少し異なります。
上記の図は、[。underline] #M＃ odel、[。underline] #V＃ iew、および[。underline] #C＃ Struts2高レベルアーキテクチャのコントローラーを示しています。 コントローラーはインターセプターと同様に Struts2 ディスパッチサーブレットフィルターで実装され、このモデルはアクションで実装され、ビューは結果タイプと結果の組み合わせです。 バリュースタックとOGNLは、他のコンポーネント間のリンクと統合を可能にする共通のスレッドを提供します。
上記のコンポーネントとは別に、構成に関連する多くの情報があります。 Webアプリケーションの構成、およびアクション、インターセプター、結果などの構成
これは、Struts 2 MVCパターンのアーキテクチャの概要です。 以降の章では、各コンポーネントについて詳しく説明します。
ライフサイクルをリクエストする
上記の図に基づいて、次のように Struts 2 でユーザーのリクエストライフサイクル全体のワークフローを理解できます-
- ユーザーは、何らかのリソース（つまり、 ページ）。
- フィルターディスパッチャーはリクエストを見て、適切なアクションを決定します。
- 検証、ファイルのアップロードなど、設定されたインターセプター機能が適用されます。
- 選択されたアクションは、要求された操作に基づいて実行されます。
- 繰り返しますが、構成されたインターセプターは、必要に応じて後処理を行うために適用されます。
- 最後に、結果はビューによって準備され、結果をユーザーに返します。
Struts 2-Hello Worldの例
Struts 2アーキテクチャから既に学んだように、ハイパーリンクをクリックするか、Struts 2 WebアプリケーションでHTMLフォームを送信すると、入力はControllerによって収集され、ActionsというJavaクラスに送信されます。 アクションが実行された後、結果は応答をレンダリングするリソースを選択します。 通常、リソースはJSPですが、PDFファイル、Excelスプレッドシート、またはJavaアプレットウィンドウにすることもできます。
すでに開発環境を構築していると仮定します。 では、最初の Hello World Struts2 プロジェクトの構築に進みましょう。 このプロジェクトの目的は、ユーザーの名前を収集し、「Hello World」の後にユーザー名を表示するWebアプリケーションを構築することです。
Struts 2プロジェクトでは、次の4つのコンポーネントを作成する必要があります-
| Sr.No | Components & Description |
|---|---|
| 1 |
Action 完全なビジネスロジックを含むアクションクラスを作成し、ユーザー、モデル、ビュー間の相互作用を制御します。 |
| 2 |
Interceptors 必要に応じてインターセプターを作成するか、既存のインターセプターを使用します。 これはコントローラーの一部です。 |
| 3 |
View ユーザーと対話して入力を行い、最終メッセージを表示するJSPを作成します。 |
| 4 |
Configuration Files アクション、ビュー、コントローラーを結合する構成ファイルを作成します。 これらのファイルは、struts.xml、web.xml、struts.propertiesです。 |
Eclipse IDEを使用して、必要なすべてのコンポーネントが動的Webプロジェクトの下に作成されるようにします。 ダイナミックWebプロジェクトの作成から始めましょう。
動的Webプロジェクトを作成する
Eclipseを起動し、 File> New> Dynamic Web Project でプロジェクト名を HelloWorldStruts2 と入力し、次の画面に示すように残りのオプションを設定します-
次の画面ですべてのデフォルトオプションを選択し、最後に* Web.xmlデプロイメント記述子の生成*オプションをチェックします。 これにより、Eclipseで動的なWebプロジェクトが作成されます。 今すぐ Windows> Show View> Project Explorer を選択すると、以下のようなプロジェクトウィンドウが表示されます-
次に、次のファイルをstruts 2 libフォルダー C：\ struts-2.2.3 \ lib からプロジェクトの WEB-INF \ lib フォルダーにコピーします。 これを行うには、次のすべてのファイルをWEB-INF \ libフォルダーにドラッグアンドドロップするだけです。
- commons-fileupload-x.y.z.jar
- commons-io-x.y.z.jar
- commons-lang-x.y.jar
- commons-logging-x.y.z.jar
- commons-logging-api-x.y.jar
- freemarker-x.y.z.jar
- javassist-.xy.z.GA
- ognl-x.y.z.jar
- struts2-core-x.y.z.jar
- xwork-core.x.y.z.jar
アクションクラスの作成
アクションクラスはStruts 2アプリケーションのキーであり、ほとんどのビジネスロジックをアクションクラスに実装します。 それでは、 Java Resources> src の下に com.finddevguides.struts2 というパッケージ名のJavaファイルHelloWorldAction.javaを作成して、以下の内容を含めます。
ユーザーがURLをクリックすると、Actionクラスはユーザーアクションに応答します。 1つ以上のActionクラスのメソッドが実行され、文字列の結果が返されます。 結果の値に基づいて、特定のJSPページがレンダリングされます。
package com.finddevguides.struts2;
public class HelloWorldAction {
private String name;
public String execute() throws Exception {
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}これは、「名前」という1つのプロパティを持つ非常に単純なクラスです。 「name」プロパティ用の標準のゲッターおよびセッターメソッドと、文字列「success」を返すexecuteメソッドがあります。
Struts 2フレームワークは、 HelloWorldAction クラスのオブジェクトを作成し、ユーザーのアクションに応じて実行されたメソッドを呼び出します。 最終的に文字列定数を返すこのメソッド内にビジネスロジックを配置します。 つまり、各URLに1つのアクションクラスを実装する必要があり、そのクラス名をアクション名として直接使用するか、struts.xmlファイルを使用して他の名前にマップすることができます（以下を参照）。
ビューを作成する
最終メッセージを表示するにはJSPが必要です。このページは、事前定義されたアクションが発生したときにStruts 2フレームワークによって呼び出され、このマッピングはstruts.xmlファイルで定義されます。 そこで、EclipseプロジェクトのWebContentフォルダーに以下のjspファイル HelloWorld.jsp を作成しましょう。 これを行うには、プロジェクトエクスプローラーでWebContentフォルダーを右クリックし、[ New> JSP File ]を選択します。
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>taglibディレクティブは、このページが Struts 2 タグを使用し、これらのタグの前に s が付くことをサーブレットコンテナに伝えます。
s：propertyタグは、HelloWorldActionクラスのメソッド* getName（）*によって返されるアクションクラスプロパティ「name>」の値を表示します。
メインページを作成
また、WebContentフォルダーに index.jsp を作成する必要があります。 このファイルは、ユーザーがStruts 2フレームワークにHelloWorldActionクラスの定義済みメソッドを呼び出してHelloWorld.jspビューをレンダリングするように指示するためにクリックできる初期アクションURLとして機能します。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>上記のビューファイルで定義された hello アクションは、struts.xmlファイルを使用してHelloWorldActionクラスとその実行メソッドにマッピングされます。 ユーザーが「送信」ボタンをクリックすると、Struts 2フレームワークがHelloWorldActionクラスで定義された実行メソッドを実行し、メソッドの戻り値に基づいて、適切なビューが選択され、応答としてレンダリングされます。
構成ファイル
URL、HelloWorldActionクラス（モデル）、およびHelloWorld.jsp（ビュー）を結び付けるマッピングが必要です。 マッピングは、どのクラスがユーザーのアクション（URL）に応答するか、そのクラスのどのメソッドが実行されるか、メソッドが返すStringの結果に基づいてどのビューをレンダリングするかをStruts 2フレームワークに伝えます。
そこで、 struts.xml というファイルを作成しましょう。 Struts 2では、struts.xmlがクラスフォルダーに存在する必要があります。 したがって、WebContent/WEB-INF/classesフォルダーの下にstruts.xmlファイルを作成します。 Eclipseはデフォルトでは「クラス」フォルダーを作成しません。そのため、これを自分で行う必要があります。 これを行うには、プロジェクトエクスプローラーでWEB-INFフォルダーを右クリックし、*新規>フォルダー*を選択します。 あなたのstruts.xmlは次のようになります-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>上記の構成ファイルに関して理解する必要のある言葉はほとんどありません。 ここでは、開発環境で作業しており、有用なログメッセージを表示する必要があるため、定数 struts.devMode を true に設定します。 次に、 helloworld というパッケージを定義します。
パッケージを作成すると、アクションをグループ化するときに便利です。 この例では、アクションに「hello」という名前を付けました。これは、URL /hello.action に対応し、* HelloWorldAction.class によってバックアップされます。 *HelloWorldAction.class の execute メソッドは、URL /hello.action が呼び出されたときに実行されるメソッドです。 executeメソッドの結果が「success」を返す場合、ユーザーを HelloWorld.jsp に移動します。
次のステップは、Struts 2へのリクエストのエントリポイントである web.xml ファイルを作成することです。 Struts2アプリケーションのエントリポイントは、デプロイメント記述子（web.xml）で定義されたフィルターになります。 したがって、web.xmlでorg.apache.struts2.dispatcher.FilterDispatcherクラスのエントリを定義します。 web.xmlファイルは、WebContentの下のWEB-INFフォルダーの下に作成する必要があります。 プロジェクトを作成したときに、Eclipseはすでにスケルトンweb.xmlファイルを作成していました。 したがって、次のように変更するだけです-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>index.jspをウェルカムファイルとして指定しました。 次に、すべてのURL（つまり、パターン/*に一致する任意のURL）で実行するようにStruts2フィルターを構成しました
詳細ログを有効にするには
*WEB-INF/classes* フォルダーの下に *logging.properties* ファイルを作成することにより、Struts 2での作業中に完全なログ機能を有効にできます。 プロパティファイルに次の2行を保持します-org.apache.catalina.core.ContainerBase.[Catalina].level = INFO
org.apache.catalina.core.ContainerBase.[Catalina].handlers = \
java.util.logging.ConsoleHandlerデフォルトのlogging.propertiesは、ログをstdoutにルーティングするためのConsoleHandlerとFileHandlerを指定します。 ハンドラーのログレベルのしきい値は、SEVERE、WARNING、INFO、CONFIG、FINE、FINER、FINEST、またはALLを使用して設定できます。
それでおしまい。 Struts 2フレームワークを使用してHello Worldアプリケーションを実行する準備が整いました。
アプリケーションの実行手順
プロジェクト名を右クリックし、[エクスポート]> [WARファイル]をクリックして、WARファイルを作成します。
次に、このWARをTomcatのwebappsディレクトリにデプロイします。
最後に、Tomcatサーバーを起動して、URL http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が表示されます-
値「Struts2」を入力して、ページを送信します。 次のページが表示されます
struts.xmlファイルでアクションとして index を定義できることに注意してください。その場合、 http：//localhost：8080/HelloWorldStruts2/index.action としてインデックスページを呼び出すことができます。 アクションとしてインデックスを定義する方法を以下で確認してください-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "index">
<result >/index.jsp</result>
</action>
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>Struts 2-構成ファイル
この章では、 Struts 2 アプリケーションに必要な基本構成について説明します。 ここでは、 web.xml、struts.xml、strutsconfig.xml 、 struts.properties などのいくつかの重要な構成ファイルを使用して構成できるものを確認します。
率直に言って、 web.xml および struts.xml 構成ファイルを使用するだけで作業を開始できます（この2つのファイルを使用して例が機能する前の章で既に目撃したように）。 ただし、あなたの知識のために、他のファイルについても説明します。
web.xmlファイル
web.xml構成ファイルは、サーブレットコンテナによってHTTP要求の要素が処理される方法を決定するJ2EE構成ファイルです。 これは厳密にはStruts2構成ファイルではありませんが、Struts2が機能するように構成する必要があるファイルです。
前に説明したように、このファイルはWebアプリケーションのエントリポイントを提供します。 Struts2アプリケーションのエントリポイントは、デプロイメント記述子（web.xml）で定義されたフィルターになります。 したがって、web.xmlで_FilterDispatcher_クラスのエントリを定義します。 web.xmlファイルは、フォルダー WebContent/WEB-INF の下に作成する必要があります。
これは、テンプレートまたはテンプレートを生成するツール（EclipseやMaven2など）を使用せずに起動する場合に構成する必要がある最初の構成ファイルです。
以下は、最後の例で使用したweb.xmlファイルのコンテンツです。
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Struts 2フィルターを / 。action ではなく */ *にマップすることに注意してください。これは、すべてのURLがstrutsフィルターによって解析されることを意味します。 これについては、注釈の章で説明します。
Struts.xmlファイル
*struts.xml* ファイルには、アクションの開発時に変更する構成情報が含まれています。 このファイルは、_struts.devMode = false_およびプロパティファイルで定義されている他の設定など、アプリケーションのデフォルト設定をオーバーライドするために使用できます。 このファイルは、フォルダー *WEB-INF/classes* の下に作成できます。前の章で説明したHello Worldの例で作成したstruts.xmlファイルを見てみましょう。
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
<-- more actions can be listed here -->
</package>
<-- more packages can be listed here -->
</struts>最初に注意することは DOCTYPE です。 すべてのstruts構成ファイルには、小さな例に示すように正しいdoctypeが必要です。 <struts>はルートタグ要素で、その下で<package>タグを使用してさまざまなパッケージを宣言します。 ここで、<パッケージ>を使用すると、構成を分離してモジュール化できます。 これは、大きなプロジェクトがあり、プロジェクトが異なるモジュールに分割されている場合に非常に便利です。
たとえば、プロジェクトにbusiness_application、customer_application、staff_applicationの3つのドメインがある場合、3つのパッケージを作成し、関連するアクションを適切なパッケージに保存できます。
パッケージタグには次の属性があります-
| Sr.No | Attribute & Description |
|---|---|
| 1 |
name (required) パッケージの一意の識別子 |
| 2 |
extends このパッケージはどのパッケージから拡張されますか？ デフォルトでは、struts-defaultを基本パッケージとして使用します。 |
| 3 |
abstract trueとマークされている場合、パッケージはエンドユーザーが使用できません。 |
| 4 |
namespace アクションの一意の名前空間 |
*constant* タグとnameおよびvalue属性を使用して、 *struts.devMode* プロパティを設定したように、 *default.properties* で定義された以下のプロパティをオーバーライドする必要があります。 *struts.devMode* プロパティを設定すると、ログファイルでより多くのデバッグメッセージを表示できます。アクセスするすべてのURLに対応する action タグを定義し、対応するURLにアクセスするたびにアクセスされるexecute（）メソッドでクラスを定義します。
結果は、アクションの実行後にブラウザに返されるものを決定します。 アクションから返される文字列は、結果の名前でなければなりません。 結果は、上記のようにアクションごとに、または「グローバル」結果として構成され、パッケージ内のすべてのアクションで使用できます。 結果には、オプションの name および type 属性があります。 デフォルトの名前の値は「成功」です。
Struts.xmlファイルは時間とともに大きくなる可能性があるため、パッケージで分割することはモジュール化の1つの方法ですが、 Struts はstruts.xmlファイルをモジュール化する別の方法を提供します。 ファイルを複数のxmlファイルに分割し、次の方法でインポートできます。
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="my-struts1.xml"/>
<include file="my-struts2.xml"/>
</struts>取り上げていない他の構成ファイルはstruts-default.xmlです。 このファイルにはStrutsの標準構成設定が含まれており、プロジェクトの99.99％でこれらの設定を変更する必要はありません。 このため、このファイルについてはあまり詳しく説明しません。 興味がある場合は、struts2-core-2.2.3.jarファイルにある default.properties ファイルをご覧ください。
Struts-config.xmlファイル
struts-config.xml構成ファイルは、WebクライアントのViewコンポーネントとModelコンポーネント間のリンクですが、プロジェクトの99.99％でこれらの設定を変更する必要はありません。
構成ファイルは、基本的に次の主要な要素が含まれています-
| Sr.No | Interceptor & Description |
|---|---|
| 1 |
struts-config これは、構成ファイルのルートノードです。 |
| 2 |
form-beans これは、ActionFormサブクラスを名前にマップする場所です。 この名前は、残りのstrutsconfig.xmlファイル全体、さらにはJSPページでもActionFormのエイリアスとして使用します。 |
| 3 |
global forwards このセクションは、webappのページを名前にマップします。 この名前を使用して、実際のページを参照できます。 これにより、WebページでURLをハードコーディングする必要がなくなります。 |
| 4 |
action-mappings ここでフォームハンドラを宣言します。これらはアクションマッピングとも呼ばれます。 |
| 5 |
controller このセクションでは、Struts内部を構成し、実際の状況ではめったに使用しません。 |
| 6 |
plug-in このセクションは、プロンプトとエラーメッセージを含むプロパティファイルの場所をStrutsに指示します。 |
次に、サンプルのstruts-config.xmlファイルを示します-
<?xml version = "1.0" Encoding = "ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.0//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd">
<struts-config>
<!-- ========== Form Bean Definitions ============ -->
<form-beans>
<form-bean name = "login" type = "test.struts.LoginForm"/>
</form-beans>
<!-- ========== Global Forward Definitions ========= -->
<global-forwards>
</global-forwards>
<!-- ========== Action Mapping Definitions ======== -->
<action-mappings>
<action
path = "/login"
type = "test.struts.LoginAction" >
<forward name = "valid" path = "/jsp/MainMenu.jsp"/>
<forward name = "invalid" path = "/jsp/LoginView.jsp"/>
</action>
</action-mappings>
<!-- ========== Controller Definitions ======== -->
<controller contentType = "text/html;charset = UTF-8"
debug = "3" maxFileSize = "1.618M" locale = "true" nocache = "true"/>
</struts-config>struts-config.xmlファイルの詳細については、Strutsのドキュメントをご確認ください。
Struts.propertiesファイル
この構成ファイルは、フレームワークのデフォルトの動作を変更するメカニズムを提供します。 実際、 struts.properties 構成ファイルに含まれるすべてのプロパティは、 init.param を使用して web.xml で構成することも、 struts.xml 構成ファイルで定数タグを使用して構成することもできます。 しかし、物事を分離し、よりストラット固有に保ちたい場合は、 WEB-INF/classes フォルダーの下にこのファイルを作成できます。
このファイルで構成された値は、struts2-core-x.y.z.jarディストリビューションに含まれている default.properties で構成されたデフォルト値をオーバーライドします。 struts.properties ファイルを使用して変更を検討する可能性のあるプロパティがいくつかあります-
### When set to true, Struts will act much more friendly for developers
struts.devMode = true
### Enables reloading of internationalization files
struts.i18n.reload = true
### Enables reloading of XML configuration files
struts.configuration.xml.reload = true
### Sets the port that the server is run on
struts.url.http.port = 8080ここでは、 hash （＃）で始まる行はコメントと見なされ、 Struts 2 によって無視されます。
Struts 2-アクション
- アクション*は、MVC（Model View Controller）フレームワーク用であるため、Struts2フレームワークの中核です。 各URLは特定のアクションにマッピングされ、ユーザーからのリクエストを処理するために必要な処理ロジックを提供します。
しかし、このアクションは他の2つの重要な機能にも役立ちます。 まず、アクションは、JSPであれ他のタイプの結果であれ、要求からビューへのデータの転送において重要な役割を果たします。 第二に、アクションは、リクエストへの応答で返されるビューをレンダリングする結果を決定するフレームワークを支援する必要があります。
アクションを作成
*Struts2* のアクションの唯一の要件は、StringまたはResultオブジェクトのいずれかを返し、POJOでなければならないnoargumentメソッドが1つ存在することです。 引数なしのメソッドが指定されていない場合、デフォルトの動作はexecute（）メソッドを使用することです。オプションで、 Action インターフェイスを含む6つのインターフェイスを実装する ActionSupport クラスを拡張できます。 アクションインターフェイスは次のとおりです-
public interface Action {
public static final String SUCCESS = "success";
public static final String NONE = "none";
public static final String ERROR = "error";
public static final String INPUT = "input";
public static final String LOGIN = "login";
public String execute() throws Exception;
}Hello Worldの例のアクションメソッドを見てみましょう-
package com.finddevguides.struts2;
public class HelloWorldAction {
private String name;
public String execute() throws Exception {
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}アクションメソッドがビューを制御する点を説明するために、 execute メソッドに次の変更を加え、次のようにクラスActionSupportを拡張しましょう-
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
if ("SECRET".equals(name)) {
return SUCCESS;
} else {
return ERROR;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}この例では、name属性を調べるためのexecuteメソッドにいくつかのロジックがあります。 属性が文字列 "SECRET" と等しい場合、結果として SUCCESS を返します。それ以外の場合、結果として ERROR を返します。 ActionSupportを拡張しているため、文字列定数 SUCCESS およびERRORを使用できます。 さて、次のようにstruts.xmlファイルを変更しましょう-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>ビューを作成する
eclipseプロジェクトのWebContentフォルダーに以下のjspファイル HelloWorld.jsp を作成しましょう。 これを行うには、プロジェクトエクスプローラーでWebContentフォルダーを右クリックし、[ New> JSP File ]を選択します。 このファイルは、返される結果がSUCCESSである場合に呼び出されます。SUCCESSは、Actionインターフェイスで定義されている文字列定数「成功」です-
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>以下は、アクションの結果が文字列定数「error」に等しいERRORの場合にフレームワークによって呼び出されるファイルです。 以下は AccessDenied.jsp のコンテンツです。
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Access Denied</title>
</head>
<body>
You are not authorized to view this page.
</body>
</html>また、WebContentフォルダーに index.jsp を作成する必要があります。 このファイルは、ユーザーがStruts 2フレームワークにHelloWorldActionクラスの* execute *メソッドを呼び出してHelloWorld.jspビューをレンダリングするように指示するためにクリックできる初期アクションURLとして機能します。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>それだけです。web.xmlファイルに必要な変更はないので、例*の章で作成したweb.xmlと同じものを使用しましょう。 これで、Struts 2フレームワークを使用して *Hello World アプリケーションを実行する準備が整いました。
アプリケーションを実行する
プロジェクト名を右クリックし、[エクスポート]> [WAR ファイル]をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が表示されます-
「SECRET」と単語を入力してみましょう。次のページが表示されます-
「SECRET」以外の単語を入力すると、次のページが表示されます-
複数のアクションを作成する
あなたは頻繁に異なる要求を処理し、ユーザーに異なるURLを提供するために複数のアクションを定義します。したがって、以下に定義するように異なるクラスを定義します-
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
class MyAction extends ActionSupport {
public static String GOOD = SUCCESS;
public static String BAD = ERROR;
}
public class HelloWorld extends ActionSupport {
...
public String execute() {
if ("SECRET".equals(name)) return MyAction.GOOD;
return MyAction.BAD;
}
...
}
public class SomeOtherClass extends ActionSupport {
...
public String execute() {
return MyAction.GOOD;
}
...
}次のようにstruts.xmlファイルでこれらのアクションを設定します-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorld"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
<action name = "something"
class = "com.finddevguides.struts2.SomeOtherClass"
method = "execute">
<result name = "success">/Something.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>上記の仮想的な例でわかるように、アクション結果 SUCCESS と ERROR’s は重複しています。
この問題を回避するには、結果の結果を含むクラスを作成することをお勧めします。
Struts 2-インターセプター
インターセプターは、概念的にはサーブレットフィルターまたはJDKプロキシクラスと同じです。 インターセプターにより、アクションおよびフレームワークとは別にクロスカット機能を実装できます。 あなたはインターセプターを使用して以下を達成することができます-
アクションが呼び出される前に前処理ロジックを提供します。
アクションが呼び出された後の後処理ロジックを提供します。
代替処理を実行できるように例外をキャッチします。
*Struts2* フレームワークで提供される機能の多くは、インターセプターを使用して実装されています。
- 例*には、例外処理、ファイルのアップロード、ライフサイクルコールバックなどが含まれます。 実際、Struts2はインターセプターの機能の多くを強調しているため、アクションごとに7つまたは8つのインターセプターが割り当てられることはほとんどありません。
Struts2フレームワークインターセプター
Struts 2フレームワークは、事前構成されてすぐに使用できるすぐに使用可能なインターセプターの優れたリストを提供します。 重要なインターセプターのいくつかは以下にリストされています-
| Sr.No | Interceptor & Description |
|---|---|
| 1 |
alias パラメータがリクエスト間で異なる名前エイリアスを持つことを許可します。 |
| 2 |
checkbox チェックされていないチェックボックスにfalseのパラメーター値を追加することにより、チェックボックスの管理を支援します。 |
| 3 |
conversionError エラー情報を、文字列からパラメータータイプへの変換からアクションのフィールドエラーに配置します。 |
| 4 |
createSession HTTPセッションがまだ存在しない場合、自動的に作成します。 |
| 5 |
debugging 開発者にいくつかの異なるデバッグ画面を提供します。 |
| 6 |
execAndWait アクションがバックグラウンドで実行されている間に、ユーザーを中間の待機ページに送ります。 |
| 7 |
exception アクションからスローされた例外を結果にマップし、リダイレクトによる自動例外処理を可能にします。 |
| 8 |
fileUpload 簡単なファイルのアップロードを容易にします。 |
| 9 |
i18n ユーザーのセッション中に選択したロケールを追跡します。 |
| 10 |
logger 実行中のアクションの名前を出力することにより、簡単なロギングを提供します。 |
| 11 |
params アクションの要求パラメーターを設定します。 |
| 12 |
prepare これは通常、セットアップデータベース接続などの前処理作業を行うために使用されます。 |
| 13 |
profile アクションの単純なプロファイリング情報を記録できます。 |
| 14 |
scope セッションまたはアプリケーションスコープでアクションの状態を保存および取得します。 |
| 15 |
ServletConfig アクションにさまざまなサーブレットベースの情報へのアクセスを提供します。 |
| 16 |
timer アクションの実行にかかる時間の形式で、単純なプロファイリング情報を提供します。 |
| 17 |
token 有効なトークンのアクションをチェックして、フォーム送信の重複を防ぎます。 |
| 18 |
validation アクションの検証サポートを提供します |
上記のインターセプターの詳細については、Struts 2のドキュメントをご覧ください。 ただし、Strutsアプリケーションで一般的なインターセプターの使用方法を説明します。
インターセプターの使用方法
既存のインターセプターを「Hello World」プログラムに使用する方法を見てみましょう。 アクションメソッドの実行にかかった時間を測定することを目的とする timer インターセプターを使用します。 同時に、リクエストパラメータをアクションに送信することが目的の params インターセプタを使用しています。 このインターセプターを使用せずに例を試すと、パラメーターがアクションに到達できないため、 name プロパティが設定されていないことがわかります。
例*の章で作成したHelloWorldAction.java、web.xml、HelloWorld.jspおよびindex.jspファイルを保持しますが、 *struts.xml ファイルを変更してインターセプターを追加します。
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<interceptor-ref name = "params"/>
<interceptor-ref name = "timer"/>
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>プロジェクト名を右クリックし、[エクスポート]> [WARファイル]をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
指定されたテキストボックスに任意の単語を入力し、[Say Hello]ボタンをクリックして、定義されたアクションを実行します。 生成されたログを確認する場合、次のテキストが表示されます-
INFO: Server startup in 3539 ms
27/08/2011 8:40:53 PM
com.opensymphony.xwork2.util.logging.commons.CommonsLogger info
INFO: Executed action [//hello!execute] took 109 ms.ここでは、 timer インターセプターがアクションの実行に合計109ミリ秒かかったことを示すため、最終行が生成されています。
カスタムインターセプターを作成する
アプリケーションでカスタムインターセプターを使用することは、横断的なアプリケーション機能を提供するエレガントな方法です。 カスタムインターセプターの作成は簡単です。拡張する必要があるインターフェイスは、次の Interceptor インターフェイスです-
public interface Interceptor extends Serializable {
void destroy();
void init();
String intercept(ActionInvocation invocation)
throws Exception;
}名前が示すように、init（）メソッドはインターセプターを初期化する方法を提供し、destroy（）メソッドはインターセプターのクリーンアップ機能を提供します。 アクションとは異なり、インターセプターはリクエスト間で再利用されるため、スレッドセーフ、特にintercept（）メソッドが必要です。
*ActionInvocation* オブジェクトは、ランタイム環境へのアクセスを提供します。 アクション自体とメソッドにアクセスしてアクションを呼び出し、アクションがすでに呼び出されているかどうかを判断できます。初期化またはクリーンアップコードが必要ない場合は、 AbstractInterceptor クラスを拡張できます。 これにより、init（）およびdestroy（）メソッドのデフォルトのnooperation実装が提供されます。
インターセプタークラスを作成する
*Java Resources> src* フォルダに次のMyInterceptor.javaを作成しましょう-package com.finddevguides.struts2;
import java.util.*;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
public class MyInterceptor extends AbstractInterceptor {
public String intercept(ActionInvocation invocation)throws Exception {
/*let us do some pre-processing*/
String output = "Pre-Processing";
System.out.println(output);
/*let us call action or next interceptor*/
String result = invocation.invoke();
/*let us do some post-processing*/
output = "Post-Processing";
System.out.println(output);
return result;
}
}お気づきのとおり、実際のアクションは** invocation.invoke（）* *callによってインターセプターを使用して実行されます。 したがって、要件に基づいて前処理と後処理を行うことができます。
フレームワーク自体は、ActionInvocationオブジェクトのinvoke（）を最初に呼び出すことでプロセスを開始します。* invoke（）*が呼び出されるたびに、ActionInvocationはその状態を調べ、次に来るインターセプターを実行します。 設定されたすべてのインターセプターが呼び出されると、invoke（）メソッドによりアクション自体が実行されます。
次の図は、要求フローを通じて同じ概念を示しています-
アクションクラスの作成
*Java Resources> src* の下に *com.finddevguides.struts2* というパッケージ名のJavaファイルHelloWorldAction.javaを作成します。内容は以下のとおりです。package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
System.out.println("Inside action....");
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}これは、前の例で見たのと同じクラスです。 「name」プロパティ用の標準のゲッターおよびセッターメソッドと、文字列「success」を返すexecuteメソッドがあります。
ビューを作成する
eclipseプロジェクトのWebContentフォルダーに以下のjspファイル HelloWorld.jsp を作成しましょう。
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>メインページを作成
また、WebContentフォルダーに index.jsp を作成する必要があります。 このファイルは、ユーザーがクリックしてStruts 2フレームワークにHelloWorldActionクラスの定義済みメソッドを呼び出し、HelloWorld.jspビューをレンダリングするように指示できる初期アクションURLとして機能します。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>上記のビューファイルで定義された hello アクションは、struts.xmlファイルを使用してHelloWorldActionクラスとその実行メソッドにマッピングされます。
構成ファイル
ここで、インターセプターを登録してから、前の例でデフォルトのインターセプターを呼び出したように呼び出す必要があります。 新しく定義されたインターセプターを登録するには、<interceptors> … </interceptors>タグを<package>タグのins * struts.xml *ファイルの直下に配置します。 前の例で行ったように、デフォルトのインターセプターではこのステップをスキップできます。 しかし、ここで次のように登録して使用してみましょう-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<interceptors>
<interceptor name = "myinterceptor"
class = "com.finddevguides.struts2.MyInterceptor"/>
</interceptors>
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<interceptor-ref name = "params"/>
<interceptor-ref name = "myinterceptor"/>
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>*<package>* タグ内で複数のインターセプターを登録でき、同時に *<action>* タグ内で複数のインターセプターを呼び出すことができることに注意してください。 同じインターセプターを異なるアクションで呼び出すことができます。web.xmlファイルは、次のようにWebContentの下のWEB-INFフォルダーの下に作成する必要があります-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>プロジェクト名を右クリックし、[エクスポート]> [WARファイル]をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
指定されたテキストボックスに任意の単語を入力し、[Say Hello]ボタンをクリックして、定義されたアクションを実行します。 今、あなたが生成されたログを確認する場合は、下部に次のテキストがあります-
Pre-Processing
Inside action....
Post-Processing複数のインターセプターのスタック
ご想像のとおり、アクションごとに複数のインターセプターを構成する必要があると、すぐに管理できなくなります。 このため、インターセプターはインターセプタースタックで管理されます。 以下は、strutsdefault.xmlファイルから直接の例です-
<interceptor-stack name = "basicStack">
<interceptor-ref name = "exception"/>
<interceptor-ref name = "servlet-config"/>
<interceptor-ref name = "prepare"/>
<interceptor-ref name = "checkbox"/>
<interceptor-ref name = "params"/>
<interceptor-ref name = "conversionError"/>
</interceptor-stack>上記のステークは basicStack と呼ばれ、以下に示すように構成で使用できます。 この構成ノードは、<package …/>ノードの下に配置されます。 各<interceptor-ref …/>タグは、インターセプターまたは現在のインターセプタースタックの前に構成されたインターセプタースタックを参照します。 したがって、初期インターセプターとインターセプタースタックを構成するときは、名前がすべてのインターセプターとインターセプタースタック構成で一意であることを確認することが非常に重要です。
インターセプターをアクションに適用する方法はすでに見てきましたが、インターセプタースタックの適用も同じです。 実際には、まったく同じタグを使用します-
<action name = "hello" class = "com.finddevguides.struts2.MyAction">
<interceptor-ref name = "basicStack"/>
<result>view.jsp</result>
</action上記の「basicStack」の登録は、helloアクションで6つのインターセプターすべての完全なステークを登録します。 これは、インターセプターが構成された順序で実行されることに注意してください。 たとえば、上記の場合、例外が最初に実行され、2番目がservlet-configなどになります。
Struts 2-結果と結果タイプ
前述したように、 <results> タグは、Struts2 MVCフレームワークで view の役割を果たします。 アクションは、ビジネスロジックの実行を担当します。 ビジネスロジックを実行した後の次の手順は、 <results> タグを使用してビューを表示することです。
多くの場合、結果にはいくつかのナビゲーションルールが添付されています。 たとえば、アクションメソッドがユーザーの認証である場合、3つの可能な結果があります。
- ログイン成功
- ログイン失敗-間違ったユーザー名またはパスワード
- アカウントがロックされました
このシナリオでは、3つの可能な結果文字列と結果をレンダリングするための3つの異なるビューでアクションメソッドが構成されます。 これは前の例ですでに見ました。
ただし、Struts2は、JSPをビューテクノロジーとして使用することとは関係ありません。 結局、MVCパラダイムの全体的な目的は、レイヤーを分離し、高度に構成可能にすることです。 たとえば、Web2.0クライアントの場合、出力としてXMLまたはJSONを返すことができます。 この場合、XMLまたはJSONの新しい結果タイプを作成し、これを実現できます。
Strutsには、事前定義された多くの result types と、JSPページへのディスパッチに使用されるデフォルトのresult type dispatcher がすでに見られています。 Strutsを使用すると、ビューテクノロジーに他のマークアップ言語を使用して結果を表示することができ、 Velocity、Freemaker、XSLT 、 Tiles などの一般的な選択肢があります。
ディスパッチャの結果タイプ
*dispatcher* 結果タイプはデフォルトタイプであり、他の結果タイプが指定されていない場合に使用されます。 サーバー上のサーブレット、JSP、HTMLページなどに転送するために使用されます。 _RequestDispatcher.forward（）_メソッドを使用します。以前の例では、結果タグの本文としてJSPパスを提供した「速記」バージョンを見ました。
<result name = "success">
/HelloWorld.jsp
</result>次のように<result …>要素内で<param name = "location">タグを使用してJSPファイルを指定することもできます-
<result name = "success" type = "dispatcher">
<param name = "location">
/HelloWorld.jsp
</param >
</result>また、デフォルトでtrueである parse パラメーターを指定することもできます。 解析パラメーターは、OGNL式についてロケーションパラメーターを解析するかどうかを決定します。
FreeMaker結果タイプ
この例では、 FreeMaker をビューテクノロジとして使用する方法を確認します。 Freemakerは、事前定義されたテンプレートを使用して出力を生成するために使用される一般的なテンプレートエンジンです。 次の内容で hello.fm というFreemakerテンプレートファイルを作成します。
Hello World ${name}上記のファイルは、 name が定義済みのアクションを使用して外部から渡されるパラメーターであるテンプレートです。 このファイルはCLASSPATHに保持します。
次に、 struts.xml を変更して、次のように結果を指定します-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<result name = "success" type = "freemarker">
<param name = "location">/hello.fm</param>
</result>
</action>
</package>
</struts>例の章で作成したHelloWorldAction.java、HelloWorldAction.jspおよびindex.jspファイルを保持します。
次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] *をクリックして、WARファイルを作成します。
次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます。
値「Struts2」を入力して、ページを送信します。 次のページが表示されます。
ご覧のとおり、これはJSPビューとまったく同じですが、ビューテクノロジーとしてJSPを使用することに縛られていない点が異なります。 この例ではFreemakerを使用しました。
リダイレクト結果タイプ
*redirect* 結果タイプは、標準の_response.sendRedirect（）_メソッドを呼び出して、ブラウザーに特定の場所への新しいリクエストを作成させます。場所は、<result …>要素の本体で、または<param name = "location">要素として提供できます。 リダイレクトは、 parse パラメーターもサポートしています。 これは、XMLを使用して構成された例です-
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<result name = "success" type = "redirect">
<param name = "location">
/NewWorld.jsp
</param >
</result>
</action>したがって、上記のようにstruts.xmlファイルを変更してリダイレクトタイプを定義し、helloアクションが成功を返すたびにリダイレクトされる新しいファイルNewWorld.jpgを作成します。 理解を深めるために、リンク：/struts_2/struts_redirect_action [Struts 2 Redirect Action]の例を確認できます。
Struts 2-バリュースタック/OGNL
価値スタック
値スタックは、提供された順序で次のオブジェクトを保持するいくつかのオブジェクトのセットです-
| Sr.No | Objects & Description |
|---|---|
| 1 |
Temporary Objects ページの実行中に作成されるさまざまな一時オブジェクトがあります。 たとえば、JSPタグでループされているコレクションの現在の反復値。 |
| 2 |
The Model Object Strutsアプリケーションでモデルオブジェクトを使用している場合、現在のモデルオブジェクトは値スタックのアクションの前に配置されます。 |
| 3 |
The Action Object これは、実行されている現在のアクションオブジェクトになります。 |
| 4 |
Named Objects これらのオブジェクトには、＃application、＃session、＃request、＃attr、および#parametersが含まれ、対応するサーブレットスコープを参照します。 |
値スタックには、JSP、Velocity、またはFreemarkerに提供されているタグを介してアクセスできます。 Struts 2.0値スタックを取得および設定するために使用されるさまざまなタグが別々の章で学習されます。 次のように、アクション内でvalueStackオブジェクトを取得できます-
ActionContext.getContext().getValueStack()ValueStackオブジェクトを取得したら、次のメソッドを使用してそのオブジェクトを操作できます-
| Sr.No | ValueStack Methods & Description |
|---|---|
| 1 |
Object findValue(String expr) デフォルトの検索順序でスタックに対して指定された式を評価することにより、値を見つけます。 |
| 2 |
CompoundRoot getRoot() スタックにプッシュされたオブジェクトを保持するCompoundRootを取得します。 |
| 3 |
Object peek() スタックを変更せずに、スタックの一番上にあるオブジェクトを取得します。 |
| 4 |
Object pop() スタックの一番上にあるオブジェクトを取得し、スタックから削除します。 |
| 5 |
void push(Object o) このオブジェクトをスタックの一番上に置きます。 |
| 6 |
void set(String key, Object o) findValue（key、…）で取得できるように、指定されたキーでスタック上のオブジェクトを設定します |
| 7 |
void setDefaultType(Class defaultType) 値を取得するときに型が提供されない場合に変換するデフォルトの型を設定します。 |
| 8 |
void setValue(String expr, Object value) デフォルトの検索順序を使用して、指定された式でスタック内のBeanにプロパティを設定しようとします。 |
| 9 |
int size() スタック内のオブジェクトの数を取得します。 |
OGNL
*Object-Graph Navigation Language* （OGNL）は、ValueStackのデータを参照および操作するために使用される強力な式言語です。 OGNLは、データ転送と型変換にも役立ちます。OGNLはJSP Expression Languageに非常に似ています。 OGNLは、コンテキスト内にルートオブジェクトまたはデフォルトオブジェクトを持つという考えに基づいています。 デフォルトオブジェクトまたはルートオブジェクトのプロパティは、マークアップ表記法（ポンド記号）を使用して参照できます。
前述のとおり、OGNLはコンテキストに基づいており、StrutsはOGNLで使用するActionContextマップを作成します。 ActionContextマップは次で構成されています-
- アプリケーション-アプリケーションスコープ変数
- セッション-セッションスコープ変数
- ルート/値スタック-すべてのアクション変数はここに保存されます
- リクエスト-スコープ変数のリクエスト
- パラメータ-リクエストパラメータ
- 属性-ページ、リクエスト、セッション、アプリケーションのスコープに保存されている属性
Actionオブジェクトは値スタックで常に利用可能であることを理解することが重要です。 そのため、アクションオブジェクトにプロパティ*“ x” および“ y” *がある場合、すぐに使用できます。
ActionContext内のオブジェクトはポンド記号を使用して参照されますが、値スタック内のオブジェクトは直接参照できます。
たとえば、*従業員*がアクションクラスのプロパティである場合、次のように参照できます-
<s:property value = "name"/>の代わりに
<s:property value = "#name"/>「ログイン」と呼ばれるセッションに属性がある場合は、次のようにそれを取得することができます-
<s:property value = "#session.login"/>OGNLは、コレクション、つまりMap、List、Setの処理もサポートしています。 たとえば、色のドロップダウンリストを表示するには、次のようにします-
<s:select name = "color" list = "{'red','yellow','green'}"/>OGNL式は、「赤」、「黄」、「緑」を色として解釈し、それに基づいてリストを作成するのに便利です。
OGNL式は、次の章でさまざまなタグを検討するときに広範囲に使用されます。 したがって、それらを個別に見るのではなく、フォームタグ/コントロールタグ/データタグとAjaxタグセクションの例を使用して見てみましょう。
ValueStack/OGNLの例
アクションを作成
valueStackにアクセスし、ビュー、つまりJSPページでOGNLを使用してアクセスするいくつかのキーを設定する次のアクションクラスを考えてみましょう。
package com.finddevguides.struts2;
import java.util.*;
import com.opensymphony.xwork2.util.ValueStack;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport {
private String name;
public String execute() throws Exception {
ValueStack stack = ActionContext.getContext().getValueStack();
Map<String, Object> context = new HashMap<String, Object>();
context.put("key1", new String("This is key1"));
context.put("key2", new String("This is key2"));
stack.push(context);
System.out.println("Size of the valueStack: " + stack.size());
return "success";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}実際、Struts 2は実行時にアクションをvalueStackの一番上に追加します。 そのため、値スタックにデータを配置する通常の方法は、値のゲッター/セッターをActionクラスに追加し、<s：property>タグを使用して値にアクセスすることです。 しかし、StrutsでActionContextとValueStackが正確に機能する方法を示しています。
ビューを作成する
eclipseプロジェクトのWebContentフォルダーに以下のjspファイル HelloWorld.jsp を作成しましょう。 このビューは、アクションが成功を返す場合に表示されます-
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Entered value : <s:property value = "name"/><br/>
Value of key 1 : <s:property value = "key1"/><br/>
Value of key 2 : <s:property value = "key2"/> <br/>
</body>
</html>また、コンテンツが次のとおりであるWebContentフォルダーに index.jsp を作成する必要があります-
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>構成ファイル
以下は struts.xml ファイルの内容です-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>以下は web.xml ファイルの内容です-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>プロジェクト名を右クリックし、[エクスポート]> [WARファイル]をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。
最後に、Tomcatサーバーを起動して、URL http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます
指定されたテキストボックスに任意の単語を入力し、「Say Hello」ボタンをクリックして、定義されたアクションを実行します。 今、あなたが生成されたログを確認する場合は、下部に次のテキストがあります-
Size of the valueStack: 3これにより、次の画面が表示されます。この画面には、入力する値と、ValueStackに設定したkey1およびkey2の値が表示されます。
Struts 2-ファイルのアップロード
Struts 2フレームワークは、「HTMLでのフォームベースのファイルアップロード」を使用してファイルアップロードを処理するための組み込みサポートを提供します。 ファイルがアップロードされると、通常は一時ディレクトリに保存され、データが失われないようにするために、Actionクラスによって処理または移動される必要があります。
注-サーバーには、一時ディレクトリおよびWebアプリケーションに属するディレクトリ以外のディレクトリへの書き込みを禁止するセキュリティポリシーが設定されている場合があります。
Strutsでのファイルのアップロードは、org.apache.struts2.interceptor.FileUploadInterceptorクラスを通じて利用可能で、* defaultStack の一部として含まれている *FileUpload インターセプターと呼ばれる事前定義されたインターセプターによって可能です。 以下に示すように、struts.xmlでそれを使用してさまざまなパラメーターを設定できます。
ビューファイルを作成する
選択したファイルを参照してアップロードするために必要なビューの作成から始めましょう。 だから、ユーザーがファイルをアップロードできるプレーンHTMLアップロードフォームで index.jsp を作成しましょう-
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>File Upload</title>
</head>
<body>
<form action = "upload" method = "post" enctype = "multipart/form-data">
<label for = "myFile">Upload your file</label>
<input type = "file" name = "myFile"/>
<input type = "submit" value = "Upload"/>
</form>
</body>
</html>上記の例には、注目に値する点がいくつかあります。 最初に、フォームのenctypeが multipart/form-data に設定されます。 これは、ファイルのアップロードがファイルアップロードインターセプターによって正常に処理されるように設定する必要があります。 次の点は、フォームのアクションメソッド upload とファイルアップロードフィールドの名前（ myFile ）です。 アクションメソッドとStruts構成を作成するには、この情報が必要です。
次に、単純なjspファイル success.jsp を作成して、ファイルアップロードが成功した場合の結果を表示します。
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>File Upload Success</title>
</head>
<body>
You have successfully uploaded <s:property value = "myFileFileName"/>
</body>
</html>以下は、ファイルのアップロード中にエラーが発生した場合の結果ファイル error.jsp です-
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>File Upload Error</title>
</head>
<body>
There has been an error in uploading the file.
</body>
</html>アクションクラスの作成
次に、 uploadFile.java というJavaクラスを作成します。このクラスは、ファイルのアップロードと、そのファイルの安全な場所への保存を処理します-
package com.finddevguides.struts2;
import java.io.File;
import org.apache.commons.io.FileUtils;
import java.io.IOException;
import com.opensymphony.xwork2.ActionSupport;
public class uploadFile extends ActionSupport {
private File myFile;
private String myFileContentType;
private String myFileFileName;
private String destPath;
public String execute() {
/*Copy file to a safe location*/
destPath = "C:/apache-tomcat-6.0.33/work/";
try {
System.out.println("Src File name: " + myFile);
System.out.println("Dst File name: " + myFileFileName);
File destFile = new File(destPath, myFileFileName);
FileUtils.copyFile(myFile, destFile);
} catch(IOException e) {
e.printStackTrace();
return ERROR;
}
return SUCCESS;
}
public File getMyFile() {
return myFile;
}
public void setMyFile(File myFile) {
this.myFile = myFile;
}
public String getMyFileContentType() {
return myFileContentType;
}
public void setMyFileContentType(String myFileContentType) {
this.myFileContentType = myFileContentType;
}
public String getMyFileFileName() {
return myFileFileName;
}
public void setMyFileFileName(String myFileFileName) {
this.myFileFileName = myFileFileName;
}
}*uploadFile.java* は非常に単純なクラスです。 注意すべき重要なことは、FileUploadインターセプターとParametersインターセプターがすべての面倒な作業を行うということです。FileUploadインターセプターは、デフォルトで3つのパラメーターを使用可能にします。 彼らは次のパターンで命名されています-
- [ファイル名パラメータ] -これは、ユーザーがアップロードした実際のファイルです。 この例では、「myFile」になります
- [ファイル名パラメータ] ContentType -これは、アップロードされたファイルのコンテンツタイプです。 この例では、「myFileContentType」になります
- [ファイル名パラメータ] FileName -これはアップロードされたファイルの名前です。 この例では、「myFileFileName」になります
Struts Interceptorsのおかげで、3つのパラメーターを使用できます。 行う必要があるのは、Actionクラスに正しい名前で3つのパラメーターを作成することです。これらの変数は自動的に自動接続されます。 そのため、上記の例では、3つのパラメーターと、すべてが正常に終了した場合に「成功」を返すアクションメソッドがあり、それ以外の場合は「エラー」を返します。
構成ファイル
以下は、ファイルのアップロードプロセスを制御するStruts2構成プロパティです-
| Sr.No | Properties & Description |
|---|---|
| 1 |
struts.multipart.maxSize ファイルのアップロードとして受け入れられるファイルの最大サイズ（バイト単位）。 デフォルトは250Mです。 |
| 2 |
struts.multipart.parser マルチパートフォームのアップロードに使用されるライブラリ。 デフォルトでは jakarta |
| 3 |
struts.multipart.saveDir 一時ファイルを保存する場所。 デフォルトではjavax.servlet.context.tempdirです。 |
これらの設定を変更するには、アップロードするファイルの最大サイズを変更するのと同じように、アプリケーションのstruts.xmlファイルで constant タグを使用できます。
次のように struts.xml を用意しましょう-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<constant name = "struts.multipart.maxSize" value = "1000000"/>
<package name = "helloworld" extends = "struts-default">
<action name = "upload" class = "com.finddevguides.struts2.uploadFile">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>*FileUpload* インターセプターはインターセプターのデフォルトスタックの一部であるため、明示的に構成する必要はありません。 ただし、<interceptor-ref>タグを<action>内に追加できます。 fileUploadインターセプターは、2つのパラメーター*（a）maximumSize *および*（b）allowedTypes *を取ります。maximumSizeパラメーターは、許可される最大ファイルサイズを設定します（デフォルトは約2MBです）。 allowedTypesパラメータは、以下に示すように、受け入れられたコンテンツ（MIME）タイプのコンマ区切りリストです-
<action name = "upload" class = "com.finddevguides.struts2.uploadFile">
<interceptor-ref name = "basicStack">
<interceptor-ref name = "fileUpload">
<param name = "allowedTypes">image/jpeg,image/gif</param>
</interceptor-ref>
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>以下は web.xml ファイルの内容です-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/upload.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
[参照]ボタンを使用してファイル「Contacts.txt」を選択し、アップロードボタンをクリックしてファイルをサーブにアップロードすると、次のページが表示されます。 アップロードされたファイルがC：\ apache-tomcat-6.0.33 \ workに保存されていることを確認できます。
FileUpload Interceptorはアップロードされたファイルを自動的に削除するため、削除される前に、アップロードされたファイルをプログラムで特定の場所に保存する必要があります。
エラーメッセージ
fileUplaodインターセプターはいくつかのデフォルトのエラーメッセージキーを使用します-
| Sr.No | Error Message Key & Description |
|---|---|
| 1 |
struts.messages.error.uploading ファイルをアップロードできなかったときに発生する一般的なエラー。 |
| 2 |
struts.messages.error.file.too.large アップロードされたファイルがmaximumSizeで指定された大きすぎる場合に発生します。 |
| 3 |
struts.messages.error.content.type.not.allowed アップロードされたファイルが、指定された予想されるコンテンツタイプと一致しない場合に発生します。 |
*WebContent/WEB-INF/classes/messages.properties* リソースファイルでこれらのメッセージのテキストをオーバーライドできます。Struts 2-データベースアクセス
この章では、Struts 2を使用して簡単な手順でデータベースにアクセスする方法を説明します。 StrutsはMVCフレームワークであり、データベースフレームワークではありませんが、JPA/Hibernate統合の優れたサポートを提供します。 休止状態の統合については後の章で説明しますが、この章ではデータベースにアクセスするために単純な古いJDBCを使用します。
この章の最初のステップは、データベースのセットアップと準備です。 この例では、MySQLをデータベースとして使用しています。 マシンにMySQLをインストールし、「struts_tutorial」という新しいデータベースを作成しました。 login というテーブルを作成し、いくつかの値を設定しました。 以下は、テーブルの作成と設定に使用したスクリプトです。
MYSQLデータベースにはデフォルトのユーザー名「root」と「root123」パスワードがあります
CREATE TABLE `struts_tutorial`.`login` (
`user` VARCHAR( 10 ) NOT NULL ,
`password` VARCHAR( 10 ) NOT NULL ,
`name` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `user` )
) ENGINE = InnoDB;
INSERT INTO `struts_tutorial`.`login` (`user`, `password`, `name`)
VALUES ('scott', 'navy', 'Scott Burgemott');次のステップは、https://dev.mysql.com/downloads/connector/j/5.1l [MySQL Connector] jarファイルをダウンロードし、このファイルをプロジェクトのWEB-INF \ libフォルダーに配置することです。 これを行った後、アクションクラスを作成する準備ができました。
アクションを作成
アクションクラスには、データベーステーブルの列に対応するプロパティがあります。 String属性として user、password および name があります。 アクションメソッドでは、ユーザーとパスワードのパラメーターを使用してユーザーが存在するかどうかを確認し、存在する場合は、次の画面にユーザー名を表示します。
ユーザーが間違った情報を入力した場合、ログイン画面に再度送信します。
以下は LoginAction.java ファイルの内容です-
package com.finddevguides.struts2;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport {
private String user;
private String password;
private String name;
public String execute() {
String ret = ERROR;
Connection conn = null;
try {
String URL = "jdbc:mysql://localhost/struts_tutorial";
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(URL, "root", "root123");
String sql = "SELECT name FROM login WHERE";
sql+=" user = ? AND password = ?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, user);
ps.setString(2, password);
ResultSet rs = ps.executeQuery();
while (rs.next()) {
name = rs.getString(1);
ret = SUCCESS;
}
} catch (Exception e) {
ret = ERROR;
} finally {
if (conn != null) {
try {
conn.close();
} catch (Exception e) {
}
}
}
return ret;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}メインページを作成
次に、JSPファイル index.jsp を作成して、ユーザー名とパスワードを収集します。 このユーザー名とパスワードは、データベースに対してチェックされます。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Login</title>
</head>
<body>
<form action = "loginaction" method = "post">
User:<br/><input type = "text" name = "user"/><br/>
Password:<br/><input type = "password" name = "password"/><br/>
<input type = "submit" value = "Login"/>
</form>
</body>
</html>ビューを作成する
次に、アクションがSUCCESSを返す場合に呼び出される success.jsp ファイルを作成しますが、アクションからERRORが返される場合は別のビューファイルがあります。
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Successful Login</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>アクションからエラーが返された場合のビューファイル error.jsp は次のようになります。
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Invalid User Name or Password</title>
</head>
<body>
Wrong user name or password provided.
</body>
</html>構成ファイル
最後に、次のようにstruts.xml構成ファイルを使用してすべてをまとめましょう-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "loginaction"
class = "com.finddevguides.struts2.LoginAction"
method = "execute">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>以下は web.xml ファイルの内容です-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
間違ったユーザー名とパスワードを入力してください。 次のページが表示されます。
ユーザー名として scott を、パスワードとして navy を入力します。 次のページが表示されます。
Struts 2-メールの送信
この章では、Struts 2アプリケーションを使用して電子メールを送信する方法について説明します。
この演習では、https://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-eeplat-419426l#javamail-1.4.4-othからmail.jarをダウンロードしてインストールする必要があります。 -JPR [JavaMail API 1.4.4]および mail.jar ファイルをWEB-INF \ libフォルダーに配置し、アクション、ビュー、および構成ファイルを作成する標準の手順に従います。
アクションを作成
次のステップは、電子メールの送信を処理するActionメソッドを作成することです。 次の内容を持つ Emailer.java という新しいクラスを作成しましょう。
package com.finddevguides.struts2;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import com.opensymphony.xwork2.ActionSupport;
public class Emailer extends ActionSupport {
private String from;
private String password;
private String to;
private String subject;
private String body;
static Properties properties = new Properties();
static {
properties.put("mail.smtp.host", "smtp.gmail.com");
properties.put("mail.smtp.socketFactory.port", "465");
properties.put("mail.smtp.socketFactory.class",
"javax.net.ssl.SSLSocketFactory");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.port", "465");
}
public String execute() {
String ret = SUCCESS;
try {
Session session = Session.getDefaultInstance(properties,
new javax.mail.Authenticator() {
protected PasswordAuthentication
getPasswordAuthentication() {
return new
PasswordAuthentication(from, password);
}
}
);
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(to));
message.setSubject(subject);
message.setText(body);
Transport.send(message);
} catch(Exception e) {
ret = ERROR;
e.printStackTrace();
}
return ret;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getTo() {
return to;
}
public void setTo(String to) {
this.to = to;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public static Properties getProperties() {
return properties;
}
public static void setProperties(Properties properties) {
Emailer.properties = properties;
}
}上記のソースコードに見られるように、 Emailer.java には、以下に示すemail.jspページのフォーム属性に対応するプロパティがあります。 これらの属性は-
- From -送信者の電子メールアドレス。 GoogleのSMTPを使用しているため、有効なgtalk IDが必要です
- パスワード-上記のアカウントのパスワード
- To -メールの送信先
- 件名-メールの件名
- Body -実際の電子メールメッセージ
上記のフィールドの検証については検討していませんが、次の章で検証を追加します。 ここで、execute（）メソッドを見てみましょう。 execute（）メソッドはjavax Mailライブラリを使用して、指定されたパラメーターを使用して電子メールを送信します。 メールが正常に送信された場合、アクションはSUCCESSを返し、そうでない場合はERRORを返します。
メインページを作成
上記の電子メール関連情報を収集するために使用されるメインページJSPファイル index.jsp を記述しましょう-
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Email Form</title>
</head>
<body>
<em>The form below uses Google's SMTP server.
So you need to enter a gmail username and password
</em>
<form action = "emailer" method = "post">
<label for = "from">From</label><br/>
<input type = "text" name = "from"/><br/>
<label for = "password">Password</label><br/>
<input type = "password" name = "password"/><br/>
<label for = "to">To</label><br/>
<input type = "text" name = "to"/><br/>
<label for = "subject">Subject</label><br/>
<input type = "text" name = "subject"/><br/>
<label for = "body">Body</label><br/>
<input type = "text" name = "body"/><br/>
<input type = "submit" value = "Send Email"/>
</form>
</body>
</html>ビューを作成する
アクションがSUCCESSを返した場合に呼び出されるJSPファイル success.jsp を使用しますが、アクションからERRORが返された場合は別のビューファイルがあります。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Email Success</title>
</head>
<body>
Your email to <s:property value = "to"/> was sent successfully.
</body>
</html>アクションからエラーが返された場合のビューファイル error.jsp は次のようになります。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Email Error</title>
</head>
<body>
There is a problem sending your email to <s:property value = "to"/>.
</body>
</html>構成ファイル
次のようにstruts.xml構成ファイルを使用してすべてをまとめましょう-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "emailer"
class = "com.finddevguides.struts2.Emailer"
method = "execute">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>以下は web.xml ファイルの内容です-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
必要な情報を入力し、[メールを送信]ボタンをクリックします。 すべてがうまくいくと、次のページが表示されます。
Struts 2-検証フレームワーク
この章では、Struts検証フレームワークをさらに詳しく見ていきます。 Strutsコアには、アプリケーションがルールを実行してアクションメソッドが実行される前に検証を実行するのを支援する検証フレームワークがあります。
クライアント側の検証は通常、Javascriptを使用して実現されます。 ただし、クライアント側の検証のみに依存するべきではありません。 ベストプラクティスでは、アプリケーションフレームワークのすべてのレベルで検証を導入することを推奨しています。 ここで、Strutsプロジェクトに検証を追加する2つの方法を見てみましょう。
ここでは、単純なページを使用して名前と年齢をキャプチャする Employee の例を取り上げ、これら2つの検証を行って、ユーザーが常に名前と年齢を入力することを確認します。 28と65。
例のメインJSPページから始めましょう。
メインページを作成
メインページJSPファイル index.jsp を作成します。これは、上記の従業員関連情報を収集するために使用されます。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20"/>
<s:textfield name = "age" label = "Age" size = "20"/>
<s:submit name = "submit" label = "Submit" align="center"/>
</s:form>
</body>
</html>index.jspはStrutsタグを使用しますが、これについてはまだ説明していませんが、タグ関連の章で学習します。 ただし、現時点では、s：textfieldタグが入力フィールドを出力し、s：submitが送信ボタンを出力すると仮定します。 各タグのラベルプロパティを使用して、各タグのラベルを作成しました。
ビューを作成する
定義されたアクションがSUCCESSを返す場合に呼び出されるJSPファイルsuccess.jspを使用します。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Success</title>
</head>
<body>
Employee Information is captured successfully.
</body>
</html>アクションを作成
そこで、小さなアクションクラス Employee を定義し、次に Employee.java ファイルに示すように* validate（）というメソッドを追加しましょう。 アクションクラスが *ActionSupport クラスを拡張していることを確認してください。そうしないと、validateメソッドが実行されません。
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport {
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void validate() {
if (name == null || name.trim().equals("")) {
addFieldError("name","The name is required");
}
if (age < 28 || age > 65) {
addFieldError("age","Age must be in between 28 and 65");
}
}
}上記の例に示すように、検証メソッドは「名前」フィールドに値があるかどうかをチェックします。 値が指定されていない場合は、カスタムエラーメッセージとともに「名前」フィールドにフィールドエラーを追加します。 次に、「Age」フィールドに入力された値が28〜65であるかどうかを確認します。この条件が満たされない場合は、検証済みフィールドの上にエラーを追加します。
構成ファイル
最後に、次のように struts.xml 構成ファイルを使用してすべてをまとめましょう-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "empinfo"
class = "com.finddevguides.struts2.Employee"
method = "execute">
<result name = "input">/index.jsp</result>
<result name = "success">/success.jsp</result>
</action>
</package>
</struts>以下は web.xml ファイルの内容です-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
必要な情報を入力せずに、[送信]ボタンをクリックしてください。 次の結果が表示されます-
必要な情報を入力しますが、間違った差出人フィールドを入力し、名前を「test」、年齢を30と言い、最後に Submit ボタンをクリックします。 次の結果が表示されます-
この検証の仕組み
ユーザーが送信ボタンを押すと、Struts 2は自動的にvalidateメソッドを実行し、メソッド内にリストされている "if" ステートメントのいずれかがtrueの場合、Struts 2はaddFieldErrorメソッドを呼び出します。 エラーが追加された場合、Struts 2はexecuteメソッドの呼び出しに進みません。 むしろ、Struts 2フレームワークは、アクションを呼び出した結果として input を返します。
したがって、検証が失敗し、Struts 2が input を返すと、Struts 2フレームワークはindex.jspファイルを再表示します。 Struts 2のフォームタグを使用したため、Struts 2はファイルされたフォームのすぐ上にエラーメッセージを自動的に追加します。
これらのエラーメッセージは、addFieldErrorメソッド呼び出しで指定したものです。 addFieldErrorメソッドは2つの引数を取ります。 最初はエラーが適用される form フィールド名で、2番目はそのフォームフィールドの上に表示されるエラーメッセージです。
addFieldError("name","The name is required");*input* の戻り値を処理するには、次の結果を *struts.xml* のアクションノードに追加する必要があります。<result name = "input">/index.jsp</result>XMLベースの検証
検証を行う2番目の方法は、アクションクラスの横にxmlファイルを配置することです。 Struts2 XMLベースの検証は、電子メール検証、整数範囲検証、フォーム検証フィールド、式検証、正規表現検証、必須検証、必須文字列検証、文字列長検証などの検証オプションを提供します。
xmlファイルには '[action-class]'-validation.xml という名前を付ける必要があります。 したがって、私たちの場合、次の内容を持つ Employee-validation.xml というファイルを作成します-
<!DOCTYPE validators PUBLIC
"-//OpenSymphony Group//XWork Validator 1.0.2//EN"
"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
<validators>
<field name = "name">
<field-validator type = "required">
<message>
The name is required.
</message>
</field-validator>
</field>
<field name = "age">
<field-validator type = "int">
<param name = "min">29</param>
<param name = "max">64</param>
<message>
Age must be in between 28 and 65
</message>
</field-validator>
</field>
</validators>上記のXMLファイルは、理想的にはクラスファイルとともにCLASSPATHに保存されます。 * validate（）*メソッドを使用せずに、次のようにEmployeeアクションクラスを作成します。
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport{
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}セットアップの残りの部分は前の例のままです。アプリケーションを実行すると、前の例で受け取ったものと同じ結果が生成されます。
構成を保存するためのxmlファイルを持つことの利点は、アプリケーションコードから検証を分離することを可能にします。 開発者にコードを記述させ、ビジネスアナリストに検証xmlファイルを作成させることができます。 もう1つ注意すべきことは、デフォルトで使用可能なバリデータータイプです。
Strutsにはデフォルトで付属するバリデーターがたくさんあります。 一般的なバリデータには、日付バリデータ、正規表現バリデータ、文字列長バリデータが含まれます。 詳細については、次のリンクを確認してください：/struts_2/xml_based_validators [Struts-XML Based Validators]。
Struts2-ローカリゼーション、国際化（i18n）
国際化（i18n）は、製品とサービスを特定の現地の言語と文化に簡単に適合させることができるように、製品とサービスを計画および実装するプロセスです。ローカリゼーションと呼ばれるプロセスです。 国際化プロセスは、翻訳またはローカリゼーションの有効化と呼ばれます。
国際化は i18n と省略されます。これは、単語が文字「」で始まり、「」で終わるため、最初のiと最後のnの間に18文字があるためです。
Struts2は、ローカライズ、つまり、以下の場所でリソースバンドル、インターセプター、およびタグライブラリを介した国際化（i18n）サポートを提供します-
- UIタグ
- メッセージとエラー。
- アクションクラス内。
リソースバンドル
Struts2はリソースバンドルを使用して、Webアプリケーションのユーザーに複数の言語およびロケールオプションを提供します。 異なる言語でページを書くことを心配する必要はありません。 必要なことは、必要な言語ごとにリソースバンドルを作成することです。 リソースバンドルには、ユーザーの言語のタイトル、メッセージ、およびその他のテキストが含まれます。 リソースバンドルは、アプリケーションのデフォルト言語のキー/値のペアを含むファイルです。
リソースファイルの最も簡単な命名形式は-
bundlename_language_country.propertiesここで、 bundlename は、ActionClass、Interface、SuperClass、Model、Package、Globalリソースプロパティです。 次の部分 language_country は国のロケールを表します。たとえば、スペイン語（スペイン）ロケールはes_ESで表され、英語（米国）ロケールはen_USなどで表されます。 ここでは、オプションである国の部分をスキップできます。
あなたがそのキーによってメッセージ要素を参照するとき、Strutsフレームワークは次の順序で対応するメッセージバンドルを検索します-
- ActionClass.properties
- Interface.properties
- SuperClass.properties
- model.properties
- package.properties
- struts.properties
- global.properties
アプリケーションを複数の言語で開発するには、それらの言語/ロケールに対応する複数のプロパティファイルを維持し、キー/値のペアに関してすべてのコンテンツを定義する必要があります。
たとえば、米国英語（デフォルト）、スペイン語、フランス語のアプリケーションを開発する場合、3つのプロパティファイルを作成する必要があります。 ここでは、 global.properties ファイルのみを使用します。異なるプロパティファイルを使用して、異なるタイプのメッセージを分離することもできます。
- global.properties -デフォルトでは英語（米国）が適用されます
- global_fr.properties -これはFranchロケールに使用されます。
- global_es.properties -これはスペイン語ロケールで使用されます。
メッセージにアクセスする
getText、textタグ、UIタグのキー属性、i18nタグなど、メッセージリソースにアクセスする方法がいくつかあります。 それらを簡単に見てみましょう-
*i18n* テキストを表示するには、プロパティタグで *getText* の呼び出しを使用するか、次のようなUIタグなどの他のタグを使用します-<s:property value = "getText('some.key')"/>- textタグ*は、デフォルトのリソースバンドル（struts.properties）からメッセージを取得します
<s:text name = "some.key"/>- i18nタグ*は、任意のリソースバンドルを値スタックにプッシュします。 i18nタグのスコープ内の他のタグは、そのリソースバンドルからのメッセージを表示できます。
<s:i18n name = "some.package.bundle">
<s:text name = "some.key"/>
</s:i18n>ほとんどのUIタグの key 属性を使用して、リソースバンドルからメッセージを生成できます-
<s:textfield key = "some.key" name = "textfieldName"/>ローカリゼーションの例
複数の言語で前の章の index.jsp を作成することをターゲットにしましょう。 同じファイルは次のように書かれます-
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Employee Form with Multilingual Support</title>
</head>
<body>
<h1><s:text name = "global.heading"/></h1>
<s:url id = "indexEN" namespace="/" action = "locale" >
<s:param name = "request_locale" >en</s:param>
</s:url>
<s:url id = "indexES" namespace="/" action = "locale" >
<s:param name = "request_locale" >es</s:param>
</s:url>
<s:url id = "indexFR" namespace="/" action = "locale" >
<s:param name = "request_locale" >fr</s:param>
</s:url>
<s:a href="%{indexEN}" >English</s:a>
<s:a href="%{indexES}" >Spanish</s:a>
<s:a href="%{indexFR}" >France</s:a>
<s:form action = "empinfo" method = "post" namespace = "/">
<s:textfield name = "name" key = "global.name" size = "20"/>
<s:textfield name = "age" key = "global.age" size = "20"/>
<s:submit name = "submit" key = "global.submit"/>
</s:form>
</body>
</html>定義されたアクションが SUCCESS を返す場合に呼び出される success.jsp ファイルを作成します。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Success</title>
</head>
<body>
<s:property value = "getText('global.success')"/>
</body>
</html>ここでは、次の2つのアクションを作成する必要があります。 （a）ロケールを処理し、同じindex.jspファイルを異なる言語で表示する最初のアクションa（b）別のアクションは、フォーム自体の送信を処理することです。 両方のアクションがSUCCESSを返しますが、目的は両方のアクションで異なるため、戻り値に基づいて異なるアクションを実行します
ロケールの世話をするアクション
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Locale extends ActionSupport {
public String execute() {
return SUCCESS;
}
}フォームを送信するアクション
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Employee extends ActionSupport{
private String name;
private int age;
public String execute() {
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}ここで、次の3つの global.properties ファイルを作成し、 CLASSPATH に入れます。
global.properties
global.name = Name
global.age = Age
global.submit = Submit
global.heading = Select Locale
global.success = Successfully authenticatedglobal_fr.properties
global.name = Nom d'utilisateur
global.age = l'âge
global.submit = Soumettre des
global.heading = Sé lectionnez Local
global.success = Authentifi é avec succèsglobal_es.properties
global.name = Nombre de usuario
global.age = Edad
global.submit = Presentar
global.heading = seleccionar la configuracion regional
global.success = Autenticado correctamente次の2つのアクションを使用して struts.xml を作成します-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<constant name = "struts.custom.i18n.resources" value = "global"/>
<package name = "helloworld" extends = "struts-default" namespace="/">
<action name = "empinfo"
class = "com.finddevguides.struts2.Employee"
method = "execute">
<result name = "input">/index.jsp</result>
<result name = "success">/success.jsp</result>
</action>
<action name = "locale"
class = "com.finddevguides.struts2.Locale"
method = "execute">
<result name = "success">/index.jsp</result>
</action>
</package>
</struts>以下は web.xml ファイルの内容です-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
今、言語のいずれかを選択し、私たちは*スペイン語*を選択したとしましょう、それは次の結果を表示します-
フランス語も試してみることができます。 最後に、スペイン語のロケールにいるときに[送信]ボタンをクリックしてみてください。次の画面が表示されます-
おめでとうございます、多言語のウェブページができたので、ウェブサイトをグローバルに立ち上げることができます。
Struts 2-タイプ変換
HTTPリクエストのすべては、プロトコルによって String として扱われます。 これには、数字、ブール値、整数、日付、小数などが含まれます。 ただし、Strutsクラスでは、任意のデータ型のプロパティを使用できます。
Strutsはどのようにプロパティを自動配線しますか？
*Struts* は、カバーの下にあるさまざまなタイプコンバーターを使用して、重量物を持ち上げます。たとえば、Actionクラスに整数属性がある場合、Strutsは何もせずに要求パラメーターを整数属性に自動的に変換します。 デフォルトでは、Strutsには多数のタイプコンバーターが付属しています
あなたが以下にリストされたコンバータのいずれかを使用している場合、あなたは心配することは何もありません-
- 整数、浮動小数点、倍精度、10進数
- 日付と日時
- 配列とコレクション
- 列挙型
- ブール値
- BigDecimal
独自のデータ型を使用している場合、表示する前にこれらの値を変換する方法をStrutsに認識させるために独自のコンバーターを追加する必要があります。 次のPOJOクラス Environment.java を検討してください。
package com.finddevguides.struts2;
public class Environment {
private String name;
public Environment(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}これは name という属性を持つ非常に単純なクラスなので、このクラスについて特別なことは何もありません。 システム- SystemDetails.java に関する情報を含む別のクラスを作成しましょう。
この演習では、環境を「開発」に、オペレーティングシステムを「Windows XP SP3」にハードコーディングしました。
リアルタイムプロジェクトでは、この情報をシステム構成から取得します。
私たちは次のアクションクラスを持ってみましょう-
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class SystemDetails extends ActionSupport {
private Environment environment = new Environment("Development");
private String operatingSystem = "Windows XP SP3";
public String execute() {
return SUCCESS;
}
public Environment getEnvironment() {
return environment;
}
public void setEnvironment(Environment environment) {
this.environment = environment;
}
public String getOperatingSystem() {
return operatingSystem;
}
public void setOperatingSystem(String operatingSystem) {
this.operatingSystem = operatingSystem;
}
}次に、単純なJSPファイル System.jsp を作成して、環境とオペレーティングシステムの情報を表示します。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>System Details</title>
</head>
<body>
Environment: <s:property value = "environment"/><br/>
Operating System:<s:property value = "operatingSystem"/>
</body>
</html>*struts.xml* を使用して、 *system.jsp* と *SystemDetails.java* クラスをまとめて配線しましょう。SystemDetailsクラスには、文字列「 SUCCESS 」を返す単純なexecute（）メソッドがあります。
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "system"
class = "com.finddevguides.struts2.SystemDetails"
method = "execute">
<result name = "success">/System.jsp</result>
</action>
</package>
</struts>- プロジェクト名を右クリックし、[エクスポート]> [WARファイル]をクリックして、WARファイルを作成します。
- 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL http：//localhost：8080/HelloWorldStruts2/system.action *にアクセスしてみます。 これにより、次の画面が生成されます-
上記の出力の何が問題になっていますか？ Strutsは、文字列「Windows XP SP3」およびその他の組み込みデータ型を表示および変換する方法を知っていますが、 Environment 型のプロパティをどう処理するかを知りません。 それは単にクラスの* toString（）*メソッドと呼ばれます
この問題を解決するために、Environmentクラスの単純な TypeConverter を作成して登録しましょう。
以下を使用して EnvironmentConverter.java というクラスを作成します。
package com.finddevguides.struts2;
import java.util.Map;
import org.apache.struts2.util.StrutsTypeConverter;
public class EnvironmentConverter extends StrutsTypeConverter {
@Override
public Object convertFromString(Map context, String[] values, Class clazz) {
Environment env = new Environment(values[0]);
return env;
}
@Override
public String convertToString(Map context, Object value) {
Environment env = (Environment) value;
return env == null ? null : env.getName();
}
}*EnvironmentConverter* は *StrutsTypeConverter* クラスを拡張し、Strutsに* convertFromString（）*および* convertToString（）*の2つのメソッドをオーバーライドすることで、EnvironmentをStringに、またはその逆に変換する方法を指示します。アプリケーションで使用する前に、このコンバーターを登録しましょう。 コンバーターを登録するには2つの方法があります。
コンバーターが特定のアクションでのみ使用される場合、 '[action-class]' converstion.properties という名前を付ける必要があるプロパティファイルを作成する必要があります。
私たちの場合、次の登録エントリを持つ SystemDetails-converstion.properties というファイルを作成します-
environment = com.finddevguides.struts2.EnvironmentConverter上記の例では、「environment」は SystemDetails.java クラスのプロパティの名前であり、このプロパティとの間の変換に EnvironmentConverter を使用するようStrutsに指示しています。
ただし、これを行うのではなく、アプリケーション全体で使用できるように、このコンバーターをグローバルに登録します。 これを行うには、 WEBINF/classes フォルダーに次の行で xwork-conversion.properties というプロパティファイルを作成します
com.finddevguides.struts2.Environment = \
com.finddevguides.struts2.EnvironmentConverterこれはコンバーターをグローバルに登録するだけなので、 Struts は、Environmentタイプのオブジェクトに遭遇するたびに自動的に変換を実行できます。 今、あなたがプログラムを再コンパイルして再実行すると、次のようなより良い出力が得られます-
明らかに、結果はより良くなり、Strutsコンバーターは正常に動作しています。
これは、複数のコンバーターを作成し、要件に従って使用するためにそれらを登録する方法です。
Struts 2-テーマとテンプレート
この章の実際のチュートリアルを開始する前に、https://struts.apache.orgで指定されているいくつかの定義を見てみましょう。
| Sr.No | Term & Description |
|---|---|
| 1 |
TAG JSP、FreeMarker、またはVelocity内から実行される小さなコード。 |
| 2 |
TEMPLATE 通常はFreeMarkerで記述された特定のタグ（HTMLタグ）でレンダリングできるコード。 |
| 3 |
THEME 共通の機能を提供するために一緒にパッケージ化されたテンプレートのコレクション。 |
また、リンク：/struts_2/struts_localization [Struts2 Localization]の章を参照することをお勧めします。エクササイズを実行するためにもう一度同じ例を使用するためです。
Webページで<s：submit …>、<s：textfield …>などの Struts 2 タグを使用すると、Struts 2フレームワークは事前に構成されたスタイルとレイアウトでHTMLコードを生成します。 Struts 2には3つの組み込みテーマが付属しています-
| Sr.No | Theme & Description |
|---|---|
| 1 |
SIMPLE theme 「添えもの」のない最小限のテーマ。 たとえば、textfieldタグは、ラベル、検証、エラー報告、またはその他のフォーマットや機能なしでHTML <input/>タグをレンダリングします。 |
| 2 |
XHTML theme これは、Struts 2で使用されるデフォルトのテーマであり、シンプルテーマが提供するすべての基本を提供し、HTMLの標準2列テーブルレイアウト、各HTMLのラベル、検証、エラー報告などのいくつかの機能を追加します。 |
| 3 |
CSS_XHTML theme このテーマは、シンプルなテーマが提供するすべての基本を提供し、HTML Strutsタグの<div>、CSSスタイルシートに従って配置された各HTML Strutsタグのラベルを使用する、標準の2列CSSベースのレイアウトなどのいくつかの機能を追加します。 |
上記のように、テーマを指定しない場合、Struts 2はデフォルトでxhtmlテーマを使用します。 たとえば、このStruts 2選択タグ-
<s:textfield name = "name" label = "Name"/>次のHTMLマークアップを生成します-
<tr>
<td class="tdLabel">
<label for = "empinfo_name" class="label">Name:</label>
</td>
<td>
<input type = "text" name = "name" value = "" id = "empinfo_name"/>
</td>
</tr>ここで、 empinfo はstruts.xmlファイルで定義されたアクション名です。
テーマの選択
あなたは、Struts 2、タグごとにテーマを指定するか、次のいずれかの方法を使用して、Struts 2が使用するテーマを指定できます-
- 特定のタグのテーマ属性
- タグの周囲のフォームタグのテーマ属性
- 「テーマ」という名前のページスコープ属性
- 「テーマ」という名前の要求スコープ属性
- 「テーマ」という名前のセッションスコープ属性
- 「テーマ」という名前のアプリケーションスコープの属性
- struts.propertiesのstruts.ui.themeプロパティ（デフォルトはxhtml）
異なるタグに異なるテーマを使用する場合は、タグレベルでそれらを指定する構文を次に示します-
<s:textfield name = "name" label = "Name" theme="xhtml"/>テーマをタグごとに使用することはあまり実用的ではないため、次のタグを使用して struts.properties ファイルでルールを指定するだけです。
# Standard UI theme
struts.ui.theme = xhtml
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the default template type. Either ftl, vm, or jsp
struts.ui.templateSuffix = ftl以下は、ローカライズの章から選択した結果で、デフォルトのテーマを使用し、デフォルトでstruts2-core.xy.zにある struts-default.properties ファイルで struts.ui.theme = xhtml の設定を使用しました。 jarファイル。
テーマの仕組み
特定のテーマに対して、すべてのstrutsタグには、 s：textfield→text.ftl および s：password→password.ftl などの関連テンプレートがあります。
これらのテンプレートファイルは、struts2-core.xy.z.jarファイルに圧縮されています。 これらのテンプレートファイルは、タグごとに事前定義されたHTMLレイアウトを保持します。
このようにして、 Struts 2 フレームワークは、Sturtsタグと関連テンプレートを使用して最終的なHTMLマークアップコードを生成します。
Struts 2 tags + Associated template file = Final HTML markup code.デフォルトのテンプレートはFreeMarkerで書かれており、拡張子は .ftl です。
速度またはJSPを使用してテンプレートを設計し、それに応じて struts.ui.templateSuffix および struts.ui.templateDir を使用してstruts.propertiesの構成を設定することもできます。
新しいテーマの作成
新しいテーマを作成する最も簡単な方法は、既存のテーマ/テンプレートファイルをコピーし、必要な変更を加えることです。
_WebContent/WEBINF/classes_に template というフォルダーと、新しいテーマの名前を持つサブフォルダーを作成することから始めましょう。 たとえば、_WebContent/WEB-INF/classes/template/mytheme_のようになります。
ここから、テンプレートの構築をゼロから開始できます。または、* Struts2ディストリビューション*からテンプレートをコピーして、必要に応じてテンプレートを変更することもできます。
学習目的で既存のデフォルトテンプレート xhtml を変更します。 次に、struts2-core-x.y.z.jar/template/xhtml_からコンテンツをテーマディレクトリにコピーし、_WebContent/WEBINF/classes/template/mytheme/control.ftlファイルのみを変更します。 次の行を持つcontrol.ftlを開くと-
<table class="${parameters.cssClass?default('wwFormTable')?html}"<#rt/>
<#if parameters.cssStyle??> style="${parameters.cssStyle?html}"<#rt/>
</#if>
>上記のファイル control.ftl を次の内容に変更します-
<table style = "border:1px solid black;">*form.ftl* をチェックすると、このファイルで *control.ftl* が使用されていることがわかりますが、form.ftlはxhtmlテーマからこのファイルを参照しています。 次のように変更します-<#include "/${parameters.templateDir}/xhtml/form-validate.ftl"/>
<#include "/${parameters.templateDir}/simple/form-common.ftl"/>
<#if (parameters.validate?default(false))>
onreset = "${parameters.onreset?default('clearErrorMessages(this);\
clearErrorLabels(this);')}"
<#else>
<#if parameters.onreset??>
onreset="${parameters.onreset?html}"
</#if>
</#if>
#include "/${parameters.templateDir}/mytheme/control.ftl"/>*FreeMarker* テンプレート言語をあまり理解していないと思いますが、それでも.ftlファイルを見れば何をすべきかをよく理解できます。ただし、上記の変更を保存し、ローカライズの例に戻って、次のコンテンツで WebContent/WEB-INF/classes/struts.properties ファイルを作成しましょう
# Customized them
struts.ui.theme = mytheme
# Directory where theme template resides
struts.ui.templateDir = template
# Sets the template type to ftl.
struts.ui.templateSuffix = ftlこの変更後、プロジェクト名を右クリックし、エクスポート> WARファイル*をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動し、URL *http：//localhost：8080/HelloWorldStruts2 にアクセスしてみます。 これにより、次の画面が生成されます-
xhtmlテーマからコピーした後、outテーマで行った変更の結果であるフォームコンポーネントの周囲に境界線が表示されます。 FreeMarkerの学習にほとんど力を入れなければ、テーマを非常に簡単に作成または変更できます。
*Sturts 2* のテーマとテンプレートの基本的な理解ができたことを願っています。Struts 2-例外処理
*Struts* は、キャッチされない例外を処理し、専用のエラーページにユーザーをリダイレクトする簡単な方法を提供します。 例外ごとに異なるエラーページを持つようにStrutsを簡単に構成できます。Strutsは、「例外」インターセプターを使用することにより、例外処理を容易にします。 「例外」インターセプターはデフォルトスタックの一部として含まれているため、特別な設定を行う必要はありません。 すぐに使用でき、すぐに使用できます。
HelloWorldAction.javaファイルに変更を加えた簡単なHello Worldの例を見てみましょう。 ここでは、 HelloWorldAction アクションコードにNullPointer例外を意図的に導入しました。
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class HelloWorldAction extends ActionSupport{
private String name;
public String execute(){
String x = null;
x = x.substring(0);
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}次のように HelloWorld.jsp の内容を保持しましょう-
<%@ page contentType = "text/html; charset = UTF-8" %>
<%@ taglib prefix = "s" uri = "/struts-tags" %>
<html>
<head>
<title>Hello World</title>
</head>
<body>
Hello World, <s:property value = "name"/>
</body>
</html>以下は index.jsp の内容です-
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2</h1>
<form action = "hello">
<label for = "name">Please enter your name</label><br/>
<input type = "text" name = "name"/>
<input type = "submit" value = "Say Hello"/>
</form>
</body>
</html>あなたの struts.xml は次のようになります-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
値「Struts2」を入力して、ページを送信します。 次のページが表示されます-
上記の例に示されているように、デフォルトの例外インターセプターは例外を処理する上で素晴らしい仕事をします。
ここで、例外用の専用エラーページを作成しましょう。 次の内容で Error.jsp と呼ばれるファイルを作成します-
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title></title>
</head>
<body>
This is my custom error page
</body>
</html>例外が発生した場合にこのエラーページを使用するようにStrutsを構成しましょう。 次のように struts.xml を変更しましょう-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<exception-mapping exception = "java.lang.NullPointerException"
result = "error"/>
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/Error.jsp</result>
</action>
</package>
</struts>上記の例に示すように、NullPointerException専用のError.jspを使用するようにStrutsを構成しました。 ここでプログラムを再実行すると、次の出力が表示されます-
これに加えて、Struts2フレームワークには、例外をログに記録するための「ロギング」インターセプターが付属しています。 ロガーがキャッチされなかった例外をログに記録できるようにすることで、スタックトレースを簡単に確認して、何が問題だったかを突き止めることができます。
グローバル例外マッピング
アクション固有の例外を処理する方法を見てきました。 すべてのアクションに適用される例外をグローバルに設定できます。 たとえば、同じNullPointerException例外をキャッチするには、<package …>タグ内に <global-exception-mappings …> タグを追加し、その<result …>タグを<action内に追加する必要があります…> struts.xmlファイルの次のタグ-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<global-exception-mappings>
<exception-mapping exception = "java.lang.NullPointerException"
result = "error"/>
</global-exception-mappings>
<action name = "hello"
class = "com.finddevguides.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/Error.jsp</result>
</action>
</package>
</struts>Struts 2-注釈
前述のように、Strutsは2つの形式の構成を提供します。 従来の方法は、すべての構成に struts.xml ファイルを使用することです。 これまでのチュートリアルでは、これに関する非常に多くの例を見てきました。 Strutsを構成するもう1つの方法は、Java 5アノテーション機能を使用することです。 strutsアノテーションを使用して、*ゼロ構成*を実現できます。
プロジェクトで注釈の使用を開始するには、次のjarファイルが WebContent/WEB-INF/lib フォルダーに含まれていることを確認してください-
- struts2-convention-plugin-x.y.z.jar
- asm-x.y.jar
- antlr-x.y.z.jar
- commons-fileupload-x.y.z.jar
- commons-io-x.y.z.jar
- commons-lang-x.y.jar
- commons-logging-x.y.z.jar
- commons-logging-api-x.y.jar
- freemarker-x.y.z.jar
- javassist-.xy.z.GA
- ognl-x.y.z.jar
- struts2-core-x.y.z.jar
- xwork-core.x.y.z.jar
ここで、 struts.xml ファイルで使用可能な構成を廃止し、注釈に置き換える方法を見てみましょう。
Struts2でのアノテーションの概念を説明するには、リンク：/struts_2/struts_validations [Struts2検証]の章で説明されている検証例を再検討する必要があります。
ここでは、単純なページを使用して名前と年齢をキャプチャする従業員の例を取り上げます。2つの検証を行い、ÜSERが常に名前を入力し、年齢が28〜65の間にあることを確認します。
例のメインJSPページから始めましょう。
メインページを作成
メインページJSPファイル index.jsp を作成します。このファイルは、上記の従業員関連情報を収集するために使用されます。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20"/>
<s:textfield name = "age" label = "Age" size = "20"/>
<s:submit name = "submit" label = "Submit" align="center"/>
</s:form>
</body>
</html>index.jspはStrutsタグを使用しますが、これについてはまだ説明していませんが、タグ関連の章でそれらを学習します。 ただし、現時点では、s：textfieldタグが入力フィールドを出力し、s：submitが送信ボタンを出力すると仮定します。 各タグのラベルプロパティを使用して、各タグのラベルを作成しました。
ビューを作成する
定義済みのアクションが SUCCESS を返す場合に呼び出されるJSPファイル success.jsp を使用します。
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Success</title>
</head>
<body>
Employee Information is captured successfully.
</body>
</html>アクションを作成
これは、注釈が使用される場所です。 アノテーションを使用してアクションクラス Employee を再定義し、次に Employee.java ファイルに示すように* validate（）というメソッドを追加します。 アクションクラスが *ActionSupport クラスを拡張していることを確認してください。そうしないと、validateメソッドが実行されません。
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import com.opensymphony.xwork2.validator.annotations.*;
@Results({
@Result(name = "success", Location = "/success.jsp"),
@Result(name = "input", Location = "/index.jsp")
})
public class Employee extends ActionSupport {
private String name;
private int age;
@Action(value = "/empinfo")
public String execute() {
return SUCCESS;
}
@RequiredFieldValidator( message = "The name is required" )
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@IntRangeFieldValidator(message = "Age must be in between 28 and 65", min = "29", max = "65")
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}この例では、いくつかの注釈を使用しました。 私はそれらを一つずつ見ていきましょう-
- 最初に、 Results 注釈を含めました。 結果注釈は結果のコレクションです。
- 結果の注釈の下に、2つの結果の注釈があります。 結果の注釈には、executeメソッドの結果に対応する*名前*があります。 これらには、execute（）からの戻り値に対応するビューを提供する場所も含まれています。
- 次の注釈は Action 注釈です。 これは、execute（）メソッドを修飾するために使用されます。 Actionメソッドは、アクションが呼び出されるURLである値も受け取ります。
- 最後に、2つの validation 注釈を使用しました。 name フィールドに必須フィールドバリデーターを、 age フィールドに整数範囲バリデーターを構成しました。 検証用のカスタムメッセージも指定しました。
構成ファイル
本当に struts.xml 構成ファイルは必要ないので、このファイルを削除して web.xml ファイルの内容を確認しましょう-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
<init-param>
<param-name>struts.devMode</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/index.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
必要な情報を入力せずに、[送信]ボタンをクリックしてください。 次の結果が表示されます-
必要な情報を入力しますが、間違った差出人フィールドを入力し、名前を「test」、年齢を30と言い、最後に Submit ボタンをクリックします。 次の結果が表示されます-
Struts 2アノテーションタイプ
Struts 2アプリケーションは、XMLおよびJavaプロパティ構成の代替としてJava 5アノテーションを使用できます。 あなたは、さまざまなカテゴリに関連する最も重要な注釈のリストを確認することができます-
リンク：/struts_2/struts_annotations_types [Struts 2アノテーションタイプ]。
Struts 2-コントロールタグ
Struts 2タグには、ページ実行のフローを簡単に制御できるタグのセットがあります。
以下は重要なStruts 2コントロールタグのリストです-
IfおよびElseタグ
これらのタグは、すべての言語で見られる基本的な条件フローを実行します。
*'If'* タグは単独で、または *'Else If'* タグおよび/または単一または複数の *'Else'* タグとともに使用されます。<s:if test = "%{false}">
<div>Will Not Be Executed</div>
</s:if>
<s:elseif test = "%{true}">
<div>Will Be Executed</div>
</s:elseif>
<s:else>
<div>Will Not Be Executed</div>
</s:else>リンク：/struts_2/struts_if_else_tags [詳細な例を確認]
イテレータタグ
この iterator は値を反復処理します。 反復可能な値は、itherjava.util.Collectionまたはjava.util.Iteratorファイルのいずれかです。 イテレータを反復処理している間、 Sort タグを使用して結果をソートするか、 SubSet タグを使用してリストまたは配列のサブセットを取得できます。
次の例では、値スタック上の現在のオブジェクトのgetDays（）メソッドの値を取得し、それを使用して繰り返します。
<s：property/>タグは、イテレーターの現在の値を出力します。
<s:iterator value = "days">
<p>day is: <s:property/></p>
</s:iterator>リンク：/struts_2/struts_iterator_tags [詳細な例を確認]
マージタグ
これらの merge タグは2つ以上のリストをパラメーターとして受け取り、以下に示すようにそれらをすべてマージします-
<s:merge var = "myMergedIterator">
<s:param value = "%{myList1}"/>
<s:param value = "%{myList2}"/>
<s:param value = "%{myList3}"/>
</s:merge>
<s:iterator value = "%{#myMergedIterator}">
<s:property/>
</s:iterator>リンク：/struts_2/struts_merge_tag [詳細な例を確認]
追加タグ
これらの append タグは、パラメータとして2つ以上のリストを取り、以下に示すようにそれらをすべて一緒に追加します-
<s:append var = "myAppendIterator">
<s:param value = "%{myList1}"/>
<s:param value = "%{myList2}"/>
<s:param value = "%{myList3}"/>
</s:append>
<s:iterator value = "%{#myAppendIterator}">
<s:property/>
</s:iterator>link：/struts_2/struts_append_tag [詳細な例を確認]
ジェネレータータグ
これらの generator タグは、指定されたval属性に基づいて反復子を生成します。 次のジェネレータタグは、イテレータを生成し、イテレータタグを使用して出力します。
<s:generator val = "%{'aaa,bbb,ccc,ddd,eee'}">
<s:iterator>
<s:property/><br/>
</s:iterator>
</s:generator>リンク：/struts_2/struts_generator_tag [詳細な例を確認]
Struts 2-データタグ
Struts 2 *データタグ*は、主にページに表示されるデータを操作するために使用されます。 以下に重要なデータタグを示します。<ここから開始>
アクションタグ
このタグにより、開発者はアクション名とオプションのネームスペースを指定することにより、JSPページから直接アクションを呼び出すことができます。 タグの本文コンテンツは、アクションからの結果をレンダリングするために使用されます。 executeResultパラメーターが指定されない限り、struts.xmlでこのアクションに対して定義された結果プロセッサーは無視されます。
<div>Tag to execute the action</div>
<br/>
<s:action name = "actionTagAction" executeresult = "true"/>
<br/>
<div>To invokes special method in action class</div>
<br/>
<s:action name = "actionTagAction!specialMethod" executeresult = "true"/>リンク：/struts_2/struts_action_tag [詳細な例を確認]
インクルードタグ
これらの include は、JSPファイルを別のJSPページに含めるために使用されます。
<-- First Syntax -->
<s:include value = "myJsp.jsp"/>
<-- Second Syntax -->
<s:include value = "myJsp.jsp">
<s:param name = "param1" value = "value2"/>
<s:param name = "param2" value = "value2"/>
</s:include>
<-- Third Syntax -->
<s:include value = "myJsp.jsp">
<s:param name = "param1">value1</s:param>
<s:param name = "param2">value2</s:param>
</s:include>リンク：/struts_2/struts_include_tag [詳細な例を確認]
Beanタグ
これらの bean タグは、JavaBeans仕様に準拠するクラスをインスタンス化します。 このタグには、そのクラスのミューテーターメソッドを設定するためのいくつかのParam要素を含むことができる本体があります。 var属性がBeanTagに設定されている場合、インスタンス化されたBeanはスタックのコンテキストに配置されます。
<s:bean name = "org.apache.struts2.util.Counter" var = "counter">
<s:param name = "first" value = "20"/>
<s:param name = "last" value = "25"/>
</s:bean>リンク：/struts_2/struts_bean_tag [詳細な例を確認]
日付タグ
これらの date タグを使用すると、すばやく簡単に日付をフォーマットできます。 カスタム形式を指定できます（例： 「dd/MM/yyyy hh：mm」）、読みやすい表記（「2時間、14分」など）を生成するか、キー 'struts.date.format’を使用して定義済みの形式にフォールバックできますプロパティファイル。
<s:date name = "person.birthday" format = "dd/MM/yyyy"/>
<s:date name = "person.birthday" format = "%{getText('some.i18n.key')}"/>
<s:date name = "person.birthday" nice="true"/>
<s:date name = "person.birthday"/>リンク：/struts_2/struts_date_tag [詳細な例を確認]
Paramタグ
これらの param タグは、他のタグをパラメーター化するために使用できます。 このタグには、次の2つのパラメーターがあります。
- name（文字列）-パラメータの名前
- 値（オブジェクト）-パラメータの値
<pre>
<ui:component>
<ui:param name = "key" value = "[0]"/>
<ui:param name = "value" value = "[1]"/>
<ui:param name = "context" value = "[2]"/>
</ui:component>
</pre>link：/struts_2/struts_param_tag [詳細な例を確認]
プロパティタグ
これらの property タグは、値のプロパティを取得するために使用されます。値が指定されていない場合、デフォルトでスタックの一番上になります。
<s:push value = "myBean">
<!-- Example 1: -->
<s:property value = "myBeanProperty"/>
<!-- Example 2: -->TextUtils
<s:property value = "myBeanProperty" default = "a default value"/>
</s:push>リンク：/struts_2/struts_property_tag [詳細な例を確認]
プッシュタグ
これらの push タグは、使用を簡素化するためにスタックに値をプッシュするために使用されます。
<s:push value = "user">
<s:propery value = "firstName"/>
<s:propery value = "lastName"/>
</s:push>リンク：/struts_2/struts_push_tag [詳細な例を確認]
セットタグ
これらの set タグは、指定されたスコープ内の変数に値を割り当てます。 変数を複雑な式に割り当て、複雑な式ではなくその変数を毎回単純に参照する場合に便利です。 利用可能なスコープは、 application、session、request、page 、および action です。
<s:set name = "myenv" value = "environment.name"/>
<s:property value = "myenv"/>リンク：/struts_2/struts_set_tag [詳細な例を確認]
テキストタグ
これらの text タグは、I18nテキストメッセージを表示するために使用されます。
<!-- First Example -->
<s:i18n name = "struts.action.test.i18n.Shop">
<s:text name = "main.title"/>
</s:i18n>
<!-- Second Example -->
<s:text name = "main.title"/>
<!-- Third Examlpe -->
<s:text name = "i18n.label.greetings">
<s:param >Mr Smith</s:param>
</s:text>リンク：/struts_2/struts_text_tag [詳細な例を確認]
URLタグ
これらの url タグは、URLを作成するために使用されます。
<-- Example 1 -->
<s:url value = "editGadget.action">
<s:param name = "id" value = "%{selected}"/>
</s:url>
<-- Example 2 -->
<s:url action = "editGadget">
<s:param name = "id" value = "%{selected}"/>
</s:url>
<-- Example 3-->
<s:url includeParams="get">
<s:param name = "id" value = "%{'22'}"/>
</s:url>link：/struts_2/struts_url_tag [詳細な例を確認]
Struts 2-フォームタグ
*form* タグのリストは、Struts UIタグのサブセットです。 これらのタグは、Struts Webアプリケーションに必要なユーザーインターフェイスのレンダリングに役立ち、3つのカテゴリに分類できます。 この章では、3種類のUIタグすべてについて説明します。シンプルなUIタグ
これらのタグはすでに例で使用していますが、この章ではそれらをブラッシングします。 いくつかのシンプルなUIタグを持つシンプルなビューページ email.jsp を見てみましょう-
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<s:head/>
<title>Hello World</title>
</head>
<body>
<s:div>Email Form</s:div>
<s:text name = "Please fill in the form below:"/>
<s:form action = "hello" method = "post" enctype = "multipart/form-data">
<s:hidden name = "secret" value = "abracadabra"/>
<s:textfield key = "email.from" name = "from"/>
<s:password key = "email.password" name = "password"/>
<s:textfield key = "email.to" name = "to"/>
<s:textfield key = "email.subject" name = "subject"/>
<s:textarea key = "email.body" name = "email.body"/>
<s:label for = "attachment" value = "Attachment"/>
<s:file name = "attachment" accept = "text/html,text/plain"/>
<s:token/>
<s:submit key = "submit"/>
</s:form>
</body>
</html>HTMLを認識している場合、使用されるタグはすべて、非常に一般的なHTMLタグであり、追加のプレフィックス* s：*が各タグと異なる属性とともに追加されています。 上記のプログラムを実行すると、使用するすべてのキーに対して適切なマッピングが設定されていれば、次のユーザーインターフェイスが表示されます。
示されているように、s：headは、Struts2アプリケーションに必要なjavascriptおよびスタイルシート要素を生成します。
次に、s：div要素とs：text要素があります。 s：divは、HTML Div要素をレンダリングするために使用されます。 これは、HTMLタグとStrutsタグを混在させたくない人に役立ちます。 それらの人々のために、彼らはdivをレンダリングするためにs：divを使用する選択肢があります。
示されているs：textは、画面上にテキストをレンダリングするために使用されます。
次に、使い慣れたs：formタグがあります。 s：formタグには、フォームを送信する場所を決定するアクション属性があります。 フォームにファイルアップロード要素があるため、enctypeをmultipartに設定する必要があります。 それ以外の場合は、これを空白のままにします。
formタグの最後に、s：submitタグがあります。 これは、フォームを送信するために使用されます。 フォームが送信されると、すべてのフォーム値がs：formタグで指定されたアクションに送信されます。
s：formの中には、secretという隠し属性があります。 これにより、HTMLの非表示要素がレンダリングされます。 この場合、「secret」要素の値は「abracadabra」です。 この要素はエンドユーザーには表示されず、あるビューから別のビューに状態を伝えるために使用されます。
次に、s：label、s：textfield、s：password、およびs：textareaタグがあります。 これらは、それぞれラベル、入力フィールド、パスワード、およびテキスト領域のレンダリングに使用されます。 これらは、「Struts-電子メールの送信」の例で実際に使用されています。
ここで注意すべき重要なことは、「キー」属性の使用です。 「key」属性は、プロパティファイルからこれらのコントロールのラベルを取得するために使用されます。 この機能については、Struts2のローカライズ、国際化の章ですでに説明しています。
次に、入力ファイルアップロードコンポーネントをレンダリングするs：fileタグがあります。 このコンポーネントにより、ユーザーはファイルをアップロードできます。 この例では、s：fileタグの「accept」パラメーターを使用して、アップロードできるファイルの種類を指定しています。
最後に、s：tokenタグがあります。 トークンタグは、フォームが二重送信されたかどうかを確認するために使用される一意のトークンを生成します
フォームがレンダリングされると、隠し変数がトークン値として配置されます。 たとえば、トークンが「ABC」であるとしましょう。 このフォームが送信されると、Struts Fitlerはトークンをセッションに保存されているトークンと照合します。 一致する場合、セッションからトークンを削除します。 これで、フォームを誤って再送信した場合（更新またはブラウザの戻るボタンを押すことにより）、フォームはトークンとして「ABC」で再送信されます。 この場合、フィルターはセッションに保存されているトークンに対してトークンを再度チェックします。 ただし、トークン「ABC」はセッションから削除されているため、一致せず、Strutsフィルターは要求を拒否します。
グループUIタグ
グループUIタグは、ラジオボタンとチェックボックスを作成するために使用されます。 チェックボックスとラジオボタンタグを備えた HelloWorld.jsp のシンプルなビューページを見てみましょう-
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head/>
</head>
<body>
<s:form action = "hello.action">
<s:radio label = "Gender" name = "gender" list="{'male','female'}"/>
<s:checkboxlist label = "Hobbies" name = "hobbies"
list = "{'sports','tv','shopping'}"/>
</s:form>
</body>
</html>上記のプログラムを実行すると、出力は次のようになります-
ここで例を見てみましょう。 最初の例では、ラベル「性別」を持つ単純なラジオボタンを作成しています。 name属性はラジオボタンタグに必須であるため、「性別」という名前を指定します。 次に、性別にリストを提供します。 リストには、値「male」および「female」が入力されます。 したがって、出力では、2つの値を持つラジオボタンを取得します。
2番目の例では、チェックボックスリストを作成しています。 これは、ユーザーの趣味を収集することです。 ユーザーは複数の趣味を持つことができるため、ラジオボタンの代わりにチェックボックスを使用しています。 チェックボックスには、「スポーツ」、「テレビ」、「ショッピング」のリストが表示されます。 これにより、趣味がチェックボックスリストとして表示されます。
UIタグを選択
Strutsが提供するSelectタグのさまざまなバリエーションを調べてみましょう。 selectタグを使用した簡単なビューページ HelloWorld.jsp を見てみましょう-
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head/>
</head>
<body>
<s:form action = "login.action">
<s:select name = "username" label = "Username"
list = "{'Mike','John','Smith'}"/>
<s:select label = "Company Office" name = "mySelection"
value = "%{'America'}" list="%{#{'America':'America'}}">
<s:optgroup label = "Asia"
list = "%{#{'India':'India','China':'China'}}"/>
<s:optgroup label = "Europe"
list="%{#{'UK':'UK','Sweden':'Sweden','Italy':'Italy'}}"/>
</s:select>
<s:combobox label = "My Sign" name = "mySign"
list = "#{'aries':'aries','capricorn':'capricorn'}" headerkey = "-1"
headervalue = "--- Please Select ---" emptyOption = "true" value = "capricorn"/>
<s:doubleselect label = "Occupation" name = "occupation"
list = "{'Technical','Other'}" doublename = "occupations2"
doubleList="top == 'Technical' ?
{'I.T', 'Hardware'} : {'Accounting', 'H.R'}"/>
</s:form>
</body>
</html>上記のプログラムを実行すると、出力は次のようになります-
それでは、個々のケースを1つずつ見ていきましょう。
- 最初に、選択タグはHTML選択ボックスをレンダリングします。 最初の例では、名前が「username」でラベルが「username」の単純な選択ボックスを作成しています。 選択ボックスには、Mike、John、Smithという名前のリストが表示されます。
- 2番目の例では、当社にアメリカに本社があります。 また、アジアとヨーロッパにグローバルオフィスがあります。 選択ボックスにオフィスを表示したいのですが、大陸の名前でグローバルオフィスをグループ化します。 これは、optgroupが便利な場所です。 s：optgroupタグを使用して、新しいグループを作成します。 グループにラベルと個別のリストを与えます。
- 3番目の例では、コンボボックスが使用されます。 コンボボックスは、入力フィールドと選択ボックスの組み合わせです。 ユーザーは、選択ボックスから値を選択できます。その場合、ユーザーが選択した値が入力フィールドに自動的に入力されます。 ユーザーが値を直接入力する場合、選択ボックスの値は選択されません。
- この例では、コンボボックスに太陽の兆候がリストされています。 選択ボックスには4つのエントリのみがリストされ、リストにない場合はユーザーが太陽記号を入力できます。 また、選択ボックスにヘッダーエントリを追加します。 ヘッダーエントリは、選択ボックスの上部に表示されるものです。 この例では、「選択してください」を表示します。 ユーザーが何も選択しない場合、値として-1が想定されます。 場合によっては、ユーザーに空の値を選択させたくないことがあります。 これらの条件では、「emptyOption」プロパティをfalseに設定します。 最後に、この例では、コンボボックスのデフォルト値として「山羊座」を指定します。
- 4番目の例では、二重選択があります。 2つの選択ボックスを表示する場合は、二重選択が使用されます。 最初の選択ボックスで選択した値によって、2番目の選択ボックスに表示されるものが決まります。 この例では、最初の選択ボックスに「技術」と「その他」が表示されます。 ユーザーが技術を選択すると、2番目の選択ボックスにITとハードウェアが表示されます。 それ以外の場合は、経理と人事を表示します。 これは、例に示すように「list」および「doubleList」属性を使用して可能です。
上記の例では、上部の選択ボックスがテクニカルに等しいかどうかを確認するために比較を行いました。 存在する場合は、ITとハードウェアを表示します。
また、上部のボックス（ "name = 'Occupations'）と下部のボックス（doubleName = 'occupations2'）に名前を付ける必要があります。
Struts 2-Ajaxタグ
Strutsは、AJAXタグの実装にDOJOフレームワークを使用します。 まず、この例を進めるには、struts2-dojo-plugin-2.2.3.jarをクラスパスに追加する必要があります。
このファイルは、struts2ダウンロードのlibフォルダー（C：\ struts-2.2.3all \ struts-2.2.3 \ lib \ struts2-dojo-plugin-2.2.3.jar）から取得できます。
この例外については、次のように HelloWorld.jsp を変更しましょう-
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<%@ taglib prefix = "sx" uri = "/struts-dojo-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head/>
<sx:head/>
</head>
<body>
<s:form>
<sx:autocompleter label = "Favourite Colour"
list = "{'red','green','blue'}"/>
<br/>
<sx:datetimepicker name = "deliverydate" label = "Delivery Date"
displayformat = "dd/MM/yyyy"/>
<br/>
<s:url id = "url" value = "/hello.action"/>
<sx:div href="%{#url}" delay="2000">
Initial Content
</sx:div>
<br/>
<sx:tabbedpanel id = "tabContainer">
<sx:div label = "Tab 1">Tab 1</sx:div>
<sx:div label = "Tab 2">Tab 2</sx:div>
</sx:tabbedpanel>
</s:form>
</body>
</html>上記の例を実行すると、次の出力が得られます-
次に、この例を1ステップずつ見ていきましょう。
最初に気づくのは、接頭辞sxを持つ新しいタグライブラリの追加です。 これ（struts-dojo-tags）は、ajax統合のために特別に作成されたタグライブラリです。
次に、HTMLヘッド内でsx：headを呼び出します。 これにより、dojoフレームワークが初期化され、ページ内のすべてのAJAX呼び出しの準備が整います。 このステップは重要です-sx：headが初期化されていないと、ajax呼び出しは機能しません。
最初にオートコンプリータータグがあります。 オートコンプリートタグは、選択ボックスによく似ています。 赤、緑、青の値が入力されます。 しかし、選択ボックスとこれとの違いは、選択ボックスが自動的に完了することです。 つまり、grで入力を開始すると、「緑」で塗りつぶされます。 それ以外は、このタグは先ほど説明したs：selectタグと非常によく似ています。
次に、日付時刻ピッカーがあります。 このタグは、ボタンが横にある入力フィールドを作成します。 ボタンが押されると、ポップアップ日時ピッカーが表示されます。 ユーザーが日付を選択すると、タグ属性で指定された形式で日付が入力テキストに入力されます。 この例では、日付の形式としてdd/MM/yyyyを指定しています。
次に、前の演習で作成したsystem.actionファイルへのurlタグを作成します。 system.actionである必要はありません-以前に作成した任意のアクションファイルである可能性があります。 次に、ハイパーリンクがURLに設定され、遅延が2秒に設定されたdivがあります。 これを実行すると、「初期コンテンツ」が2秒間表示され、次にdivのコンテンツが hello.action 実行からのコンテンツに置き換えられます。
最後に、2つのタブがある単純なタブパネルがあります。 タブは、ラベルがタブ1およびタブ2のdivである。
StrutsでのAJAXタグの統合はまだ進行中の作業であり、この統合の成熟度はリリースごとに徐々に増加していることに注意してください。
Struts 2とSpringの統合
Springは、多くの一般的なWebタスクと簡単に統合できる人気のあるWebフレームワークです。 質問は、Struts2があるのになぜSpringが必要なのかということです。 さて、SpringはMVCフレームワーク以上のものです。Strutsでは利用できない他の多くの機能を提供します。
例：任意のフレームワークに役立つ依存性注入。 この章では、SpringとStruts2を統合する方法を簡単な例で説明します。
まず、Springインストールからプロジェクトのビルドパスに次のファイルを追加する必要があります。 Spring Frameworkの最新バージョンは、https://www.springsource.org/downloadからダウンロードしてインストールできます。
- org.springframework.asm-x.y.z.M（a）.jar
- org.springframework.beans-x.y.z.M（a）.jar
- org.springframework.context-x.y.z.M（a）.jar
- org.springframework.core-x.y.z.M（a）.jar
- org.springframework.expression-x.y.z.M（a）.jar
- org.springframework.web-x.y.z.M（a）.jar
- org.springframework.web.servlet-x.y.z.M（a）.jar
最後に、struts libディレクトリから WEB-INF/lib に struts2-spring-plugin-x.y.z.jar を追加します。 Eclipseを使用している場合、例外_java.lang.ClassNotFoundException：org.springframework.web.context.ContextLoaderListener_が発生する場合があります。
この問題を修正するには、[マーカー]タブに移動し、クラスの依存関係を1つずつ右クリックして、すべての依存関係を公開/エクスポートするクイック修正を行う必要があります。 最後に、マーカータブで使用可能な依存関係の競合がないことを確認します。
次のようにStruts-Spring統合の web.xml をセットアップしましょう-
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>ここで注意すべき重要なことは、設定したリスナーです。 ContextLoaderListener は、スプリングコンテキストファイルをロードするために必要です。 Springの構成ファイルは applicationContext.xml ファイルと呼ばれ、 web.xml ファイルと同じレベルに配置する必要があります
firstNameとlastNameの2つのプロパティを持つ User.java という単純なアクションクラスを作成しましょう。
package com.finddevguides.struts2;
public class User {
private String firstName;
private String lastName;
public String execute() {
return "success";
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}次に、 applicationContext.xml スプリング構成ファイルを作成し、 User.java クラスをインスタンス化します。 前述したように、このファイルはWEB-INFフォルダーの下にある必要があります-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id = "userClass" class = "com.finddevguides.struts2.User">
<property name = "firstName" value = "Michael"/>
<property name = "lastName" value = "Jackson"/>
</bean>
</beans>上記のように、ユーザーBeanを構成し、値 Michael および Jackson をBeanに注入しました。 また、このBeanに「userClass」という名前を付けて、他の場所でこれを再利用できるようにしました。 次に、WebContentフォルダーに User.jsp を作成します-
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World From Struts2 - Spring integration</h1>
<s:form>
<s:textfield name = "firstName" label = "First Name"/><br/>
<s:textfield name = "lastName" label = "Last Name"/><br/>
</s:form>
</body>
</html>*User.jsp* ファイルは非常に単純です。 ユーザーオブジェクトの名と姓の値を表示するという1つの目的しかありません。 最後に、 *struts.xml* ファイルを使用してすべてのエンティティをまとめましょう。<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "helloworld" extends = "struts-default">
<action name = "user" class="userClass"
method = "execute">
<result name = "success">/User.jsp</result>
</action>
</package>
</struts>重要なことは、クラスを参照するためにid userClass を使用していることです。 これは、ばねを使用してUserクラスの依存性注入を行うことを意味します。
次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/User.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
ここまでで、2つの優れたフレームワークを統合する方法を説明しました。 これで、Struts-Spring統合の章は終わりです。
Struts 2とタイルの統合
この章では、TilesフレームワークをStruts2と統合する手順を説明します。 Apache Tilesは、Webアプリケーションユーザーインターフェイスの開発を簡素化するために構築されたテンプレートフレームワークです。
まず、https://tiles.apache.org/[Apache Tiles] Webサイトからタイルjarファイルをダウンロードする必要があります。 次のjarファイルをプロジェクトのクラスパスに追加する必要があります。
- tiles-api-x.y.z.jar
- tiles-compat-x.y.z.jar
- tiles-core-x.y.z.jar
- tiles-jsp-x.y.z.jar
- tiles-servlet-x.y.z.jar
上記に加えて、 WEB-INF/lib のstruts2ダウンロードから次のjarファイルをコピーする必要があります。
- commons-beanutils-x.y.zjar
- commons-digester-x.y.jar
- struts2-tiles-plugin-x.y.z.jar
次に、以下に示すように、Struts-Tiles統合用の web.xml をセットアップしましょう。 ここで注意すべき2つの重要なポイントがあります。 最初に、タイル構成ファイル tiles.xml の場所をタイルに指示する必要があります。 この例では、 /WEB-INF フォルダーの下にあります。 次に、Struts2ダウンロードに付属するTilesリスナーを初期化する必要があります。
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id = "WebApp_ID" version = "2.5">
<display-name>Struts2Example15</display-name>
<context-param>
<param-name>
org.apache.tiles.impl.BasicTilesContainer.DEFINITIONS_CONFIG
</param-name>
<param-value>
/WEB-INF/tiles.xml
</param-value>
</context-param>
<listener>
<listener-class>
org.apache.struts2.tiles.StrutsTilesListener
</listener-class>
</listener>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>次に、/WEB-INFフォルダーに tiles.xml を作成し、次の内容を含めます-
<?xml version = "1.0" Encoding = "UTF-8" ?>
<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
"http://tiles.apache.org/dtds/tiles-config_2_0.dtd">
<tiles-definitions>
<definition name = "baseLayout" template="/baseLayout.jsp">
<put-attribute name = "title" value = "Template"/>
<put-attribute name = "banner" value = "/banner.jsp"/>
<put-attribute name = "menu" value = "/menu.jsp"/>
<put-attribute name = "body" value = "/body.jsp"/>
<put-attribute name = "footer" value = "/footer.jsp"/>
</definition>
<definition name = "tiger" extends = "baseLayout">
<put-attribute name = "title" value = "Tiger"/>
<put-attribute name = "body" value = "/tiger.jsp"/>
</definition>
<definition name = "lion" extends = "baseLayout">
<put-attribute name = "title" value = "Lion"/>
<put-attribute name = "body" value = "/lion.jsp"/>
</definition>
</tiles-definitions>次に、 baseLayout.jsp で基本的なスケルトンレイアウトを定義します。 5つの再利用可能/オーバーライド可能な領域があります。 つまり、 title、banner、menu、body 、および footer です。 baseLayoutのデフォルト値を提供してから、デフォルトレイアウトから拡張する2つのカスタマイズを作成します。 tigerレイアウトは、基本レイアウトに似ていますが、本文として tiger.jsp を使用し、タイトルとしてテキスト「Tiger」を使用する点が異なります。 同様に、ライオンレイアウトは基本レイアウトに似ていますが、本文として lion.jsp を使用し、タイトルとしてテキスト「ライオン」を使用する点が異なります。
個々のjspファイルを見てみましょう。 以下は、 baseLayout.jsp ファイルの内容です-
<%@ taglib uri = "http://tiles.apache.org/tags-tiles" prefix = "tiles"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset = UTF-8">
<title>
<tiles:insertAttribute name = "title" ignore="true"/>
</title>
</head>
<body>
<tiles:insertAttribute name = "banner"/><br/>
<hr/>
<tiles:insertAttribute name = "menu"/><br/>
<hr/>
<tiles:insertAttribute name = "body"/><br/>
<hr/>
<tiles:insertAttribute name = "footer"/><br/>
</body>
</html>ここでは、タイル属性を持つ基本的なHTMLページをまとめました。 必要な場所にタイル属性を挿入します。 次に、次の内容を持つ banner.jsp ファイルを作成しましょう-
<img src="http://www.finddevguides.com/images/tp-logo.gif"/>*menu.jsp* ファイルには、TigerMenu.actionおよびLionMenu.action strutsアクションへのリンクである次の行が含まれます。<%@taglib uri = "/struts-tags" prefix = "s"%>
<a href = "<s:url action = "tigerMenu"/>" Tiger</a><br>
<a href = "<s:url action = "lionMenu"/>" Lion</a><br>*lion.jsp* ファイルには次の内容があります-<img src="http://upload.wikimedia.org/wikipedia/commons/d/d2/Lion.jpg"/>
The lion*tiger.jsp* ファイルには次の内容があります-<img src="http://www.freewebs.com/tigerofdarts/tiger.jpg"/>
The tiger次に、次を含むアクションクラスファイル MenuAction.java を作成します-
package com.finddevguides.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class MenuAction extends ActionSupport {
public String tiger() { return "tiger"; }
public String lion() { return "lion"; }
}これは非常に単純なクラスです。 結果としてそれぞれtigerとlionを返すtiger（）とlion（）の2つのメソッドを宣言しました。 すべてを struts.xml ファイルにまとめてみましょう-
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name = "default" extends = "struts-default">
<result-types>
<result-type name = "tiles"
class="org.apache.struts2.views.tiles.TilesResult"/>
</result-types>
<action name = "*Menu" method = "{1}"
class = "com.finddevguides.struts2.MenuAction">
<result name = "tiger" type = "tiles">tiger</result>
<result name = "lion" type = "tiles">lion</result>
</action>
</package>
</struts>上記のファイルで行ったことを確認しましょう。 まず、ビューテクノロジにプレーンjspの代わりにタイルを使用しているため、「タイル」と呼ばれる新しい結果タイプを宣言しました。 Struts2はTiles View結果タイプをサポートしているため、結果タイプ「tiles」を作成して「org.apache.struts2.view.tiles.TilesResult」クラスにします。
次に、リクエストが/tigerMenu.actionに対するものである場合、ユーザーをtigerタイルページに移動し、リクエストが/lionMenu.actionに対するものである場合、ライオンタイルページに移動します。
これを実現するには、少し正規表現を使用します。 アクション定義では、パターン「 *Menu」に一致するものはすべてこのアクションで処理されると言います。 一致するメソッドはMenuActionクラスで呼び出されます。 つまり、tigerMenu.actionはtiger（）を呼び出し、lionMenu.actionはlion（）を呼び出します。 次に、結果の結果を適切なタイルページにマップする必要があります。
次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル]* をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL http：//localhost：8080/HelloWorldStruts2/tigerMenu.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
同様に、lionMenu.actionページに移動すると、同じタイルレイアウトを使用するライオンページが表示されます。
Struts 2とHibernateの統合
Hibernateは、オープンソースのGNU Lesser General Public License（LGPL）の下でライセンスされ、無料でダウンロードできる高性能のオブジェクト/リレーショナル永続性およびクエリサービスです。 この章では。 Struts 2とHibernateの統合を実現する方法を学習します。 Hibernateに慣れていない場合は、リンク：/hibernate/index [Hibernateチュートリアル]を確認してください。
データベースのセットアップ
このチュートリアルでは、「struts2_tutorial」MySQLデータベースを使用します。 ユーザー名「root」を使用し、パスワードは使用せずに、マシン上のこのデータベースに接続します。 まず、次のスクリプトを実行する必要があります。 このスクリプトは、*学生*という新しいテーブルを作成し、このテーブルにいくつかのレコードを作成します-
CREATE TABLE IF NOT EXISTS `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`first_name` varchar(40) NOT NULL,
`last_name` varchar(40) NOT NULL,
`marks` int(11) NOT NULL,
PRIMARY KEY (`id`)
);
--
-- Dumping data for table `student`
--
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(1, 'George', 'Kane', 20);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(2, 'Melissa', 'Michael', 91);
INSERT INTO `student` (`id`, `first_name`, `last_name`, `marks`)
VALUES(3, 'Jessica', 'Drake', 21);休止状態の設定
次に、hibernateの構成ファイルであるhibernate.cfg.xmlを作成しましょう。
<?xml version = '1.0' encoding = 'utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name = "hibernate.connection.driver_class">c
om.mysql.jdbc.Driver
</property>
<property name = "hibernate.connection.url">
jdbc:mysql://www.finddevguides.com/struts_tutorial
</property>
<property name = "hibernate.connection.username">root</property>
<property name = "hibernate.connection.password"></property>
<property name = "hibernate.connection.pool_size">10</property>
<property name = "show_sql">true</property>
<property name = "dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name = "hibernate.hbm2ddl.auto">update</property>
<mapping class = "com.finddevguides.hibernate.Student"/>
</session-factory>
</hibernate-configuration>hibernate構成ファイルを見ていきましょう。 まず、MySQLドライバーを使用していることを宣言しました。 次に、データベースに接続するためのjdbc URLを宣言しました。 次に、接続のユーザー名、パスワード、およびプールサイズを宣言しました。 また、「show_sql」をtrueに設定することで、ログファイルにSQLを表示することを示しました。 これらのプロパティの意味を理解するには、Hibernateチュートリアルをご覧ください。
最後に、この章で作成するマッピングクラスをcom.finddevguides.hibernate.Studentに設定します。
環境設定
次に、このプロジェクトには多くのjarが必要です。 添付されている必要なJARファイルの完全なリストのスクリーンショットです-
ほとんどのJARファイルは、Strutsディストリビューションの一部として取得できます。 glassfish、websphere、jbossなどのアプリケーションサーバーがインストールされている場合は、残りのjarファイルの大部分をappserverのlibフォルダーから取得できます。 そうでない場合は、ファイルを個別にダウンロードできます-
- Hibernate jarファイル-http://hibernate.org/[Hibernate.org]
- Struts hibernateプラグイン-https://code.google.com/p/full-hibernate-plugin-for-struts2/downloads/list[Struts hibernateプラグイン]
- JTAファイル-https://www.oracle.com/technetwork/java/javaee/jta/indexl[JTAファイル]
- Dom4jファイル-http://dom4j.sourceforge.net/[Dom4j]
- log4jファイル-https://logging.apache.org/log4j/1.2/[log4j]
残りのファイルは、Struts2ディストリビューションから取得できるはずです。
Hibernateクラス
hibernate統合に必要なJavaクラスを作成しましょう。 以下は Student.java の内容です-
package com.finddevguides.hibernate;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "student")
public class Student {
@Id
@GeneratedValue
private int id;
@Column(name = "last_name")
private String lastName;
@Column(name = "first_name")
private String firstName;
private int marks;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public int getMarks() {
return marks;
}
public void setMarks(int marks) {
this.marks = marks;
}
}これは、Hibernate仕様に従って student テーブルを表すPOJOクラスです。 学生テーブルの列名に対応するプロパティid、firstName、lastNameがあります。 次に、次のように StudentDAO.java ファイルを作成します-
package com.finddevguides.hibernate;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.SessionTarget;
import com.googlecode.s2hibernate.struts2.plugin.\
annotations.TransactionTarget;
public class StudentDAO {
@SessionTarget
Session session;
@TransactionTarget
Transaction transaction;
@SuppressWarnings("unchecked")
public List<Student> getStudents() {
List<Student> students = new ArrayList<Student>();
try {
students = session.createQuery("from Student").list();
} catch(Exception e) {
e.printStackTrace();
}
return students;
}
public void addStudent(Student student) {
session.save(student);
}
}StudentDAOクラスは、Studentクラスのデータアクセスレイヤーです。 すべての学生をリストし、新しい学生レコードを保存するメソッドがあります。
アクションクラス
次のファイル AddStudentAction.java は、アクションクラスを定義します。 ここには、execute（）とlistStudents（）の2つのアクションメソッドがあります。 execute（）メソッドは、新しい学生レコードを追加するために使用されます。 daoのsave（）メソッドを使用してこれを実現します。
もう1つのメソッドlistStudents（）は、学生をリストするために使用されます。 daoのlistメソッドを使用して、すべての学生のリストを取得します。
package com.finddevguides.struts2;
import java.util.ArrayList;
import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.finddevguides.hibernate.Student;
import com.finddevguides.hibernate.StudentDAO;
public class AddStudentAction extends ActionSupport implements ModelDriven<Student> {
Student student = new Student();
List<Student> students = new ArrayList<Student>();
StudentDAO dao = new StudentDAO();
@Override
public Student getModel() {
return student;
}
public String execute() {
dao.addStudent(student);
return "success";
}
public String listStudents() {
students = dao.getStudents();
return "success";
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
}ModelDrivenインターフェイスを実装していることに気づくでしょう。 これは、アクションクラスが個別のプロパティ（firstName、lastNameなど）ではなく、具象モデルクラス（Studentなど）を処理する場合に使用されます。 ModelAwareインターフェイスでは、モデルを返すメソッドを実装する必要があります。 この場合、「学生」オブジェクトを返します。
ビューファイルを作成する
次の内容で student.jsp ビューファイルを作成しましょう-
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head/>
</head>
<body>
<s:form action = "addStudent">
<s:textfield name = "firstName" label = "First Name"/>
<s:textfield name = "lastName" label = "Last Name"/>
<s:textfield name = "marks" label = "Marks"/>
<s:submit/>
<hr/>
<table>
<tr>
<td>First Name</td>
<td>Last Name</td>
<td>Marks</td>
</tr>
<s:iterator value = "students">
<tr>
<td><s:property value = "firstName"/></td>
<td><s:property value = "lastName"/></td>
<td><s:property value = "marks"/></td>
</tr>
</s:iterator>
</table>
</s:form>
</body>
</html>student.jspは非常に簡単です。 上部のセクションには、「addStudent.action」に送信するフォームがあります。 firstName、lastName、marksを取ります。 addStudentアクションはModelAwareの「AddSudentAction」に関連付けられているため、firstName、lastName、およびマークが自動入力された値を持つ学生Beanが自動的に作成されます。
下部のセクションでは、学生リストを確認します（AddStudentAction.javaを参照）。 リストを反復処理し、名、姓、およびマークを表に表示します。
Struts構成
*struts.xml* を使用してまとめてみましょう-<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true"/>
<package name = "myhibernate" extends = "hibernate-default">
<action name = "addStudent" method = "execute"
class = "com.finddevguides.struts2.AddStudentAction">
<result name = "success" type = "redirect">
listStudents
</result>
</action>
<action name = "listStudents" method = "listStudents"
class = "com.finddevguides.struts2.AddStudentAction">
<result name = "success">/students.jsp</result>
</action>
</package>
</struts>ここで重要なことは、パッケージ「myhibernate」が「hibernate-default」と呼ばれるstruts2デフォルトパッケージを拡張することです。 次に、addStudentとlistStudentsの2つのアクションを宣言します。 addStudentはAddStudentActionクラスでexecute（）を呼び出し、成功するとlistStudentsアクションメソッドを呼び出します。
listStudentアクションメソッドは、AddStudentActionクラスのlistStudents（）を呼び出し、student.jspをビューとして使用します。
次に、プロジェクト名を右クリックし、[エクスポート]> [WARファイル] をクリックして、WARファイルを作成します。 次に、このWARをTomcatのwebappsディレクトリにデプロイします。 最後に、Tomcatサーバーを起動して、URL *http：//localhost：8080/HelloWorldStruts2/student.jsp にアクセスしてみます。 これにより、次の画面が生成されます-
上部のセクションには、新しい学生レコードの値を入力するフォームがあり、下部のセクションにはデータベース内の学生がリストされています。 先に進み、新しい学生記録を追加して、送信を押します。 [送信]をクリックするたびに、画面が更新され、更新されたリストが表示されます。 Struts-2-struts-questions-answers
