What is Struts2 in Java with Examples | Struts Architecture Tutorial

Struts2 is an open-source web application framework for developing Java-based enterprise applications. It is a popular choice among developers for building scalable, maintainable, and robust web applications. Here’s an explanation of various aspects of Struts2:

MVC Architecture:

Struts2 follows the Model-View-Controller (MVC) architectural pattern, which separates the application into three key components:

Model: Represents the application’s data and business logic.
View: Handles the presentation layer, typically responsible for rendering HTML templates or other types of views.
Controller: Manages the flow of the application, handling user requests, and coordinating interactions between the model and view.

Key Features:

Actions: Actions in Struts2 are Java classes that process user requests and perform business logic. They are typically associated with URL patterns and handle data processing, validation, and interaction with the model.
Interceptors: Interceptors provide a mechanism to add cross-cutting concerns to actions, such as authentication, logging, or input validation. They intercept the request processing flow and can perform actions before and after the execution of an action.
Result Types: Struts2 supports various result types for handling the response generated by actions. This includes rendering JSP pages, generating XML or JSON responses, or even redirecting to other URLs.
Tags and UI Components: Struts2 provides a set of UI tags and components that simplify the development of web forms, input validation, and handling user input.

Configuration:

Struts2 applications are configured using XML files or annotations. The configuration files define the mapping between URLs, actions, and result types.
The configuration also defines how data is passed between the client and server, typically using form parameters or request parameters.

Validation:

Struts2 includes a powerful validation framework that allows developers to define validation rules for form inputs.
Validation rules can be applied both on the client-side (using JavaScript) and on the server-side (using Java validation annotations or XML configuration).
The validation framework provides built-in validators for common data types, as well as the ability to create custom validators.

Integration and Extensibility:

Struts2 can be easily integrated with other Java frameworks and libraries, such as Hibernate for database persistence or Spring for dependency injection and transaction management.
It is highly extensible, allowing developers to create custom interceptors, result types, or tags to meet specific application requirements.

Examples of Struts2:

Here’s a simple example of a Struts2 application that demonstrates the basic concepts:

Create a Maven project and add the necessary dependencies for Struts2 in the pom.xml file:


<dependencies>
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-core</artifactId>
        <version>2.5.26</version>
    </dependency>
</dependencies>

Create a Struts2 configuration file named struts.xml in the src/main/resources directory:

<!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">
        <action name="hello" class="com.example.actions.HelloAction" method="execute">
            <result name="success">/hello.jsp</result>
        </action>
    </package>
</struts>

Create a Java class named HelloAction in the com.example.actions package:

package com.example.actions;

public class HelloAction {
    private String message;

    public String execute() {
        message = "Hello, Struts2!";
        return "success";
    }

    public String getMessage() {
        return message;
    }
}

Create a JSP file named hello.jsp in the src/main/webapp directory:

<!DOCTYPE html>
<html>
<head>
    <title>Hello Struts2</title>
</head>
<body>
    <h1>${message}</h1>
</body>
</html>

Set up a web server (e.g., Apache Tomcat) and deploy the application.
Access the application by navigating to http://localhost:8080/your-app-name/hello.action in a web browser.

When you access the URL, the following happens:

The request is mapped to the HelloAction class and the execute() method is called.
The execute() method sets the message property to “Hello, Struts2!”.
The success result is returned, and the hello.jsp view is rendered.
The ${message} expression in the JSP file is replaced with the value of the message property.

As a result, you will see the text “Hello, Struts2!” displayed on the web page. This example demonstrates the basic flow of handling requests, executing actions, and rendering views in a Struts2 application.

Overall, Struts2 provides a robust foundation for building enterprise web applications by following the MVC pattern, offering features like actions, interceptors, result types, and validation. Its extensibility and integration capabilities make it a popular choice for Java developers looking to create scalable and maintainable applications.

BihariGraphic