Struts 2

Ajax File Upload

noreply@blogger.com (sandy) — Fri, 16 Nov 2007 05:15:00 +0000

checkout the ajax file upload in struts 2

click here to view

Apache Tiles 2 plugin

noreply@blogger.com (sandy) — Fri, 16 Nov 2007 04:56:00 +0000

hi guys...
the tiles 2 support for the inelliJ IDEA is out...

click here to view

checkout the link

struts 2 plugin

noreply@blogger.com (sandy) — Fri, 16 Nov 2007 04:33:00 +0000

hi guys good news...
now finally IntelliJ IDEA has announced the struts 2 support...

click here to download the plugin

Dependency Injection in Struts 2

noreply@blogger.com (sandy) — Thu, 15 Nov 2007 07:11:00 +0000

hi friends ,
i have created a demo of how dependency injection work,

click here or download it from here

please let me know where i have miss anything, I am just learning now,
so hope to get some suggestion on it,

Difference between Tiles 1 and Tiles 2

noreply@blogger.com (sandy) — Mon, 12 Nov 2007 05:25:00 +0000

The main diffrence between tiles1 and tiles2 is that,
Tiles 1 was mainly dependent on the struts. While Tiles 2 can be used with the other framework like struts 2, JSF, Shale, etc..

for more detail info you can visit this page...
Use Tiles Decorations; Reduce Configuration

Ajax validation in struts 2

noreply@blogger.com (sandy) — Fri, 26 Oct 2007 06:33:00 +0000

Hi Friends,

I have developed a demo on struts 2 and dwr based ajax validation on struts 2 simple theme,

hope you'll all like it,

click here or click here to download it

Help on struts 2

noreply@blogger.com (sandy) — Mon, 22 Oct 2007 09:02:00 +0000

To download the Struts 2 pdf help document click here

There are many resources are available on strut 2, some of them are listed below :

www.roseindia.net/struts/struts2

www.infoq.com/minibooks/starting-struts2

http://cwiki.apache.org/WW/home.html

Getting started with Struts 2 and Tiles 2

noreply@blogger.com (sandy) — Wed, 17 Oct 2007 12:43:00 +0000

Hi guys,

I have developed the demo application which shows how the struts 2 and tiles 2 works together.

You can download it by clicking here : struts2-tiles.zip or struts2-tiles.zip

Comparing Struts 1 and 2

noreply@blogger.com (sandy) — Wed, 10 Oct 2007 04:59:00 +0000

Struts 1 Vs Struts 2

