Happy GWT

irtualization: VMware vs. Microsoft vs. Xen, 2009

2009-10-04T02:21:00.002+08:00

Article Source: http://itmanagement.earthweb.com/entdev/article.php/3815481/Virtualization-VMware-vs-Microsoft-vs-Xen-2009.htm

April 15, 2009
By

David Strom

It is time once again for our annual look at what has happened and will happen in the server virtualization space. For the historical record, check out the comparison of VMware vs. Microsoft vs. Xen from 2008 and the same virtualization vendor comparison from 2007.

In the past year, Microsoft has come out with Hyper-V, a free add-on to Windows Server 2008 for its 64-bit versions only. VMware has revamped its pricing and also gone through a couple of releases of various products. And Citrix, which owns Xensource, continued to expand its alliances.

Others, such as VirtualIron.com and Sun's Virtual Box, are still hanging in there. And Cisco is starting to compete in this space with its Unified Communications platform that will run both HyperV and ESX on a new collection of hardware that integrates storage and switching.

What makes the new Cisco gear interesting is that it will handle 384 GB of RAM and not require the purchase of 4 CPU licenses of the hypervisors that would be required on other platforms from traditional server vendors. This could save money in the long term, because many IT shops are overbuying on multiple-CPU servers just so they can get enough DIMM slots to install more RAM.

Let's review where the three biggest virtualization vendors are and give you a report card on how they measure up on various developments.

We also updated our comparison chart too.

1) Pre-built appliances continue to grow

VMware: A

Microsoft: a solid C

Citrix: F

One of the big advantages of virtualization is the ease of creating new servers as guest virtual machines (VMs) – it just involves copying a few files and setting up a small number of configuration parameters.

Two of the three major virtualization vendors have pre-built "appliances" that they offer, and most of these are free for anyone to download and install.

The leader is still VMware, which has a list here of more than 1,000 appliances. There are more than a dozen VDIs from Microsoft, but most of these are still just a collection of core Microsoft Windows products, such as SharePoint and SQL Server and different versions of Windows servers. And Citrix XenServer doesn't yet have any listing of appliances but is working on having such a collection later this year.

2) Enterprise-class VM management tools are still under development

VMware: B

Microsoft: C+

Citrix: B

As you get more experienced with VM creation, you find that you need all sorts of tools to manage your guest VMs and servers.

The big three vendors have lots of add-on tools besides the basic hypervisor that can handle such things as:

• dynamic provisioning of VMs (for such things as peak demand processing and load balancing)

• role-based access controls so that not everyone in your enterprise can modify or copy a VM instance (look at a new third-party tool called the Hytrust's Appliance for help here)

• replication tools to copy new guest VMs

• high availability/cluster managers (to enable automatic restarting of guest VMs and automatic failover)

• patch management of guest VMs (so you can install OS patches and upgrades across all the guest VMs)

• P2V migration tools

Many of these tools are included in the fee-based XenServer editions, while they are purchased separately from VMware. Microsoft has the fewest management tools for HyperV.

3) Hypervisors now come pre-installed with server hardware

VMware: B

Microsoft: D, but no one really cares because it’s Windows 2008

Citrix: B

Most of the major server manufacturers now sell their gear with a choice of hypervisors pre-installed and certified to run on their equipment. Both ESX and Xen Server come pre-installed from a number of vendors, including Dell PowerEdge R and M series, HP ProLiant DL and BL series, and IBM's BladeCenter HS21 XM. A few vendors are also looking at pre-installing Microsoft's HyperV.

To complicate matters even further, VMware makes two different versions of ESX, with a free version, ESXi, which has a smaller memory footprint and comes pre-installed on some servers and lacks features found on the fee-based ESX version.

Microsoft's HyperV comes in two versions as well, one that comes as part of its 64-bit Windows Server 2008 OS (which is the one that most people are currently using) and one called HyperV Server that is an independent free version. This free version is labeled as a bare-metal hypervisor but is basically just a command-line version of Windows to run its guest VMs on it.

However, many people find that HyperV Server isn't much of an operating system, particularly for denser virtualized setups that require multiple network cards and storage adapters.

4) Understand your guest VM licensing needs – and costs.

VMware: B-

Microsoft: A, because of Windows Enterprise licensing quirks

Citrix: B+

Another balancing act is figuring out the costs of the licenses for your guest VMs versus the cost of the hypervisor or physical server pieces that you need to run them.

VMware in particular has one of the most complex licensing and pricing details, although they have taken steps to simplify it over the past couple of years. One of the advantages of going with Microsoft's HyperV running on the Enterprise version of Windows Server 2008 is that you can have unlimited free licenses for your guest Windows VMs, which can add up to a significant savings. Citrix's licensing is a bit easier to understand and price out than VMware's.

Virtual Server product comparison: VMware vs Microsoft vs Xen: 2009

Performance improvement techniques in Object creation

2009-08-05T23:44:00.001+08:00

Reference: http://www.precisejava.com/javaperf/j2se/Objects.htm

Note: This section assumes that reader has some basic knowledge of Java.

Optimization techniques in Object creation

Avoid creating objects in a loop.

