Struts2-クイックガイド
Model View Controllerまたは MVC一般的に呼ばれているように、Webアプリケーションを開発するためのソフトウェアデザインパターンです。Model View Controllerパターンは、次の3つの部分で構成されています-
Model −データの維持を担当するパターンの最低レベル。
View −これは、データのすべてまたは一部をユーザーに表示する責任があります。
Controller −モデルとビュー間の相互作用を制御するソフトウェアコード。
MVCは、アプリケーションロジックをユーザーインターフェイスレイヤーから分離し、関心の分離をサポートするため、人気があります。ここで、コントローラーはアプリケーションに対するすべての要求を受信し、モデルと連携してビューに必要なデータを準備します。次に、ビューはコントローラーによって準備されたデータを使用して、最終的な提示可能な応答を生成します。MVCの抽象化は、次のようにグラフィカルに表すことができます。
モデル
モデルは、アプリケーションのデータを管理する責任があります。ビューからの要求に応答し、コントローラーからの指示にも応答して自身を更新します。
景色
これは、データを提示するというコントローラーの決定によってトリガーされる、特定の形式でのデータの提示を意味します。これらは、JSP、ASP、PHPなどのスクリプトベースのテンプレートシステムであり、AJAXテクノロジとの統合が非常に簡単です。
コントローラー
コントローラは、ユーザー入力に応答し、データモデルオブジェクトに対して対話を実行する責任があります。コントローラは入力を受け取り、入力を検証してから、データモデルの状態を変更するビジネスオペレーションを実行します。
Struts2MVCベースのフレームワークです。次の章では、Struts2内でMVC手法を使用する方法を見てみましょう。
Struts2は、MVCデザインパターンに基づく人気のある成熟したWebアプリケーションフレームワークです。Struts2はStruts1の新しいバージョンであるだけでなく、Strutsアーキテクチャを完全に書き直したものです。
Webworkフレームワークは当初、Strutsフレームワークをベースとして開始され、その目標は、開発者がWeb開発を容易にするためにStruts上に構築された拡張および改善されたフレームワークを提供することでした。
しばらくして、WebworkフレームワークとStrutsコミュニティが協力して、有名なStruts2フレームワークを作成しました。
Struts2フレームワークの機能
Struts2 −を検討せざるを得ない可能性のある優れた機能のいくつかを次に示します。
POJO Forms and POJO Actions− Struts2は、Strutsフレームワークの不可欠な部分であったアクションフォームを廃止しました。Struts2を使用すると、任意のPOJOを使用してフォーム入力を受け取ることができます。同様に、POJOをActionクラスとして表示できるようになりました。
Tag Support − Struts2は、フォームタグと新しいタグを改善し、開発者がより少ないコードを記述できるようにしました。
AJAX Support − Struts2は、Web2.0テクノロジーによる引き継ぎを認識し、AJAXタグを作成することでAJAXサポートを製品に統合しました。この機能は、標準のStruts2タグと非常によく似ています。
Easy Integration − Struts2で利用可能なさまざまな統合により、Spring、Tiles、SiteMeshなどの他のフレームワークとの統合が容易になりました。
Template Support −テンプレートを使用したビューの生成のサポート。
Plugin Support−プラグインを使用することで、Struts2のコア動作を強化および強化できます。Struts2には多数のプラグインが用意されています。
Profiling− Struts2は、アプリケーションをデバッグおよびプロファイリングするための統合プロファイリングを提供します。これに加えて、Strutsは組み込みのデバッグツールの助けを借りて統合されたデバッグも提供します。
Easy to Modify Tags− Struts2のタグマークアップは、Freemarkerテンプレートを使用して微調整できます。これには、JSPまたはJavaの知識は必要ありません。タグを変更するには、HTML、XML、CSSの基本的な知識で十分です。
Promote Less configuration− Struts2は、さまざまな設定にデフォルト値を使用することで、構成の削減を促進します。Struts2で設定されたデフォルト設定から逸脱しない限り、何かを構成する必要はありません。
View Technologies − Struts2は、複数のビューオプション（JSP、Freemarker、Velocity、XSLT）を強力にサポートしています。
上にリストされているのはのトップ10の機能です Struts 2 これにより、エンタープライズ対応のフレームワークになります。
Struts2のデメリット
Struts 2には優れた機能のリストが付属していますが、現在のバージョンにはいくつかの制限があります。Struts2にはさらに改善が必要です。記載されている主なポイントのいくつか-
Bigger Learning Curve − StrutsでMVCを使用するには、標準のJSP、サーブレットAPI、および大規模で精巧なフレームワークに慣れている必要があります。
Poor Documentation −標準のサーブレットおよびJSP APIと比較して、Strutsのオンラインリソースは少なく、多くの初めてのユーザーは、オンラインのApacheドキュメントがわかりにくく整理されていないと感じています。
Less Transparent − Strutsアプリケーションでは、通常のJavaベースのWebアプリケーションよりも多くのことが舞台裏で行われているため、フレームワークを理解するのが困難です。
最後に、優れたフレームワークは、多くの異なるタイプのアプリケーションがそれを利用できる一般的な動作を提供する必要があります。
Struts 2 は最高のWebフレームワークの1つであり、リッチインターネットアプリケーション（RIA）の開発に非常に使用されています。
最初のタスクは、最小限のStruts2アプリケーションを実行することです。この章では、Struts2で作業を開始するための開発環境を準備する方法について説明します。
すでにJDK（5 +）、Tomcat、Eclipseがマシンにインストールされていると思います。これらのコンポーネントがインストールされていない場合は、ファストトラックで指定された手順に従ってください-
ステップ1-JavaDevelopment Kit（JDK）をセットアップする
-あなたは、OracleのJavaサイトからSDKの最新バージョンをダウンロードすることができたJava SEダウンロード。ダウンロードしたファイルに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-ApacheTomcatをセットアップする
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/
Windowsマシンで以下のコマンドを実行することでTomcatを停止できます-
%CATALINA_HOME%\bin\shutdown
or
C:\apache-tomcat-5.5.29\bin\shutdownUnix（Solaris、Linuxなど）マシンで次のコマンドを実行すると、Tomcatを停止できます。
$CATALINA_HOME/bin/shutdown.sh
or
/usr/local/apache-tomcat-5.5.29/bin/shutdown.shステップ3-Eclipse（IDE）をセットアップする
このチュートリアルのすべての例は、EclipseIDEを使用して記述されています。マシンに最新バージョンのEclipseがインストールされていることをお勧めします。
Eclipseをインストールするには最新のEclipseバイナリをからダウンロードします https://www.eclipse.org/downloads/。インストールをダウンロードしたら、バイナリディストリビューションを便利な場所に解凍します。
たとえば、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ファイルをダウンロードします。
Struts2バイナリの最新バージョンをからダウンロードします https://struts.apache.org/download.cgi。
このチュートリアルを書いている時点で、私はダウンロードしました struts-2.0.14-all.zip ダウンロードしたファイルを解凍すると、C：\ struts-2.2.3内に次のようなディレクトリ構造が表示されます。
2番目のステップは、zipファイルを任意の場所に抽出することです。ダウンロードして抽出しました struts-2.2.3-all.zip に c:\ すべてのjarファイルを入れるようにWindows7マシンのフォルダー C:\struts-2.2.3\lib。CLASSPATH変数を適切に設定してください。そうしないと、アプリケーションの実行中に問題が発生します。
大まかに言えば、Struts2はプルMVC（またはMVC2）フレームワークです。Struts2のModel-ViewControllerパターンは、次の5つのコアコンポーネントで実装されています-
- Actions
- Interceptors
- バリュースタック/ OGNL
- 結果/結果タイプ
- テクノロジーを見る
Struts 2 いくつかの重複はありますが、アクションがコントローラーではなくモデルの役割を担う従来のMVCフレームワークとは少し異なります。
上の図は、 Mオデル、 Viewと CStruts2高レベルアーキテクチャへのオントローラー。コントローラは、Struts2サーブレットフィルターとインターセプターをディスパッチします。このモデルはアクションで実装され、ビューは結果タイプと結果の組み合わせです。バリュースタックとOGNLは、他のコンポーネント間の統合をリンクおよび有効化する共通のスレッドを提供します。
上記のコンポーネントとは別に、構成に関連する多くの情報があります。Webアプリケーションの構成、およびアクション、インターセプター、結果などの構成。
これは、Struts 2MVCパターンのアーキテクチャの概要です。各コンポーネントについては、以降の章で詳しく説明します。
ライフサイクルのリクエスト
上の図に基づいて、ユーザーのリクエストライフサイクル全体のワークフローを理解できます。 Struts 2 次のように-
ユーザーは、いくつかのリソース（つまりページ）を要求するためにサーバーに要求を送信します。
Filter Dispatcherは要求を確認してから、適切なアクションを決定します。
検証、ファイルアップロードなど、構成されたインターセプター機能が適用されます。
選択されたアクションは、要求された操作に基づいて実行されます。
この場合も、必要に応じて、構成済みのインターセプターを適用して後処理を実行します。
最後に、結果はビューによって準備され、結果をユーザーに返します。
Struts 2アーキテクチャからすでに学んだように、ハイパーリンクをクリックするか、Struts 2 WebアプリケーションでHTMLフォームを送信すると、入力はControllerによって収集され、ActionsというJavaクラスに送信されます。アクションが実行された後、結果は応答をレンダリングするリソースを選択します。リソースは通常JSPですが、PDFファイル、Excelスプレッドシート、またはJavaアプレットウィンドウの場合もあります。
すでに開発環境を構築していると仮定します。それでは、最初のビルドに進みましょうHello World Struts2事業。このプロジェクトの目的は、ユーザーの名前を収集し、「HelloWorld」の後にユーザー名を表示するWebアプリケーションを構築することです。
Struts 2プロジェクトでは、次の4つのコンポーネントを作成する必要があります-
| シニア番号 | コンポーネントと説明 |
|---|---|
| 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 次の画面に示すように、残りのオプションを設定します-
次の画面ですべてのデフォルトオプションを選択し、最後にチェックします Generate Web.xml deployment descriptorオプション。これにより、Eclipseで動的なWebプロジェクトが作成されます。今一緒に行くWindows > Show View > Project Explorer、プロジェクトウィンドウが次のように表示されます-
次に、struts 2libフォルダーから次のファイルをコピーします 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
アクションクラスの作成
アクションクラスはStruts2アプリケーションの鍵であり、ほとんどのビジネスロジックをアクションクラスに実装しています。それでは、下にJavaファイルHelloWorldAction.javaを作成しましょう。Java Resources > src パッケージ名付き com.tutorialspoint.struts2 以下の内容で。
Actionクラスは、ユーザーがURLをクリックしたときにユーザーアクションに応答します。1つ以上のActionクラスのメソッドが実行され、Stringの結果が返されます。結果の値に基づいて、特定のJSPページがレンダリングされます。
package com.tutorialspoint.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;
}
}これは、「name」と呼ばれる1つのプロパティを持つ非常に単純なクラスです。「name」プロパティ用の標準のgetterメソッドとsetterメソッド、および文字列「success」を返すexecuteメソッドがあります。
Struts 2フレームワークは、のオブジェクトを作成します HelloWorldActionクラスを作成し、ユーザーのアクションに応じて実行されたメソッドを呼び出します。このメソッド内にビジネスロジックを配置すると、最終的に文字列定数が返されます。つまり、URLごとに1つのアクションクラスを実装する必要があり、そのクラス名をアクション名として直接使用するか、以下に示すようにstruts.xmlファイルを使用して他の名前にマップできます。
ビューを作成する
最終メッセージを表示するにはJSPが必要です。このページは、事前定義されたアクションが発生したときにStruts 2フレームワークによって呼び出され、このマッピングはstruts.xmlファイルで定義されます。それでは、以下のjspファイルを作成しましょうHelloWorld.jspEclipseプロジェクトのWebContentフォルダーにあります。これを行うには、プロジェクトエクスプローラーで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タグは、メソッドによって返されるアクションクラスプロパティ "name>の値を表示します getName() HelloWorldActionクラスの。
メインページを作成する
また、作成する必要があります index.jspWebContentフォルダにあります。このファイルは、ユーザーがクリックして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クラスとそのexecuteメソッドにマップされます。ユーザーが[送信]ボタンをクリックすると、Struts 2フレームワークがHelloWorldActionクラスで定義されたexecuteメソッドを実行し、メソッドの戻り値に基づいて、適切なビューが選択され、応答としてレンダリングされます。
構成ファイル
URL、HelloWorldActionクラス（モデル）、およびHelloWorld.jsp（ビュー）を結び付けるためのマッピングが必要です。マッピングは、Struts 2フレームワークに、ユーザーのアクション（URL）に応答するクラス、そのクラスのどのメソッドが実行されるか、およびそのメソッドが返す文字列の結果に基づいてレンダリングするビューを指示します。
それでは、というファイルを作成しましょう。 struts.xml。Struts 2では、struts.xmlがclassesフォルダーに存在する必要があるためです。したがって、WebContent / WEB-INF / classesフォルダーの下にstruts.xmlファイルを作成します。Eclipseはデフォルトで「classes」フォルダーを作成しないため、これを自分で行う必要があります。これを行うには、プロジェクトエクスプローラーでWEB-INFフォルダーを右クリックし、[New > Folder。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.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>上記の設定ファイルに関して理解する必要のあるいくつかの単語。ここでは、定数を設定しますstruts.devMode に true、開発環境で作業していて、いくつかの有用なログメッセージを表示する必要があるためです。次に、というパッケージを定義しますhelloworld。
パッケージの作成は、アクションをグループ化する場合に役立ちます。この例では、アクションにURLに対応する「hello」という名前を付けました。/hello.action によってバックアップされていますHelloWorldAction.class。ザ・execute の方法 HelloWorldAction.class URLが実行されるときに実行されるメソッドです /hello.actionが呼び出されます。executeメソッドの結果が「success」を返す場合、ユーザーは次のようになります。HelloWorld.jsp。
次のステップは、を作成することです web.xmlStruts 2へのリクエストのエントリポイントであるファイル。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フィルターを構成しました。
詳細ログを有効にするには
Struts 2の操作中に、作成することで完全なログ機能を有効にできます logging.properties 下のファイル WEB-INF/classesフォルダ。プロパティファイルに次の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を使用して設定できます。
それでおしまい。Struts2フレームワークを使用してHelloWorldアプリケーションを実行する準備が整いました。
アプリケーションの実行手順
プロジェクト名を右クリックして、 Export > WAR File Warファイルを作成します。
次に、このWARをTomcatのwebappsディレクトリにデプロイします。
最後に、Tomcatサーバーを起動し、URLにアクセスしてみます http://localhost:8080/HelloWorldStruts2/index.jsp。これにより、次の画面が表示されます-
値「Struts2」を入力して、ページを送信します。次のページが表示されます
定義できることに注意してください index struts.xmlファイルのアクションとして、その場合はインデックスページを次のように呼び出すことができます 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.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>この章では、に必要な基本構成について説明します。 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>Struts2フィルターをにマップすることに注意してください /*、ではなく /*.actionこれは、すべてのURLがstrutsフィルターによって解析されることを意味します。これについては、注釈の章を通過するときに説明します。
Struts.xmlファイル
ザ・ struts.xmlファイルには、アクションの開発時に変更する構成情報が含まれています。このファイルは、アプリケーションのデフォルト設定（struts.devMode = falseやプロパティファイルで定義されているその他の設定など）を上書きするために使用できます。このファイルはフォルダの下に作成できますWEB-INF/classes。
前の章で説明したHelloWorldの例で作成した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.tutorialspoint.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>タグを使用してさまざまなパッケージを宣言します。ここで<package>を使用すると、構成を分離してモジュール化できます。これは、大規模なプロジェクトがあり、プロジェクトが異なるモジュールに分割されている場合に非常に便利です。
たとえば、プロジェクトにbusiness_application、customer_application、staff_applicationの3つのドメインがある場合、3つのパッケージを作成し、関連するアクションを適切なパッケージに保存できます。
パッケージタグには次の属性があります-
| シニア番号 | 属性と説明 |
|---|---|
| 1 | name (required) パッケージの一意の識別子 |
| 2 | extends このパッケージはどのパッケージから拡張されますか？デフォルトでは、struts-defaultを基本パッケージとして使用します。 |
| 3 | abstract trueとマークされている場合、パッケージはエンドユーザーが使用できません。 |
| 4 | namespace アクションの一意の名前空間 |
ザ・ constant タグと名前および値の属性を使用して、で定義されている次のプロパティのいずれかをオーバーライドする必要があります。 default.properties、設定したように struts.devModeプロパティ。設定struts.devMode プロパティを使用すると、ログファイルでより多くのデバッグメッセージを確認できます。
定義する action タグはアクセスしたいすべてのURLに対応し、対応するURLにアクセスするたびにアクセスされるexecute（）メソッドを使用してクラスを定義します。
結果は、アクションの実行後にブラウザに返されるものを決定します。アクションから返される文字列は、結果の名前である必要があります。結果は、上記のようにアクションごとに、または「グローバル」結果として構成され、パッケージ内のすべてのアクションで使用できます。結果にはオプションがありますname そして type属性。デフォルトの名前の値は「success」です。
Struts.xmlファイルは時間の経過とともに大きくなる可能性があるため、パッケージごとに分割することは、モジュール化する1つの方法ですが、 Strutsstruts.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％でこれらの設定に触れる必要はありません。このため、このファイルについてはあまり詳しく説明しません。興味のある方は、をご覧ください。default.properties struts2-core-2.2.3.jarファイルで利用可能なファイル。
Struts-config.xmlファイル
struts-config.xml構成ファイルは、Webクライアントのビューコンポーネントとモデルコンポーネント間のリンクですが、プロジェクトの99.99％でこれらの設定に触れる必要はありません。
設定ファイルには基本的に次の主要な要素が含まれています-
| シニア番号 | インターセプターと説明 |
|---|---|
| 1 | struts-config これは、構成ファイルのルートノードです。 |
| 2 | form-beans ここで、ActionFormサブクラスを名前にマップします。この名前は、strutsconfig.xmlファイルの残りの部分全体、さらにはJSPページでもActionFormのエイリアスとして使用します。 |
| 3 | global forwards このセクションでは、Webアプリのページを名前にマップします。この名前を使用して、実際のページを参照できます。これにより、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 構成ファイルは、 web.xml を使用して init-param、およびで定数タグを使用する struts.xml構成ファイル。しかし、物事を分離し、よりストラットを特定したい場合は、フォルダーの下にこのファイルを作成できますWEB-INF/classes。
このファイルで構成された値は、で構成されたデフォルト値を上書きします default.propertiesこれはstruts2-core-xyzjarディストリビューションに含まれています。を使用して変更を検討する可能性のあるプロパティがいくつかあります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。
Actionsは、MVC（Model View Controller）フレームワークの場合と同様に、Struts2フレームワークのコアです。各URLは特定のアクションにマップされ、ユーザーからの要求を処理するために必要な処理ロジックを提供します。
しかし、この行動は他の2つの重要な役割も果たします。まず、アクションは、JSPであろうと他のタイプの結果であろうと、リクエストからビューへのデータの転送において重要な役割を果たします。次に、アクションは、要求への応答で返されるビューをレンダリングする結果を決定する際にフレームワークを支援する必要があります。
アクションの作成
でのアクションの唯一の要件 Struts2StringまたはResultオブジェクトのいずれかを返すnoargumentメソッドが1つ必要であり、POJOである必要があります。引数なしのメソッドが指定されていない場合、デフォルトの動作はexecute（）メソッドを使用することです。
オプションで、を拡張できます ActionSupport 以下を含む6つのインターフェースを実装するクラス Actionインターフェース。アクションインターフェイスは次のとおりです-
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;
}HelloWorldの例のアクションメソッドを見てみましょう-
package com.tutorialspoint.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.tutorialspoint.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;
}
}この例では、executeメソッドにname属性を調べるロジックがいくつかあります。属性が文字列と等しい場合"SECRET"、 我々は返します SUCCESS 結果として、それ以外の場合は戻ります ERROR結果として。ActionSupportを拡張したため、文字列定数を使用できますSUCCESSおよびエラー。ここで、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.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>ビューを作成する
以下のjspファイルを作成しましょう HelloWorld.jspEclipseプロジェクトのWebContentフォルダーにあります。これを行うには、プロジェクトエクスプローラーでWebContentフォルダーを右クリックし、[New >JSP File。このファイルは、戻り結果がSUCCESSである場合に呼び出されます。これは、アクションインターフェイスで定義されている文字列定数「成功」です。
<%@ 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>また、作成する必要があります index.jspWebContentフォルダにあります。このファイルは、ユーザーがクリックしてStruts2フレームワークに呼び出すことができる初期アクションURLとして機能します。executeHelloWorldActionクラスのメソッドであり、HelloWorld.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>これで、web.xmlファイルに変更は必要ないので、で作成したものと同じweb.xmlを使用しましょう。 Examples章。これで、実行する準備ができましたHello World Struts2フレームワークを使用するアプリケーション。
アプリケーションを実行する
プロジェクト名を右クリックして、 Export > WARWarファイルを作成するためのファイル。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/index.jsp。これにより、次の画面が表示されます-
「SECRET」という単語を入力すると、次のページが表示されます-
「SECRET」以外の単語を入力すると、次のページが表示されます-
複数のアクションを作成する
さまざまなリクエストを処理し、ユーザーにさまざまなURLを提供するために、複数のアクションを定義することがよくあります。したがって、以下に定義するようにさまざまなクラスを定義します。
package com.tutorialspoint.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.tutorialspoint.struts2.HelloWorld"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
<action name = "something"
class = "com.tutorialspoint.struts2.SomeOtherClass"
method = "execute">
<result name = "success">/Something.jsp</result>
<result name = "error">/AccessDenied.jsp</result>
</action>
</package>
</struts>上記の架空の例でわかるように、アクションの結果は SUCCESS そして ERROR’s 重複しています。
この問題を回避するには、結果の結果を含むクラスを作成することをお勧めします。
インターセプターは、概念的にはサーブレットフィルターまたはJDKプロキシクラスと同じです。インターセプターを使用すると、フレームワークだけでなくアクションとは別に、横断的な機能を実装できます。インターセプターを使用して次のことを実現できます-
アクションが呼び出される前に前処理ロジックを提供します。
アクションが呼び出された後に後処理ロジックを提供します。
代替処理を実行できるように例外をキャッチします。
で提供される機能の多く Struts2 フレームワークはインターセプターを使用して実装されます。
Examples 例外処理、ファイルアップロード、ライフサイクルコールバックなどが含まれます。実際、Struts2はインターセプターの機能の多くを強調しているため、アクションごとに7つまたは8つのインターセプターが割り当てられることはほとんどありません。
Struts2フレームワークインターセプター
Struts 2フレームワークは、事前構成されてすぐに使用できる、すぐに使用できるインターセプターの優れたリストを提供します。重要なインターセプターのいくつかを以下に示します-
| シニア番号 | インターセプターと説明 |
|---|---|
| 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 アクションの検証サポートを提供します |
上記のインターセプターの詳細については、Struts2のドキュメントを参照してください。ただし、Strutsアプリケーションで一般的にインターセプターを使用する方法を説明します。
インターセプターの使い方は？
「HelloWorld」プログラムに既存のインターセプターを使用する方法を見てみましょう。を使用しますtimerアクションメソッドの実行にかかった時間を測定することを目的としたインターセプター。同時に、私は使用していますparamsリクエストパラメータをアクションに送信することを目的とするインターセプター。このインターセプターを使用せずに例を試すことができ、name パラメータがアクションに到達できないため、プロパティが設定されていません。
HelloWorldAction.java、web.xml、HelloWorld.jsp、およびindex.jspファイルは、で作成されたとおりに保持します。 Examples 章が変更しましょう 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.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<interceptor-ref name = "params"/>
<interceptor-ref name = "timer" />
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、この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 アクションが実行されるのに合計109msかかったことを伝えているインターセプター。
カスタムインターセプターを作成する
アプリケーションでカスタムインターセプターを使用することは、横断的なアプリケーション機能を提供するための洗練された方法です。カスタムインターセプターの作成は簡単です。拡張が必要なインターフェースは次のとおりですInterceptor インターフェイス-
public interface Interceptor extends Serializable {
void destroy();
void init();
String intercept(ActionInvocation invocation)
throws Exception;
}名前が示すように、init（）メソッドはインターセプターを初期化する方法を提供し、destroy（）メソッドはインターセプターをクリーンアップする機能を提供します。アクションとは異なり、インターセプターはリクエスト間で再利用され、特にintercept（）メソッドでスレッドセーフである必要があります。
ザ・ ActionInvocationオブジェクトは、ランタイム環境へのアクセスを提供します。アクション自体とメソッドにアクセスして、アクションを呼び出し、アクションがすでに呼び出されているかどうかを判断できます。
初期化またはクリーンアップコードが必要ない場合は、 AbstractInterceptorクラスを拡張できます。これにより、init（）メソッドとdestroy（）メソッドのデフォルトのnooperation実装が提供されます。
インターセプタークラスを作成する
次のMyInterceptor.javaをで作成しましょう Java Resources > src フォルダ-
package com.tutorialspoint.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()コール。したがって、要件に基づいて、前処理と後処理を行うことができます。
フレームワーク自体は、ActionInvocationオブジェクトのinvoke（）を最初に呼び出すことによってプロセスを開始します。毎回invoke()が呼び出されると、ActionInvocationはその状態を調べて、次に来るインターセプターを実行します。構成されたすべてのインターセプターが呼び出されると、invoke（）メソッドによってアクション自体が実行されます。
次の図は、リクエストフローによる同じ概念を示しています-
アクションクラスの作成
下にJavaファイルHelloWorldAction.javaを作成しましょう Java Resources > src パッケージ名付き com.tutorialspoint.struts2 以下の内容で。
package com.tutorialspoint.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」プロパティ用の標準のgetterメソッドとsetterメソッド、および文字列「success」を返すexecuteメソッドがあります。
ビューを作成する
以下のjspファイルを作成しましょう HelloWorld.jsp EclipseプロジェクトのWebContentフォルダーにあります。
<%@ 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.jspWebContentフォルダにあります。このファイルは、ユーザーがクリックして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クラスとそのexecuteメソッドにマップされます。
構成ファイル
ここで、インターセプターを登録してから、前の例でデフォルトのインターセプターを呼び出したように呼び出す必要があります。新しく定義されたインターセプターを登録するには、<interceptors> ... </ interceptors>タグを<package>タグのすぐ下に配置します。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.tutorialspoint.struts2.MyInterceptor" />
</interceptors>
<action name = "hello"
class = "com.tutorialspoint.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>プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、この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.tutorialspoint.struts2.MyAction">
<interceptor-ref name = "basicStack"/>
<result>view.jsp</result>
</action上記の「basicStack」の登録により、6つのインターセプターすべての完全な株式がhelloアクションで登録されます。これは、インターセプターが構成された順序で実行されることに注意してください。たとえば、上記の場合、例外が最初に実行され、2番目がservlet-configなどになります。
前に述べたように、 <results> タグはの役割を果たします viewStruts2MVCフレームワークで。アクションは、ビジネスロジックの実行を担当します。ビジネスロジックを実行した後の次のステップは、を使用してビューを表示することです。<results> 鬼ごっこ。
多くの場合、結果にはいくつかのナビゲーションルールが添付されています。たとえば、アクションメソッドがユーザーの認証である場合、3つの可能な結果があります。
- ログインの成功
- ログインに失敗しました-ユーザー名またはパスワードが正しくありません
- アカウントがロックされました
このシナリオでは、アクションメソッドは、結果をレンダリングするために3つの可能な結果文字列と3つの異なるビューで構成されます。これは前の例ですでに見ました。
ただし、Struts2は、ビューテクノロジとしてJSPを使用することに縛られることはありません。結局のところ、MVCパラダイムの全体的な目的は、レイヤーを分離して高度に構成可能に保つことです。たとえば、Web2.0クライアントの場合、出力としてXMLまたはJSONを返したい場合があります。この場合、XMLまたはJSONの新しい結果タイプを作成して、これを実現できます。
Strutsには、事前定義された多数の機能が付属しています result types そして、私たちがすでに見たものはすべて、デフォルトの結果タイプでした dispatcher、JSPページへのディスパッチに使用されます。Strutsを使用すると、ビューテクノロジーに他のマークアップ言語を使用して結果を表示でき、人気のある選択肢には次のものがあります。Velocity, Freemaker, XSLT そして Tiles。
ディスパッチャの結果タイプ
ザ・ dispatcher結果タイプはデフォルトのタイプであり、他の結果タイプが指定されていない場合に使用されます。これは、サーバー上のサーブレット、JSP、HTMLページなどに転送するために使用されます。RequestDispatcher.forward（）メソッドを使用します。
以前の例では、結果タグの本体としてJSPパスを指定した「省略形」バージョンを見ました。
<result name = "success">
/HelloWorld.jsp
</result>次のように、<result ...>要素内の<paramname = "location">タグを使用してJSPファイルを指定することもできます。
<result name = "success" type = "dispatcher">
<param name = "location">
/HelloWorld.jsp
</param >
</result>私達はまた供給することができます parseパラメータ。デフォルトではtrueです。parseパラメーターは、ロケーションパラメーターがOGNL式に対して解析されるかどうかを決定します。
FreeMaker結果タイプ
この例では、どのように使用できるかを見ていきます FreeMakerビューテクノロジーとして。Freemakerは、事前定義されたテンプレートを使用して出力を生成するために使用される人気のあるテンプレートエンジンです。と呼ばれるFreemakerテンプレートファイルを作成しましょうhello.fm 以下の内容で-
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.tutorialspoint.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ファイルを保持しましょう。
次に、プロジェクト名を右クリックして、 Export > WAR File 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.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success" type = "redirect">
<param name = "location">
/NewWorld.jsp
</param >
</result>
</action>したがって、struts.xmlファイルを変更して、上記のようにリダイレクトタイプを定義し、新しいファイルNewWorld.jpgを作成します。このファイルでは、helloアクションが成功を返すたびにリダイレクトされます。理解を深めるために、Struts2リダイレクトアクションの例を確認できます。
バリュースタック
値スタックは、次のオブジェクトを指定された順序で保持するいくつかのオブジェクトのセットです-
| シニア番号 | オブジェクトと説明 |
|---|---|
| 1 | Temporary Objects ページの実行中に作成されるさまざまな一時オブジェクトがあります。たとえば、JSPタグでループオーバーされているコレクションの現在の反復値。 |
| 2 | The Model Object strutsアプリケーションでモデルオブジェクトを使用している場合、現在のモデルオブジェクトは値スタックのアクションの前に配置されます。 |
| 3 | The Action Object これは、実行されている現在のアクションオブジェクトになります。 |
| 4 | Named Objects これらのオブジェクトには、＃application、＃session、＃request、＃attr、および#parametersが含まれ、対応するサーブレットスコープを参照します。 |
値スタックには、JSP、Velocity、またはFreemarkerに提供されているタグを介してアクセスできます。別の章で学習するさまざまなタグがあり、Struts2.0の値スタックを取得および設定するために使用されます。次のように、アクション内でvalueStackオブジェクトを取得できます-
ActionContext.getContext().getValueStack()ValueStackオブジェクトを取得したら、次のメソッドを使用してそのオブジェクトを操作できます-
| シニア番号 | ValueStackのメソッドと説明 |
|---|---|
| 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式言語と非常によく似ています。OGNLは、コンテキスト内にルートオブジェクトまたはデフォルトオブジェクトを持つという考えに基づいています。デフォルトオブジェクトまたはルートオブジェクトのプロパティは、ポンド記号であるマークアップ表記を使用して参照できます。
前述のように、OGNLはコンテキストに基づいており、StrutsはOGNLで使用するためのActionContextマップを作成します。ActionContextマップは、次のもので構成されます。
Application −アプリケーションスコープ変数
Session −セッションスコープ変数
Root / value stack −すべてのアクション変数がここに保存されます
Request −スコープ変数を要求する
Parameters −リクエストパラメータ
Atributes −ページ、リクエスト、セッション、およびアプリケーションスコープに保存されている属性
Actionオブジェクトは常に値スタックで使用できることを理解することが重要です。したがって、Actionオブジェクトにプロパティがある場合“x” そして “y” すぐに使用できます。
ActionContext内のオブジェクトはポンド記号を使用して参照されますが、値スタック内のオブジェクトは直接参照できます。
たとえば、 employee はアクションクラスのプロパティである場合、次のように参照できます。
<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にアクセスし、ビューでOGNLを使用してアクセスするいくつかのキー（JSPページ）を設定する次のアクションクラスについて考えてみましょう。
package com.tutorialspoint.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>タグを使用して値にアクセスすることです。しかし、私はActionContextとValueStackがStrutsでどのように正確に機能するかを示しています。
ビューを作成する
以下のjspファイルを作成しましょう HelloWorld.jspEclipseプロジェクトのWebContentフォルダーにあります。このビューは、アクションが成功を返した場合に表示されます-
<%@ 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>また、作成する必要があります index.jsp コンテンツが次のWebContentフォルダー内-
<%@ 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.tutorialspoint.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>プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。
最後に、Tomcatサーバーを起動し、URLにアクセスしてみます http://localhost:8080/HelloWorldStruts2/index.jsp。これにより、次の画面が表示されます
次に、指定されたテキストボックスに任意の単語を入力し、[Say Hello]ボタンをクリックして、定義されたアクションを実行します。生成されたログを確認すると、下部に次のテキストが表示されます-
Size of the valueStack: 3これにより、次の画面が表示されます。この画面には、入力する値と、ValueStackに設定したkey1およびkey2の値が表示されます。
Struts 2フレームワークは、「HTMLでのフォームベースのファイルアップロード」を使用してファイルアップロードを処理するための組み込みサポートを提供します。ファイルがアップロードされると、通常は一時ディレクトリに保存され、データが失われないように、Actionクラスによって処理または永続ディレクトリに移動する必要があります。
Note −サーバーには、一時ディレクトリおよびWebアプリケーションに属するディレクトリ以外のディレクトリへの書き込みを禁止するセキュリティポリシーが設定されている場合があります。
Strutsでのファイルのアップロードは、と呼ばれる事前定義されたインターセプターを介して可能です。 FileUpload org.apache.struts2.interceptor.FileUploadInterceptorクラスを介して利用可能であり、defaultStack。それでも、struts.xmlでそれを使用して、以下に示すようにさまざまなパラメーターを設定できます。
ビューファイルを作成する
選択したファイルを参照してアップロードするために必要なビューの作成から始めましょう。だから私たちは作成しましょうindex.jsp ユーザーがファイルをアップロードできるプレーンなHTMLアップロードフォーム付き-
<%@ 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。アクションメソッドと支柱の構成を作成するには、この情報が必要です。
次に、簡単な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>アクションクラスの作成
次に、というJavaクラスを作成しましょう。 uploadFile.java ファイルのアップロードとそのファイルの安全な場所への保存を処理します-
package com.tutorialspoint.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つのパラメーターを使用できるようにします。それらは次のパターンで名前が付けられます-
[your file name parameter] −これはユーザーがアップロードした実際のファイルです。この例では、「myFile」になります
[your file name parameter]ContentType−これはアップロードされたファイルのコンテンツタイプです。この例では、「myFileContentType」になります
[your file name parameter]FileName−これはアップロードされたファイルの名前です。この例では、「myFileFileName」になります
Struts Interceptorsのおかげで、3つのパラメーターを使用できます。Actionクラスに正しい名前で3つのパラメーターを作成するだけで、これらの変数が自動的に自動的に配線されます。したがって、上記の例では、3つのパラメーターと、すべてがうまくいった場合は単に「成功」を返すアクションメソッドがあり、そうでない場合は「エラー」を返します。
構成ファイル
以下は、ファイルのアップロードプロセスを制御するStruts2構成プロパティです-
| シニア番号 | プロパティと説明 |
|---|---|
| 1 | struts.multipart.maxSize ファイルのアップロードとして受け入れられるファイルの最大サイズ（バイト単位）。デフォルトは250Mです。 |
| 2 | struts.multipart.parser マルチパートフォームのアップロードに使用されるライブラリ。デフォルトではjakarta |
| 3 | struts.multipart.saveDir 一時ファイルを保存する場所。デフォルトはjavax.servlet.context.tempdirです。 |
これらの設定のいずれかを変更するには、次を使用できます constant アップロードするファイルの最大サイズを変更したのと同じように、アプリケーションのstruts.xmlファイルにタグを付けます。
私たちを持ってみましょう 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.tutorialspoint.struts2.uploadFile">
<result name = "success">/success.jsp</result>
<result name = "error">/error.jsp</result>
</action>
</package>
</struts>以来、 FileUploadインターセプターは、インターセプターのデフォルトスタックの一部であるため、明示的に構成する必要はありません。ただし、<action>内に<interceptor-ref>タグを追加できます。fileUploadインターセプターは2つのパラメーターを取ります(a) maximumSize そして (b) allowedTypes。
maximumSizeパラメーターは、許可される最大ファイルサイズを設定します（デフォルトは約2MBです）。allowedTypesパラメーターは、以下に示すように、受け入れられたコンテンツ（MIME）タイプのコンマ区切りのリストです。
<action name = "upload" class = "com.tutorialspoint.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>次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/upload.jsp。これにより、次の画面が表示されます-
次に、[参照]ボタンを使用してファイル「Contacts.txt」を選択し、[アップロード]ボタンをクリックすると、サーブにファイルがアップロードされ、次のページが表示されます。アップロードしたファイルがC：\ apache-tomcat-6.0.33 \ workに保存されていることを確認できます。
FileUpload Interceptorはアップロードされたファイルを自動的に削除するため、アップロードされたファイルを削除する前に、プログラムでどこかに保存する必要があることに注意してください。
エラーメッセージ
fileUplaodインターセプターはいくつかのデフォルトのエラーメッセージキーを使用します-
| シニア番号 | エラーメッセージのキーと説明 |
|---|---|
| 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 リソースファイル。
この章では、Struts2を使用してデータベースにアクセスする方法を簡単な手順で説明します。StrutsはMVCフレームワークであり、データベースフレームワークではありませんが、JPA / Hibernate統合の優れたサポートを提供します。後の章で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');次のステップは、MySQL Connector jarファイルをダウンロードし、このファイルをプロジェクトのWEB-INF \ libフォルダーに配置することです。これが完了すると、アクションクラスを作成する準備が整います。
アクションの作成
アクションクラスには、データベーステーブルの列に対応するプロパティがあります。我々は持っていますuser, password そして name文字列属性として。actionメソッドでは、userパラメーターとpasswordパラメーターを使用して、ユーザーが存在するかどうかを確認します。存在する場合は、次の画面にユーザー名を表示します。
ユーザーが間違った情報を入力した場合、ログイン画面に再度送信されます。
以下はの内容です LoginAction.java ファイル-
package com.tutorialspoint.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.jsp アクションがSUCCESSを返した場合に呼び出されるファイルですが、アクションから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.tutorialspoint.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>次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/index.jsp。これにより、次の画面が表示されます-
間違ったユーザー名とパスワードを入力してください。次のページが表示されます。
今入力します scott ユーザー名として navyパスワードとして。次のページが表示されます。
この章では、Struts2アプリケーションを使用して電子メールを送信する方法について説明します。
この演習では、JavaMail API 1.4.4からmail.jarをダウンロードしてインストールし、mail.jar WEB-INF \ libフォルダーにファイルを保存してから、アクション、ビュー、および構成ファイルを作成する標準的な手順に従います。
アクションの作成
次のステップは、電子メールの送信を処理するActionメソッドを作成することです。という新しいクラスを作成しましょうEmailer.java 以下の内容で。
package com.tutorialspoint.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を使用しているため、有効なgtalkIDが必要です
Password −上記のアカウントのパスワード
To −誰にメールを送信しますか？
Subject −メールの件名
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>ビューを作成する
JSPファイルを使用します success.jsp これは、アクションがSUCCESSを返した場合に呼び出されますが、アクションから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.tutorialspoint.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>次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/index.jsp。これにより、次の画面が表示されます-
必要な情報を入力して、 Send Emailボタン。すべてがうまくいけば、次のページが表示されます。
この章では、Struts検証フレームワークについて詳しく見ていきます。Strutsコアには、アクションメソッドが実行される前にアプリケーションがルールを実行して検証を実行するのを支援する検証フレームワークがあります。
クライアント側の検証は通常、Javascriptを使用して行われます。ただし、クライアント側の検証だけに頼るべきではありません。ベストプラクティスでは、アプリケーションフレームワークのすべてのレベルで検証を導入する必要があることを示唆しています。次に、Strutsプロジェクトに検証を追加する2つの方法を見てみましょう。
ここでは、例を取り上げます Employee その名前と年齢は単純なページを使用して取得する必要があります。ユーザーが常に28〜65の範囲の名前と年齢を入力するように、これら2つの検証を行います。
例のメイン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が送信ボタンを出力すると仮定します。各タグのラベルを作成する各タグのlabelプロパティを使用しました。
ビューを作成する
定義されたアクションが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、次にというメソッドを追加します validate() 以下に示すように Employee.javaファイル。アクションクラスが拡張することを確認してくださいActionSupport それ以外の場合、validateメソッドは実行されません。
package com.tutorialspoint.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");
}
}
}上記の例に示されているように、検証メソッドは「名前」フィールドに値があるかどうかをチェックします。値が指定されていない場合は、カスタムエラーメッセージとともに「名前」フィールドのフィールドエラーを追加します。次に、「年齢」フィールドに入力した値が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.tutorialspoint.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>次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/index.jsp。これにより、次の画面が表示されます-
必要な情報を入力せずに、をクリックするだけです。 Submitボタン。次の結果が表示されます-
必要な情報を入力しますが、間違ったFromフィールドを入力し、名前を「テスト」、年齢を30と言い、最後にクリックします。 Submitボタン。次の結果が表示されます-
この検証はどのように機能しますか？
ユーザーが送信ボタンを押すと、Struts 2は自動的にvalidateメソッドを実行し、 “if”メソッド内にリストされているステートメントが真の場合、Struts2はそのaddFieldErrorメソッドを呼び出します。エラーが追加された場合、Struts2はexecuteメソッドの呼び出しに進みません。むしろStruts2フレームワークが返されますinput アクションを呼び出した結果として。
したがって、検証が失敗し、Struts2が input、Struts2フレームワークはindex.jspファイルを再表示します。Struts 2フォームタグを使用したため、Struts2は提出されたフォームのすぐ上にエラーメッセージを自動的に追加します。
これらのエラーメッセージは、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() 方法−
package com.tutorialspoint.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-XMLベースのバリデーターの詳細については、次のリンクを確認してください。
国際化（i18n）は、製品やサービスを計画および実装して、特定の地域の言語や文化に簡単に適応できるようにするプロセスであり、ローカリゼーションと呼ばれるプロセスです。国際化プロセスは、翻訳またはローカリゼーションの有効化と呼ばれます。
国際化は省略されます i18n 単語は文字で始まるので “i” そしてで終わる “n”、および最初のiと最後のnの間に18文字があります。
Struts2は、ローカリゼーション、つまり、次の場所にあるリソースバンドル、インターセプター、およびタグライブラリを介した国際化（i18n）サポートを提供します。
UIタグ
メッセージとエラー。
アクションクラス内。
リソースバンドル
Struts2は、リソースバンドルを使用して、Webアプリケーションのユーザーに複数の言語とロケールのオプションを提供します。異なる言語でページを書くことを心配する必要はありません。あなたがしなければならないのはあなたが望む言語ごとにリソースバンドルを作成することです。リソースバンドルには、ユーザーの言語のタイトル、メッセージ、およびその他のテキストが含まれます。リソースバンドルは、アプリケーションのデフォルト言語のキーと値のペアを含むファイルです。
リソースファイルの最も単純な命名形式は-です。
bundlename_language_country.propertiesここに、 bundlenameActionClass、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、テキストタグ、UIタグのキー属性、i18nタグなど、メッセージリソースにアクセスする方法はいくつかあります。それらを簡単に見てみましょう-
表示する i18n テキスト、呼び出しを使用して getText プロパティタグ、または次のようなUIタグなどの他のタグ内-
<s:property value = "getText('some.key')" />ザ・ text tag デフォルトのリソースバンドル、つまりstruts.propertiesからメッセージを取得します
<s:text name = "some.key" />ザ・ i18n tag任意のリソースバンドルを値スタックにプッシュします。i18nタグのスコープ内の他のタグは、そのリソースバンドルからのメッセージを表示できます-
<s:i18n name = "some.package.bundle">
<s:text name = "some.key" />
</s:i18n>ザ・ key ほとんどのUIタグの属性を使用して、リソースバンドルからメッセージを生成できます-
<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.jsp 定義されたアクションが返される場合に呼び出されるファイル SUCCESS。
<%@ 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.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class Locale extends ActionSupport {
public String execute() {
return SUCCESS;
}
}フォームを送信するためのアクション
package com.tutorialspoint.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作成します struts.xml 次の2つのアクションで-
<?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.tutorialspoint.struts2.Employee"
method = "execute">
<result name = "input">/index.jsp</result>
<result name = "success">/success.jsp</result>
</action>
<action name = "locale"
class = "com.tutorialspoint.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>次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/index.jsp。これにより、次の画面が表示されます-
次に、任意の言語を選択します。 Spanish、次の結果が表示されます-
フランス語でも試すことができます。最後に、クリックしてみましょうSubmit スペイン語ロケールにいるときにボタンを押すと、次の画面が表示されます-
おめでとうございます。多言語のウェブページができました。ウェブサイトをグローバルに立ち上げることができます。
HTTPリクエストのすべては、として扱われます Stringプロトコルによって。これには、数値、ブール値、整数、日付、小数などが含まれます。ただし、Strutsクラスでは、任意のデータ型のプロパティを持つことができます。
Strutsはどのようにプロパティを自動配線しますか？
Struts カバーの下にさまざまなタイプのコンバーターを使用して、重い物を持ち上げます。
たとえば、Actionクラスに整数属性がある場合、Strutsは何もしなくてもリクエストパラメータを整数属性に自動的に変換します。デフォルトでは、Strutsにはいくつかのタイプコンバーターが付属しています
以下にリストされているコンバーターのいずれかを使用している場合は、心配する必要はありません。
- 整数、浮動小数点、倍精度、10進数
- 日付と日時
- 配列とコレクション
- Enumerations
- Boolean
- BigDecimal
独自のデータ型を使用している場合は、表示する前にStrutsにそれらの値を変換する方法を認識させるために、独自のコンバーターを追加する必要があります。次のPOJOクラスを検討してくださいEnvironment.java。
package com.tutorialspoint.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。
この演習では、環境を「開発」に、オペレーティングシステムを「WindowsXPSP3」にハードコーディングしました。
リアルタイムプロジェクトでは、システム構成からこの情報を取得します。
次のアクションクラスを作成しましょう-
package com.tutorialspoint.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>配線しましょう system.jsp そしてその SystemDetails.java 一緒にクラスを使用して struts.xml。
SystemDetailsクラスには、文字列 "を返す単純なexecute（）メソッドがあります。SUCCESS"。
<?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.tutorialspoint.struts2.SystemDetails"
method = "execute">
<result name = "success">/System.jsp</result>
</action>
</package>
</struts>プロジェクト名を右クリックして、 Export > WAR File Warファイルを作成します。
次に、このWARをTomcatのwebappsディレクトリにデプロイします。
最後に、Tomcatサーバーを起動し、URLにアクセスしてみます http://localhost:8080/HelloWorldStruts2/system.action。これにより、次の画面が表示されます-
上記の出力の何が問題になっていますか？Strutsは、文字列「Windows XP SP3」およびその他の組み込みデータ型を表示および変換する方法を知っていますが、のプロパティをどう処理するかを知りません。Environmentタイプ。それは単に呼ばれますtoString() クラスのメソッド
この問題を解決するために、簡単なものを作成して登録しましょう TypeConverter Environmentクラスの場合。
というクラスを作成します EnvironmentConverter.java 以下で。
package com.tutorialspoint.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に、環境を文字列に変換する方法と、その逆の2つのメソッドをオーバーライドする方法を指示します。 convertFromString() そして convertToString()。
アプリケーションで使用する前に、このコンバーターを登録しましょう。コンバータを登録する方法は2つあります。
コンバーターが特定のアクションでのみ使用される場合は、次の名前を付ける必要があるプロパティファイルを作成する必要があります。 '[action-class]'converstion.properties。
この場合、というファイルを作成します SystemDetails-converstion.properties 次の登録エントリで-
environment = com.tutorialspoint.struts2.EnvironmentConverter上記の例では、「environment」は内のプロパティの名前です。 SystemDetails.java クラスと私たちはStrutsに使用するように言っています EnvironmentConverter このプロパティとの間で変換するため。
ただし、これは行いません。代わりに、このコンバーターをグローバルに登録して、アプリケーション全体で使用できるようにします。これを行うには、というプロパティファイルを作成しますxwork-conversion.properties の中に WEBINF/classes 次の行のフォルダ
com.tutorialspoint.struts2.Environment = \
com.tutorialspoint.struts2.EnvironmentConverterこれは単にコンバーターをグローバルに登録するので、 StrutsタイプEnvironmentのオブジェクトに遭遇するたびに、自動的に変換を実行できます。ここで、プログラムを再コンパイルして再実行すると、次のようにより良い出力が得られます。
明らかに、結果はより良くなります。これは、Strutsコンバーターが正常に機能していることを意味します。
これは、複数のコンバーターを作成し、要件に従って使用するためにそれらを登録する方法です。
この章の実際のチュートリアルを開始する前に、次のようにいくつかの定義を調べてみましょう。 https://struts.apache.org−
| シニア番号 | 用語と説明 |
|---|---|
| 1 | TAG JSP、FreeMarker、またはVelocity内から実行される小さなコード。 |
| 2 | TEMPLATE 特定のタグ（HTMLタグ）でレンダリングできる、通常はFreeMarkerで記述されたコード。 |
| 3 | THEME 共通の機能を提供するために一緒にパッケージ化されたテンプレートのコレクション。 |
また、同じ例をもう一度取り上げて演習を行うため、Struts2ローカリゼーションの章を読むことをお勧めします。
あなたが使用するとき Struts 2Webページの<s：submit ...>、<s：textfield ...>などのタグを使用すると、Struts2フレームワークは事前構成されたスタイルとレイアウトでHTMLコードを生成します。Struts2には3つの組み込みテーマが付属しています-
| シニア番号 | テーマと説明 |
|---|---|
| 1 | SIMPLE theme 「鐘と笛」のない最小限のテーマ。たとえば、textfieldタグは、ラベル、検証、エラーレポート、またはその他のフォーマットや機能なしでHTML <input />タグをレンダリングします。 |
| 2 | XHTML theme これはStruts2で使用されるデフォルトのテーマであり、シンプルなテーマが提供するすべての基本を提供し、HTMLの標準の2列のテーブルレイアウト、各HTMLのラベル、検証とエラーレポートなどのいくつかの機能を追加します。 |
| 3 | CSS_XHTML theme このテーマは、シンプルなテーマが提供するすべての基本を提供し、標準の2列のCSSベースのレイアウトなど、CSSスタイルシートに従って配置されたHTML Strutsタグの<div>、各HTMLStrutsタグのラベルを使用していくつかの機能を追加します。 。 |
上記のように、テーマを指定しない場合、Struts2はデフォルトでxhtmlテーマを使用します。たとえば、このStruts 2selectタグ-
<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のタグごとにテーマを指定するか、次のいずれかの方法を使用して、Struts2が使用するテーマを指定できます。
特定のタグのテーマ属性
タグの周囲のフォームタグのテーマ属性
「theme」という名前のページスコープ属性
「theme」という名前のリクエストスコープの属性
「theme」という名前のセッションスコープの属性
「theme」という名前のアプリケーションスコープの属性
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以下は、デフォルトのテーマを設定で使用したローカリゼーションの章から取得した結果です。 struts.ui.theme = xhtml に struts-default.properties struts2-core.xy.z.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。
また、velocityまたはJSPを使用してテンプレートを設計し、それに応じてstruts.propertiesで構成を設定することもできます。 struts.ui.templateSuffix そして struts.ui.templateDir。
新しいテーマの作成
新しいテーマを作成する最も簡単な方法は、既存のテーマ/テンプレートファイルをコピーして、必要な変更を加えることです。
というフォルダの作成から始めましょう template中のWebContent / WEBINF /クラスと私たちの新しいテーマの名前のサブフォルダ。たとえば、WebContent / WEB-INF / classes / template / mythemeです。
ここから、テンプレートの作成を最初から開始することも、テンプレートをからコピーすることもできます。 Struts2 distribution 将来必要に応じて変更できます。
既存のデフォルトテンプレートを変更します xhtml学習目的のため。ここで、コンテンツをstruts2-core-xyzjar / 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この変更後、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2。これにより、次の画面が表示されます-
xhtmlテーマからコピーした後、outテーマで行った変更の結果であるフォームコンポーネントの周囲に境界線が表示されます。FreeMarkerの学習に少し力を入れれば、テーマを非常に簡単に作成または変更できるようになります。
これで、基本的な理解ができたと思います。 Sturts 2 テーマやテンプレートですね。
Strutsキャッチされなかった例外を処理し、ユーザーを専用のエラーページにリダイレクトする簡単な方法を提供します。例外ごとに異なるエラーページを持つようにStrutsを簡単に構成できます。
Strutsは、「例外」インターセプターを使用することにより、例外処理を容易にします。「例外」インターセプターはデフォルトスタックの一部として含まれているため、構成するために特別なことをする必要はありません。すぐに使用できる状態で利用できます。
HelloWorldAction.javaファイルにいくつかの変更を加えた簡単なHelloWorldの例を見てみましょう。ここでは、意図的にNullPointer例外を導入しましたHelloWorldAction アクションコード。
package com.tutorialspoint.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.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
</action>
</package>
</struts>次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、この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.tutorialspoint.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例外をキャッチするために、次のように追加できます。<global-exception-mappings...> <package ...>タグ内のタグとその<result ...>タグは、struts.xmlファイルの<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">
<global-exception-mappings>
<exception-mapping exception = "java.lang.NullPointerException"
result = "error" />
</global-exception-mappings>
<action name = "hello"
class = "com.tutorialspoint.struts2.HelloWorldAction"
method = "execute">
<result name = "success">/HelloWorld.jsp</result>
<result name = "error">/Error.jsp</result>
</action>
</package>
</struts>前述のように、Strutsは2つの構成形式を提供します。従来の方法は、struts.xmlすべての構成のファイル。これまでのチュートリアルでは、その例を数多く見てきました。Strutsを構成するもう1つの方法は、Java5アノテーション機能を使用することです。支柱の注釈を使用して、Zero Configuration。
プロジェクトでアノテーションの使用を開始するには、次の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の注釈の概念を説明するには、Struts2の検証の章で説明した検証の例を再検討する必要があります。
ここでは、名前と年齢が単純なページを使用して取得される従業員の例を取り上げ、ÜSERが常に名前を入力し、年齢が28〜65であることを確認するために2つの検証を行います。
例のメイン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が送信ボタンを出力すると仮定します。各タグのラベルを作成する各タグのlabelプロパティを使用しました。
ビューを作成する
JSPファイルを使用します success.jsp これは、定義されたアクションが返される場合に呼び出されます SUCCESS。
<%@ 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 アノテーションを付けて、というメソッドを追加します validate () 以下に示すように Employee.javaファイル。アクションクラスが拡張することを確認してくださいActionSupport それ以外の場合、validateメソッドは実行されません。
package com.tutorialspoint.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つの結果の注釈があります。結果の注釈にはnameこれは、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>次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/index.jsp。これにより、次の画面が表示されます-
必要な情報を入力せずに、をクリックするだけです。 Submitボタン。次の結果が表示されます-
必要な情報を入力しますが、間違ったFromフィールドを入力し、名前を「テスト」、年齢を30と言い、最後にクリックします。 Submitボタン。次の結果が表示されます-
Struts2アノテーションタイプ
Struts 2アプリケーションは、XMLおよびJavaプロパティ構成の代わりにJava5アノテーションを使用できます。さまざまなカテゴリに関連する最も重要な注釈のリストを確認できます-
Struts2アノテーションタイプ。
Struts 2タグには、ページ実行のフローを簡単に制御できるようにする一連のタグがあります。
以下は重要なStruts2コントロールタグのリストです-
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>詳細な例を確認する
イテレータタグ
この iterator値を繰り返し処理します。反復可能な値は、itherjava.util.Collectionまたはjava.util.Iteratorファイルのいずれかです。イテレータを反復処理している間、次を使用できますSort 結果を並べ替えるためのタグまたは SubSet リストまたは配列のサブセットを取得するためのタグ。
次の例では、値スタック上の現在のオブジェクトのgetDays（）メソッドの値を取得し、それを使用して繰り返し処理します。
<s：property />タグは、イテレータの現在の値を出力します。
<s:iterator value = "days">
<p>day is: <s:property/></p>
</s:iterator>詳細な例を確認する
マージタグ
これら merge tagは、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>詳細な例を確認する
追加タグ
これら 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>詳細な例を確認する
ジェネレータタグ
これら generatortagは、指定されたval属性に基づいてイテレータを生成します。次のジェネレータタグはイテレータを生成し、イテレータタグを使用して出力します。
<s:generator val = "%{'aaa,bbb,ccc,ddd,eee'}">
<s:iterator>
<s:property /><br/>
</s:iterator>
</s:generator>詳細な例を確認する
ストラッツ2 data tags主に、ページに表示されるデータを操作するために使用されます。重要なデータタグは次のとおりです。<ここから開始>
アクションタグ
このタグを使用すると、開発者はアクション名とオプションの名前空間を指定することにより、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" />詳細な例を確認する
インクルードタグ
これら 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>詳細な例を確認する
Beanタグ
これら beantagは、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>詳細な例を確認する
日付タグ
これら dateタグを使用すると、日付をすばやく簡単にフォーマットできます。カスタム形式（「dd / MM / yyyyhh：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" />詳細な例を確認する
Paramタグ
これら paramタグは、他のタグをパラメータ化するために使用できます。このタグには、次の2つのパラメータがあります。
name（文字列）-パラメータの名前
value（オブジェクト）-パラメータの値
<pre>
<ui:component>
<ui:param name = "key" value = "[0]"/>
<ui:param name = "value" value = "[1]"/>
<ui:param name = "context" value = "[2]"/>
</ui:component>
</pre>詳細な例を確認する
プロパティタグ
これら property タグは、値のプロパティを取得するために使用されます。値が指定されていない場合、デフォルトでスタックの最上位になります。
<s:push value = "myBean">
<!-- Example 1: -->
<s:property value = "myBeanProperty" />
<!-- Example 2: -->TextUtils
<s:property value = "myBeanProperty" default = "a default value" />
</s:push>詳細な例を確認する
プッシュタグ
これら push タグは、簡単に使用できるようにスタックに値をプッシュするために使用されます。
<s:push value = "user">
<s:propery value = "firstName" />
<s:propery value = "lastName" />
</s:push>詳細な例を確認する
セットタグ
これら settagは、指定されたスコープ内の変数に値を割り当てます。変数を複雑な式に割り当ててから、複雑な式ではなく、毎回その変数を参照するだけの場合に便利です。利用可能なスコープはapplication, session, request, page そして action。
<s:set name = "myenv" value = "environment.name"/>
<s:property value = "myenv"/>詳細な例を確認する
テキストタグ
これら 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>詳細な例を確認する
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>詳細な例を確認する
のリスト formタグはStrutsUIタグのサブセットです。これらのタグは、Struts Webアプリケーションに必要なユーザーインターフェイスのレンダリングに役立ち、3つのカテゴリに分類できます。この章では、3種類のUIタグすべてについて説明します。
シンプルなUIタグ
これらのタグはすでに例で使用しています。この章でブラシをかけます。簡単なビューページを見てみましょうemail.jsp いくつかのシンプルなUIタグ付き-
<%@ 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要素とstylesheet要素を生成します。
次に、s：div要素とs：text要素があります。s：divは、HTMLDiv要素をレンダリングするために使用されます。これは、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-SendingEmail」の例でこれらの動作を確認しました。
ここで注意すべき重要なことは、「key」属性の使用です。「key」属性は、プロパティファイルからこれらのコントロールのラベルをフェッチするために使用されます。この機能については、Struts2ローカリゼーションの国際化の章ですでに説明しました。
次に、入力ファイルのアップロードコンポーネントをレンダリングするs：fileタグがあります。このコンポーネントを使用すると、ユーザーはファイルをアップロードできます。この例では、s：fileタグの「accept」パラメーターを使用して、アップロードを許可するファイルの種類を指定しています。
最後に、s：tokenタグがあります。トークンタグは、フォームが二重に送信されたかどうかを確認するために使用される一意のトークンを生成します
フォームがレンダリングされると、非表示の変数がトークン値として配置されます。たとえば、トークンが「ABC」であるとします。このフォームが送信されると、StrutsFitlerはトークンをセッションに保存されているトークンと照合します。一致する場合は、セッションからトークンを削除します。これで、フォームが誤って再送信された場合（更新するか、ブラウザの戻るボタンを押すことにより）、フォームは「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>上記のプログラムを実行すると、出力は次のようになります。
ここで例を見てみましょう。最初の例では、「Gender」というラベルの付いた単純なラジオボタンを作成しています。ラジオボタンタグにはname属性が必須であるため、「gender」という名前を指定します。次に、性別のリストを提供します。リストには、「男性」と「女性」の値が入力されます。したがって、出力には2つの値が含まれるラジオボタンが表示されます。
2番目の例では、チェックボックスリストを作成しています。これは、ユーザーの趣味を集めることです。ユーザーは複数の趣味を持つことができるため、ラジオボタンの代わりにチェックボックスを使用しています。チェックボックスには、「スポーツ」、「テレビ」、「ショッピング」のリストが表示されます。これにより、趣味がチェックボックスリストとして表示されます。
UIタグを選択します
Strutsが提供するSelectTagのさまざまなバリエーションを見てみましょう。簡単なビューページを見てみましょう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つずつ見ていきましょう。
まず、selectタグは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は、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のラベルが付いたdivsthemselevesです。
StrutsでのAJAXタグの統合はまだ進行中であり、この統合の成熟度はリリースごとに徐々に増加していることに注意してください。
Springは、多くの一般的なWebタスクと簡単に統合できる人気のあるWebフレームワークです。だから問題は、Struts2があるのになぜSpringが必要なのかということです。さて、SpringはMVCフレームワーク以上のものであり、Strutsでは利用できない他の多くの機能を提供します。
例：あらゆるフレームワークに役立つ依存性注入。この章では、SpringとStruts2を統合する方法を確認するための簡単な例を紹介します。
まず、Springインストールからプロジェクトのビルドパスに次のファイルを追加する必要があります。SpringFrameworkの最新バージョンはからダウンロードしてインストールできます。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
最後に追加 struts2-spring-plugin-x.y.z.jar あなたの中で WEB-INF/libstrutslibディレクトリから。Eclipseを使用している場合は、例外java.lang.ClassNotFoundException：org.springframework.web.context.ContextLoaderListenerが発生する可能性があります。
この問題を解決するには、参加する必要があります Markerタブをクリックしてクラスの依存関係を1つずつ右クリックし、クイック修正を実行してすべての依存関係を公開/エクスポートします。最後に、マーカータブで利用可能な依存関係の競合がないことを確認します。
それでは、セットアップしましょう web.xml Struts-Spring統合の場合は次のようになります-
<?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>ここで注意すべき重要なことは、構成したリスナーです。ザ・ContextLoaderListenerSpringコンテキストファイルをロードするために必要です。Springの設定ファイルはapplicationContext.xml ファイルとそれはと同じレベルに配置する必要があります web.xml ファイル
と呼ばれる単純なアクションクラスを作成しましょう User.java firstNameとlastNameの2つのプロパティがあります。
package com.tutorialspoint.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 Spring構成ファイルをインスタンス化し、 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.tutorialspoint.struts2.User">
<property name = "firstName" value = "Michael" />
<property name = "lastName" value = "Jackson" />
</bean>
</beans>上記のように、ユーザーBeanを構成し、値を挿入しました Michael そして Jackson豆に。また、このBeanに「userClass」という名前を付けて、他の場所で再利用できるようにしました。次に、を作成しましょうUser.jsp WebContentフォルダー内-
<%@ 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クラスを参照します。これは、Springを使用してUserクラスの依存性注入を行っていることを意味します。
次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/User.jsp。これにより、次の画面が表示されます-
これで、2つの優れたフレームワークを統合する方法を見てきました。これで、Struts-Spring統合の章は終わりです。
この章では、TilesフレームワークをStruts2と統合するための手順を見ていきましょう。Apache Tilesは、Webアプリケーションのユーザーインターフェイスの開発を簡素化するために構築されたテンプレートフレームワークです。
まず、Apache TilesWebサイトからタイル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
上記に加えて、次のjarファイルをstruts2ダウンロードからコピーする必要があります。 WEB-INF/lib。
- commons-beanutils-x.y.zjar
- commons-digester-x.y.jar
- struts2-tiles-plugin-x.y.z.jar
それでは、セットアップしましょう web.xml以下に示すStruts-Tiles統合の場合。ここで注意すべき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>次に作成しましょう tiles.xml / WEB-INFフォルダの下に次の内容が含まれています-
<?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本文は「タイガー」、タイトルは「タイガー」。同様に、ライオンのレイアウトは基本的なレイアウトと似ていますが、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.tutorialspoint.com/images/tp-logo.gif"/>ザ・ menu.jsp ファイルには、TigerMenu.actionおよびLionMenu.actionstrutsアクションへのリンクである次の行が含まれます。
<%@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.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class MenuAction extends ActionSupport {
public String tiger() { return "tiger"; }
public String lion() { return "lion"; }
}これはかなり単純なクラスです。tiger（）とlion（）の2つのメソッドを宣言し、それぞれtigerとlionを結果として返します。それをすべてまとめましょう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.tutorialspoint.struts2.MenuAction">
<result name = "tiger" type = "tiles">tiger</result>
<result name = "lion" type = "tiles">lion</result>
</action>
</package>
</struts>上記のファイルで何をしたかを確認しましょう。まず、ビューテクノロジにプレーンjspの代わりにタイルを使用しているため、「タイル」と呼ばれる新しい結果タイプを宣言しました。Struts2はTilesView結果タイプをサポートしているため、「org.apache.struts2.view.tiles.TilesResult」クラスの結果タイプ「tiles」を作成します。
次に、リクエストが/tigerMenu.actionに対するものである場合は、ユーザーをtiger tilesページに移動し、リクエストが/lionMenu.actionに対するものである場合は、ユーザーをliontilesページに移動します。
これは、少しの正規表現を使用して実現します。アクション定義では、パターン「* Menu」に一致するものはすべてこのアクションによって処理されると言います。マッチングメソッドはMenuActionクラスで呼び出されます。つまり、tigerMenu.actionはtiger（）を呼び出し、lionMenu.actionはlion（）を呼び出します。次に、結果の結果を適切なタイルページにマッピングする必要があります。
次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/tigerMenu.jsp。これにより、次の画面が表示されます-
同様に、lionMenu.actionページに移動すると、同じタイルレイアウトを使用するライオンページが表示されます。
Hibernateは、オープンソースのGNU劣等一般公衆利用許諾契約書（LGPL）の下でライセンスされ、無料でダウンロードできる、高性能のオブジェクト/リレーショナル永続性およびクエリサービスです。この章では。Struts2とHibernateの統合を実現する方法を学習します。Hibernateに慣れていない場合は、Hibernateチュートリアルを確認できます。
データベースのセットアップ
このチュートリアルでは、「struts2_tutorial」MySQLデータベースを使用します。ユーザー名「root」を使用し、パスワードを使用せずに、自分のマシンでこのデータベースに接続します。まず、次のスクリプトを実行する必要があります。このスクリプトは、という新しいテーブルを作成しますstudent このテーブルにいくつかのレコードを作成します-
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の構成ファイルである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.tutorialspoint.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.tutorialspoint.hibernate.Student" />
</session-factory>
</hibernate-configuration>Hibernate構成ファイルを見てみましょう。まず、MySQLドライバーを使用していることを宣言しました。次に、データベースに接続するためのjdbcurlを宣言しました。次に、接続のユーザー名、パスワード、およびプールサイズを宣言しました。また、「show_sql」をtrueに設定して、ログファイルにSQLを表示することも指定しました。これらのプロパティの意味を理解するには、Hibernateチュートリアルを実行してください。
最後に、マッピングクラスをこの章で作成するcom.tutorialspoint.hibernate.Studentに設定します。
環境設定
次に、このプロジェクトにはたくさんのjarファイルが必要です。添付されているのは、必要なJARファイルの完全なリストのスクリーンショットです-
ほとんどのJARファイルは、Strutsディストリビューションの一部として取得できます。glassfish、websphere、jbossなどのアプリケーションサーバーがインストールされている場合は、残りのjarファイルの大部分をappserverのlibフォルダーから取得できます。そうでない場合は、ファイルを個別にダウンロードできます-
Hibernatejarファイル-Hibernate.org
Strutshibernateプラグイン-Strutshibernateプラグイン
JTAファイル-JTAファイル
Dom4jファイル-Dom4j
log4jファイル-log4j
残りのファイルは、Struts2ディストリビューションから取得できるはずです。
Hibernateクラス
ここで、Hibernate統合に必要なJavaクラスを作成しましょう。以下はの内容ですStudent.java −
package com.tutorialspoint.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;
}
}これは、を表すPOJOクラスです。 studentHibernate仕様によるテーブル。学生テーブルの列名に対応するプロパティid、firstName、lastNameがあります。次に作成しましょうStudentDAO.java 次のようにファイル-
package com.tutorialspoint.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.tutorialspoint.struts2;
import java.util.ArrayList;
import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.tutorialspoint.hibernate.Student;
import com.tutorialspoint.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」オブジェクトを返します。
ビューファイルを作成する
作成しましょう 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、およびマークを取り込みます。addStudentアクションはModelAwareの「AddSudentAction」に関連付けられているため、firstName、lastName、およびマークの値が自動的に入力された学生Beanが自動的に作成されます。
下部のセクションで、学生リストを確認します（AddStudentAction.javaを参照）。リストを繰り返し処理し、名、姓、マークの値をテーブルに表示します。
ストラット構成
を使用してすべてをまとめましょう 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.tutorialspoint.struts2.AddStudentAction">
<result name = "success" type = "redirect">
listStudents
</result>
</action>
<action name = "listStudents" method = "listStudents"
class = "com.tutorialspoint.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をビューとして使用します。
次に、プロジェクト名を右クリックして、 Export > WAR FileWarファイルを作成します。次に、このWARをTomcatのwebappsディレクトリにデプロイします。最後に、Tomcatサーバーを起動し、URLにアクセスしてみますhttp://localhost:8080/HelloWorldStruts2/student.jsp。これにより、次の画面が表示されます-
上のセクションには、新しい学生レコードの値を入力するためのフォームが表示され、下のセクションには、データベース内の学生が一覧表示されます。先に進み、新しい学生レコードを追加して、送信を押します。[送信]をクリックするたびに、画面が更新され、更新されたリストが表示されます。