In the Java EE 5 Tutorial “Development Roles” chapter we can see the following three roles, from the code to the deployment :

• Application Component Provider: “The application component provider is the company or person who creates web components, enterprise beans, applets, or application clients for use in Java EE applications.”
• Application Assembler: “The application assembler is the company or person who receives application modules from component providers and assembles them into a Java EE application EAR file.”
• Application Deployer and Administrator: “The application deployer and administrator is the company or person who configures and deploys the Java EE application …”

This page says that this is the Application Assembler job to configure the deployment descriptor before packaging the EAR.

Beside that, artifact produced by mavenized enterprise projects are EARs, already packaged. Plus, it often is the developer (or Application Component Provider) that write the packaging configuration.

Next comes the “configuration for deployment” time. Here, if deployment dependant configuration is in deployment descriptors you would have to unpack the EAR and possibly nested java archives (WARs and/or JARs) to get a hand on all deployment descriptors.

This task can be quite cumbersome and time consuming (really dumb too).

I’ve read about people using maven profiles to build several EARs with different configuration but this means that the different configurations are hosted in the development project and so are released at the same time. I needed a way to have the development project contains only development and testing configuration and have deployment specific configurations hosted in a separate project that have its own release lifecycle.

I wrote jaroverlay-maven-plugin to address this need. It’s another simple maven plugin that can take an existing maven artifact and apply an overlay to it. Here is an example configuration that add/remove/replace files inside an EAR and it’s nested java archives :

 <build>
  <plugins>
   <plugin>
    <groupId>org.n0pe.mojo</groupId>
    <artifactId>jaroverlay-maven-plugin</artifactId>
    <version>0.1-SNAPSHOT</version>
    <executions>
     <execution>
     <id>ear</id>
     <goals><goal>jaroverlay</goal></goals>
     <phase>package</phase>
     <configuration>
      <overlay>
       <source>
        <groupId>org.n0pe.mojo.examples</groupId>
        <artifactId>ear-example</artifactId>
        <version>0.1-SNAPSHOT</version>
        <type>ear</type>
       </source>
       <classifier>custom-packaging</classifier>
       <puts>
        <put>
         <from>src/main/resources/test.txt</from>
         <to>war-example-0.1-SNAPSHOT.war|WEB-INF/test.txt</to>
        </put>
        <put>
         <from>src/main/resources/test.txt</from>
         <to>ejb-example-0.1-SNAPSHOT.jar|META-INF/test/txt</to>
        </put>
       </puts>
       <removes>
        <remove>war-example-0.1-SNAPSHOT.war|index.jsp</remove>
        <remove>war-example-0.1-SNAPSHOT.war|WEB-INF/lib/commons-lang-2.3.jar|META-INF/NOTICE.txt</remove>
       </removes>
      </overlay>
     </configuration>
    </execution>
   </executions>
  </plugin>
 </plugins>
</build>


When writing a path to a file contained by a nested archive, use a pipe (”|”) to inform the plugin that it has to navigate inside a nested archive.

I did not released the 0.1 as the current code is more a proof of concept than anything. It is working well for file operations. I need to clean the code up and add support for directories operations and the 0.1 will be out.

The project is hosted at google code : http://code.google.com/p/jaroverlay-maven-plugin/

I released the second version of asadmin-maven-plugin today.

It added the following features :

• Issue#1: support for maven projects with “ejb” packaging
• support for (un)deploying to remote glassfish instance (thanks to Larry Sanderson that provided the patch)

The following issues were fixed :

• Issue#2: asadmin is not found when only glassfishHome is specified and glassfishHome/bin not in PATH (thanks to streifi that provided a patch)
• Issue#3: asadmin:start-domain hangs on windows (thanks again to streifi)

Go to the project’s page for more information.

I’m building a web backoffice for an IT product with GWT for several month now. I had to internationalize all the UI. GWT provides several mechanisms for i18n. I use Constants and Messages because I love the compile time check and the fact that deferred binding permutations provide a download as small as possible to the users.

