Free practice test , mock test, driving test, interview questions » struts2

Action classes in Struts

smitha — Mon, 16 Nov 2009 13:05:48 +0000

In this post we will explore the features of Struts 2 action class and its capabilities.

Struts2 Actions are the most important and main part of struts2 Framework. They work as Model of MVC framework. Following article gives you more deep idea about Action classes role, configuration etc.

Action class Role:

1. Acts as Model encapsulates the business Logic: The main responsibility of Action class is to include business logic. The business logic will be encapsulated in execute method of the Action class.
2. The class helps the controller in result routing: The action class returns String, which helps to determine the view to be loaded. Example if struts.xml has following action definition

/page1.jsp
/page2.jsp

If the execute() method (of example.Calulator class) returns String “SUCCESS” then the page1.jsp will be chosen by controller to render and if execute() method returns “ERROR”, then page2.jsp will be chosen.
This behaviour is bit different than Struts 1. Struts 1 action classes used specify the routing information using ActionForward objects. This new approach of struts2 has made struts action classes much simpler and clean.
3. Action class acts as data carrier in Struts 2. This is a different behaviour and major difference from struts 1. Struts 1 Action classes were singleton, where one single instance of action class serves all the requests. The ActionBean carries data.
The struts2 action classes get instantiated per request. The ActionBeans have disappeared. The Action classes itself acts as data carrier. This approach again makes the action classes much cleaner and reusable.

Another major difference is the Action class execute method signature. The exculte method depends upon the servlet API. But the struts 2 action classes are simpler like any other POJO. The unit testing of Action classes have become easier as they dont rely on the HttpRequest and HttpResponse objects.

Next section will describe how the Action classes and be configured and their packaging.

Struts 2 – Hands on Tutorial

smitha — Sun, 15 Nov 2009 15:33:31 +0000

Struts 2 Practical Tutorial:

Following tutorial demonstrates you a simple struts2 application and explains you how things work together in struts2. The tutorial demonstrates sruts2 using a calculator application which calculates different operation results and displays them.

The tutorial uses Eclipse3 IDE - or above.

Step 1: Download struts2

Download struts2-blank-xxx.war from : http://struts.apache.org/download.cgi

Step 2: create a project in eclipse

Create a new Web project in eclipse. (To create webProject click File Menu on top–> select New –> Select Web Project ).
Once you create the application will have src folder and a WebRoot folder.

Step 3: copy jars
Copy jars from downloaded struts 2-blank/EB-INF/lib to WebRoot/WEB-INF/lib directory. You can see the copied jars in the references jars once you refresh the project after copying.

Step 4: web.xml setup

Struts2 is based on MVC (Model – View – Controller) architecture. All requests must go through a central controller. This controller decides what action should be taken and then generates the view and sends back to the client. The controller in struts 2 is filter called ‘FilterDispatcher’ . The Controller reads struts.xml file to map a url request to an Action. We will discuss the struts.xml later.

To make all the calls go through he controller, we have to configure it in web application’s deployment descriptor. i.e web.xml file.
We need to configure this in the web.xml as below:

http://java.sun.com/xml/ns/j2ee” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd“>

Test

struts2
org.apache.struts2.dispatcher.FilterDispatcher

