Clouds come floating into my life, no longer to carry rain or usher storm, but to add color to my sunset sky.
~ Rabindranath Tagore

I was at the base all afternoon and as it was quiet I was watching the kids swimming from the jetty. Later in the afternoon a storm front came our way.

About the photo:I was really hoping I would be able to capture the awesome colour of the lake today, and I think I did. I used aperture priority mode and set it to f11 for this shot.

With Java EE 6 and GlassFish v3 out, it is time to take a little break and look at the application server world. J2EE 1.2 was created in 1999, that’s 10 years ago. The application server market at the time was completely different of the one today. There was Weblogic and Websphere, other proprietary application servers (not following J2EE) and no open source application server. Today, it is a completely different story.

The application servers’ world has changed so much in the last 10 years, but people still have in mind the heavyweight server that takes huge amount of RAM, disk space and takes ages to start (being completely useless for agile developers who need to test and code quickly and often). So let’s focus on some application servers  (Geronimo, GlassFish, JBoss, Jetty, JOnAS, Resin, Tomcat, Weblogic and Webspere) and check some parameters.

The benchmark

Disclaimer :This is not a real benchmark !

In this little test I’m just concerned about the usability of an application server for a developer. The idea is to download it, install it, start it and take some measurements (size of download, ease of installation, size of disk, startup time, size of RAM…). That’s all. No deployment of an application, no fancy twists to gain performance…. Because some of these application servers are resource consuming, I’m doing all my tests on a Windows XP virtual machine (running on Virtual Box 3.1). It is a fresh install of Windows XP sp3 with 1Gb of RAM and not too many software installed (I had to install Avast but). So when I boot there are 27 processes running and using 230 Mb of RAM (leaving 770 Mb free). Virtualizing can be slower, so keep in mind that startup time can be a bit faster that what I’m giving you here. I use JDK 1.6.0_17 (when it’s not bundled with the server). No optimization at all is made (I haven’t twisted the JVM, or antyhing application server parameter, everything comes out of the box).

To calculate the startup time, I don’t do any fancy rocket science either. I just start the server a few times, check how long it takes and use the best startup time. Also remember that some servers do not load any container at startup, making them very fast to start. Others load everything (making them slower). Again, I have to point out that I’m not deploying an application, so it’s really starting up the server from a fresh install. To calculate the memory footprint, I just use the Windows task manager and check the size of the java.exe process.

Disclaimer bis : Some of these servers were completely unknown for me, so I might not have been completely accurate. Feel free to leave a comment.

Disclaimer Ter : And again, this is not a real benchmark, so don’t use it to sale any product to your customer ;o) I just wanted to give an overview of most application servers and some numbers.

Geronimo

Geronimo is the Apache Java EE 5 application server.

Geronimo 2.x

Geronimo 2.x comes with two flavours : one bundle with Jetty, the other one with Tomcat (the one I’ve picked up).

(*) user : system / pwd : manager

GlassFish

GlassFish is the open source reference implementation of the last Java EE specifications.

GlassFish 2.x

GlassFish v2 is the reference implementation of Java EE 5.

GlassFish 3.x

GlassFish v3 is the reference implementation of Java EE 6.

JBoss

JBoss is the RedHat open source application server.

JBoss 5.x

JBoss 5 is a Java EE 5 application server

(*) That’s using the default domain

JBoss 6.x

JBoss is still a work in progress. It will eventually implement Java EE 6.

Jetty

Jetty provides an HTTP server, HTTP client, and a Servlet container.

Jetty 6.x

Jetty 7.x

JOnAS

JOnAS is an application server part of the OW2 development community.

JOnAS 5.1.1

Resin

Resin provides an HTTP server, HTTP client, and a javax.servlet 2.5 container.

Resin 3.x

Resin 4.x

Resim 4.x is still in development. It implements the Java EE 6 Web Profile.

Tomcat

