struts2 « WordPress.com Tag Feed

Struts 2.1.8 : New Plug-ins

igazga — Fri, 20 Nov 2009 03:35:12 +0000

ออกมาใหม่ซิงๆ ได้ไม่นาน มี Plug-ins ใหม่ OVal Plugin OSGi Plugin JSON Plugin Embedded JSP Plugin เท่

struts 1.2 validation framework, tiles framework ...

struts2spring — Thu, 05 Nov 2009 18:38:01 +0000

This is a demo HR application in struts 1.2 to demonstrate validation framework, tiles framework . H

Difference between Struts 1 & Struts 2

:) — Fri, 30 Oct 2009 19:30:46 +0000

	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 provide 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 support 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.

Struts2+Spring plugin on Weblogic 8.1

Andrea Cerisara — Sat, 24 Oct 2009 07:15:54 +0000

Goal: to run Struts2+Spring plugin on a Weblogic 8.1 platform bundled with JDK 1.4.2_08, J2EE 1.3 (Servlet 2.3 and JSP 1.2) using the backported 2.0.14 version.

Premise: a J2EE 1.4 environment seems required to run Struts2, but some guys have successfully deployed it on a J2EE 1.3 application server like Weblogic 8.1.

Download the backported version, the standard version and deploy a simple Struts2 project with, at least, these dependencies:

backport-util-concurrent-3.1.jar # from backport package
commons-fileupload-1.2.1.jar # from standard package
commons-io-1.3.2.jar # from standard package
commons-logging-1.0.4.jar # from standard package
freemarker-2.3.15.jar # from standard package
ognl-2.6.11.jar # from standard package
retrotranslator-runtime-1.2.9.jar # from backport package
struts2-core-j4-2.0.14.jar # from backport package
xwork-j4-2.0.7.jar # from backport package

You should be able to run the project without errors. You have to manually backport the plugin to use Spring as DI container (the reported error is the usual “Unsupported major.minor version 49.0“), typing the following command in a terminal:

java -jar retrotranslator-transformer-1.2.2.jar -advanced -srcjar $standard_package_path/lib/struts2-spring-plugin-2.0.14.jar -destjar struts2-spring-plugin-j4-2.0.14.jar

You can find the retrotranslator-transformer jar in the backport package. As usual, you have to add the plugin to the classpath along with all the Spring stuff.

Optiontransferselect Tag (Form Tag) Example

knishe — Fri, 16 Oct 2009 05:55:49 +0000

JSP Pages:
SampleAssignPage.jsp

<%–
Document : SampleAssignPage
Created on : Oct 16, 2009, 8:54:48 AM
Author : Nishanthan
–%>

<%@page contentType=”text/html” pageEncoding=”UTF-8″%>
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”
“http://www.w3.org/TR/html4/loose.dtd”>
<%@ taglib prefix=”s” uri=”/struts-tags” %>

<html>
<head>
<meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″>
<title>JSP Page</title>
<!– –>
<s:head/>
</head>
<body>
<s:url id=”insert” action=”getAllDefault”/>
<s:a href=”%{insert}”>Click Here View all default values</s:a>
<!– The above action could be automated –>
<s:form action=”MyAssignAction”>
<!– Dont forget to put s:head tag with in the jsp tag–>
<s:optiontransferselect
allowUpDownOnLeft=”false”
allowUpDownOnRight=”false”
name=”leftSide”
list=”defaultLeft”
doubleName=”rightSide”
doubleList=”defaultRight”>
</s:optiontransferselect>
<s:submit/>
</s:form>
</body>
</html>

SuccessPage.jsp

<%–
Document : SuccessPage
Created on : Oct 16, 2009, 9:07:51 AM
Author : Nishanthan
–%>

<%@page contentType=”text/html” pageEncoding=”UTF-8″%>
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”
“http://www.w3.org/TR/html4/loose.dtd”>
<%@ taglib prefix=”s” uri=”/struts-tags” %>

<html>
<head>
<meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″>
<title>JSP Page</title>
</head>
<body>
<h2>Left List</h2>
<table>
<s:iterator value=”leftSide”>
<tr>
<td>
<s:property/>
</td>
</tr>
</s:iterator>
</table>

<br/><br/>

<h2>Right List</h2>
<table>
<s:iterator value=”rightSide”>
<tr>
<td>
<s:property/>
</td>
</tr>
</s:iterator>
</table>
</body>
</html>

struts.xml

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

<struts>
<include file=”example.xml”/>
<!– Configuration for the default package. –>
<package name=”default” extends=”struts-default”>
<action name=”getAllDefault” method=”getAllDefault”>
<result name=”success”>/SampleAssignPage.jsp</result>
</action>
<action name=”MyAssignAction”>
<result name=”success”>/SuccessPage.jsp</result>
</action>
</package>
</struts>

Action class:

place with in the com.mydemo.action

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package com.mydemo.action;

import com.mydemo.manager.DataManager;
import com.opensymphony.xwork2.ActionSupport;
import java.util.List;

/**
*
* @author Nishanthan
*/

public class AssignAction extends ActionSupport{

private List<String> leftSide;
private List<String> rightSide;
private List<String> defaultLeft;
private List<String> defaultRight;

public AssignAction() {
}

public List<String> getDefaultLeft() {
return defaultLeft;
}

public void setDefaultLeft(List<String> defaultLeft) {
this.defaultLeft = defaultLeft;
}

public List<String> getDefaultRight() {
return defaultRight;
}

public void setDefaultRight(List<String> defaultRight) {
this.defaultRight = defaultRight;
}

public List<String> getLeftSide() {
return leftSide;
}

public void setLeftSide(List<String> leftSide) {
this.leftSide = leftSide;
}

public List<String> getRightSide() {
return rightSide;
}

public void setRightSide(List<String> rightSide) {
this.rightSide = rightSide;
}

public String execute() throws Exception {
if(this.getLeftSide()!=null){
//Do some thing with left side list
}else if(this.getRightSide()!=null){
//Do some thing with right side list
}
return SUCCESS;
}

public String getAllDefault(){
this.setDefaultLeft(DataManager.getAllLeft());
this.setDefaultRight(DataManager.getAllRight());
return SUCCESS;
}
}

DataManager class:

This class is used to get example data.

place with in com.mydemo.manager

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.mydemo.manager;

import java.util.ArrayList;
import java.util.List;

/**
*
* @author Nishanthan
*/
public class DataManager {

private static List<String> defaultRight;
private static List<String> defaultLeft;

public static List<String> getAllLeft(){
defaultLeft = new ArrayList<String>();
defaultLeft.add(“Nishanthan”);
defaultLeft.add(“Jayanthan”);
defaultLeft.add(“Theeepan”);
return defaultLeft;
}

public static List<String> getAllRight(){
defaultRight = new ArrayList<String>();
defaultRight.add(“Ragavan”);
defaultRight.add(“Bharathi”);
return defaultRight;
}
}

1. TO-DO list: Getting started with hibernate

ruemarin — Wed, 07 Oct 2009 07:12:29 +0000

Introduction

We will start the application by setting up the project. Here are the steps:

Installing a database server
Downloading Hibernate jar files
Downloading the MySQL connector
Setting up the project and adding the references

Installing a database server

I installed MySQL version 5.1 community edition.

Hibernate and MySQL connector jar files

You will need to download and add to your project several jar files relating to struts, hibernate, mysql …

Hibernate: Download Hibernate core, annotation and validator from https://www.hibernate.org/30.html
MySQL connector: http://dev.mysql.com/downloads/connector/j/3.1.html
http://sourceforge.net/projects/hsqldb/files/
http://code.google.com/p/full-hibernate-plugin-for-struts2/

You can download and extract those files in a location that makes sense for you. For example in C:/Java/lib

Setting up the project and adding the references

Next, open Eclipse and create a new project. Create a New “Dynamic Web Project” and called it “Todo”.

Now we will need to add the those references. You need to copy the following list of JAR files to the lib folder of your application (workspace$\Todo\WebContent\WEB-INF\lib).

Here is the list of the jar files that you can find in your lib folder of the struts2 folder:

antlr-2.7.6.jar
commons-collections-3.2.jar, commons-fileupload-1.2.1.jar, commons-io-1.3.2.jar, commons-lang-2.3.jar, commons-logging-1.0.4.jar
dom4j-1.6.1.jar
ejb3-persistence.jar
freemarker-2.3.13.jar
hibernate3.jar, hibernate-annotations.jar, hibernate-commons-annotations.jar, hibernate-validator.jar
hsqldb.jar
javassist-3.9.0.GA.jar
jta-1.1.jar
log4j-1.2.9.jar
mysql-connector-java-5.1.10-bin.jar
ognl-2.6.11.jar
slf4j-api-1.5.8.jar
slf4j-api.jar
struts2-convention-plugin-2.1.6.jar
struts2-core-2.1.6.jar
xwork-2.1.2.jar

Conclusion: At this point, you are ready to code your application.

Thoughts: Honestly, it is quite painful to go around the web to download all those jar files. RubyOnRails is a full stacked framework, meaning it has all of this and more already settup in your project.

Next, we will set up a simple website with a a view, a javabean and a data access object to persist our tasks.

Struts2 TO-DO List project outline

ruemarin — Wed, 07 Oct 2009 00:03:54 +0000

This is my attempt to create a small project using Struts2.

I want to create a simple TO-DO list using the following frameworks and technologies:

Struts2
MySQL
Hibernate
REST
AJAX/jQuery/JSON
Tiles
Velocity
Internationalization
Testing
Maven

I will do this progressively and enhancing the application 1 step at a time. This project will be divided in the following posts:

Getting started with Hibernate
Setting up the REST plugin
Adding AJAX behavior
Adding internationalization
Adding Velocity templates
Testing
Using Tiles
Using Maven

Notes to myself

ruemarin — Mon, 05 Oct 2009 22:47:14 +0000

=======================================================================

Goals:

- Create an application to manage users and their cars

- Create a search features for users

- Use tiles

- use Hibernate

- use Json

- use jQuery

- use REST

- use internationalization

Part 1: plain app: CRUD and search

Part 2: using REST

part 3: using AJAX

part 4: using the internationalization

=======================================================================

web.xml:Used to configure the struts2 dispatcher

struts.xml: used to map action to classes and specify result pages for success or errors+

Note: the class Controller class is not extending any particular class

We don’t have to use the struts.xml config file if we use the convention plugin.

We can use annotations instead

First way:

===========

If we use the convention plugin:

- the controller class must extend com.opensymphony.xwork2.ActionSupport

- The Convention plug-in uses the action class name to map the action URL. Example: the action name coulld be welcome-user and the class name will be

WelcomeUser. The plug-in converts the camel case class name to dashes to get the request URL.

- the Convention plug-in will look for result pages or templates in the WEB-INF/content directory. By convention, if the action returns success, the plugin

will look for a file named: welcome-user-success.jsp or welcome-user.jsp. If the result type is input, then: welcome-user-input.jsp or welcome-user-input.vm

or welcome-user-input.ftl

Second way:

=============

The controller shall import:

import org.apache.struts2.convention.annotation.Action;

import org.apache.struts2.convention.annotation.Result;

The Controller name shall end with Action. Example: WelcomeUserAction

The url mapping to this Controller is welcome-user by convention

By using the following:

@Action(value=”/welcome”,results={@Result(name=”success”,location=”/results/successPage.jsp”)}):

- we will call the WelcomeUserAction by calling the url /welcome and look for a success result view in the results folder and use the successpage.jsp file as

the result page.

File Upload on Google App Engine using struts2

whyjava — Sun, 04 Oct 2009 13:14:02 +0000

Intent of my Blog

Few months back, i wrote a blog on Creating Struts2 application on Google App Engine and some developers asked me how to upload a file using struts2 on google app engine. At that point of time, i was playing with google app engine and was not very clear about the limitation google app engine imposes. Google App Engine does not allow your application to write a file to their application server. This was a very big limitation as most of the application require some sort of file upload. So, i decided to find some way by which i can achieve the upload functionality and i found this link. But, i didn’t wanted to use servelt in my code because i was trying to build a application using struts 2.I wanted to work with actions and use FileUploadInterceptor. With the current implementation of struts 2 FileUploadInterceptor, i can’t do fileupload because it writes file to server.So, after spending some time with struts2 code, i wrote my own extension for Struts 2.This post will discuss how you can use small struts2 wrapper framework, i created for google app engine in your application to do fileupload and more.

Prerequisites for starting Struts2 Application on Google App Engine

Before you start building your sample application on google app engine using struts 2 you will need the following:-

Google App Engine runs on java 5 and above so if necessary, download and install the Java SE Development Kit (JDK) for your platform and for mac users download and install the latest version.
In this example we will be using Eclipse as our ide. So if necessary, download eclipse and google app engine plugin for eclipse.You will also need to download the google java app engine SDK. For more information you can refer to installing the java SDK for google app engine.
Download the latest release of Struts2 framework.If you want to learn struts 2 a very good reference is struts 2 in action book.Please buy Struts 2 in Action.
Download the latest release of struts2-gae framework.It is an wrapper around struts 2 for google app engine.

