Joe on Computing http://joemorrison.org/blog How I Learned to Stop Worrying and Love Writing Software Fri, 24 Oct 2008 01:38:36 +0000 http://wordpress.org/?v=2.6.2 en Java template for WSDL-first web services using CXF (for Maven2 and Eclipse) http://joemorrison.org/blog/2008/10/23/cxf-wsdl-first/ http://joemorrison.org/blog/2008/10/23/cxf-wsdl-first/#comments Fri, 24 Oct 2008 01:38:36 +0000 Joe http://joemorrison.org/blog/?p=21 This took me a while to put together so I thought I’d post it. I wanted the simplest possible template for building a web service in Java. I wanted it to be JAX-WS compliant, so I used the CXF open source implementation which is not only compliant, but also flexible and fast. I also wanted the template to be WSDL first, meaning that I should be able to edit the WSDL by hand to maintain total control over the service contract, then from that, generate Java code to make it easy to fill in the implementation.  (I consider that to be an important part of web service best practices. Doing it the other way - automatically generating WSDL from code - is simpler, but results in messy, sometimes incorrect WSDL that limits your ability to change web service implementations later.) Furthermore, I didn’t want to edit any generated code. I wanted to be able to fill in the implementation details by inheriting from a generated class or implementing a generated interface. Finally, I wanted to take advantage of Maven to build the project, but also be able to work on it in Eclipse, taking advantage of its Web Tools Platform (WTP) to allow synchronization with a live application server. Here’s the result in just under 300 lines of code. (Or you can cut to the chase and just download the zip file and follow the instructions at the end of this posting.)

First, here is the trade.xsd schema file containing the input and output datatypes used by the web services:

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

<xsd:schema targetNamespace="http://com.joemo.schema.trade" xmlns="http://com.joemo.schema.trade"
	xmlns:xsd="http://www.w3.org/2001/XMLSchema">

	<!-- web service input types -->

	<xsd:element name="trade">
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element name="security" type="xsd:string" minOccurs="1" maxOccurs="1" />
				<xsd:element name="quantity" type="xsd:integer" minOccurs="1" maxOccurs="1" />
				<!-- note the use of "unbounded"; comments can occur multiple times -->
				<xsd:element name="comments" type="comment" minOccurs="1" maxOccurs="unbounded" />
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>

	<xsd:complexType name="comment">
		<xsd:sequence>
			<xsd:element name="message" type="xsd:string" minOccurs="1" maxOccurs="1" />
			<xsd:element name="author" type="xsd:string" minOccurs="1" maxOccurs="1" />
		</xsd:sequence>
	</xsd:complexType>

	<!-- web service output types -->

	<xsd:element name="status">
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element name="id" type="xsd:string" minOccurs="1" maxOccurs="1" />
				<xsd:element name="message" type="xsd:string" minOccurs="1" maxOccurs="1" />
			</xsd:sequence>
		</xsd:complexType>
	</xsd:element>

</xsd:schema>

Next, we need the trade.wsdl file which imports the schema file and completes the WSDL definition:

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions targetNamespace="http://com.joemo.schema.tradeservice"
	xmlns="http://com.joemo.schema.tradeservice"
	xmlns:tr="http://com.joemo.schema.trade"
	xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
	xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

	<wsdl:types>
		<xsd:schema targetNamespace="http://com.joemo.schema.tradeservice">
			<xsd:import namespace="http://com.joemo.schema.trade" schemaLocation="trade.xsd" />
		</xsd:schema>
	</wsdl:types>

	<wsdl:message name="tradeInput">
		<wsdl:part name="trade" element="tr:trade" />
	</wsdl:message>

	<wsdl:message name="tradeOutput">
		<wsdl:part name="status" element="tr:status" />
	</wsdl:message>

	<wsdl:portType name="TradeService">
		<wsdl:operation name="book">
			<wsdl:input message="tradeInput" />
			<wsdl:output message="tradeOutput" />
		</wsdl:operation>
	</wsdl:portType>

	<wsdl:binding name="TradeServiceHTTPBinding" type="TradeService">
		<wsdlsoap:binding style="document"
			transport="http://schemas.xmlsoap.org/soap/http" />
		<wsdl:operation name="book">
			<wsdlsoap:operation soapAction="" />
			<wsdl:input>
				<wsdlsoap:body use="literal" />
			</wsdl:input>
			<wsdl:output>
				<wsdlsoap:body use="literal" />
			</wsdl:output>
		</wsdl:operation>
	</wsdl:binding>

	<wsdl:service name="TradeServicePorts">
		<wsdl:port binding="TradeServiceHTTPBinding" name="TradeService">
			<wsdlsoap:address
				location="http://localhost:9084/tradeService/TradeServicePorts" />
		</wsdl:port>
	</wsdl:service>