Always try to use String literals instead of String objects.

Eg . String str1 = "Hello I am here "; //String literal

String str2= "Hello I am here "; //String literal

String str3 = new ("Hello I am here "); //String Object

When we create a String without the new operator and if the content is already existing it uses a single instance of the literal instead of creating a new object every time.

Never create objects just for accessing a method.

Whenever you are done with an object make that reference null so that it is eligible for garbage collection.

Never keep inheriting chains long since it involves calling all the parent constructors all along the chain until the constructor for java.lang.Object is reached.

Use primitive data types rather than using wrapper classes.

Whenever possible avoid using class variables, use local variables since accessing local variables is faster than accessing class variables.

Use techniques such as lazy evaluation. Lazy evaluation refers to the technique of avoiding certain computations until they are absolutely necessary. This way we put off certain computations that may never need to be done at all.

Another technique is Lazy object creation : i.e. delaying the memory allocation to an object till it is not being put into use. This way a lot of memory is saved till the object is actually put in to use.

Key Points

Avoid creating objects in a loop.

Use String literals instead of String objects (created using the 'new' keyword) if the content is same.

Make used objects eligible for garbage collection.

Do not keep inheritance chains long.

Accessing local variables is faster than accessing class variables

Use lazy evaluation, lazy object creation whenever possible.

Performance Improvement techniques in Java Collections

2009-08-05T23:38:00.001+08:00

Reference: http://www.precisejava.com/javaperf/j2se/Collections.htm
Lists:

Use ArrayList with proper initialization if you don't want thread safe for the collection whenever you add/remove/access objects at end and middle of collection.

Use Vector with proper initialization if you want thread safe for the collection whenever you add/remove/access objects at end and middle of collection.

Use LinkedList if you don't want thread safe for the collection whenever you add/remove/access objects at beginning of collection.

Use synchronized LinkedList if you want thread safe for the collection whenever you add/remove/access objects at beginning of collection.

Use ListIterator than Iterator and Enumeration for List types

Sets:

Use HashSet for maintaining unique objects if you don't want thread safe for the collection for all basic(add/remove/access) operations otherwise use synchronized HashSet for thread safe.

Use TreeSet for ordered and sorted set of unique objects for non-thread safe collection otherwise use synchronized TreeSet for thread safe

Maps:

Use HashMap for non-thread safe map collection otherwise use Hashtable for thread safe collection.

Use TreeMap for non-thread safe ordered map collection otherwise use synchronized TreeMap for thread safe.

Tuning Performance of Java Web Application

2009-08-05T23:28:00.008+08:00

source: http://java-junction.blogspot.com/search/label/Performance%20Tuning

Best Practices to improve performance in Servlets

1. Use init() method to cache static data
2. Use StringBuffer/StringBuilder rather than using + operator when you concatenate multiple strings
3. Use print() method rather than println() method
4. Use ServletOutputStream rather than PrintWriter to send binary data
5. Initialize the PrintWriter with proper size
6. Flush the data partly
7. Minimize code in the synchronized block
8. Set the content length
9. Release resources in destroy() method.
10. Implement getLastModified() method to use browser cache and server cache
11. Use application server caching facility
12. Use Mixed session mechanisms such as HttpSession with hidden fields
13. Remove HttpSession objects explicitly in your program whenever you finish the task
14. Reduce session time out value as much as possible
15. Use 'transient' variables to reduce serialization overhead if your HttpSession tracking mechanism uses serialization process.
16. Disable servlet auto reloading feature.
17. Use thread pool for your servlet engine and define the size as per application requirement.

Best Practices to improve Performance in JSP

1. Use jspInit() method to cache static data
2. Use StringBuffer rather than using + operator when you concatenate multiple strings
3. Use print() method rather than println() method
4. Use ServletOutputStream instead of JSPWriter to send binary data
5. Initialize the 'out' object (implicit object) with proper size in the page directive.
6. Flush the data partly
7. Minimize code in the synchronized block
8. Set the content length
9. Release resources in jspDestroy() method.
10. Give 'false' value to the session in the page directive to avoid session object creation.
11. Use include directive instead of include action when you want to include the child page content in the translation phase.
12. Avoid giving unnecessary scope in the 'useBean' action.
13. Do not use custom tags if you do not have reusability.
14. Use application server caching facility
15. Use Mixed session mechanisms such as 'session' with hidden fields
16. Use 'session' and 'application' as cache.
17. Use caching tags provided by different organizations like openSymphony.com
18. Remove 'session' objects explicitly in your program whenever you finish the task
19. Reduce session time out value as much as possible
20. Use 'transient' variables to reduce serialization overhead if your session tracking mechanism uses serialization process.
21. Disable JSP auto reloading feature.
22. Use thread pool for your JSP engine and define the size of thread pool as per application requirement.

Best practices to improve performance in JDBC