Step by Step procedure to create Struts2 File Upload application on Google App Engine.

Step 1: Create a new project by clicking the New Web Application Project button in the toolbar.

Step 2 : Give the project name say struts2-fileupload as we are going to create a simple file upload application. Enter package name as com.login and uncheck “Use Google Web Toolkit,” and ensure “Use Google App Engine” is checked and click the finish button.

Step3 : When you click the finish button you will get a sample HelloWorld application, which you can run going in the Run menu, select Run As > Web Application.By default application will run at port 8080, you can view the sample application at http://locahost:8080. For more information on the sample google web application created by the plugin you can refer to Google java app engine documentation .Please keep in mind that intent of this document is not to provide developers the overview of Google App engine for Java.

Step4 : By now you are ready with the google app engine infrastructure and we can move to the next step of creating a file upload application in Struts 2.

for creating a struts 2 application you will need to first add the required dependencies to the struts2-fileupload project. The required struts 2 jars are below mentioned and you can find these jars in struts2 package you downloaded inside the lib folder :-
- commons-fileupload-1.2.1.jar
- commons-io-1.3.2.jar
- commons-logging-1.1.jar
- freemarker-2.3.13.jar
- ognl-2.6.11.jar
- struts2-core-2.1.6.jar
- struts2-gae-0.1.jar
- xwork-2.1.2.jar
Add these dependencies in your eclipse java build path.

Add these dependencies in the war/WEB-INF/lib folder so that these jars gets deployed along with your application.
First step in creating a struts 2 application is configuring the web.xml (deployment descriptor) which is located in WEB-INF folder.You can remove the servlet declaration from web.xml as we will not be needing this.In the last post,we configured FilterDispatcher(this is theFilterDispatcher which comes with struts2) but in this application we need to add the GaeFilterDispatcher(this is provided by struts 2 extension framework for GAE). We will declare GaeFilterDispatcher in web.xml, because in struts2 every request goes pass through a FilterDispatcher, which will invoke the appropriate action corresponding to the URL mapping.So our web.xml will look like :-

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
 <filter>
 <filter-name>struts2-gae</filter-name>
 <filter-class>com.struts2.gae.dispatcher.GaeFilterDispatcher</filter-class>
 </filter>
 <filter-mapping>
 <filter-name>struts2-gae</filter-name>
 <url-pattern>/*</url-pattern>
 </filter-mapping>
 <welcome-file-list>
 <welcome-file>index.html</welcome-file>
 </welcome-file-list>
</web-app>

To start we will be creating a jsp fileupload page using struts 2 tag library and we will call file upload page from index.html.To call the fileupload page there are two ways first, we can directly call the upload.jsp page from link second, we can calling it through struts. We will be taking the second step as this will show you how to configure actions when you dont need to invoke any action.Lets first see how our login page and index.html will look like :-

index.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Struts2 File upload on Google App Engine</title>
</head>

<body>
<h1>Struts2 File upload on Google App Engine!</h1>
<table>
<tr>
<td colspan="2" style="font-weight: bold;">Available Application:</td>
</tr>
<tr>
<td><a href="/add" />Upload my Photo</td>
</tr>
</table>
</body>
</html>

upload.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"</pre>
 pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Upload my Photo</title>
</head>
<body>
 <s:form action="upload" method="post" enctype="multipart/form-data">
 <s:file name="photo" label="Upload new Photo"></s:file>
 <s:submit value="Upload"></s:submit>
 </s:form>

</body>
</html>

After creating the upload.jsp we need to configure this as action in the struts.xml file which you be should put inside source folder parallel to log4j.properties file.We can configure action as mentioned below:-

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
	<include file="struts-default.xml"></include>
<package name="" namespace="/" extends="struts-default">
		<action name="add">
			<result>/upload.jsp</result>
		</action>
	</package>
</struts>

Now try running this application by right click on project run as > web application and click http://localhost:8080. You will see index.html and when you click on upload my photo you will get this exception :-

SEVERE: Unable to set parameter [location] in result of type [org.apache.struts2.dispatcher.ServletDispatcherResult]

Caught OgnlException while setting property ‘location’ on type ‘org.apache.struts2.dispatcher.ServletDispatcherResult’. – Class: ognl.OgnlRuntime

File: OgnlRuntime.java

Method: invokeMethod

Line: 508 – ognl/OgnlRuntime.java:508:-1

at com.opensymphony.xwork2.ognl.OgnlUtil.internalSetProperty(OgnlUtil.java:392)

Caused by: java.lang.IllegalAccessException: Method [public void org.apache.struts2.dispatcher.StrutsResultSupport.setLocation(java.lang.String)] cannot be accessed.

at ognl.OgnlRuntime.invokeMethod(OgnlRuntime.java:508)

at ognl.OgnlRuntime.callAppropriateMethod(OgnlRuntime.java:812)

at ognl.OgnlRuntime.setMethodValue(OgnlRuntime.java:964)

at ognl.ObjectPropertyAccessor.setPossibleProperty(ObjectPropertyAccessor.java:75)

at ognl.ObjectPropertyAccessor.setProperty(ObjectPropertyAccessor.java:131)

at com.opensymphony.xwork2.ognl.accessor.ObjectAccessor.setProperty(ObjectAccessor.java:28)

at ognl.OgnlRuntime.setProperty(OgnlRuntime.java:1656)

at ognl.ASTProperty.setValueBody(ASTProperty.java:101)

at ognl.SimpleNode.evaluateSetValueBody(SimpleNode.java:177)

at ognl.SimpleNode.setValue(SimpleNode.java:246)

at ognl.Ognl.setValue(Ognl.java:476)

at com.opensymphony.xwork2.ognl.OgnlUtil.setValue(OgnlUtil.java:192)

at com.opensymphony.xwork2.ognl.OgnlUtil.internalSetProperty(OgnlUtil.java:385)

… 73 more

In order to resolve this problem we need to make entry in web.xml file also for OgnlListener.This OgnlListener is also provided by struts2-gae framework.(A struts2 extension framework for GAE).

[/sourcecode]

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
<filter>
<filter-name>struts2-gae</filter-name>
<filter-class>com.struts2.gae.dispatcher.GaeFilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2-gae</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<listener>
<listener-class>com.struts2.gae.listener.OgnlListener</listener-class>
</listener>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>

[sourcecode]

You need to add this step if you are using Google App Engine 1.2.6 because when you run struts2 application on google app engine 1.2.6 you will get the following error:-

javax.servlet.ServletException: java.lang.NoClassDefFoundError: javax.swing.tree.TreeNode is a restricted class. Please see the Google App Engine developer’s guide for more details.
at org.apache.jasper.runtime.PageContextImpl.doHandlePageException(PageContextImpl.java:825)
at org.apache.jasper.runtime.PageContextImpl.access$1100(PageContextImpl.java:64)
at org.apache.jasper.runtime.PageContextImpl$12.run(PageContextImpl.java:745)
at java.security.AccessController.doPrivileged(Native Method)
at org.apache.jasper.runtime.PageContextImpl.handlePageException(PageContextImpl.java:743)
at org.apache.jsp.login_jsp._jspService(login_jsp.java:86)
at org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:94)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:806)
at org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:324)
at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:292)
at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:236)
at com.google.appengine.tools.development.PrivilegedJspServlet.access$101(PrivilegedJspServlet.java:23)
at com.google.appengine.tools.development.PrivilegedJspServlet$2.run(PrivilegedJspServlet.java:59)
at java.security.AccessController.doPrivileged(Native Method)
at com.google.appengine.tools.development.PrivilegedJspServlet.service(PrivilegedJspServlet.java)

To avoid this error you need to create a new package “freemarker.core” in your source folder and add the following class

</span></span>

/*
 * Copyright (c) 2003 The Visigoth Software Society. All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution, if
 *    any, must include the following acknowledgement:
 *       "This product includes software developed by the
 *        Visigoth Software Society (http://www.visigoths.org/)."
 *    Alternately, this acknowledgement may appear in the software
itself,
 *    if and wherever such third-party acknowledgements normally
appear.
 *
 * 4. Neither the name "FreeMarker", "Visigoth", nor any of the names
of the
 *    project contributors may be used to endorse or promote products
derived
 *    from this software without prior written permission. For written
 *    permission, please contact visigo...@visigoths.org.
 *
 * 5. Products derived from this software may not be called
"FreeMarker" or "Visigoth"
 *    nor may "FreeMarker" or "Visigoth" appear in their names
 *    without prior written permission of the Visigoth Software
Society.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE VISIGOTH SOFTWARE SOCIETY OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Visigoth Software Society. For more
 * information on the Visigoth Software Society, please see
 * http://www.visigoths.org/
 */

package freemarker.core;

import java.io.IOException;

/**
 * A TemplateElement representing a block of plain text.
 *
 * @version $Id: TextBlock.java,v 1.17 2004/01/06 17:06:42 szegedia Exp $
 */
public final class TextBlock extends TemplateElement {
 private static final char[] EMPTY_CHAR_ARRAY = new char[0];
 static final TextBlock EMPTY_BLOCK = new TextBlock(EMPTY_CHAR_ARRAY, false);
 // We're using char[] instead of String for storing the text block because
 // Writer.write(String) involves copying the String contents to a char[]
 // using String.getChars(), and then calling Writer.write(char[]).By
 // using Writer.write(char[]) directly, we avoid array copying on each
 // write.
 private char[] text;
 private final boolean unparsed;

 public TextBlock(String text) {
 this(text, false);
 }

 public TextBlock(String text, boolean unparsed) {
 this(text.toCharArray(), unparsed);
 }

 private TextBlock(char[] text, boolean unparsed) {
 this.text = text;
 this.unparsed = unparsed;
 }

 /**
 * Simply outputs the text.
 */
 public void accept(Environment env) throws IOException {
 env.getOut().write(text);
 }

 public String getCanonicalForm() {
 String text = new String(this.text);
 if (unparsed) {
 return "<#noparse>" + text + "</#noparse>";
 }
 return text;
 }

 public String getDescription() {
 String s = new String(text).trim();
 if (s.length() == 0) {
 return "whitespace";
 }
 if (s.length() > 20) {
 s = s.substring(0, 20) + "...";
 s = s.replace('\n', ' ');
 s = s.replace('\r', ' ');
 }
 return "text block (" + s + ")";
 }

 TemplateElement postParseCleanup(boolean stripWhitespace) {
 if (text.length == 0)
 return this;
 int openingCharsToStrip = 0, trailingCharsToStrip = 0;
 boolean deliberateLeftTrim = deliberateLeftTrim();
 boolean deliberateRightTrim = deliberateRightTrim();
 if (!stripWhitespace || text.length == 0) {
 return this;
 }
 if (parent.parent == null && previousSibling() == null)
 return this;
 if (!deliberateLeftTrim) {
 trailingCharsToStrip = trailingCharsToStrip();
 }
 if (!deliberateRightTrim) {
 openingCharsToStrip = openingCharsToStrip();
 }
 if (openingCharsToStrip == 0 && trailingCharsToStrip == 0) {
 return this;
 }
 this.text = substring(text, openingCharsToStrip, text.length
 - trailingCharsToStrip);
 if (openingCharsToStrip > 0) {
 this.beginLine++;
 this.beginColumn = 1;
 }
 if (trailingCharsToStrip > 0) {
 this.endColumn = 0;
 }
 return this;
 }

 /**
 * Scans forward the nodes on the same line to see whether there is a
 * deliberate left trim in effect. Returns true if the left trim was
 * present.
 */
 private boolean deliberateLeftTrim() {
 boolean result = false;
 for (TemplateElement elem = this.nextTerminalNode(); elem != null
 && elem.beginLine == this.endLine; elem = elem
 .nextTerminalNode()) {
 if (elem instanceof TrimInstruction) {
 TrimInstruction ti = (TrimInstruction) elem;
 if (!ti.left && !ti.right) {
 result = true;
 }
 if (ti.left) {
 result = true;
 int lastNewLineIndex = lastNewLineIndex();
 if (lastNewLineIndex >= 0 || beginColumn == 1) {
 char[] firstPart = substring(text, 0,
 lastNewLineIndex + 1);
 char[] lastLine = substring(text, 1 + lastNewLineIndex);
 if (trim(lastLine).length == 0) {
 this.text = firstPart;
 this.endColumn = 0;
 } else {
 int i = 0;
 while (Character.isWhitespace(lastLine[i])) {
 i++;
 }
 char[] printablePart = substring(lastLine, i);
 this.text = concat(firstPart, printablePart);
 }
 }
 }
 }
 }
 if (result) {
 }
 return result;
 }

