Struts Tutorial «Prev  Next»


Configuring Apache Struts 7.0.3

Apache Struts 7.0.3 is a modern, open-source MVC framework for building enterprise-grade Java web applications. It emphasizes convention over configuration, supports Jakarta EE, and requires Java 17 or higher. Configuring a Struts 7.0.3 application involves setting up the web.xml deployment descriptor and the Struts configuration file, typically named struts.xml. Below, we outline the steps to configure these files correctly, followed by an explanation of how Struts integrates with the Spring Framework.

Configuring web.xml

The web.xml file, located in the /WEB-INF directory, is the standard deployment descriptor for Java web applications. For Struts 7.0.3, you need to configure the Struts filter to handle incoming requests, replacing the older ActionServlet used in Struts 1. The following example shows how to set up the Struts FilterDispatcher to process requests with a .action URL pattern.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
         version="6.0">

    <!-- Struts Filter Configuration -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>*.action</url-pattern>
    </filter-mapping>

</web-app>
    

This configuration uses the StrutsPrepareAndExecuteFilter, which is the standard controller for Struts 2 and later, including Struts 7.0.3. It intercepts requests ending in .action and routes them to the appropriate Struts actions. Unlike Struts 1, Struts 7.0.3 does not rely on servlet-based controllers, making it more flexible and aligned with modern Jakarta EE standards.


Configuring struts.xml

The struts.xml file, typically placed in the /WEB-INF directory or the classpath (e.g., src/main/resources), defines the Struts application's configuration, including action mappings, results, and interceptors. Below is a basic example of a struts.xml file for Struts 7.0.3.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <package name="default" namespace="/" extends="struts-default">
        <action name="hello" class="com.example.actions.HelloAction" method="execute">
            <result name="success">/WEB-INF/views/hello.jsp</result>
        </action>
    </package>
</struts>
    

In this example:

This configuration is minimal but extensible. Struts 7.0.3 supports annotations as an alternative to XML, allowing developers to define actions directly in Java classes for simpler setups. For example:

@Namespace("/")
@Action(value = "hello", results = {
    @Result(name = "success", location = "/WEB-INF/views/hello.jsp")
})
public class HelloAction {
    public String execute() {
        return "success";
    }
}
    


Integration with Spring Framework

Apache Struts 7.0.3 integrates seamlessly with the Spring Framework, a popular choice for building modern Java applications due to its robust dependency injection (DI) and aspect-oriented programming (AOP) capabilities. Spring complements Struts by managing the lifecycle of Struts action classes and providing additional features like transaction management and data access.

Using the Struts-Spring Plugin

To integrate Struts 7.0.3 with Spring, you can use the struts2-spring-plugin, which allows Spring to manage Struts action classes as beans. This enables dependency injection into Struts actions, making applications more modular and testable. To set this up:

  1. Add the Struts-Spring Plugin Dependency: If using Maven, include the following in your pom.xml:
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-spring-plugin</artifactId>
        <version>7.0.3</version>
    </dependency>
                
  2. Configure Spring in web.xml: Add a Spring ContextLoaderListener to initialize the Spring application context:
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
                
  3. Define Spring Beans: Create an applicationContext.xml file in /WEB-INF to define beans that Struts actions can use. For example:
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="helloService" class="com.example.services.HelloServiceImpl" />
        <bean id="helloAction" class="com.example.actions.HelloAction" scope="prototype">
            <property name="helloService" ref="helloService" />
        </bean>
    </beans>
                
  4. Inject Dependencies into Struts Actions: In your Struts action class, use Spring-managed dependencies:
    public class HelloAction {
        private HelloService helloService;
    
        public void setHelloService(HelloService helloService) {
            this.helloService = helloService;
        }
    
        public String execute() {
            // Use helloService for business logic
            String message = helloService.getMessage();
            return "success";
        }
    }
                


Benefits of Struts-Spring Integration

Considerations

While Struts 7.0.3 is a modernized framework, Spring (particularly Spring Boot) has become the preferred choice for many new Java web projects due to its lightweight nature and extensive ecosystem. Struts is often used in legacy systems or where its specific MVC model is preferred. For new projects, developers may opt for Spring MVC or Spring Boot alone unless Struts' plugin architecture or action-based workflow is required.

For further details, consult the Apache Struts documentation for Struts 7.0.3 specifics and the Spring Framework documentation for integration details.