1. Get database connection from connection pool rather than getting it directly
2. Use batch transactions.
3. Choose right isolation level as per your requirement. TRANSACTION_READ_UNCOMMITED gives best performance for concurrent transaction based applications. TRANSACTION_NONE gives best performance for non-concurrent transaction based applications.
4. Your database server may not support all isolation levels, be aware of your database server features.
5. Use PreparedStatement when you execute the same statement more than once.
6. Use CallableStatement when you want result from multiple and complex statements for a single request.
7. Use batch update facility available in Statements.
8. Use batch retrieval facility available in Statements or ResultSet.
9. Set up proper direction for processing rows.
10. Use proper getXXX () methods.
11. Close ResultSet, Statement and Connection whenever you finish your work with them.
12. Write precise SQL queries.
13. Cache read-only and read-mostly tables data.

Performance improvement techniques in Object creation

1. Avoid creating objects in a loop.
2. Use String literals instead of String objects (created using the 'new' keyword) if the content is same.
3. Whenever you are done with an object make that reference null so that it is eligible for garbage collection.
4. Never keep inheriting chains long since it involves calling all the parent constructors all along the chain until the constructor for java.lang.Object is reached.
5. Use primitive data types rather than using wrapper classes.
6. Whenever possible avoid using class variables, use local variables since accessing local variables is faster than accessing class variables.
7. Another technique is Lazy object creation: i.e. delaying the memory allocation to an object till it is not being put into use. This way a lot of memory is saved till the object is actually put in to use.
Performance improvement techniques in Exceptions
1. In a catch block avoid using the generic class Exception. For each try block use specific catch blocks based on what can go wrong in your code.
2. Whenever you are using a throws clause always use the specific subclass of Exception like FileNotFoundException rather than using throws Exception.
3. Always use the finally block to release the resources like a database connection, closing a file or socket connection etc. This prevents resource leaks even if an exception occurs.
4. Do not use Exception handling in loops. It is better to place loops inside try/catch blocks than vice versa. Here is an code snippet that gives bench mark.

Performance improvement techniques in loops

1. Always use an int data type as the loop index variable whenever possible because it is efficient when compared to using byte or short data types. because when we use byte or short data type as the loop index variable they involve implicit type cast to int data type.
2. When using arrays it is always efficient to copy arrays using System.arraycopy() than using a loop.
3. Always avoid anything that can be done outside of the loop like method calls, assigning values to variables, or testing for conditions.
4. Method calls are very costly and you only make it worse by putting them in a loop. So as far as possible avoid method calls in a loop.
5. It is better to avoid accessing array elements in a loop the better option would be to use a temporary variables inside the loop and modify the array values out of the loop. It is fast to use a variable in a loop than accessing an array element.
6. Try to compare the terminating condition with zero if you use non-JIT or HotSpot virtual machine, here is an example to prove the point. JIT or HotSpot virtual machines are optimized for general loops so you do not have to bother about the terminating condition.

Reference: www.precisejava.com

Tips For Measuring Application Performance

Here are some of important points which should be considered while measuring application performance.

- Test systems should match production as closely as possible. Same hardware, OS, and software.
- Populate databases with the number of records expected in production.
An application may perform well with a small number of records in the database. Performance could degrade a great deal as the number of records in the table(s) increases
- Test HTTP requests with different request parameters.
Test with the extremes. A page which performs a search may perform well when the search criteria returns a small result set, but perform poorly when the search criteria returns a large result set.
- Simulate expected traffic over time including short term spikes.
A page which performs well with low request volume can cause the server to fail under higher request volume.
- Use Server load testing tools (like Apache Jakarta JMeter) to simulate heavy load.

Tomcat - Jboss Performance Tuning Tips

Apache Tomcat is an implmentation of the Java Servlet and JavaServer Pages technologies.
In production Enviroment, number of resources which can all impact application overall performance. Here are some important point which can help to improve Tomcat Performance.

Performance Tuning - Tomcat Configuration

Configure server.xml parameters as following.

-Set reloadable to false

When reloadable is true Tomcat tries to detect web application class changes and automatically reload any classes which change. Setting this to false removes a lot of unnecessary overhead in production.

-Set liveDeploy to false

liveDeploy controls whether your webapps directory is periodically checked for new web application directories and war files. This is done using a background thread. Set this to false and use the manager application or ant deploy tasks instead.

-Set debug to 0

Disable all debug output, unnecessary logging just adds overhead.

-Set swallowOutput to true

This makes sure all output to stdout or stderr for a web application gets directed to the web application log rather than the console or catalina.out. This makes it easier to troubleshoot web application problems.

Performance Tuning - Jasper 2 Configuration

Configure web.xml parameters as following.

-Set development to false

Disables JSP page out of date checks on each request and enables JSP background recompiles. development is set to true by default.

-Use JSP custom tag pooling

Object pooling of classes which implement custom tags significantly improves performance of JSP pages which use custom tag libraries. JSP custom tag pooling is enabled by default.

-Configure Jasper to fork javac compiles. (Do not set fork to true on MS Windows)

The JVM compiler javac has known memory leaks. Eliminates JVM memory usage and GC overhead of javac by configuring Jasper to fork javac when compiling JSP pages.

Detecting Window Size and Scrolling In Javascript

2009-08-03T12:28:00.001+08:00

Source: http://www.howtocreate.co.uk/tutorials/javascript/browserwindow

Window size and scrolling

Finding the size of the browser window