 /**
 * Checks for the presence of a t or rt directive on the same line. Returns
 * true if the right trim directive was present.
 */
 private boolean deliberateRightTrim() {
 boolean result = false;
 for (TemplateElement elem = this.prevTerminalNode(); elem != null
 && elem.endLine == this.beginLine; elem = elem
 .prevTerminalNode()) {
 if (elem instanceof TrimInstruction) {
 TrimInstruction ti = (TrimInstruction) elem;
 if (!ti.left && !ti.right) {
 result = true;
 }
 if (ti.right) {
 result = true;
 int firstLineIndex = firstNewLineIndex() + 1;
 if (firstLineIndex == 0) {
 return false;
 }
 if (text.length > firstLineIndex
 && text[firstLineIndex - 1] == '\r'
 && text[firstLineIndex] == '\n') {
 firstLineIndex++;
 }
 char[] trailingPart = substring(text, firstLineIndex);
 char[] openingPart = substring(text, 0, firstLineIndex);
 if (trim(openingPart).length == 0) {
 this.text = trailingPart;
 this.beginLine++;
 this.beginColumn = 1;
 } else {
 int lastNonWS = openingPart.length - 1;
 while (Character.isWhitespace(text[lastNonWS])) {
 lastNonWS--;
 }
 char[] printablePart = substring(text, 0, lastNonWS + 1);
 if (trim(trailingPart).length == 0) {
 // THIS BLOCK IS HEINOUS! THERE MUST BE A BETTER
 // WAY! REVISIT (JR)
 boolean trimTrailingPart = true;
 for (TemplateElement te = this.nextTerminalNode(); te != null
 && te.beginLine == this.endLine; te = te
 .nextTerminalNode()) {
 if (te.heedsOpeningWhitespace()) {
 trimTrailingPart = false;
 }
 if (te instanceof TrimInstruction
 && ((TrimInstruction) te).left) {
 trimTrailingPart = true;
 break;
 }
 }
 if (trimTrailingPart)
 trailingPart = EMPTY_CHAR_ARRAY;
 }
 this.text = concat(printablePart, trailingPart);
 }
 }
 }
 }
 return result;
 }

 /*
 * private String leftTrim(String s) { int i =0; while (i<s.length()) { if
 * (!Character.isWhitespace(s.charAt(i))) break; ++i; } return
 * s.substring(i); }
 */
 private int firstNewLineIndex() {
 String content = new String(text);
 int newlineIndex1 = content.indexOf('\n');
 int newlineIndex2 = content.indexOf('\r');
 int result = newlineIndex1 >= 0 ? newlineIndex1 : newlineIndex2;
 if (newlineIndex1 >= 0 && newlineIndex2 >= 0) {
 result = Math.min(newlineIndex1, newlineIndex2);
 }
 return result;
 }

 private int lastNewLineIndex() {
 String content = new String(text);
 return Math.max(content.lastIndexOf('\r'), content.lastIndexOf('\n'));
 }

 /**
 * figures out how many opening whitespace characters to strip in the
 * post-parse cleanup phase.
 */
 private int openingCharsToStrip() {
 int newlineIndex = firstNewLineIndex();
 if (newlineIndex == -1 && beginColumn != 1) {
 return 0;
 }
 ++newlineIndex;
 if (text.length > newlineIndex) {
 if (newlineIndex > 0 && text[newlineIndex - 1] == '\r'
 && text[newlineIndex] == '\n') {
 ++newlineIndex;
 }
 }
 if (new String(text).substring(0, newlineIndex).trim().length() > 0) {
 return 0;
 }
 // We look at the preceding elements on the line to see if we should
 // strip the opening newline and any whitespace preceding it.
 for (TemplateElement elem = this.prevTerminalNode(); elem != null
 && elem.endLine == this.beginLine; elem = elem
 .prevTerminalNode()) {
 if (elem.heedsOpeningWhitespace()) {
 return 0;
 }
 }
 return newlineIndex;
 }

 /**
 * figures out how many trailing whitespace characters to strip in the
 * post-parse cleanup phase.
 */
 private int trailingCharsToStrip() {
 String content = new String(text);
 int lastNewlineIndex = lastNewLineIndex();
 if (lastNewlineIndex == -1 && beginColumn != 1) {
 return 0;
 }
 String substring = content.substring(lastNewlineIndex + 1);
 if (substring.trim().length() > 0) {
 return 0;
 }
 // We look at the elements afterward on the same line to see if we
 // should strip any whitespace after the last newline
 for (TemplateElement elem = this.nextTerminalNode(); elem != null
 && elem.beginLine == this.endLine; elem = elem
 .nextTerminalNode()) {
 if (elem.heedsTrailingWhitespace()) {
 return 0;
 }
 }
 return substring.length();
 }

 boolean heedsTrailingWhitespace() {
 if (isIgnorable()) {
 return false;
 }
 for (int i = 0; i < text.length; i++) {
 char c = text[i];
 if (c == '\n' || c == '\r') {
 return false;
 }
 if (!Character.isWhitespace(c)) {
 return true;
 }
 }
 return true;
 }

 boolean heedsOpeningWhitespace() {
 if (isIgnorable()) {
 return false;
 }
 for (int i = text.length - 1; i >= 0; i--) {
 char c = text[i];
 if (c == '\n' || c == '\r') {
 return false;
 }
 if (!Character.isWhitespace(c)) {
 return true;
 }
 }
 return true;
 }

 boolean isIgnorable() {
 if (text == null || text.length == 0) {
 return true;
 }
 if (!isWhitespace()) {
 return false;
 }
 // trick here
 boolean atTopLevel = true;
 TemplateElement prevSibling = previousSibling();
 TemplateElement nextSibling = nextSibling();
 return ((prevSibling == null && atTopLevel) || nonOutputtingType(prevSibling))
 && ((nextSibling == null && atTopLevel) || nonOutputtingType(nextSibling));
 }

 private boolean nonOutputtingType(TemplateElement element) {
 return (element instanceof Macro || element instanceof Assignment
 || element instanceof AssignmentInstruction
 || element instanceof PropertySetting
 || element instanceof LibraryLoad || element instanceof Comment);
 }

 private static char[] substring(char[] c, int from, int to) {
 char[] c2 = new char[to - from];
 System.arraycopy(c, from, c2, 0, c2.length);
 return c2;
 }

 private static char[] substring(char[] c, int from) {
 return substring(c, from, c.length);
 }

 private static char[] trim(char[] c) {
 if (c.length == 0) {
 return c;
 }
 return new String(c).trim().toCharArray();
 }

 private static char[] concat(char[] c1, char[] c2) {
 char[] c = new char[c1.length + c2.length];
 System.arraycopy(c1, 0, c, 0, c1.length);
 System.arraycopy(c2, 0, c, c1.length, c2.length);
 return c;
 }

 boolean isWhitespace() {
 return text == null || trim(text).length == 0;
 }

}

Now if you run the web application you will see the upload page.
Next step is to configure the GaeFileUploadInterceptor in struts.xml file.In struts 2, file upload is done by FileUploadInterceptor which intercept all the MultiPartRequest and provides the File object to the action. Then action does what ever it wants to do with the File object.But, on google app engine you can’t get the File object because file writes and many other file related operations are not allowed on GAE.So, we will use GaeFileUploadInterceptor which provides a String object which contains all the file content.You can save this string as a blob into the datastore or convert this string object into InputStream and return to the user.You need to add an entry in struts.xml for GaeFileUploadInterceptor.

</pre>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="struts-default.xml"></include>
<package name="" namespace="/" extends="struts-default">
<interceptors>
<interceptor name="gaeFileUploadInterceptor"
class="com.struts2.gae.interceptor.GaeFileUploadInterceptor" />
<interceptor-stack name="fileUploadStack">
<interceptor-ref name="gaeFileUploadInterceptor"></interceptor-ref>
<interceptor-ref name="basicStack"></interceptor-ref>
</interceptor-stack>
</interceptors>

<default-interceptor-ref name="fileUploadStack" />
<action name="add">
<result>/upload.jsp</result>
</action>
</package>

</struts>
<pre>

Next step is to create the UploadAction which will handle the upload request.


package com.fileupload;

import java.io.InputStream;

import org.apache.commons.io.IOUtils;

import com.opensymphony.xwork2.ActionSupport;

public class UploadAction extends ActionSupport {

 private static final long serialVersionUID = -300329750248730163L;
 private String photo;
 private String photoContentType;
 private String photoFileName;
 private InputStream photoStream;

 public String upload() throws  Exception {
 photoStream = IOUtils.toInputStream(photo,"ISO-8859-1");
 return "success";
 }

 public String getPhoto() {
 return photo;
 }

 public void setPhoto(String photo) {
 this.photo = photo;
 }

 public String getPhotoContentType() {
 return photoContentType;
 }

 public void setPhotoContentType(String photoContentType) {
 this.photoContentType = photoContentType;
 }

 public String getPhotoFileName() {
 return photoFileName;
 }

 public void setPhotoFileName(String photoFileName) {
 this.photoFileName = photoFileName;
 }

 public InputStream getPhotoStream() {
 return photoStream;
 }

 public void setPhotoStream(InputStream photoStream) {
 this.photoStream = photoStream;
 }
}

If you notice there are three properties in the action photo,photoContentType,photoFileName.These properties get their values from the GaeFileUploadInterceptor. These properties have to start with name you gave the file in the upload.jsp <s:file name=”photo” label=”Upload new Photo”></s:file>. In this, name is “photo” so you will get your file content in a property called photo and the two other properties will start with photo.

The second thing to notice is that result of action is “success” which is not SUCCESS you normally use. In this we are using a different result type called org.apache.struts2.dispatcher.StreamResult. Stream result is a custom Result type for sending raw data (via an InputStream) directly to the HttpServletResponse.

Now we will configure UploadAction in struts.xml


<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
 <include file="struts-default.xml"></include>
 <package name="" namespace="/" extends="struts-default">
 <interceptors>
 <interceptor name="gaeFileUploadInterceptor"
 class="com.struts2.gae.interceptor.GaeFileUploadInterceptor" />
 <interceptor-stack name="fileUploadStack">
 <interceptor-ref name="gaeFileUploadInterceptor"></interceptor-ref>
 <interceptor-ref name="basicStack"></interceptor-ref>
 </interceptor-stack>
 </interceptors>

 <default-interceptor-ref name="fileUploadStack" />
 <action name="add">
 <result>/upload.jsp</result>
 </action>
 <action name="upload" method="upload">
 <result name="success" type = "stream">
 <param name="contentType">image/jpeg</param>
 <param name="inputName">photoStream</param>
 <param name="contentDisposition">filename="photo.jpg"</param>
 <param name="bufferSize">1024</param>
 </result>
 </action>
 </package>

</struts>

Finally, Run this application you will be able to upload the photo and then view it in your browser.

In this blog, i have tried to explain you how you can do file upload using struts 2 on google app engine.Please make sure you download the struts2-gae jar.Hope this helps you all.

You can dowload the sample project from here.

Getting Started With Struts2 - Part 1

ruemarin — Mon, 28 Sep 2009 23:49:39 +0000

My first Struts2 steps …

At first, I got very confused with Struts2 on how and where to get started.

What do I need to know? Learn? Shall I first learn about Servlet and JSP? How much shall I know?
How about Enterprise Java Beans? JavaBeans? What do I need to know?

I started with many resources without finding anything for a beginner that was easy to follow and understand and really thought struts2 and the Java world are very difficult to penetrate. These are some of the resources I first used but did not like:

http://www.packtpub.com/apache-struts-2-web-application-development-beginners-guide/book. I thought it wasn’t easy to access is as a beginner …
APress book on Struts2 which preview is available online at http://www.apress.com/book/preview/9781590599037 which also was not the simple and easy introduction that I was looking for.

After many hours of looking for the right resources, I finally found 1 site that had what fitted me … the struts2 website itself!!

You should start with the bootstrap series are easy enough and will help you to make your first baby steps.
Then vaannila.com has also series of tutorials pretty easy to follow. Plus it has also simple tutorials on Hibernate and Spring.
http://struts.apache.org/2.x/docs/home.html has a link to a free PDF to start with Struts2.

Besides the first 2 tutorials, all the resources I found were starting with a brief description of the framework and then configuration .. struts2 is a lot of configuration so don’t be discouraged and just go over it until it’s more fun.

I think if you have Web Development background but new to the Java world, those are the steps that will get you familiar with the Struts2 framework.

Struts2 - Chapter 4: OGNL - Object Graph Notation Language

sanjeevdebnath — Fri, 25 Sep 2009 19:25:40 +0000

Struts2 - Chapter 3: Actions & Results

sanjeevdebnath — Fri, 25 Sep 2009 19:24:51 +0000

Struts2 - Chapter 2: Installation & Configuration

sanjeevdebnath — Fri, 25 Sep 2009 19:21:30 +0000

Struts2 - Chapter 1: Evolution of web applications

sanjeevdebnath — Fri, 25 Sep 2009 19:18:13 +0000

Web development in Java: Installing the tools

ruemarin — Sat, 19 Sep 2009 21:46:55 +0000

I will soon start a new job as a Web Developer where using J2EE.

I do not have experience in Java Web Development but I do in ASP.NET and C#, PHP and Ruby on Rails.

So I will add new posts on my learning experience on Java Web Development and blog about Struts2 framework, Maven, Eclipse …