Feature	Struts 1	Struts 2
Action classes	Struts 1 requires Action classes to extend an abstract base class. A common problem in Struts 1 is programming to abstract classes instead of interfaces.	An Struts 2 Action may implement an `Action` interface, along with other interfaces to enable optional and custom services. Struts 2 provides a base ActionSupport class to implement commonly used interfaces. Albeit, the Action interface is not required. Any POJO object with a `execute` signature can be used as an Struts 2 Action object.
Threading Model	Struts 1 Actions are singletons and must be thread-safe since there will only be one instance of a class to handle all requests for that Action. The singleton strategy places restrictions on what can be done with Struts 1 Actions and requires extra care to develop. Action resources must be thread-safe or synchronized.	Struts 2 Action objects are instantiated for each request, so there are no thread-safety issues. (In practice, servlet containers generate many throw-away objects per request, and one more object does not impose a performance penalty or impact garbage collection.)
Servlet Dependency	Struts 1 Actions have dependencies on the servlet API since the HttpServletRequest and HttpServletResponse is passed to the `execute` method when an Action is invoked.	Struts 2 Actions are not coupled to a container. Most often the servlet contexts are represented as simple Maps, allowing Actions to be tested in isolation. Struts 2 Actions can still access the original request and response, if required. However, other architectural elements reduce or eliminate the need to access the HttpServetRequest or HttpServletResponse directly.
Testability	A major hurdle to testing Struts 1 Actions is that the `execute` method exposes the Servlet API. A third-party extension, Struts TestCase, offers a set of mock object for Struts 1.	Struts 2 Actions can be tested by instantiating the Action, setting properties, and invoking methods. Dependency Injection support also makes testing simpler.
Harvesting Input	Struts 1 uses an ActionForm object to capture input. Like Actions, all ActionForms must extend a base class. Since other JavaBeans cannot be used as ActionForms, developers often create redundant classes to capture input. DynaBeans can used as an alternative to creating conventional ActionForm classes, but, here too, developers may be redescribing existing JavaBeans.	Struts 2 uses Action properties as input properties, eliminating the need for a second input object. Input properties may be rich object types which may have their own properties. The Action properties can be accessed from the web page via the taglibs. Struts 2 also supports the ActionForm pattern, as well as POJO form objects and POJO Actions. Rich object types, including business or domain objects, can be used as input/output objects. The ModelDriven feature simplifies taglb references to POJO input objects.
Expression Language	Struts 1 integrates with JSTL, so it uses the JSTL EL. The EL has basic object graph traversal, but relatively weak collection and indexed property support.	Struts 2 can use JSTL, but the framework also supports a more powerful and flexible expression language called "Object Graph Notation Language" (OGNL).
Binding values into views	Struts 1 uses the standard JSP mechanism for binding objects into the page context for access.	Struts 2 uses a "ValueStack" technology so that the taglibs can access values without coupling your view to the object type it is rendering. The ValueStack strategy allows reuse of views across a range of types which may have the same property name but different property types.
Type Conversion	Struts 1 ActionForm properties are usually all Strings. Struts 1 uses Commons-Beanutils for type conversion. Converters are per-class, and not configurable per instance.	Struts 2 uses OGNL for type conversion. The framework includes converters for basic and common object types and primitives.
Validation	Struts 1 supports manual validation via a `validate` method on the ActionForm, or through an extension to the Commons Validator. Classes can have different validation contexts for the same class, but cannot chain to validations on sub-objects.	Struts 2 supports manual validation via the `validate` method and the XWork Validation framework. The Xwork Validation Framework supports chaining validation into sub-properties using the validations defined for the properties class type and the validation context.
Control Of Action Execution	Struts 1 supports separate Request Processors (lifecycles) for each module, but all the Actions in the module must share the same lifecycle.	Struts 2 supports creating different lifecycles on a per Action basis via Interceptor Stacks. Custom stacks can be created and used with different Actions, as needed.

Why Struts 2

noreply@blogger.com (sandy) — Wed, 10 Oct 2007 04:50:00 +0000

The new version Struts 2 is a combination of the Sturts action framework and Webwork.

Simplified Design

Programming the abstract classes instead of interfaces is one of design problem of struts1 framework that has been resolved in the struts 2 framework. Most of the Struts 2 classes are based on interfaces and most of its core interfaces are HTTP independent. Struts 2 Action classes are framework independent and are simplified to look as simple POJOs. Framework components are tried to keep loosely coupled.

Simplified Actions

Actions are simple POJOs. Any java class with execute() method can be used as an Action class. Even we don't need to implement interfaces always. Inversion of Control is introduced while developing the action classes. This make the actions to be neutral to the underlying framework .

No more ActionForms

ActionForms feature is no more known to the struts2 framework. Simple JavaBean flavored actions are used to put properties directly . No need to use all String properties.

Simplified testability

Struts 2 Actions are HTTP independent and framework neutral. This enables to test struts applications very easily without resorting to mock objects.

Intelligent Defaults

Most configuration elements have a default value which can be set according to the need. Even there are xml-based default configuration files that can be overridden according to the need.

Improved results

Unlike ActionForwards, Struts 2 Results provides flexibility to create multiple type of outputs and in actual it helps to prepare the response.

Better Tag features

Struts 2 tags enables to add style sheet-driven markup capabilities, so that we can create consistent pages with less code. Struts 2 tags are more capable and result oriented. Struts 2 tag markup can be altered by changing an underlying stylesheet. Individual tag markup can be changed by editing a FreeMarker template. Both JSP and FreeMarker tags are fully supported.

Annotations introduced

Applications in struts 2 can use use Java 5 annotations as an alternative to XML and Java properties configuration. Annotations minimizes the use of xml.

Stateful Checkboxes

Struts 2 checkboxes do not require special handling for false values.

QuickStart

Many changes can be made on the fly without restarting a web container.

customizing controller