Clue browser can only work out window width.
Tkhtml Hv3 has the body/documentElement clientHeight/Width values reversed - versions before September 2007 also do not support innerHeight/Width, so they cannot work with this script.

There are some constants available that give the document area of the window that is available for writing to. These will not be available until after the document has loaded and the method used for referencing them is browser specific. The available constants are:

window.innerHeight/Width: Provided by most browsers, but importantly, not Internet Explorer.
document.body.clientHeight/Width: Provided by many browsers, including Internet Explorer.
document.documentElement.clientHeight/Width: Provided by most DOM browsers, including Internet Explorer.

This is a little messy because the clientHeight/Width properties can mean different things in different browsers, and even different things in the same browser, depending on whether the document type declaration triggers the browser's strict mode or quirks mode. In some cases, they refer to the dimensions of the window, and sometimes they refer to the dimensions of the contents of the document. The table below shows what the properties mean in different browsers, and different modes:

Properties and what they relate to
Browser	window. innerHeight	document. body. clientHeight	document. documentElement. clientHeight
Opera 9.5+ strict	window	document	window
Opera 9.5+ quirks	window	window	document
Opera 7-9.2	window	window	document
Opera 6	window	window	N/A
Mozilla strict	window	document	window
Mozilla quirks	window	window	document
KHTML	window	document	document
Safari	window	document	document
iCab 3	window	document	document
iCab 2	window	window	N/A
IE 6+ strict	N/A	document	window
IE 5-7 quirks	N/A	window	0
IE 4	N/A	window	N/A
ICEbrowser	window	window	document
Tkhtml Hv3	window	window	document
Netscape 4	window	N/A	N/A

As you can see, the browsers seem to have settled on at least one reliable property; innerHeight. Internet Explorer is the one that cannot make up its mind, and its influence means that other browsers change their clientHeight behaviour in different versions in order to match it. For now, almost all browsers provide window.innerHeight/Width so that can be used. Internet Explorer has chosen to swap the values around when it is in strict mode. Fortunately, it gives 0 in quirks mode. This means that if we see a value on the documentElement's properties, and the browser does not provide the properties on the window object, we can assume it is Internet Explorer in strict mode.

The most accurate method I could come up with uses the following algorithm, although it may have problems with future browsers, a situation which I am definitely not happy with:

If window.innerHeight/Width is provided, that is fully trustworthy, use that (Hooray!).
Else if document.documentElement.clientHeight/Width is provided and either one is greater than 0, use that.
Else use document.body.clientHeight/Width.

This algorithm will fail with IE 6+ in 'standards compliant mode' if the window is shrunk to 0px by 0px. This is only possible when the user actively shrinks the window to hide the page within it. Even then, it will just give the height of the document instead, so it should not be a problem. The following code performs the algorithm as described.

function alertSize() {
 var myWidth = 0, myHeight = 0;
 if( typeof( window.innerWidth ) == 'number' ) {
   //Non-IE
   myWidth = window.innerWidth;
   myHeight = window.innerHeight;
 } else if( document.documentElement && ( document.documentElement.clientWidth || document.documentElement.clientHeight ) ) {
   //IE 6+ in 'standards compliant mode'
   myWidth = document.documentElement.clientWidth;
   myHeight = document.documentElement.clientHeight;
 } else if( document.body && ( document.body.clientWidth || document.body.clientHeight ) ) {
   //IE 4 compatible
   myWidth = document.body.clientWidth;
   myHeight = document.body.clientHeight;
 }
 window.alert( 'Width = ' + myWidth );
 window.alert( 'Height = ' + myHeight );
}

Test it here: get the inner dimensions of this window.

Note that browsers may take the width either inside or outside the scrollbar (if there is one). I do not cover any way to work with these differences.

Finding how far the window has been scrolled

OmniWeb 4.2-, NetFront 3.3- and Clue browser do not provide any way to do this.
Safari and OmniWeb 4.5+ have bugs that do not affect this script - see below.

When trying to produce document effects like falling snow, or more serious things like menus that remain in the same place relative to the browser window when the user scrolls, it is essential to be able to obtain the scrolling offsets in both the horizontal and vertical direction.

There are also three ways to find this out, but it is easier than finding the size of the window. Most browsers provide window.pageXOffset/pageYOffset. These are completely reliable. Once again, Internet Explorer is the odd one out, as it does not provide these properties. Internet Explorer and some other browsers will provide document.body.scrollLeft/Top. In strict mode, IE 6 and a few other browsers, provide document.documentElement.scrollLeft/Top.

If the scrollLeft/Top properties are provided on either the document.body or document.documentElement, they are reliable in everything except Safari and OmniWeb 4.5+, which return -8 if the scrolling is 0, but get all other scrolling offsets correct. However, as they correctly provide window.pageXOffset/pageYOffset, this script will not have any problems.

The following script will obtain the scrolling offsets.