FYI, I use a Mac with Leopard OS on it. You should also know that I am a newbie to web development in Java, so you are warned! This is more like a blog from beginner to beginner.

In today’s post, I’ll talk about some installation issues of Tomcat, Eclipse and Struts2.

Starting point:

Installing Java

This is only for Windows users. You need to download and save the Java SDK. I installed mine under C:\Sun\

Installing Tomcat

Link to download Tomcat: http://tomcat.apache.org/download-60.cgi

Here is link to install Tomcat on MacOSX: http://www.malisphoto.com/tips/tomcatonosx.html

Installing Eclipse

http://www.eclipse.org/downloads/

Download this version: Eclipse IDE for Java EE Developers

You can install Eclipse in your application folder on Mac or in the Program Files on Windows.

Eclipse uses a special folder called workspace where all the projects created via Eclipse will be located. On Mac, I created this folder under /Documents/Projects and on Windows, I created it under C:/
On Windows only: make also sure that the init file (C:\Program Files\eclipse\eclipse.init) is pointing to the Java runtime file in the JDK’s bin folder. I have mine under C:\Sun\SDK\jdk\bin. The reason I mention this is that I had some issues to run Tomcat because Eclipse was looking for the javaw.exe file under my JRE folder (C:\Program Files\Java\jre1.6.0_02) … which didn’t have it. The difference between the JRE and the JDK is that the JDK allows you to develop and run Java applications while the JRE only allows you to run Java applications. So if you need to update the .init file, replace the line under -vm with the path to your jdk’s bin folder (ex: mine is C:/Sun/SDK/jdk/bin/javaw.exe.). Mac users will not have this issue because Mac comes with Java installed in a well defined folder .. so all JAVA apps running under Mac know where to look for the Java runtime. On Windows, the user does the installation and make the choice on where to save all the Java files.
On Mac, I put my eclipse folder in the Application folder so the location is different for all Windows users.

Installing Struts2

http://struts.apache.org/2.x/index.html

There is nothing to do besides downloading the package.

Struts2 is basically a library you will reference for your projects from Eclipse. So download it, unzip it and put the unzipped folder to a meaningful location like My Documents/Library/Java/Struts2/version on Windows on under HD/Library/Java/Struts2/ on Mac.

Now, explore the folder. You will see 4 main directories:

apps: Contains templates of struts app and especially the blank app. These sample apps are packaged under the WAR format. To uncrompress them, change their extension to .zip instead of .war and then uncompress. Navigate to the uncompressed blank app’s folder to see the required jar files needed for basic struts2 web apps and aslo to get a basic struts.xml file.
docs: contains documentation
lib: contains the jar files
src: contains the source code of the framework

When you will create a Struts2 projects from scratch by hand (without Maven), you will copy and paste the needed jar file to the lib folder of your application.

And that’s pretty much it for the installation part. We will install other components later but let’s keep it simple and to the point for now.

Struts 2 : the modern web application framework

syamtastic — Fri, 04 Sep 2009 23:02:54 +0000

Modern web applications are situated in a complex technological context. Some books that you read might be about a single subject, such as the Java language, or a specific API or library. This book is about Struts 2, a full-featured web application framework for the Java EE platform. As such, this book must take into account the vast array of technologies that converge in the space of the Java EE.

In response to this complexity, we’ll start by outlining some of the most impor- tant technologies that Struts 2 depends on. Struts 2 provides some powerful boosts to production through convention over configuration, and automates many tasks that were previously accomplished only by the sweat of the developer. But we think true efficiency comes through understanding the underlying technological context, particularly as these technologies become more and more obscured by the opacity of scaffolding and the like. That said, the first half of this chapter provides a primer on the Struts 2 environment. If you’re comfortable with this stuff, feel free to skim or skip these sections entirely.

After sketching the important figures of the landscape, we’ll move into a high-level overview of Struts 2 itself. We’ll introduce how the Model-View-Controller (MVC) fits into the Struts 2 architecture. After that, we’ll go through a more detailed account of what happens when the framework processes a request. When we finish up, you’ll be fully ready for chapter 2’s HelloWorld application.

Let’s get going!

1.1 Web applications: a quick study

This section provides a rough primer on the technological context of a web application. We’ll cover the technology stack upon which web applications sit, and take a quick survey of common tasks that all web applications must routinely accomplish as they service their requests. If you’re quite familiar with this information, you could skip ahead to the Struts 2 architectural overview in section 1.3, but a quick study of the following sections would still provide an orientation on how we, the authors, view the web application domain.

1.1.1 Using the Web to build applications

While many Java developers today may have worked on web applications for most of their careers, it’s always beneficial to revisit the foundations of the domain in which one is working. A solid understanding of the context in which a framework such as Struts 2 is situated provides an intuitive understanding of the architectural decisions made by the framework. Also, establishing a common vocabulary for our discussions will make everything easier throughout the book.

A web application is simply, or not so simply, an application that runs over the Web. With rapid improvements in Internet speed, connectivity, and client/server technologies, the Web has become an increasingly powerful platform for building all classes of applications, from standard business-oriented enterprise solutions to personal software. The latest iterations of web applications must be as full featured and easy to use as traditional desktop applications. Yet, in spite of the increasing variety in applications built on the web platform, the core workflow of these applications remains markedly consistent, a perfect opportunity for reuse. Frameworks such as Struts 2 strive to release the developer from the mundane concerns of the domain by providing a reusable architectural solution to the core web application workflows.

1.1.2 Examining the technology stack

We’ll now take a quick look at two of the main components in the technology stack upon which a web application is built. In one sense, the Web is a simple affair: as with all good solutions, if it weren’t simple, it probably wouldn’t be successful. Figure 1.1 provides a simple depiction of the context in which Struts 2 is used.

As depicted in figure 1.1, Struts 2 sits on top of two important technologies. At the heart of all Struts 2 applications lie the client/server exchanges of the
HTTP protocol. The Java Servlet API exposes these low level HTTP communications to the Java language. Although it’s possible to write web applications by directly coding against the Servlet API, this is generally not considered a good practice. Basically, Struts 2 uses the Servlet API so that you don’t have to. But while it’s a good idea to keep the Servlet API out of your Struts 2 code, it seems cavalier to enter into Struts 2 development without some idea of the underlying technologies. The next two sections provide concise descriptions of the more relevant aspects of HTTP and Java Servlets.

HYPERTEXT TRANSFER PROTOCOL (HTTP)

Most web applications run on top of HTTP. This protocol is a stateless series of client/server message exchanges. Normally, the client is a web browser and the server is a web or application server. The client initiates communication by sending a request for a specific resource. The resource can be a static HTML document that exists on the server’s local file system, or it can be a dynamically generated document with untold complexity behind its creation.

Much could be said about the HTTP protocol and the variety of ways of doing things in this domain. We’ll limit ourselves to the most important implications as seen from the perspective of a web application. We can start by noting that HTTP was not originally designed to serve in the capacity that web application developers demand of it. It was meant for requesting and serving static HTML documents. All web applications built on HTTP must address this discrepancy.

For web applications, HTTP has two hurdles to get over. It’s stateless, and it’s text based. Stateless protocols don’t keep track of the relationships among the various requests they receive. Each request is handled as if it were the only request the server had ever received. The HTTP server keeps no records that would allow it to track and logically connect multiple requests from a given client. The server has the client’s address, but it will only be used to return the currently requested document. If the client turns around and requests another document, the server will be unaware of this
client’s repeated visits.

But if we are trying to build more complex web applications with more complicated use cases, this won’t work. Take the simplest, most common case of the secure web application. A secure application needs to authenticate its users. To do this, the request in which the client sends the user name and password must somehow be associated with all other requests coming from that client during that user session. Without the ability to keep track of relationships among various requests, even this introductory use case of modern web applications is impossible. This problem must be addressed by every modern web application.

Equally as troublesome, HTTP also is text based. Mating a text-based technology to a strongly typed technology such as Java creates a significant amount of data-binding work. While in the form of an HTTP request, all data must be represented as text. Somewhere along the way, this encoding of data must be mapped onto Java data types. Furthermore, this process must occur at both ends of the request-handling process. Incoming request parameters must be migrated into the Java environment, and outgoing responses must pull data from Java back into the text-based HTTP response. While this is not rocket science, it can create mounds of drudge work for a web application. These tasks are both error-prone and time-consuming.

JAVA SERVLET API

The Java Servlet API helps alleviate some of the pain. This important technology exposes HTTP to the Java platform. This means that Java developers can write HTTP server code against an intuitive object-oriented abstraction of the HTTP client/server communications. The central figures in the Servlet API are the servlet, request, and response objects. A servlet is a singleton Java object whose whole purpose is to receive requests and return responses after some arbitrary back-end processing. The request
object encapsulates the various details of the request, including the all-important request parameters as submitted via form fields and querystring parameters. The response object includes such key items as the response headers and the output stream that will generate the text of the response. In short, a servlet receives a request object, examines its data, does the appropriate back-end magic, and then writes and returns the response to the client.

ESSENTIAL KNOWLEDGE

You should know Sun and the Servlet Specification. If you’re unfamiliar with Sun’s way of doing things, here’s a short course. Sun provides a specification of a technology, such as the Servlet API. The specifications are generated through a community process that includes a variety of interested parties, not the least of which is Sun itself. The specification details the obligations and contracts that the API must honor; actual implementations are provided by various third-party vendors. In the case of the Servlet Specification, the implementations are servlet containers. These containers can be standalone implementations such as the popular Apache Tomcat, or they can be containers embedded in some larger application server. They also run the gamut from open source to fully proprietary. If you’re unfamiliar with the Servlet Specification, we recommend reading it. It’s short, to the point, and well written.

Creating Struts2 application on Google App Engine (GAE)

whyjava — Sun, 30 Aug 2009 21:37:49 +0000

Why i am writing this blog?

I faced lot of problems while creating my first application using Struts 2 on Google App Engine . So i decided to write a blog detailing how developers can create their application on Struts2 by avoiding the problems that i faced while developing my application.

Note

If you want to do FileUpload using struts 2 on google app engine please refer to this post.

Prerequisites for starting Struts2 Application on Google App Engine

Before you start building your sample application on google app engine using struts 2 you will need the following:-

Google App Engine runs on java 5 and above so if necessary, download and install the Java SE Development Kit (JDK) for your platform and for mac users download and install the latest version.
In this example we will be using Eclipse as our ide. So if necessary, download eclipse and google app engine plugin for eclipse.You will also need to download the google java app engine SDK. For more information you can refer to installing the java SDK for google app engine.
Download the latest release of Struts2 framework.If you want to learn struts 2 a very good reference is struts 2 in action book.Please buy Struts 2 in Action.

Step by Step procedure to create Struts2 application on Google App Engine.

Step 1: Create a new project by clicking the New Web Application Project button in the toolbar.

Step 2 : Give the project name say login as we are going to create a simple login application. Enter package name as com.login and uncheck “Use Google Web Toolkit,” and ensure “Use Google App Engine” is checked and click the finish button.

Step3 : When you click the finish button you will get a sample HelloWorld application, which you can run going in the Run menu, select Run As > Web Application.By default application will run at port 8080, you can view the sample application at http://locahost:8080. For more information on the sample google web application created by the plugin you can refer to Google java app engine documentation .Please keep in mind that intent of this document is not to provide developers the overview of Google App engine for Java.

Step4 : By now you are ready with the google app engine infrastructure and we can move to the next step of creating a login application in Struts 2.

for creating a struts 2 application you will need to first add the required dependencies to the login project. The required struts 2 jars are below mentioned and you can find these jars in struts2 package you downloaded inside the lib folder :-
- commons-fileupload-1.2.1.jar
- commons-io-1.3.2.jar
- commons-logging-1.1.jar
- freemarker-2.3.13.jar
- ognl-2.6.11.jar
- struts2-core-2.1.6.jar
- xwork-2.1.2.jar
Add these dependencies in your eclipse java build path.

Add these dependencies in the war/WEB-INF/lib folder so that these jars gets deployed along with your application.

As you can see in the above image there are some warnings in the problems view like “commons-fileupload-1.2.1.jar’ will not be available on the server’s classpath” .To remove these warnings you need to right click on the project and select properties and then go to Google > web application and click the add button and add all the jars and then press ok.

First step in creating a struts 2 application is configuring the web.xml (deployment descriptor) which is located in WEB-INF folder.You can remove the servlet declaration from web.xml as we will not be needing this.We need to add the FilterDispatcher declaration in web.xml because in struts2 every request goes pass through FilterDispatcher which will invoke the appropriate action corresponding to the URL mapping.So our web.xml will look like :-

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

	version="2.5">
	<filter>
		<filter-name>struts2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
	</welcome-file-list>
</web-app>

To start we will be creating a jsp login page using struts 2 tag library and we will call login page from index.html.To call the login page there are two ways first, we can directly call the login.jsp page from link second, we can calling it through struts. We will be taking the second step as this will show you how to configure actions when you dont need to invoke any action.Lets first see how our login page and index.html will look like :-

index.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Struts2 on Google App Engine</title>
</head>

