Questo è il secondo articolo della serie di Tutorial su Struts 2. Se sei arrivato direttamente qui, ti consiglio di controllare anche il post precedente. Tutorial per principianti su Struts 2 Nel tutorial precedente, abbiamo esaminato l’architettura di Struts 2, i suoi componenti e abbiamo creato una semplice applicazione web Struts 2 con una configurazione basata su XML (struts.xml). In questo tutorial vedremo come evitare completamente il file di configurazione di Struts utilizzando annotazioni o convenzioni di denominazione.
Concetto di Convenzioni di Struts 2
Struts 2 utilizza due metodologie per trovare le classi di azione e le classi di risultato. Dobbiamo utilizzare l’API struts2-convention-plugin per utilizzare una qualsiasi di queste metodologie. Se hai un’applicazione web normale, puoi scaricare il file jar e metterlo nella directory lib dell’applicazione web. Per i progetti Maven, puoi semplicemente aggiungere la dipendenza come mostrato di seguito.
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-convention-plugin</artifactId>
<version>2.3.15.1</version>
</dependency>
-
Scansione: In questo metodo, specifichiamo il pacchetto che deve essere scansionato per le classi di azione. La configurazione deve essere fatta nel file web.xml per il filtro di Struts 2, come mostrato di seguito.
<filter> <filter-name>struts2</filter-name> <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class> <init-param> <param-name>actionPackages</param-name> <param-value>com.journaldev.struts2.actions</param-value> </init-param> </filter>Struts 2 troverà le classi di azione seguendo questi metodi.
- Qualsiasi classe annotata con @Action o @Actions.
- Qualsiasi classe che implementa l’interfaccia Action o estende la classe ActionSupport.
- Qualsiasi classe il cui nome termina con Action e contiene il metodo execute(). Per queste classi, viene utilizzata una convenzione di denominazione per determinare l’azione e i risultati.
-
Convenzione di denominazione: Struts 2 creerà automaticamente un’azione per le classi il cui nome termina con Action. Il nome dell’azione viene determinato rimuovendo il suffisso Action e convertendo la prima lettera in minuscolo. Quindi, se il nome della classe è HomeAction, l’azione sarà “home”. Se queste classi non sono annotate con @Result per fornire il risultato, le pagine di risultato vengono cercate nella directory WEB-INF/content e il nome dovrebbe essere {azione}-{stringa_di_ritorno}.jsp. Quindi, se la classe di azione HomeAction restituisce “success”, la richiesta verrà inoltrata alla pagina WEB-INF/content/home-success.jsp. Utilizzare solo la convenzione di denominazione può essere molto confuso e non possiamo utilizzare la stessa pagina JSP per altre classi di azione. Pertanto, dovremmo cercare di evitarlo e utilizzare una configurazione basata su annotazioni.
Ora siamo pronti per creare la nostra applicazione Hello World di Struts 2 utilizzando le annotazioni e non avremo un file di configurazione di Struts 2. Crea un progetto web dinamico in Eclipse chiamato Struts2AnnotationHelloWorld e convertilo in un progetto Maven. Il progetto finale sarà simile all’immagine qui sotto. 
Configurazione di Maven
Abbiamo aggiunto le dipendenze struts2-core e struts2-convention-plugin nel pom.xml, il codice finale del pom.xml è:
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>Struts2AnnotationHelloWorld</groupId>
<artifactId>Struts2AnnotationHelloWorld</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<dependencies>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>2.3.15.1</version>
</dependency>
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-convention-plugin</artifactId>
<version>2.3.15.1</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>2.3</version>
<configuration>
<warSourceDirectory>WebContent</warSourceDirectory>
<failOnMissingWebXml>false</failOnMissingWebXml>
</configuration>
</plugin>
</plugins>
<finalName>${project.artifactId}</finalName>
</build>
</project>
Configurazione del descrittore di distribuzione
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xmlns="https://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id="WebApp_ID" version="3.0">
<display-name>Struts2AnnotationHelloWorld</display-name>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
<init-param>
<param-name>actionPackages</param-name>
<param-value>com.journaldev.struts2.actions</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
Notare l’elemento init-param in cui forniamo il pacchetto delle classi di azione che verrà scansionato da Struts 2.
Pagine di risultato
Abbiamo tre pagine di risultato nella nostra applicazione.login.jsp
<%@ page language="java" contentType="text/html; charset=US-ASCII"
pageEncoding="US-ASCII"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<%-- Using Struts2 Tags in JSP --%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Login Page</title>
</head>
<body>
<h3>Welcome User, please login below</h3>
<s:form action="login">
<s:textfield name="name" label="User Name"></s:textfield>
<s:textfield name="pwd" label="Password" type="password"></s:textfield>
<s:submit value="Login"></s:submit>
</s:form>
</body>
</html>
error.jsp
<%@ page language="java" contentType="text/html; charset=US-ASCII"
pageEncoding="US-ASCII"%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Error Page</title>
</head>
<body>
<h4>User Name or Password is wrong</h4>
<s:include value="login.jsp"></s:include>
</body>
</html>
welcome.jsp
<%@ page language="java" contentType="text/html; charset=US-ASCII"
pageEncoding="US-ASCII"%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Welcome Page</title>
</head>
<body>
<h3>Welcome <s:property value="name"></s:property></h3>
</body>
</html>
Ora creiamo le nostre classi di azione che annoteremo per configurare le azioni e le pagine di risultato.
Classi di azione con annotazioni
package com.journaldev.struts2.actions;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Actions;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.Namespaces;
import org.apache.struts2.convention.annotation.Result;
import com.opensymphony.xwork2.ActionSupport;
/**
* An empty class for default Action implementation for:
*
* <action name="home">
* <result>/login.jsp</result>
* </action>
* HomeAction class will be automatically mapped for home.action
* Default page is login.jsp which will be served to client
* @author pankaj
*
*/
@Namespaces(value={@Namespace("/User"),@Namespace("/")})
@Result(location="/login.jsp")
@Actions(value={@Action(""),@Action("home")})
public class HomeAction extends ActionSupport {
}
Notare che HomeAction è una classe vuota con lo scopo di inoltrare la richiesta alla pagina login.jsp.
package com.journaldev.struts2.actions;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.Namespaces;
import org.apache.struts2.convention.annotation.Result;
/**
* Notice the @Action annotation where action and result pages are declared
* Also notice that we don't need to implement Action interface or extend ActionSupport
* class, only we need is an execute() method with same signature
* @author pankaj
*
*/
@Action(value = "login", results = {
@Result(name = "SUCCESS", location = "/welcome.jsp"),
@Result(name = "ERROR", location = "/error.jsp") })
@Namespaces(value={@Namespace("/User"),@Namespace("/")})
public class LoginAction {
public String execute() throws Exception {
if("pankaj".equals(getName()) && "admin".equals(getPwd()))
return "SUCCESS";
else return "ERROR";
}
//Java Bean per contenere i parametri del modulo
private String name;
private String pwd;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
Si noti l’uso delle annotazioni @Action, @Actions, @Result, @Namespace e @Namespaces, l’utilizzo è autoesplicativo. Ora, quando eseguiamo la nostra applicazione, otteniamo le seguenti pagine di risposta. 
Se hai letto l’ultimo post in cui abbiamo sviluppato la stessa applicazione con la configurazione struts.xml, noterai che è quasi la stessa. L’unico cambiamento riguarda il modo in cui collegiamo le classi di azione dell’applicazione e le pagine dei risultati.