Struts 1 lets to customize the request processor per module, Struts 2 lets to customize the request handling per action, if desired.

Easy Spring integration

Struts 2 Actions are Spring-aware. Just needs to add Spring beans!

Easy plugins

Struts 2 extensions can be added by dropping in a JAR. No manual configuration required!

AJAX support

The AJAX theme gives interactive applications a significant boost.
The framework provides a set of tags to help you ajaxify your applications, even on Dojo. The AJAX features include:

AJAX Client Side Validation
Remote form submission support (works with the submit tag as well)
An advanced div template that provides dynamic reloading of partial HTML
An advanced a template that provides the ability to load and evaluate JavaScript remotely
An AJAX-only tabbed Panel implementation
A rich pub-sub event model
Interactive auto complete tag

What's new in Struts 2.0?

noreply@blogger.com (sandy) — Wed, 10 Oct 2007 04:48:00 +0000

Introduction
In this article we will talk about the new features in Struts 2.0. Over the years, every developers believes that struts is the best and simple framework to implement. Since last two years, more new frameworks come to the market and the use of Struts is declined. Lack of updation in the Struts framework is the main reason for developers choosing alternative framework. To answer this, Struts team comes with the Struts 2.0, an integration of Struts 1.0 with Webwork. Here we will look into the prominent features in the new framework.

An Struts 2 Action may implement an Action interface, along with other interfaces to enable optional and custom services. Struts 2 provides a base ActionSupport class to implement commonly used interfaces. Albeit, the Action interface is not required. Any POJO object with a execute signature can be used as an Struts 2 Action object.

Threading Model

Struts 2 Action objects are instantiated for each request, so there are no thread-safety issues. (In practice, servlet containers generate many throw-away objects per request, and one more object does not impose a performance penalty or impact garbage collection.)

Testability

Struts 2 Actions can be tested by instantiating the Action, setting properties, and invoking methods. Dependency Injection support also makes testing simpler.

Servlet Dependency
Struts 2 Actions are not coupled to a container. Most often the servlet contexts are represented as simple Maps, allowing Actions to be tested in isolation. Struts 2 Actions can still access the original request and response, if required. However, other architectural elements reduce or eliminate the need to access the HttpServetRequest or HttpServletResponse directly.

Harvesting Input
Struts 2 uses Action properties as input properties, eliminating the need for a second input object. Input properties may be rich object types which may have their own properties. The Action properties can can be accessed from the web page via the taglibs. Struts 2 also supports the ActionForm pattern, as well as POJO form objects and POJO Actions. Rich object types, including business or domain objects, can be used as input/output objects. The ModelDriven feature simplifies taglb references to POJO input objects.

Expression Language
Struts 2 can use JSTL, but the framework also supports a more powerful and flexible expression language called "Object Graph Notation Language" (OGNL).

Binding values into views
Struts 2 uses a "ValueStack" technology so that the taglibs can access values without coupling your view to the object type it is rendering. The ValueStack strategy allows reuse of views across a range of types which may have the same property name but different property types.

Type Conversion
Struts 2 uses OGNL for type conversion. The framework includes converters for basic and common object types and primitives.

Validation

Struts 2 supports manual validation via the validate method and the XWork Validation framework. The Xwork Validation Framework supports chaining validation into sub-properties using the validations defined for the properties class type and the validation context.

Control Of Action Execution
Struts 2 supports creating different lifecycles on a per Action basis via Interceptor Stacks. Custom stacks can be created and used with different Actions, as needed.

Struts 2 links

noreply@blogger.com (sandy) — Tue, 09 Oct 2007 12:24:00 +0000

Discussion on different kind of topic of struts2 2
http://groups.google.com/group/struts-2