All this worked well until we wanted to provide customers the ability to change how things are named in our product. In the UI layer of course !

Like said above, GWT is using deferred binding to provide a Constant/Message implementation per locale. I extended this mechanism to provide a Constant/message implementation per locale and a given GWT property.

Enough talk, lets see how this is done.

Classic i18n

Here we will use the Constants approach, this is working with Messages too. For the purpose of this example we will use only one message “businessKey” that is called “Business Key” in our product but that some customers will like to name “DaGlobalUniquePersonnalIdentifierToRuleThemAll” or anything else they want.

Following the GWT documentation about static string internationalization, create an interface that extends Constants :

    public interface MyI18N extends Constants {
        String businessKey();
        String anotherMessage();
    }


In the same package, provide a properties file for each locale you want to support :

MyI18N.properties :
    businessKey=Business Key
    anotherMessage=Another message

MyI18N_fr.properties :
    businessKey=Identifiant
    anotherMessage=Un autre message

All this is not enough to get i18n to work with GWT, you have to modify your gwt.xml file. Read the documentation for more information.

The first i18n overlay

Now we want to add an i18n overlay to change how “businessKey” is named for only one customer.

Create an interface that extends the previous MyI18N interface :
    public interface MyCustomI18N extends MyI18N {}

This interface can be empty as we only want to provide customized existing messages. Now create a properties file for each locale you want to support :

MyCustomI18N.properties :
    businessKey=DaGlobalUniquePersonnalIdentifierToRuleThemAll

MyCustomI18N_fr.properties :
    businessKey=IdentifiantGlobalUniquePersonnelPourLesControlerTous

Here we declare only the message(s) we want to overwrite in this i18n overlay.

Adding a GWT property

We now need a gwt property that will trigger the use of an i18n overlay. We will name it “flavour”. For this you have to modify you host page and you gwt.xml file.

We will have two possible value for this property : “default” and “customer1″.

Add the flavour property in a meta tag inside your host page :
    <meta name="gwt:property" content="flavour=customer1” />

Now you know that with some server side code you can change this property in your host page depending on various configuration details. It’s up to you.

Finally, add theses lines in your GWT module gwt.xml file :

    <define-property name=”flavour” values=”default,customer1” />
    <property-provider name=”flavour”>
    <![CDATA[
        var flavour = __gwt_getMetaProperty("flavour");
        if (flavour == null){
            flavour = "default";
        }
        return flavour;
    ]]>
    </property-provider>


This snippet will allow us to use this property’s value for deferred binding.

Writing an i18n factory

Next, we need a way to defer to runtime the choice between My18N and MyCustom18N constants. We need to add a permutation layer on top of the GWT built-in locale permutation. We will do this with a simple factory.

First, write the MyI18NFactory interface :
    public interface MyI18NFactory {
        MyI18N getMyI18N();
    }

Next, write the default implementation, aka MyDefaultI18NFactory :

    public class MyDefaultI18NFactory implements MyI18NFactory {
        private static final MyI18N i18n = (MyI18N) GWT.create(MyI18N.class);
        public MyI18N getMyI18N() {
            return i18n;
        }
    }


And the implementation for customer1, aka MyCustomerOneI18NFactory :

    public class MyCustomerOneI18NFactory implements MyI18NFactory {
        private static final MyI18N i18n = (MyI18N) GWT.create(MyCustomI18N.class);
        public MyI18N getMyI18N() {
            return i18n;
        }
    }


The only difference is the targeted i18n implementation.

Deferred binding

The final step is to add deferred binding for our MyI18NFactory implementations so that depending on the “flavour” property, GWT will instanciate MyDefaultI18NFactory or MyCustomerOneI18NFactory.