Apache Tomcat is an open source software implementation of the Servlet specification. So we can say it’s a web container that servers Servlets and JSPs.

Tomcat 6.x

(*) To be able to log on to the admin console, you need to change the %TOMCAT_HOME%\conf\tomcat-users.xml configuration files and add a manager role.

Weblogic

Oracle Weblogic server belonged once to BEA and is a Java EE 5 application server.

Weblogic 10.x

Websphere

Websphere 7.x

Websphere 7 is the Java EE 5 application server of IBM.

Conclusion

There is not a real conclusion that you can take out of these tests, just some hints and numbers to show you that things are moving. Comparing Websphere with Tomcat is like comparing apples with bananas. Of course Tomcat is way faster and lighter than Websphere, but it doesn’t do the same thing. Also some application servers are minimalist and only come with application containers. On the other hand, other come with integrated portals and so on. So, of course, the startup time is different.

All that to say that the figures of the table below have to be taken with respect of what the application server does (remember that Tomcat and Jetty are just servlet containers). In red the less efficient, in orange the second less efficient, in green the most efficient, in blue the second most efficient.

Java EE 5

If you only concentrate on the Java EE 5 implementation, you’ll get the sub-table below :

When you read this table there are things that you would have not expected. For example, JBoss is the slowest server to startup and Weblogic is the fastest. JBoss is also the one that has the biggest memory footprint. Websphere has the second less efficient score of all categories, while GlassFish has the second most efficient scores. JOnAS, on the other hand, has the smallest memory footprint.

Again, I haven’t deployed any application, used the administration console extensively, created clusters and did any fancy performance tests. But I wanted to show you that a full Java EE 5 server can start in 9 seconds or can only take 73 Mb or RAM. With Java EE 6 coming and the Web Profile, application servers have to become more modular and carry less weight. GlassFish v3 is a good example as it starts up in only 5.6 seconds and Resin 4 in 1640 ms. Application servers today are not the same that when they were created 10 years ago. Things have changed : Java EE 6 has become lighter, and so are the application servers.

PS : If I have omitted an application server that you (and I) think is important, let me know and I’ll give it a try and add it to the list. If you have any information to report, feel free to leave a comment.

A lake is the landscape’s most beautiful and expressive feature. It is earth’s eye; looking into which the beholder measures the depth of his own nature.
~ Henry David Thoreau

I walked over to a nearby suburb for the splendid lake views and a drink at the lovely lakeside cafe. Lo and behold, there was another jetty to photograph.

About the photo: I have been using aperture priority, this was shot at f11. The late afternoon sun was a bit in the way and of course I had left my sun shade at home

Well promise is a promise, this is another one of Grandma house sketch, now this are the man made streams nearby the house, the stream are used for transporting harvested coconuts or cocoa by small “sampan” (wooden boat) to nearby collection point. As seen from the sketch, the stream water level are control by series of dam, especially useful during dry seasons. Lots of mud crab in those streams during those days, well mud crab aren’t that popular in the market back then mostly just consume locally by farmers well all those change now as restaurant now offer gourmet mud crab dishes nowadays. If you can see carefully there is a contraption (next to the man pulling the string from the water), it’s a square curved net with rotten fish head hanging in the middle. This are lowered into the stream and wait for movement on the string. Once they moved, just quickly pull them up there u have your crab. Pretty easy actually especially and they are hungry. Hope you like this sketch.

Latest developer versions of Chrome (at least for Windows) include support for WebSockets. Moreover a Jetty extension is available, that adds support for this communication mode on the server side.