function getScrollXY() {
 var scrOfX = 0, scrOfY = 0;
 if( typeof( window.pageYOffset ) == 'number' ) {
   //Netscape compliant
   scrOfY = window.pageYOffset;
   scrOfX = window.pageXOffset;
 } else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ) {
   //DOM compliant
   scrOfY = document.body.scrollTop;
   scrOfX = document.body.scrollLeft;
 } else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) {
   //IE6 standards compliant mode
   scrOfY = document.documentElement.scrollTop;
   scrOfX = document.documentElement.scrollLeft;
 }
 return [ scrOfX, scrOfY ];
}

Test it here: get the scrolling offsets.

Struts2 + Struts2 JSF plugin + ICE Faces

2009-07-25T22:27:00.002+08:00

I found that there are a lot of people are looking for example or guide to make ICEfaces work together in a Struts 2 framework. Perhaps somebody who know the way can give some guides here...

GWT plugin for Struts

2009-07-07T16:50:00.002+08:00

The source of this tutorial: http://cwiki.apache.org/S2PLUGINS/gwt-plugin.html

This plugin can be used to call methods on Struts actions using Google Web Toolkit (GWT):

Name	GWT Plugin
Publisher	Musachy Barroso, Sean McRae
License	Open Source (ASL2)
Version	0.2 stable
Compatibility	Struts 2.0.2+
Homepage	http://code.google.com/p/struts2gwtplugin/
Download	http://code.google.com/p/struts2gwtplugin/downloads/list

Example

Setup Action

Start by creating an action that contains the method that is going to be called. This method needs to match the signature of the service interface, but you don't need to implement the interface on the action. This method will be different from regular Struts 2 action methods in that it returns any object (that GWT can serialize), instead of a result name. If you want to call regular actions from GWT (not using GWT's RPC) go here

In this example the action "Hello" will return the string passed to it. Remember, the returned object is not the regular Struts result, it is the object that you will receive on the client side.

Example:

public class Hello {
 public String hello(String text) {
     return text;
 }
}

Write the mapping for the action

For any action mapping that is going to be called from GWT:

Add the map inside a package that extends "gwt-default"
Add the "gwt" interceptor to the mapping

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.enable.DynamicMethodInvocation" value="false" />
<constant name="struts.devMode" value="true" />

<package name="example" extends="gwt-default">
<action name="Hello" class="example.Hello" method="hello">
<interceptor-ref name="gwt"/>
</action>
</package>

</struts>

GWT classes

Write the required service interface as described here. This is regular GWT stuff.

As an example of the interface:

public interface MyService extends RemoteService {
  public String hello(String s);
}

public interface MyServiceAsync {
  public void hello(String s, AsyncCallback callback);
}

And to call it:

MyServiceAsync service = (MyServiceAsync) GWT.create(MyService.class);
AsyncCallback callback = new AsyncCallback() {
  public void onSuccess(Object result) {
      Window.alert(result.toString());
  }

  public void onFailure(Throwable caught) {
      Window.alert(caught.toString());
  }
};
ServiceDefTarget endpoint = (ServiceDefTarget) service;
endpoint.setServiceEntryPoint("Hello.action");
service.hello("Hi There!", callback);

Installation

This plugin can be installed by copying the plugin jar and gwt-servlet.jar (from GWT) into your application's /WEB-INF/lib directory. No other files need to be copied or created.

Integrate GWT into Struts 2 Application

2009-07-07T16:40:00.004+08:00

Source of this tutorial: http://cwiki.apache.org/WW/struts-2-gwt.html

These tutorial will demonstrate how to call an Struts 2 action, using GWT to submit a form and use the returned data.

Write your action.

Example action:

"Hello.java"

package example;

import com.opensymphony.xwork2.Action;

public class Hello {
private String firstName;
private String lastName;

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

public String getFirstName() {
   return firstName;
}
public void setFirstName(String firstName) {
   this.firstName = firstName;
}
public String getLastName() {
   return lastName;
}
public void setLastName(String lastName) {
   this.lastName = lastName;
}
}

Write the mapping for your action.

In this example the mapping is in struts.xml:

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>

<package name="example" extends="struts-default">
<action name="Hello" class="example.Hello">
<result type="json" />
</action>

<action name="Main" class="com.opensymphony.xwork2.ActionSupport">
<result>org.apache.struts.gwt.Main/Main.jsp</result>
</action>
</package>

</struts>

The "Hello" action has a result of type "json", which will serialize the action object into a JSON

string. If "firstName" is set to "John" and "lastName" is set to "Galt", the output of the "Hello" action will be:

{
"firstName" : "John",
"lastName"  : "Galt"
}

The "Main" action points to the "Main.jsp" page which is the page that uses GWT. The path of the result is "org.apache.struts.gwt.Main/Main.jsp". That means that the files generated by GWT must go under a folder named "org.apache.struts.gwt.Main" under the root of your application. See "Deployment structure" for more details.

Write "Main.jsp" page.

This is the page that is generated by GWT's "applicationCreator". It has been renamed to .jsp because we have modified it to be a jsp page, instead of a plain html page.

Main.jsp

<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
<s:head theme="ajax" debug="true"/>
<meta name='gwt:module' content='org.apache.struts.gwt.Main/org.apache.struts.gwt.Main'>
</head>

<body>
<script language="javascript" src="${pageContext.request.contextPath}/org.apache.struts.gwt.Main/gwt.js"/>