Simply add the following to your GWT module gwt.xml file :

    <replace-with class=”my.MyDefaultI18NFactory“>
        <when-type-is class=”my.MyI18NFactory”/>
        <when-property-is name=”flavour” value=”default“/>
    </replace-with>
    <replace-with class=”my.MyCustomerOneI18NFactory“>
        <when-type-is class=”my.MyI18NFactory”/>
        <when-property-is name=”flavour” value=”customer1“/>
    </replace-with>


Usage

To get the right i18n Constants implementation in your code you now can use the following statement :

    ((MyI18NFactory) GWT.create(MyI18NFactory.class)).getMyI18N().businessKey();


Of course you would like to cache the MyI18N instance as instanciation is an expensive task.

I don’t know if this is the simplest or the beautifulest way to do this. If someone has a better pattern I’ll be glad to learn !

This post is only a snapshot of what is available at the time of writing to use Glassfish from maven., seen from the perspective of a simple maven plugin developer (simple plugin or simple developer ?).

Before beginning asadmin-maven-plugin, I searched and tried several ways to use Glassfish from maven. Main use case is simply deployment and undeployment of applications.

There are two ways to do this “programmatically” :

• using the asadmin command, Glassfish specific,
• and using the JSR-88 api, app-server agnostic

Here are all the glassfish maven plugins I’ve found :

• cargo-maven2-plugin on http://codehaus.org/

  The Cargo maven plugin project will provide the JSR-88 way soon or later.

• glassfish-maven-plugin on http://code.google.com

  I couldn’t make this one work, source code available in the subversion repository has not moved since december, 2007. This plugin use the same approach as asadmin-maven-plugin : using the asadmin command

• glassfish-maven-plugin on http://java.net

  No source code, no files released yet.

• maven-glassfish-plugin on http://java.net again

  No source code, no files released yet.

• clownfish-maven-plugin on http://sourceforge.net

  Appears to use the JSR-88 Glassfish implementation. I did not try this one yet.

Appart from this, the exec-maven-plugin allows to execute external commands and some posts on the net provide examples of using this plugin to invoke the asadmin command from a maven pom. Some others posts talks about using ant tasks inside maven pom to invoke asadmin.

In fact asadmin-maven-plugin is based on what Wouter van Reeven explain in a post called Deploying to GlassFish using Maven2 on the AMIS Technology Blog. I was using the exec-maven-plugin the way it’s explained there in my projects when I realized how much xml I had to copy/paste around.

At the end of the day, asadmin-maven-plugin is just a convenience maven plugin to execute the asadmin glassfish command leveraging the “convention over configuration” concept that maven teached to me.

In conclusion, I hope that the support for JSR-88 will soon be available in Cargo as we, developers, mostly need the cargo’s integration api usable from unit tests. On the other side, I hope that beside the immediate need of a working solution I’ll have time to maintain and continue asadmin-maven-plugin development.

Next time I’ll publish some documentation about asadmin-maven-plugin configuration.

To ease the use of asadmin-maven-plugin I have set up a public repository that you can add to your maven settings / poms / proxies for maven to be able to download the plugin automagically.

The repositories are :

• Releases Repository : http://asadmin-maven-plugin.googlecode.com/svn/trunk/repository/releases - contains nothing ATM
• Snapshots Repository : http://asadmin-maven-plugin.googlecode.com/svn/trunk/repository/snapshots - contains the 0.1-SNAPSHOT

Here is the xml snippet you could add to your pom.xml file :

    <pluginRepositories>
        <pluginRepository>
            <id>asadmin-maven-plugin-releases-repository</id>
            <name>asadmin-maven-plugin-releases-repository</name>
            <url>http://asadmin-maven-plugin.googlecode.com/svn/trunk/repository/releases</url>
            <releases><enabled>true</enabled></releases>
            <snapshots><enabled>false</enabled></snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>asadmin-maven-plugin-snapshots-repository</id>
            <name>asadmin-maven-plugin-snapshots-repository</name>
            <url>http://asadmin-maven-plugin.googlecode.com/svn/trunk/repository/snapshots</url>
            <releases><enabled>false</enabled></releases>
            <snapshots><enabled>true</enabled></snapshots>
        </pluginRepository>
    </pluginRepositories>