It was a rather warm Summer night on Saturday here in Perth and we had clear skies, so I decided to head out and spend a few hours shooting some star trails. I decided to head down to Lake Clifton http://www.lakeclifton.com.au South of Mandurah, and about 100km South of Perth. On this visit, there was no moon not like on my last visit http://eos20.wordpress.com/2009/08/07/august-7/ so conditions were ideal for shooting star trails, but having some moon light would have been ideal so I could have used the ambient light from the moon to illuminate the Thrombolites http://www.lakeclifton.com.au/yalgorup.html so had to use my spotlight to bring out the detail of the Thrombolites. I brought along two cameras on this visit, I bought my EOS 7D and used my new EF-S 15-85 IS lens, and I also brought along my old EOS 300D and 18-55 lens, and I also brought along my 50mm f/2.5 macro to use as a large aperture lens. I set up both cameras on tripods with shutter release cables, and I shot a series of 30 second exposures and combined them using the Star Trails stacking software http://www.startrails.de/ which I find does a better job then shooting a single long exposure which tends to result in a image full of long exposure noise which can easily ruin a nights work, and by using software I can delete frames if necessary (Planes flying though the exposure, camera shake, etc) and I get a cleaner final result and can shoot star trails pretty much anywhere without worrying about getting a over exposed shot when shooting near bright light sources such as in the city.

On this night it was pitch black, with no ambient lighting out here, since it’s located a fair way away from the nearest towns, which meant the stars were easily visible with very little light pollution other then headlights of passing cars off in the distance. There was a bit of lightning off towards the horizon East of my location when I arrived, but that only lasted about 30 mins and didn’t affect my shooting since I had the cameras pointed South to try and get the best star trail patterns, unfortunately I didn’t end up aiming the cameras directly at the Southern Star, so I was a bit off, and didn’t get the full circle I was after, but the results still came out well enough.

It was windy on this visit, unlike on my first visit where it was relativity calm which resulted in some nice reflections on the water, and the tide was coming in which meant the Thrombolites were submerged again on this visit, and I ended up getting wet to set my camera up low enough to get the composition I was after on my final star trail series, but I think it was worth it for the shot I ended up getting. Here are a few of the photos from the night:

http://www.redbubble.com/people/eos20/art/4261586-2-star-trails-over-lake-clifton

http://www.redbubble.com/people/eos20/art/4261582-2-star-trails-over-lake-clifton-thrombolites

http://www.redbubble.com/people/eos20/art/4262314-3-star-trails-over-thrombolites

The wooden jetties at Derg Marina, Ballina, above Killaloe Bridge at the bottom of Lough Derg, suffered severe damage in the floods.

Summer afternoon, summer afternoon; to me those have always been the two most beautiful words in the English language.
~ Henry James

At around 5pm I went back to the jetty I photographed yesterday to see what it looked like in the late afternoon light on a sunny day.

About the photo: This time I got even lower and photographed the jetty. I shielded the lens with my hand as I hadn’t brought my the sun shade for my lens. In Lightroom I brought out the colour of the wood a bit more and had to do a straighten and a crop as I hadn’t quite gotten the horizon straight.

Java EE servers are based on the Java™ 2 Platform, Enterprise Edition (J2EE™) and is used widely to provide code portability, reuse across tiers, platform support, scalability and for EJB strengths. Instead these supports are provided by the most of the java EE servers, this article is the place where you can share the Java EE servers used during your project development. I have assessed most of the Java EE servers used by the developers in the below. Kindly choose the Java EE server(Choose all that apply) which you use, also share the reason why you choose the particular Java EE server for your project development. Also if your option is others remark your Java EE server in the comments.

If you spend your whole life waiting for the storm, you’ll never enjoy the sunshine.
~Morris West

A stormy day today with lots of wind. I thought it’d be interesting to go to the same marina as where I shot Boats. I actually managed to get a few good shots today and picking which one to upload was difficult (the luxury!).

About the photo: I used the landscape setting to take this photo and played around with viewpoints, rather than camera settings today. I have several versions of this photo, but I prefer this one where I got down low over the standing-up versions. I think it’s much more powerful in leading your eye through the photo. Also, I deliberately broke the rule-of-thirds here and I think it paid off.