using ${ , # and %{}

noreply@blogger.com (sandy) — Tue, 09 Oct 2007 09:57:00 +0000

${} is for writing JSP EL, while %{} is for writing OGNL.
Both serve similar purposes, and if you have a servlet container that supports
JSP EL and are running Struts 2, they can be used almost
interchangeably. And # is used for map/lists.

For more details you can read up on the JSP EL:

http://java.sun.com/j2ee/1.4/docs/tutorial/doc/JSPIntro7.html

and using OGNL with Struts 2:

http://struts.apache.org/2.0.9/docs/ognl.html

http://struts.apache.org/2.0.9/docs/tag-syntax.html

Struts2 Plugin

noreply@blogger.com (sandy) — Sat, 06 Oct 2007 09:53:00 +0000

Apache Struts 2 provides a simple plugin architecture so that develpers can extend the framework just by adding a JAR to the application's classpath (in addition to whatever JARs may be required to fulfill the dependencies of the plugin itself). Since plugins are contained in a JAR, they are easy to share with others. Here, we list plugins available for Struts 2 and provides help on how to use them.

Codebehind Plugin — reduces mundane configuration by adding "Page Controller" conventions
Config Browser Plugin — a simple tool to help view your Struts configuration at runtime
Connext Graph Plugin — allows web applications to make use of the Open Flash Chart charts.
ExtraTags Plugin — provides a set of additional tags that complement the core UI tags
Groovy Standalone Plugin — provides support for Actions (and Interceptors) written in the Groovy language
GWT Plugin — can be used to call methods on Struts actions using Google Web Toolkit (GWT)
HDIV Plugin — integrates HDIV (HTTP Data Integrity Validator) with Struts 2 adding Security functionalities
Image Plugin — collection of various plugins for image handling (thumbnails, remote storage, validator)
JasperReports Plugin — enables Actions to return reports through JasperReports
JFreeChart Plugin — allows Actions to easily return generated charts and graphs
JSCalendar Plugin — a backport of the Webwork 2.2.6 JSCalendar tag
JSF Plugin — provides support for JavaServer Faces components with no additional configuration
JSON Plugin — provides a "json" result type that serializes actions into JSON
LightBoxJS Plugin — makes it easier to use the popular LightBoxJS script
OSGi Plugin — leverages OSGi to allow Struts 2 applications to be divided into multiple jars (bundles) and managed at runtime
Pell Multipart Plugin — instructs Struts to use Jason Pell's multipart parser to process file uploads
Plexus Plugin — enables Struts Actions, Interceptors, and Results to be created and injected by Plexus
Rome RSS-Atom Plugin — allows easy outputting of Rome SyndFeed objects (RSS, Atom)
Scope plugin — implements JBoss Seam-style scoped bijection
SiteGraph Plugin — generates graphical diagrams representing the flow of your web application
Sitemesh Plugin — allows Sitemesh templates to access Struts information
SmartURLs plugin — a code by convention and component plugin similar to the Codebehind and Zero-config plugins
Spring MVC Plugin — allows Spring MVC controllers and interceptors to be executed in Struts 2
Spring Plugin — allows Actions, Interceptors, and Results to be created and/or autowired by Spring
Spring Webflow Plugin — integrates Spring Webflow (SWF) with Struts 2
Struts 1 Plugin — allows you to use existing Struts 1 Actions and ActionForms in Struts 2 applications
Table Tags — Struts 2 tags for displaying table data
Tiles Plugin — allows actions to return Tiles pages
WebWork2 Plugin — aims to be a drop-in replacement for WebWork 2 in a web application
YUI Plugin — provides tags based on YUI

Struts 2: Validation

noreply@blogger.com (sandy) — Sat, 06 Oct 2007 05:53:00 +0000

Struts 2.0 relies on a validation framework provided by XWork input validation. Along with basic validation and client-side Javascript validation offered in Struts 1.x, Struts 2 offers Ajax based validation. The following example demonstrates how to use Struts 2 validation, both basic and ajax validations. For this, the sample page used is shown below.

<s:form action="RegisterUser">
<s:textfield name="userName" size="20" label="User Name"  />
<s:textfield name="emailAddress" size="20" label="Email Address" />
<s:textfield name="dateOfBirth" size="20" label="Date Of Birth" />
<s:submit name="submit" value="submit" />
</s:form>

The Action definition is shown below:

<action name="RegisterUser" method="registerUser" class="example.RegisterUser">
<result name="input">/example/Register.jsp</result>
<result>/example/HelloWorld.jsp</result>
</action>

Based on above definition, the Action class must have a method name registerUser.
Basic Validation
For basic validaton, you have to define the validation rules in &ltActionClassName>-validation.xml file. The validations for this form are defined in the RegisterUser-validation.xml file as follows

<validators>
<field name="userName">
<field-validator type="requiredstring">
 <message key="requiredstring" />
</field-validator>
</field>
<field name="emailAddress">
<field-validator type="email">
 <message key="fieldFormat" />
</field-validator>
</field>
<field name="dateOfBirth">
<field-validator type="requiredstring">
 <message key="requiredstring" />
</field-validator>
<field-validator type="regex">
 <param name="expression">
  [0-9][0-9]/[0-9][0-9]/[1-9][0-9][0-9][0-9]
 </param>
 <message key="fieldFormat" />
</field-validator>
</field>
</validators>

Note that the "date of birth" field has two validators associated with it. The "regex" validator type takes a parameter by the name "expression" which is the regular expression used to validate the field. The message keys used in validation rules must be defined in "package.properties" file as follows:

requiredstring = ${getText(fieldName)} is required.
fieldFormat = ${getText(fieldName)} is not formatted properly.

Client Side Validation
For simple client-side validation without Ajax, just add a validate="true" to the form definition in the JSP, as follows:

<s:form action="RegisterUser" validate="true">

Also note that the message keys do not work(atleast not for me), and you may have to define the error messages directly instead of through the properties file as follows:

<message>Date of birth is not formatted properly</message>

Ajax Validation
Struts implements Ajax Validation by using DWR. For a quick start of DWR read Ajax in Java with DWR. Coming to Struts validation, follow these steps to setup DWR

Download DWR from here.

Add DWR servlet mapping in the web deployment descriptor as shown below

<servlet>
<servlet-name>dwr</servlet-name>
<servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>
<init-param>
 <param-name>debug</param-name>
 <param-value>true</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dwr</servlet-name>
<url-pattern>/dwr/*</url-pattern>
</servlet-mapping>

In your WEB-INF directory, create a dwr.xml file and declare the struts validator as follows

<!DOCTYPE dwr PUBLIC
"-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN"
"http://www.getahead.ltd.uk/dwr/dwr10.dtd">

<dwr>
<allow>
<create creator="new" javascript="validator">
 <param name="class"
  value="org.apache.struts2.validators.DWRValidator" />
</create>
<convert converter="bean"
 match="com.opensymphony.xwork2.ValidationAwareSupport" />
</allow>

<signatures>
<![CDATA[
import java.util.Map;
import org.apache.struts2.validators.DWRValidator;

DWRValidator.doPost(String, String, Map<String, String>);
]]>
</signatures>
</dwr>

Change the form declaration in your JSP file to include "theme=ajax" as shown below
```
<s:form action="RegisterUser" validate="true" theme="ajax">
```

Struts 2 Framework

noreply@blogger.com (sandy) — Mon, 05 Mar 2007 13:15:00 +0000

Apache Struts is a free open-source framework for creating Java web applications.

Web applications differ from conventional websites in that web applications can create a dynamic response. Many websites deliver only static pages. A web application can interact with databases and business logic engines to customize a response.

Web applications based on JavaServer Pages sometimes commingle database code, page design code, and control flow code. In practice, we find that unless these concerns are separated, larger applications become difficult to maintain.

One way to separate concerns in a software application is to use a Model-View-Controller (MVC) architecture. The Model represents the business or database code, the View represents the page design code, and the Controller represents the navigational code. The Struts framework is designed to help developers create web applications that utilize a MVC architecture.

(Struts 2 / WebWork architecture)

The framework provides three key components:

A "request" handler provided by the application developer that is mapped to a standard URI.
A "response" handler that transfers control to another resource which completes the response.
A tag library that helps developers create interactive form-based applications with server pages.

The framework's architecture and tags are buzzword compliant. Struts works well with conventional REST applications and with new technologies like SOAP and AJAX.

The Apache Struts Project offers two major versions of the Struts framework. Struts 1 is recognized as the most popular web application framework for Java. The 1.x framework is mature, well-documented, and widely supported. Struts 1 is the best choice for teams who value proven solutions to common problems.

Struts 2 was originally known as WebWork 2. After working independently for several years, the WebWork and Struts communities joined forces to create Struts 2. The new framework is the best choice for teams who value elegant solutions to difficult problems.

Struts 2 is still under construction. An initial release is expected in the third quarter of 2006.