Struts 2 – Spring integration

An introduction and web application example

Recently, There has been a lot of noise about Dependency Injection and Inversion of Control based frameworks, most of this due to this article of Uncle Bob.
I consider article of Martin Fowler about above-mentioned pattern somewhat like a “manifest” of Inversion Control\Dependency Injection, so I invite you to accurately read it.
But now, what about real, pragmatic, occupational impact of this technology on a Java developer?
What I can see is a broad diffusion of Spring framework, that is a great tool in my opinion, but a giant apart universe, too. Spring gives to team of developers the ability to decoupling entire project in separate parts, each one independent from each other and several sub-teams can work singly, without or with very poor knowledge about work of collegues on other parts.

Typically, each team work on a single level of a classic three-tiers architecture:

  • Presentation layer
  • Business Logic layer
  • Physical layer
But this rule is not written anywhere. Spring framework gives great support on integration and decoupling of project shares, but it has a price!
Gigantic overall configuration work (expecially if you integrate more frameworks\technologies), giant and multiple xml\properties files writing..well, in my humble opinion.. it seems a pachyderm to manage. Furthermore, code injected via xml is often difficult to debug. I am very sceptical that it is the panacea of all ills, the jolly to be used in every circumstance.
However, Spring helps very much in some cases, I never dream for a moment to criticize this wonderful product and the amazing work performed by community of developers.
My questions are: It is really helpful to you? Do you really save time and resources using that? How big your project is to justify that configuration and xml-read working?
For most project I worked on, Spring would involve to many resource and time to be spent and my response to above questions is No for all three  cases, BUT I am a very curious person and I like challenges; further more it is so required on market, that, sooner or later, I will massively use in professional environment. As they say on official documentation preface: Spring is modular, allowing you to use only those parts that you need”. Moreover I am very bewitched from Spring’s Transaction Manager, that I think, in general, is a survival module for every web application project.

Anyway, this is not an article on Spring, neither on Dependency Injection. I am going to show how to integrate two useful frameworks: Struts 2 and Spring.
I assume that the reader knows both technologies, one is a MVC Framework (most used for web development), the other is a “lightweight solution” to develop java enterprise applications.
Googling I found several workarounds and some of that they works only with specific version of above frameworks.
I tried out almost all the most published solutions to take this task and I found this one, that I’m going to explain in this article, the more efficient and easy to implement.
I know, a service locator can be used for this purpose instead of dependency injection or, better, we can do all the work within Spring framework, using Web Flow, but I think Struts 2 is a great tool for developing presentation tier of web applications and I prefer to use it over Web Flow.
Let’s go into practical side!

Wait wait!! ..marginal note: I switched to MyEclipse IDE since two months, I never loved Eclipse as IDE, too many configuration settings, not intuitive user interaction, very mnemonic use required, everywhere you click-right, a big menu will be open.. But MyEclipse rocks! Explosed deployment and plugins (dependency) management are features useful enough to motivate my emphasis on this tool.

Steps to be followed to configure your project for Spring and Struts2 support are simple in MyEclipse:
    just Right-click on project –> MyEclipse –> then first add Struts Capability, then Spring Capability. 
Remember to select version 2.1 of Struts core libraries and spring plugin (servlet default specification will be 2.5) and for Spring add 3.0 Core libraries and Web libraries specify the path where to put applicationContext.xml file: WEB-INF (but you can always manually move in future).

On other IDEs, I suppose there are other ways to add these supports to main project, the result, however, will be exactly this:

Fig. 1 Libraries included

and at the end of the file, first of tag closing, write:

This snippet of code sets a listener to use Spring as Struts action manager.


so web.xml file will look like this:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns=""

Now, let’s create a Struts action; in our example it is used to retrieve some information from a service  on business layer and push it in a jsp.
Again, I am going to show only how to integrate two frameworks, so:
 – Jsp will be very ugly;
 – Project will not be extended to physical layer (no database use and interaction);

Tutorials on these missing features will be submitted in the near future (I am writing several articles on Hibernate and JQuery).

Our application uses a Struts Action to call an interface of a concrete implementation of a service and then, through action, it whows results to a JSP.
Here the UML code:

Struts Action code:

package it.nickg.webapp.web.actions;


import java.util.List;

import com.opensymphony.xwork2.ActionSupport;