<body>
<h1>Struts2 on Google App Engine!</h1>
<table>
<tr>
<td colspan="2" style="font-weight: bold;">Available Application:</td>
</tr>
<tr>
<td><a href="/member/login" />Login</td>
</tr>
</table>
</body>
</html>

login.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Please login</title>
</head>
<body>
 <s:actionerror/>
 <s:form action="home" method="post">
 <s:textfield name="username" label="UserName"></s:textfield>
 <s:textfield name="password" label="Password"></s:textfield>
 <s:submit name="login" value="login"></s:submit>
 </s:form>
</body>
</html>

After creating the login.jsp we need to configure this as action in the struts.xml file which you be should put inside source folder parallel to log4j.properties file.We can configure action as mentioned below:-

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
	<include file="struts-default.xml"></include>
<package name="member" namespace="/member" extends="struts-default">
		<action name="login">
			<result>/login.jsp</result>
		</action>
	</package>
</struts>

Now try running this application by right click on project run as > web application and click http://localhost:8080. You will see index.html and when you click on login you will get this exception :-

SEVERE: Unable to set parameter [location] in result of type [org.apache.struts2.dispatcher.ServletDispatcherResult]

Caught OgnlException while setting property ‘location’ on type ‘org.apache.struts2.dispatcher.ServletDispatcherResult’. – Class: ognl.OgnlRuntime

File: OgnlRuntime.java

Method: invokeMethod

Line: 508 – ognl/OgnlRuntime.java:508:-1

at com.opensymphony.xwork2.ognl.OgnlUtil.internalSetProperty(OgnlUtil.java:392)

Caused by: java.lang.IllegalAccessException: Method [public void org.apache.struts2.dispatcher.StrutsResultSupport.setLocation(java.lang.String)] cannot be accessed.

at ognl.OgnlRuntime.invokeMethod(OgnlRuntime.java:508)

at ognl.OgnlRuntime.callAppropriateMethod(OgnlRuntime.java:812)

at ognl.OgnlRuntime.setMethodValue(OgnlRuntime.java:964)

at ognl.ObjectPropertyAccessor.setPossibleProperty(ObjectPropertyAccessor.java:75)

at ognl.ObjectPropertyAccessor.setProperty(ObjectPropertyAccessor.java:131)

at com.opensymphony.xwork2.ognl.accessor.ObjectAccessor.setProperty(ObjectAccessor.java:28)

at ognl.OgnlRuntime.setProperty(OgnlRuntime.java:1656)

at ognl.ASTProperty.setValueBody(ASTProperty.java:101)

at ognl.SimpleNode.evaluateSetValueBody(SimpleNode.java:177)

at ognl.SimpleNode.setValue(SimpleNode.java:246)

at ognl.Ognl.setValue(Ognl.java:476)

at com.opensymphony.xwork2.ognl.OgnlUtil.setValue(OgnlUtil.java:192)

at com.opensymphony.xwork2.ognl.OgnlUtil.internalSetProperty(OgnlUtil.java:385)

… 73 more

In order to resolve this problem we need to create an ServletContextListner which will set OGNL security manager to null when the context is initialized.

package com.login;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import ognl.OgnlRuntime;

public class OgnlListener implements ServletContextListener {

	@Override
	public void contextDestroyed(ServletContextEvent arg0) {
		// TODO Auto-generated method stub

	}

	@Override
	public void contextInitialized(ServletContextEvent arg0) {
		OgnlRuntime.setSecurityManager(null);
	}

}

Also we will need to make entry in web.xml file also for OgnlListener

	<listener>
	<listener-class>com.login.OgnlListener</listener-class>
</listener>

Now if you run the web application you will see the login page.
You need to add this step if you are using Google App Engine 1.2.6 because when you run struts2 application on google app engine 1.2.6 you will get the following error:-

To avoid this error you need to create a new package “freemarker.core” in your source folder and add the following class

</span></span>

/*
 * Copyright (c) 2003 The Visigoth Software Society. All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution, if
 *    any, must include the following acknowledgement:
 *       "This product includes software developed by the
 *        Visigoth Software Society (http://www.visigoths.org/)."
 *    Alternately, this acknowledgement may appear in the software
itself,
 *    if and wherever such third-party acknowledgements normally
appear.
 *
 * 4. Neither the name "FreeMarker", "Visigoth", nor any of the names
of the
 *    project contributors may be used to endorse or promote products
derived
 *    from this software without prior written permission. For written
 *    permission, please contact visigo...@visigoths.org.
 *
 * 5. Products derived from this software may not be called
"FreeMarker" or "Visigoth"
 *    nor may "FreeMarker" or "Visigoth" appear in their names
 *    without prior written permission of the Visigoth Software
Society.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE VISIGOTH SOFTWARE SOCIETY OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Visigoth Software Society. For more
 * information on the Visigoth Software Society, please see
 * http://www.visigoths.org/
 */

package freemarker.core;

import java.io.IOException;

/**
 * A TemplateElement representing a block of plain text.
 *
 * @version $Id: TextBlock.java,v 1.17 2004/01/06 17:06:42 szegedia Exp $
 */
public final class TextBlock extends TemplateElement {
 private static final char[] EMPTY_CHAR_ARRAY = new char[0];
 static final TextBlock EMPTY_BLOCK = new TextBlock(EMPTY_CHAR_ARRAY, false);
 // We're using char[] instead of String for storing the text block because
 // Writer.write(String) involves copying the String contents to a char[]
 // using String.getChars(), and then calling Writer.write(char[]).By
 // using Writer.write(char[]) directly, we avoid array copying on each
 // write.
 private char[] text;
 private final boolean unparsed;

 public TextBlock(String text) {
 this(text, false);
 }

 public TextBlock(String text, boolean unparsed) {
 this(text.toCharArray(), unparsed);
 }

 private TextBlock(char[] text, boolean unparsed) {
 this.text = text;
 this.unparsed = unparsed;
 }

 /**
 * Simply outputs the text.
 */
 public void accept(Environment env) throws IOException {
 env.getOut().write(text);
 }

 public String getCanonicalForm() {
 String text = new String(this.text);
 if (unparsed) {
 return "<#noparse>" + text + "</#noparse>";
 }
 return text;
 }

 public String getDescription() {
 String s = new String(text).trim();
 if (s.length() == 0) {
 return "whitespace";
 }
 if (s.length() > 20) {
 s = s.substring(0, 20) + "...";
 s = s.replace('\n', ' ');
 s = s.replace('\r', ' ');
 }
 return "text block (" + s + ")";
 }

 TemplateElement postParseCleanup(boolean stripWhitespace) {
 if (text.length == 0)
 return this;
 int openingCharsToStrip = 0, trailingCharsToStrip = 0;
 boolean deliberateLeftTrim = deliberateLeftTrim();
 boolean deliberateRightTrim = deliberateRightTrim();
 if (!stripWhitespace || text.length == 0) {
 return this;
 }
 if (parent.parent == null && previousSibling() == null)
 return this;
 if (!deliberateLeftTrim) {
 trailingCharsToStrip = trailingCharsToStrip();
 }
 if (!deliberateRightTrim) {
 openingCharsToStrip = openingCharsToStrip();
 }
 if (openingCharsToStrip == 0 && trailingCharsToStrip == 0) {
 return this;
 }
 this.text = substring(text, openingCharsToStrip, text.length
 - trailingCharsToStrip);
 if (openingCharsToStrip > 0) {
 this.beginLine++;
 this.beginColumn = 1;
 }
 if (trailingCharsToStrip > 0) {
 this.endColumn = 0;
 }
 return this;
 }

 /**
 * Scans forward the nodes on the same line to see whether there is a
 * deliberate left trim in effect. Returns true if the left trim was
 * present.
 */
 private boolean deliberateLeftTrim() {
 boolean result = false;
 for (TemplateElement elem = this.nextTerminalNode(); elem != null
 && elem.beginLine == this.endLine; elem = elem
 .nextTerminalNode()) {
 if (elem instanceof TrimInstruction) {
 TrimInstruction ti = (TrimInstruction) elem;
 if (!ti.left && !ti.right) {
 result = true;
 }
 if (ti.left) {
 result = true;
 int lastNewLineIndex = lastNewLineIndex();
 if (lastNewLineIndex >= 0 || beginColumn == 1) {
 char[] firstPart = substring(text, 0,
 lastNewLineIndex + 1);
 char[] lastLine = substring(text, 1 + lastNewLineIndex);
 if (trim(lastLine).length == 0) {
 this.text = firstPart;
 this.endColumn = 0;
 } else {
 int i = 0;
 while (Character.isWhitespace(lastLine[i])) {
 i++;
 }
 char[] printablePart = substring(lastLine, i);
 this.text = concat(firstPart, printablePart);
 }
 }
 }
 }
 }
 if (result) {
 }
 return result;
 }

 /**
 * Checks for the presence of a t or rt directive on the same line. Returns
 * true if the right trim directive was present.
 */
 private boolean deliberateRightTrim() {
 boolean result = false;
 for (TemplateElement elem = this.prevTerminalNode(); elem != null
 && elem.endLine == this.beginLine; elem = elem
 .prevTerminalNode()) {
 if (elem instanceof TrimInstruction) {
 TrimInstruction ti = (TrimInstruction) elem;
 if (!ti.left && !ti.right) {
 result = true;
 }
 if (ti.right) {
 result = true;
 int firstLineIndex = firstNewLineIndex() + 1;
 if (firstLineIndex == 0) {
 return false;
 }
 if (text.length > firstLineIndex
 && text[firstLineIndex - 1] == '\r'
 && text[firstLineIndex] == '\n') {
 firstLineIndex++;
 }
 char[] trailingPart = substring(text, firstLineIndex);
 char[] openingPart = substring(text, 0, firstLineIndex);
 if (trim(openingPart).length == 0) {
 this.text = trailingPart;
 this.beginLine++;
 this.beginColumn = 1;
 } else {
 int lastNonWS = openingPart.length - 1;
 while (Character.isWhitespace(text[lastNonWS])) {
 lastNonWS--;
 }
 char[] printablePart = substring(text, 0, lastNonWS + 1);
 if (trim(trailingPart).length == 0) {
 // THIS BLOCK IS HEINOUS! THERE MUST BE A BETTER
 // WAY! REVISIT (JR)
 boolean trimTrailingPart = true;
 for (TemplateElement te = this.nextTerminalNode(); te != null
 && te.beginLine == this.endLine; te = te
 .nextTerminalNode()) {
 if (te.heedsOpeningWhitespace()) {
 trimTrailingPart = false;
 }
 if (te instanceof TrimInstruction
 && ((TrimInstruction) te).left) {
 trimTrailingPart = true;
 break;
 }
 }
 if (trimTrailingPart)
 trailingPart = EMPTY_CHAR_ARRAY;
 }
 this.text = concat(printablePart, trailingPart);
 }
 }
 }
 }
 return result;
 }

 /*
 * private String leftTrim(String s) { int i =0; while (i<s.length()) { if
 * (!Character.isWhitespace(s.charAt(i))) break; ++i; } return
 * s.substring(i); }
 */
 private int firstNewLineIndex() {
 String content = new String(text);
 int newlineIndex1 = content.indexOf('\n');
 int newlineIndex2 = content.indexOf('\r');
 int result = newlineIndex1 >= 0 ? newlineIndex1 : newlineIndex2;
 if (newlineIndex1 >= 0 && newlineIndex2 >= 0) {
 result = Math.min(newlineIndex1, newlineIndex2);
 }
 return result;
 }

 private int lastNewLineIndex() {
 String content = new String(text);
 return Math.max(content.lastIndexOf('\r'), content.lastIndexOf('\n'));
 }

 /**
 * figures out how many opening whitespace characters to strip in the
 * post-parse cleanup phase.
 */
 private int openingCharsToStrip() {
 int newlineIndex = firstNewLineIndex();
 if (newlineIndex == -1 && beginColumn != 1) {
 return 0;
 }
 ++newlineIndex;
 if (text.length > newlineIndex) {
 if (newlineIndex > 0 && text[newlineIndex - 1] == '\r'
 && text[newlineIndex] == '\n') {
 ++newlineIndex;
 }
 }
 if (new String(text).substring(0, newlineIndex).trim().length() > 0) {
 return 0;
 }
 // We look at the preceding elements on the line to see if we should
 // strip the opening newline and any whitespace preceding it.
 for (TemplateElement elem = this.prevTerminalNode(); elem != null
 && elem.endLine == this.beginLine; elem = elem
 .prevTerminalNode()) {
 if (elem.heedsOpeningWhitespace()) {
 return 0;
 }
 }
 return newlineIndex;
 }

 /**
 * figures out how many trailing whitespace characters to strip in the
 * post-parse cleanup phase.
 */
 private int trailingCharsToStrip() {
 String content = new String(text);
 int lastNewlineIndex = lastNewLineIndex();
 if (lastNewlineIndex == -1 && beginColumn != 1) {
 return 0;
 }
 String substring = content.substring(lastNewlineIndex + 1);
 if (substring.trim().length() > 0) {
 return 0;
 }
 // We look at the elements afterward on the same line to see if we
 // should strip any whitespace after the last newline
 for (TemplateElement elem = this.nextTerminalNode(); elem != null
 && elem.beginLine == this.endLine; elem = elem
 .nextTerminalNode()) {
 if (elem.heedsTrailingWhitespace()) {
 return 0;
 }
 }
 return substring.length();
 }

