Posted by Paolo Predonzani
on April 9, 2009

Introduction

In this tutorial we'll see two things.
First we'll do a very simple customization of Portofino: changing the logo and css stylesheet.
Second we'll use Maven to create a new mywebapp.war which bundles, in a single .war, the standard Portofino distribution, the customizations and the portofino-custom.properties configuration.

In this way, the mywebapp.war that contains the customized application will be self-contained, professional and easy to deploy.

The problem

If I had to create and distribute an application based on Portofino I would:

• Download the standard Portofino distribution
• Unpack the war file
  
• Add a portofino-custom.properties configuration file
• Customize or add any other resources, e.g., css files, images, jars or class files
• Repackage the war file as mywebapp.war
  
• Distribute to my clients (who will deploy myapp.war to their app servers)

In a simplistic approach, I would do these steps manually. However this brings the following problems:

• If many files need to be changed/added, the technique becomes error prone.
• If a new version of Portofino comes out, I have to repeat all the steps manually again.
• I have to document the customizations that I've applied, or I'm going to forget them.
  
• If I distribute the source code rather than the .war package, I have to teach my users how to repeat the process.

For a one-off exercise this might be fine, but if I want to develop and maintain a serious application based on Portofino I would need a better process.

Maven overlays

All the manual steps mentioned above can be automated using Maven overlays. The process becomes repeatable, less error-prone, and overall simpler.

Maven is a build/dependency/project management tool. For an overview, see the Maven in 5 minutes guide.

Overlays are a specific, advanced use of Maven. Fundamentally they allow you to build a target war (mywebapp.war) as a "merge" between an original war (the Portofino standard distribution) and other code/files that you develop. To visualize how this "merge" works, see Manipulating WAR Overlays.

Installing Maven

From a shell/command line, check if Maven is already installed on your system:


Any version of Maven since 2.0.6 is suitable for our purposes.

To download and install Maven, follow the instructions here: http://maven.apache.org/download.html.

Installing Portofino in the local repository

This is a preliminary step that you need to do once on your system. Repeat it only when a new version of Portofino becomes available.

Download Portofino. Expand the archive and check that the file "portofino-war-3.1.0.war" is present. Then type the following command:


Notice that you must change "/path/to/portofino-war-3.1.0.war" to the location where you've actually downloaded Portofino.

Creating the maven overlay project

To kick-start the new maven project we'll use an archetype, a kind of template for various types of project. We choose the "maven-archetype-webapp", which is an archetype suitable for any war-based applications.

Before you start, you need to decide the groupId and artifactId for the customized application, roughly equivalent to an identifier of your organization and an identified of your webapp. We'll use:

• groupId: com.mycompany.app
• artifactId: mywebapp
  

Now we can run:


Maven will run and log several messages. Make sure the last few lines look like this:


A new directory called "my-webapp" has been created. Let's have a look at it.


As you can see, a standard directory structure has been created (for more information on this, see the Introduction to the standard directory layout).
Now edit the pom.xml file and add the section in bold:


Now we're ready to run our first build. Type:


And make sure you get the BUILD SUCCESSFUL message.
Have a look at a folder called "target", which has just been created. It should contain a file called "mywebapp.war" as well as an expanded version of it in the "mywebapp" directory.
Well, that is the overlaid war target. It still doesn't do what we want, but we're getting closer.

Cleaning up some files we don't need

Before proceeding, make sure you delete two files that were automatically created by the archetype:

• src/main/webapp/index.jsp
• src/main/webapp/WEB-INF/web.xml
  

Unless you really want to customize Portofino's index.jsp and web.xml files, those two files must not be left around.

Adding the portofino-custom.properties

The portofino-custom.properties can be easily bundled inside mywebapp.war. Create the file:


And copy the following content:

Of course customize the database connection details. If you do not want to hardwire this information in the configuration file, you may use the following content instead:


...which refers to a JNDI data source called jdbc/portofinodb that you'll have to set up on the deployment server.

Adding a custom logo

Create or choose a logo image and save it as

Adding a custom stylesheet

Our custom stylesheet will be just sufficient to display the custom logo. Create this file:


And copy the following content:


Notice the structure. The @import statement at the first line ensures that the standard Portofino css is still used, while the lines that follow override only the part that takes case of the title/logo display.

The size and position of the logo on the screen will depend on the values shown in bold. Make sure you customize them to your needs.

Building the .war file

Let's check we have all the files in place.


Now run:


Maven will run for a few seconds. At the end you should have a file in:


That's the final .war, containing all the customizations/configurations, that you can deploy or distribute.

Where to go next

No discussion of war overlays is complete without talking about profiles and filtering: this is the subject of the Using Maven profiles and resource filtering tutorial.
Maven can be employed in many useful situations. For a real life application see our tutorial Integrating Portofino with Alfresco.

The technique we've seen lays the basis for more serious customizations where you can extend the functionality of Portofino. This will be the subject of other tutorials. For now you can have a preview from the reference manual:

• Advanced workflows
• Listeners
• Custom operations