These terns seem to love the posts on this little jetty. I had seen birds on these numerous times before and thought they looked pretty cool. I had ventured to the spot a few times hoping to get a shot similar to this but the birds never co-operated… Sometimes there would be seagulls hogging this prime real estate, but for some reason they just seemed to ‘flighty’ when I would be about to take the shot !  This particular foggy morning the terns were having their turn at the prime real estate and it all came together and I shot this on 6×17 and this is a 6×6 crop so I’m pretty stoked with it.

‘prime real estate  –  medium format 6×6 velvia. ’

Visiting Pulau Ketam 7A Jetty at 2:30pm on 25th Nov 2009

This page will describe how to create a spring MVC application to test a connection to MySQL database. The user will provide the connection URL and username/password. The system will make a simple connection to the database and return the results to the screen.

Requirements

• Access to a MySQL Server
• Maven 2
• Eclipse
• Spring 2.5
• Java 1.5 or above

Start a new Project

Start a new project by creating it from an archetype.

mvn archetype:generate
Choose option:
18: internal -> maven-archetype-webapp (A simple Java web application)

Answer the questions like this:

Define value for groupId: : test
Define value for artifactId: : spring-mysql-test
Define value for version:  1.0-SNAPSHOT: :
Define value for package:  test: :
Confirm properties configuration:
groupId: test
artifactId: spring-mysql-test
version: 1.0-SNAPSHOT
package: test
 Y: :

cd spring-mysql-test
modify pom.xml and insert the following dependencies

	<dependencies>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.9</version>
		</dependency>
		<dependency>
		  <groupId>org.springframework</groupId>
		  <artifactId>spring</artifactId>
		  <version>2.5.6</version>
		</dependency>
		<dependency>
		  <groupId>org.springframework</groupId>
		  <artifactId>spring-webmvc</artifactId>
		  <version>2.5.6</version>
		</dependency>
	<dependency>
		<groupId>org.apache.geronimo.specs</groupId>
		<artifactId>geronimo-servlet_2.5_spec</artifactId>
		<version>1.2</version>
		<type>jar</type>
		<scope>provided</scope>
	</dependency>
	</dependencies>

insert the following into