</wsdl:definitions>

Now we need a Maven project file that will take this WSDL and generate the Java code. Here’s what the pom.xml file looks like. It’s long and messy but it does a lot. It specifies all the dependencies and the compiler level, includes the rule to generate Java code from WSDL whenever necessary, and includes Jetty and WTP support for testing and running the web services in different environments.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.joemo</groupId>
	<artifactId>ws-example</artifactId>
	<packaging>war</packaging>
	<version>0.1</version>
	<name>ws-example</name>
	<url>http://maven.apache.org</url>
	<properties>
		<cxf.version>2.1</cxf.version>
		<spring.version>2.5</spring.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-core</artifactId>
			<version>${cxf.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-frontend-jaxws</artifactId>
			<version>${cxf.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-transports-http</artifactId>
			<version>${cxf.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-common-utilities</artifactId>
			<version>${cxf.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.4</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<!-- Use Java 5 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.5</source>
					<target>1.5</target>
				</configuration>
			</plugin>

			<!-- CXF WSDL-to-Java code generation -->
			<plugin>
				<groupId>org.apache.cxf</groupId>
				<artifactId>cxf-codegen-plugin</artifactId>
				<version>2.0.6</version>
				<executions>
					<execution>
						<id>generate-sources</id>
						<phase>generate-sources</phase>
						<configuration>
							<sourceRoot>${basedir}/target/generated/src/main/java</sourceRoot>
							<wsdlOptions>
								<wsdlOption>
									<wsdl>src/main/resources/trade.wsdl</wsdl>
								</wsdlOption>
							</wsdlOptions>
						</configuration>
						<goals>
							<goal>wsdl2java</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<!-- Jetty support for testing -->
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>maven-jetty-plugin</artifactId>
			</plugin>
		</plugins>
		<!-- Eclipse WTP support -->
		<pluginManagement>
			<plugins>
				<plugin>
					<artifactId>maven-eclipse-plugin</artifactId>
					<configuration>
						<wtpversion>2.0</wtpversion>
						<wtpapplicationxml>true</wtpapplicationxml>
						<wtpmanifest>true</wtpmanifest>
						<downloadSources>true</downloadSources>
						<downloadJavadocs>true</downloadJavadocs>
						<projectNameTemplate>[artifactId]-[version]</projectNameTemplate>
						<manifest>${basedir}/src/main/resources/META-INF/MANIFEST.MF</manifest>
					</configuration>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>
</project>

Among other things, the rules in this pom.xml file will generate a Java interface called TradeService (based on the names in the WSDL file). The only code we will have to write is the implementation of this interface. Although this generation is done automatically by any Maven commands that need it (e.g. mvn package or mvn install) you might want to force it to be done sooner rather than later, so that you can refresh your Eclipse project with the generated code, enabling Eclipse to recognize the interface that you’re trying to implement. You can do this using the commands:

mvn generate-sources
mvn eclipse:clean eclipse:eclipse

This generates Java code from the WSDL, then regenerates the Eclipse project files, after which you should be able to refresh the project in Eclipse. If you see errors about libraries not being found, you may need to configure Eclipse to know about your Maven repository, i.e. select Eclipse / Window / Preferences / Java / Build Path / Classpath Variables, then enter the appropriate settings, e.g.

Name: M2_REPO
Path: C:/Documents and Settings/MyAccount/.m2/repository

Once the project is properly configured in Eclipse, you can fill in the implementation:

package com.joemo.service;

import trade.schema.joemo.com.Comment;
import trade.schema.joemo.com.Status;
import trade.schema.joemo.com.Trade;
import tradeservice.schema.joemo.com.TradeService;

public class TradeServiceImpl implements TradeService {

	public Status book(Trade trade) {
		System.out.print ("Booking security ");
		System.out.print (trade.getSecurity());
		System.out.print (", quantity ");
		System.out.print (trade.getQuantity());
		System.out.println();
		if (trade.getComments() != null) {
			System.out.println ("Comments:");
			for (Comment c : trade.getComments()) {
				System.out.print (c.getAuthor());
				System.out.print (": ");
				System.out.print (c.getMessage());
				System.out.println();
			}
		}
		Status s = new Status();
		s.setId("12345");
		s.setMessage("ok");
		return s;
	}

}

We are almost done. We still need a web.xml file which will direct SOAP requests to the CXF infrastructure:

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:appContext.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<servlet>
		<servlet-name>dispatcher</servlet-name>
		<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<url-pattern>/*</url-pattern>
	</servlet-mapping>
</web-app>

Finally, we need the appContext.xml file, which is the Spring configuration file loaded by CXF that defines the web service endpoint:

<?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:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:jaxws="http://cxf.apache.org/jaxws"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd"
	default-dependency-check="none" default-lazy-init="false">

	<!-- Load the needed resources that are present in the cxf* jars -->
	<import resource="classpath:META-INF/cxf/cxf.xml" />
	<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
	<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

	<!-- Hook up the web service -->
	<jaxws:endpoint id="ws-example" implementor="com.joemo.service.TradeServiceImpl"
		address="/ws-example" />

</beans>

That’s everything. There are six files, only one of which contains any Java code. You need to make sure you put each file in the right place:

ws-example/pom.xml
ws-example/src/main/resources/trade.xsd
ws-example/src/main/resources/trade.wsdl
ws-example/src/main/resources/appContext.xml
ws-example/src/main/webapp/WEB-INF/web.xml
ws-example/src/main/java/com/joemo/service/TradeServiceImpl.java

A zip file of this example is available for download here. To build and run it, you will need Maven to be installed on your development system. Unzip the file, and in the directory containing the pom.xml file, run the command:

mvn jetty:run

That will generate the Java code from the WSDL, build the example, and run the web service in the Jetty container. You should be able to visit the URL http://localhost:8080/ws-example/ws-example?wsdl from a web browser and see the WSDL for the web service, test the web service using SoapUI, and so on.

Alternatively you can run the command:

mvn eclipse:eclipse

and follow the directions from my earlier blog entry to run the example using Eclipse WTP, which will allow you to edit the code while keeping it synchronized with a live application server.

Good luck! If you encounter any problems using this template, please email me or post a comment so that I can look into it and revise the instructions if necessary.

]]> http://joemorrison.org/blog/2008/10/23/cxf-wsdl-first/feed/ A maze of twisty little Java web service standards, all alike http://joemorrison.org/blog/2008/10/22/a-maze-of-twisty-little-java-web-service-standards-all-alike/ http://joemorrison.org/blog/2008/10/22/a-maze-of-twisty-little-java-web-service-standards-all-alike/#comments Wed, 22 Oct 2008 21:40:57 +0000 Joe http://joemorrison.org/blog/?p=18 It’s almost impossible to keep up with all the fractal-like Java standards related to web services. As fast as each can be learned, Sun invents another, and a dozen open source implementations appear. For my own sanity I tried to create a rough map of some of them. I tried to avoid making recommendations; my main objective was to sketch out how they fit together. I also focused on the open source options; there are many good commercial implementations of all of these too.

First, it’s important to understand that in the open source world, there are three main players with implementations of of these standards: Sun, the Apache foundation, and Codehaus. There are other open source implementations as well, but these are the three 800 pound gorillas, for a total of 2400 pounds, or almost exactly one metric tonne (for our international audience).

Second, keep in mind that there are three important APIs which are inter-related: JAX-WS, JAXB, and StAX. Once you understand how these fit together, everything else falls into place more easily.

JAX-WS

Let’s begin our journey with the latest Sun standard for creating and consuming web services: JAX-WS, which stands for Java API for XML Web Services. This standard was introduced in 2004. You can ignore JAX-RPC, since JAX-WS replaces it.

There are three noteworthy implementations of JAX-WS. The first is from Sun, and is called JAX-WS RI for the JAX-WS Reference Implementation (they always had a way with names). The second and third are both from the Apache Group and are called Axis2 and CXF. You can ignore Axis1, XFire, and Celtix, since they are all obsolete. There is also a web service framework called Spring-WS, but it’s not JAX-WS compliant.

So if you are creating web services in Java, the first order of business is to to choose an implementation to work with, and unless you have a reason not to, you should probably stick to one that complies with JAX-WS, which means either JAX-WS RI, Axis2, or CXF.

Related to these is an open source project from Sun called Web Services Interoperability Technologies (WSIT), previously known as Project Tango. This is an implementation of several web service standards (WS-SecurityPolicy, WS-ReliableMessaging, and so on). Metro is an open source web service stack which is a combination of JAX-WS RI and WSIT (so it’s actually a reasonable fourth option).

JAX-WS is oriented around SOAP web services, but many programmers are now using the REST approach. Sun is coming out with the JAX-RS API to support that, but it’s not quite ready yet.

JAXB

Web service development requires mapping between XML and Java objects. JAXB is the Sun API for that (also referred to as JAXB2 since the latest version is the important one). There are two noteworthy implementations: JAXB-RI (Sun’s reference implementation) and JaxMe (the unfortunately named contribution from Apache). JaxMe is in the incubation stage and is not formally part of Apache yet. There are many other interesting and popular XML/Java mapping frameworks, but most of them are not compliant with JAXB. Examples include Castor (from Codehaus), JiBX (a spectacularly fast open source implementation), and XMLBeans (a flexible implementation from Apache).

A recurring source of confusion is that in the past, Sun was less clear about the distinction between APIs and reference implementations, so people would take JAXB to mean both, and you would often see online articles like “Which is better: JAXB or JiBX?” But today developers should always try to use the JAXB API, which will enable a choice of compliant implementations such as JAXB-RI or JaxMe with minimal or no code changes.

StAX

For Java code that needs to read and write large XML documents quickly without necessarily mapping them to objects, there is the Streaming API for XML (StAX). There are several implementations of this API too. There is the Sun Java Streaming XML Parser called SJSXP (another snappy name from Sun), the Woodstox open source implementation which is excellent, and the StAX reference implementation from Codehaus which is referred to simply as StAX (unfortunately perpetuating the confusion between APIs and implementations). Xerces is a streaming XML processing library which used to be part of the Apache project, and work was underway to make it StAX compliant, but that was dropped.

Putting it all together

Web services need to process XML, sometimes mapping it to and from Java objects (e.g. for creating proxy objects and an RPC-like experience), and sometimes processing it directly (e.g. for streaming results when high performance is needed). Therefore Sun designed the JAX-WS API to rely on the JAXB API, which makes perfect sense; any JAX-WS compliant web service implementation should be able to use any JAXB compliant mapping library. Other relationships between these APIs are up to individual implementations. For example, JAX-WS RI supports the StAX API, so you can use any StAX implementation for streaming. CXF also supports the StAX API, as well as a host of Java/XML mapping options including JAXB (allowing the use of any JAXB compliant mapping implementation), XMLBeans, Castor, and JiBX. Yes, they are heroes.

So if you get confused, just ask yourself clarifying questions like: Which Java web service libraries support JAX-WS? Which JAXB compliant Java/XML mapping implementation shall I use for this project? Which is better for processing streaming XML: Woodstox or the StAX reference implementation?

If you’re still confused, then just accept the recommendations I promised not to make: Use CXF for your web services (which complies with JAX-WS), JAXB-RI for your Java/XML mapping (which complies with JAXB), and Woodstox for streaming (which complies with StAX).

]]> http://joemorrison.org/blog/2008/10/22/a-maze-of-twisty-little-java-web-service-standards-all-alike/feed/ Is Eclipse collapsing under its own weight? http://joemorrison.org/blog/2008/10/20/is-eclipse-collapsing-under-its-own-weight/ http://joemorrison.org/blog/2008/10/20/is-eclipse-collapsing-under-its-own-weight/#comments Mon, 20 Oct 2008 21:39:51 +0000 Joe http://joemorrison.org/blog/?p=17 Maybe Eclipse’s black-hole-like splash screen is more appropriate than its designers realize. Eclipse’s open architecture has enabled the creation of countless useful plugins, and that’s helped maintain its position as the leading Java IDE. But as plugins compound upon plugins, bugs and compatibility issues have been surfacing increasingly frequently, and I’m starting to get the sense the Eclipse developers have lost control.

I spent considerable time downloading Ganymede today for only one reason: I wanted to try the new JAX-WS WSDL First project wizard. It would be hard to come up with a geekier, more obscure name than that, but in essence the feature promised to allow me to create a web service with the click of a button, following various best practices. With great anticipation (okay, I’m exaggerating; with vague hopefulness) I downloaded Ganymede, and decided to try the wizard with the CXF web service library. Here’s the error I got:

Error instantiating builder 'org.eclipse.stp.sc.annvalidator'.
Plug-in org.eclipse.stp.sc.annvalidator was unable to load class org.eclipse.stp.sc.annvalidator.builder.AnnValidator.

What? Did they even test this? And who is Ann Validator anyway? A quick Google search turned up incomprehensible articles with titles like “AnnValidator missing from Ganymede Update”. The gist of the articles was basically “oh yeah, we should clean up our releases better”.

I’m probably oversimplifying the Eclipse point of view, but I don’t really care. The point is, now I have to research an obscure problem in order to perform something that should be the most basic of activities - creating a simple web service, using a fresh download of a supposedly mature IDE.

There is only one thing keeping me from switching to Netbeans immediately and recommending that everyone dump Eclipse: I’m still waiting for a good Perforce plugin. Okay, two things: I’m also addicted to Max Uermann’s Goto File plugin.

]]> http://joemorrison.org/blog/2008/10/20/is-eclipse-collapsing-under-its-own-weight/feed/ Tomato: An antioxidant for your router http://joemorrison.org/blog/2008/10/06/tomato-an-antioxidant-for-your-router/ http://joemorrison.org/blog/2008/10/06/tomato-an-antioxidant-for-your-router/#comments Tue, 07 Oct 2008 00:21:52 +0000 Joe http://joemorrison.org/blog/?p=16 Every few months my Linksys WRT54G V4 home wireless router stops working and nothing short of a full reset gets it going again. This weekend it happened again. I got fed up and started Googling. I found out I’m not the only one to suffer from this problem. But then I found out that in 2003 Linksys, under pressure to comply with the GPL, released the router firmware and immediately afterward people started coming out of the woodwork improving it. (Doesn’t anyone have better things to do with their time?) Seriously, this has to be one of the best open source success stories ever. Some open-source variations of the firmware provide more features, giving this $60 router functionality similar to a $600 router. Others allow you to boost the RF signal. Still others provide a simplified and improved user interface. Most allow SSH or Telnet access to the router’s Linux kernel. All of them reportedly improve its reliability. I researched several of these and tried DD-WRT for a few hours. It’s very powerful and I was almost sold, but then I discovered Tomato. It’s perfect and I’m never going back.

From the Tomato home page: “Tomato is a small, lean and simple replacement firmware for Linksys’ WRT54G/GL/GS, Buffalo WHR-G54S/WHR-HP-G54 and other Broadcom-based routers. It features a new easy to use GUI, a new bandwidth usage monitor, more advanced QOS and access restrictions, enables new wireless features such as WDS and wireless client modes, raises the limits on maximum connections for P2P, allows you to run your custom scripts or telnet/ssh in and do all sorts of things like re-program the SES/AOSS button, adds wireless site survey to see your wifi neighbors, and more.”

It installed like a dream on top of DD-WRT, and the user interface is simple and clean. Most of the complexity is devoted to QoS functions, which I actually care about (unlike many of the obscure routing options provided by the original Linksys firmware) since I use my home computers for streaming music, Skype, and other network-intensive applications. Furthermore it provides nice usage monitoring and visualization tools. The user interface is a nice red color, the exact same shade as Campbell’s tomato soup.

After installation, my home network seems noticeably faster, but that may just be cognitive dissonance. (After all, if I spent an entire evening not making my network faster, that would make a pretty poor blog entry.) The main question now is whether my router’s reliability will improve, but from reviews online and my initial experience, I’m optimistic. We’ll see over the next few months.

If you decide to try installing Tomato, make sure your router hardware version is supported. For example, Tomato isn’t supported on the Linksys WRT54G V5 or later since Linksys removed half the RAM in all versions after V4.

]]> http://joemorrison.org/blog/2008/10/06/tomato-an-antioxidant-for-your-router/feed/ Orange lines http://joemorrison.org/blog/2008/08/02/orange-lines/ http://joemorrison.org/blog/2008/08/02/orange-lines/#comments Sat, 02 Aug 2008 19:32:51 +0000 Joe http://joemorrison.org/blog/?p=15 A few evenings ago I looked out of my kitchen window and saw an airplane’s vapor trail in the sunset - a beautiful, bright, clean, orange line cutting through the clouds. At that moment I had brief but unmistakable feeling of optimism about the human race.

For one thing, jet airplanes are a marvel of engineering. Hundreds of thousands of people collaborated to create them, maybe even millions if you include the scientists who worked out the principles of flight and jet propulsion, the inventors and engineers who applied those principles, the entrepreneurs who created an airline industry, and the pilots, air traffic controllers, technicians, and support staff who keep it all running. Think of everything that goes into an aircraft and try to count the number of people involved. Don’t forget the avionics, the bathrooms, and the in-flight entertainment system. (Maybe leave out the food, and definitely leave out the homeland security people.)

Then consider the manner by which all those people collaborated. Nobody was coerced, and it wasn’t necessary to gather everyone into a giant room to plan it all. Rather, it all came about gradually over the course of decades, fueled by a combination of personal initiative, market forces, and government action. It’s one of the greatest triumphs of managed capitalism. (We are all Keynesians now.) In Europe aircraft are made by English, French, and German people working together. Could anyone imagine that fifty years ago? Economic integration is the primary force protecting us from another world war.

But what’s most amazing is that flying is routine. At the tip of that orange line in the sky was a silver tube filled with people having dinner, reading newspapers, and generally acting as though it’s not a big deal to shoot through the sky at 600 miles per hour. But it is.

]]> http://joemorrison.org/blog/2008/08/02/orange-lines/feed/ Slimmer, trimmer messaging from Google http://joemorrison.org/blog/2008/07/15/slimmer-trimmer-messaging-from-google/ http://joemorrison.org/blog/2008/07/15/slimmer-trimmer-messaging-from-google/#comments Tue, 15 Jul 2008 17:10:11 +0000 Joe http://joemorrison.org/blog/?p=14 Google’s Protocol Buffers offer lightweight, language-independent object serialization. I love the design, especially as I’m increasingly seeing enterprise networks clogged with hordes of oversized XML messages. Protocol buffer bindings are available for C++, Java, and Python, but not C# yet. Once there is support for .NET, I think this could be a really interesting technology for financial applications.

]]> http://joemorrison.org/blog/2008/07/15/slimmer-trimmer-messaging-from-google/feed/ Developing Web applications with Maven and Eclipse: You *can* have it all http://joemorrison.org/blog/2008/06/01/developing-web-applications-with-maven-and-eclipse-you-can-have-it-all/ http://joemorrison.org/blog/2008/06/01/developing-web-applications-with-maven-and-eclipse-you-can-have-it-all/#comments Sun, 01 Jun 2008 16:14:08 +0000 Joe http://joemorrison.org/blog/2008/06/01/developing-web-applications-with-maven-and-eclipse-you-can-have-it-all/ When developing applications using Eclipse or a similar IDE, you quickly get used to being able to test your software immediately after making a change. Plugins like MyEclipseIDE enable that kind of instant edit/compile/test cycle for web applications as well.

But if you’re building web applications with Maven, it’s not so easy. Maven is a fantastic tool for building applications and managing dependencies, but it lends itself to a more batch-oriented mode of operation in which you build and deploy war files from the command line. I found myself wishing I could have the best of both worlds; building my web applications using Maven, but with a seamless edit/compile/test cycle when using Eclipse. Then I discovered the WTP (Web Tools Platform) project. Hallelujah!

WTP extends the Eclipse platform with tools for developing Web and Java EE applications. Not only does that include a way to incrementally deploy applications to an application server, it’s supported by Maven - so you can have your cake and eat it too. The trick is to add a clause to your Maven pom.xml file which causes Maven’s eclipse:eclipse target to emit the proper WTP configuration information. Then when you open the project in Eclipse, you can use WTP’s seamless deployment capabilities.

Here’s a step by step explanation of how to set this up:

1. First you need to have your web application working with Maven. There are plenty of tutorials on the web explaining how to do this. If you just want to create a simple example quickly, you can build a skeleton web application using this command (after you have Maven installed and working on your PC). This should be typed all on one line:

mvn archetype:create -DgroupId=com.lab49.example -DartifactId=myWebApp
     -DarchetypeArtifactId=maven-archetype-webapp

This will create a skeleton hello, world web application that can be built with Maven, which you can extend with JSP pages, classes, etc.

2. Add the following two clauses within the build element in the pom.xml file:

<!-- add support for Jetty testing -->
<plugins>
    <plugin>
        <groupId>org.mortbay.jetty</groupId>
        <artifactId>maven-jetty-plugin</artifactId>
    </plugin>
</plugins>

<!-- add Eclipse WTP support -->
<pluginManagement>
    <plugins>
        <plugin>
            <artifactId>maven-eclipse-plugin</artifactId>
            <configuration>
                <wtpversion>2.0</wtpversion>
                <wtpapplicationxml>true</wtpapplicationxml>
                <wtpmanifest>true</wtpmanifest>
                <downloadSources>true</downloadSources>
                <downloadJavadocs>true</downloadJavadocs>
                <projectNameTemplate>[artifactId]-[version]</projectNameTemplate>
                <manifest>${basedir}/src/main/resources/META-INF/MANIFEST.MF</manifest>
            </configuration>
        </plugin>
    </plugins>
</pluginManagement>

The Jetty support is not what this article is about, but it’s a nice thing to include. It enables you to test your code using the Maven command:

mvn jetty:run

to compile your application, start up a web server (based on the Jetty web server library), and deploy itself so you can access it via a URL something like:

http://localhost:8080/myWebApp/

Having to test your application by starting a web server from the command line is still a batch mode of operation and doesn’t perfectly fit the Eclipse model of development, but nonetheless it’s very convenient.

3. Now let’s enable the WTP support. Generate a set of Eclipse project files for your Maven project. If you had previously generated them without WTP support you should delete them and recreate them, i.e.

mvn eclipse:clean
mvn eclipse:eclipse

4. Make sure you have WTP support in your version of Eclipse. The easiest way to do that is to use the version Eclipse IDE for Java EE Developers which already includes WTP support. If you weren’t using that version before, you can download it, then open your original Eclipse workspace to migrate seamlessly. Otherwise you’ll have to follow these instructions to add WTP support to your existing version of Eclipse.

5. Set up your Maven web application as a Java project within Eclipse (i.e. create a new Java Project from existing source, and select the root Maven web application directory with the generated Eclipse config files). At that point you should see your Maven project in Eclipse, be able to edit JSPs, Java classes and so on.

6. Install an application server on your PC if you don’t already have one set up, e.g. Tomcat.

7. The next step is to link Eclipse to your Tomcat installation (or other application server). The WTP platform refers to this as setting up a Server Runtime Environment. To do this, go to Eclipse / Window / Preferences / Server / Installed Runtimes (this option will only be available if WTP support has been installed), click Add, select your application server type and version (e.g. Tomcat 6.0), and select the installation directory of the application server along with any other required options e.g. which JRE to use.

Then go to the Server View in Eclipse (Window / Show View/ Other… / Server / Servers). Right click in the window and select New / Server. Choose the server runtime you just configured. Click Finish.

The Servers view should now display an entry for your application server. Select it and click the green triangle icon to start the server. (Make sure the server was not running beforehand.) If everything is set up properly, Eclipse will launch the server, the console will show the startup log, and the server state in Eclipse will change to Started.

8. Finally, tell Eclipse to add your web application project to the application server. From the Servers View, right click on your application server and select Add and Remove Projects. Your Eclipse web application project should show up on the left hand side of the window as an available project (since Maven added the WTP configuration when generating the Eclipse project files). Click Add to move it over to the right hand side (configured projects) and click Finish.

If everything has been configured properly, the Server View will show your web application project listed under the application server, and the status will show as Synchronized. Your project will be live and accessible via a URL like:

http://localhost:8080/myWebApp/

Now you can leave your application server running all the time. You can edit JSPs, Java code, etc. in your web project and whenever you save a change, it will instantly be published to the application server. (If you look at the Servers View window, you’ll see it temporarily change to status republish then back to synchronized whenever you save a change).

Now you have an instant edit/compile/test cycle, but you can also rebuild your application at any time from the command line using Maven. You can have it all.

p.s. I’ve found Eclipse sometimes gets carried away validating various elements of web projects. This can be so slow as to make the IDE unusable. You can disable validation by selecting Window / Preferences / Validation. From this window you can disable validation globally, for specific projects, or for specific types of files.

p.p.s. If you are using Java 5 or Java 6, Eclipse may also highlight your web project in red with the error Java compiler level does not match the version of the installed Java project facet. To fix this, right click on the web project and select Properties. Select Project Facets. Click Modify Project. A list of Project Facets will be displayed. Correct the Java Version (e.g. from 1.4 to 5.0). Click Finish.

]]> http://joemorrison.org/blog/2008/06/01/developing-web-applications-with-maven-and-eclipse-you-can-have-it-all/feed/ A virtuous pairing http://joemorrison.org/blog/2008/04/16/a-virtuous-pairing/ http://joemorrison.org/blog/2008/04/16/a-virtuous-pairing/#comments Wed, 16 Apr 2008 13:48:53 +0000 Joe http://joemorrison.org/blog/2008/04/16/a-virtuous-pairing/ I ran across the following comments on an El Reg article about virtualization: Comments about “Virtualization: Nothing New”.

He’s right, isn’t he? Having the same company offer both virtualization and grid solutions is a truly virtuous pairing. First you tell people they need a grid solution to make a huge pool of computers look like a single one, then after it’s all set up you sell them virtualization software. It’s beautiful. It’s like if, for example, Nestle and Jenny Craig got together to simultaneously offer chocolate products and dieting solutions. Oh wait, they did: Nestle to buy Jenny Craig.

Still, cynicism aside, both trends make sense if you think about it. Commodity x86 hardware offers the cheapest computing cycles per dollar right now. For truly large scale computing that fact can’t be ignored, which means grid computing technologies are needed to harness and coordinate that power.

But software development is increasingly decentralized, as the cost of software and hardware decreases. At investment firms traders don’t want to wait for centralized IT organizations to get around to implementing their requirements - they want dedicated, local teams serving them quickly, and they can afford it. SOA provides a set of protocols and practices that allows decentralized development teams to work more efficiently and connect their software components together. This is creating demand for quickly being able to provision new hosts, databases, application servers, etc. that each team can manage independently. Virtualization makes it possible for a single system administration team to manage all the compute power, while other distributed development teams feel like they have the boxes to themselves.

So offering blade computing hardware, grid computing software, and virtualization solutions all at once isn’t an exercise in cynically extracting money from confused customers, but actually makes a kind of sense. I’m less sure about the Jenny Craig / Nestle thing, but I’ll think about it as I snack on my low-cal Anytime Bar.

]]> http://joemorrison.org/blog/2008/04/16/a-virtuous-pairing/feed/ My new favorite ISP http://joemorrison.org/blog/2008/03/13/my-new-favorite-isp/ http://joemorrison.org/blog/2008/03/13/my-new-favorite-isp/#comments Fri, 14 Mar 2008 03:37:07 +0000 Joe http://joemorrison.org/blog/2008/03/13/my-new-favorite-isp/ My new favorite web hosting provider is A Small Orange. Their pricing is competitive, and their tech support is unbelievably quick and clueful.

]]> http://joemorrison.org/blog/2008/03/13/my-new-favorite-isp/feed/ Understanding Java5 Generics http://joemorrison.org/blog/2008/01/27/understanding-java5-generics/ http://joemorrison.org/blog/2008/01/27/understanding-java5-generics/#comments Mon, 28 Jan 2008 00:09:11 +0000 Joe http://joemorrison.org/blog/2008/01/27/understanding-java5-generics/ Good article on Java5 Generics by Martin Wolf:

http://blogs.infosupport.com/martinw/articles/generics.aspx

It seems many programmers are confused about generics, in particular the use of the ? extends ... notation. The question mark is called a type wildcard, and is typically used as the value of a type parameter in a generic method. It means that wherever the method is invoked in your code, the compiler infers a specific type to be substituted for the wildcard and enforces that at compile time. The notation ? extends X is a bounded wildcard, meaning that the deduced type must be a subtype of X. Here’s a variation on Wolf’s example which I think might help clarify the difference.

Say you have a class Animal which supports the method feed(), with subclasses Cat and Dog. Consider this code which does not use generics:

public static void feedAnimals1(List<Animal> pets) {

	for (Animal a : pets) {
		a.feed();
	}

	for (int i=0; i < pets.size(); i++) {
		pets.set(i, (i % 2 == 0) ? new Cat() : new Dog());
	}
}

The argument pets is of type List<Animal>. That means that each element can be a Cat or a Dog object. They all understand the feed() method, and any element can be reassigned to a Cat or Dog object (since the elements are of type Animal).

But what if we write it this way instead?

public static void feedAnimals2(List<? extends Animal> pets) {

	for (Animal a : pets) {
		a.feed();
	}

	for (int i=0; i < pets.size(); i++) {
		pets.set(i, (i % 2 == 0) ? new Cat() : new Dog());    // compile error
	}
}

This second version uses generics. In this case we are not saying that the input must be of type List<Animal>. Rather, we are saying that the input must be of type List<X> where X is any subtype of Animal. At each location in the code where this method is called, the Java compiler will guess a suitable type for X at compile time and enforce it. It’s exactly as though you had written different overloaded versions of this method, one for lists of Cat objects, one for lists of Dog objects, and so on.

In the generic example the compiler will not let you randomly assign dogs and cats to the list elements, because the caller might legitimately pass in a list of Dog objects in which case the cat assignment would be illegal, and vice versa. But apart from that restriction, the generic version is more flexible. It can work on inputs of type List<Animal>, List<Dog>, or List<Cat> e.g.

	List<Dog> pets = new ArrayList<Dog>();
	pets.add(new Dog());
	pets.add(new Dog());
	feedAnimals1 (pets);    // compile error - pets must be of type List<Animal>
	feedAnimals2 (pets);    // ok

The Sun tutorial on generics explains all in detail:

http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

]]> http://joemorrison.org/blog/2008/01/27/understanding-java5-generics/feed/