Java Enums can implement Interfaces

Something which came as a surprise to me but ended up quite useful, was that enums in Java can also implement interfaces.

A typical enumeration in Java, introduced in Java 5, looks like a String value, but also introduces other features which make them a particularly useful language feature. Besides looking like an typical enumeration with a finite ordered list of values, it is also possible to attach additional information to each enumeration value.

A basic enumeration, which defines the four suits in a typical set of cards looks like this:

public enum Suit 
{ CLUBS, DIAMONDS, HEARTS, SPADES }

To attach additional information to the enumerated type, add a private constructor, add a private field, and get each enumeration value to call the new constructor.

public enum Numbers {
	One(1), Two(2), Three(3);

	private Numbers(int value)
	{
		this.value = value;
	}
	
	public int getValue()
	{
		return this.value;
	}
	
	private int value;
}

In the example above, we also introduced the getValue() method. This introduces the concept of behaviour to our enumeration; not something we would normally consider. It also lends itself to the idea of common behaviour between enumerated types.

To show how this works, consider an interface which defines the mapping between a class and a table.

public interface DatabaseMapping {
	public String getType();
	public boolean isKey();
	public boolean isNullable();
	//public String name();
}

The method name() is commented for now, we’ll get back to that in a minute.

To use this, we can now create a new Java class and then define the mapping of that class to a database.

public class Person {
	public String getFirstname() {
		return firstname;
	}
	public void setFirstname(String firstname) {
		this.firstname = firstname;
	}
	public String getLastname() {
		return lastname;
	}
	public void setLastname(String lastname) {
		this.lastname = lastname;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	private String firstname;
	private String lastname;
	private int age;
}

(I realise there are better ways to map a class to a database table, this example is contrived) When we define the mapping from our class to our table, we can define a separate mapping class. We create this class, we will make it an enumeration and allow each class/database field to be a member in an enumeration.

public enum PersonMapping {
	personId, firstname, lastname, age;
}

Using the trick where we are able to attach additional information to enumerated types, we define some of the database mapping details:

public enum PersonMapping {
	personId("INTEGER", true, false), 
	firstname("TEXT", false, false), 
	lastname("TEXT", false, false),
	age("INTEGER", false, false);
	private PersonMapping(String type, boolean key, boolean nullable )
	{
		this.type = type;
		this.key = key;
		this.nullable = nullable;
	}
	public String getType() {
		return type;
	}
	public boolean isKey() {
		return key;
	}
	public boolean isNullable() {
		return nullable;
	}
	private final String type;
	private final boolean key;
	private final boolean nullable;
}

So now we are able to use the enumeration to iterate the fields and do some database stuff. For the moment we’ll hold off including the interface.

public String dbTableCreate(String tableName) {
	StringBuilder builder = new StringBuilder("Create table ");
	builder.append(tableName);
	builder.append("(");
	for (PersonMapping column : PersonMapping.values()) {
		builder.append(column.name());
		builder.append(" ");
		builder.append(column.getType());
		builder.append(column.isKey() ? " primary key" : "");
		builder.append(", ");
	}
	builder = new StringBuilder(builder.substring(0, builder.length() - 2));
	builder.append(");");
	return builder.toString();
}

Which looks fine for our PersonMapping enumerated type, but doesn’t allow us to plug in different class-to-database mappings. Time to introduce the interface. Looking closely at the code above, we need to use two of the additional methods available to all enumerations, name() and values(). The first returns the text name of the current enumerated value, and the second allows us to access the values that make up this enumerated type.

First add the interface to the enumeration:

public enum PersonMapping implements MappingEnum{

Uncomment the name() method so that it can be accessed from the interface.

public interface MappingEnum {
	public String getType();
	public boolean isKey();
	public boolean isNullable();
	public String name();
}

Final piece of the puzzle is to write the dbTableCreate() above to allow it to be reused with other enumerated types. The problem we need to work around is that the values() method is static, making it difficult to pass the enumerated type to the method. The simple solution is to call the method explicitly and pass the values:

dbTableCreate("tableName", PersonMapping.values()));

… and realise that we can now receive the values using the interface …

public String dbTableCreate(String tableName, MappingEnum[] values) {
	StringBuilder builder = new StringBuilder("Create table ");
	builder.append(tableName);
	builder.append("(");
	for (MappingEnum column : values) {
		builder.append(column.name());
		builder.append(" ");
		builder.append(column.getType());
		builder.append(column.isKey() ? " primary key" : "");
		builder.append(", ");
	}
	builder = new StringBuilder(builder.substring(0, builder.length() - 2));
	builder.append(");");
	return builder.toString();
}

Conclusion

* Enumerations can store additional data and have additional methods,
* Enumerations can use interfaces to define behaviour,
* Enumerated item behaviour can be accessed via an interface, the same as regular Java classes,
* The values() method from enumerations can be used to return an array of a interface.

Combined, it allows us to treat enumerated types as both regular Java classes and enumerated types and interact using common behaviour rather than being tied to a single implementation.

Liferay Standard Development Environment

I wrote a post a while back outlining the general set up we use when running our Liferay plugins through Continuous Integration, but it occurred to me that there should be an article that comes before that one which outlines the set up of the development environment. Many of the results of the decisions and best practices can be seen in that post, but there is still plenty that can be covered with respect to setting up a development environment for Liferay plugins.

Development Environments

There a few slight changes to the setup described in the previous article, but we’ll assume that a Liferay project always requires the following tools:

  • Liferay Development Studio (LDS). This is essentialy the Eclipse IDE plus some Eclipse plug ins to assist Liferay development.
  • Liferay Software Development Kit (SDK). This does most of the work with respect to building the plugins and the ANT tasks can be used from the command line without requiring the LDS.
  • A Liferay Bundle. A bundle is a pre-packaged Liferay server instance and in our case we tend to use Liferay bundled with Tomcat almost exclusively during development. The other benefit is that the Tomcat bundle is already assumed and pre-configured for some of the steps below and hence simplifies set up and reduces the work and chances of getting things wrong later.
  • Liferay Source. This isn’t essential to the set up, but when creating a new development environment we always do this at the same time and there or little additional effort required.

Recipe

Install Liferay Development Studio

You can install the LDS to the location of your choice and you can use the same LDS instance to manage multiple Liferay project workspaces, but more on this as we go. If you have already installed LDS then there is no need to do it again.

Create a new workspace directory for the Liferay project. For the sake of this article we’ll call the directory workspace.

Note that the Liferay source, SDK and bundle in the next steps should all be for the same version. Don’t mix them up. You have been warned.

Install Liferay Software Development Kit (SDK)

Copy the Liferay SDK zip file eg liferay-plugins-sdk-6.0-ee-sp1.zip to the workspace. Unzip the file so that there is a directory with the same name eg liferay-plugins-sdk-6.0-ee-sp1.

If your operating system does not allow soft links to directories, rename the SDK directory to plugins. Otherwise (and preferably) create a soft link to the SDK directory called plugins. By pointing external configuration at the plugins directory rather than at a specific SDK version, it makes it easier to upgrade your development environmnet later on.

Hopefully it gives you something like this in the workspace directory.

drwxr-xr-x 13      4096 2011-05-26 12:00 liferay-plugins-sdk-6.0-ee-sp1/
-rw-r--r--  1   9358463 2011-03-09 23:38 liferay-plugins-sdk-6.0-ee-sp1.zip
lrwxrwxrwx  1        71 2011-05-26 08:17 plugins -> liferay-plugins-sdk-6.0-ee-sp1/

Install the Bundle

Very similar to the previous step, copy the bundle zip file to the workspace, unzip and either rename or soft link as bundles. The bundles name is important here, so don’t get creative.

This adds the following to our directory:

lrwxrwxrwx  1        66 2011-05-26 08:18 bundles -> liferay-portal-6.0-ee-sp1/
drwxr-xr-x  5      4096 2011-05-26 16:32 liferay-portal-6.0-ee-sp1/
-rw-r--r--  1 187336800 2011-03-09 23:37 liferay-portal-tomcat-6.0-ee-sp1.zip

Install the Source

Once again copy the source zip file to the workspace directory, unzip and rename or soft link as source.

drwxr-xr-x 20      4096 2011-05-26 09:47 liferay-portal-src-6.0-ee-sp1/
-rw-r--r--  1 230320369 2011-03-09 23:37 liferay-portal-src-6.0-ee-sp1.zip
lrwxrwxrwx  1        70 2011-05-26 08:18 source -> liferay-portal-src-6.0-ee-sp1/

The complete Workspace

Remove the zip files if you want, but personally I just leave them there. The parts we’re interested in are the bundles, plugins and source directories.

lrwxrwxrwx  1        66 2011-05-26 08:18 bundles -> liferay-portal-6.0-ee-sp1/
drwxr-xr-x 13      4096 2011-05-26 12:00 liferay-plugins-sdk-6.0-ee-sp1/
-rw-r--r--  1   9358463 2011-03-09 23:38 liferay-plugins-sdk-6.0-ee-sp1.zip
drwxr-xr-x  5      4096 2011-05-26 16:32 liferay-portal-6.0-ee-sp1/
drwxr-xr-x 20      4096 2011-05-26 09:47 liferay-portal-src-6.0-ee-sp1/
-rw-r--r--  1 230320369 2011-03-09 23:37 liferay-portal-src-6.0-ee-sp1.zip
-rw-r--r--  1 187336800 2011-03-09 23:37 liferay-portal-tomcat-6.0-ee-sp1.zip
lrwxrwxrwx  1        71 2011-05-26 08:17 plugins -> liferay-plugins-sdk-6.0-ee-sp1/
lrwxrwxrwx  1        70 2011-05-26 08:18 source -> liferay-portal-src-6.0-ee-sp1/

How the parts interact

Before we complete the configuration, we’ll pause and look at how the parts interact.

Liferay Development Studio (LDS) and Software Development Kit (SDK)

The LDS provides some wizards, configuration checking and general assistance in building and managing Liferay plugins, but mostly it delegates to the SDK to perform the actual build and deploy work.

Therefore in just a second we’ll tell the LDS where the SDK is but first a word of warning…

Excuse me for shouting, but only ever register a single SDK with a Liferay workspace, and make sure it is the one in the workspace called plugins. Having multiple SDKs registered with in a single workspace can cause confusion or worse, and doesn’t add benefit to the environment. Please don’t do it.

LDS and the Bundle

LDS is able to start/stop the bundle but is also able to shortcut the deployment process and deploy straight to the bundle without needing help from the SDK.

Depending on the LDS version used, you may be asked to point to a bundle (or Liferay Runtime) the first time you point the LDS to a new workspace. Be sure to point to the workspace/bundles directory.

SDK and the Bundle

The SDK uses the libraries in the bundle to compile the plugins, and it also needs to know the location of the bunlde directory so that the deploy target can copy the WAR files to the Liferay Runtime

Configuration

As pointed out above, you should only configure a single SDK in the LDS for a given workspace. When you point the LDS to another workspace you are able to specify a different SDK as this value is configured against the workspace and is not global to the LDS. This will come as a major relief as the alternative would be incredibly restricting.

Furthermore, the plugins also have the registered name of the SDK included in their project properties, so it is important that all team members use the same name to describe the SDK within the LDS. I believe our default is liferay_sdk but it doesn’t matter what is selected provided everyone uses the same value. If not, you’ll be forced to fix this value every time someone else changes it in version control, and you’ll be unable to build or deploy until it is corrected. It is very annoying.

We may have already specified the Liferay Runtime when first pointing the LDS at the new workspace, but if not go to the LDS menu and select Window > Preferences and on the Preferences screen select Server > Runtime Environments, select ‘Add’, select the Liferay version for your bundle from the servers available and then point to the workspace/bundles/tomcat directory.

The next step would be to configure the SDK and bundle to work together, but as hinted earlier we don’t need to. If you look into the workspace/plugins/build.properties default settings, the server is already set to tomcat and the server location and deploy folder location are already correct because we have a directory called bundles pointing to the Runtime home directory.

Finally, right click on some spare space in the Package Explorer in the LDS, import, general, import and existing Eclipse project, navigate to the workspace directory, click OK and then select the source directory to import. This is useful for development and debugging.

Creating a new Plugin

When you create a new plugin project in the LDS, the wizard wants to know which SDK to use and since we have a single SDK there is no problem. The wizard ends up creating a new project in one of the subdirectories under the plugins directory, but within the LDS the project will display as if it were in the root directory of the workspace. It isn’t, but it is worth knowing the difference. If you get confused, right click the project in the LDS, go to the properties and look at the resource location.

Plugin Version Control

It is a bad idea to check the entire SDK into version control, so it is lucky that the LDS places them at the base of the Project Explorer. Right click, team, share, happiness.

Adding a Liferay plugin project from version control back into the LDS has some tricks to it.

Firstly, you’ll want to place the plugin project in the correct subdirectory in the SDK. When you import the project from version control, the second screen in the import wizard prompts you to import into the default workspace location. Don’t do this, and instead select the correct SDK subdirectory for that Liferay Plugin project type. But that’s not all.

Unless the bug has been fixed since the last time I checked, importing from version control will get the project into your LDS workspace, but the plugin will be imported as a Java project and not a Liferay Plugin Project; some of the Eclipse facets are lost. This matters. To fix it, right click and delete the project(s) that you just imported from version control but do not delete from the file system. Once again right click on some free space in the LDS Package Explorer, import, LIferay > Liferay Plugin SDK Projects, select the one and only SDK, select the project(s) to import and then they get imported correctly as Liferay Plugin projects.

Conclusion

So while I haven’t spelled out all of the learnings and reasons which has led us to this set up as our preferred Liferay Standard Development Environment, I hope that there are enough reasons provided for you to consider this approach and I hope that there are sufficient instructions provide to recreate the same in your own workspace.