struts2
/*

index.html

This FilterDispatcher acts as controller here. All the requests to any url of this application get redirected to this filter.

Now we have setup struts 2 framework. We now start developing calculator components.

Step 5: The Action Class

Action class has execute() method, where the action for the request takes place. This method gets called when there is any request came for this action. All the request data gets copied to the action class using getter methods before calling execute method. In the example, we have param1 and param2 parameters, which will be copied to the action class using the setter methods exposed. In action class’s execute method, one can concentrate on business logic leaving beind codes like retrieving request parameters, validation etc.
Once the business logic is done the Action classes execute method returns a String. This String is used by controller to determine which view to be displayed. The view will be picked up. The data needed by the view (jsp page) will be retrieved from the action class using setter methods
The action class is a simple bean, which calculates the results of the input values. Create a package example and create a class Calculator with following contents:

package example;

public class Calculator {
private int param1;
private int param2;
private int result1;
private int result2;
private int result3;
private int result4;

public String execute() {
if(param1>0 && param2 >0){
result1 = param1 + param2;

if(param2> param1)
result2 = param2 – param1;
else
result2 = param1 – param2;

result3 = param1 * param2;

result4 = param1 / param2;
}
return “result”;
}

public int getParam1() {return param1; }
public void setParam1(int param1) { this.param1 = param1;}
public int getParam2() {return param2; }
public void setParam2(int param2) { this.param2 = param2; }
public int getResult1() { return result1; }
public void setResult1(int result1) {this.result1 = result1; }
public int getResult2() { return result2; }
public void setResult2(int result2) {this.result2 = result2; }
public int getResult3() { return result3; }
public void setResult3(int result3) {this.result3 = result3; }
public int getResult4() {return result4; }
public void setResult4(int result4) { this.result4 = result4; }
}

Step 7: The view

The Jsp files:
Create a file called Calculator.jsp and copy following contents:

<%@ page contentType=”text/html; charset=UTF-8″ %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>

Name Collector

Enter 2 Numbers

Sum =

Diffence =

param 1 X param 2 =

param 1 / param 2 =

The view fetches result1, result2, result3 and result4 properties from the action class targeted using the url. . In View we can access and set Action data using an expression language called OGNL.

When submit button is clicked, the Calculate.action will be called.( )

Step 6: The struts.xml file

This is the main configuration file where we define which url request should be mapped to what Action. Controller uses this file to determine the Action and the resulting view to be displayed.
Create a file named struts.xml in src folder and copy following contents.

“-//Apache Software Foundation//DTD Struts Configuration 2.0//EN”
“http://struts.apache.org/dtds/struts-2.0.dtd“>

/Calculator.jsp

/Calculator.jsp

With above setup, any request to http://server-name:port/application_name/Calculator.action
Will load the Calculator.jsp file with empty values.
Any request to Calculate.action will call execute() method onresult”>)

Now access http://localhost/test/Calculator.action, You can enter 2 numbers and get results.

Struts 2 New Features

smitha — Thu, 29 Oct 2009 18:11:44 +0000

Recently for a training I started learning struts2. As I had worked on struts one few years back I started comparing both struts-2 and 1. I found struts2 very easier than struts1.

Though struts 1 was very popular, comparing it with the newer frameworks, which has come into market in last 2 years, struts 1 has some problems.

ActionForms / Action classes etc – one action needed lots of coding and they were a pain
Also the action class unit testing was difficult.
Type conversions were not automatic.
There was no special feature for AJAX in the framework.. etc

Strut 2 has come up with new features to overcome all above problems. The strut 2.0 is an integration of Struts 1.0 with Webwork. The basic changes in struts 2 are struts 2 Action classes and interceptors. In struts 2 a filter named ‘FilterDispatcher’ acts as controller to dispatch the request to separate action class instance. There is no more ActionForms in Struts 2. The view will directly pull data from action class (as it happens in JSF). Beans can be used inside Action class as properties.

The Struts 2 framework doesn’t impose any much ways of formal requirements on the actions classes. Any class can be an action if it wants. It simply must provide an entry method for the framework to invoke when the action is executed. Struts 2 actions don’t have to implement the Action interface. Any POJO object with a execute signature can be used as a Struts 2 Action object.

The struts 2 actions do three things. First is encapsulating the actual work to be done for a given request. The second major role is to serve as a data carrier in the framework’s automatic transfer of data from the request to the view. Finally, the action must assist the framework in determining which result should render the view that’ll be returned in the request response.

These make ActionForms to disappear from Struts 2. The Data will be pulled from the Action classes directly making the process simpler.

Another new feature in Struts 2 is introduction of interceptors. Interceptors are Struts 2 components that execute both before and after the rest of the request processing. They provide an architectural component in which to define various workflow and cross-cutting tasks so that they can be easily reused as well as separated from other architectural concerns.

Logging is a good example. Logging should be done with the invocation of every action, but it probably shouldn’t be put in the action itself. Because it’s not part of the action’s own unit of work. It’s more administrative, overhead if you will. Struts 2 uses interceptors to both separate and reuse these cross-cutting concerns.

Another difference in struts 1 and struts-2 is the threading model. Struts one Action classes were singletons (one instance of Action class serving all the requests for that action). This requires extra care in some cases. Where as in Struts-2 the action classes are instantiated per request. Each request will be served by different thread.

The Struts 2 action classes do not depend upon the servlet API (The execute method of the struts 1 needs HttpServletRequest and Response objects as parameter.). Hence they can be easily tested by instantiating them.

Few other new features of Struts 2 are

Its expression language. It can still use JSTL but It also introduces a powerful expression language OGNL (Object Graph Notation Language).
Type conversion in Struts 1 was always a pain. But Struts2 using OGNL expression langage can automatically convert basic object types and primitives.
Also Struts 2 has introduced AJAX theme to make the webapplication more dynamic.
It also support configuration of action classes using annotations. Also it provides easy integration with Spring and Hibernate.

All these new feature make struts 2 more attractive. One draw back of struts 2 is, as its bit new, the community using struts 2 is small. But the powerful features make development in struts 2 much easier.