public class HelloAction extends ActionSupport {

private HelloService helloService;
 private List words;

public List getWords() {
 return words;

public void setWords(List words) {
 this.words = words;

public HelloService getHelloService() {
 return helloService;

public void setHelloService(HelloService helloService) {
 this.helloService = helloService;

public String execute() throws Exception {

words = helloService.getWords();
 return SUCCESS;

Struts2 apply dependency injection through setters, so every variable that you need to use in jsp, must have a setter (and I add getter too).

HelloService Interface code:


import java.util.List;

public interface HelloService {

public abstract List getWords();

// mandatory setter method for Spring's dependency injection
 public abstract void setWords(List words);

HelloServiceImpl, real service implementation:



import java.util.List;

public class HelloServiceImpl implements Serializable, HelloService {

private List words;

public List getWords() {
 return words;

public void setWords(List words) {
 this.words = words;

Spring applies injection to setter, too: when you need to return some variable from a method in middle-tier, just declare it as private and define a setter, then in xml spring’s configuration file define values to be setted. Spring inject values and presentation tier doesn’t need to know real implementation of business object.

Now edit struts.xml file to map the action created:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "">
<package name="default" extends="struts-default">
<action name="hello" class="helloAction">
<result type="success">/result.jsp</result>

<h3><span style=”font-size: small;”><strong>Crucial  note: what allows to estabilish the link between Struts and Spring is here, <em>class </em>parameter of action must be set as <em>id </em>of spring’s bean calling that action<span style=”font-size: x-small;”>.</span></strong></span></h3>
Add this code to applicationContext.xml file

<?xml version="1.0" encoding="UTF-8"?>

<bean id="helloService" class="">
 <property name="words">
 <value>Hello </value>
 <value>World! </value>
 <value>This is </value>
 <value>a Struts - Spring </value>
 <value>integration example</value>

 <bean id="helloAction" class="it.nickg.webapp.web.actions.HelloAction">
 <property name="helloService" ref="helloService"/>

Now we write JSPs. Let’s give to index.jsp the role to redirect to our action:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
<%@ taglib prefix="c" uri="" %>

<c:redirect url="hellopage.action"/>

and write the “success.jsp” in order to display data returned from action:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 String path = request.getContextPath();
 String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort()
 + path + "/";
<%@ taglib prefix="s" uri="/struts-tags"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <base href="<%=basePath%>">

<title>My JSP 'success.jsp' starting page</title>

<meta http-equiv="pragma" content="no-cache">
 <meta http-equiv="cache-control" content="no-cache">
 <meta http-equiv="expires" content="0">
 <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 <meta http-equiv="description" content="This is my page">
 <link rel="stylesheet" type="text/css" href="styles.css">


 <h3>This is only a sample</h3>
 <s:iterator value="words">

When you run the application, it goes to index.jsp, redirected to hellopage.action and from here to success.jsp that displays an output like this:

In the next article, I will start from this application and I will extend it to physical layer, adding a database and an ORM implementation.

Stay tuned!

Java is fatherless now..

It’s been a long time since I wrote last post and I’m planning to publish a new article on interesting things in next days.
Unfortunately a sad announcement (among other bad news) echoes in Java community:
our father, the man who gives us this powerful and amazing “thing” named Java (as weel as providing us possibility to have a job), decides to resign from Oracle.
Here is the link to his brand new blog.
We all looking forward to his next steps.

Struts2 and Netbeans, configuring latest versions.

Configuring Netbeans to work with Struts2 framework

In this article I provide a workaround to let configure Netbeans Web Project, supporting Struts2 framework. Searching on the web, with Google and not only, I found an official plugin for Netbeans IDE, in developing status; but, sadly, last update was on 2008.

There is a blog , whose author provides an updated version of official plugin (it is modified for netbeans 6.7 and Struts 2.1.6) and this could be useful enough for my purpose…but maybe for curiosity or obduracy, I have created this workaround for installing and configuring a development environment, always updated to latest versions of both IDE and framework.

Very quick overview on Struts2 for those who already know Struts

Most revolutionary innovation provided by Struts2 is related, beyond a shadow of a doubt, with most important method in every Action: execute() method.
Unlike first version of Struts, in Struts2 this method is implemented without parameters to be passed;
and so anyone should ask: how to get the object which we need to work with?
With Struts, this is possible through Form beans, ActionForm. With Struts2, this becomes possible thanks to a specific pattern, known as inversion control or dependency injection.
I don’t pretend to dwell on a theoric explanation about this pattern, but for most curious of you, I warmly suggest to read  this interesting article, written by Martin Fowler.

Every way, this is the pattern which Spring framework is known for.

Struts2 complies to an advanced interpretation of MVC paradigm: pull-MVC. The purposes of this article are far away from an exhaustive text on differences between Struts and Struts2, you can find a lot of readings about this issue, with a quick Google search.
Anyway, some of this differences between two frameworks are fundamental, in my opinion.
MVC schema

Actions play a difference role, they pass from Controller to Model and View’s layers are now able to pull data directly from the actions, there is no more need of an extra object of model layer. The framework is based on 5 main components:
    – Action;
    – Interceptors;
    – DispatcherFilter;
    – Result type;
    – Result view (representation of results);
    – Valuestack\OGNL (modules that make possible integration between other components).
Who works with Struts knows very weel that one of the main configuration file used by framework is web.xml. References to several modules that builds the framework are defined inside that.
Let’s go with practical part.

Creation of a Web Project supporting Struts2, with Netbeans

The first step is to create e new empty WebProject:

File –> New –> Project 

From Categories choose Java Web and, on the left, Web Application. Then Next.

In the next view, give a name to the project, now select an Application Server and in the last page leave unchecked the Struts2 support . Then Finish.

At this point add Struts2 libraries to the project:
right click on Libraries and  Add Jar\Folder.
Now choose which libraries to include in the project, I personally suggest to begin including only necessary ones:
imported libraries

It seems that adding all of those it is not a good idea, because they can generate conflicts. Last two libraries listed above became essential since version 2.1 of struts, I’ll investigate on that.

Creation of web.xml file.

Next step is writing web.xml file.

In particular, it is all handled through filters definition. It is necessary to add an entry for FilterDispatcher:That is the class that behaves like servlet filter, it initializes the framework and manages requets.
This file can be easily edited using the tab General, in this way:
Open it, select tab Filters –> Add Filters Element

In filter name field type: Struts2In filter class field, we should enter the FilterDispatcher class, who handles requests filtering. But the API of this class indicates:

Since Struts 2.1.3, use StrutsPrepareAndExecuteFilter instead or StrutsPrepareFilter and StrutsExecuteFilter if needing using the ActionContextCleanUp filter in addition to this one

Hence, since Struts 2.1.3, in filter class, inside web.xml, you should

The reason of this is still a mystery for me, until the official documentation on
versions subsequent to 2.1.3 will not be updated.

Inside Filter Mappingapply to URL: /*

Final xml will be something like this:

<web-app version="2.5" xmlns:xsi="" xmlns="" xsi:schemalocation="">

Creation of struts.xml file.
Struts.xml file, in version 2 of Struts, replace struts-config.xml. Here it is the template, very basic, for every project.

Go in Source Package directory and create a brand new xml with a simple right click, then type:
<div style="margin-bottom: 0; margin-top: 0;">

 "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

 <package name="default" extends="struts-default">

I experienced several problems when deploy the application and I solved them creating a directory (manually) named classes inside the WEB-INF one (it can be done easily within Netbeans) and putting inside there the struts.xml file.

Now It is all ready to run you first application, It would be very interesting to delve into other configuring issues of Struts2, for example the properties files. But in this context, they can be left empty.

If you want to create your first Struts2 application, I refer you to documentation on the
official site


An italian version of this article is available here:

Wellnet lab

Welcome, folks!

Welcome to my brand new blog!

You’ll probably say: why another blog on Java, developing, frameworks and others things like these?
My answer is: because I need it!
I love my job and I’ve been interested in Information Technology, Software Engineering, Unix-like Operating Systems and so on for a long time and now I work on these fascinating things, but..lately I really have short free time to upgrade my knowledge and it is frustrating!

Every time I say to myself: “I’ll study this new technology next weekend” or “Interesting! I’ll expand on that”…
And then..Nothing! I have never kept those promises, due to short time..but due to my laziness, too!

So.. with this blog I hope that I will be more motivated to study and I will not put off my good intentions.

I’m fighting my laziness. Please, help me to defeat it!