Plus, if you browse the source tree you’ll find two exemple projects, a WAR and an EAR, that use this plugin.

To seamlessly use Glassfish from maven projects, JSR-88 seems to be answer. The cargo maven plugin has JSR-88 support planned but this will take time.

I published some days ago a maven plugin that simply wraps the asadmin command and aims to provide maven integration for starting, stopping glassfish and deploying and undeploying applications and modules.

Go to the Google Code page of asadmin-maven-plugin to download a preview version named asadmin-maven-plugin-0.1-SNAPSHOT : http://code.google.com/p/asadmin-maven-plugin/

The api is designed for easy extensibility so feel free to submit contributions !

Install the jar provided in the download section in your local repository and add this to your pom :

<build>
    <plugin>
        <groupId>org.n0pe.mojo</groupId>
        <artifactId>asadmin-maven-plugin</artifactId>
        <version>0.1-SNAPSHOT</version>
    </plugin>
</build>

Check that either AS_HOME or GLASSFISH_HOME environment variables are set to your SJAS/Glassfish installation folder.

You can now use the following commands :

• mvn asadmin:start-database
• mvn asadmin:start-domain
• mvn asadmin:deploy
• mvn asadmin:undeploy
• mvn asadmin:stop-domain
• mvn asadmin:stop-database

By default the asadmin-maven-plugin use the following settings :

• user: admin
• password-file: ~/.asadmintruststore
• admin-host: localhost
• admin-port: 4848
• domain: domain1

You can override all theses settings in the plugin configuration section in your pom.xml. Full documentation will soon be provided but if you have a maven aware editor, you will get completion on available options.

By default again, the deploy and undeploy mojos use the archive (jar/war/ear) produced by your maven project and deploy it using your project’s artifactId as module name.

The next step is to provide user and developer documentation.

I sometimes need to use java.util.Map objects in WebServices. As I’m building all my WebServices with the JAX-WS RI (using the Metro bundle). The block responsible for XML (un)marshalling of POJO, named JAXB, does not allows to directly use Maps as a soap operation parameter. For this purpose I’ve written the following simple class that allows me to wrap Maps in a POJO that JAXB is able to (un)marshall :

public class JAXBMapWrapper<KT, VT> {

    private Map<KT, VT> wrappedMap;

    public JAXBMapWrapper() {
        wrappedMap = new HashMap<KT, VT>();
    }

    public Map<KT, VT> getWrappedMap() {
        return wrappedMap;
    }

    public void setWrappedMap(final Map<KT, VT> givenMap) {
        wrappedMap = givenMap;
    }

}

ATTENTION : I posted this some days ago and removed the post after understanding that this is simpler on the service side but that the client side gets cumbersome generated classes.. but google cache indexed the post in less than half a day.

Just don’t use this ! If you need to transmit Maps over JAX-WS webservices, do it the XmlAdapter way as advertised in the official Unofficial JAXB Guide instead.

Java 7 is coming. And it’s an awesome project ! Now that java is distributed under the GPL, developers can believe that the JSR way of doing things will be more and more pragmatic.

The title of this post is a little bit coarse but this is the feeling java gives to developpers who “learn and use java to create and run programs that make devices and internet useful for people“.

I just read some articles about jdk7 changes that I want to share :

About the new framework for fork-join style parallel decomposition and the ParallelArray class in java.util.concurrent :

• Stick a fork in it - Part One
• Stick a fork in it - Part Two

About the first attempt to give packages and visibility modifiers a lift :

• JSR-294 Superpackages

The first ones are really exciting ! The one about the superpackages scares me a little. I know it’s the first “public” communication about it but I sincerely hope that the final solution will be presented with successfull examples of complex implementations, ie. will be pragmatic.

