Struts 2-퀵 가이드
MOdel View Controller 또는 MVC일반적으로 불리는은 웹 애플리케이션 개발을위한 소프트웨어 디자인 패턴입니다. Model View Controller 패턴은 다음 세 부분으로 구성됩니다.
Model − 데이터 유지를 담당하는 패턴의 최하위 수준.
View − 이는 사용자에게 데이터의 전체 또는 일부를 표시하는 책임이 있습니다.
Controller − 모델과 뷰 간의 상호 작용을 제어하는 소프트웨어 코드.
MVC는 사용자 인터페이스 계층에서 응용 프로그램 논리를 분리하고 문제 분리를 지원하므로 널리 사용됩니다. 여기서 컨트롤러는 애플리케이션에 대한 모든 요청을 수신 한 다음 모델과 함께 작동하여 뷰에 필요한 데이터를 준비합니다. 그런 다음 View는 컨트롤러가 준비한 데이터를 사용하여 최종 표현 가능한 응답을 생성합니다. MVC 추상화는 다음과 같이 그래픽으로 표현할 수 있습니다.
모델
모델은 응용 프로그램의 데이터를 관리합니다. 뷰의 요청에 응답하고 컨트롤러의 명령에 응답하여 자체 업데이트합니다.
보기
이는 데이터를 표시하기로 한 컨트롤러의 결정에 의해 트리거되는 특정 형식으로 데이터를 표시하는 것을 의미합니다. JSP, ASP, PHP와 같은 스크립트 기반 템플릿 시스템이며 AJAX 기술과 통합하기가 매우 쉽습니다.
컨트롤러
컨트롤러는 사용자 입력에 응답하고 데이터 모델 개체에 대한 상호 작용을 수행합니다. 컨트롤러는 입력을 받고 입력을 확인한 다음 데이터 모델의 상태를 수정하는 비즈니스 작업을 수행합니다.
Struts2MVC 기반 프레임 워크입니다. 다음 장에서는 Struts2 내에서 MVC 방법론을 어떻게 사용할 수 있는지 살펴 보겠습니다.
Struts2MVC 디자인 패턴을 기반으로하는 인기 있고 성숙한 웹 애플리케이션 프레임 워크입니다. Struts2는 Struts 1의 새로운 버전 일뿐만 아니라 Struts 아키텍처를 완전히 재 작성한 것입니다.
Webwork 프레임 워크는 처음에 Struts 프레임 워크를 기반으로 시작되었으며 그 목표는 개발자가 웹 개발을 더 쉽게 할 수 있도록 Struts에 구축 된 강화되고 개선 된 프레임 워크를 제공하는 것이 었습니다.
잠시 후 Webwork 프레임 워크와 Struts 커뮤니티가 손을 잡고 유명한 Struts2 프레임 워크를 만들었습니다.
Struts 2 프레임 워크 기능
다음은 Struts2를 고려해야하는 몇 가지 훌륭한 기능입니다.
POJO Forms and POJO Actions− Struts2는 Struts 프레임 워크의 필수 부분이었던 Action Forms를 없앴습니다. Struts2를 사용하면 모든 POJO를 사용하여 양식 입력을받을 수 있습니다. 마찬가지로 이제 모든 POJO를 Action 클래스로 볼 수 있습니다.
Tag Support − Struts2는 개발자가 적은 코드를 작성할 수 있도록 양식 태그와 새로운 태그를 개선했습니다.
AJAX Support − Struts2는 Web2.0 기술의 인수를 인식하고 AJAX 태그를 생성하여 AJAX 지원을 제품에 통합했습니다.이 기능은 표준 Struts2 태그와 매우 유사합니다.
Easy Integration − Spring, Tiles 및 SiteMesh와 같은 다른 프레임 워크와의 통합이 이제 Struts2와 함께 사용 가능한 다양한 통합으로 더 쉬워졌습니다.
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 엔터프라이즈 급 프레임 워크로 만듭니다.
Struts 2 단점
Struts 2에는 훌륭한 기능 목록이 포함되어 있지만 현재 버전 인 Struts 2에는 추가 개선이 필요한 몇 가지 제한 사항이 있습니다. 다음은 주요 요점 중 일부입니다.
Bigger Learning Curve − MVC를 Struts와 함께 사용하려면 표준 JSP, Servlet API 및 크고 정교한 프레임 워크에 익숙해야합니다.
Poor Documentation − 표준 서블릿 및 JSP API에 비해 Struts는 온라인 리소스가 적고 많은 최초 사용자가 온라인 Apache 문서가 혼란스럽고 잘못 구성되어 있다고 생각합니다.
Less Transparent − Struts 애플리케이션에서는 프레임 워크를 이해하기 어렵게 만드는 일반적인 Java 기반 웹 애플리케이션보다이면에서 훨씬 더 많은 일이 진행됩니다.
마지막으로 좋은 프레임 워크는 다양한 유형의 애플리케이션에서 사용할 수있는 일반적인 동작을 제공해야합니다.
Struts 2 최고의 웹 프레임 워크 중 하나이며 RIA (Rich Internet Applications) 개발에 많이 사용됩니다.
첫 번째 작업은 최소한의 Struts 2 애플리케이션을 실행하는 것입니다. 이 장에서는 Struts 2로 작업을 시작하기 위해 개발 환경을 준비하는 방법을 안내합니다.
컴퓨터에 이미 JDK (5+), Tomcat 및 Eclipse가 설치되어 있다고 가정합니다. 이러한 구성 요소를 설치하지 않은 경우 빠른 트랙에서 주어진 단계를 따르십시오.
1 단계-JDK (Java Development Kit) 설정
Oracle의 Java 사이트 -Java SE Downloads 에서 최신 버전의 SDK를 다운로드 할 수 있습니다 . 다운로드 한 파일에서 JDK 설치 지침을 찾을 수 있으며, 주어진 지침에 따라 설치 및 구성을 수행합니다. 마지막으로 PATH 및 JAVA_HOME 환경 변수를 설정하여 java 및 javac (일반적으로 각각 java_install_dir / bin 및 java_install_dir)를 포함하는 디렉토리를 참조하십시오.
Windows를 실행 중이고 C : \ jdk1.5.0_20에 SDK를 설치 한 경우 C : \ autoexec.bat 파일에 다음 줄을 입력해야합니다.
set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20또는 Windows NT / 2000 / XP에서-
내 컴퓨터를 마우스 오른쪽 버튼으로 클릭하고 속성, 고급, 환경 변수를 차례로 선택할 수 있습니다. 그런 다음 PATH 값을 업데이트하고 OK 버튼을 누릅니다.
Unix (Solaris, Linux 등)에서 SDK가 /usr/local/jdk1.5.0_20에 설치되어 있고 C 쉘을 사용하는 경우 .cshrc 파일에 다음을 넣습니다.
Unix (Solaris, Linux 등)에서 SDK가 /usr/local/jdk1.5.0_20에 설치되어 있고 C 쉘을 사용하는 경우 .cshrc 파일에 다음을 넣습니다.
setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20또는 Borland JBuilder, Eclipse, IntelliJ IDEA 또는 Sun ONE Studio와 같은 IDE (통합 개발 환경)를 사용하는 경우 간단한 프로그램을 컴파일하고 실행하여 IDE가 Java를 설치 한 위치를 알고 있는지 확인하고 그렇지 않으면 주어진 IDE 문서.
2 단계-Apache Tomcat 설정
최신 버전의 Tomcat을 다음에서 다운로드 할 수 있습니다. https://tomcat.apache.org/. 설치를 다운로드 한 후 편리한 위치에 바이너리 배포판의 압축을 풉니 다.
예를 들어 Windows의 C : \ apache-tomcat-6.0.33 또는 Linux / Unix의 /usr/local/apachetomcat-6.0.33에서 이러한 위치를 가리키는 CATALINA_HOME 환경 변수를 만듭니다.
Windows 시스템에서 다음 명령을 실행하여 Tomcat을 시작하거나 startup.bat를 두 번 클릭하기 만하면됩니다.
%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-6.0.33\bin\startup.batTomcat은 Unix (Solaris, Linux 등) 컴퓨터에서 다음 명령을 실행하여 시작할 수 있습니다.
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-6.0.33/bin/startup.sh성공적으로 시작한 후 Tomcat에 포함 된 기본 웹 응용 프로그램은 다음을 방문하여 사용할 수 있습니다. http://localhost:8080/. 모든 것이 정상이면 다음 결과가 표시됩니다.
Tomcat 구성 및 실행에 대한 자세한 내용은 여기에 포함 된 설명서와 Tomcat 웹 사이트에서 찾을 수 있습니다. https://tomcat.apache.org/
Windows 시스템에서 다음 명령을 실행하여 Tomcat을 중지 할 수 있습니다.
%CATALINA_HOME%\bin\shutdown
or
C:\apache-tomcat-5.5.29\bin\shutdownTomcat은 Unix (Solaris, Linux 등) 시스템에서 다음 명령을 실행하여 중지 할 수 있습니다.
$CATALINA_HOME/bin/shutdown.sh
or
/usr/local/apache-tomcat-5.5.29/bin/shutdown.sh3 단계-Eclipse (IDE) 설정
이 튜토리얼의 모든 예제는 Eclipse IDE를 사용하여 작성되었습니다. 컴퓨터에 최신 버전의 Eclipse가 설치되어있는 것이 좋습니다.
Eclipse를 설치하려면 다음에서 최신 Eclipse 바이너리를 다운로드하십시오. https://www.eclipse.org/downloads/. 설치를 다운로드 한 후 편리한 위치에 바이너리 배포의 압축을 풉니 다.
예를 들어 Windows의 C : \ eclipse 또는 Linux / Unix의 / usr / local / eclipse에서 마지막으로 PATH 변수를 적절하게 설정하십시오. Windows 시스템에서 다음 명령을 실행하여 Eclipse를 시작하거나 eclipse.exe를 두 번 클릭하면됩니다.
%C:\eclipse\eclipse.exeEclipse는 Unix (Solaris, Linux 등) 시스템에서 다음 명령을 실행하여 시작할 수 있습니다.
$/usr/local/eclipse/eclipse성공적으로 시작한 후 모든 것이 정상이면 다음 결과가 표시되어야합니다.
4 단계-Struts2 라이브러리 설정
이제 모든 것이 정상이면 Struts2 프레임 워크 설정을 진행할 수 있습니다. 다음은 컴퓨터에 Struts2를 다운로드하고 설치하는 간단한 단계입니다.
Windows 또는 Unix에 Struts2를 설치할 것인지 선택한 후 다음 단계로 진행하여 Windows 용 .zip 파일과 Unix 용 .tz 파일을 다운로드합니다.
최신 버전의 Struts2 바이너리를 다운로드하십시오. https://struts.apache.org/download.cgi.
이 튜토리얼을 작성할 때 struts-2.0.14-all.zip 다운로드 한 파일의 압축을 풀면 다음과 같이 C : \ struts-2.2.3 내에 디렉토리 구조가 제공됩니다.
두 번째 단계는 모든 위치에서 zip 파일을 추출하는 것입니다. struts-2.2.3-all.zip 에 c:\ 내 Windows 7 컴퓨터의 폴더로 모든 jar 파일을 C:\struts-2.2.3\lib. CLASSPATH 변수를 올바르게 설정했는지 확인하십시오. 그렇지 않으면 응용 프로그램을 실행하는 동안 문제가 발생합니다.
높은 수준에서 Struts2는 pull-MVC (또는 MVC2) 프레임 워크입니다. Struts2의 Model-ViewController 패턴은 다음 5 가지 핵심 구성 요소로 구현됩니다.
- Actions
- Interceptors
- 가치 스택 / OGNL
- 결과 / 결과 유형
- 기술보기
Struts 2 동작이 컨트롤러가 아닌 모델의 역할을 수행하는 기존 MVC 프레임 워크와 약간 다릅니다.
위의 다이어그램은 Model, View 그리고 CStruts2 고수준 아키텍처에 온 트롤러. 컨트롤러는Struts2인터셉터뿐만 아니라 서블릿 필터를 디스패치합니다.이 모델은 작업으로 구현되며보기는 결과 유형과 결과의 조합입니다. 가치 스택과 OGNL은 공통 스레드를 제공하여 다른 구성 요소 간의 통합을 가능하게합니다.
위의 구성 요소 외에도 구성과 관련된 많은 정보가 있습니다. 웹 애플리케이션에 대한 구성 및 작업, 인터셉터, 결과 등에 대한 구성
이것은 Struts 2 MVC 패턴의 아키텍처 개요입니다. 이후 장에서 각 구성 요소에 대해 자세히 살펴 보겠습니다.
라이프 사이클 요청
위의 다이어그램을 바탕으로 사용자의 요청 라이프 사이클을 통한 워크 플로우를 이해할 수 있습니다. Struts 2 다음과 같이-
사용자는 일부 리소스 (예 : 페이지)를 요청하기 위해 서버에 요청을 보냅니다.
필터 디스패처는 요청을보고 적절한 조치를 결정합니다.
검증, 파일 업로드 등과 같은 구성된 인터셉터 기능이 적용됩니다.
선택한 작업은 요청 된 작업에 따라 수행됩니다.
다시 말하지만, 구성된 인터셉터는 필요한 경우 사후 처리를 수행하기 위해 적용됩니다.
마지막으로 결과는 뷰에 의해 준비되고 결과를 사용자에게 반환합니다.
Struts 2 아키텍처에서 이미 배웠 듯이 하이퍼 링크를 클릭하거나 Struts 2 웹 애플리케이션에서 HTML 양식을 제출할 때 입력은 Actions라는 Java 클래스로 전송되는 Controller에 의해 수집됩니다. Action이 실행 된 후 결과는 응답을 렌더링 할 리소스를 선택합니다. 자원은 일반적으로 JSP이지만 PDF 파일, Excel 스프레드 시트 또는 Java 애플릿 창일 수도 있습니다.
이미 개발 환경을 구축했다고 가정합니다. 이제 첫 번째 빌드를 진행하겠습니다.Hello World Struts2계획. 이 프로젝트의 목적은 사용자 이름을 수집하고 "Hello World"다음에 사용자 이름을 표시하는 웹 애플리케이션을 빌드하는 것입니다.
Struts 2 프로젝트에 대해 다음 네 가지 구성 요소를 만들어야합니다.
| Sr. 아니요 | 구성 및 설명 |
|---|---|
| 1 | Action 완전한 비즈니스 로직을 포함하고 사용자, 모델 및보기 간의 상호 작용을 제어하는 조치 클래스를 작성하십시오. |
| 2 | Interceptors 필요한 경우 인터셉터를 생성하거나 기존 인터셉터를 사용합니다. 이것은 컨트롤러의 일부입니다. |
| 삼 | View 입력을 받고 최종 메시지를 표시하기 위해 사용자와 상호 작용할 JSP를 만듭니다. |
| 4 | Configuration Files 작업,보기 및 컨트롤러를 연결하는 구성 파일을 만듭니다. 이러한 파일은 struts.xml, web.xml, struts.properties입니다. |
Eclipse IDE를 사용하여 필요한 모든 구성 요소가 Dynamic Web Project 아래에 생성됩니다. 이제 Dynamic Web Project 생성부터 시작하겠습니다.
동적 웹 프로젝트 만들기
Eclipse를 시작한 다음 File > New > Dynamic Web Project 프로젝트 이름을 다음과 같이 입력하십시오. HelloWorldStruts2 다음 화면과 같이 나머지 옵션을 설정하십시오.
다음 화면에서 모든 기본 옵션을 선택하고 마지막으로 확인하십시오. Generate Web.xml deployment descriptor선택권. 그러면 Eclipse에서 동적 웹 프로젝트가 생성됩니다. 이제Windows > Show View > Project Explorer, 다음과 같이 프로젝트 창을 볼 수 있습니다.
이제 struts 2 lib 폴더에서 다음 파일을 복사하십시오. C:\struts-2.2.3\lib 우리 프로젝트의 WEB-INF\lib폴더. 이렇게하려면 다음 파일을 모두 WEB-INF \ lib 폴더로 끌어서 놓기 만하면됩니다.
- commons-fileupload-x.y.z.jar
- commons-io-x.y.z.jar
- commons-lang-x.y.jar
- commons-logging-x.y.z.jar
- commons-logging-api-x.y.jar
- freemarker-x.y.z.jar
- javassist-.xy.z.GA
- ognl-x.y.z.jar
- struts2-core-x.y.z.jar
- xwork-core.x.y.z.jar
액션 클래스 생성
액션 클래스는 Struts 2 애플리케이션의 핵심이며 대부분의 비즈니스 로직을 액션 클래스에 구현합니다. 이제 Java 파일 HelloWorldAction.java를Java Resources > src 패키지 이름으로 com.tutorialspoint.struts2 아래에 주어진 내용으로.
Action 클래스는 사용자가 URL을 클릭 할 때 사용자 작업에 응답합니다. 하나 이상의 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"이라는 하나의 속성이있는 매우 간단한 클래스입니다. "name"속성에 대한 표준 getter 및 setter 메서드와 "success"문자열을 반환하는 실행 메서드가 있습니다.
Struts 2 프레임 워크는 HelloWorldAction사용자의 작업에 대한 응답으로 실행 된 메서드를 호출합니다. 마지막으로 String 상수를 반환하는이 메서드에 비즈니스 논리를 넣습니다. 즉, 각 URL에 대해 하나의 액션 클래스를 구현해야하며 해당 클래스 이름을 액션 이름으로 직접 사용하거나 아래와 같이 struts.xml 파일을 사용하여 다른 이름에 매핑 할 수 있습니다.
보기 만들기
최종 메시지를 표시하려면 JSP가 필요합니다.이 페이지는 미리 정의 된 작업이 발생하고이 매핑이 struts.xml 파일에 정의 될 때 Struts 2 프레임 워크에 의해 호출됩니다. 따라서 아래 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 지시문은 Servlet 컨테이너에이 페이지가 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 클래스에 정의 된 실행 메서드를 실행하고 메서드의 반환 된 값에 따라 적절한보기가 선택되고 응답으로 렌더링됩니다.
구성 파일
URL, HelloWorldAction 클래스 (모델) 및 HelloWorld.jsp (뷰)를 함께 연결하려면 매핑이 필요합니다. 매핑은 Struts 2 프레임 워크에 사용자의 작업 (URL)에 응답 할 클래스, 해당 클래스의 어떤 메서드가 실행될 것인지, 메서드가 반환하는 String 결과를 기반으로 렌더링 할 뷰를 알려줍니다.
이제 다음과 같은 파일을 생성하겠습니다. struts.xml. Struts 2에서는 클래스 폴더에 struts.xml이 있어야합니다. 따라서 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에서 실행되도록 Struts2 필터를 구성했습니다 (예 : / * 패턴과 일치하는 모든 URL).
상세 로그를 활성화하려면
Struts 2로 작업하는 동안 완전한 로깅 기능을 활성화하려면 logging.properties 아래 파일 WEB-INF/classes폴더. 속성 파일에 다음 두 줄을 유지하십시오-
org.apache.catalina.core.ContainerBase.[Catalina].level = INFO
org.apache.catalina.core.ContainerBase.[Catalina].handlers = \
java.util.logging.ConsoleHandler기본 logging.properties는 로깅을 stdout 및 FileHandler로 라우팅하기위한 ConsoleHandler를 지정합니다. 핸들러의 로그 수준 임계 값은 SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST 또는 ALL을 사용하여 설정할 수 있습니다.
그게 다야. Struts 2 프레임 워크를 사용하여 Hello World 애플리케이션을 실행할 준비가되었습니다.
응용 프로그램 실행 절차
프로젝트 이름을 마우스 오른쪽 버튼으로 클릭하고 Export > WAR File War 파일을 만듭니다.
그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다.
마지막으로 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구성 파일 (이 두 파일을 사용하여 예제가 작동 한 이전 장에서 이미 확인했듯이). 그러나 귀하의 지식을 위해 다른 파일에 대해서도 설명합니다.
web.xml 파일
web.xml 구성 파일은 서블릿 컨테이너에서 HTTP 요청 요소를 처리하는 방법을 결정하는 J2EE 구성 파일입니다. 엄격히 Struts2 구성 파일은 아니지만 Struts2가 작동하도록 구성해야하는 파일입니다.
앞에서 설명한 것처럼이 파일은 모든 웹 응용 프로그램에 대한 진입 점을 제공합니다. Struts2 애플리케이션의 진입 점은 배치 설명자 (web.xml)에 정의 된 필터입니다. 따라서 web.xml 에 FilterDispatcher 클래스 항목을 정의합니다 . web.xml 파일은 폴더 아래에 생성되어야합니다.WebContent/WEB-INF.
이 파일을 생성하는 템플릿이나 도구 (예 : Eclipse 또는 Maven2)없이 시작하는 경우 구성해야하는 첫 번째 구성 파일입니다.
다음은 마지막 예제에서 사용한 web.xml 파일의 내용입니다.
<?xml version = "1.0" Encoding = "UTF-8"?>
<web-app xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id = "WebApp_ID" version = "3.0">
<display-name>Struts 2</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>Struts 2 필터를 /*,하지 /*.action이는 모든 URL이 struts 필터에 의해 구문 분석된다는 것을 의미합니다. 주석 장을 살펴볼 때이를 다룰 것입니다.
Struts.xml 파일
그만큼 struts.xml파일에는 작업이 개발 될 때 수정할 구성 정보가 포함되어 있습니다. 이 파일은 응용 프로그램에 대한 기본 설정 (예 : struts.devMode = false 및 속성 파일에 정의 된 기타 설정) 을 재정의하는 데 사용할 수 있습니다 . 이 파일은 폴더 아래에 만들 수 있습니다.WEB-INF/classes.
이전 장에서 설명한 Hello World 예제에서 만든 struts.xml 파일을 살펴 보겠습니다.
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.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이라는 세 개의 도메인이있는 경우 세 개의 패키지를 만들고 관련 작업을 적절한 패키지에 저장할 수 있습니다.
패키지 태그에는 다음과 같은 속성이 있습니다.
| Sr. 아니요 | 속성 및 설명 |
|---|---|
| 1 | name (required) 패키지의 고유 식별자 |
| 2 | extends 이 패키지는 어떤 패키지에서 확장됩니까? 기본적으로 struts-default를 기본 패키지로 사용합니다. |
| 삼 | abstract true로 표시되면 최종 사용자가 패키지를 사용할 수 없습니다. |
| 4 | namespace 작업에 대한 고유 한 네임 스페이스 |
그만큼 constant 이름 및 값 속성과 함께 태그를 사용하여에 정의 된 다음 속성을 재정의해야합니다. default.properties, 방금 설정 한 것처럼 struts.devMode특성. 환경struts.devMode 속성을 사용하면 로그 파일에서 더 많은 디버그 메시지를 볼 수 있습니다.
우리는 정의합니다 action 태그는 액세스하려는 모든 URL에 해당하며 해당 URL에 액세스 할 때마다 액세스되는 execute () 메소드로 클래스를 정의합니다.
결과는 작업이 실행 된 후 브라우저에 반환되는 내용을 결정합니다. 작업에서 반환 된 문자열은 결과의 이름이어야합니다. 결과는 위와 같이 작업별로 구성되거나 패키지의 모든 작업에 사용할 수있는 "전역"결과로 구성됩니다. 결과에는 선택 사항이 있습니다.name 과 type속성. 기본 이름 값은 "success"입니다.
Struts.xml 파일은 시간이 지남에 따라 커질 수 있으므로 패키지별로 분할하는 것이 모듈화하는 한 가지 방법이지만 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 구성 파일은 웹 클라이언트의보기 및 모델 구성 요소 간의 링크이지만 프로젝트의 99.99 %에 대해 이러한 설정을 건드릴 필요가 없습니다.
구성 파일은 기본적으로 다음과 같은 주요 요소를 포함합니다.
| Sr. 아니요 | 인터셉터 및 설명 |
|---|---|
| 1 | struts-config 구성 파일의 루트 노드입니다. |
| 2 | form-beans 여기에서 ActionForm 하위 클래스를 이름에 매핑합니다. 나머지 strutsconfig.xml 파일과 JSP 페이지에서도이 이름을 ActionForm의 별명으로 사용합니다. |
| 삼 | global forwards 이 섹션은 웹앱의 페이지를 이름에 매핑합니다. 이 이름을 사용하여 실제 페이지를 참조 할 수 있습니다. 이렇게하면 웹 페이지에서 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.propertiesstruts2-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은 사용자의 요청을 처리하는 데 필요한 처리 논리를 제공하는 특정 작업에 매핑됩니다.
그러나이 조치는 다른 두 가지 중요한 역할을합니다. 첫째, 작업은 JSP 또는 다른 유형의 결과에 관계없이 요청에서보기를 통해 데이터를 전송하는 데 중요한 역할을합니다. 둘째, 작업은 요청에 대한 응답으로 반환 될 뷰를 렌더링해야하는 결과를 결정하는 프레임 워크를 지원해야합니다.
액션 만들기
작업에 대한 유일한 요구 사항 Struts2String 또는 Result 개체를 반환하는 인수없는 메서드가 하나 있어야하며 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;
}Hello World 예제에서 액션 메서드를 살펴 보겠습니다.
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;
}
}이 예제에서 우리는 이름 속성을보기위한 실행 메소드에 몇 가지 로직을 가지고 있습니다. 속성이 문자열과 같은 경우"SECRET", 우리는 돌아 간다 SUCCESS 그 결과 그렇지 않으면 우리는 ERROR결과로서. ActionSupport를 확장했기 때문에 문자열 상수를 사용할 수 있습니다.SUCCESS및 ERROR. 이제 다음과 같이 struts.xml 파일을 수정하겠습니다.
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "hello"
class = "com.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 폴더에 있습니다. 이 파일은 사용자가 클릭하여 Struts 2 프레임 워크에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 Struts 2 프레임 워크를 사용하는 애플리케이션.
응용 프로그램 실행
프로젝트 이름을 마우스 오른쪽 버튼으로 클릭하고 Export > WARWar 파일을 만드는 파일입니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 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 프레임 워크는 미리 구성되어 바로 사용할 수있는 즉시 사용 가능한 인터셉터 목록을 제공합니다. 중요한 인터셉터는 다음과 같습니다.
| Sr. 아니요 | 인터셉터 및 설명 |
|---|---|
| 1 | alias 매개 변수가 요청 전체에서 다른 이름 별칭을 가질 수 있습니다. |
| 2 | checkbox 선택하지 않은 선택란에 대해 매개 변수 값 false를 추가하여 선택란 관리를 지원합니다. |
| 삼 | conversionError 문자열을 매개 변수 유형으로 변환하는 오류 정보를 조치의 필드 오류에 배치합니다. |
| 4 | createSession HTTP 세션이 아직없는 경우 자동으로 생성합니다. |
| 5 | debugging 개발자에게 다양한 디버깅 화면을 제공합니다. |
| 6 | execAndWait 작업이 백그라운드에서 실행되는 동안 사용자를 중간 대기 페이지로 보냅니다. |
| 7 | exception 작업에서 발생한 예외를 결과에 매핑하여 리디렉션을 통한 자동 예외 처리를 허용합니다. |
| 8 | fileUpload 간편한 파일 업로드가 가능합니다. |
| 9 | i18n 사용자 세션 중에 선택한 로케일을 추적합니다. |
| 10 | logger 실행중인 작업의 이름을 출력하여 간단한 로깅을 제공합니다. |
| 11 | params 조치에 대한 요청 매개 변수를 설정합니다. |
| 12 | prepare 이는 일반적으로 데이터베이스 연결 설정과 같은 사전 처리 작업을 수행하는 데 사용됩니다. |
| 13 | profile 작업에 대한 간단한 프로파일 링 정보를 기록 할 수 있습니다. |
| 14 | scope 세션 또는 응용 프로그램 범위에서 작업의 상태를 저장하고 검색합니다. |
| 15 | ServletConfig 다양한 서블릿 기반 정보에 대한 액세스와 함께 조치를 제공합니다. |
| 16 | timer 작업을 실행하는 데 걸리는 시간의 형태로 간단한 프로파일 링 정보를 제공합니다. |
| 17 | token 중복 양식 제출을 방지하기 위해 유효한 토큰에 대한 조치를 확인합니다. |
| 18 | validation 작업에 대한 유효성 검사 지원을 제공합니다. |
위에서 언급 한 인터셉터에 대한 자세한 내용은 Struts 2 문서를 참조하십시오. 하지만 Struts 애플리케이션에서 일반적으로 인터셉터를 사용하는 방법을 보여 드리겠습니다.
인터셉터를 사용하는 방법?
"Hello World"프로그램에 이미 존재하는 인터셉터를 사용하는 방법을 살펴 보겠습니다. 우리는timer액션 메서드를 실행하는 데 걸린 시간을 측정하는 목적을 가진 인터셉터. 동시에 나는params요청 매개 변수를 조치에 보내는 것을 목적으로하는 인터셉터. 이 인터셉터를 사용하지 않고 예제를 시도 할 수 있으며name 매개 변수가 작업에 도달 할 수 없기 때문에 속성이 설정되지 않았습니다.
HelloWorldAction.java, web.xml, HelloWorld.jsp 및 index.jsp 파일은 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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 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"문자열을 반환하는 실행 메서드가 있습니다.
보기 만들기
아래 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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 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"등록은 hello 액션과 함께 모든 6 개의 인터셉터의 완전한 지분을 등록합니다. 인터셉터는 구성된 순서대로 실행된다는 점에 유의해야합니다. 예를 들어, 위의 경우 예외가 먼저 실행되고 두 번째는 servlet-config 등이 실행됩니다.
앞서 언급했듯이 <results> 태그는 viewStruts2 MVC 프레임 워크에서. 이 작업은 비즈니스 논리를 실행합니다. 비즈니스 로직을 실행 한 후 다음 단계는<results> 꼬리표.
종종 결과와 함께 몇 가지 탐색 규칙이 첨부됩니다. 예를 들어 작업 방법이 사용자를 인증하는 경우 가능한 결과는 세 가지입니다.
- 성공적인 로그인
- 로그인 실패-잘못된 사용자 이름 또는 비밀번호
- 잠긴 계정
이 시나리오에서 작업 방법은 결과를 렌더링하기 위해 세 가지 가능한 결과 문자열과 세 가지 다른보기로 구성됩니다. 우리는 이미 이전 예제에서 이것을 보았습니다.
그러나 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 ...> 요소 내에서 <param name = "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 파일을 만듭니다.
그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 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 파일을 수정하고 hello 작업이 성공할 때마다 리디렉션 될 새 파일 NewWorld.jpg를 만듭니다. 더 나은 이해를 위해 Struts 2 Redirect Action 예제를 확인할 수 있습니다 .
가치 스택
값 스택은 제공된 순서대로 다음 개체를 유지하는 여러 개체의 집합입니다-
| Sr. 아니요 | 개체 및 설명 |
|---|---|
| 1 | Temporary Objects 페이지 실행 중에 생성되는 다양한 임시 개체가 있습니다. 예를 들어 JSP 태그에서 반복되는 콜렉션의 현재 반복 값입니다. |
| 2 | The Model Object Struts 애플리케이션에서 모델 객체를 사용하는 경우 현재 모델 객체가 값 스택의 작업 앞에 배치됩니다. |
| 삼 | The Action Object 실행중인 현재 작업 개체가됩니다. |
| 4 | Named Objects 이러한 객체에는 #application, #session, #request, #attr 및 #parameters가 포함되며 해당 서블릿 범위를 참조합니다. |
값 스택은 JSP, Velocity 또는 Freemarker에 제공된 태그를 통해 액세스 할 수 있습니다. 별도의 장에서 공부할 다양한 태그가 있으며 struts 2.0 값 스택을 가져오고 설정하는 데 사용됩니다. 다음과 같이 작업 내에서 valueStack 객체를 얻을 수 있습니다.
ActionContext.getContext().getValueStack()ValueStack 객체가 있으면 다음 메서드를 사용하여 해당 객체를 조작 할 수 있습니다.
| Sr. 아니요 | ValueStack 방법 및 설명 |
|---|---|
| 1 | Object findValue(String expr) 기본 검색 순서의 스택에 대해 주어진 표현식을 평가하여 값을 찾으십시오. |
| 2 | CompoundRoot getRoot() 스택에 푸시 된 객체를 보유하는 CompoundRoot를 가져옵니다. |
| 삼 | 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) 기본 검색 순서를 사용하여 주어진 표현식으로 스택의 빈에 속성을 설정하려고합니다. |
| 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"/>세션에 "login"이라는 속성이 있으면 다음과 같이 검색 할 수 있습니다.
<s:property value = "#session.login"/>OGNL은 또한 Map, List 및 Set와 같은 컬렉션 처리를 지원합니다. 예를 들어 색상 드롭 다운 목록을 표시하려면 다음을 수행 할 수 있습니다.
<s:select name = "color" list = "{'red','yellow','green'}" />OGNL 표현식은 "빨강", "노란색", "녹색"을 색상으로 해석하고이를 기반으로 목록을 작성하는 데 영리합니다.
OGNL 표현식은 다음 장에서 다른 태그를 연구 할 때 광범위하게 사용됩니다. 따라서 개별적으로보기보다는 양식 태그 / 제어 태그 / 데이터 태그 및 Ajax 태그 섹션의 몇 가지 예를 사용하여 살펴 보겠습니다.
ValueStack / OGNL 예제
액션 만들기
valueStack에 액세스 한 다음 뷰, 즉 JSP 페이지에서 OGNL을 사용하여 액세스 할 몇 가지 키를 설정하는 다음 액션 클래스를 고려해 보겠습니다.
package com.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의 맨 위에 작업을 추가합니다. 따라서 값 스택에 항목을 넣는 일반적인 방법은 값에 대한 getter / setter를 Action 클래스에 추가 한 다음 <s : property> 태그를 사용하여 값에 액세스하는 것입니다. 하지만 저는 Struts에서 ActionContext와 ValueStack이 정확히 어떻게 작동하는지 보여 드리고 있습니다.
보기 만들기
아래 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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다.
마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오. http://localhost:8080/HelloWorldStruts2/index.jsp. 그러면 다음 화면이 생성됩니다.
이제 주어진 텍스트 상자에 단어를 입력하고 "Say Hello"버튼을 클릭하여 정의 된 작업을 실행합니다. 이제 생성 된 로그를 확인하면 하단에 다음과 같은 텍스트가 있습니다.
Size of the valueStack: 3그러면 입력 할 값과 ValueStack에 입력 한 key1 및 key2의 값이 표시되는 다음 화면이 표시됩니다.
Struts 2 프레임 워크는 "HTML의 양식 기반 파일 업로드"를 사용하여 파일 업로드 처리를위한 내장 지원을 제공합니다. 파일이 업로드되면 일반적으로 임시 디렉토리에 저장되며 데이터가 손실되지 않도록 조치 클래스에 의해 영구 디렉토리로 처리되거나 이동되어야합니다.
Note − 서버에는 임시 디렉토리 및 웹 애플리케이션에 속한 디렉토리 이외의 디렉토리에 쓰기를 금지하는 보안 정책이있을 수 있습니다.
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 인터셉터가 우리를 위해 모든 무거운 작업을 수행한다는 것입니다.
FileUpload 인터셉터는 기본적으로 세 가지 매개 변수를 제공합니다. 그들은 다음 패턴으로 명명됩니다-
[your file name parameter] − 사용자가 업로드 한 실제 파일입니다. 이 예에서는 "myFile"이됩니다.
[your file name parameter]ContentType− 업로드 된 파일의 내용 유형입니다. 이 예에서는 "myFileContentType"이됩니다.
[your file name parameter]FileName− 업로드 된 파일의 이름입니다. 이 예에서는 "myFileFileName"이됩니다.
Struts 인터셉터 덕분에 세 가지 매개 변수를 사용할 수 있습니다. 우리가해야 할 일은 Action 클래스에서 올바른 이름으로 세 개의 매개 변수를 만드는 것입니다.이 변수는 자동으로 연결됩니다. 따라서 위의 예에서 세 개의 매개 변수와 모든 것이 잘 진행되면 단순히 "성공"을 반환하는 액션 메소드가 있습니다. 그렇지 않으면 "오류"를 반환합니다.
구성 파일
다음은 파일 업로드 프로세스를 제어하는 Struts2 구성 속성입니다.
| Sr. 아니요 | 속성 및 설명 |
|---|---|
| 1 | struts.multipart.maxSize 파일 업로드로 허용 할 파일의 최대 크기 (바이트)입니다. 기본값은 250M입니다. |
| 2 | struts.multipart.parser 멀티 파트 양식을 업로드하는 데 사용되는 라이브러리입니다. 기본적으로jakarta |
| 삼 | 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 인터셉터는 두 개의 매개 변수를 사용합니다.(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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오.http://localhost:8080/HelloWorldStruts2/upload.jsp. 그러면 다음 화면이 생성됩니다.
이제 Browse 버튼을 사용하여 "Contacts.txt"파일을 선택하고 업로드 버튼을 클릭하면 서브에 파일이 업로드되고 다음 페이지가 표시됩니다. 업로드 된 파일이 C : \ apache-tomcat-6.0.33 \ work에 저장되어 있는지 확인할 수 있습니다.
FileUpload 인터셉터는 업로드 된 파일을 자동으로 삭제하므로 삭제하기 전에 업로드 된 파일을 특정 위치에 프로그래밍 방식으로 저장해야합니다.
오류 메시지
fileUplaod 인터셉터는 몇 가지 기본 오류 메시지 키를 사용합니다.
| Sr. 아니요 | 오류 메시지 키 및 설명 |
|---|---|
| 1 | struts.messages.error.uploading 파일을 업로드 할 수 없을 때 발생하는 일반적인 오류입니다. |
| 2 | struts.messages.error.file.too.large 업로드 된 파일이 maximumSize에 지정된 것보다 너무 큰 경우 발생합니다. |
| 삼 | struts.messages.error.content.type.not.allowed 업로드 된 파일이 지정된 예상 콘텐츠 형식과 일치하지 않을 때 발생합니다. |
다음에서 이러한 메시지의 텍스트를 재정의 할 수 있습니다. WebContent/WEB-INF/classes/messages.properties 리소스 파일.
이 장에서는 간단한 단계로 Struts 2를 사용하여 데이터베이스에 액세스하는 방법을 설명합니다. Struts는 MVC 프레임 워크이며 데이터베이스 프레임 워크는 아니지만 JPA / Hibernate 통합에 대한 탁월한 지원을 제공합니다. 이후 장에서 하이버 네이트 통합에 대해 살펴 보 겠지만이 장에서는 데이터베이스에 액세스하기 위해 일반 구형 JDBC를 사용합니다.
이 장의 첫 번째 단계는 데이터베이스를 설정하고 초기화하는 것입니다. 이 예제에서는 MySQL을 데이터베이스로 사용하고 있습니다. 내 컴퓨터에 MySQL이 설치되어 있고 "struts_tutorial"이라는 새 데이터베이스를 만들었습니다. 나는 테이블을 만들었습니다.login일부 값으로 채웠습니다. 아래는 테이블을 만들고 채우는 데 사용한 스크립트입니다.
내 MYSQL 데이터베이스에는 기본 사용자 이름 "root"및 "root123"암호가 있습니다.
CREATE TABLE `struts_tutorial`.`login` (
`user` VARCHAR( 10 ) NOT NULL ,
`password` VARCHAR( 10 ) NOT NULL ,
`name` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `user` )
) ENGINE = InnoDB;
INSERT INTO `struts_tutorial`.`login` (`user`, `password`, `name`)
VALUES ('scott', 'navy', 'Scott Burgemott');다음 단계는 MySQL Connector jar 파일 을 다운로드 하고이 파일을 프로젝트의 WEB-INF \ lib 폴더에 배치하는 것입니다. 이 작업을 마치면 이제 액션 클래스를 만들 준비가되었습니다.
액션 만들기
조치 클래스에는 데이터베이스 테이블의 열에 해당하는 특성이 있습니다. 우리는user, password 과 name문자열 속성으로. 작업 방법에서는 사용자 및 암호 매개 변수를 사용하여 사용자가 존재하는지 확인하고, 존재하는 경우 다음 화면에 사용자 이름을 표시합니다.
사용자가 잘못된 정보를 입력 한 경우 다시 로그인 화면으로 보냅니다.
다음 내용은 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 조치에서 ERROR가 리턴되는 경우.
<%@ 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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오.http://localhost:8080/HelloWorldStruts2/index.jsp. 그러면 다음 화면이 생성됩니다.
잘못된 사용자 이름과 암호를 입력하십시오. 다음 페이지가 보일 것입니다.
이제 입력 scott 사용자 이름 및 navy암호로. 다음 페이지가 보일 것입니다.
이 장에서는 Struts 2 애플리케이션을 사용하여 이메일을 보내는 방법을 설명합니다.
이 연습을 위해 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를 사용하고 있으므로 유효한 gtalk ID가 필요합니다.
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 조치에서 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 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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오.http://localhost:8080/HelloWorldStruts2/index.jsp. 그러면 다음 화면이 생성됩니다.
필요한 정보를 입력하고 Send Email단추. 모든 것이 잘되면 다음 페이지가 표시됩니다.
이 장에서 우리는 Struts 검증 프레임 워크에 대해 더 자세히 살펴볼 것입니다. Struts 코어에는 작업 메서드가 실행되기 전에 유효성 검사를 수행하는 규칙을 실행하도록 애플리케이션을 지원하는 유효성 검사 프레임 워크가 있습니다.
클라이언트 측 유효성 검사는 일반적으로 Javascript를 사용하여 수행됩니다. 그러나 클라이언트 측 유효성 검사에만 의존해서는 안됩니다. 모범 사례에 따르면 애플리케이션 프레임 워크의 모든 수준에서 유효성 검사를 도입해야합니다. 이제 Struts 프로젝트에 유효성 검사를 추가하는 두 가지 방법을 살펴 보겠습니다.
여기에서 우리는 Employee 간단한 페이지를 사용하여 이름과 나이를 캡처해야하며 사용자가 항상 28에서 65 사이의 범위에있는 이름과 나이를 입력하는지 확인하기 위해이 두 가지 유효성 검사를 수행합니다.
예제의 기본 JSP 페이지부터 시작하겠습니다.
메인 페이지 생성
메인 페이지 JSP 파일 작성 index.jsp, 위에서 언급 한 직원 관련 정보를 수집하는 데 사용됩니다.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20" />
<s:textfield name = "age" label = "Age" size = "20" />
<s:submit name = "submit" label = "Submit" align="center" />
</s:form>
</body>
</html>index.jsp는 아직 다루지 않은 Struts 태그를 사용하지만 태그 관련 장에서 살펴 보겠습니다. 그러나 지금은 s : textfield 태그가 입력 필드를 인쇄하고 s : submit이 제출 버튼을 인쇄한다고 가정합니다. 우리는 각 태그에 대한 레이블을 생성하는 각 태그에 대해 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");
}
}
}위의 예와 같이 유효성 검사 방법은 '이름'필드에 값이 있는지 여부를 확인합니다. 값이 제공되지 않은 경우 사용자 지정 오류 메시지와 함께 '이름'필드에 대한 필드 오류를 추가합니다. 둘째, 'Age'필드에 입력 된 값이 28 ~ 65 사이인지 확인하고,이 조건이 충족되지 않으면 유효성 검사 필드 위에 오류를 추가합니다.
구성 파일
마지막으로 struts.xml 다음과 같이 구성 파일-
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "helloworld" extends = "struts-default">
<action name = "empinfo"
class = "com.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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오.http://localhost:8080/HelloWorldStruts2/index.jsp. 그러면 다음 화면이 생성됩니다.
이제 필요한 정보를 입력하지 말고 Submit단추. 다음 결과가 표시됩니다-
필요한 정보를 입력하되 From 필드를 잘못 입력하고 이름은 "test", age는 30으로 말하고 마지막으로 클릭합니다. Submit단추. 다음 결과가 표시됩니다-
이 검증은 어떻게 작동합니까?
사용자가 제출 버튼을 누르면 Struts 2는 자동으로 validate 메소드를 실행하고 “if”메서드 안에 나열된 문이 참이면 Struts 2는 addFieldError 메서드를 호출합니다. 오류가 추가 된 경우 Struts 2는 실행 메소드 호출을 진행하지 않습니다. 오히려 Struts 2 프레임 워크가input 조치를 호출 한 결과입니다.
따라서 유효성 검사가 실패하고 Struts 2가 input, Struts 2 프레임 워크는 index.jsp 파일을 다시 표시합니다. Struts 2 양식 태그를 사용했기 때문에 Struts 2는 양식 파일 바로 위에 오류 메시지를 자동으로 추가합니다.
이러한 오류 메시지는 addFieldError 메서드 호출에서 지정한 것입니다. addFieldError 메서드는 두 개의 인수를 사용합니다. 첫 번째는form 오류가 적용되는 필드 이름이고 두 번째는 해당 양식 필드 위에 표시 할 오류 메시지입니다.
addFieldError("name","The name is required");반환 값을 처리하려면 input 다음 결과를 액션 노드에 추가해야합니다. struts.xml.
<result name = "input">/index.jsp</result>XML 기반 유효성 검사
유효성 검사를 수행하는 두 번째 방법은 액션 클래스 옆에 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에 보관됩니다. Employee 액션 클래스를 다음과 같이 만들지 않고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 파일을 작성할 수 있습니다. 주목해야 할 또 다른 사항은 기본적으로 사용 가능한 유효성 검사기 유형입니다.
Struts와 함께 기본적으로 제공되는 더 많은 유효성 검사기가 있습니다. 일반적인 유효성 검사기에는 날짜 유효성 검사기, 정규식 유효성 검사기 및 문자열 길이 유효성 검사기가 포함됩니다. Struts-XML Based Validators에 대한 자세한 내용은 다음 링크를 확인하십시오 .
국제화 (i18n)는 제품 및 서비스를 계획하고 구현하여 특정 현지 언어 및 문화에 쉽게 적용 할 수 있도록하는 프로세스입니다.이를 로컬라이제이션이라고합니다. 국제화 프로세스를 번역 또는 현지화 지원이라고합니다.
국제화는 축약됩니다. i18n 단어가 문자로 시작하기 때문에 “i” 그리고 끝 “n”, 첫 번째 i와 마지막 n 사이에는 18 개의 문자가 있습니다.
Struts2는 다음 위치에서 리소스 번들, 인터셉터 및 태그 라이브러리를 통해 지역화, 즉 국제화 (i18n) 지원을 제공합니다.
UI 태그
메시지 및 오류.
액션 클래스 내.
리소스 번들
Struts2는 자원 번들을 사용하여 웹 애플리케이션 사용자에게 여러 언어 및 로케일 옵션을 제공합니다. 다른 언어로 페이지를 작성하는 것에 대해 걱정할 필요가 없습니다. 원하는 각 언어에 대한 리소스 번들을 생성하기 만하면됩니다. 리소스 번들에는 사용자 언어로 된 제목, 메시지 및 기타 텍스트가 포함됩니다. 리소스 번들은 애플리케이션의 기본 언어에 대한 키 / 값 쌍이 포함 된 파일입니다.
리소스 파일의 가장 간단한 이름 지정 형식은 다음과 같습니다.
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
여러 언어로 애플리케이션을 개발하려면 해당 언어 / 로케일에 해당하는 여러 속성 파일을 유지하고 키 / 값 쌍의 관점에서 모든 콘텐츠를 정의해야합니다.
예를 들어 미국 영어 (기본값), 스페인어 및 프랑스어 용 응용 프로그램을 개발하려는 경우 세 개의 속성 파일을 만들어야합니다. 여기서는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>여기에서 다음 두 가지 작업을 만들어야합니다. (a) 첫 번째 조치 a는 로케일을 처리하고 동일한 index.jsp 파일을 다른 언어로 표시합니다. (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;
}
}이제 다음 세 가지를 만들어 보겠습니다. 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 다음과 같이 두 가지 동작으로-
<?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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 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.
이 연습에서는 환경을 "개발"로, 운영 체제를 "Windows XP SP3"로 하드 코딩했습니다.
실시간 프로젝트에서는 시스템 구성에서이 정보를 얻을 수 있습니다.
다음과 같은 액션 클래스가 있습니다.
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 파일을 만듭니다.
그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다.
마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오. http://localhost:8080/HelloWorldStruts2/system.action. 그러면 다음 화면이 생성됩니다.
위의 출력에 어떤 문제가 있습니까? Struts는 문자열 "Windows XP SP3"및 기타 기본 제공 데이터 유형을 표시하고 변환하는 방법을 알고 있지만 속성으로 수행 할 작업을 모릅니다Environment유형. 간단히toString() 수업 방법
이 문제를 해결하기 위해 이제 간단한 TypeConverter 환경 클래스.
라는 클래스를 만듭니다. 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에게 환경을 문자열로 또는 그 반대로 변환하는 방법을 알려줍니다. convertFromString() 과 convertToString().
이제 응용 프로그램에서 사용하기 전에이 변환기를 등록하겠습니다. 변환기를 등록하는 방법에는 두 가지가 있습니다.
변환기가 특정 작업에서만 사용되는 경우 다음과 같이 이름을 지정해야하는 속성 파일을 만들어야합니다. '[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환경 유형의 객체를 만날 때마다 자동으로 변환을 수행 할 수 있습니다. 이제 프로그램을 다시 컴파일하고 다시 실행하면 다음과 같이 더 나은 출력을 얻을 수 있습니다.
분명히 이제 결과가 더 나아질 것이며 이는 Struts 변환기가 잘 작동 함을 의미합니다.
이것이 여러 변환기를 만들고 요구 사항에 따라 사용하도록 등록하는 방법입니다.
이 장의 실제 튜토리얼을 시작하기 전에 다음과 같이 몇 가지 정의를 살펴 보겠습니다. https://struts.apache.org−
| Sr. 아니요 | 용어 및 설명 |
|---|---|
| 1 | TAG JSP, FreeMarker 또는 Velocity 내에서 실행되는 작은 코드입니다. |
| 2 | TEMPLATE 일반적으로 FreeMarker로 작성된 약간의 코드로 특정 태그 (HTML 태그)로 렌더링 할 수 있습니다. |
| 삼 | THEME 공통 기능을 제공하기 위해 함께 패키지 된 템플릿 모음입니다. |
또한 연습을 수행하기 위해 동일한 예제를 다시 사용할 것이므로 Struts2 Localization 장을 살펴볼 것을 제안 합니다.
사용할 때 Struts 2웹 페이지에서 <s : submit ...>, <s : textfield ...> 등과 같은 태그를 사용하면 Struts 2 프레임 워크는 미리 구성된 스타일과 레이아웃으로 HTML 코드를 생성합니다. Struts 2에는 세 가지 기본 제공 테마가 있습니다.
| Sr. 아니요 | 주제 및 설명 |
|---|---|
| 1 | SIMPLE theme "종소리와 휘파람"이없는 최소한의 테마. 예를 들어, textfield 태그는 레이블, 유효성 검사, 오류보고 또는 기타 형식이나 기능없이 HTML <input /> 태그를 렌더링합니다. |
| 2 | XHTML theme 이것은 Struts 2에서 사용하는 기본 테마이며 단순 테마가 제공하는 모든 기본 사항을 제공하고 HTML에 대한 표준 2 열 테이블 레이아웃, 각 HTML에 대한 레이블, 유효성 검사 및 오류보고 등과 같은 여러 기능을 추가합니다. |
| 삼 | CSS_XHTML theme 이 테마는 단순 테마가 제공하는 모든 기본 사항을 제공하고, HTML Struts 태그에 <div>를 사용하고 CSS 스타일 시트에 따라 배치 된 각 HTML Struts 태그에 대한 레이블을 사용하여 표준 2 열 CSS 기반 레이아웃과 같은 여러 기능을 추가합니다. . |
위에서 언급했듯이 테마를 지정하지 않으면 Struts 2는 기본적으로 xhtml 테마를 사용합니다. 예를 들어,이 Struts 2 select tag −
<s:textfield name = "name" label = "Name" />다음 HTML 마크 업 생성-
<tr>
<td class="tdLabel">
<label for = "empinfo_name" class="label">Name:</label>
</td>
<td>
<input type = "text" name = "name" value = "" id = "empinfo_name"/>
</td>
</tr>여기 empinfo struts.xml 파일에 정의 된 조치 이름입니다.
테마 선택
Struts 2, 태그 기준에 따라 테마를 지정하거나 다음 방법 중 하나를 사용하여 Struts 2가 사용해야하는 테마를 지정할 수 있습니다.
특정 태그의 테마 속성
태그 주변 양식 태그의 테마 속성
"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.
속도 또는 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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오.http://localhost:8080/HelloWorldStruts2. 그러면 다음 화면이 생성됩니다.
xhtml 테마에서 복사 한 후 out 테마에서 변경 한 결과 인 양식 구성 요소 주변의 테두리를 볼 수 있습니다. FreeMarker를 배우는 데 약간의 노력을 기울이면 테마를 매우 쉽게 만들거나 수정할 수 있습니다.
이제 기본적인 이해가 되셨기를 바랍니다. Sturts 2 테마와 템플릿, 그렇지 않습니까?
Struts포착되지 않은 예외를 처리하고 사용자를 전용 오류 페이지로 리디렉션하는 더 쉬운 방법을 제공합니다. 다른 예외에 대해 다른 오류 페이지를 갖도록 Struts를 쉽게 구성 할 수 있습니다.
Struts는 "예외"인터셉터를 사용하여 예외 처리를 쉽게합니다. "예외"인터셉터는 기본 스택의 일부로 포함되어 있으므로 구성하기 위해 추가 작업을 수행 할 필요가 없습니다. 바로 사용할 수 있습니다.
HelloWorldAction.java 파일을 약간 수정 한 간단한 Hello World 예제를 살펴 보겠습니다. 여기서는 의도적으로 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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 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는 두 가지 형태의 구성을 제공합니다. 전통적인 방법은struts.xml모든 구성에 대한 파일. 지금까지 튜토리얼에서 많은 예제를 보았습니다. Struts를 구성하는 다른 방법은 Java 5 Annotations 기능을 사용하는 것입니다. Struts 주석을 사용하여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 파일을 작성하고 annotaions로 교체하십시오.
Struts2에서 Annotation의 개념을 설명하려면 Struts2 Validations 장 에서 설명한 검증 예제를 재고해야합니다 .
여기에서는 이름, 나이가 간단한 페이지를 사용하여 캡처되는 직원의 예를 살펴보고 ÜSER가 항상 이름을 입력하고 나이가 28 ~ 65 세 사이인지 확인하기 위해 두 가지 유효성 검사를 수행합니다.
예제의 기본 JSP 페이지부터 시작하겠습니다.
메인 페이지 생성
메인 페이지 JSP 파일 작성 index.jsp, 위에서 언급 한 직원 관련 정보를 수집하는 데 사용됩니다.
<%@ page language = "java" contentType = "text/html; charset = ISO-8859-1"
pageEncoding = "ISO-8859-1"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Employee Form</title>
</head>
<body>
<s:form action = "empinfo" method = "post">
<s:textfield name = "name" label = "Name" size = "20" />
<s:textfield name = "age" label = "Age" size = "20" />
<s:submit name = "submit" label = "Submit" align="center" />
</s:form>
</body>
</html>index.jsp는 아직 다루지 않은 Struts 태그를 사용하지만 태그 관련 장에서 살펴볼 것입니다. 그러나 지금은 s : textfield 태그가 입력 필드를 인쇄하고 s : submit이 제출 버튼을 인쇄한다고 가정합니다. 우리는 각 태그에 대한 레이블을 생성하는 각 태그에 대해 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주석. 결과 주석은 결과 모음입니다.
결과 주석 아래에는 두 개의 결과 주석이 있습니다. 결과 주석에는name실행 메소드의 결과에 해당합니다. 또한 execute ()의 반환 값에 해당하는 뷰를 제공해야하는 위치도 포함합니다.
다음 주석은 Action주석. execute () 메서드를 장식하는 데 사용됩니다. Action 메소드는 또한 액션이 호출되는 URL 값을받습니다.
마지막으로 두 가지를 사용했습니다. 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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오.http://localhost:8080/HelloWorldStruts2/index.jsp. 그러면 다음 화면이 생성됩니다.
이제 필요한 정보를 입력하지 말고 Submit단추. 다음 결과가 표시됩니다-
필요한 정보를 입력하되 From 필드를 잘못 입력하고 이름은 "test", age는 30으로 말하고 마지막으로 클릭합니다. Submit단추. 다음 결과가 표시됩니다-
Struts 2 주석 유형
Struts 2 애플리케이션은 XML 및 Java 특성 구성의 대안으로 Java 5 주석을 사용할 수 있습니다. 다른 카테고리와 관련된 가장 중요한 주석 목록을 확인할 수 있습니다.
Struts 2 주석 유형 .
Struts 2 태그에는 페이지 실행 흐름을 쉽게 제어 할 수있는 태그 세트가 있습니다.
다음은 중요한 Struts 2 제어 태그 목록입니다.
If 및 Else 태그
이러한 태그는 모든 언어에서 발견되는 기본 조건 흐름을 수행합니다.
'If' 태그는 단독으로 또는 'Else If' 태그 및 / 또는 단일 / 다중 'Else' 아래 그림과 같이 태그-
<s:if test = "%{false}">
<div>Will Not Be Executed</div>
</s:if>
<s:elseif test = "%{true}">
<div>Will Be Executed</div>
</s:elseif>
<s:else>
<div>Will Not Be Executed</div>
</s:else>자세한 예 확인
반복자 태그
이 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 태그는 두 개 이상의 목록을 매개 변수로 취하고 아래와 같이 모두 병합합니다.
<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 태그는 두 개 이상의 목록을 매개 변수로 취하고 아래에 표시된대로 모두 함께 추가합니다.
<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>자세한 예 확인
생성기 태그
이들 generator태그는 제공된 val 속성을 기반으로 반복자를 생성합니다. 다음 생성기 태그는 반복기를 생성하고 반복기 태그를 사용하여 출력합니다.
<s:generator val = "%{'aaa,bbb,ccc,ddd,eee'}">
<s:iterator>
<s:property /><br/>
</s:iterator>
</s:generator>자세한 예 확인
Struts 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태그는 JavaBeans 사양을 준수하는 클래스를 인스턴스화합니다. 이 태그에는 해당 클래스에 뮤 테이터 메소드를 설정하기 위해 여러 Param 요소를 포함 할 수있는 본문이 있습니다. var 속성이 BeanTag에 설정되면 인스턴스화 된 빈을 스택의 Context에 배치합니다.
<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 / yyyy hh : mm")을 지정하거나, 읽기 쉬운 표기법 (예 : "2 시간, 14 분 후")을 생성하거나 다음을 사용하여 미리 정의 된 형식으로 대체 할 수 있습니다. 속성 파일의 'struts.date.format'키.
<s:date name = "person.birthday" format = "dd/MM/yyyy" />
<s:date name = "person.birthday" format = "%{getText('some.i18n.key')}" />
<s:date name = "person.birthday" nice="true" />
<s:date name = "person.birthday" />자세한 예 확인
Param 태그
이들 param태그는 다른 태그를 매개 변수화하는 데 사용할 수 있습니다. 이 태그에는 다음 두 개의 매개 변수가 있습니다.
name (String) − 매개 변수의 이름
value (Object) − 매개 변수의 값
<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>자세한 예 확인
세트 태그
이들 set태그는 지정된 범위의 변수에 값을 할당합니다. 복잡한 표현식에 변수를 할당 한 다음 복잡한 표현식이 아닌 매번 해당 변수를 참조하려는 경우에 유용합니다. 사용 가능한 범위는 다음과 같습니다.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태그는 Struts UI 태그의 하위 집합입니다. 이러한 태그는 Struts 웹 애플리케이션에 필요한 사용자 인터페이스의 렌더링에 도움이되며 세 가지 범주로 분류 될 수 있습니다. 이 장에서는 세 가지 유형의 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 및 스타일 시트 요소를 생성합니다.
다음으로 s : div 및 s : text 요소가 있습니다. s : div는 HTML Div 요소를 렌더링하는 데 사용됩니다. 이것은 HTML과 Struts 태그를 함께 섞는 것을 좋아하지 않는 사람들에게 유용합니다. 이러한 사람들에게는 s : div를 사용하여 div를 렌더링 할 수 있습니다.
s : text는 화면에 텍스트를 렌더링하는 데 사용됩니다.
다음으로 famiilar s : form 태그가 있습니다. s : form 태그에는 양식을 제출할 위치를 결정하는 작업 속성이 있습니다. 양식에 파일 업로드 요소가 있으므로 enctype을 multipart로 설정해야합니다. 그렇지 않으면 비워 둘 수 있습니다.
양식 태그 끝에 s : submit 태그가 있습니다. 이것은 양식을 제출하는 데 사용됩니다. 양식이 제출되면 모든 양식 값이 s : form 태그에 지정된 조치에 제출됩니다.
s : form 내부에는 secret이라는 숨겨진 속성이 있습니다. 이것은 HTML에서 숨겨진 요소를 렌더링합니다. 우리의 경우 "secret"요소는 "abracadabra"값을 갖습니다. 이 요소는 최종 사용자에게 표시되지 않으며 한보기에서 다른보기로 상태를 전달하는 데 사용됩니다.
다음으로 s : label, s : textfield, s : password 및 s : textarea 태그가 있습니다. 라벨, 입력 필드, 암호 및 텍스트 영역을 각각 렌더링하는 데 사용됩니다. "Struts-Sending Email"예제에서 이러한 기능이 작동하는 것을 확인했습니다.
여기서 주목해야 할 중요한 것은 "key"속성의 사용입니다. "key"속성은 속성 파일에서 이러한 컨트롤의 레이블을 가져 오는 데 사용됩니다. 우리는 이미 Struts2 지역화, 국제화 장에서이 기능을 다루었습니다.
그런 다음 입력 파일 업로드 구성 요소를 렌더링하는 s : file 태그가 있습니다. 이 구성 요소를 사용하면 사용자가 파일을 업로드 할 수 있습니다. 이 예에서는 s : file 태그의 "accept"매개 변수를 사용하여 업로드 할 수있는 파일 유형을 지정했습니다.
마지막으로 s : token 태그가 있습니다. 토큰 태그는 양식이 이중 제출되었는지 확인하는 데 사용되는 고유 토큰을 생성합니다.
양식이 렌더링되면 숨겨진 변수가 토큰 값으로 배치됩니다. 예를 들어 토큰이 "ABC"라고 가정 해 보겠습니다. 이 양식이 제출되면 Struts Fitler는 세션에 저장된 토큰에 대해 토큰을 확인합니다. 일치하면 세션에서 토큰을 제거합니다. 이제 양식이 실수로 다시 제출 된 경우 (새로 고침하거나 브라우저 뒤로 버튼을 눌러서) 양식이 "ABC"토큰으로 다시 제출됩니다. 이 경우 필터는 세션에 저장된 토큰에 대해 토큰을 다시 확인합니다. 그러나 "ABC"토큰이 세션에서 제거 되었기 때문에 일치하지 않으며 Struts 필터가 요청을 거부합니다.
그룹 UI 태그
그룹 UI 태그는 라디오 버튼과 확인란을 만드는 데 사용됩니다. 간단한보기 페이지를 보자HelloWorld.jsp 체크 박스와 라디오 버튼 태그 포함-
<%@ page contentType = "text/html; charset = UTF-8"%>
<%@ taglib prefix = "s" uri = "/struts-tags"%>
<html>
<head>
<title>Hello World</title>
<s:head />
</head>
<body>
<s:form action = "hello.action">
<s:radio label = "Gender" name = "gender" list="{'male','female'}" />
<s:checkboxlist label = "Hobbies" name = "hobbies"
list = "{'sports','tv','shopping'}" />
</s:form>
</body>
</html>위의 프로그램을 실행하면 출력은 다음과 유사합니다.
이제 예를 살펴 보겠습니다. 첫 번째 예에서는 레이블이 "성별"인 간단한 라디오 버튼을 만듭니다. 이름 속성은 라디오 버튼 태그에 필수이므로 "gender"라는 이름을 지정합니다. 그런 다음 성별에 대한 목록을 제공합니다. 목록은 "male"및 "female"값으로 채워집니다. 따라서 출력에는 두 개의 값이있는 라디오 버튼이 있습니다.
두 번째 예에서는 체크 박스 목록을 생성합니다. 사용자의 취미를 모으기위한 것입니다. 사용자는 하나 이상의 취미를 가질 수 있으므로 라디오 버튼 대신 확인란을 사용합니다. 확인란은 "스포츠", "TV"및 "쇼핑"목록으로 채워집니다. 취미를 체크 박스 목록으로 표시합니다.
UI 태그 선택
Struts에서 제공하는 Select Tag의 다양한 변형을 살펴 보겠습니다. 간단한보기 페이지를 보자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>위의 프로그램을 실행하면 출력은 다음과 유사합니다.
이제 개별 사례를 하나씩 살펴 보겠습니다.
먼저 선택 태그는 HTML 선택 상자를 렌더링합니다. 첫 번째 예에서는 이름이 "username"이고 레이블이 "username"인 간단한 선택 상자를 만듭니다. 선택 상자는 Mike, John 및 Smith라는 이름이 포함 된 목록으로 채워집니다.
두 번째 예에서 우리 회사는 미국에 본사를두고 있습니다. 또한 아시아와 유럽에 글로벌 지사를두고 있습니다. 선택 상자에 사무실을 표시하고 싶지만 대륙 이름으로 글로벌 사무실을 그룹화하려고합니다. 이것이 optgroup이 유용한 곳입니다. s : optgroup 태그를 사용하여 새 그룹을 만듭니다. 그룹에 레이블과 별도의 목록을 제공합니다.
세 번째 예에서는 콤보 상자가 사용됩니다. 콤보 상자는 입력 필드와 선택 상자의 조합입니다. 사용자는 선택 상자에서 값을 선택할 수 있습니다.이 경우 입력 필드는 사용자가 선택한 값으로 자동으로 채워집니다. 사용자가 값을 직접 입력해야하는 경우 선택 상자의 값이 선택되지 않습니다.
이 예에서는 태양 기호를 나열하는 콤보 상자가 있습니다. 선택 상자에는 사용자가 목록에없는 경우 태양 기호를 입력 할 수있는 4 개의 항목 만 나열됩니다. 선택 상자에 헤더 항목도 추가합니다. 헤더 항목은 선택 상자의 맨 위에 표시되는 항목입니다. 이 경우 "선택하십시오"를 표시하려고합니다. 사용자가 아무것도 선택하지 않으면 -1을 값으로 가정합니다. 어떤 경우에는 사용자가 빈 값을 선택하는 것을 원하지 않습니다. 이러한 조건에서 "emptyOption"속성을 false로 설정합니다. 마지막으로,이 예에서는 콤보 박스의 기본값으로 "염소 자리"를 제공합니다.
네 번째 예에서는 이중 선택이 있습니다. 두 개의 선택 상자를 표시하려는 경우 이중 선택이 사용됩니다. 첫 번째 선택 상자에서 선택한 값에 따라 두 번째 선택 상자에 표시되는 내용이 결정됩니다. 이 예에서 첫 번째 선택 상자에는 "Technical"및 "Other"가 표시됩니다. 사용자가 기술을 선택하면 두 번째 선택 상자에 IT 및 하드웨어가 표시됩니다. 그렇지 않으면 회계 및 HR이 표시됩니다. 이는 예제에 표시된대로 "list"및 "doubleList"속성을 사용하여 가능합니다.
위의 예에서 우리는 상단 선택 상자가 Technical과 같은지 비교했습니다. 그렇다면 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>위의 예를 실행하면 다음과 같은 결과가 나옵니다.
이제이 예를 한 번에 한 단계 씩 살펴 보겠습니다.
가장 먼저 주목해야 할 것은 접두사 sx가있는 새 태그 라이브러리가 추가 된 것입니다. 이것은 (struts-dojo-tags) 특별히 ajax 통합을 위해 만들어진 태그 라이브러리입니다.
그런 다음 HTML 헤드 내부에서 sx : head라고합니다. 이렇게하면 dojo 프레임 워크가 초기화되고 페이지 내의 모든 AJAX 호출이 준비됩니다. 이 단계는 중요합니다. ajax 호출은 sx : head가 초기화되지 않으면 작동하지 않습니다.
먼저 autocompleter 태그가 있습니다. 자동 완성기 태그는 선택 상자와 매우 유사합니다. 빨간색, 녹색 및 파란색 값으로 채워집니다. 그러나 선택 상자와이 상자의 차이점은 자동 완성된다는 것입니다. 즉, gr을 입력하기 시작하면 "green"으로 채워집니다. 그 외에이 태그는 이전에 다룬 s : select 태그와 매우 유사합니다.
다음으로 날짜 시간 선택기가 있습니다. 이 태그는 옆에 버튼이있는 입력 필드를 만듭니다. 버튼을 누르면 팝업 날짜 시간 선택기가 표시됩니다. 사용자가 날짜를 선택하면 태그 속성에 지정된 형식으로 입력 텍스트에 날짜가 채워집니다. 이 예에서는 날짜 형식으로 dd / MM / yyyy를 지정했습니다.
다음으로 이전 연습에서 만든 system.action 파일에 대한 url 태그를 만듭니다. system.action 일 필요는 없습니다. 이전에 만든 모든 작업 파일 일 수 있습니다. 그런 다음 하이퍼 링크가 URL로 설정되고 지연이 2 초로 설정된 div가 있습니다. 이것을 실행하면 "초기 콘텐츠"가 2 초 동안 표시되고 div의 콘텐츠가hello.action 실행.
마지막으로 두 개의 탭이있는 간단한 탭 패널이 있습니다. 탭은 Tab 1 및 Tab2 레이블이있는 div 셀입니다.
Struts의 AJAX 태그 통합은 아직 진행 중이며이 통합의 성숙도는 모든 릴리스에서 천천히 증가하고 있다는 점에 주목할 가치가 있습니다.
Spring은 많은 일반적인 웹 작업과 쉽게 통합 할 수있는 인기있는 웹 프레임 워크입니다. 그래서 질문은 Struts2가 있는데 왜 Spring이 필요한가요? 음, Spring은 MVC 프레임 워크 이상입니다. Struts에서 사용할 수없는 다른 많은 장점을 제공합니다.
예 : 모든 프레임 워크에 유용 할 수있는 종속성 주입. 이 장에서는 Spring과 Struts2를 함께 통합하는 방법을보기 위해 간단한 예제를 살펴 보겠습니다.
먼저 Spring 설치에서 프로젝트의 빌드 경로에 다음 파일을 추가해야합니다. 최신 버전의 Spring Framework를 다운로드하여 설치할 수 있습니다.https://www.springsource.org/download
- org.springframework.asm-x.y.z.M(a).jar
- org.springframework.beans-x.y.z.M(a).jar
- org.springframework.context-x.y.z.M(a).jar
- org.springframework.core-x.y.z.M(a).jar
- org.springframework.expression-x.y.z.M(a).jar
- org.springframework.web-x.y.z.M(a).jar
- org.springframework.web.servlet-x.y.z.M(a).jar
마지막으로 추가 struts2-spring-plugin-x.y.z.jar 당신의 WEB-INF/libstruts lib 디렉토리에서. Eclipse를 사용하는 경우 예외 java.lang.ClassNotFoundException : org.springframework.web.context.ContextLoaderListener에 직면 할 수 있습니다 .
이 문제를 해결하려면 Marker탭을 클릭하고 클래스 종속성을 하나씩 마우스 오른쪽 버튼으로 클릭하고 모든 종속성을 게시 / 내보내기 위해 빠른 수정을 수행합니다. 마지막으로 마커 탭에서 사용 가능한 종속성 충돌이 없는지 확인하십시오.
이제 설정하겠습니다. 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>여기서 주목해야 할 중요한 것은 우리가 구성한 리스너입니다. 그만큼ContextLoaderListener스프링 컨텍스트 파일을로드하는 데 필요합니다. Spring의 구성 파일이 호출됩니다.applicationContext.xml 파일과 동일한 수준에 배치되어야합니다. web.xml 파일
다음과 같은 간단한 액션 클래스를 생성하겠습니다. User.java 두 가지 속성-firstName 및 lastName이 있습니다.
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 스프링 구성 파일을 생성하고 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>위에서 볼 수 있듯이 사용자 빈을 구성하고 값을 주입했습니다. Michael 과 Jackson콩에. 또한이 빈에 "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파일은 매우 간단합니다. 사용자 개체의 이름과 성 값을 표시하는 한 가지 용도로만 사용됩니다. 마지막으로,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 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오.http://localhost:8080/HelloWorldStruts2/User.jsp. 그러면 다음 화면이 생성됩니다.
이제 우리는 두 개의 훌륭한 프레임 워크를 하나로 모으는 방법을 보았습니다. 이것으로 Struts-Spring 통합 장을 마칩니다.
이 장에서는 Tiles 프레임 워크를 Struts2와 통합하는 단계를 살펴 보겠습니다. Apache Tiles는 웹 애플리케이션 사용자 인터페이스의 개발을 단순화하기 위해 구축 된 템플릿 프레임 워크입니다.
먼저 Apache Tiles 웹 사이트 에서 tiles 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
위의 것 외에도 struts2 다운로드에서 다음 jar 파일을 복사해야합니다. WEB-INF/lib.
- commons-beanutils-x.y.zjar
- commons-digester-x.y.jar
- struts2-tiles-plugin-x.y.z.jar
이제 설정하겠습니다. web.xmlStruts-Tiles 통합을 위해 아래와 같이 제공됩니다. 여기서 주목해야 할 두 가지 중요한 사항이 있습니다. 먼저 타일 구성 파일을 찾을 위치를 타일에 알려야합니다.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에 대한 기본값을 제공 한 다음 기본 레이아웃에서 확장되는 두 가지 사용자 지정을 만듭니다. 타이거 레이아웃은 기본 레이아웃과 비슷하지만tiger.jsp본문과 제목으로 "Tiger"라는 텍스트가 있습니다. 마찬가지로, 사자 레이아웃은 기본 레이아웃과 비슷하지만lion.jsp 본문과 제목으로 "Lion"이라는 텍스트가 있습니다.
개별 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.action struts 작업에 대한 링크 인 다음 행이 있습니다.
<%@taglib uri = "/struts-tags" prefix = "s"%>
<a href = "<s:url action = "tigerMenu"/>" Tiger</a><br>
<a href = "<s:url action = "lionMenu"/>" Lion</a><br>그만큼 lion.jsp 파일 내용은 다음과 같습니다-
<img src="http://upload.wikimedia.org/wikipedia/commons/d/d2/Lion.jpg"/>
The lion그만큼 tiger.jsp 파일 내용은 다음과 같습니다-
<img src="http://www.freewebs.com/tigerofdarts/tiger.jpg"/>
The tiger다음으로 액션 클래스 파일을 생성하겠습니다. MenuAction.java 다음을 포함하는-
package com.tutorialspoint.struts2;
import com.opensymphony.xwork2.ActionSupport;
public class MenuAction extends ActionSupport {
public String tiger() { return "tiger"; }
public String lion() { return "lion"; }
}이것은 매우 간단한 수업입니다. 우리는 각각 tiger와 lion을 결과로 반환하는 두 개의 메소드 tiger ()와 lion ()을 선언했습니다. 우리 모두를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는 Tiles View 결과 유형을 지원하므로 "org.apache.struts2.view.tiles.TilesResult"클래스가 될 결과 유형 "tiles"를 생성합니다.
다음으로, 요청이 /tigerMenu.action에 대한 것인지 사용자를 타이거 타일 페이지로 이동하고 /lionMenu.action에 대한 요청 인 경우 사용자를 라이온 타일 페이지로 이동한다고 말하고 싶습니다.
우리는 약간의 정규식을 사용하여 이것을 달성합니다. 액션 정의에서 "* Menu"패턴과 일치하는 모든 것이이 액션에 의해 처리된다고 말합니다. 일치하는 메서드는 MenuAction 클래스에서 호출됩니다. 즉, tigerMenu.action은 tiger ()를 호출하고 lionMenu.action은 lion ()을 호출합니다. 그런 다음 결과 결과를 적절한 타일 페이지에 매핑해야합니다.
이제 프로젝트 이름을 마우스 오른쪽 버튼으로 클릭하고 Export > WAR FileWar 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오.http://localhost:8080/HelloWorldStruts2/tigerMenu.jsp. 그러면 다음 화면이 생성됩니다.
마찬가지로 lionMenu.action 페이지로 이동하면 동일한 타일 레이아웃을 사용하는 라이온 페이지가 표시됩니다.
Hibernate는 오픈 소스 GNU Lesser General Public License (LGPL)에 따라 라이센스가 부여되고 무료로 다운로드 할 수있는 고성능 객체 / 관계형 지속성 및 쿼리 서비스입니다. 이 챕터에서는. 우리는 Hibernate와 Struts 2 통합을 달성하는 방법을 배울 것입니다. 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>최대 절전 설정 파일을 살펴 보겠습니다. 먼저 MySQL 드라이버를 사용하고 있다고 선언했습니다. 그런 다음 데이터베이스에 연결하기위한 jdbc URL을 선언했습니다. 그런 다음 연결의 사용자 이름, 암호 및 풀 크기를 선언했습니다. 또한 "show_sql"을 true로 설정하여 로그 파일에서 SQL을보고 싶다고 표시했습니다. 이러한 속성의 의미를 이해하려면 최대 절전 모드 자습서를 참조하십시오.
마지막으로이 장에서 생성 할 매핑 클래스를 com.tutorialspoint.hibernate.Student로 설정합니다.
환경 설정
다음으로이 프로젝트에는 많은 항아리가 필요합니다. 첨부는 필요한 JAR 파일의 전체 목록의 스크린 샷입니다.
대부분의 JAR 파일은 struts 배포의 일부로 얻을 수 있습니다. glassfish, websphere 또는 jboss와 같은 응용 프로그램 서버가 설치되어있는 경우 응용 프로그램 서버의 lib 폴더에서 나머지 jar 파일 대부분을 가져올 수 있습니다. 그렇지 않은 경우 파일을 개별적으로 다운로드 할 수 있습니다.
Hibernate jar 파일 -Hibernate.org
Struts Hibernate 플러그인 − Struts Hibernate 플러그인
JTA 파일 -JTA 파일
Dom4j 파일 -Dom4j
log4j 파일 -log4j
나머지 파일은 Struts2 배포판에서 가져올 수 있습니다.
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 ()의 두 가지 작업 메서드가 있습니다. execute () 메서드는 새 학생 레코드를 추가하는 데 사용됩니다. 이를 위해 dao의 save () 메소드를 사용합니다.
다른 방법 인 listStudents ()는 학생을 나열하는 데 사용됩니다. 우리는 dao의 목록 방법을 사용하여 모든 학생의 목록을 가져옵니다.
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.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 및 마크에 대한 값이 자동으로 채워지는 학생 빈이 자동으로 생성됩니다.
하단 섹션에서는 학생 목록을 살펴 봅니다 (AddStudentAction.java 참조). 목록을 반복하고 이름, 성 및 마크 값을 테이블에 표시합니다.
Struts 구성
모두 함께 사용하여 struts.xml −
<?xml version = "1.0" Encoding = "UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name = "struts.devMode" value = "true" />
<package name = "myhibernate" extends = "hibernate-default">
<action name = "addStudent" method = "execute"
class = "com.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의 두 가지 작업을 선언합니다. addStudent는 AddStudentAction 클래스에서 execute ()를 호출하고 성공하면 listStudents 작업 메서드를 호출합니다.
listStudent 작업 메서드는 AddStudentAction 클래스에서 listStudents ()를 호출하고 student.jsp를보기로 사용합니다.
이제 프로젝트 이름을 마우스 오른쪽 버튼으로 클릭하고 Export > WAR FileWar 파일을 만듭니다. 그런 다음 Tomcat의 webapps 디렉토리에이 WAR을 배포합니다. 마지막으로 Tomcat 서버를 시작하고 URL에 액세스하십시오.http://localhost:8080/HelloWorldStruts2/student.jsp. 그러면 다음 화면이 생성됩니다.
상단 섹션에는 새 학생 기록에 대한 값을 입력하는 양식이 있고 하단 섹션에는 데이터베이스의 학생이 나열됩니다. 계속해서 새 학생 기록을 추가하고 제출을 누르십시오. 제출을 클릭 할 때마다 화면이 새로 고쳐지고 업데이트 된 목록이 표시됩니다.