<form id="form1">
<input type="text" name="firstName">
<br/>
<input type="text" name="lastName">
<span id="slot1"></span>
</form>

<br/>
<span id="slot2"></span>
</body>
</html>

We set head's tag attribute "theme" to ajax to use Dojo, don't panic, you won't have to use it directly. Note that we have changed a few things from the original html page generated by GWT, we set "content" to "org.apache.struts.gwt.Main/org.apache.struts.gwt.Main" because the GWT generated files will be under "AppRoot/org.apache.struts.gwt.Main" instead of beneath root, and we set "src" to "${pageContext.request.contextPath}/org.apache.struts.gwt.Main/gwt.js" for the same reason. Without these two changes the GWT files wouldn't be loaded.
Struts2GWTHelper

This class will take care of making the request. Why? Why do I need this class? Couple of reasons, first, there is a bug on bug on HTTPRequest.asyncPost which doesn't encode the payload properly, second, if you want to submit a form, you have to encode it yourself, and this class will help you do that. Optionally you can download a jar containing this class (with more methods) from here, add this to your GWT application file (i.e Main.gwt.xml):

<inherits name='struts2gwt.Struts2GWT'/>

and add the jar to the classpath in your compile script (i.e Main-compile.cmd) and the compile script (i.e Main-shell.cmd).
Struts2GWTHelper .java

package org.apache.struts.gwt.client;

import com.google.gwt.user.client.ResponseTextHandler;

public class Struts2GWTHelper {

/**
* Make asynchronous post
* @param url Action url
* @param formId id of form that will be posted
* @param handler callback function
*/
public static native void asyncPost(String url, String formId, ResponseTextHandler handler) /*-{
dojo = $wnd.dojo;
//don't use the dojo.io.bind({...}) shortcut, it doesn't work here
var request = new dojo.io.Request(url);
request.load = function(type, data, request) {
handler.@com.google.gwt.user.client.ResponseTextHandler::onCompletion(Ljava/lang/String;)(data);
};
request.formNode = dojo.byId(formId);
request.method = "POST";
$wnd.dojo.io.bind(request);
}-*/;

/**
* Make asynchronous post
* @param url Action url
* @param handler callback function
*/
public static void asyncPost(String url, ResponseTextHandler handler) {
Struts2GWTHelper.asyncPost(url, handler);
}
}

See? It wasn't that bad.
Write your GWT entry point
Main.java

package org.apache.struts.gwt.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.user.client.ResponseTextHandler;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.Widget;

/**
* Entry point classes define <code>onModuleLoad()</code>.
*/
public class Main implements EntryPoint {
final Label label = new Label();

/**
* This is the entry point method.
*/
public void onModuleLoad() {
final Button button = new Button("Click me");

button.addClickListener(new ClickListener() {
public void onClick(Widget sender) {
makeRequest();
}
});

RootPanel.get("slot1").add(button);
RootPanel.get("slot2").add(label);
}

private void makeRequest() {
Struts2GWTHelper.asyncPost("Hello.action", "form1", new ResponseTextHandler() {
public void onCompletion(String responseText) {
JSONObject obj = (JSONObject)JSONParser.parse(responseText);
JSONString firstName = (JSONString)obj.get("firstName");
JSONString lastName = (JSONString)obj.get("lastName");
label.setText("Welcome " + firstName.stringValue() + " " + lastName.stringValue());
}
});
}
}

The makeRequest() method will make a request to the "Hello" action that we created before, and will pass the fields of the form "form1" as parameters. Which will be populated on the action, and serialized back as JSON. Using JSONParser the JSON string is parsed into a JSON object. It is definitely not type safe as GWT Remoting, but it works.
Create Main.gwt.xml

Nothing new on this file, just as reference:
Main.gwt.xml

<module>


<inherits name='com.google.gwt.user.User'/>
<inherits name='com.google.gwt.json.JSON'/>


<entry-point class='org.apache.struts.gwt.client.Main'/>

</module>

Deployment structure
Folder Notes
AppRoot The application deployment folder
AppRoot/index.html Welcome Page
AppRoot/org.apache.struts.gwt.Main Content generated by GWT (usually it gets generated into a folder named 'www')
AppRoot/WEB-INF Regular webapp files and classes

A GWT app: HouseOnMaps.com

2009-07-07T16:29:00.003+08:00

Here got a web site 100% developed in GWT. It's House On Maps Dot Com @ www.houseonmaps.com

I think the Google map is loaded a bit slow. Perhaps there should be a trick to make it faster.

GWT-Ext

2009-07-07T16:22:00.005+08:00

Source: http://gwt-ext.com/ (official site of GWT-Ext)
GWT-Ext is a powerful widget library that provides rich widgets like Grid with sort, paging and filtering, Tree’s with Drag & Drop support, highly customizable ComboBoxes, Tab Panels, Menus & Toolbars, Dialogs, Forms and a lot more right out of the box with a powerful and easy to use API. It uses GWT and Ext.

GWT-Ext 2.0.5 has been released. Grab the distribution from the Downloads area. GWT-Ext 2.0.5 supports GWT 1.5 final (1.5.2), Firefox3 and Chrome.