I’m extensively using Joda-Time for handling time in my Java development, client or server side. Joda-Time is the codebase of the coming RI implementation of JSR-310 that will hopefully ship in Java 7.

I often need to work with dates in web services implementations, here is the JAXB custom binding lines I use to un/marshall JodaTime types to standard xs:date and xs:dateTime XML Schema types.

Note : I’m using the RI implementation of JAXB spec bundled in Metro.

DateTimeXmlAdapter that convert Joda-Time types to standard java types

import java.util.Date;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import org.joda.time.DateTime;

@XmlTransient
public class DateTimeXmlAdapter extends XmlAdapter {

    @Override
    public DateTime unmarshal(Date date) throws Exception {
        return new DateTime(date.getTime());
    }

    @Override
    public Date marshal(DateTime dateTime) throws Exception {
        return new Date(dateTime.getMillis());
    }

}

JAXB Custom binder for binding xs:date to java.util.Date.

In the documentation, an example JAXB customization file that use this binder.

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import javax.xml.bind.DatatypeConverter;

/**
 * <?xml version="1.0" encoding="UTF-8"?>
 * <bindings xmlns="http://java.sun.com/xml/ns/jaxb"
 *           version="2.0"
 *           xmlns:xs="http://www.w3.org/2001/XMLSchema">
 *     <globalBindings>
 *         <javaType name="java.util.Date" xmlType="xs:date"
 *                   parseMethod="org.your.package.name.XSDateCustomBinder.parseDate"
 *                   printMethod="org.your.package.name.XSDateCustomBinder.printDate"
 *         />
 *     </globalBindings>
 * </bindings>
 */
public class XSDateCustomBinder {

    public static Date parseDate(String s) {
        return DatatypeConverter.parseDate(s).getTime();
    }

    public static String printDate(Date dt) {
        Calendar cal = new GregorianCalendar();
        cal.setTime(dt);
        return DatatypeConverter.printDate(cal);
    }

}

JAXB Custom binder for binding xs:dateTime to java.util.Date.

In the documentation, an example JAXB customization file that use this binder.

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import javax.xml.bind.DatatypeConverter;

/**
 * <?xml version="1.0" encoding="UTF-8"?>
 * <bindings xmlns="http://java.sun.com/xml/ns/jaxb"
 *           version="2.0"
 *           xmlns:xs="http://www.w3.org/2001/XMLSchema">
 *     <globalBindings>
 *         <javaType name="java.util.Date" xmlType="xs:dateTime"
 *                   parseMethod="org.your.package.name.XSDateTimeCustomBinder.parseDateTime"
 *                   printMethod="org.your.package.name.XSDateTimeCustomBinder.printDateTime"
 *         />
 *     </globalBindings>
 * </bindings>
 */
public class XSDateTimeCustomBinder {

    public static Date parseDateTime(String s) {
        return DatatypeConverter.parseDate(s).getTime();
    }

    public static String printDateTime(Date dt) {
        Calendar cal = new GregorianCalendar();
        cal.setTime(dt);
        return DatatypeConverter.printDate(cal);
    }

}

I hope this may help you.

Deep understanding of Java classpath is something that is too often neglected. I won’t write an article about classpath, internet is full of readings about it :

• How Classes are Found at java.sun.com
• Classpath (Java) page from Wikipedia
• Classpath entry in the Java Glossary
• Java Tip 105: Mastering the classpath with JWhich

Here come JWhich and jcfind. Both are classpath reflection tools.

JWhich provides a command line interface and a Java api where jcfind only has command line interface and is written in python.

I prefer to use jcfind from the command line because it’s really faster than Which4j and the command line is more practical. In Java software, I use the JWhich API that is really easy to use. The big drawback of using Which4j from command line is that you must provide a full class name, using it’s API you can search for a class simple name.