spring-mysql-test/src/main/webapp/WEB-INF/web.xml

	<display-name>TestWeb</display-name>
	<servlet>
		<servlet-name>spring</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	</servlet>

	<servlet-mapping>
		<servlet-name>spring</servlet-name>
		<url-pattern>/app/*</url-pattern>
	</servlet-mapping>

	<welcome-file-list>
		<welcome-file>/app/helloWorld</welcome-file>
	</welcome-file-list>

Insert the following into

spring-mysql-test/src/main/webapp/WEB-INF/spring-servlet.xml

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

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-2.5.xsd">

	<context:component-scan base-package="test" />

	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/jsp/" />
		<property name="suffix" value=".jsp" />
	</bean>

</beans>

Create a java class that looks like this…

spring-mysql-test/src/main/java/test/HelloWorldController.java

package test;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
import org.springframework.stereotype.Controller;

@Controller("/helloWorld")
public class HelloWorldController extends AbstractController {
	@Override
	protected ModelAndView handleRequestInternal(HttpServletRequest request,
			HttpServletResponse response) throws Exception {

		ModelAndView mav = null;
		// control logic goes here
		mav = new ModelAndView("helloWorld");
		return mav;
	}
}

spring-mysql-test/src/main/webapp/WEB-INF/jsp/helloWorld.jsp

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
	<head>
		<title>HelloWorld test page</title>
		<meta http-equiv="Content-type" content="text/html; charset=iso-8859-1" />
		<meta http-equiv="Content-Language" content="en-us" />
	</head>

	<body>
		Hello World page!
	</body>
</html>

Run the Project

In order to run the project we need to put a couple of more things into pom.xml file.

1. The jetty plugin will allow Maven to run the project in the jetty servlet container. In the plug-in section of the pom.xml file put in the following…
2. By default Maven uses an old version of the JDK to compile. We need to set it to use a higher version. (supports annotations). If you don’t have 1.6 then change the source and target elements below to 1.5 at least.

pom.xml inside the build tag

  <build>
    <finalName>spring-mysql-test</finalName>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.0.2</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>jetty-maven-plugin</artifactId>
				<configuration>
					<scanIntervalSeconds>1</scanIntervalSeconds>
				</configuration>
			</plugin>
		</plugins>
  </build>

To run the web application type:
type jetty:run

Navigate your browser to http://localhost:8080/app/helloWorld to test if everything is okay up to this point. If something is not working please review the steps seen above and make sure you at least see hello world printed on the screen.

We will create a Controller that draws a input form that the user can use to specify database url, username, password.

The controller will take this form submission and make a connection to the database with the results printed to the screen.

spring-mysql-test/src/main/java/test/TestDBController.java

package test;

import java.sql.Connection;
import java.sql.DriverManager;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.validation.BindException;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.SimpleFormController;

@Controller("/dbParameters")
public class TestDBConnectionController extends SimpleFormController {

	public TestDBConnectionController() {
		setFormView("dbParameters");
		setCommandClass(DBParam.class);
		setSuccessView("success");
		setCommandName("dbParam");
	}

	@Override
	protected ModelAndView processFormSubmission(HttpServletRequest request,
			HttpServletResponse response, Object command, BindException errors)
			throws Exception {
		System.out.println("form submitted");

		DBParam dbParam = (DBParam)command;
		String url = dbParam.getUrl();
		String username = dbParam.getUsername();
		String password = dbParam.getPassword();

		// make a connection
		Class.forName("com.mysql.jdbc.Driver").newInstance();
		Connection conn = DriverManager.getConnection(url, username, password);
		System.out.println("got a connection: " + conn);

		return super.processFormSubmission(request, response, command, errors);
	}
}

We have enabled component scanning in our spring-servlet.xml file so we don’t have to register this controller in the xml file.

spring-mysql-test/src/main/webapp/WEB-INF/jsp/dbParameters.jsp

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
<title>DB Parameters</title>
<meta http-equiv="Content-type" content="text/html; charset=iso-8859-1" />
<meta http-equiv="Content-Language" content="en-us" />

</head>
<body>
	<form method="post">
		<label>JDBC connect string: </label><input type="text" name="url"/><br/>
		<label>password: </label><input type="text" name="username"/><br/>
		<label>username: </label><input type="password" name="password"/><br/>
		<input type="submit" value="submit"/><br/>
	</form>
</body>
</html>

spring-mysql-test/src/main/webapp/WEB-INF/jsp/success.jsp

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
<title>DB Parameters</title>
<meta http-equiv="Content-type" content="text/html; charset=iso-8859-1" />
<meta http-equiv="Content-Language" content="en-us" />

</head>
<body>
	success
</body>
</html>

Run the project

You may run the project under jetty

mvn jetty:run

navigate your browser to:

http://localhost:8080/

http://localhost:8080/app/dbParameters

That’s it for now!!!

Two people hurt on jetty

Written by Nick Grube, The Triplicate November 10, 2009 12:00 am

Two people, including a 10-year-old boy, were washed off the Crescent City jetty by a wave Sunday and taken by ambulance to Sutter Coast Hospital.

http://www.triplicate.com/20091110107428/News/Local-News/Two-people-hurt-on-jetty

TWINS Paula and Lee Bowman have been singing together since they could talk…. From The Australian. Full story

This site may contain information about: diamond cut. The blog is also related to: diamond bridal jewelry.

This page describes the process of creating a standard web project using maven Archetypes. Afterwards we will run the web application in the built-in servlet container called jetty and an external one with Tomcat 6.

Requirements

1. Eclipse J2EE IDE
2. Tomcat installed and integrated with eclipse WTP.
3. Maven 2
4. Ability to command line on your machine

We start by creating the project

mvn archetype:generate

Choose option for “maven-archetype-webapp”

By default the archetype does not create a javasource folder so go ahead and create the following directory under the project.

src/main/java

Also by default the web application is not a WTP application, it has no idea how to run itself under jetty and does not know how to regenerate itself as an eclipse project.

In order to make this project do all those cool things we need to add a couple lines of code in the plugins section of the pom.xml file.

		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-war-plugin</artifactId>
			<configuration>
				<warName>${artifactId}</warName>
			</configuration>
		</plugin>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-eclipse-plugin</artifactId>
			<configuration>
				<projectNameTemplate>${artifactId}</projectNameTemplate>
				<wtpapplicationxml>true</wtpapplicationxml>
				<downloadSources>true</downloadSources>
				<downloadJavadocs>true</downloadJavadocs>
				<wtpversion>1.5</wtpversion>
				<classpathContainers>
					<classpathContainer>org.eclipse.jst.j2ee.internal.web.container</classpathContainer>
					<classpathContainer>org.eclipse.jst.j2ee.internal.module.container</classpathContainer>
				</classpathContainers>
			</configuration>
		</plugin>
		<plugin>
			<groupId>org.mortbay.jetty</groupId>
			<artifactId>jetty-maven-plugin</artifactId>
		</plugin>

By default the pom.xml that is created by this archetype does not specify to the other plugins what jvm version we will be using: In the build section of the pom.xml file put the following.

	<pluginManagement>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
		<configuration>
			<source>1.6</source>
			<target>1.6</target>
		</configuration>
			</plugin>
		</plugins>
	</pluginManagement>

In order to create a web application you need additional dependencies to be added

<dependency>
	<groupId>org.apache.geronimo.specs</groupId>
	<artifactId>geronimo-servlet_2.5_spec</artifactId>
	<version>1.2</version>
	<type>jar</type>
	<scope>provided</scope>
</dependency>

Regenerate the eclipse project

mvn eclipse:clean eclipse:eclipse

Return to eclipse and refresh the project.

Creating a servlet

Create a test Servlet.

package com.test;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TestServlet extends HttpServlet {

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("servlet ran successfully");
		request.getRequestDispatcher("/index.jsp").forward(request, response);
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	}

}

Modify the xml to look like this:

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
  	<servlet-name>TestServlet</servlet-name>
  	<display-name>TestServlet</display-name>
  	<description></description>
  	<servlet-class>
  	com.test.TestServlet</servlet-class>
  </servlet>
  <servlet-mapping>
  	<servlet-name>TestServlet</servlet-name>
  	<url-pattern>/TestServlet</url-pattern>
  </servlet-mapping>
</web-app>

Running the Web Project in Jetty

In the project top level directory start the jetty servlet engine.

mvn jetty:run

Open browser and navigate to http://localhost:8080/ You should be seeing a hello world page. To test the servlet navigate to http://localhost:8080/TestServlet

When you run the servlet you should see “servlet ran successfully” printed to the console and the same Hello World message in the browser.

When you are done with the test, shut down the jetty server by hitting CTRL-C on the command line window.

Running the Web Project in Tomcat 6

Please make sure you have shut-down jetty before proceeding… Unless you changed them both jetty and tomcat 6 run on the default port of 8080. They both can not run at the same time.

Using Eclipse WTP all you need to do is make sure that Tomcat is defined and you are able to start and stop it. Right click on the project and click “Run On Server” option. Tomcat should show some output on the terminal. Follow the same steps you did while testing jetty. You should get the same results as above.

Congratulations

You have just configured a simple web application project using archetypes and hosted the application using both the built in web-app server called jetty and Tomcat 6 under eclipse using WTP.

You can also try out the following post. This is a simpler way to start a Spring MVC application from an archetype.

Thats all for now!