Note that GWT-Ext only supports Ext 2.0.2 that has a LGPL license option.

The download link for current latest version of GWT-Ext (GWT-Ext 2.0): http://gwt-ext.com/demo

gwt window manager

2008-01-15T12:18:00.001+08:00

Just now, I found that other people have done the same thing as mine, even better than the one I did. They really have done a great job.. that they put a lot of animations, transparent backgrounds, sophisticated window buttons (e.g: vista & iMac themes), etc.
They called it GWT Window Manager. You can find out more from this link:

http://www.gwtwindowmanager.org/

gwt window demo

2008-01-15T00:04:00.000+08:00

I have made the demo of gwt window (as shown in the figure below):

You can go to the link below to view the demo:

http://www.euzertech.com/gwt/gwtwindow.html

The source files of this demo project can be downloaded from this link:

http://www.euzertech.com/gwt/gwtwindow.zip

Please note that the background and border color of the window dialogbox generated by my Window class is transparent. So, you can use external CSS to color the window. In this demo, the source code of my CSS is as below:

.gwt-Window {
background-color: #0055ff;
border-color: #0000ff;
border-style: solid;
border-width: 2px;
}

.gwt-Window .HeadPanel {
background-color: #00eeff;
}

.gwt-Window .HeadPanel .Caption {
font-weight: bold;
}

Please note that in order to use the "Window.java", 6 images files (close.png, close_white.png, minimize.png, minimize_white.png, maximize.png, maximize_white.png) must be included in the same folder. You can see the files structure of the demo from the figure below:

gwt window dialogbox widget with minimize and close buttons

2008-01-14T17:39:00.000+08:00

I wanted to make a draggable window dialog box with minimize and close buttons on the caption panel, but i couldn't find this kind of gwt widget API from the web. So, i have decided to build my own one by modifying the source code from a gwt library file called "DialogBox.java". Below is the source code of my "Window.java":