 boolean heedsTrailingWhitespace() {
 if (isIgnorable()) {
 return false;
 }
 for (int i = 0; i < text.length; i++) {
 char c = text[i];
 if (c == '\n' || c == '\r') {
 return false;
 }
 if (!Character.isWhitespace(c)) {
 return true;
 }
 }
 return true;
 }

 boolean heedsOpeningWhitespace() {
 if (isIgnorable()) {
 return false;
 }
 for (int i = text.length - 1; i >= 0; i--) {
 char c = text[i];
 if (c == '\n' || c == '\r') {
 return false;
 }
 if (!Character.isWhitespace(c)) {
 return true;
 }
 }
 return true;
 }

 boolean isIgnorable() {
 if (text == null || text.length == 0) {
 return true;
 }
 if (!isWhitespace()) {
 return false;
 }
 // trick here
 boolean atTopLevel = true;
 TemplateElement prevSibling = previousSibling();
 TemplateElement nextSibling = nextSibling();
 return ((prevSibling == null && atTopLevel) || nonOutputtingType(prevSibling))
 && ((nextSibling == null && atTopLevel) || nonOutputtingType(nextSibling));
 }

 private boolean nonOutputtingType(TemplateElement element) {
 return (element instanceof Macro || element instanceof Assignment
 || element instanceof AssignmentInstruction
 || element instanceof PropertySetting
 || element instanceof LibraryLoad || element instanceof Comment);
 }

 private static char[] substring(char[] c, int from, int to) {
 char[] c2 = new char[to - from];
 System.arraycopy(c, from, c2, 0, c2.length);
 return c2;
 }

 private static char[] substring(char[] c, int from) {
 return substring(c, from, c.length);
 }

 private static char[] trim(char[] c) {
 if (c.length == 0) {
 return c;
 }
 return new String(c).trim().toCharArray();
 }

 private static char[] concat(char[] c1, char[] c2) {
 char[] c = new char[c1.length + c2.length];
 System.arraycopy(c1, 0, c, 0, c1.length);
 System.arraycopy(c2, 0, c, c1.length, c2.length);
 return c;
 }

 boolean isWhitespace() {
 return text == null || trim(text).length == 0;
 }

}

Next step is to create the LoginAction which will be do the business processing of whether usename and password are correct .

package com.login;