/*
* Copyright 2007 Google Inc.
*
* Modified from DialogBox.java of GWT 1.4.61
* by Wong Thai Min at 14th January 2008.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.thaimin.client;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.AbstractImagePrototype;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.HasHorizontalAlignment;
import com.google.gwt.user.client.ui.HasVerticalAlignment;
import com.google.gwt.user.client.ui.MouseListener;
import com.google.gwt.user.client.ui.PopupPanel;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.ImageBundle;
import com.google.gwt.user.client.ui.VerticalPanel;

/**
* A form of popup window that has a caption area at the top and can be dragged by the
* user. Minimize, maximize and close window buttons are on the caption area.
*
* CSS Style Rules
*
* .gwt-Window { the outside of the window }
* .gwt-Window .HeadPanel { the header panell of the window }
* .gwt-Window .HeadPanel .Caption { the caption }
*
*/
public class Window extends PopupPanel implements MouseListener {

public interface WindowImages extends ImageBundle {

AbstractImagePrototype maximize();

AbstractImagePrototype maximize_white();

AbstractImagePrototype minimize();

AbstractImagePrototype minimize_white();

AbstractImagePrototype close();

AbstractImagePrototype close_white();
}
public static final WindowImages images = (WindowImages) GWT.create(WindowImages.class);
private Image minmax = images.minimize().createImage();
private Image close = images.close().createImage();
private HorizontalPanel icons = new HorizontalPanel();
private HorizontalPanel headhor = new HorizontalPanel();
private VerticalPanel headver = new VerticalPanel();
private FlexTable content = new FlexTable();
private Label caption = new Label();
private Widget child;
private boolean dragging;
private int dragStartX, dragStartY;
private FlexTable panel = new FlexTable();

/**
* Creates an empty dialog box. It should not be shown until its child widget
* has been added using {@link #add(Widget)}.
*/
public Window() {
this(false);
}

/**
* Creates an empty dialog box specifying its "auto-hide" property. It should
* not be shown until its child widget has been added using
* {@link #add(Widget)}.
*
* @param autoHide true if the dialog should be automatically
* hidden when the user clicks outside of it
*/
public Window(boolean autoHide) {
this(autoHide, true);
}

/**
* Creates an empty dialog box specifying its "auto-hide" property. It should
* not be shown until its child widget has been added using
* {@link #add(Widget)}.
*
* @param autoHide true if the dialog should be automatically
* hidden when the user clicks outside of it
* @param modal true if keyboard and mouse events for widgets
* not contained by the dialog should be ignored
*/
public Window(boolean autoHide, boolean modal) {
super(autoHide, modal);

// minimize & close buttons for DialogBox
minmax.setTitle("minimize");
close.setTitle("close");

// panel:headver:headhor:icons HorizontalPanel ==> display minmax & close images
icons.setHorizontalAlignment(HorizontalPanel.ALIGN_RIGHT);
icons.setVerticalAlignment(HorizontalPanel.ALIGN_MIDDLE);
icons.setHeight("100%");
icons.setSpacing(2);
icons.add(minmax);
icons.add(close);

// panel:headver:headhor HorizontalPanel
headhor.setWidth("100%");
headhor.setVerticalAlignment(HorizontalPanel.ALIGN_MIDDLE);
headhor.add(caption);
headhor.setCellWidth(caption, "100%");
headhor.setCellHorizontalAlignment(caption, HorizontalPanel.ALIGN_LEFT);
headhor.add(icons);
headhor.setCellHorizontalAlignment(icons, HorizontalPanel.ALIGN_RIGHT);

// panel:headver:content VerticalPanel

// panel:headver VerticalPanel
headver.setWidth("100%");
headver.add(headhor);
headver.add(content);

// panel Flextable
panel.setWidget(0, 0, headver);
panel.setHeight("100%");
panel.setBorderWidth(0);
panel.setCellPadding(0);
panel.setCellSpacing(0);
panel.getCellFormatter().setHeight(1, 0, "100%");
panel.getCellFormatter().setWidth(1, 0, "100%");
panel.getCellFormatter().setAlignment(1, 0,
HasHorizontalAlignment.ALIGN_CENTER,
HasVerticalAlignment.ALIGN_MIDDLE);

// Display the layout of the window
super.setWidget(panel);

setStyleName("gwt-Window");
headhor.setStyleName("HeadPanel");
caption.setStyleName("Caption");
caption.addMouseListener(this);

//---------------------- Mouse Listener for window buttons -----------------
minmax.addMouseListener(new MouseListener() {

public void onMouseDown(Widget sender, int x, int y) {
}

// Minimize(grey) icon become white color
public void onMouseEnter(Widget sender) {
if (isMinimize()) {
images.maximize_white().applyTo(minmax);
} else {
images.minimize_white().applyTo(minmax);
}
}

public void onMouseLeave(Widget sender) {
if (isMinimize()) {
images.maximize().applyTo(minmax);
} else {
images.minimize().applyTo(minmax);
}
}

public void onMouseMove(Widget sender, int x, int y) {
}

public void onMouseUp(Widget sender, int x, int y) {
if (isMinimize()) {
setMinimize(false);
} else {
setMinimize(true);
}
}
});

close.addMouseListener(new MouseListener() {

public void onMouseDown(Widget sender, int x, int y) {
}
// Close(grey) icon become white color
public void onMouseEnter(Widget sender) {
images.close_white().applyTo(close);
}

public void onMouseLeave(Widget sender) {
images.close().applyTo(close);
}

public void onMouseMove(Widget sender, int x, int y) {
}

public void onMouseUp(Widget sender, int x, int y) {
}
});

// Close the window
close.addClickListener(new ClickListener() {

public void onClick(Widget sender) {
hide();
}
});
//------------------ End of Mouse Listener for window buttons ------------------
}

public String getText() {
return caption.getText();
}

public boolean onEventPreview(Event event) {
// We need to preventDefault() on mouseDown events (outside of the
// DialogBox content) to keep text from being selected when it
// is dragged.
if (DOM.eventGetType(event) == Event.ONMOUSEDOWN) {
if (DOM.isOrHasChild(caption.getElement(), DOM.eventGetTarget(event))) {
DOM.eventPreventDefault(event);
}
}

return super.onEventPreview(event);
}

public void onMouseDown(Widget sender, int x, int y) {
dragging = true;
DOM.setCapture(caption.getElement());
dragStartX = x;
dragStartY = y;
}

public void onMouseEnter(Widget sender) {
}

public void onMouseLeave(Widget sender) {
}

public void onMouseMove(Widget sender, int x, int y) {
if (dragging) {
int absX = x + getAbsoluteLeft();
int absY = y + getAbsoluteTop();
setPopupPosition(absX - dragStartX, absY - dragStartY);
}
}

public void onMouseUp(Widget sender, int x, int y) {
dragging = false;
DOM.releaseCapture(caption.getElement());
}

public boolean remove(Widget w) {
if (child != w) {
return false;
}

panel.remove(w);
return true;
}

/**
* Set the caption of the window.
*
* @param text
*/
public void setText(String text) {
caption.setText(text);
}

/**
* Insert a content widget into the window. If there is any widget in the
* content area of the window, it will be removed and replaced by
* w.
*
* @param w The content widget to be inserted to the Window.
*/
public void setWidget(Widget w) {
// If there is already a widget, remove it.
if (child != null) {
content.remove(child);
}

// Add the widget to the center of the cell.
if (w != null) {
content.setWidget(1, 0, w);
}

child = w;
}

/**
* Override, so that interior panel reflows to match parent's new width.
*
* @Override
*/
public void setWidth(String width) {
super.setWidth(width);

// note that you CANNOT call panel.setWidth("100%") until parent's width
// has been explicitly set, b/c until then parent's width is unconstrained
// and setting panel's width to 100% will flow parent to 100% of browser
// (i.e. can't do this in constructor)
panel.setWidth("100%");
}

/**
* Determines whether the window state is currently minimized or restored.
*/
public boolean isMinimize() {
return !content.isVisible();
}

/**
* Set the window state whether to be minimized or restored.
*
* @param state true to minimize the window.
*/
public void setMinimize(boolean b) {
content.setVisible(!b);
if (b = true) {
images.maximize().applyTo(minmax);
} else {
images.minimize().applyTo(minmax);
}
}
}