import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport {

	private static final long serialVersionUID = 1L;
	private String username;
	private String password;

	public String login(){
		if(username.equals("whyjava") && password.equals("password")){
			addActionMessage("You are successfully logged in.");
			return SUCCESS;
		}
		addActionError("Username and Password Combination doesnot match.");
		return INPUT;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

}

Next we need to modify struts.xml so that we LoginAction is configured.

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
	<include file="struts-default.xml"></include>
<package name="member" namespace="/member" extends="struts-default">
		<action name="login">
			<result>/login.jsp</result>
		</action>
		<action name="home" method="login" class="com.login.LoginAction">
			<result>/home.jsp</result>
			<result name="input">/login.jsp</result>
		</action>
	</package>
</struts>

finally we need to add one more jsp which is home.jsp which will be called when user is able to successfully login.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Home Page</title>
</head>
<body>
<s:actionmessage />

</body>
</html>

Now try running this application by right click on project run as > web application and click http://localhost:8080.

Now click on the login link you will be taken to the login page

Now enter username as whyjava and password as password you will be an struts 2 action will fire and you will be taken to the home page.

I have tried to cover all the steps you will need to start of your first struts 2 project. Hope you all find this post useful.

If you need to start learning struts2 you can read Struts 2 in Action. It is a very good book to get a very good understanding of all the struts 2 concepts.

EJB 3.0 and Struts2

hlinski — Mon, 24 Aug 2009 16:06:00 +0000

Задался вопросом, каким образом EJB 3.0 уживаются с таким фрэймворком как Struts2. Насколько мне известно, анатация @EJB работает только в объектах управляемых контейнером. Как же получить что-то подобное в struts action? Google Guice -один из ответов. Это IoC легковесный контейнер от Google. Вот не плохая статья. Для примера использую Eclipse Galileo for J2EE и Geronimo 2.1.4 on Jetty. Для начала нужно установить плагин для Geronimo.

Нужны следующие jar:

commons-fileupload-1.2.1.jar
commons-logging-1.0.4.jar
freemarker-2.3.13.jar
ognl-2.6.11.jar
struts2-core-2.1.6.jar
xwork-2.1.2.jar
guice-struts2-plugin-1.0.1.jar
guice-1.0.jar
guice-servlet-1.0.jar

Создаём EAR приложение, EJB проект и WEB проект:

Создаём Stateless Session Bean и бизнесс интерфейсы, можно только Local

Создаём struts.xml

<?xml version=”1.0″ encoding=”UTF-8″ ?>
<!DOCTYPE struts PUBLIC
“-//Apache Software Foundation//DTD Struts Configuration 2.0//EN”
“http://struts.apache.org/dtds/struts-2.0.dtd”>
<struts>
<constant name=”struts.enable.DynamicMethodInvocation” value=”false” />
<constant name=”struts.devMode” value=”false” />

<!– Use Guice as the ObjectFactory for this application –>
<constant name=”struts.objectFactory” value=”guice” />
<!– When wiring actions use Guice bindings defined in the below module –>
<constant name=”guice.module” value=”com.store.module.EJBModule”/>

<package name=”store” extends=”struts-default”>
<action name=”saveItem”>
<result>/result.html</result>
</action>
<!– Add more actions here –>
</package>
</struts>

Solving the UI Framework Puzzle

winstond — Wed, 19 Aug 2009 14:02:49 +0000

I was recently tasked to recommend and specify components of a thin client architecture for a large web-based application (1000+ views!). It had to be Java-based, so the first obvious questions that sprung-up were -

– What is best way to build such a large web aplication in Java ?….which in turn can be broken down into -
          - What are the best frameworks available in the world today that facilitate web-app development?…which in turn can be broken down into -
                 – Which framework is most suitable in terms of technical, functional & commercial criteria? — clearly each of these 3 criteria classes can further be exploded into detailed independant heirarchies.
                 – Which framework will result in code/artifacts that are well-factored & maintenable.
                 – Which framework will support well-known Usability patterns.

       – What development methodology will be most suitable?….which can further be broken down into -
              - Which framework will guarantee high levels of productivity…which can further be broken down into -
                   - Which framework/tool(set) supports a clean separation of and smooth hand-offs of UI design & coding concerns?….which can further be broken down into -
                            – Which framework will allow parallelism of work-streams?

So, simply put, one just needs to pick out the best “techno-functional-commercial” framework out there that also ensures that the application is delivered at an acceptable cost !

Sounds simple?…hmmm maybe yes, if one had to choose only from say 2 or 3 UI frameworks and, if it were year 2001 !
Today if one scans the Internet for UI frameworks, the information found can be overwhelming and quite difficult to effectively navigate through. The UI framework puzzle as it were, also is a rather pertinent question, as seen from the number of google searches people have made on key words such as
  - “ui frameworks comparison” – 5.19 million.
  - “ui frameworks” – 5.8 million.
  - “ui framework java” – 1.76 million.

So here’s a first hand account of an approach that can help one solve the UI framework puzzle. Mind you, there is no one single “best” solution; there’s only what is most suitable & acceptable for a given need, with the (relative ) peace of mind that you have (wisely) considered and understood the rationale for all the choices you have made & not made!

I use an age old principle of dealing with complexity/information overload – “Abstraction”.

To quote Wikipedia – “Abstraction is the process or result of generalization by reducing the information content of a concept or an observable phenomenon, typically to retain only information which is relevant for a particular purpose”.

Following this principle one can easily derive a few “UI Framework Abstractions” and start placing/sorting available frameworks/toolkits/technologies into these “Abstraction buckets”. So here goes..

1. Web 1.0 Technologies (JavaScript, DOM, HTML & CSS)
These address client-side need only. This is essentially the pre-2004 way of building Web applications, featured by -
- Open standards
- No asynchronous calls and as a result – complete page refresh.
- No rich widget library.
- Requires a good server-side MVC framework as described in point 5 below.
2. Lightweight Ajax Toolkits
Again, these address client-side need only. Ajax is not a technology in itself, rather a group of technologies such as HTML, CSS, Javascript, DOM, XML, JSON and a method for exchanging data asynchronously between browser and server, thereby avoiding complete page reloads. Key features of this framework type are:

- Ajax applied correctly, increases Responsiveness of the application by avoiding complete page refreshes.
- It is based on open standards mentioned above.
- It usually provides a rich widget library, and if not, may combine with other widget libraries.
- Screen developers code in HTML & JavaScript with API support for widgets and data exchange via asynchronous server calls.
- Requires a good server-side MVC framework as described in point 5 below.

The popular ones are:
- Dojo
- Yahoo UI
- Ext-JS
- jQuery
- MooTools
- Prototype + Scriptaculous

3. Java Component-based Ajax Toolkits
These address both Client & Server side needs. These frameworks have essentially adapted the Java Swing or Eclipse SWT programming model to the Web. They differ from Lightweight Ajax Toolkit in that -

- The development language is Java. Developers need to code HTML, Javascript only in exceptional cases.
- The framework compiles screen layout & behaviour code written in Java, to Javascript rendered by the browser.
- Server-side application development is also framework driven. No need for a separate server-side MVC framework.
- It usually provides a rich widget library, and if not, may combine with other widget libraries.

The popular ones are:
- GWT (Ext)
- Ext-GWT
- Echo3
- Apache Wicket

4. RIA Toolkits
These address both Client & Server side needs. These are complete Web application toolkits promoted by companies such as Adobe, Microsoft & Sun. Their USP is rich internet applications using rapid development tools. Other key features are:
- It requires a runtime interpreter to be installed as a plug-in within each browser.
- It is usually based on custom scripting and layout languages and data exchange formats.
- Framework drives development of both client & server-side application components. No need for separate MVC server-side framework.

The popular ones are:
- Flex (Cairngorm + BlazeDS)
- JavaFx
- Silverlight

5. Server-side-only UI Frameworks
These address server-side need only. This is a basket of frameworks that not only aid the development of application components that accept and process a web request, but also aggregate and render page views back to the browser. They are meant to be used in conjunction with Lightweight Ajax Toolkits OR Web 1.0 Technologies. The popular ones are:
- Struts2
- Spring MVC & Webflow
- JSF
- Seam Framework
- Tapestry
- Stripes

Some of the popular Scripting language based frameworks -
- Ruby On Rails
- Grails

5A. View Technology
Though this is essentially a Server-side framework/component and represents the ‘V’ part of a MVC framework, it deserves a separate section of its own on account of the varied choices available in this area too. The key responsibility of View technology is to manage dynamic web content. This could involve say completely dynamic HTML generation or merge dynamic content with static HTML+Javascript.

The popular View Technologies are:
- JSP (Java Server Pages) + JSTL (JSP Standard Tag Library)
- Velocity & Freemarker (Templating Engine)
- XSLT (Xml –> Html)

5Aa.View Aggregation Technology
This is essentially a web-page layout and decoration framework that provides a consistent look and feel, navigation and layout scheme. It works on top of any of the View technologies mentioned in 5A.
- Site Mesh
- Tiles

This throws up a number of interesting combinations or styles from an architecture perspective. Some of the valid ones are:

A. Traditional & Conservative – (1) Web 1.0 tech + (5) Server-side-only UI Frameworks

B. Modern yet Conservative – (2) Lightweight Ajax Toolkits + (5) Server-side-only UI Frameworks

C. Modern & Not-so-conservative – (3) Java Component-based Ajax Toolkits

D. Modern & Cutting-edge – (4) RIA Toolkits

So which one combination/style do I choose? Or can I make 2 choices? What are the trade-offs I need to be aware of when I make a choice? Will a particular style help acheive my GOAL (heirarchy)? Soul-searching questions, right?

The level of abstraction that we are dealing in, can only help so far as to eliminate or put aside “Styles”, one is not “comfortable” with. For example:

- Style A is probably totally superceded by other styles and one really should look at modernizing with changing times.

- Some of us may “feel”, Style C is actually a Leap-of-Faith – As a general practice, how can you expect me NOT to touch Javascript & HTML, basically I don’t trust the Java-to-Javascript compiler well enough to handle all things that I have done all these years with DHTML. This may gravitate one to the slightly conservative Style B, though one would lose out on Style C’s BIG benefit of fine-grained componentization of UI element layout & behaviour, coded in Java language itself. Debugging, re-factoring & code maintenance is so much better with a strongly typed language like Java than Javascript and mind you, as a rough estimate, in a large enterprise business application, atleast 35% effort goes into UI layer development, and within that atleast 70% goes into screen layout and behaviour development.

- Some of us may not want to surrender to proprietory (licensed) IDE driven approach of Style D, since one would really need to use the IDE to reap the productivity benefits espoused by it. However, the richness in UI features offered by RIA Toolkits is much greater than that offered by any of the other Styles and that alone may favour Style D, especially if your competitor’s product already offers it.

- Style B is kind-of-a small evolutionary step forward, which I think most Enterprises would prefer for their back-office applications. It has many more moving parts than any of the other Styles and there are a number of sub-combinations possible within Style B itself. Still, it is the most robust on account of reliance on time-tested design patterns. A BIG issue that creeps up gradually especially in case of large applications is the “Javascript Mayhem”. Simply too much gets written and quickly becomes unweildy and unmanageble, duplication across number of screens and difficult to change, test & refactor. All is not lost on this front though. Upfront thought and effort can be put to struture Javascript usage in a Object oriented fashion. Here are some links:
            http://www.amazon.com/Object-Oriented-JavaScript-high-quality-applications-libraries/dp/1847194141
            http://my.safaribooksonline.com/9781590599082
            http://www.webreference.com/programming/javascript/ncz/column5/
            http://www.jsunit.net/

So there we have it, a few architectural styles to choose from. There may be more, please do share your thoughts & comments. Once you’ve chosen a style, the next step is the evaluation of frameworks within a Style say between Dojo & YUI or Struts 2 & Spring MVC or GWT & Wicket. The internet is abound with such comparisons and one should back it up with PoCs of her own. Here are some links:

http://en.wikipedia.org/wiki/Comparison_of_JavaScript_frameworks
http://www.oreillynet.com/onjava/blog/2008/03/spring_mvc_javafx_google_web_t.html

xxx

Framework MCV Para Java -Struts2

Maik Guerra — Sun, 28 Jun 2009 19:55:38 +0000

Struts 2

Los frameworks pueden ser vistos como implementaciones de patrones de diseño que facilitan la reutilización de diseño y código.

Apache Struts es una de estas frameworks

Creada por Craig McClanahan y donada a la Apache Software Foundation en el 2000 .

Provee librería de clases y TAG-LIBS que conforman el Controlador, la integración con el Modelo (o lógica de negocio) y facilitan la construcción de vistas.

Struts ofrece su propio componente controlador y proporciona integración con otras tecnologías para implementar el modelo, mediante tecnologías de acceso a datos como JDBC, y la vista, mediante JSP o XSLT. Además ofrece un sistema de tuberías que permite la comunicación entre el modelo que contiene los datos y las vistas que ofrecen estos datos a los usuarios y reciben sus órdenes.

Struts 2 está basado en el patrón MVC (Modelo-Vista-Controlador), una arquitectura que busca reducir el acoplamiento dividiendo las responsabilidades en 3 capas:

El modelo, que hace referencia a los datos que maneja la aplicación y las reglas de negocio que operan sobre ellos. Se traducen en las Acciones.

La vista, encargada de generar la interfaz con la que la aplicación interacciona con el usuario. Equivale a los Resultados.

El controlador, que comunica la vista y el modelo respondiendo a eventos generados por el usuario en la vista, invocando cambios en el modelo, y devolviendo a la vista la información del modelo necesaria para que pueda generar la respuesta adecuada para el usuario. Se implementa mediante el filtro FilterDispatcher.

Como Actúa el Framework Struts en una aplicacion Web

En relacion con el Framework Sprin MVC, los dos tienden a tener las mismas formas de programarlo en la forma como lo veo.

Solo lo que cambian serian los metodos o sentencias de una a la otra.

Flex with Struts 2 with Source

niamathbasha — Fri, 26 Jun 2009 04:53:19 +0000

In my previous post (http://niamathbasha.wordpress.com/2008/09/01/configuring-struts-2-with-flex/) I

Struts2 File Upload

truongngh — Thu, 25 Jun 2009 11:26:10 +0000

The Struts 2 framework provides built-in support for processing file uploads that conform to RFC 1867, “Form-based File Upload in HTML”. When correctly configured the framework will pass uploaded file(s) into your Action class. Support for individual and multiple file uploads are provided. When a file is uploaded it will typically be stored in a temporary directory. Uploaded files should be processed or moved by your Action class to ensure the data is not lost. Be aware that servers may have a security policy in place that prohibits you from writing to directories other than the temporary directory and the directories that belong to your web application.

Dependencies

The Struts 2 framework leverages add-on libraries to handle the parsing of uploaded files. These libraries are not included in the Struts distribution, you must add them into your project. The libraries needed are:

Library	URL	Struts 2.0.x	Struts 2.1.x
Commons-FileUpload	http://commons.apache.org/fileupload/	1.1.1	1.2.1
Commons-IO	http://commons.apache.org/io/	1.0	1.3.2

If you are using Maven then you can add these libraries as dependencies in your project’s pom.xml.

Struts 2.0.x File Upload Dependencies

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.1.1</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>1.0</version>
</dependency>

Struts 2.1.x File Upload Dependencies

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.2.1</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>1.3.2</version>
</dependency>

Basic Usage

The org.apache.struts2.interceptor.FileUploadInterceptor class is included as part of the defaultStack. As long as the required libraries are added to your project you will be able to take advantage of of the Struts 2 fileUpload capability. Configure an Action mapping for your Action class as you typically would.

Example action mapping:

<action name="doUpload" class="com.example.UploadAction">
    <result name="success">good_result.jsp</result>
</action>

A form must be create with a form field of type file, <INPUT type="file" name="upload">. The form used to upload the file must have its encoding type set to multipart/form-data, <FORM action="doUpload" enctype="multipart/form-data" method="post">. The standard procedure for adding these elements is by using the Struts 2 tag libraries as shown in the following example:

Example JSP form tags:

<s:form action="doUpload" method="post" enctype="multipart/form-data">
    <s:file name="upload" label="File"/>
<s:submit/></s:form>

The fileUpload interceptor will use setter injection to insert the uploaded file and related data into your Action class. For a form field named upload you would provide the three setter methods shown in the following example:

Example Action class:

package com.example;
import java.io.File;   import com.opensymphony.xwork2.ActionSupport;

public UploadAction extends ActionSupport {
    private File file;
    private String contentType;
    private String filename;

      public void setUpload(File file) {         this.file = file;      }

      public void setUploadContentType(String contentType) {         this.contentType = contentType;      }

      public void setUploadFileName(String filename) {         this.filename = filename;      }

      public String execute() {         //...         return SUCCESS;      }
}

The purpose of each one of these methods is described in the table below. Notice that if you have multiple file form elements with different names you would be required to have another corresponding set of these methods for each file uploaded.

Method Signature	Description
setX(File file)	The file that contains the content of the uploaded file. This is a temporary file and `file.getName()` will not return the original name of the file
setXContentType(String contentType)	The mime type of the uploaded file
setXFileName(String fileName)	The actual file name of the uploaded file (not the HTML name)

Uploading Multiple Files

As mentioned in the previous section one technique for uploading multiple files would be to simply have multiple form input elements of type file all with different names. This would require a number of setter methods that was equal to 3 times the number of files being uploaded. Another option is to use Arrays or java.util.Lists. The following examples are taken from the Showcase example application that is part sample applications you can download at http://struts.apache.org/download.cgi. For the Action mapping details see struts-fileupload.xml in the sample application download.

Uploading Multiple Files using Arrays

multipleUploadUsingArray.jsp Notice all file input types have the same name.

<%@ page	language="java"	contentType="text/html; charset=UTF-8"    pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
<title>Showcase - fileupload - multiple fileupload using List</title>
</head>
<body>

<s:form action="doMultipleUploadUsingArray" method="POST" enctype="multipart/form-data">
    <s:file label="File (1)" name="upload" />
    <s:file label="File (2)" name="upload" />
    <s:file label="FIle (3)" name="upload" />
    <s:submit />
</s:form>

</body>
</html>

MultipleFileUploadUsingArrayAction.java

package org.apache.struts2.showcase.fileupload;

import java.io.File;

import com.opensymphony.xwork2.ActionSupport;

/** * Showcase action - mutiple file upload using array. * * @version $Date$ $Id$ */public class MultipleFileUploadUsingArrayAction extends ActionSupport {

    private File[] uploads;    private String[] uploadFileNames;    private String[] uploadContentTypes;

    public File[] getUpload() { return this.uploads; }    public void setUpload(File[] upload) { this.uploads = upload; }

    public String[] getUploadFileName() { return this.uploadFileNames; }
    public void setUploadFileName(String[] uploadFileName) { this.uploadFileNames = uploadFileName; }

    public String[] getUploadContentType() { return this.uploadContentTypes; }
    public void setUploadContentType(String[] uploadContentType) { this.uploadContentTypes = uploadContentType; }

    public String upload() throws Exception {
        System.out.println("\n\n upload2");
        System.out.println("files:");
        for (File u: uploads) {    System.out.println("*** "+u+"\t"+u.length());        }
        System.out.println("filenames:");
        for (String n: uploadFileNames) {    System.out.println("*** "+n);        }
        System.out.println("content types:");
        for (String c: uploadContentTypes) {    System.out.println("*** "+c);        }
        System.out.println("\n\n");
        return SUCCESS;
    }
}

Uploading Multiple Files using Lists

multipleUploadUsingList.jsp Notice all file input types have the same name.

<%@ page	language="java"	contentType="text/html; charset=UTF-8"    pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
<title>Showcase - fileupload - multiple fileupload using List</title>
</head>
<body>

<s:form action="doMultipleUploadUsingList" method="POST" enctype="multipart/form-data">
<s:file label="File (1)" name="upload" />
 <s:file label="File (2)" name="upload" />
 <s:file label="FIle (3)" name="upload" />
 <s:submit />
</s:form>

</body>
</html>

MultipleFileUploadUsingListAction.java

package org.apache.struts2.showcase.fileupload;import java.io.File;import java.util.ArrayList;import java.util.List;

import com.opensymphony.xwork2.ActionSupport;

/** * Showcase action - multiple file upload using List
 * @version $Date$ $Id$
 */
public class MultipleFileUploadUsingListAction extends ActionSupport {

    private List<File> uploads = new ArrayList<File>();
    private List<String> uploadFileNames = new ArrayList<String>();
    private List<String> uploadContentTypes = new ArrayList<String>();

    public List<File> getUpload() {        return this.uploads;    }
    public void setUpload(List<File> uploads) {        this.uploads = uploads;    }

    public List<String> getUploadFileName() {        return this.uploadFileNames;    }
    public void setUploadFileName(List<String> uploadFileNames) {        this.uploadFileNames = uploadFileNames;    }

    public List<String> getUploadContentType() {        return this.uploadContentTypes;    }
    public void setUploadContentType(List<String> contentTypes) {        this.uploadContentTypes = contentTypes;    }

    public String upload() throws Exception {

        System.out.println("\n\n upload1");
        System.out.println("files:");
        for (File u: uploads) {            System.out.println("*** "+u+"\t"+u.length());        }
        System.out.println("filenames:");
        for (String n: uploadFileNames) {            System.out.println("*** "+n);        }
        System.out.println("content types:");
        for (String c: uploadContentTypes) {            System.out.println("*** "+c);        }
        System.out.println("\n\n");        return SUCCESS;
    }
}

Advanced Configuration

The Struts 2 default.properties file defines several settings that affect the behavior of file uploading. You may find in necessary to change these values. The names and default values are:

struts.multipart.parser=jakarta
struts.multipart.saveDir=
struts.multipart.maxSize=2097152

In order to change theses settings you define a constant in your applications struts.xml file like so:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
                        "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
     <constant name="struts.multipart.maxSize" value="1000000" />
 ...
</struts>

Additionally the fileUpload interceptor has settings that can be put in place for individual action mappings by customizing your interceptor stack.

<action name="doUpload" class="com.example.UploadAction">
    <interceptor-ref name="basicStack"/>
    <interceptor-ref name="fileUpload">
        <param name="allowedTypes">text/plain</param>
    </interceptor-ref>
    <interceptor-ref name="validation"/>
    <interceptor-ref name="workflow"/>

    <result name="success">good_result.jsp</result>
</action>

File Size Limits

There are two separate file size limits. First is struts.multipart.maxSize which comes from the Struts 2 default.properties file. This setting exists for security reasons to prohibit a malicious user from uploading extremely large files to file up your servers disk space. This setting defaults to approximately 2 megabytes and should be adjusted to the maximum size file (2 gigs max) that your will need the framework to receive. If you are uploading more than one file on a form the struts.multipart.maxSize applies to the combined total, not the individual file sizes. The other setting, maximumSize, is an interceptor setting that is used to ensure a particular Action does not receive a file that is too large. Notice the locations of both settings in the following example:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC	"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
                        "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <constant name="struts.multipart.maxSize" value="1000000" />

    <action name="doUpload" class="com.example.UploadAction">
        <interceptor-ref name="basicStack"/>
        <interceptor-ref name="fileUpload">
            <param name="maximumSize">500000</param>
        </interceptor-ref>
        <interceptor-ref name="validation"/>
        <interceptor-ref name="workflow"/>

        <result name="success">good_result.jsp</result>
    </action>
</struts>

File Types

There are two ways to limit the uploaded file type, declaratively and programmatically. To declaratively limit the file type a comma separated list of allowedTypes can be specified as a fileUpload interceptor param as shown in the following example:

<action name="doUpload" class="com.example.UploadAction">
    <interceptor-ref name="basicStack"/>
    <interceptor-ref name="fileUpload">
        <param name="allowedTypes">image/jpeg,image/gif</param>
    </interceptor-ref>
    <interceptor-ref name="validation"/>
    <interceptor-ref name="workflow"/>

    <result name="success">good_result.jsp</result>
</action>

When the uploaded file type does not match one of the MIME types specified a field error will be created as described in the next section entitled Error Messages. Programmatically limiting the file type means using the information passed in to your Action class via the setXContentType(String contentType) method. The benefit to this type of approach would be that it’s more flexible and no interceptor configuration would be needed if file sizes are keep under 2 megs.

Error Messages

If an error occurs several field errors will be added assuming that the action implements com.opensymphony.xwork2.ValidationAware or extends com.opensymphony.xwork2.ActionSupport. These error messages are based on several i18n values stored in struts-messages.properties, a default i18n file processed for all i18n requests. You can override the text of these messages by providing text for the following keys:

Error Key	Description
struts.messages.error.uploading	A general error that occurs when the file could not be uploaded
struts.messages.error.file.too.large	Occurs when the uploaded file is too large as specified by maximumSize.
struts.messages.error.content.type.not.allowed	Occurs when the uploaded file does not match the expected content types specified

Temporary Directories

All uploaded files are saved to a temporary directory by the framework before being passed in to an Action. Depending on the allowed file sizes it may be necessary to have the framework store these temporary files in an alternate location. To do this change struts.multipart.saveDir to the directory where the uploaded files will be placed. If this property is not set it defaults to javax.servlet.context.tempdir. Keep in mind that on some operating systems, like Solaris, /tmp is memory based and files stored in that directory would consume an amount of RAM approximately equal to the size of the uploaded file.

Alternate Libraries

The struts.multipart.parser used by the fileUpload interceptor to handle HTTP POST requests, encoded using the MIME-type multipart/form-data, can be changed out. Currently there are two choices, jakarta and pell. The jakarta parser is a standard part of the Struts 2 framework needing only its required libraries added to a project. The pell parser uses Jason Pell’s multipart parser instead of the Commons-FileUpload library. The pell parser is a Struts 2 plugin, for more details see: http://cwiki.apache.org/S2PLUGINS/pell-multipart-plugin.html. There was a third alternative, cos, but it was removed due to licensing incompatibilities.

Source: http://struts.apache.org/2.0.14/docs/file-upload.html

Struts 2 File Upload

truongngh — Mon, 15 Jun 2009 07:09:09 +0000

In this section you will learn how to write program in Struts 2 to upload the file on the server. In this example we are also providing the code to save the uploaded file in any directory on the server machine.

The Struts 2 FileUpload component can be used to upload the multipart file in your Struts 2 application. In this section you will learn about the code to upload file on the server.

How File Upload Works in Struts 2?

Struts 2 utilizes the service of File Upload Interceptor to add the support for uploading files in the Struts applications. The Struts 2 File Upload Interceptor is based on MultiPartRequestWrapper, which is automatically applied to the request if it contains the file element. Then it adds the following parameters to the request (assuming the uploaded file name is MyFile).

[MyFile] : File – the actual File
[MyFile]ContentType : String – the content type of the file
[File Name]FileName : String – the actual name of the file uploaded (not the HTML name)

In the action class you can get the file, the uploaded file name and content type by just creating getter and setters. For example, setMyfile(File file), setMyFileContentType(String contentType), getMyFile(), etc..

//
//

The file upload interceptor also does the validation and adds errors, these error messages are stored in the struts-messsages.properties file. The values of the messages can be overridden by providing the text for the following keys:

struts.messages.error.uploading – error when uploading of file fails
struts.messages.error.file.too.large – error occurs when file size is large
struts.messages.error.content.type.not.allowed – when the content type is not allowed

Parameters

You can use the following parameters to control the file upload functionality.

maximumSize This parameter is optional. The default value of this is 2MB.
allowedTypes This parameter is also optional. It allows you to specify the allowed content type.

Writing Example code to upload file

Now we will write the code to upload the file on server.

Action Class

In the action class we will define four properties to facilitate the file upload.

private File upload; // The actual file

private String uploadContentType;// The content type of the file

private String uploadFileName;// The uploaded file name and path

private String fileCaption;// The caption of the file entered by user.

Here is the full code of action class StrutsFileUpload.java

 package net.roseindia;

import java.util.Date;

import java.io.File;

import com.opensymphony.xwork2.ActionSupport;

public class StrutsFileUpload extends ActionSupport {

 

 private File upload;//The actual file

 private String uploadContentType; //The content type of the file

 private String uploadFileName; //The uploaded file name

 private String fileCaption;//The caption of the file entered by user

 public String execute() throws Exception {
 return SUCCESS;
 }

 public String getFileCaption() {

 return fileCaption;

 }

 public void setFileCaption(String fileCaption) {

 this.fileCaption = fileCaption;

 }

 public File getUpload() {

 return upload;

 }

 public void setUpload(File upload) {

 this.upload = upload;

 }

 public String getUploadContentType() {

 return uploadContentType;

 }

 public void setUploadContentType(String uploadContentType) {

 this.uploadContentType = uploadContentType;

 }

 public String getUploadFileName() {

 return uploadFileName;

 }

 public void setUploadFileName(String uploadFileName) {

 this.uploadFileName = uploadFileName;

 }

}

Here we have not shown the code to save the uploaded file. But it can be done easily using the following code in execute(..) method of action class. Here is code snippet.

//Following code can be used to save the uploaded file

try {

String fullFileName = “c:/upload/myfile.txt”;

File theFile = new File(fullFileName);

FileUtils.copyFile(upload, theFile);

} catch (Exception e) {

addActionError(e.getMessage());

return INPUT;

}

Writing JSP page

Here is the code of jsp file (upload.jsp) that displays the file upload form to the user.

<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>File Upload Example</title>
<link href=”<s:url value=”/css/main.css”/>” rel=”stylesheet” type=”text/css”/>

</head>

<body>

<s:actionerror />
<s:fielderror />
<s:form action=”doUpload” method=”POST” enctype=”multipart/form-data“>
<tr>
<td colspan=”2″><h1>File Upload Example</h1></td>
</tr>

<s:file name=”upload” label=”File”/>
<s:textfield name=”caption” label=”Caption”/>
<s:submit />
</s:form>
</body>
</html>

In the above code the form encrypt type is “multipart/form-data” and <s:file ../> tag renders the html file tag.

File upload success page

Here is the code of file upload(upload-success.jsp) success page.

<%@ page
language=”java”
contentType=”text/html; charset=UTF-8″
pageEncoding=”UTF-8″%>
<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>Showcase</title>
<link href=”<s:url value=”/css/main.css”/>” rel=”stylesheet” type=”text/css”/>
</head>

<td colspan=”2″><h1>File Upload Example</h1></td>
</tr>

<tr>
<td><label for=”doUpload_upload”>Content Type:</label></td>
<td><s:property value=”uploadContentType” /></td>
</tr>

<tr>
<td><label for=”doUpload_upload”>File Caption:</label></td>
<td><s:property value=”caption” /></td>
</tr>

</table>

</body>
</html>

Adding mapping in struts.xml file

Add the following mapping in the struts.xml file.

<!– File Upload –>

<action name=”showUpload”>
<result>/pages/upload.jsp</result>
</action>

<action name=”doUpload”>
<result name=”input”>/pages/upload.jsp</result>
<result>/pages/upload-success.jsp</result>
</action>

<!– End File Upload –>

The “showUpload” action displays the upload form and “doUpload” action actually uploads the file.

Running the example

To test the application compile code and then run the tomcat. Type http://localhost:8080/struts2tutorial/roseindia/showUpload.action in your browser. You browser should show the following form:

Now browse the file, enter caption and then click on the “Submit” button. Application will upload your file and then following success screen will be displayed.

There is one important point to be noted about File Upload Interceptor. The File Upload Interceptor actually deletes the the upload, once the action is executed. Here is the screen shot of tomcat that shows the file delete message:

INFO: Removing file upload C:\apache-tomcat-6.0.10Struts2\apache-tomcat-6.0.10\work\Catalina\
localhost\struts2tutorial\upload__13f532f7_1132e1d4754__8000_00000000.tmp

In this section you learnt the concept of file upload in struts 2.

Java Persistence API In EJB 3 For Professionals - Covers EJB 3.1 using GlassFish v3 Prelude

sharanamshah — Wed, 03 Jun 2009 03:14:36 +0000

Java Persistence API In EJB 3 For Professionals

Designed for beginners and intermediate developers, this book teaches JPA from the ground up with an aim to get the reader up to speed with JPA as quickly as possible. It delves deeply into the core of the JPA, providing a sound understanding of the components that make up the frameworkand the way they interact with each other.

This book uses the learning by doing pattern with a lot of ready-to-use examples. This pattern has proven to be the best approach for learning a new technology. Most [if not all] of the concepts that you will find in this book are demonstrated using well described and easy to understand examples, yet sophisticated enough to demonstrate JPA in a real-world context.

This book demonstrates a step-by-step guide to developing Web as well as Enterprise applications [using EJB 3 ] which re-enforces all the learning that takes place throughout the book. It also teaches how to integrate an enterprise application with Struts2. Not only this, the book also introduces EJB 3.1 [a part of Java EE 6] and demonstrates developing a IPA based EIB 3.1 application with the help of Glassfish v3 Prelude.

What You’ll Learn?

Building Web Applications

Using JSP/Servlets, DAO, JPA using Hibernate 3, Ajax, Glassfish v2

Using JSP, JPA using TopLink, Glassfish v2

Building Enterprise Applications

Using JSP/Servlets, EJB 3 – Session Beans, JPA using TopLink, Glassfish v2

Integrating an enterprise application with Struts2 [An extensible framework for creating enterprise-ready Java Web applications]

Building Enterprise Applications Using EJB 3.1

Using JSP/Servlets, EJB 3.1 – Session Beans, JPA using EclipseLink, Glassfish v3 Prelude

Using the NetBeans IDE to develop JPA based applications
Reverse Engineering POJOs and Mapping Documents from Database tables

Pagination using JPA

To ensure that the focus remains on understanding the technology, we have adopted the simplest and most customary domain models such as Customer, Authors, ContactDetails, Books, Subscribers and Guestbook.

ISBN 10: 81-8404-709-7

ISBN 13: 978-81-8404-709-7

Edition: First

Downloads

Sample Chapter

TOC

THE TOPICS COVERED IN THE BOOK

Introduction
Persistence, Object/Relational Mapping And JPA, Introduction To Java Persistence API, Writing The First Application
Core Components Of JPA

Entity, Entity Manager And Its Factory, Transactions, Persistence Unit
Metadata
Getting Started With Metadata, Database Identity, Associations, Collections, Inheritance, Defining Metadata Using XML
The JPA Query Language

The Basics Of Java Persistence Query Language, Joins, Query Interface, Pagination, Named Queries, Native SQL Queries
Web Application Development

Customer Database Web Application, Subscriber Management Web Application

Enterprise Application Development

Introduction To EJB 3.0, Customer Database Enterprise Application, Integrating Customer Database Enterprise Application With Struts2
Enterprise Application Development Using EJB 3.1

Introduction To EJB 3.1, Customer Database Enterprise Application
Appendix
Installing The NetBeans IDE, Customer Database Application Using Different ORMs

CONTENTS OF THE CD-ROM

Setup files for JDK 6

NetBeans IDE 6.5

Hibernate Core 3.x

Hibernate Annotations 3.x

Hibernate EntityManager 3.x

Struts 2.x

MySQL Community Server 6.x

JDBC Drivers

Library files for:

Display Tags

EclipseLink

TopLink

OpenJPA

Source code for the examples covered in this book

<!–[if !mso]> <! st1\:*{behavior:url(#ieooui) } –>

What You’ll Learn?

ü Building Web Applications

Using JSP/Servlets, DAO, JPA using Hibernate 3, Ajax, Glassfish v2

Using JSP, JPA using TopLink, Glassfish v2

ü Building Enterprise Applications

Using JSP/Servlets, EJB 3 – Session Beans, JPA using TopLink, Glassfish v2

Integrating an enterprise application with Struts2 [An extensible framework for creating enterprise-ready Java Web applications]

ü Building Enterprise Applications Using EJB 3.1

Using JSP/Servlets, EJB 3.1 – Session Beans, JPA using EclipseLink, Glassfish v3 Prelude

ü Using the NetBeans IDE to develop JPA based applications
Reverse Engineering POJOs and Mapping Documents from Database tables

ü Pagination using JPA