CTP Java Competence

CDI Query Module First Alpha Released!

2011-11-22T11:25:00.000+01:00

It's been some months now since we started exploring CDI extensions as a small exercise. As it turned out, the exercise forged into something usable which we're pushing now in the open as a first Alpha shot.

So I'm happy to announce the availability of the CDI Query Module on Maven Central! The module helps you creating JPA queries with much less boilerplate, and is of course leveraging the CDI extension API as well as Seam Solder. Some of the feature highlights are:

Query By Name

Assuming you have a Person entity which looks probably similar to this:

@Entity
public class Person { 

    ... // primary key etc. skipped

    @Getter @Setter
    private String firstName;
    
    @Getter @Setter
    private String lastName;

}

You can simply create a DAO interface to query for Persons:

@Dao
public interface PersonDao extends EntityDao<Person, Long> {

    Person findByFirstNameAndLastName(String firstName, String lastName);

}

This interface does not need to be implemented. A client can just inject it, call the interface method and in the background, the JPA query is automatically created and executed. To create the query, the method name is analyzed and matching the name to entity properties.

public class PersonAction {

    @Inject
    private PersonDao personDao;
    
    public void lookup() {
        person = personDao.findByFirstNameAndLastName(firstName, lastName);
    }

}

Note that the base interface contains also a couple of other methods which you might also expect from an entity DAO. Ideally, you should not need to inject an EntityManager anymore.

Query by Query Strings and Named Queries

Of course matching property names is not extremely safe to refactorings (some more validation support here is on the roadmap) - if you like to have more control over your JPA queries, you can also annotate the method with the query to execute:

@Dao
public interface PersonDao extends EntityDao<Person, Long> {

    @Query("select p from Person p where p.ssn = ?1")
    Person findBySSN(String ssn);

    @Query(named=Person.BY_FULL_NAME)
    Person findByFullName(String firstName, String lastName);

}

Criteria API Simplifications

If you're not a big fan of query strings but rather prefer using the JPA 2 criteria API, we also allow to simplify this with a small utility API:

public abstract class PersonDao extends AbstractEntityDao<Person, Long> {

    public List<Person> findAdultFamilyMembers(String name, Integer minAge) {
        return criteria()
                    .like(Person_.name, "%" + name + "%")
                    .gtOrEq(Person_.age, minAge)
                    .eq(Person_.validated, Boolean.TRUE)
                    .orderDesc(Person_.age)
                    .createQuery()
                    .getResultList();
    }

}

All the code is hosted and documented on GitHub. Please:

Give feedback! If you find this useful or actually not so, we're happy to hear what is still missing.
Participate! Forking and creating pull requests are really a breeze on GitHub :-)

Credits:

Bartek Majsak for improving the initial code, taking care about quality reports and soon finalizing the stuff on the validation branch ;-) (just kidding, check out Bartek's cool work on the Arquillian Persistence Module!)
Grails GORM for inspiring me for this Java implementation
The CDI folks for a really great specification
Last but not least the Arquillian guys, developing and testing this stuff is pure fun with Arquillian!

JBoss Forge JRebel Plugin - Video Tutorial

2011-11-11T15:24:00.002+01:00

It's actually out for quite a while now (and therefore already slighly out of date) but I have hardly found some time to blog about it: If you're using JRebel and JBoss Forge, have a look at this Video tutorial how to use both of them together.

<p>&amp;amp;amp;lt;p&amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;lt;p&amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;br /&amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;lt;/p&amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;lt;/p&amp;amp;amp;gt;</p>

Make sure to watch it in HD and full screen mode. Thanks to Chris "Kubrik" Reimann for putting the tutorial together!

As an addition, Forge now also supports checking out specific versions of a plugin, which is in our case version 1.0.0.Beta1 of the JRebel plugin. We've also added the plugin to the Forge plugin repository index so you can search for it.

By the way, if you're only using one of the tools or (even worse) none of them, this is the perfect opportunity to get a quick hands-on.

A CDI Extension for Query Generation

2011-04-04T18:24:00.004+02:00

While the DAO pattern has come out of fashion with Java EE 6, it can still be a useful approach to centralize query related logic when you have to do more than just delegating to the entity manager. Often this approach leads then to small frameworks containing reusable code within a project, or also sometimes into a bigger framework spreading over complete IT departments within a company.

Inspired by features of Grails or the Spring Data JPA project, my plan was to learn more about CDI extensions by implementing a proof of concept on such a DAO framework based on CDI. CDI is part of Java EE 6 and, already by itself a powerful addition to the platform programming model, provides SPIs to extend it even further. A prominent sample is the Seam framework, which in its latest version contains a lot of those extensions. Just drop them in your classpath and they are ready for use. Impressive enough to learn more about the technology.

While I was getting my hands dirty it seemed to me the result is useful enough to share it here - and also of course to demonstrate the power and easiness of creating CDI extensions. In this article I’ll give you a quick start on CDI extensions as well as (hopefully) an idea on how a portable framework might look like based on this technology. All code presented here is available on GitHub.

The DAO Framework

Some common ingredients of a DAO framework are captured in the code snippet below:


@Dao
public interface SimpleDao extends EntityDao<Simple, Long> {
    
    Simple findByNameAndEnabled(String name, Boolean enabled);

    @Query(named=Simple.BY_NAME)
    List<Simple> findByNamedQuery(String name);
    
    @Query(named=Simple.BY_NAME)
    List<Simple> findByNamedQueryRestricted(String name, 
            @MaxResults int max, @FirstResult int first);
    
    @Query(named=Simple.BY_ID)
    Simple findByNamedQueryNamedParams(
            @QueryParam("id") Long id, 
            @QueryParam("enabled") Boolean enabled);
    
    @Query("select s from Simple s where s.name = ?1")
    Simple findByQueryString(String name);

}

Typically a DAO framework has a common interface concrete DAOs can extend from. Using generics here allows to have a standard set of methods like saving or retrieving all entities of a specific type, and can also be used during query generation. Usually this is nothing that cannot be done easily with an entity manager. But once you have injected a DAO in your service class - do you really want to inject the entity manager as well? In order to keep code leaner, a DAO base interface should provide this kind of methods and of course implement them all automagically - nothing you would like to rewrite again and again.

Some other features are shown in the method declarations above. Automatic query generation out of method names and parameters as GORM method expressions do, or creating queries based on annotation meta data and parameters will often allow just leaving those easy cases to the query generator and keep the code lean to focus on the complex ones.

The CDI Approach

One way to implement such a framework is over a CDI extension. CDI allows extensions to listen to various lifecycle events:
- Before CDI starts discovering beans.
- While it processes annotated types, injection targets, producers, beans and observers.
- And when it finishes with both discovery and validation.

As in our case we are dealing with plain interfaces, the easiest approach is to simply annotate the interface and then listen for annotation processing events. The sample above shows a Dao annotation on the interface, but this would be placed on the extended AbstractEntityDao interface so developers won’t have to worry about it.

So on the extension we listen for annotated types, check if it is our Dao annotation and register a proxy bean which implements the annotated type. Registering the extension a matter of two things:
1. Implementing the extension class and listen for the Dao annotation.


public class QueryExtension implements Extension {

    <X> void processAnnotatedType(@Observes ProcessAnnotatedType<X> event, BeanManager beanManager) {
        // all the required information on the type is found in the event
        // the bean manager is used to register the proxy
    }

}

2. Register the extension class as a service provider in the appropriate file (META-INF/services/javax.enterprise.inject.spi.Extension).

Registering the proxy with the bean manager is slightly more work, but luckily someone has already done that. If you work with CDI extensions, make sure to include Seam Solder - the Swiss army knife for CDI developers. Solder has built-in support for so called service handlers, where you annotate an abstract type with a reference to the handler class. The documentation use case looks probably kind of familiar ;-) All our extension will have to do is to override the handler lookup - and we’re done with registering the proxy! The reason we don't use the ServiceHandlerExtension directly is to separate the handler reference from the annotation, and that we can have a chance to e.g. validate and process further meta data in the extension class.


public class QueryExtension extends ServiceHandlerExtension {

    @Override
    protected <X> Class<?> getHandlerClass(ProcessAnnotatedType<X> event) {
        if (event.getAnnotatedType().isAnnotationPresent(Dao.class)) {
            return QueryHandler.class;
        }
        return null;
    }

}

public class QueryHandler {

    @Inject
    private Instance<EntityManager> entityManager;
    
    @AroundInvoke
    public Object handle(InvocationContext ctx) throws Exception {
        ...
    }

}

The handler class simply has to provide a public method annotated with @AroundInvoke, where you get all the required information to build up your query dynamically. Note that in the handler class you will also be able to use CDI services like injection.
As a framework user, all you will have to do is to drop the JAR in the classpath and annotate the interface. Look mom, no XML! Well almost, you still need an (empty) beans.xml somewhere to activate all the CDI magic.

Testing the Extension

Arquillian is a relatively new testing framework which allows you to create dynamic deployment units and run them in a container. A great feature for an extension as you can easily test it live in a unit test without leaving the IDE! This looks like the following:


@RunWith(Arquillian.class)
public class QueryHandlerTest {
    
    @Deployment
    public static Archive<?> deployment() {
        return ShrinkWrap.create(WebArchive.class, "test.war")
                .addClasses(QueryExtension.class)
                .addAsWebInfResource("test-persistence.xml", ArchivePaths.create("classes/META-INF/persistence.xml"))
                .addAsWebInfResource(EmptyAsset.INSTANCE, ArchivePaths.create("beans.xml"))
                .addAsWebInfResource("glassfish-resources.xml")
                .addClasses(SimpleDao.class)
                .addPackage(Simple.class.getPackage());
    }
    
    @Inject
    private SimpleDao dao;
    
    @Produces
    @PersistenceContext
    private EntityManager entityManager;
    
    @Test
    public void shouldCreateQueryByMethodName() {
        // given
        final String name = "testCreateQueryByMethodName";
        createSimple(name);
        
        // when
        Simple result = dao.findByNameAndEnabled(name, Boolean.TRUE);
        
        // then
        Assert.assertNotNull(result);
        Assert.assertEquals(name, result.getName());
    }

}

This creates a stripped down web archive deployment, in this sample for an embedded GlassFish. The test class itself is registered as a bean in the test and can therefore use injections (CDI or container injections, see the @PersistenceContext). Resources like persistence units can be added on demand as we see in the deployment method (persistence.xml for the persistence unit, glassfish-resources.xml contains a data source definition).

The container gets started and we can see our injected proxy in action. In the sample above we then create some test data and see if our generated query fetches the right data back.

Conclusion

Of course this article is a very simplified version of the whole setup - especially the Arquillian setup required some trial and error as the framework is still in Alpha (if anybody finds out how to create the data source without deploying the glassfish-resources.xml into a web archive - let me know).

Check out the project source on GitHub to get started. The module structure might look a little complicate but it follows common Seam module structure separating API (in our case the client annotations) from implementation (the extension code). Documentation is still "basic" but looking at the unit tests might give an indication on the usage.

Once the project setup is done, things get extremely productive though. Seam Solder provides a rich tool set you can use to create an extension, Arquillian lets you immediately test your code inside a container. The result is an easy to reuse and easy to distribute framework you will probably get back to in many of your following Java EE 6 projects.

Introduction to OSGi

2011-03-18T14:35:00.001+01:00

As my first blog entry here I want to introduce you to the OSGi framework. It allows you to build Java applications with high modularity and I believe that this technology will become more and more important in the future. The goal of this introduction is that the reader has a quick overview about the OSGi framework and that he understands the benefits of it. Further, this should be an introduction to my planned series of Eclipse plug-in development.

1 What is OSGi?

The OSGi Alliance (formerly known as Open Services Gateway initiative, now an obsolete name), founded in March 1999, originally specified and maintains the OSGi specification. This specification allows you to write so called bundles, self contained modules that can provide functionality to other bundles. There are several implementations of this specification, the most common ones are:

Eclipse Equinox
Apache Felix
Knoplerfish

1.1 Why OSGi?

As mentioned before, the OSGi specification aims to create Java applications with extremely high modularity. Of course, this is what every developer aims at, but OSGi encourages and supports you in doing so. Also a great feature is that you can install or uninstall such bundles during runtime of the application without restarting it. It also supports lazy loading. This means that you can configure a bundle to be loaded when it’s called the first time. This truly increases the performance of an application. The OSGi specification also defines some useful services, that have to be provided by an OSGi implementation.
What does that mean to CTP? As high modularity is becoming more and more important, clients will have the need to extend their application. As seen in the sM-Client project, for example, the client wants to make small extensions like custom forms without packaging a whole new release. Which is quite understandable. Now a plug-in style mechanism is evaluated, but there may be problems, especially with classloading, which are well solved in OSGi.

2 Architecture

The OSGi framework is based on several Layers:

Security layer: The OSGi Security Layer is an optional layer that underlies the OSGi Service
Platform. The layer is based on the Java 2 security architecture. It provides
the infrastructure to deploy and manage applications that must run in finegrained
controlled environments.

Module layer: The Module Layer is responsible for the packaging of the modules (“bundles”), those are simple JAR files which follow some requirements. I will explain more about bundles in section 2.1.

Life cycle layer: This layer gives you the possibility to install, uninstall, start and stop bundles inside an application framework without restarting the whole framework, (e.g. if you contribute a bug fix inside a bundle). This also increases the availability of your application framework.

Service Layer: The Service Layer enables you to provide OSGi services to other bundles. An OSGi service is nothing but a POJO, that is registered in the Service Registry and can be referenced from everywhere outside the declaring bundle. The service has to implement an agreed interface.

2.1 Bundles

As the description of the Module Layer says, a bundle is a plain old JAR file. But it has some special characteristics. There has to be a MANIFEST.MF file in the META-INF directory, which is located at the root of the JAR file (see the JAR specification). This file provides several meta information about the bundle like dependencies, exported and imported packages etc. Note, that in difference to a normal JAR file, all packages are hidden by default to other bundles. So you have to define which packages are exported and therefore are accessible from other bundles. Additionally, you have to specify which packages you want to import from other bundles. Also you can define required bundles, which will import all exported packages of the required bundles. Let’s have a look at an example MANIFEST.MF file:


Bundle-Name: Hello World
Bundle-SymbolicName: com.ctp.helloworld
Bundle-Description: A Hello World bundle
Bundle-ManifestVersion: 2
Bundle-Version: 1.0.0
Bundle-Activator: com.ctp.Activator
Export-Package: com.ctp.helloworld;version="1.0.0"
Import-Package: org.osgi.framework;version="1.3.0"
Require-Bundle: com.ctp.other;bundle-version="2.5.0"
Bundle-RequiredExecutionEnvironment: JavaSE-1.6

These configuration elements are explained as follows:

Bundle-Name: Defines a human-readable name for this bundle, Simply assigns a short name to the bundle.
Bundle-SymbolicName: The only required header, this entry specifies a unique identifier for a bundle, based on the reverse domain name convention (also used by the java packages).
Bundle-Description: A description of the bundle's functionality.
Bundle-ManifestVersion: This little known header indicates the OSGi specification to use for reading this bundle.
Bundle-Version: Designates a version number to the bundle.
Bundle-Activator: Indicates the class name to be invoked once a bundle is activated.
Export-Package: Expresses what Java packages contained in a bundle will be made available to the outside world.
Import-Package: Indicates what Java packages will be required from the outside world, in order to fulfill the dependencies needed in a bundle.
Require-Bundle: Indicates what OSGi bundles will be required from the application framework. This will import all exported packages from the specified bundle(s).
Bundle-RequiredExecutionEnvironment: Specifies the minimum execution environment(s) required to run this bundle.

2.1.1 Bundle life cycles

A bundle’s life cycle could have the following states (managed by OSGi’s Life Cycle Layer):

Bundle State	Description
INSTALLED	The bundle has been successfully installed.
RESOLVED	All Java classes that the bundle needs are available. This state indicates that the bundle is either ready to be started or has stopped.
STARTING	The bundle is being started, the BundleActivator.start method will be called, and this method has not yet returned. When the bundle has an activation policy, the bundle will remain in the STARTING state until the bundle is activated according to its activation policy.
ACTIVE	The bundle has been successfully activated and is running; its Bundle Activator start method has been called and returned.
STOPPING	The bundle is being stopped. The BundleActivator.stop method has been called but the stop method has not yet returned.
UNINSTALLED	The bundle has been uninstalled. It cannot move into another state.

2.2 OSGi Services

OSGi Services are Java objects, that implement agreed interfaces. This means that the Service itself is defined by a Java interface and the bundles which use the service don’t have to know where the specific implementation actually is. The following is a simple OSGi Service:

The service interface:

public interface HelloWorld {
    public String getMessage();
}

The service implementation:

package com.ctp.helloworld.service.impl;

import com.ctp.helloworld.service.HelloWorld;

class HelloWorldImpl implements HelloWorld {
    @Override
    public String getMessage() {
        return “Hello World”;
    }
}

Now, without any tools like Spring Dynamic Modules, iPOJO or Declarative Services, we have to register our service manually so that it can be accessed by other bundles. I will explain this in the following section.
Please note that the -Impl naming convention does not really make sense in OSGi, since it’s possible to have multiple implementations of one service, it was just the easiest for this example.

3 Example

Let’s write a simple bundle that contains the HelloWorld service we created above. First, download an OSGi framework (I’m using Equinox 3.6, but this example should work on all implementations since it’s very basic). This example is made as you could get going without any special IDE. The source code can be downloaded here.

Copy the downloaded jar file to a location where you would like to start your application (further called $APP_HOME).

Now create a work folder, where your source files are (further called $SRC_HOME).
Create the following folders and files:
$SRC_HOME/com/ctp/helloworld/service/HelloWorld.java
$SRC_HOME/com/ctp/helloworld/service/impl/HelloWorldImpl.java
$SRC_HOME/com/ctp/helloworld/Activator.java
$SRC_HOME/META-INF/MANIFEST.MF

The MANIFEST.MF file is very basic and should have the following contents:


Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Hello World
Bundle-SymbolicName: com.ctp.helloworld
Bundle-Version: 1.0.0
Bundle-Activator: com.ctp.helloworld.Activator
Bundle-Vendor: CTP
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: org.osgi.framework;version="1.3.0"
Bundle-ActivationPolicy: lazy

Make sure you have a carriage return and/or newline character at the end of the last line as this is required (see manifest specification in the JAR specification).

Let’s create the OSGi Service as the example in section 2.2:

$SRC_HOME/com/ctp/helloworld/service/HelloWorld.java:


package com.ctp.helloworld.service;

public interface HelloWorld {
    public String getMessage();
}

$SRC_HOME/com/ctp/helloworld/service/impl/HelloWorldImpl.java:

package com.ctp.helloworld.service.impl;

import com.ctp.helloworld.service.HelloWorld;

public class HelloWorldImpl implements HelloWorld {

   @Override
   public String getMessage() {
       return "Hello World";
   }
}

The defined activator ($SRC_HOME/com/ctp/helloworld/Activator.java) should have the following contents so that it is able to run:

package com.ctp.helloworld;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

public class Activator implements BundleActivator {

   private static BundleContext context;

   static BundleContext getContext() {
       return context;
   }

   public void start(BundleContext bundleContext) throws Exception {
       Activator.context = bundleContext;
   }

   public void stop(BundleContext bundleContext) throws Exception {
       Activator.context = null;
   }

}

At this state, the OSGi bundle should be ready to compile and deploy it. But first, we want to register our service. We do this in the method com.ctp.helloworld.Activator#start:

import org.osgi.framework.ServiceReference;
import com.ctp.helloworld.service.HelloWorld;
import com.ctp.helloworld.service.impl.HelloWorldImpl;
...
public void start(BundleContext bundleContext) throws Exception {
   System.out.println("Registering HelloWordld service...");

   // this will register the service in the Service Registry
   bundleContext.registerService(HelloWorld.class.getName(), new HelloWorldImpl(), null);

   // Test the availability of the service
   ServiceReference ref = bundleContext.getServiceReference(HelloWorld.class.getName());

   if(ref == null) {
      System.out.println("Service is not registered...");
   } else {
      // it’s also possible to get an array of services...
      HelloWorld service = (HelloWorld)bundleContext.getService(ref);
      System.out.println("HelloWorld#getMessage(): " + service.getMessage());
   }
   Activator.context = bundleContext;
}
...

Now we can compile the code and create a JAR file:
cd $SRC_HOME;
javac -cp $APP_HOME/org.eclipse.osgi_3.6.0.v20100517.jar com/ctp/helloworld/service/HelloWorld.java com/ctp/helloworld/service/impl/HelloWorldImpl.java com/ctp/helloworld/Activator.java;
jar cvfm example.jar META-INF/MANIFEST.MF com;
cp example.jar $APP_HOME/example.jar;

If your bundle was built correctly you could start your test application:
cd $APP_HOME;
java -jar org.eclipse.osgi_3.6.0.v20100517.jar -console;

Now you can administrate the OSGi platform with the console. Test the bundle like the following:
osgi>install file:///$APP_HOME/example.jar
Bundle id is 4

osgi>start 4
Registering HelloWorld service...
HelloWorldService#getMessage(): Hello World

osgi>

NOTE: If you want to use the service inside another bundle, you have to add the package com.ctp.helloworld.service to the Export-Package directive in the MANIFEST.MF file.

4 Multiple Implementations

This example shows you how to use multiple implementations of a service. It’s a solution which I think, personally, is quite elegant. I won’t go through all steps that we already did in the previous example. A source code can be downloaded here. Let’s create a bundle with the symbolic name com.ctp.playground.multiple and the following classes:
com.ctp.playground.multiple.Activator
com.ctp.playground.multiple.math.OperationService
com.ctp.playground.multiple.math.OperationServiceFactory
com.ctp.playground.multiple.math.internal.Addition
com.ctp.playground.multiple.math.internal.Substraction

Also create the following Enum:
com.ctp.playground.multiple.math.Operation

The bundle activator should have the following contents (don’t forget the imports):

public class Activator implements BundleActivator {

   private static BundleContext context;

   public static BundleContext getContext() {
       return context;
   }

   public void start(BundleContext bundleContext) throws Exception {
       Activator.context = bundleContext;
   }

   public void stop(BundleContext bundleContext) throws Exception {
       Activator.context = null;
   }

}

The interface com.ctp.playground.multiple.OperationService has one method:

public Double doOperation(Double a, Double b);

The classes Addition and Substraction implement this interface and are our actual services:

@Override
public Double doOperation(Double a, Double b) {
 return a + b;
}

and:

@Override
public Double doOperation(Double a, Double b) {
 return a - b;
}

The Enum Operation looks like the following (don’t forget the imports):

public enum Operation {
   ADDITION {
       @Override
       public Class<?> getServiceClass() {
           return Addition.class;
       }
   }, SUBSTRACTION {
       @Override
       public Class<?> getServiceClass() {
           return Substraction.class;
       }
   };
   public abstract Class<?> getServiceClass();
}

And now comes the part where we get our service implementations and decide which one to take. For that we created the Class OperationServiceFactory. Now extend it with the following method:

public static OperationService getService(Operation o) {
 BundleContext bundleContext = Activator.getContext();
 ServiceReference[] refs = null;
 try {
  // get the service references
  refs = bundleContext.getServiceReferences(OperationService.class.getName(),null);
  
 } catch (InvalidSyntaxException e) {
  // this should never happen, because the second argument
  // of bundleContext.getServiceReferences() is null.
  // You have the possibility to give filter criterias with
  // this parameter
 }
 OperationService service = null;
 if(refs != null) {
  for(int i = 0;i<refs.length;i++) {
   service = (OperationService) bundleContext.getService(refs[i]);
   // check, if the service is the wanted one
   if(service.getClass().equals(o.getServiceClass())) {
    return service;
   }
  }
 }
 return null;
}

All we have to do now is to register the services in the Activator class and test them. Extend the com.ctp.playground.multiple.Activator:

...
public void start(BundleContext bundleContext) throws Exception {

 Activator.context = bundleContext;
    // register services
 bundleContext.registerService(OperationService.class.getName(), new Addition(), null);
 bundleContext.registerService(OperationService.class.getName(), new Substraction(), null);
 
    // test the services
    OperationService operation = OperationServiceFactory.getService(Operation.ADDITION);
 Double result = operation.doOperation(10.0, 20.0);
 System.out.println(result);
 operation = OperationServiceFactory.getService(Operation.SUBSTRACTION);
 result = operation.doOperation(10.0, 20.0);
 System.out.println(result);
}
...

The MANIFEST.MF file should have the following contents:

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Multiple Service implementations Example
Bundle-SymbolicName: com.ctp.playground.multiple
Bundle-Version: 1.0.0
Bundle-Activator: com.ctp.playground.multiple.Activator
Bundle-Vendor: CTP
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: org.osgi.framework;version="1.3.0"
Bundle-ActivationPolicy: lazy
Export-Package: com.ctp.playground.multiple.math

Now build the bundle (compile and make jar file), put it in the $APP_HOME directory, run the platform and install / start it like we did in the previous example.
You should have the following output after starting the bundle:

osgi> 30.0
-10.0

5 Conclusion

Let’s summarize and see if you reached your targets:

OSGi is a framework specification for creating highly modular Java applications
A bundle is a simple jar file, defined through manifest headers
An OSGi Service is a simple POJO that needs to be registered in the OSGi Service Registry
You can create a simple bundle
You are able to create a simple OSGi Service
You can manage multiple service implementations

As I mentioned at the top of this blog, this is the first part of my series about OSGi and Eclipse plug-in development. I will publish the blogs like the following (there may be changes):

Introduction to OSGi
OSGi in a declarative way
How to use additional frameworks like Spring DM or Declarative Services
OSGi and Eclipse
The way how Eclipse uses OSGi and introduction to Eclipse plug-in development
Eclipse UI
How the Eclipse UI works and how to use it
Eclipse SDK 4.0 - Model driven development
All about the new Eclipse SDK and its model driven approach
Eclipse SDK 4.0 - New features
New features of the SDK like XWT and usage of dependency injection

I hope you enjoyed this little introduction to OSGi and I’m looking forward to read your comments, so I could improve my further planned blogs.

Starting Scala

2010-10-15T08:10:00.004+02:00

I'm starting to learn Scala. I try to learn a new programming language every year (a tip from the Pragmatic programmer) because it's a good way to keep your head young. Last year I learned JavaFx Script, too bad that Oracle announced that they are not going forward with this. I really liked the whole notion of binding.

Anyway Scala is a functional language, so that will be a challenge, because I've never written any code in a functional language before. I'm still learning so I thought let's take something form my day to day job.

This was the problem, we have a web service that we can only call with 100 ids at a time. So we need to split our list with ids in batches of a 100. Fist I thought there must be some library that can do this. We did some google-ing, but we could not find it, so this is what we came up with:


    static <E> List<List<E>> subDivide(List<E> list, int size) {
        List<List<E>> resultList = new ArrayList<List<E>>();
        
        int subdivideCount = list.size() / size;
        if (list.size() % size != 0) {
            subdivideCount++;
        }
        
        for (int i = 0; i < subdivideCount; i++) {
            int maxLength = Math.min(i * size + size, list.size());
            resultList.add(list.subList(i * size, maxLength));
        }
        
        return resultList;
    }

Very standard way to solve something like this in Java. So I thought let's solve this in Scala. List are very cool in Scala and you can do pattern matching on them. Let's try that:


  def subDivide(list: List[Int], batchSize:Int):List[List[Int]] = list match {
    case Nil => Nil
    case l if l.length > batchSize => List(list.splitAt(batchSize)._1) ::: subDivide(list.splitAt(batchSize)._2, batchSize)
    case l => List(list)
  }

As you can see this code is much nicer. It checks the size of the list taking the batchSize off and then sub dividing the rest and adding this to the result. If the size is smaller than the batchSize we can return it without splitting. If anyone knows a better way of doing this in Scala, please leave me a comment.

This is a much nicer solution, because there is way less int calculation involved. And the recursion also makes it a lot nicer, because there is no need of a for loop. So maybe this is what people are talking about, Scala does make you solve things differently.

But of course we could do this in Java as well. In Java we don't have a nice pattern matching, so we'll have to do with if-s.


    static <E> void subDivide(List<E> list, int size, List<List<E>> result) {
        if (list.isEmpty()) {
            return;
        } 
        if (list.size() > size) {
            result.add(list.subList(0, size));
            subDivide(list.subList(size, list.size()), size, result);
        } else {
            result.add(list);
        }
    }

As you can see a lot better. So at least Scala improved my Java code a bit today.

Swiss ICT Awards 2010

2010-09-28T09:32:00.004+02:00

Ok, this is not really a Java article as we usually post here on the blog - just a small company advertisement where you might help out. CTP has been nominated by the Swiss ICT Awards 2010 in the category "Champion". This award category gets selected by a jury. For the PUBLIC category, you can actually place a vote!

Please click on the below link and vote for Cambridge Technology Partners now and we may become the winners of the PUBLIC category:

http://www.swissitmagazine.ch/index.cfm?pid=7786&cid=2103

Thanks!

JavaOne 2010

2010-09-23T06:13:00.051+02:00

Time is running quickly, and shocked we have realized that this year's JavaOne is already over - high time to share some conference highlights with you! It's the first time that Oracle drove the conference after acquiring Sun, so we were curious whether the spirit we valued so much during the last years is still around. To give you the conclusion already now - it's a yes, but there are some drawbacks.

It's clear that JavaOne is just the "side conference" this year - it had to leave its home in the Moscone center, which is mainly hosting Oracle OpenWorld. With the move, things got slightly smaller - session rooms (which is probably the most annoying aspect), the chill-out zones and exhibition space, ... . But of course it's not the size that matters; it's the content that compensates for it! The quality of the talks, we've seen, has been very good so far, and as usual it's a lot of great ideas, visions and news floating around. Below we give you a quick summary of the latest Java news and session highlights:

Keynotes

On Sunday evening Larry Ellison hosted the opening session of the Oracle OpenWorld. First of all most of the JavaOne attendees were rather surprised, they were not allowed to join in for this keynote. Nevertheless a quick update on this keynote is provided here before moving on with the real Java stuff.

The first presentation was the Oracle Exalogic Elastic Cloud, which is very briefly summarized “The Cloud in a Box”. The Exalogic box provides both hardware and software. Oracle further announced benefits to the customer due to the homogeneous hardware and software, which is also reflected in Oracle's new tag line "Hardware and Software Engineered to Work Together". Exalogic combines up to 30 servers, including storage (hard disk drive and SSD) and a high-speed internal network between the servers in a rack. The Exalogic solution is designed and optimized to run Enterprise Java applications, i.e. the Oracle Fusion Middleware stack, similar to the Oracle Exadata center which runs Oracle DB servers. Oracle Exalogic can be scaled from 1/4 up to 8 racks, whereas according to Larry Ellison two full racks were enough to host all of Facebook.com.

Afterwards the Unbreakable Enterprise Kernel was presented, which will be 100% RedHat compatible. It is Oracle’s answer to the slowly moving RedHat distribution; according to Larry Ellison RedHat is 4 years behind the mainline.

Finally Oracle Fusion Application was unveiled. It is a CRM/ERP/HRMS system which offers the features of products earlier acquired by Oracle such as PeopleSoft and Siebel. The entire code basis has been re-written based on Oracle Fusion Middleware, which had to be enhanced to support all the middleware functionality needed. It took Oracle five years to develop Oracle Fusion Applications and is one of the biggest projects Oracle ever faced.

On Monday and Tuesday the JavaOne Opening Keynote and the General Technical Session were about the Future of Java, which is the right thing to do after the Sun/Oracle merger last year. After finalizing the Java EE 6 Specification in December 2009, this year the focus is moved to the next version of the Java Standard Edition (Java SE). The last update on the Standard Edition was Java SE 6 in 2006. After a five years break we will get two new versions within roughly 18 months, OpenJDK 7 in mid 2011 and OpenJDK 8 in late 2012.

Java SE version 7 contains a bunch of smaller language changes and enhancements. Project Coin contributes most of the new language features, such as Diamond Operator for declaration and instantiation of generics, Try-with-Resource block for proper closing of resources implementing the new AutoCloseable interface in the java.lang package, Mutli-Catch and Re-Throw of Exceptions, Switch statements with Strings and String literals using “_” (int a = 0b100_1010_0011;). Additionally JSR 292 is implemented in this release, which supports mainly other languages setting up on top of the JVM, such as Scala and Groovy. The Fork/Join Framework provides better support for modern multi core processors. There are some other updates shipped with this release such as JDBC 4.1, which supports resource management, and more.

Java SE version 8 will bring a new modularization concept, finally no more hassle with the JAR files and the classpath! Project Jigsaw is defining these new features. A module (*.jmod) contains all its classfiles and a declaration of modules it depends on. This declaration is placed in the module-info.java file, which contains the name and the version of the dependencies. Modules need to be installed on the target system before they can be executed. A second set of major improvements will come out of the Project Lambda. These improvements include closures, value classes - no need to write getters and setters, extension methods and eventually reification.

On the tooling side two new versions of Netbeans IDE will be released during 2011 (check the feature list). Project Glassfish also committed to publish two new releases during calendar year 2011 (check the feature list).

JavaFX script will not be further developed by Oracle and is replaced by a set of APIs, which is supposed to make the technology more accessible to all Java developers without the need to learn a new language. Additionally 3D support is added to JavaFX! According to Thomas Kurian there will be direct 3D hardware rendering support using Microsoft DirectX or OpenGL and a HTML5/JavaScript output for web-based clients.

Not surprisingly, hot topics like the lawsuit with Google or the future of the JCP were not discussed.

Session Highlights

In Hyperproductive JSF 2.0, JSF co-spec lead Ed Burns showed a couple of reasons why your project development might run with hand brake pulled. With several demos he showed probably underused new features in JSF 2 like Groovy support for all JSF artifacts that get hot deployed, or the new facelets >ui:debug< tag that gives you information on the component trees or scope variables. He also emphasised the importance of standards or conventions for a team, which is indeed an often overlooked aspect when a new project needs to get out quickly. This was supplemented by another talk on the new JSF 2 composite components, which make it very easy to create reusable components for e.g. your corporate layout and build up a highly productive framework like that.

While Maven founder Jason van Zyl's talk on Maven 3 was not intended to show new Maven features, he gave an overview of how he envisions future enterprise development. This includes tight integration from IDE over SCM to CI, up to a new tool called Proviso which is targeted to standardize enterprise deployment processes. Another interesting aspect was how Sonatype standardized their component model around Maven and Hudson plugins as well as their repository manager to achieve better reuse, which is now all built around JSR-330.

As a company mainly dealing with enterprise development we were of course giving a main focus on all the Java EE 6 talks. Spec lead Roberto Chinnici gave one of them explaining the Java EE programming model. Even though we have been working with the technology for a while now, this gave a nice summary and showed again that you still get that extra little information from JavaOne that makes the conference very useful when you hear things from the mind behind it. Roberto provided a quick overview on managed beans, CDI and several "must knows" when changing to the new programming model.

On the same track was Dan Allen with presenting in depth on CDI and Seam 3. The talk went from all the CDI concepts from typesafe injection with qualifiers over loose coupling with events to the SPI in CDI leading to Seam 3. This is now split in several independent modules where your application can take what it needs. Spinning this thought further - why not break up all the EJB services and make them a portable extension? We might see something like this in Java EE 7. By the way, Dan is not only an excellent author (when are we going to see Seam in Action 2nd edition?), but also a great speaker - make sure to visit one of his talks when you got a chance.

To close the sessions on Java EE, we were deeply impressed by the session on Arquillian. The framework evolved out of working on the RI for CDI (Weld) and takes the idea of the new EE component model to your unit tests. By eliminating the build to create archives for integration tests, the team around Arquillian has managed to decrease complexity and improve speed of the integration test massively - something critical if you want your team to actually use them. The outcome was a generic component testing framework, which we're convinced will significantly improve quality on EE applications. You can programmatically create an archive on the components you want to test, and run the test either in container or as client in a running application server. This is the time when you feel that enterprise engineering is still a young discipline - why has this not been around for longer?

Last but not least, if you have been following our people spotlights you probably know we're big fans of the Java Posse! As in the last 4 years the posse was present also at this year's JavaOne holding a BoF in the Mason street tent, celebrating the 5th anniversary of the Java Posse. While it was less interactive than the last years BoFs, we got a great show with special guest "Loose" Bruce Kerr giving a live performance of the Posse song, funky costumes and interesting insights on the future of Java - well kind of. Go and download the recordings - although this time I guess it's too bad this is not a video podcast!

As usual we enjoyed being here - CU again next year!

Installing Oracle on Ubuntu

2010-09-21T14:02:00.020+02:00

Most of the applications we write here at CTP depend on an Oracle database.
After putting some effort on configuring our development environment for a new project and figuring out the process wasn't as straightforward as I expected, I decided to share my finding in this walkthrough.
It describes the steps required to install Oracle on a Ubuntu Server.

Prerequisites

The instructions apply to Oracle 11g (version 11.2.0.1.0) on an Ubuntu 10.04.1 Server Edition 64-bit.
Download Ubuntu's installation ISO from http://www.ubuntu.com/server/get-ubuntu/download and Oracle's ZIPs from http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html.
A Windows environment is used as client. You will need the following tools:

PuTTY, an SSH client - http://www.chiark.greenend.org.uk/~sgtatham/putty/
Cygwin X, a POSIX environment, but here we're interested only on its X-Server capabilities - http://www.cygwin.com
- You will need the following packages (within group "X11")
  - xorg-server
  - xinit
  - xorg-docs (optional, man)
  - X-start-menu-icons
- From other packages
  - openssh
  - inetutils

Server configuration

Installation

Install Ubuntu in your server. In this example a virtual machine with 32 Gb of disk and 2Gb of RAM is used.
During the installation process, select the "SSH server" to be installed. To do it after installation, run:


  sudo apt-get install openssh-server openssh-client

X Forwarding

You should configure PuTTY to forward the graphical applications from the Ubuntu server (the 'server') to your Windows workstation (the 'client'),
as the Oracle 11g installation depends on it.
Open PuTTY and enter the IP address of your server, give a name to the session and save it. Configure the following options:

In "Connection > SSH > X11", check "Enable X11 forwarding" and for "X display location" enter "localhost:0"

Go to the "Session" menu and save your session again, to persist the configuration changes.

Start the X server in your client computer before connecting to the server through PuTTY. In the programs menu, open "Cygwin-X" and run "XWin Server".
It may start a graphical terminal (XTerm) but you should close it, to avoid confusion. All you need is to keep the server running, indicated by the fancy X icon in the system tray.
Now you can establish the SSH connection. To test if the X Forwarding is properly configured, run xeyes in the server (if not found, run sudo apt-get install x11-apps) and you should see the eyes in your desktop.

Swap configuration

The amount of swap space required by the Oracle DB depends on the available RAM:

Available RAM	Swap required
Between 1 and 2 Gb	1.5 x RAM
Between 2 and 16 Gb	1 x RAM
More than 16 Gb	16 Gb

To check the existing configured space, run


  $ free
               total       used       free     shared    buffers     cached
  Mem:       2057836     181680    1876156          0      12268      91092
  -/+ buffers/cache:      78320    1979516
  Swap:      1417208          0    1417208

In this walkthrough I'm going to add 2Gb to the existing swap space.


  # Creates a swap file, may take a while to execute
  $ sudo dd if=/dev/zero of=/mnt/2Gb.swap bs=1M count=2048
  # Activating the swap file
  sudo mkswap /mnt/2Gb.swap
  sudo swapon /mnt/2Gb.swap

To have the swap file mounted automatically after a reboot, add the following line to the /etc/fstab file:


  /mnt/2Gb.swap   none    swap    sw      0       0

Updating and installing dependencies


  $ sudo apt-get update
  $ sudo apt-get upgrade
  $ sudo apt-get install build-essential libaio1 libaio-dev libmotif3 libtool expat alien ksh pdksh unixODBC unixODBC-dev sysstat elfutils libelf-dev binutils lesstif2 lsb-cxx rpm lsb-rpm gawk unzip x11-utils ia32-libs

Installing libstdc++ 5

Ubuntu comes with libstdc++ version 6, but Oracle requires version 5. To fix it:


  $ wget http://mirrors.kernel.org/ubuntu/pool/universe/g/gcc-3.3/libstdc++5_3.3.6-17ubuntu1_amd64.deb
  $ dpkg-deb -x libstdc++5_3.3.6-17ubuntu1_amd64.deb ia64-libs
  $ sudo cp ia64-libs/usr/lib/libstdc++.so.5.0.7 /usr/lib64
  $ cd /usr/lib64
  $ sudo ln -s libstdc++.so.5.0.7 libstdc++.so.5
  $ ls -al libstdc++.*
  lrwxrwxrwx 1 root root      18 2010-09-17 14:19 libstdc++.so.5 -> libstdc++.so.5.0.7
  -rw-r--r-- 1 root root  829424 2010-09-17 14:18 libstdc++.so.5.0.7
  lrwxrwxrwx 1 root root      19 2010-09-14 12:05 libstdc++.so.6 -> libstdc++.so.6.0.13
  -rw-r--r-- 1 root root 1044112 2010-03-27 01:16 libstdc++.so.6.0.13

Links update

Update the symbolic link /bin/sh from /bin/dash to /bin/bash.


  $ ls -l /bin/sh
  lrwxrwxrwx 1 root root 4 2010-09-14 12:05 sh -> dash
  $ cd /bin
  $ sudo ln -sf bash /bin/sh
  $ ls -l sh
  lrwxrwxrwx 1 root root 4 2010-09-14 14:19 sh -> bash

Some links need to be created as well:


  ln -s /usr/bin/awk /bin/awk
  ln -s /usr/bin/rpm /bin/rpm
  ln -s /usr/bin/basename /bin/basename

System users & groups

Change to root and create the following users and groups


  ctp@oracle11g:~$ sudo -s
  root@oracle11g:~# addgroup oinstall
  Adding group `oinstall' (GID 1001) ...
  Done.
  root@oracle11g:~# addgroup dba
  Adding group `dba' (GID 1002) ...
  Done.
  root@oracle11g:~# addgroup nobody
  Adding group `nobody' (GID 1003) ...
  Done.
  root@oracle11g:~# usermod -g nobody nobody
  root@oracle11g:~# useradd -g oinstall -G dba -p password -d /home/oracle -s /bin/bash oracle
  root@oracle11g:~# passwd -l oracle
  passwd: password expiry information changed.
  root@oracle11g:~# mkdir /home/oracle
  root@oracle11g:~# chown -R oracle:dba /home/oracle

Creating ORACLE_HOME


  root@oracle11g:~# mkdir -p /u01/app/oracle
  root@oracle11g:~# chown -R oracle:dba /u01

System parameters

Some Linux kernel parameters need to be modified, as specified in Oracle's installation guide. To do that, add the parameters below to the file /etc/sysctl.conf:


  fs.file-max = 65535   
  kernel.shmall = 2097152   
  kernel.shmmax = 2147483648   
  kernel.shmmni = 4096   
  kernel.sem = 250 32000 100 128   
  net.ipv4.ip_local_port_range = 1024 65535   
  net.core.rmem_default = 1048576   
  net.core.rmem_max = 1048576   
  net.core.wmem_default = 262144   
  net.core.wmem_max = 262144

The oracle user needs to have some shell limits increased by adding the parameters below to the file /etc/security/limits.conf:


  oracle soft nproc 2047   
  oracle hard nproc 16383   
  oracle soft nofile 1023   
  oracle hard nofile 65535

Add the parameters below to the file /etc/pam.d/login:


  session required /lib/security/pam_limits.so   
  session required pam_limits.so

Reboot the system to reload the configuration.

Oracle installation

From the directory you extracted the Oracle zip files, run database/runInstaller as the user oracle created above (see Unix Tips if you need help). You can ignore the DISPLAY warning, if any. If you receive an error regarding the X forwarding permission, use this remote X forwarding trick.

Installation options

The suggested installation options:

Create and configure a database

Server class

Single instance database installation

Advanced install

Enterprise Edition

General purpose/Transaction processing

Memory, Character sets, Security and Sample Schemas - as default

Run the fixup script following the instructions and then ignore the package dependencies.

To check if everything is ok, open the following address in your browser:


  https://<server>:1158/em

Startup script

First, edit the file /etc/oratab or create one if you don't have it already. Make sure that the last parameter is "Y", meaning you want the database to be started during boot.


  oracle:/u01/app/oracle/product/11.2.0/dbhome_1:Y

Now create the startup script /etc/init.d/oracledb.


  cd /etc/init.d
  sudo touch oracledb
  sudo chmod a+x oracledb

Add the following content to the startup script


  #!/bin/bash
  #
  # /etc/init.d/oracledb
  #
  # Run-level Startup script for the Oracle Enterprise Manager
  
  export ORACLE_BASE=/u01/app/oracle
  export ORACLE_HOME=$ORACLE_BASE/product/11.2.0/dbhome_1
  export ORACLE_OWNR=oracle
  export ORACLE_SID=oracle
  export PATH=$PATH:$ORACLE_HOME/bin
  
  if [ ! -f $ORACLE_HOME/bin/emctl -o ! -d $ORACLE_HOME ]
  then
      echo "Oracle startup: cannot start"
      exit 1
  fi
  
  case "$1" in
      start)
          # Oracle listener and instance startup
          echo -n "Starting Oracle: "
          sudo -u $ORACLE_OWNR -E $ORACLE_HOME/bin/lsnrctl start
          sudo -u $ORACLE_OWNR -E $ORACLE_HOME/bin/dbstart $ORACLE_HOME
          sudo -u $ORACLE_OWNR -E touch /var/lock/oracle
          # Oracle enterprise manager startup
          sudo -u $ORACLE_OWNR -E $ORACLE_HOME/bin/emctl start dbconsole
          echo "OK"
          ;;
      stop)
          
          echo -n "Shutdown Oracle: "
          # Oracle enterprise manager shutdown
          sudo -u $ORACLE_OWNR -E $ORACLE_HOME/bin/emctl stop dbconsole
          # Oracle listener and instance shutdown
          sudo -u $ORACLE_OWNR -E $ORACLE_HOME/bin/lsnrctl stop
          sudo -u $ORACLE_OWNR -E $ORACLE_HOME/bin/dbshut $ORACLE_HOME
          sudo -u $ORACLE_OWNR -E rm -f /var/lock/oracle
          echo "OK"
          ;;
      reload|restart)
          $0 stop
          $0 start
          ;;
      *)
          echo "Usage: `basename $0` start|stop|restart|reload"
          exit 1
  esac
  
  exit 0

To execute the script automatically during server startup:


  sudo update-rc.d oracledb defaults 99

General tips n' tricks

Unix tips

Open a shell as anoter user:


  sudo -u <username> -s

Remote X session config


  $ xauth list
  oracle/unix:10  MIT-MAGIC-COOKIE-1  a18621a7bf2c102fc2b27758007b56a0
  # Copy the line returned above 
  sudo -u oracle -s
  export HOME=/home/oracle
  # Paste the copied line after xauth add
  xauth add oracle/unix:10  MIT-MAGIC-COOKIE-1  a18621a7bf2c102fc2b27758007b56a0

References

http://download.oracle.com/docs/cd/B28359_01/install.111/b32285/toc.htm

http://en.kioskea.net/faq/4405-linux-installing-oracle-11g-on-ubuntu

http://www.pythian.com/news/2329/installing-oracle-11gr1-on-ubuntu-904-jaunty-jackalope/

http://forums.oracle.com/forums/thread.jspa?threadID=1077139

Java People Spotlight: Bartek Majsak

2010-08-13T14:22:00.001+02:00

I'm glad to write another people spotlight, this time about a "newbee" (from a timely perspective), or from a technical perspective about a spicy addition to the Java Geeks at our Zurich Office: Bartosz Majsak... well actually Bartek, but that's another story. He joined CTP in March 2010.
So let's see how geeky his answers are then!

Java Competence Role:
Senior Developer [aka Mr. T due to his extreme passion on Testing]
My Master Kung-Fu Skills:
I can mock you out even if you are static ;)
I'd be excited to get my hands dirty on:
Scala and/on Android

Q&A
Q: Hi Bartek, how would your message look like if you would have to tell it via Twitter what you are currently doing?
A: Thinking how to design my own #arquillian TestEnricher and how to complete "The Challenge of Hades" in GoW at the same time.
Q: ... and having some drops of Sudden Death on top of it? ;-)

Q: What was the greatest piece of code you have ever written so far?
A: Please come back to me with this question when I will retire :) After a few days, the code which I thought was the most brilliant I've ever written... I refactor, so... I don't have a good answer for this question yet :D

Q: What is the best quote you have ever heard about programming?
A: "If debugging is the process of removing bugs, then programming must be the process of putting them in." (E.W. Dijkstra)

Q: What is the best quote you have heard from our managers?
A: "There is nothing as permanent as a temporary solution".

Q: What is the most cutting-edge technology or framework you actually used on projects?
A: CDI (JSR-299) and Arquillian.

Q: What is your favorite podcast?
A: I used to listen podcast while I was commuting but nowadays I'm a little bit out of the loop - living too close to the office ;) Of course I like Java Posse (who doesn't?!) and Software Engineering Radio. I'm also addicted to Parleys, DZone and InfoQ.

Q: Which Java book can you recommend and for what reason?
A: I really enjoyed reading "Implementation Patterns" by Kent Beck and "Working Effectively with Legacy Code" by Michael Feathers. The first one gives you interesting hints for how to express yourself through code by keeping it clean and easy to understand for others. The second one will help you to stay sane while digging into the code of a person who definitely never read the first book. If you are serious about testing you should read Growing Object-Oriented Software Guided by Tests by Steve Freeman & Nat Pryce as well as xUnit Test Patterns by Gerard Meszaros. Of course all books recommended already by my colleagues are also just great but I didn't want to repeat them here.
Q: DRY pattern... :-) .... Well thanks for your answers and enjoy your mock-ito this evening at the CTP Summer Event!!

You can further follow Bartek's web presence in these directions:
- linked in: http://ch.linkedin.com/in/bartoszmajsak
- lastfm: http://www.last.fm/user/majson
- twitter: http://twitter.com/majson

Test drive with Arquillian and CDI (Part 2)

2010-08-13T11:02:00.005+02:00

The first part of the Arquillian series was mainly focused on working with an in-memory database, DI (dependency injection) and events from the CDI spec. Now we will take a closer look on how to deal with testing Contextual components. For this purpose we will extend our sample project from the first part by adding a PortfolioController class, a conversation scoped bean for handling processing of user's portfolio management.

@ConversationScoped @Named("portfolioController")
public class PortfolioController implements Serializable {
    
    // ...

    Map<Share, Integer> sharesToBuy = new HashMap<Share, Integer>();

    @Inject @LoggedIn
    User user;

    @Inject
    private TradeService tradeService;
    
    @Inject
    private Conversation conversation;
    
    public void buy(Share share, Integer amount) {
        if (conversation.isTransient()) {
            conversation.begin();
        }
        Integer currentAmount = sharesToBuy.get(share);
        if (null == currentAmount) {
            currentAmount = Integer.valueOf(0);
        }
        
        sharesToBuy.put(share, currentAmount + amount); 
    }
      
    public void confirm() {
        for (Map.Entry<Share, Integer> sharesAmount : sharesToBuy.entrySet()) {
            tradeService.buy(user, sharesAmount.getKey(), sharesAmount.getValue());
        }
        conversation.end();
    }
 
    public void cancel() {
        sharesToBuy.clear();
        conversation.end();
    }

    // ...

}

So, let's try out Arquillian! As we already know from the first part we need to create a deployment package, which then will be deployed by Arquillian on the target container (in our case Glassfish 3.0.1 Embedded).


@Deployment
public static Archive<?> createDeploymentPackage() {
    return ShrinkWrap.create("test.jar", JavaArchive.class)
                     .addPackages(false, Share.class.getPackage(), 
                                         ShareEvent.class.getPackage())
                     .addClasses(TradeTransactionDao.class, 
                                 ShareDao.class, 
                                 PortfolioController.class)
                     .addManifestResource(new ByteArrayAsset("<beans />".getBytes()), ArchivePaths.create("beans.xml"))
                     .addManifestResource("inmemory-test-persistence.xml", ArchivePaths.create("persistence.xml"));
}

Next we can start develop a simple test scenario:

given user choose CTP share,

when he confirms the order,

then his portfolio should be updated.

Which in JUnit realms could be written as follows:


@RunWith(Arquillian.class)
public class PortfolioControllerTest {

    // deployment method
          
    @Inject 
    ShareDao shareDao;
    
    @Inject
    PortfolioController portfolioController;
    
    @Test   
    public void shouldAddCtpShareToUserPortfolio() {
        // given
        User user = portfolioController.getUser();
        Share ctpShare = shareDao.getByKey("CTP");
        
        // when
        portfolioController.buy(ctpShare, 1);
        portfolioController.confirm();
        
        // then
        assertThat(user.getSharesAmount(ctpShare)).isEqualTo(3);
    }
        
}

Looks really simple, doesn't it? Well, it's almost that simple but there are some small details which you need to be aware of.

Producers

CDI provides a feature similar to Seam factories or Guice providers. It's called producer and it allows you to create injectable dependency. This could be especially useful when creation of such an instance requires additional logic, i.e. it needs to be obtained from an external source. A logged in user in a web application is a good example here. Thanks to the CDI @Produces construct we can still have very clean code which just works! All we need to do in order to inject the currently logged in user to our bean is as simple as that:

1. Create a @LoggedIn qualifier which will be used to define that a particular injection is expecting this concrete User bean.


@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
public @interface LoggedIn {
}

2. Implement the producer method which will instantiate the logged in user in the session scope just after he successfully accesses the application, so it will provide an instance of the User class which is of @LoggedIn "type".


@Produces @SessionScoped @LoggedIn User loggedInUser() {
    // code for retrieving current user from session
}

3. Decorate all injection points in other beans where we need this instance.


@Inject @LoggedIn
User user;

However this construct could be problematic when writing tests and an attentive reader would probably already be concerned about it. But with Arquillian we will run our test code in the CDI container and there is no need to simulate login procedure, using mock http sessions or any other constructs. We can take full advantage of this fact and create producer method which will replace our original one and provide the user directly from entity manager for example.


@Produces @LoggedIn User loggedInUser() {
    return entityManager.find(User.class, 1L);
}

Note: I removed @SessionScoped annotation from loggedInUser() producer method intentionally. Otherwise you could have troubles with Weld proxies and EclipseLink while trying to persist the entity class. For tests it actually does not make any difference.

Context handling

One small problem arrived when I tried to test logic based on the conversation context. I had to figure out a way to programmatically create the appropriate context which then will be used by the SUT (or CUT if you prefer this abbreviation), because I was getting org.jboss.weld.context.ContextNotActiveException. Unfortunately I wasn't able to find anything related to it on the Arquillian forum or wiki, so I desperately jumped to the Seam 3 examples. I read somewhere that they are also using this library to test their modules and sample projects. Bingo! I found what I was looking for. To make the test code more elegant I built my solution the same way as for handling the database in the first part - by using annotations and JUnit rules. Using a @RequiredScope annotation on the test method will instruct JUnit rule to handle proper context initialization and cleanup after finishing the test. To make the code even cleaner we can implement such logic in a dedicated class and treat the enum as a factory:


public enum ScopeType {

    CONVERSATION {
        @Override
        public ScopeHandler getHandler() {
            return new ConversationScopeHandler();
        }
    }
 
    // ... other scopes
    
    public abstract ScopeHandler getHandler();
    
}


public class ConversationScopeHandler implements ScopeHandler {

    @Override
    public void initializeContext() {
        ConversationContext conversationContext = Container.instance().services().get(ContextLifecycle.class).getConversationContext();
        conversationContext.setBeanStore(new HashMapBeanStore());
        conversationContext.setActive(true);
    }

    @Override
    public void cleanupContext() {
        ConversationContext conversationContext = Container.instance().services().get(ContextLifecycle.class).getConversationContext();
        if (conversationContext.isActive()) {
            conversationContext.setActive(false);
            conversationContext.cleanup();
        }
    }
}

The JUnit rule will only extract the annotation's value of the test method and delegate context handling to the proper implementation:


public class ScopeHandlingRule extends TestWatchman {

    private ScopeHandler handler;
    
    @Override
    public void starting(FrameworkMethod method) {
        RequiredScope rc = method.getAnnotation(RequiredScope.class);
        if (null == rc) {
            return;
        }       
        ScopeType scopeType = rc.value();
        handler = scopeType.getHandler();
        handler.initializeContext();
    }
    
    @Override
    public void finished(FrameworkMethod method) {
        if (null != handler) {
            handler.cleanupContext();
        }
    }
}

Finally here's fully working test class with two additional test scenarios. I also used DBUnit add-on from first post for convenience.


@RunWith(Arquillian.class)
public class PortfolioControllerTest {

    @Rule
    public DataHandlingRule dataHandlingRule = new DataHandlingRule();
    
    @Rule
    public ScopeHandlingRule scopeHandlingRule = new ScopeHandlingRule();
    
    @Deployment
    public static Archive<?> createDeploymentPackage() {
        return ShrinkWrap.create("test.jar", JavaArchive.class)
                         .addPackages(false, Share.class.getPackage(), 
                                             ShareEvent.class.getPackage())
                         .addClasses(TradeTransactionDao.class, 
                                     ShareDao.class, 
                                     TradeService.class,
                                     PortfolioController.class)
                         .addManifestResource(new ByteArrayAsset("<beans />".getBytes()), ArchivePaths.create("beans.xml"))
                         .addManifestResource("inmemory-test-persistence.xml", ArchivePaths.create("persistence.xml"));
    }
    
    @PersistenceContext
    EntityManager entityManager;
    
    @Inject 
    ShareDao shareDao;
    
    @Inject
    TradeTransactionDao tradeTransactionDao;
    
    @Inject
    PortfolioController portfolioController;
    
    @Test
    @PrepareData("datasets/shares.xml")
    @RequiredScope(ScopeType.CONVERSATION)
    public void shouldAddCtpShareToUserPortfolio() {
        // given
        User user = portfolioController.getUser();
        Share ctpShare = shareDao.getByKey("CTP");
        
        // when
        portfolioController.buy(ctpShare, 1);
        portfolioController.confirm();
        
        // then
        assertThat(user.getSharesAmount(ctpShare)).isEqualTo(3);
    }
    
    @Test
    @PrepareData("datasets/shares.xml")
    @RequiredScope(ScopeType.CONVERSATION)
    public void shouldNotModifyUserPortfolioWhenCancelProcess() {
        // given
        User user = portfolioController.getUser();
        Share ctpShare = shareDao.getByKey("CTP");
        
        // when
        portfolioController.buy(ctpShare, 1);
        portfolioController.cancel();
        
        // then
        assertThat(user.getSharesAmount(ctpShare)).isEqualTo(2);
    }
    
    @Test
    @RequiredScope(ScopeType.CONVERSATION)
    @PrepareData("datasets/shares.xml")
    public void shouldRecordTransactionWhenUserBuysAShare() {
        // given
        User user = portfolioController.getUser();
        Share ctpShare = shareDao.getByKey("CTP");
        
        // when
        portfolioController.buy(ctpShare, 1);
        portfolioController.confirm();

        // then
        List<TradeTransaction> transactions = tradeTransactionDao.getTransactions(user);
        assertThat(transactions).hasSize(1);
    }
    
    @Produces @LoggedIn User loggedInUser() {
        return entityManager.find(User.class, 1L);
    }
    
}

For the full source code you can jump directly to our google code repository.

Conclusion

As you can see playing with Arquillian is pure fun for me. Latest 1.0.0.Alpha3 release brought a lot of new goodies to the table. I hope that the examples in this blog post convinced you that working with different scopes is quite straightforward and requires just a little bit of additional code. However it's still not the ideal solution because it's using Weld's internal API to create and manage scopes. So if you are using a different CDI container you need to figure out how to achieve it, but it's just a matter of adjusting ScopeHandler implementation to your needs.

There is much more to write about Arquillian so keep an eye on our blog and share your thoughts and suggestions through comments.

Using Seam 2 with JPA 2

2010-07-30T13:20:00.008+02:00

It’s a difficult time to architect new Java web applications. Seam 2 is a proven and well working application stack, but we will hardly see many new versions on the Seam 2 train. Java EE 6 is in general an excellent option, but if your customer’s choice of application server does not yet support it, it is not reasonable. Also there is still some time left for Seam 3 prime time, which builds on top of Java EE 6.

Facing this kind of choice recently, I looked into possible migration paths between the two variants. One thing I have seen often on Seam 2 applications is that people really like the Hibernate criteria API and therefore use Hibernate directly. While Hibernate is an excellent ORM framework, it’s preferrable to use the JPA API when moving to Java EE 6. So - why not use Seam 2 with JPA 2, which finally features an even better (typesafe) criteria API?

It turns out to be a quite easy setup (once you get classloading right), with some small extra modifications. I’ve been using Maven, Seam 2.2 and Hibernate 3.5.4 on JBoss 4.2.3. Lets start with preparing the server. You need to remove the old Hibernate and JPA classes and add the new persistence provider with some dependencies (of course this will be different on other servers):

To be removed from server/lib:

Add to server/lib:

Next lets create a sample Seam project. I’m using the CTP Maven archetype for Seam. In the POM file, remove the references to the Hibernate and old JPA libraries and add the new JPA 2 libraries:


<!-- Remove all embedded dependencies
<dependency>
    <groupId>org.jboss.seam.embedded</groupId>
    <artifactId>...</artifactId>
</dependency --> 

 <dependency> 
    <groupId>org.hibernate.javax.persistence</groupId>
     <artifactId>hibernate-jpa-2.0-api</artifactId>
     <version>1.0.0.Final</version>
     <scope>provided</scope>
 </dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>3.5.4-Final</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-jpamodelgen</artifactId>
    <version>1.0.0.Final</version>
    <scope>provided</scope>
</dependency>

Note: If you’ve been using embedded JBoss for your integration tests, this will probably not work without exchanging the JARS there too. I’ve been moving away from this approach as it turned out to be a common reason for headache on our nightly builds as well as running tests in Eclipse. I’m very excited to see Arquillian evolving on this topic!

JPA 2 integrates with JSR 303 bean validation, which is the successor of Hibernate Validator. Unfortunately Seam 2 has references to Hibernate Validator 3, where JPA needs version 4. Adding the validator legacy JAR fixes this problem. As bean validation is now part of Java EE 6, we can add it to the server classpath as shown above, as well as to our POM:


<dependency>
    <artifactId>validation-api</artifactId>
    <groupId>javax.validation</groupId>
    <version>1.0.0.GA</version>
    <scope>provided</scope>
</dependency>

Now it’s time to move to some code. You can jump straight in your persistence config files and bring the schema up to version 2:


<persistence xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd" 
             version="2.0"> ...

<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
      version="2.0"> ...

Seam proxies entity managers to implement features like EL replacements in JPQL queries. This proxy does not implement methods new in JPA 2 and will therefore fail. You can write your own proxy very easy:


public class Jpa2EntityManagerProxy implements EntityManager {
    
    private EntityManager delegate;

    public Jpa2EntityManagerProxy(EntityManager entityManager) {
        this.delegate = entityManager;
    }
    
    @Override
    public Object getDelegate() {
       return PersistenceProvider.instance()
               .proxyDelegate(delegate.getDelegate());
    }

    @Override
    public void persist(Object entity) {
        delegate.persist(entity);
    }
    ...
}

Add the special Seam functionality as needed. In order to use the proxy with Seam, you’ll have to overwrite the HibernatePersistenceProvider Seam component:


@Name("org.jboss.seam.persistence.persistenceProvider")
@Scope(ScopeType.STATELESS)
@BypassInterceptors
// The original component is precedence FRAMEWORK
@Install(precedence = Install.APPLICATION, 
        classDependencies={"org.hibernate.Session",
                           "javax.persistence.EntityManager"})
public class HibernateJpa2PersistenceProvider extends HibernatePersistenceProvider {

    @Override
    public EntityManager proxyEntityManager(EntityManager entityManager) {
       return new Jpa2EntityManagerProxy(entityManager);
    }

}

If you use Hibernate Search, have a look at the superclass implementation - you might want to instantiate a FullTextEntityManager directly (as you have it in your classpath - but note that this has not been tested here).

Both implementations are on our Google Code repository, and you can integrate them directly over the following Maven dependency:


<dependency>
    <groupId>com.ctp.seam</groupId>
     <artifactId>seam-jpa2</artifactId>
    <version>1.0.0</version>
</dependency>

You’re now ready to code JPA 2 queries! We’ve already included the meta model generator utility, so let’s activate it for the build:


<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>build-helper-maven-plugin</artifactId>
    <executions>
        <execution>
            <id>add-source</id>
            <phase>validate</phase>
            <goals>
                <goal>add-source</goal>
            </goals>
            <configuration>
                <sources>
                    <source>${basedir}/src/main/hot</source>
                    <source>${basedir}/target/metamodel</source>
                </sources>
            </configuration>
        </execution>
    </executions>
</plugin>
<plugin>
    <groupId>org.bsc.maven</groupId>
    <artifactId>maven-processor-plugin</artifactId>
    <version>1.3.1</version>
    <executions>
        <execution>
            <id>process</id>
            <goals>
                <goal>process</goal>
            </goals>
            <phase>generate-sources</phase>
            <configuration>
                <outputDirectory>${basedir}/target/metamodel</outputDirectory>
                <processors>
                    <processor>
                        org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor
                    </processor>
                </processors>
            </configuration>
        </execution>
    </executions>
</plugin>

In order to use the processor plugin, you also need the following Maven repositories in your POM:


<pluginRepository>
    <id>annotation-processing-repository</id>
    <name>Annotation Processing Repository</name>
    <url>http://maven-annotation-plugin.googlecode.com/svn/trunk/mavenrepo</url>
</pluginRepository>
<pluginRepository>
    <id>jfrog-repository</id>
    <name>JFrog Releases Repository</name>
    <url>http://repo.jfrog.org/artifactory/plugins-releases</url>
</pluginRepository>

Run the build, update the project config to include the new source folder - and finally we’re ready for some sample code:


@Name("userDao")
@AutoCreate
public class UserDao {

    @In
    private EntityManager entityManager;
    
    private ParameterExpression<String> param;
    private CriteriaQuery<User> query;
    
    @Create
    public void init() {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        query = cb.createQuery(User.class);
        param = cb.parameter(String.class);
        Root<User> user = query.from(User.class);
        query.select(user)
             .where(cb.equal(user.get(User_.username), param));
    }

    public User lookupUser(String username) {
        return entityManager.createQuery(query)
                .setParameter(param, username)
                .getSingleResult();
    }
}

This is now quite close to Java EE 6 code - all we will have to do is exchange some annotations:


@Stateful
public class UserDao {

    @PersistenceContext
    private EntityManager entityManager; ...

    @Inject
    public void init() { ...
}

Enjoy!

Test drive with Arquillian and CDI (Part 1)

2010-07-13T14:19:00.000+02:00

Here at Cambridge Technology Partners we are as serious about testing as we are about cutting-edge technologies like CDI. Last time we wrote about testing EJBs on embedded Glassfish and now we are back with something even more powerful, so keep on reading!

Background

Recently I was involved in a project based on JBoss Seam where we used Unitils for testing business logic and JPA. I really like this library, mainly because of the following aspects:

Provides easy configuration and seamless integration of JPA (also a little bit of DI).
Greatly simplifies management of the test data. All you need to do in order to seed your database with prepared data is providing a xml dataset (in a DBUnit flat xml format) and then add @DataSet annotation on the test class or method.

Unitils library is definitely an interesting topic for another blog entry, but since we are going to dive into the Java EE 6 testing those of you who are not patient enough for next blog entry can jump directly to the tutorial site. I'm sure you will like it.

The only thing in Unitils which I'm not really comfortable with, is the fact that this library is not really designed for integration testing. The example which is clearly demonstrating it is an observer for Seam events. In this particular case we might need to leave unit testing world (mocks, spies and other test doubles) and develop real integration tests. The SeamTest module together with JBoss Embedded could help but it's really a tough task to make it running with Maven. On the other hand JBoss AS wasn't the target environment for us. Thankfully there is a new kid on the block from JBoss called Arquillian. In the next part of this post I will try to summarize my hands-on experience with this very promissing integration testing library. But first things first, let's look briefly at CDI events.

CDI Events

We are going to have JEE6 workshops for our customers and I was extremely happy when my colleagues asked me to play around with Arquillian and prepare some integration tests. I picked up a piece of logic responsible for logging market transactions based on CDI events. In brief it is a design technique which provides components interaction without any compilation-time dependencies. It's similar to the observer pattern but in case of CDI events, producers and observers are entirely decoupled from each other. If following example won't give you a clear explanation of the concept please refer to this well written blog post. Let's take a look at quite simplified code example.

import javax.ejb.Stateless;
import javax.enterprise.event.Event;
import javax.inject.Inject;

@Stateless
public class TradeService {

  @Inject @Buy
  private Event<ShareEvent> buyEvent;

  public void buy(User user, Share share, Integer amount) {
    user.addShares(share, amount);
    ShareEvent shareEvent = new ShareEvent(share, user, amount);
    buyEvent.fire(shareEvent);
  }

  ...

}


import javax.enterprise.event.Observes;
import javax.inject.Inject;
import javax.inject.Singleton;

@Singleton
public class TradeTransactionObserver implements Serializable {

  ...

  @Inject
  TradeTransactionDao tradeTransactionDao;

  public void shareBought(@Observes @Buy ShareEvent event) {
    TradeTransaction tradeTransaction = new TradeTransaction(event.getUser(), event.getShare(), event.getAmount(), TransactionType.BUY);
    tradeTransactionDao.save(tradeTransaction);
  }

  ...

}

To preserve the clear picture I'm not going to include Share, TradeTransaction, User and ShareEvent classes. What is worth to mention however is that the instance of ShareEvent contains user, a share which he bought and amount. In the User entity we store a map of shares together with amount using new @ElementCollection annotation introduced in JPA 2.0. It allows to use entity classes as keys in the map.

@ElementCollection
@CollectionTable(name="USER_SHARES")
@Column(name="AMOUNT")
@MapKeyJoinColumn(name="SHARE_ID")
private Map<Share, Integer> shares = new HashMap<Share, Integer>();

Then in the TradeTransaction entity we simply store this information and additionally date and TransactionType. Complete code example could be downloaded from our google code page - see Resources section at the bottom of the post.

The very first test

We will use a following scenario for our test example (written in the BDD manner):

given user choose a CTP share,
when he buys it,
then market transaction should be logged.

So the test method could look as follows:

@Test
public void shouldLogTradeTransactionAfterBuyingShare() {
  // given
  User user = em.find(User.class, 1L);
  Share share = shareDao.getByKey("CTP");
  int amount = 1;

  // when
  tradeService.buy(user, share, amount);

  // then
  List<TradeTransaction> transactions = tradeTransactionDao.getTransactions(user);
  assertThat(transactions).hasSize(1);
}

In the ideal world we could simply run this test in our favourite IDE or a build tool without writing a lot of plumbing code or dirty hacks to set up the environment like Glassfish, JBoss AS or Tomcat. And here's when Arquillian comes to play. The main goal of this project is to provide a convenient way for developers to run tests either in embedded or remote containers. It's still in alpha version but amount of already supported containers is really impressive. It opens the door to world of easy and pleasant to write integration tests. There are only two things required in order to make our tests "arquillian infected":

Set @RunWith(Arquillian.class) annotation for you test class (or extend Arquillian base class if you are a TestNG guy).
Prepare a deployment package using ShrinkWrap API in a method marked by the @Deployment annotation.

@Deployment
public static Archive<?> createDeploymentPackage() {
  return ShrinkWrap.create("test.jar", JavaArchive.class)
                   .addPackages(false, Share.class.getPackage(),
                                ShareEvent.class.getPackage(),
                                TradeTransactionDao.class.getPackage())
                   .addClass(TradeService.class)
                   .addManifestResource(new ByteArrayAsset("<beans/>".getBytes()), ArchivePaths.create("beans.xml"))
                   .addManifestResource("inmemory-test-persistence.xml", ArchivePaths.create("persistence.xml"));
}

Odds and ends

Until now I guess everything was rather easy to grasp. Unfortunately while playing with tests I encountered a few shortcomings but found the solutions which I hope make this post valuable for readers. Otherwise you could simply jump to the user guide and code examples, don't you?

JAR hell

The most time consuming issue were the dependencies conflicts better known as JAR hell. The target environment for the workshop application is Glassfish v3 so I used the embedded version for my integration tests. I decided to have my tests as integral part of the project and here problems began.

The main problem is that you cannot use javaee-api because you will get exceptions while bootstrapping the container more or less similar to : java.lang.ClassFormatError: Absent Code attribute in method that is not native or abstract in class file javax/validation/constraints/Pattern$Flag (related thread on JBoss forum). I also recommend not to download separated jars for each project which you are using because you will get even more exceptions :)

Important remark here: if you are using JPA 2.0 with Criteria API and a hibernate-jpamodelgen module for generating metamodel classes then you should also exclude org.hibernate.javax.persistence:hibernate-jpa-2.0-api dependency to avoid yet another class conflict.

You have basically two options:

Use glassfish-embedded-all jar since it already contains all needed APIs.
Create a separated project for integration testing and forget about everything what I mentioned in this section.

Preparing a database for testing

Next step is to create a data source for the Glassfish instance. But first we need to tell Arquillian to not delete the Glassfish server folder after each deployment / test execution (which is the default behaviour). All you need to do is to create a arquillian.xml file and add following configuration:

<arquillian xmlns="http://jboss.com/arquillian"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:glassfish="urn:arq:org.jboss.arquillian.glassfish.embedded30">
  <glassfish:container>
    <glassfish:bindPort>9090</glassfish:bindPort>
    <glassfish:instanceRoot>src/test/glassfish-embedded30</glassfish:instanceRoot>
    <glassfish:autoDelete>false</glassfish:autoDelete>
  </glassfish:container>
</arquillian>

Then we need to take a domain.xml file from our normal Glassfish instance (i.e. from ${glassfish_home}/glassfish/domains/domain1/config), remove all <applications> and <system-applications> nodes, add new data source and copy it to the src/test/glassfish-embedded-30/config folder. We will use HSQL 1.8.0.7 version in our tests (2.0 version is causing some problems with DBUnit).

<domain log-root="${com.sun.aas.instanceRoot}/logs" application-root="${com.sun.aas.instanceRoot}/applications" version="22">
  <system-applications />
  <applications />
  <resources>
    ...
    <jdbc-connection-pool res-type="java.sql.Driver" description="In memory HSQLDB instance" name="arquilliandemo" driver-classname="org.hsqldb.jdbcDriver">
      <property name="URL" value="jdbc:hsqldb:mem:arquilliandemomem" />
      <property name="user" value="sa" />
      <property name="password" value="" />
    </jdbc-connection-pool>
    <jdbc-resource pool-name="arquilliandemo" jndi-name="arquilliandemo-ds" />
  </resources>
  <servers>
    <server name="server" config-ref="server-config">
      ...
      <resource-ref ref="arquilliandemo-ds" />
    </server>
  </servers>
  <configs>
    ...
  </configs>
</domain>

The last file which you need to take from ${glassfish_home}/glassfish/domains/domain1/config folder is server.policy. And that's it! You have running Glassfish with HSQL database ready for some serious testing.

Data preparation

As I mentioned in the introductory section I really like Unitils and the way how you can seed the database with the test data. The only thing to do is to provide an XML file in flat dbunit format like this one:

<dataset>
  <user id="1" firstname="John" lastname="Smith" username="username" password="password" />
  <share id="1" key="CTP" price="18.00" />
</dataset>

and then put the @DataSet("test-data.xml") annotation either on the test method or a class.

I was really missing this feature so I decided to implement it myself. Very cool way of adding such behaviour is by using a JUnit rule. This mechanism, similar to interceptors, has been available since 4.7 release. I choose to extend the TestWatchman class since it provides methods to hook around test invocation. You can see the rule's logic based on the DBUnit flat xml data for seeding database in the example project. All you need to do is to create a public field in your test class and decorate it with @Rule annotation. Here's the complete test class.

@RunWith(Arquillian.class)
public class TradeServiceTest {

  @Deployment
  public static Archive<?> createDeploymentPackage() {
    return ShrinkWrap.create("test.jar", JavaArchive.class)
                     .addPackages(false, Share.class.getPackage(),
                                  ShareEvent.class.getPackage(),
                                  TradeTransactionDao.class.getPackage())
                     .addClass(TradeService.class)
                     .addManifestResource(new ByteArrayAsset("<beans />".getBytes()), ArchivePaths.create("beans.xml"))
                     .addManifestResource("inmemory-test-persistence.xml", ArchivePaths.create("persistence.xml"));
  }

  @Rule
  public DataHandlingRule dataHandlingRule = new DataHandlingRule();

  @PersistenceContext
  EntityManager em;

  @Inject
  ShareDao shareDao;

  @Inject
  TradeTransactionDao tradeTransactionDao;

  @Inject
  TradeService tradeService;

  @Test
  @PrepareData("datasets/shares.xml")
  public void shouldLogTradeTransactionAfterBuyingShare() {
    // given
    User user = em.find(User.class, 1L);
    Share share = shareDao.getByKey("CTP");
    int amount = 1;

    // when
    tradeService.buy(user, share, amount);

    // then
    List<TradeTransaction> transactions = tradeTransactionDao.getTransactions(user);
    assertThat(transactions).hasSize(1);
  }

}

I must admit that it's a JUnit specific solution, but you can always implement your own @BeforeTest and @AfterTest methods to achieve the same result in TestNG.

DBUnit gotchas

Using DBUnit's CLEAN_INSERT strategy (or deleting table content after test execution by using DELETE_ALL) could raise constraint violation exceptions. HSQL provides special SQL statement for this purpose and the sample project is invoking this statement just before DBUnit.

Final thoughts

All in all Arquillian is a really great integration testing tool with full of potential. It's just great that the JBoss guys are aiming to provide support for almost all widely used application servers and web containers. As you could see from the examples above it's not that hard to have tests for more sophisticated scenarios than you can find in the user guide. Keep your eyes on Arquillian - the roadmap is really promising.
In the upcoming second part I will dive into CDI contexts and demonstrate how to use Arquillian for testing contextual components.
If you are writing an application for the Java EE 6 stack while not using Arquillian is a serious mistake!

Resources

Full code example with all aspects mentioned in the article (svn or zip)
Fest-Assert - offers convenient assertions following fluent interface pattern (assertThat()).
JUnit Rules on InfoQ
Unitils

JSF composite component

2010-06-24T14:42:00.018+02:00

On my latest project we used RichFaces as a component library. Our client didn't like to fill out the time with the RichFaces calendar. They wanted two combo boxes to fill out the time. I don't think this is the most user friendly way to solve picking a time (I like this timepicker) but our customer is king.

I thought that there would be someone on the internet who already created a component like that, but I could not find any so I made my own. JSF 2 will introduce a new component creation method. It will be simpler to create components and you do not have to write java code to make them work. But until we have JSF 2 available on all major application servers we will have to program some java for our components to work.

The plan I had for creating it was simple enough just take two HtmlSelectOneMenu components and fill them with default options.

So I ended with something like this:


private void createChildComponents(FacesContext context) {
    Application application = context.getApplication();
    hourInput = (HtmlSelectOneMenu) application.createComponent(HtmlSelectOneMenu.COMPONENT_TYPE);
    minuteInput = (HtmlSelectOneMenu) application.createComponent(HtmlSelectOneMenu.COMPONENT_TYPE);
    List<UIComponent> children = getChildren();
    children.add(hourInput);
    HtmlOutputText sparator = (HtmlOutputText) application.createComponent(HtmlOutputText.COMPONENT_TYPE);
    sparator.setValue(":");
    children.add(sparator);
    children.add(minuteInput);

    UISelectItems hourItems = createSelectItems(application, 24, 1);
    hourInput.getChildren().add(hourItems);

    UISelectItems minuteItems = createSelectItems(application, 60, 5);
    minuteInput.getChildren().add(minuteItems);
    delegateProperties();
}

private UISelectItems createSelectItems(Application application, int number, int step) throws FacesException {
    UISelectItems selectItems = (UISelectItems) application.createComponent(UISelectItems.COMPONENT_TYPE);
    List<SelectItem> items = new ArrayList<SelectItem>();
    for (int i = 0; i < number; i += step) {
        items.add(new SelectItem(StringUtils.leftPad(String.valueOf(i), 2, "0")));
    }
    selectItems.setValue(items);
    return selectItems;
}

Rendering this was not hard but to extract the selected value and store the submitted value back into the value binding, that was not so easy. First I tried to override the validate method but that didn't "sound" right, doing it in the updateModel was much better.

The only weird thing I was still facing was that, sometimes the value from the hour and minute components were converted to Integer but sometimes they where not. So I ended up with this construction to ensure that they were always Integer.


    @Override
    public void updateModel(FacesContext context) {
        super.updateModel(context);

        hourInput.validate(context);
        minuteInput.validate(context);

        ValueExpression valueExpression = getValueExpression("value");
        Date value = (Date) valueExpression.getValue(context.getELContext());
        if (value != null && hourInput.getValue() != null 
         && minuteInput.getValue() != null) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(value);
            Integer hour = Integer.valueOf(hourInput.getValue().toString());
            calendar.set(Calendar.HOUR_OF_DAY, hour);
            Integer minute = Integer.valueOf((minuteInput.getValue().toString()));
            calendar.set(Calendar.MINUTE, minute);

            valueExpression.setValue(context.getELContext(), calendar.getTime());
        }
    }

Here I'm using the Java Date API. That of course is extremely sadistic so we could change it to use joda-time.

Now to use it we first register it as a component in components.taglib.xml


<facelet-taglib>
<namespace>http://ctp-consulting.com/components</namespace>
<!--
  usage: <ctp:timepicker value="date"/>
 -->
<tag>
   <tag-name>timepicker</tag-name>
   <component>
      <component-type>com.ctp.web.components.Timepicker</component-type>
   </component>
</tag>

Then make sure you have the components.taglib.xml registered in you're web.xml


<context-param>
 <param-name>facelets.LIBRARIES</param-name>
 <param-value>/WEB-INF/tags/components.taglib.xml;</param-value>
</context-param>

And here an example of use, fist add the namespace on the top of you're page:


 xmlns:ctp="http://ctp-consulting.com/components"

Then in our page you can do something like:


 <ctp:timepicker value="#{catering.deliveryTime}"/>

Maybe this is not the best solution, if you have comments or tips, feel free drop them directly on this post. I'm interested in what you have to say!

Jazoon 2010

2010-06-05T10:49:00.000+02:00

As a Java developer you'll need to stay on-top of what is new and noteworthy. A great way to do this is to go to a conference, because this is an interactive way to learn about new stuff. Together with Douglas, I was attending Jazoon, an international conference held in Zurich, it is my first time here. Like Devoxx it's also held in a movie theater. Although Jazoon is also an international conference there are of course a lot of Swiss here and it's a little smaller. But that just means I have more change to win an iPad :D (didn't happen, too bad).

After the keynote the first presentation I attend is about REST. Stefan Tilkov is the presenter and he does a nice job bashing web frameworks like JSF that do not do REST at all. He has a point, the web is about URI (Unified Resource Indicator) and a document should be identified with that. That has always been the way of the web. And "modern" web application frameworks have a tendency not to change the URI for every resource and use only one HTTP method (e.g. POST) instead of all 7 of them. Stefan calls this abusing the web, or even desktop applications in disguise. I must agree to what he has to say about a lot of things. Search engines like Google work because of this and even if we are writing applications that are used inside intranets they are still web applications and they should be able to work accordingly. I'll need to investigate what people developing JSF thoughts are about this.

Next up Blueprint by Costin Leau, he works for SpringSource. I personally have not used Spring since they were hesitant to adopt annotations and was rather using JBoss Seam ever since. But as we have customers interested in doing something with OSGi it will be interesting to see how they eased the way to develop something for OSGi. When I heard about Spring the first time, I was amazed and wondered why I didn't think of that. Now I have the same feeling with OSGi, it can be a lot simpler when you use IoC in combination with it. Blueprint is only a spec and there are 2 implementations. I really need to take a look at it because it looks really helpful.

On Thursday we had a nice Java roundtable to discuss all the news.
Erik was all excited! :D

On day 2 the keynote is from Ken Schwaber he is one of the founders of SCRUM. In his presentation he made the point that a lot of people who think they are doing scrum are actually not: Because they don't finish their user stories. This is due to the fact that we don't include enough when we say it's done. When is a user story done? When user acceptance testing has taken place? Load test integration test and refactoring? When things like these are kept to the very end of the project a lot of work still remains to be done when the project should have been finished. According to Ken this work will be exponentially more then when you do it after each sprint. All in all it was quite a mood breaker because Ken tried to emphasize that a lot of software projects still fail and that we should be professional and fix that by changing what we call done.

Peter Lubers (he must be Dutch :D ) had a talk about HTML 5 Websockets. I've heard about a couple of things that are going to be in the HTML 5 spec but I did not know about this! And this is very exiting: there are a lot of projects that have tried to solve the problem how to push data to a web browser client. All of the implementations are not ideal. There are a couple of polling solutions, but the overhead that you get when making a request, on average, is about 800k. That does not look like much but if you want to scale your applications it is a lot. The way Websockets work is to "upgrade" your standard HTTP connection to a socket where you can then send and receive data over. He showed a working example of this with Google Chrome the only browser that supports this right now- At the end of the presentation he said he talked to one of the technical guys from Microsoft and he has a strong feeling it will not be in IE9, how nice is that (the IE6 story all over).

The two talks I went to after lunch were both about alternative languages on the JVM namely Groovy and Scala. And they we're both about Distributed Computing. I thought it was really exciting, all we need now is a customer with a large set of data and a need to compute something with. That is the only problem with distributed computing and with cloud computing even more so, it needs lot of data to work with. Otherwise there is no need to use it. This is even more true when you already use web applications. They scale very easy because they use the request response model. Every request could be handled by a separate thread or instance in a cluster. So interesting things are happening here and a lot of development is going into solutions based on distributed computing and cloud computing.

Douglas and Daniel trying to get more infos about Web Sockets...
Well...isn't that a game on that iPad?

Last Day

On the last day of the conference the keynote was about Gaia the satellite that is going to map a lot of stars in our milky way. It was interesting to see that they use Java to analyse the huge amount of data. And that there are still debates about Java being fast enough. Come on people it's 2010 Java is blazing fast!!

The whole last day was more or less about testing. There were a lot of talks in this area and only one that I would like to mention here. There was a way to short talk about Arquillian. I don't think that the presenters wanted to have a small slot but I guess they we're forced to use a small one. Arquillian is a cool way to test EJBs inside the container. The project is brand new and they still need to add support for a couple of containers. But it's looking really promising. I got a cool shirt at their presentation so I'll definitely keep an eye on this project :-).

Thoughts

All in all Jazoon was great to see and to be at. But if I would have to choose between Jazoon or Devoxx I'd rather go for Devoxx. The idea I get is that Jazoon is younger than Devoxx and still has to proof itself as important and unique besides Devoxx. Of course Jazoon is better organized, everybody knows that people from Belgium are chaotic ( :D sorry guys), but that is not enough of course. At Jazoon I don't get yet the atmosphere you get from a Devoxx, this hold true for the size and quality of speakers too.

But I do have a lot of new things I have to look at! So all in all it was a positive experience. I hope Jazoon gets more popularity so it will attract more people from around the world.

JavaOne 2010 and Oracle OpenWorld 2010

2010-05-20T21:22:00.002+02:00

... or "Oracle acquired the city of San Francisco":
This year is the first year of JavaOne under the umbrella of Oracle and it takes place in the same city and the same week as Oracle OpenWorld: September 19th - 23rd in San Francisco.

You may ask how Oracle can host two conferences of that size at the same time in the same city: Moscone Center (for me the home of JavaOne) is now the home of Oracle OpenWorld whereas JavaOne has been relocated to the so called "The Zone" consisting of three large hotels, all near Union Square (see red markers in the following map):

View JavaOne 2010 in a larger map

Registration is open for both conferences and both do offer a discount at this moment when registering within the next few weeks.

If you go to JavaOne for the first time you might want to compare it with last year's conference where it was hosted by Sun Microsystems for the last time:

We (the CTP Java Competence Group) are very curious how both conferences will present themselves in this new Java era led by Oracle.

Java People Spotlight: Erik Jan de Wit

2010-04-29T09:00:00.054+02:00

After a rather long break, we are back with interesting articles in the pipeline, one of them released yesterday containing a nice video tutorial!

So today we want to present a rather new member in the CTP Java gang: Erik Jan de Wit, dutch Java power at its best!
Erik has joined Cambridge Technology Partners in February 2009. His technical excellence and social skills are true assets for our projects as well as for our Java oriented internal activities. Not without reasons, "@EJD" became an alias among CTP Java dudes to shortcut the fact that Erik will get "injected" and involved on projects, tasks...:-)
So let's check out the answers by Erik then!

Java Competence Role:
Senior Developer [aka Singing Scrum Master]
My Master Kung-Fu Skills:
Intergate new technology into existing projects fast
I'd be excited to get my hands dirty on:
Scala, ESB, JavaFX, Cloud-Computing and the new EJD... sorry EJB Criteria... well it's anyway JPA Criteria API :-)

Q&A
Q: Hi Erik, how would your message look like if you would have to tell it via Twitter what you are currently doing?
A: Be a great Scrum master on this time challenged project

Q: What was the greatest piece of code you have ever written so far?
A: A screen scraper that enabled to integrate an external site into another site while changing all links back to our site including form actions.
Q: Really? I'm sure dutch scrum masters did something more fancy on projects than this....:-)
A: Well yeah, you're right: So on my kenai.com account I published an open-source framework which is basically a reverse regular expression generator that is used in the testdata project to generate test data that adheres to a specific regular expression. The testdata framework inspects your domain model and creates data for your domain. So if you use hibernate validator or bean validation annotations in your domain it will use the regular expression on the field to generate data that is valid. So that's what I used later on projects.
Q: Awesome!
A: And!! ... there is also a Scala version of it, based on the StandardTokenParsers
Q: Now we're talking :-)

Q: What is the best quote you have ever heard about programming?
A: All my peers are trying to talk dutch... very nice!

Q: What is the best quote you have heard from our managers?
A: I had to review Java code written in Turkish and my manager said: "It is still Java, it is not Rocket Science!"

Q: What is the most cutting-edge technology or framework you actually used on projects?
A: jBPM, Seam, JSF and Java EE6

Q: What is your favorite podcast?
A: I really love the Java Posse, I listen to it all the time... another that I like which is actually non-Java related is Best of Youtube VideoCast.

Q: Which Java book can you recommend and for what reason?
A: It seems that always the latest book I've read is the best one, in this case it's "Clean Code" from "Uncle Bob"

You can further visit Erik at his Google Profile or on linkedin.

JBoss Seam Maven Archetype Video Tutorial

2010-04-28T16:19:00.008+02:00

While the release of Seam 3 is getting closer, you might still want to do quick prototyping based on a Seam 2 project. Of course this is easiest done with either seam-gen, or if you're like me a Maven user, with an Archetype.

Chris has prepared a video tutorial on how to get started with our Maven WAR archetype (featuring hot deploy, TestNG with embedded JBoss and either RichFaces or ICEFaces inclusion) based on one of my previous articles. Check it out here (best seen in HD [UPDATE: sorry, missed the HD embed]):

Enjoy!

Java People Spotlight: Sylvain Berthouzoz

2009-11-20T13:33:00.002+01:00

The "People Spotlight" series is catching up after a rather long break...
Sylvain has joined Cambridge Technology Partners in January 2006 and is an important know-how carrier in the Java Competence Group since then.
So let's check out the answers by Sylvain then!

Java Competence Role:
Developer [aka Java Debugger or Mr. jBPM]
My Master Kung-Fu Skills:
I can hit everyone with a single process in jBPM
I'd be excited to get my hands dirty on:
JPA2: see how they included the Criteria query...
...and to see what Ezio Audirore da Firenze will do.

Q&A
Q: Hi Sylvain, how would your message look like if you would have to tell it via Twitter what you are currently doing?
A: Sitting in the train in hoping that the locomotive don’t break this time.

Q: What was the greatest piece of code you have ever written so far?
A: Testing if all the elements in a list are different from each other:

List< Long > list = Arrays.asList(longs);
Set< Long > set = new HashSet< Long >(list);
return (longs.length == set.size());

Q: What is the best quote you have ever heard about programming?
A: “koffienodig”

Q: What is the best quote you have heard from our managers?
A: "There is not enough boxes here."

Q: What is the most cutting-edge technology or framework you actually used on projects?
A: JBoss Seam

Q: What is your favorite podcast?
A: The gameblog podcast every week. And the Java Posse from time to time.

Q: Which Java book can you recommend and for what reason?
A: Seam in Action, because it is a great book to start with seam and you’ll also learn how to play golf.

Devoxx day 4/5

2009-11-20T10:43:00.003+01:00

Day 4 was really great we had some very good keynote sessions. Ivar Jacobson is the father of components and UML. In his presentation he told us about the work he is doing to standardise the methodologies. Now a lot of companies make their own flavour of a methodology or create an entirely new one but "steal" from others. He want to create reuse so that people don't have to relearn the entire thing but just have to learn the new parts. It's food for thought, that is for sure and if it works out we'll have to wait and see.

After that, another great keynote from Robert Martin a.k.a Uncle Bob he is the founder of fitnesse and very focused on TDD (Test driven development). His talk was about "Filling The Professionalism Gap" by being Craftsmen. What it comes down to, is to make more IT projects succeed, developers must see themselves more as craftsmen. That means that developers should have a more "ethic" approach in delivering things and only create software that is clean tested and that really works. This is what we already do at CTP but I think a lot of developers can learn from this.

There were also some big announcements made at this Devoxx:

Closures are in JDK7
More new components in JavaFx 1.3

Big stuff and cool to hear that closures are going to make it in JDK7, that is a huge thing.

Also I had some fun of this day at devoxx, I went to the presentation of the JavaPosse. And when you hear the recording you can probably hear me shout: "Switzerland" :-). Of course they had their beer sponsor Atlassian so we had some nice Belgium beer (Duvel). A cool side effect of conferences is the fact that they are normally hosted inside a movie theatre: So at Devoxx they showed the new movie '2012', a very nice movie with lots of effects.

And then it is already the last day and I didn't notice this before, but it's only half a day. So I had some good sessions today one from Andy Wilkinson about Modular Web Applications with OSGi. He uses Spring DM (that's an application server, but not a Java EE certified one) to be able to split his web application vertically and/or horizontally in different OSGi bundles. That could be really good to manage big applications. Also he had some news, they are working on a version that does not require Spring DM, so that is definitely something we must keep an eye on.

That is it from Antwerp, Devoxx 2009!
So let's see what will happen with all the announcements made here in the next year...

Devoxx Day 3

2009-11-18T10:36:00.014+01:00

The network at devoxx is letting me down a bit, so this post is a little bit late. This day is the first conference day, the university days are over. That means that there are a lot more people here than yesterday. Oracle (Steven Harris) had a long keynote talk in which interesting upcoming details have been presented with what is coming with future WebLogic releases. What they demo-ed was kinda cool. A modular WebLogic based on OSGi (often referred as mSA aka Micro Service Architecture) that you can assemble using a GUI tool. That you can also run in a virtual machine without adding an OS.

Next keynote was presented by Roberto Chinnici from SUN, he is the spec lead for JavaEE6 and gave a quick overview what is new in EE6. As I already had a 2 hours talk about that topic during the university days there was nothing new to me but all in all it well covered all aspects for people hearing about it for the first time. One of the cool things in Java EE 6 I like most is the modularity of the web.xml being part of the Servlet 3.0 spec. Using 3rd party frameworks only requires to add a library, instead of also adding a servlet or servlet filter in your web.xml.

Also announced in the keynote is that everything presented at Devoxx is going to be released on parleys.com (currently upgraded to version 3!! ). That is great as all the presentations I've visited can be watched again including comments by other visitors etc.

During the break I ran into a lot of people I know from previous companies I worked for. It is always nice to hear what they are doing now and what other sessions they have seen and to tell them if they ever want to work for a nice company in Switzerland, I would know a good one :D

Now an update on where JDK7 is right now by Mark Reinhold. Great talk about what is important and where the focus for making Java move forward is going to lay. Talking about Project Jigsaw this is the first time ever I have seen some implementation how this could/would work. The shame is that there is no JSR for Java SE 7 so all development will not progress as long as this is the case. What was very surprising is that Mark wants Closures in, but in a very simple form, but that is great news for a lot of things Closures will make my code look nice.

In the keynote Apple gets a lot of criticism about being slow accepting apps in the store and the kind of feedback Apple provides when apps are disallowed.

Lunch break: Bumping into a lot of people again that I know; Talking to someone from JBoss about their community, now I have a nice CD to give away.

James Gosling is talking about the Java Store and I hope he is going to tell us that we here in Europe can use it now. So he is talking that we should provide him with feedback on the stuff they made, but as of now the Java Store is still not accessible for us. That makes his whole talk a bit pointless. Yes, I would love to have a platform I can sell my hobby projects with, but no need to tell me about how great it is when I still can't use it. There are a couple of countries being added in the near future, but Switzerland is not one of them.

Cameron Purdy tells us how we should change our programming paradigms if we want to use multi core, multi node programs. So the answer to all our problems is to use partitioning? I'm a bit puzzled how I could use this. I think this presentation could have been a bit more concrete. He presents all theoretical ways to do parallel distributed computing. At the very end I know why everything was so vague, if you want an implementation of all of what he talked about than you'll need to buy Coherence a bit of an anticlimax.

Doug Tidwell will now tell us a little about how to extract a way from implementations of cloud computing. He is from IBM an I hope this is not another product plug and it turns out that it's not, he is funny and a good speaker. What he is trying to tell us is that we need a standard for doing cloud computing, an API to talk to different clouds. The problem is that the services that clouds provide now are so diverse that one API to rule them all makes no sense. That is a bit what I miss, nobody is talking about how using a cloud will impact my design.

Then one of the creators of the Android platform Romain Guy will talk about animation. Romain Guy is really famous in the Java world so his presentation will be good. It's about animating GUI using the cartoon rules. There are some basic cartoon rules for doing animation he shows us how they apply to GUI animation.

Devoxx day 2

2009-11-17T11:28:00.017+01:00

Today it is day two at Devoxx. What I didn't put in my last post is the BOF I went to last night. BOFs here are great - there are only a couple of people in the room, it is really different than at JavaOne where there are a lot more people. So yesterday I had a BOF with the JSF spec leads (well the 3 key persons: Dan Allen, Peter Muir and Andy Schwartz) and we could in a very relaxed setting ask them some questions about the JSF 2 spec. So we could find out how and why they made some decisions. The question I asked them: "Why is JSF 2 not more focused on components so that I can mix and match components of 3rd party providers?". The answer was that they are looking into that and that a lot of problems one has with that right now is how resources are loaded: all 3rd parties made something on their own. So now all the AJAX stuff needs to be gathered and then they will look into that. Good answer, I'm glad that they are aware of what lives in the community.

My first session of today is a session about JEE6. They are talking about and demo-ing everything that is new in the spec. Antonio Goncalves a French Java Rockstar has a lot of humor and a nice presenting style. JSF 2.0 is kind of confusing, because it could run on servlet 2.5 but also on 3.0 but then less needs to be configured. Yesterday the expert group also talked about this that they communicate better what is now the "preferred" way of doing things. This is difficult when you make a spec. You can't remove things, because it needs to be backwards compatible. This is also the case for EJB3 - there is now a EJB3.1 lite edition where all old stuff is removed. According to them there are some containers being built that only support this spec.

JavaFX is what my next talk is about. This is hyped a lot by Sun and now with the takeover by Oracle also Oracle will continue with JavaFX. The last changes around JavaFX involved a lot of tooling at this year's JavaOne. Tor Norbye presented a tool for designers that they can layout an application for mobile and desktop. Stephen Chin also a Java Champion starts with a nice little JavaFX Puzzle. For his demo he is using twitter but that was a bit of a poor choice, because with the Devoxx network, reaching twitter proves a bit of a challenge. So most of the time we are waiting for some internet resource to load. So I'm changing again, I already know the basics about JavaFX and I was hoping this would be a little bit more deep dive. Emmanuel Bernard is also a guru of the Hibernate team and here at Devoxx he is talking about integrating Lucene into Hibernate as an alternative query API. So the bridge they have built for Hibernate is really cool. In the past we did this on ourselves, have a Lucene index to search on and then load entities when needed. But with the Hibernate search query API we can do it "automatically".

During the lunch I talked to Ceki Gülcü who is also from Switzerland and giving a talk about logback, the continuation of the dead log4j project, tomorrow. He would make a nice speaker on the JUGS.

Now it's time for tools in action again, first up is Gradle. Hans Dockter is the project lead and he gives an introduction about Gradle. Gradle is a build tool that uses CoC and has a DSL to configure your build. Yet another build tool, but this time is using groovy DSL to make a build file. I also blogged that Maven3 is also going to provide this. I don't know what Hans is trying to explain to me or how this is better than Maven3, but he is a bit chaotic. After a while there is a new speaker that is even worse. I think there are some good options in Gradle, but these are not the guys to explain it to me. One thing I did get from the presentation that you could fork your test over more threads, which is cool.

Next up is Scala Actors that will be a good one. You all know of course that Scala is a language on top of the JVM and developed in Switzerland. Because computers are getting more and more processors, functional languages like Scala could be very useful for this, because they are stateless and you don't need to think about how to distribute the work. After a little history lesson, Frank Sommers gave us a concrete example of how Actors can be used in Scala. It's great, a lot of stuff you get for free. Of course the concept of Actors is not bound to Scala, but there are things that Scala offers that make Scala a good language to use with Actors. For instance types in Scala are immutable by default. Great talk and when I'm going to type synchronized in code again I must remember this talk.

That is it for day number 2, it was a fun packed day and I look forward to tomorrow. One more thing I noticed today if you want to present on Devoxx you'll need a Mac and IntelliJ IDEA.

Devoxx day 1

2009-11-16T12:38:00.018+01:00

Devoxx is probably the largest European Java Conference. As it always takes place at the end of the year and approximately half a year later than big brother JavaOne, it's a good time to get the stuff again that has been announced at JavaOne and to see how the news and forecasts have been adopted in the meanwhile.

When I think of Belgium I think of beer, bars, chocolate, hospitality and cosiness. But when I arrived and saw my hotel all these feelings went away. The location of my hotel and the conference is in an industrial part of Antwerp. There is nothing here but harbours and sea containers. So there is absolutely nothing distracting me from attending the sessions :D

So my first session of the day was about jBpm 4 and that was very impressive, I've used jBpm in the past together with Seam. I wish that I could use it with my last project. They changed a lot the API making deployment and testing easier. The console is now rewritten in GWT, and there is a web app that business people can use to create and modify processes. Also creating screens for tasks now works!

So with the new version they really focused on working together and fixing the issues with regards to configuration. So I'm definitely trying that out.

Strange thing about this fist day that I haven't seen any companies yet. Maybe they will only setup their stuff when The conference days are starting. OK update on this: they are building up their stuff now.

Another important note... I already have my 2 t-shirts and one of them is a limited edition!

Next up is Architecting Robust Applications for Amazon EC2 , let's see what they have there.

This one was not interesting at all, if I want to know how the webservices of amazon work I'll look it up myself. So I switched to a talk from a SUN guy who is clicking stuff together in Netbeans. What he is talking about is interesting. But his demos don't go further than the wizard screens of Netbeans and he is looking all the time to his webpage.

So after the break it was "Tools in Action" time, these sessions are shorter and focused on tools, hence the name. The first one I saw was about Introducing Scimpi a framework rather than an actual tool, build on Naked Objects, but the concept is a bit old and Scimpi is sort of redefining it. I've used metawidget for similar things but I think this gives me more control over the output than Scimpi and also has more powerful components that I can use.

So now the last one of day one NoSQL with Cassandra and Hadoop. That was a nice introduction and they presented a nice usecase when to throw out the relational database. But I want to know more about it. Let's see if I can find some more talks.

All in all it was a very interesting day and let's see what tomorrow brings.

Portal Update November 2009 and Java Buzz

2009-10-30T16:33:00.011+01:00

After a busy summer I think it is absolutely necessary to summarize the latest updates in the Java Portal space.

From the commercial side, major players are:

Oracle WebLogic Portal:
The current release is still WLP 10g3 but soon we expect the first 11g release with codename "Sunshine".
Major improvements are
- JSR-286 compliance (Portlet 2.0)
- WSRP 2.0 support (Event based coordination, IPC for remote portlets, resource serving)
- Full interoperability with WebCenter in both directions
- Improved Ajax support
- VCR Direct SPI Support for UCM
- Even more REST APIs to access portal informations
- New REST API to access Unified User Profile data
- First support of the new Content Management Standard driven by Oasis: CMIS
- Apache Beehive still supported but not enhanced
- Replacement of Autonomy Search Engine by SES

The REST API Architecture in WLP 11g:
Oracle WebCenter Suite 11g R1:
WebCenter Suite includes the formerly known product AquaLogic Interaction by BEA, now called WCI, WebCenter Interaction. Download it here.
Adobe: Adobe? Yes... Since the new release of Adobe ColdFusion 9, there is a new portal player to be considered when it comes to interoperability based on JSR-168/286 portlets. ColdFusion 9 is now fully compliant with the Portlet Containers from the Java world.
IBM WebSphere Portal 6.1: no updates.

Open Source portals that have the most promising potential at the moment are:

JBoss Portal and eXo Portal have been merged!

This latest interesting announcement has been made official on Sep 3rd at the JBoss World in Chicago. eXo has fully committed its entire open source portal stack to Red Hat’s newly introduced GateIn portal project extending it with cutting-edge collaboration features as well as document and content management features.
Liferay Portal 5.2: no major updates since last post.
SUN continues to offer the Web Space Server based on the Liferay Portal source code. No major updates besides a brand new white paper.

JBoss Portal 2.7.2:
- Since June 2009, JBoss fully focused on the new project GateIn
eXo Portal 2.5.1: no updates besides GateIn announcements
Jetspeed 2.2.0: After quite a long time without updates a new version has been released (summer 2009) that is fully JSR-286 compliant! The new version comes along with quite a bunch of updated documentation pages... So it would be worth to have a look at it again. Download it here.

Besides the Portal related activities, let's have a look on Java related quick news:

Java EE 6: The JSR-316 has reached Proposed Final Draft. The hot discussions between JSR-299 vs JSR-330 have finally found a common resolution and both will be part of EE6 where JSR-299 will be based on the dependency injection specification defined by JSR-330.
Oracle has still not acquired SUN : The OK from EMEA is still pending.
JSF 2.0 : Mojarra 2.0, the production-quality, reference implementation for JSF 2.0 is out! This will of course be part of GlassFish v3 (final release planned for Dec-12th 2009) but you can grab the bits right now for your first dirty hands-on experience!
IntelliJ IDEA is now available in two editions. The Community Edition (JavaSE-focused) is now Available under OpenSource at JetBrains.org
Geek Food: I discovered mainly two new things that I found diserve a Geek award:
- Prezi ! Forget PPT and Google Presentations... Old school!
- Play ! Clean alternative to develop JavaEE apps based on RESTful architectures.
Google Wave: I finally got an account (thanks a lot J. !!) but up to now I'm rather disappointed... nonetheless, the full features are not released yet, so I'm ready to get blown away. If you are interested, I still have some invitations left :-) Start your wave!
JavaOne 2010 : ... no, still no signs whether there will be a next JavaOne :-(

Unit Testing EJBs and JPA with Embeddable GlassFish

2009-10-30T15:04:00.009+01:00

Java EE 6 has been a topic here at CTP for quite a while now. During summer I had the pleasure of conducting an internship which was targeted to explore the possibilities of the upcoming standard, namely EJB 3.1, JPA 2.0, JAX-RS, JSF 2.0 and JCDI on top of GlassFish v3 - and it turned out surprisingly productive, although all implementations were far from being in a release state!

Only one thing we failed to run in a stable way: The new EJB 3.1 container API refused to run our unit tests. The main problem was JPA support - persistence units got not recognized and EJBs usually failed with a NullPointerException calling the EntityManager.

Alexis and Adam recently blogged about this specific feature, and of course I had to get back and try it out myself! Indeed, starting up a container and looking up EJBs works fine. But to test your Entities there are still a few tweaks you might want to apply.

Start with creating a Maven project and add the embeddable GlassFish dependency. I'm also using TestNG instead of JUnit, as it has a nice @BeforeSuite annotation which allows starting the container only once before running your tests.


<dependency>
    <groupId>org.glassfish.extras</groupId>
    <artifactId>glassfish-embedded-all</artifactId>
    <version>3.0-b69</version>
    <scope>provided</scope>
</dependency>

<dependency>
    <groupId>org.testng</groupId>
    <artifactId>testng</artifactId>
    <version>5.9</version>
    <scope>test</scope>
    <classifier>jdk15</classifier>
</dependency>

As described in Alexis' blog, you can start your EJBContainer with a reference to your GlassFish domain. This will allow you to start up data sources you most probably need to properly test your JPA code.

The disadvantage here is that you either depend on a hardcoded location or a system property which each of your team members have to set. Or, in case of your continuous integration system, you might not want to have a GlassFish installation at all.

Fortunately you can create a mini GlassFish domain with only a few files. The image below shows the files you need and how I placed them in my Maven module:

You can take your existing domain.xml containing your data sources and place it in here - you can reference it now relatively to your module location. Your unit tests then start with:


private static Context ctx;
private static EJBContainer container;

@BeforeSuite
public static void createContainer() {
    Map<String, Object> properties = new HashMap<String, Object>();
    properties.put(EJBContainer.MODULES, new File("target/classes");
    properties.put("org.glassfish.ejb.embedded.glassfish.installation.root", 
            "./src/test/glassfish");
    container = EJBContainer.createEJBContainer(properties);
    ctx = container.getContext();
}

This will run your unit tests against your development database. In case you want to run them in a local database, you can simple replace the connection pool config in your domain.xml, e.g. with a local Derby installation:


<jdbc-connection-pool datasource-classname="org.apache.derby.jdbc.EmbeddedDataSource" 
        res-type="javax.sql.DataSource" name="[your DS name]" ping="true">
    <property name="ConnectionAttributes" value="create=true" />
    <property name="DatabaseName" value="./target/unit-test" />
    <property name="Password" value="" />
    <property name="User" value="" />
</jdbc-connection-pool>

This creates the database in your target folder and requires adding Derby to your Maven POM:


<dependency>
    <groupId>org.apache.derby</groupId>
    <artifactId>derby</artifactId>
    <version>10.5.3.0_1</version>
    <scope>test</scope>
</dependency>

Unfortunately this setup might not match with the configuration in your persistence.xml and generate invalid SQL for your test database. You can either solve this with Maven filters in different profiles, or alternatively create a staging directory for your EJBContainer. I'm using the Apache Commons IO tools here for convenience:


...
private static final String MODULE_NAME = "embedded";
private static final String TARGET_DIR = "target/" + MODULE_NAME;

@BeforeSuite
public static void createContainer() throws Exception {
    File target = prepareModuleDirectory();
    Map<String, Object> properties = new HashMap<String, Object>();
    properties.put(EJBContainer.MODULES, target);
    properties.put("org.glassfish.ejb.embedded.glassfish.installation.root", 
            "./src/test/glassfish");
    ...
}

private static File prepareModuleDirectory() throws IOException {
    File result = new File(TARGET_DIR);
    FileUtils.copyDirectory(new File("target/classes"), result);
    FileUtils.copyFile(new File("target/test-classes/META-INF/persistence.xml"), 
            new File(TARGET_DIR + "/META-INF/persistence.xml"));
    return result;
}

You can use the @AfterSuite annotation to clean up the temporary folder. Note that with this setup, the EJB lookups change:


protected <T> T lookupBy(Class<T> type) throws NamingException {
    return (T) ctx.lookup("java:global/" + MODULE_NAME + "/"
            + type.getSimpleName());
}

Oracle WebLogic Server Versions

2009-10-21T18:40:00.003+02:00

I recently got confused with the version numbers of the Oracle WebLogic Application Server, some people use the internal (BEA) version number, some refer to the Oracle release number.

So the following list should clarify the mapping between these two versioning schemes:

WLS 10g3 (10.3.0) : recent version but used by latest WebLogic Portal 10g3
WLS 11g R1 (10.3.1) : current version
WLS 11g R1 PS1 (10.3.2) : upcoming patchset version planned for Nov/Dec 2009
WLS 11g R1 PS2 (10.3.3) : another patchset anticipated March / April 2010
WLS 11g R2 : Planned for 2010. I haven't found any relation to a 10.x version at this moment.
Oracle OpenWorld 2009 Updates: WebLogic Server 11g R2 in 2010 will get Oracle RAC and Coherence integrated to make them native in the application server. WebLogic Server will get RAC event awareness, providing fast connection and fail over, while Coherence will be managed as part of WebLogic - currently it's an external application.
WLS 12g : Planned for 2011. I assume this will be the Java EE 6 compliant release along with the release of all other Fusion Middleware 12g products.

Comments are welcome!

LambdaJ new trends in Java

2009-10-16T09:35:00.015+02:00

I must say I really enjoy the presentations from the JUGS. Couple of days ago there was another one about lambdaj, presented by its author Mario Fusco. He is a big fan of Scala and that's why he wanted to bring this functional way of doing things to Java.

I think this is a trend and we are going to see this more and more. It all started with the dynamic languages built on the JVM and now more and more people want functional things. I guess it has to do with the fact that Java the language did not see much change over the last 8 years, and people see solutions that are nice for specific problems in other languages. For instance Rails, it's very good in solving one particular problem and the Java community did notice that. Not only did it get ported to run on the JVM it also brought us Groovy/Grails.

So the latest thing in Java land is functional programming. There are some things one could solve more "elegantly" by using a language that is functional in nature. An example of this is filtering collections, this is what lambdaj tries to do, making standard Java behave in a more function manner.

To give a couple of examples. To filter a list of beans in lambdaj you could write something like this:

 
int totalAge = sum(meAndMyFriends, on(Person.class).getAge());

This will work because you would do a static import of the Lambda class that has the sum and on methods. So to explain what happens, the sum method will iterate over the collection of Person objects and invoke the getAge() method and sum all the results. Actually it's very readable what will happen. Because the on method uses generics you'll even get code completion and you'll be able to use refactoring.

Even better is the sumFrom method, it will return a bean of the same type of your list and you can then call any method to get the sum from all the properties. Of course this will only work if your collection contains object instances, because java generics are not reified.


Person totalsPerson = sumFrom(meAndMyFriends);
int totalAge = totalsPerson.getAge();
int totalLength = totalsPerson.getLength();

This works because sumFrom gives back a Proxy object that is the same as the elements in the list. When you invoke a method on it, it still has a reference to the list so it will iterate over the list and sum the properties.

Another example:

  
List<Person> oldFriends = filter(having(on(Person.class).getAge(), greaterThan(30)), meAndMyFriends);

There are of course more frameworks that can do similar things. When I first saw this I thought of jxpath but the disadvantage of this framework is that when doing refactoring, you'll have to manually change the xpath queries. Another powerful framework that also takes advantage of functional paradigm is google collections.

But as Mario Fusco also pointed out at the end of his presentation.... If you can, you should really give Scala a spin. Then you will not need lambdaj, you will have something more powerful.

Maven 3 early access

2009-09-22T12:43:00.011+02:00

After the talk from Jason van Zyl, I thought it was time to give Maven 3 a try. So I checked out the sources from svn and tried to build. That was the first challenge because even though Jason told us they switched from Plexus to Guice there is still a dependency on plexus 1.2.1-SNAPSHOT. I could not find any binaries for this so I checked that one out and built that too.

So now I can build and run Maven 3. In the presentation from Jason he told us that they didn't want to change too much because they didn't want to break backwards compatibility. They did a lot of tests to fulfil that promise by checking out Maven 2 open source projects and testing them with maven 3. They even have a Hudson grid running multiple builds to ensure backwards compatibility. So I thought that my project will work without any problem. I never do anything exotic in my builds, but how wrong could I have been, because it does not build with Maven 3. It gives the following error that was very clear:

[ERROR] Some problems were encountered while processing the POMs: [ERROR] 'dependencies.dependency.(groupId:artifactId:type:classifier)' must be unique: xml-resolver:xml-resolver:jar -> null vs null @ ch.admin.smclient:smclient:1.0.1-SNAPSHOT, /home/edewit/workspace/smclient/smclient/pom.xml

So what I never noticed before is that I had the xml-resolver twice in my dependency list. Once with a version number and one without. Maven 2 never warned me about this. This shows that the dependency management resolving has improved a lot. Also the way the errors are presented is improved I think.

Also Jason mentioned that the speed of Maven 3 has improved, so I tested this as well and it turns out that on my project the speed increase was about 11%. That is not great but it's not bad as well.

Jason said that everything they are working on (Maven 3, m2eclipse and Nexus) is going to be finalized at the end of this year. So I'll be looking forward to that even though I think this version of maven is already a step forward. After more projects successfully built with Maven 3 I'm sure that they intend to add more new features.

Thoughts on Jason van Zyl talking about Maven 3

2009-09-18T06:50:00.012+02:00

Today I've been to the talk from Jason van Zyl hosted by the JUGS (Java User Group Switzerland, yes I know it's a ridiculous name). He is one of the authors of Maven 1 and 2, he talked about Maven 3 and what it's going to bring us. And I must say it's quite impressive. Being an open source contributor myself I know that good software is written in 3 times. This was also the main point of his talk. He first made the joke that he never expected us to use Maven 1 but that Maven 2 was useable, and now they are fixing everything in Maven 3. I now use Netbeans because I love the Maven support that it's got. But with Maven 3 they are also developing the m2eclipse plugin. And what Jason told us during his presentation is that also here they are fixing a lot of things there. For instance Maven will have a query-able life cycle, with this eclipse can use only a part of Maven for instance to do a compile. So no longer adding a resource will kickoff an entire maven build and 5 minutes later we are ready to code again. I still think that the editor of Eclipse is better than the one Netbeans provides and Jason also says that the Maven integration was better in Netbeans. In fact they've used a lot of the Netbeans plugin features in the new m2eclipse plugin. Knowing all this I must really give Eclipse another try. What the new maven 3 also will have is a way to describe your maven model how you would like it, so for instance you could use ruby or groovy to create you're maven object model, instead of a xml, we could do something with this just don't know what. One thing I'm really excited about is they are making the maven integration also communicate with other plugins. For instance when you make changes in the WTP plugin about your war, this will also be put in you're pom. The same holds true for PMD plugin, the settings that are in your pom will also be set in the PMD plugin and changes made will reflect back.

Jason is quite a talker, his slides were full with text and he only briefly stopped talking to take a zip of water. His company also makes Nexus a proxy for maven repositories. Other products that do something similar are Artifactory or Archiva. The cool things they've build into Nexus is the ability to also be a proxy for Eclipse plugins. But all the cool things about Nexus are in the commercial version of Nexus like for instance LDAP authentication and lots of features around provisioning repositories.

Talking about their commercial products, they also sell this concept where one can have everything setup for a developer in one go. The m2eclipse plugin will discover where Nexus is, install the necessary plugins, show the projects a developer can work on and even download wiki documentation from confluence or twiki. This can all be configured by the technical lead of the project. I really like this concept, to many times I've seen it take days for a new developer to be up to speed. Not only taking time on his one, but also needing intensive support. With this in place some of that time can be saved.

So all in all I'm very positive about this presentation, JUGS keep up the good work. And I'll be trying the dev build of maven 3 and m2eclipse right away tomorrow. I'll let you know how it works out.

JBoss Seam Archetype - now with ICEfaces

2009-07-01T22:34:00.002+02:00

Last week I visited Jazoon - and had a great opportunity to see several impressive demos of ICEfaces! Of course I had to immediately get my hands on it, and started to integrate ICEfaces in the JBoss Seam Maven archetype (as described in my previous post).

You can give it a spin by starting a shell and running Maven with the Archetype plugin:

>mvn archetype:generate -DarchetypeCatalog=http://tinyurl.com/jbsarch -DajaxLibrary=icefaces
[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
...
Choose archetype:
1: http://tinyurl.com/jbsarch -> jboss-seam-archetype (Archetype for JBoss Seam Projects)
Choose a number:  (1): 1
Define value for serverDir: : [your JBoss 5 server location]
Define value for groupId: : [your groupId]
Define value for artifactId: : [your artifactId]
Define value for version:  1.0-SNAPSHOT: : [your version]
Define value for package: : [your package]
Confirm properties configuration:
serverType: jboss5
ajaxLibrary: icefaces
...
Y: : y
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
...

Make sure you don't misspell "icefaces", this will otherwise screw up the application. No input validation in Maven Archetype yet, but I started looking into it ;-)

Again, change to the project directory and build the project:

>mvn package

Now this also executes a sample unit test (fingers crossed it works this time ;-) - thanks to Oscar for the feedback!

Have fun with it! Anybody mind contributing a decent layout template?

Creating a JBoss Seam Maven Archetype

2009-06-19T16:30:00.003+02:00

In case you're a regular reader of this blog, I guess you're aware that I'm a frequent user of both Maven and JBoss Seam - and that I'm regularly trying to combine working with both! My usual approach for setting up a new project was either to start with an empty Maven web application project and copying the missing files over, or to start with a seam-gen project and move it into a Maven structure. Both less than ideal...

Maven provides so called archetypes for a quick project setup. As there is not (yet?) an official archetype for Seam projects, I've been working on my own - and here's how you can use it as well!

All you need is

a recent version of Maven downloaded (I used 2.0.10)
and the Maven executable referenced in your path so you can use it on the console.

Open up a console, cd to your projects directory and type:


mvn archetype:generate -DarchetypeCatalog=http://tinyurl.com/jbsarch

This will start Maven and show the following command line output:


[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO]    task-segment: [archetype:generate] (aggregator-style)
[INFO] ------------------------------------------------------------------------
[INFO] Preparing archetype:generate
[INFO] No goals needed for project - skipping
[INFO] Setting property: classpath.resource.loader.class => 'org.codehaus.plexus.velocity.ContextClassLoaderResourceLoader'.
[INFO] Setting property: velocimacro.messages.on => 'false'.
[INFO] Setting property: resource.loader => 'classpath'.
[INFO] Setting property: resource.manager.logwhenfound => 'false'.
[INFO] [archetype:generate]
[INFO] Generating project in Interactive mode
[INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0)
Choose archetype:
1: http://tinyurl.com/jbsarch -> jboss-seam-archetype (Archetype for JBoss Seam Projects)
Choose a number:  (1):

The remote archetype catalog contains so far only one archetype (BTW: the jbsarch in tinyurl.com/jbsarch stands for JBoss Seam ARCHetype - hope you can remember this better than the full URL :-) Select the archetype by typing 1 and enter your Maven project properties as well as your JBoss Server directory:

[INFO] snapshot com.ctp.archetype:jboss-seam-archetype:1.0.0-SNAPSHOT: checking for updates from jboss-seam-archetype-repo
Define value for serverDir: : /Developer/Servers/JBoss/jboss-5.1.0.GA
Define value for groupId: : com.ctp
Define value for artifactId: : fluxcapacitor
Define value for version:  1.0-SNAPSHOT: :
Define value for package:  com.ctp: : com.ctp.fluxcapacitor
Confirm properties configuration:
serverType: jboss5
serverDir: /Developer/Servers/JBoss/jboss-5.1.0.GA
groupId: com.ctp
artifactId: fluxcapacitor
version: 1.0-SNAPSHOT
package: com.ctp.fluxcapacitor
Y: : y
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4 minutes 57 seconds
[INFO] Finished at: Fri Jun 19 19:12:19 CEST 2009
[INFO] Final Memory: 12M/79M
[INFO] ------------------------------------------------------------------------

Note that the serverType property defaults to jboss5. If you have a JBoss 4.2.x installation, quit with n and retype everything (hmm...) and use jboss4 instead.

In case anything fails here, make sure your archetype plugin is at least version 2.0-alpha-4 (I had to delete the local repo info file in the local repository once). Now with your project created, lets build and deploy it!

Aragorn:sandbox thug$ cd fluxcapacitor/
Aragorn:fluxcapacitor thug$ mvn package
[INFO] Scanning for projects...
[INFO] Reactor build order:
[INFO]   [fluxcapacitor]
[INFO]   [fluxcapacitor :: JBoss Configuration]
[INFO]   [fluxcapacitor :: Web Application]

The project currently features two modules: One with the actual web application, and the other one containing JBoss Server configuration files. With the basic archetype you only get a datasource there, but you can also use it to change server ports, define security realms, queues etc.

Environment specific properties are referenced in filter property files. You can find the development filter file in ${artifactId}/environment/filters/${artifactId}-development.properties. The filter file selection happens in the parent POM. It defines a development profile which sets the environment property. Setting this property to test will look for a ${artifactId}/environment/filters/${artifactId}-test.properties filter file.

Note that the parent POM contains your JBoss installation directory hard coded. You might want to factor this out into a developer specific profile when working in a team. Fire up your JBoss instance. Everything should start up well (fingers crossed...) and you can point your browser to the base URL of your application.

Done! Import the project in your favorite IDE and start prototyping!

Unfortunately this is still far away of what seam-gen provides up to now. Maven archetypes have improved over time but are currently still not as flexible to be useful in complex setups:

Entering project properties is not even close to be user friendly. At least a description, input validation (enumerations) and reasonable handling of default values might help.
Conditional installation of files. If you know how this works - let me know :-) This would be required to distinguish between WAR and EAR projects, and for targeting different applications servers (yeah, like GlassFish!).

In case I find some time to contribute something here, I'll report back. If you have feedback / contributions to the archetype, this is as usual very welcome (the code is available at our Google Code repository)!

JavaOne 2009 Summary: Friday (Day 4)

2009-06-06T10:33:00.025+02:00

JavaOne 2009 Summary: Thursday (Day 3)

2009-06-05T05:05:00.018+02:00

JavaOne 2009 Summary: Wednesday (Day 2)

2009-06-04T07:15:00.003+02:00

Back again... well I'm sorry to write this but I could not make it yesterday to publish the summary of Wednesday. It was 2:15am and I was very exhausted after having been up since 7am. So, I still hope you enjoy this summary as I try to include as much infos as a can within the given time from different sources in the net and myself.

Related Posts so far:

Day 0: CommunityOne
Day 1: JavaOne, Key Note

JavaOne Day 2 Summary

=== Mobility General Session ===

Christopher David, Head of Development and Partner Engagement at Sony Ericsson, was the main speaker for the talk. During his presentation, Erik Hullman (a Senior Java Developer with Sony Ericsson) was given the task to develop a JavaFX Twitter client from scratch that at the end of the presentation should be deployed to three different devices!
As if the task would not have been complex enough: People in the audience could send questions or comments to his Twitter accound that he answered in parallel to his programming efforts... and at the end, the same deployable artefact worked fine on all three devices. Sounds promising!!

Rikko Sakaguchi, Corporate VP of Creation and Development

=== Technical Sessions Highlights ===

Hudson: Continuous Integration in the Cloud with Hudson
(by Kohsuke Kawaguchi --> Blog)
- I very much like the automated distribution approach: You start the Master Instance with Hudson installed as well as with the Hudson PXE Plugin (Prebuilt Execution Environment). After that you start the Slave Instance (on another machine) and boot from the network. That's it!
- The defined target machines can be flagged with so called "labels" and can be used to ensure that Test Units aimed for Windows machines are executed on Windows boxes (and same for Unix boxes).
- The Hudson Master instance can run on Windows or Unix.
- Cloud: The demo was about the creation of a CI environment in Amazon EC2. It was very impressive how quickly the setup was done and executed successfully.
- Hadoop: Kohsuke also mentioned the rather new plugin for Hadoop which makes Hudson run on Hadoop.
- Slides: PPT
"Effective Java": Still effective after all these years
(by Joshua Bloch)
As in his other presentations, Joshua presented his content in a very nice way accompanied by his typical kind of humour... As of the end of the day, his book was again "Number 1" in the Bookstore's Top Seller List.
JPA 2.0 (by Linda DeMichiel)
The new Criteria API as well as the introduction of the pessimistic locking modes were interesting to follow. Overall, the session was a little bit too much on the theoretical side.
WebBeans! Sorry: JCDI, Java Contexts and Dependency Injection: JSR-299
(by Gavin King)
I just like the way Gavin presents, he has his unique style, very straight forward and nice to follow. JCDI targets to support stateful objects, builds the glue between JSF and EJB, allows loose coupling with strong typing and introduces very nice concepts like BindingTypes and DeploymentTypes.

After the speech we asked Gavin about the other "DI" related JSR submitted by Bob Lee (Google) and Rod Johnson (SpringSource): JSR-330. It states "This JSR targets Java SE, and it will lay a foundation for dependency injection in Java EE." So it seems that this is a big discussion at the moment as the JSR-299 has started 3 years ago and is nearly finalized now and could make it easily into the final release of Java EE 6 by end of this year whereas the newly submitted JSR would take at least 1 year until its finalization and would eventually postpone the release of Java EE 6 as 299 would directly depend on 330. I'm very curious how this gets resolved. My personal hope is that they agree on a common dependency injection foundation for SE and EE and include that one with potential EE specifics in the nearly finalized 299 (During the Java EE 6 Panel Discussion BOF, William Shannon meant that the EG would never accept two different DI specs on the Java Platform, so a common sense must be found, and quickly).
Links around this discusssion:
--> Bob Lee's initial post (from May 5th, 2009)
--> Gavin King's statement (from May 7th, 2009)
--> Bob's comment on Gavin's statement

=== BOFs ===

JSF Platform and Ajax: State of the Union
with Ted Goddard (Lead Architect of ICEfaces), Andy Schwartz (Oracle ADF Faces) and Alexandr Smirnov (RichFaces)
This kind of panel discussion was very interesting as each of the presenters talked about the current status and the progress towards JSF 2.0. RichFaces and ICEfaces convinced most (RichFaces because of its seemless integration with Seam and ICEfaces because of its architecture and the unique feature of automatic Ajax Push based on server-side DOM-diffing (more here)).
Woodstock was not represented. As of the presenters there are no plans for further releases. On ICEfaces there is a migration plan described from Woodstock to ICEfaces.

Ted Goddard
Java EE 6 Experts Discussion Panel
hosted by Roberto Chinnici and William Shannon
Good discussions, questions and comments... I was surprised that JSR-299 was not mentioned at all in the presentation about Java EE 6. After having asked the question why it is missing, a big *sigh* from Roberto Chinnici :-) (as expected), then responding that they were not yet sure about the inclusion of JSR-299 in Java EE 6. I reformulated my question what the current trend would be, rather "in" or "out". After eye-contacting with William Shannon, William meant "give him the full story"... Then the story around "JSR-299 vs JSR-330" has been described (see WebBeans above for more details).

William Shannon and Roberto Chinnici

=== Pavilion ===

At the ICEfaces booth we met Micha Kiener (also from Switzerland) who is working for Mimacom. We were introduced to the overall architecture of ICEfaces and that looked really cool (server-side DOM diffing, Ajax Push). The demo showed a very elegant way of doing Interportlet Communication (IPC) on Liferay Portal 5.2. Really nice!!
And some pictures from the Pavilion and its entrance area...

Dani at the SpringSource booth
where it says "Eliminating Enterprise Java Complexity"...

Cheers

JavaOne 2009 Summary: Tuesday (Day 1)

2009-06-03T07:57:00.002+02:00

Take a deep breath... Time is really rushing away, it is actually Wednesday night now (11pm), 50% already passed, but as promised in the previous post, there will be a summary of each day. So here it is!
Before kicking off, read the summary of Monday's ConferenceOne if you haven't done so already...

JavaOne Day 1 Summary

As every year, Day 1 started with the General Session, the key note by Sun itself and hosted this year by Sun's CGO (Chief Gaming Officer) Chris Melissinos.
Guests on stage were

James Barresse, VP of Architecture, Platforms and Systems with eBay
Alan Brunner, Senior VP for the Blackberry Platform
Dan Eklund, Executive VP of Advanced Technologies at Sony Pictures Home Entertainment
Lowell McAdam, President and CEO of Verizon
Diane Bryant, Executive VP at Intel
Ronan McBrien, JavaFX TV Architect (nice demo, video should be available here)
Nandini Ramani, Director for JavaFX

Some pictures:

Jonathan Schwarz about BDJ and BD Live

Java FX TV Demo:

=== Key Note Highlights ===

Oracle and the Future of Java:
At the end of the key note, Scott McNealy called Oracle CEO Larry Ellison up on stage to address the $7.4 billion dollar question -- what will be the future of Java?
My key notes from his answer are:
- Oracle with a much greater R&D budget than Sun will be able to even more push Java forward. Quote: "I don't expect a lot of changes, just expanded investment and a lot of enthusiasm coming from Oracle."
- He mentioned JavaFX many times, he wants OpenOffice to use JavaFX as UI. He also mentioned that it would be interesting to see Android based phones and netbooks from Sun running Java and JavaFX. Rumors say that pushing JavaFX will secure his seat in the UI battle between Silverlight and Flex.
- "Look at the past to see the future": by this he most probably meant Oracle's dedication to Java since its birth, its commitment to support the community and to actively participate in Java's future.
- Interesting Link about Larry's talk
- Some pictures:
Scott mentioning that Larry might have more luck
to bring the JVM on the iPhone :-)

"Mr. Oracle"

- And enjoy the following video:

Java Store! presented by James Gosling: still in beta, community is asked to give feedback on how payments should be implemented.
Release of Java FX 1.2 !
"The classpath is dead": Chief Engineer of Java SE, Mark Reinhold, said this after having shown a nifty demo on how Java SE 7 manages modules.
"The web.xml is dead": CTO at Sun, Bob Brewin, said this while talking about the next enterprise release Java EE 6.
Announcement of JATAF ! The Java Application Terminal Alignment Framework is an open, collaborative community striving for a unified Java ME platform.
Project Dark Chat: Nice demo app for the JavaOne.
--> Download this JNLP file (jre6u10 required)
DJ Anna: for me as a fan of electronic music, the opening sounds mixed live by DJ Anna, a local DJ of San Francisco, are always a pleasure to listen to...
and of course: Gosling's T-Shirt Tossing!!!

=== Technical Sessions Highlights ===
As it got already very late and I am still writing about yesterday!, more take aways from the technical sessions will follow (as CTP internal Knowledge Shares or in form of upcoming blog posts):
Interesting sessions were EJB 3.1, Servlet 3.0, Java EE 6 and GlassFish v3, Spring 3.0, JSF 2.0 and others...

=== BOFs ===

The most exciting BOF was of course the one of JavaPosse !
Download the mp3 and listen yourself what happened!! :
Episode 0x100 (#256)

As last year, the beer got sponsored by Atlassian and started with some polls from the audience. After that, they talked about topics and news they picked up during the first day...
After the show we joined them for some drinks at the Kate O'Briens pub near Moscone. I could finally tell Joe to accept my friend request on Xbox360 in order to see his hotlaps in Forza2 (he is actually a real race driver, watch this video if you don't believe me) and Carl told us some more details about his brand new Tesla (100% electric car)... A great moment in life indeed to finally get to know these dudes! :-) I could not talk much with Dick Wall unfortunately... One more reason to go again to JavaOne! ;-) At least one important thing I could tell him: Talk more about Enterprise stuff!
BOF about Lift: The Best Way to create RIAs with Scala
(by David Pollak, Lead of the Lift Framework)

to be honest, I can't comment on this content-wise... The way it was presented was cool (I like the humour of David Pollak), it was also interesting to see how he quickly implemented a fully functioning ajax based chat tool from scratch in less than 100 lines of code :-) but I could only take this one with me: Learn Scala first, then lift off with Lift.... ok! -> Scala book bought!!

Good night (oh no... in 5 hours the alarm kicks on :-),
Balz

JavaOne 2009 Summary: Monday (CommunityOne)

2009-06-02T06:00:00.010+02:00

JavaOne has not officially started yet, it's Monday and not Tuesday, it's CommunityOne and not JavaOne, but the community spirit already caught us and punched us into the geeky experience of the world's biggest Java conference in the nice Moscone Center in San Francisco... main focus of today's sessions was on GlassFish stuff... In a nutshell: Niiice!!

So here is our summary of today's CommunityOne day (after having had some beers at the OpenSolaris & Sun Cloud Party in Hall A):

=== Sessions ===

Sun GlassFish Application Server Portfolio (by Eduardo Pelegri-Llopart from Sun): Where Sun's Platform Is Going:
not much news for us actually... no infos regarding how Oracle want to proceed with GF
Running Seam on the GlassFish Application Server (by Dan Allen from Red Hat):
- Seam best works with Hibernate as persistence provider (and looks for it in the classpath). GlassFish v2 comes with Toplink, Glassfish v3 with EclipseLink. Dan Allen from Red Hat made a nice summary of all the tweeks you have to apply in order to make Seam work with GF's default persistence provider.
- Dan further went into differences of JBoss AS and GlassFish AS which also brought some steps to be done if Seam should run on GF.
- But: from a developer perspective, such details are not necessarily required to be known as "seam-gen" supports both application servers out of the box. We asked Dan about support of Oracle WebLogic Application Server and he pointed us to a chapter in the Seam documentation. As that is not the whole story (as of my current status), we might come up with our additions soon...
Lightning Talks!
This special type of talks runs throughout the day, split in multiple parts of 50 minutes each where every part again contains up to 8 very short speaches... I visited part 3 covering:
- The Mural Project
- Deep Dive Sneak Peek Sun Learning Services
- Atmosphere (by JF Arcand!): good to know that Atmosphere is not only useful in containers not supporting Servlet 3.0: it autodetects Servlet 3.0 and still provides a nice abstraction of the rather complex Async API of Servlet 3.0
- Adding AJAX Push (Ted Goddard from ICEsoft, focusing on ICEfaces of course)
- Alice
- BluJ
- In a summary: Cool to listen to, nice to get an impression of the topic and good as decision maker whether to go to the full sessions on certain topics not already being enrolled in your schedule...
Developing RESTful Web Services with JAX-RS and Jersey (by Marc Hadley and Paul Sandoz from Sun)
- The two spec leads of JSR-311 made a quick walkthrough from the architectural style REST to the JSR-311 (JAX-RS) and showed two demos running on the reference implementation Jersey.
- One demo showed how JCDI (JSR-299, fka WebBeans), Java Contexts and Dependency Injection works together with Jersey using Google Guice. This was interesting, and in a side remark he recommended to have a look at Guicey Fruit running on Guice 2.0. Geeks... but we like it ;-)
EclipseLink - The Road to JPA 2.0 (by Doug Clarke from Oracle and Co-Lead of the EclipseLink project):
- no much news for us at this moment

=== Pavilion ===

The Pavilion opened at 3pm. Between the sessions and after 5pm, it was interesting to walk from one booth to the other until 7pm when it closed.
GlassFish, Portals: We talked to Srikanth Konjarla (Software Architect of Web Space Server, aka WebSynergy Project having the same codebase as the Liferay Portal). He was also not allowed to talk about how Oracle will continue with the GlassFish products like WebSpace Server (Portal) and the GlassFish Application Server... we hope for more details in tomorrow's general session!
Atlassian: We had quite a deep introduction by Douglas Butler (thanks!) into the new versions of Atlassian's products:
- JIRA (4.0 beta)
- Confluence (3.0 released TODAY!!)
- Fisheye together with Crucible
- Bamboo and Clover -- Really nice what we have seen here!
- The new versions generally invested a lot into the visualization of data, hiding complexities by using more wizards but also many things happened from an integration point of view:
- Atlassian released widgets/gadgets to be deployed into any portlet container in order to create nice dashboards etc.
- They will also soon provide RESTful interfaces for all their products to freely integrate them into any other app.... This sounds very cool indeed.
- And the give-away gadgets are nice too ;-) Have a look at their new T-Shirts: If you wear one of those and have it filmed by an Atlassian camera, some things get out of the shirt!! ;-)

- And yes, they acquired GreenHopper (announced TODAY).
Livescribe: At last year's Java One, Livescribe presented their JavaME based pen and sold 150 pieces right after the general session... I also bought one. I'm happy to see that the company still exists and that they heavily extended their features (e.g. Pencasts). At their booth today I got a nice little paper blanks (which is not sold in Europe so far).
Vaadin: IT Mill has released the 6th version of their server driven RIA framework known as IT Mill Tollkit. Together with the release they rebranded it into Vaadin. It is free, open source and looks actually very much like GWT... The demo looked very nice. Certainly worth having a closer look at it!
James Gosling: Spotted early at the Pavilion entrance! ;-)
Sun Cloud: We haven't had the chance to check out the details of Sun Cloud yet but with the rather big party this evening sponsored by Sun Cloud and OpenSolaris we expect a bigger announcement by tomorrow... so stay tuned.
NUUX: We also met Ben (an Alumni CTP Consultant) at his booth in the Java Utopia corner. Check out his website!!
Anchor Steam Beer: San Francisco's local beer is really worth to be mentioned here as single item ;-) and it tasted great in the OpenSolaris branded glass!

=== Bookstore ===

Bought today:
- Java EE 6 with GlassFish 3
- The Definitive Guide to Lift
More tomorrow ;-) ...

=== Tomorrow ===
Sure, lots of interesting session are registered in our schedule, but:
tomorrow is also the long expected JavaPosse BOF from 9.30pm to 10.20pm, so don't expect a summary like this after that :-) We will most probably post a 2-day summary on Wednesday evening... ok?
So cu then! And don't forget to follow Balz @ Twitter for live updates!
- Cheers, Balz & Dani.

JBoss Seam Hot Deploy with Maven - EAR Projects

2009-05-29T23:23:00.003+02:00

As requested on some comments on my previous posts (initial post and update), the Seam Hotdeploy Maven plugin now works also with EAR projects.

Some more details on how to configure your project can be found in our Google Code Wiki. The plugin now defines a new packaging type for Seam WAR modules - the only possibility to override the war:war goal in the package phase.

If you're interested in how to override the default lifecycle Maven goal, you can check out the plugin source - something I haven't been able to google easily. Or, maybe wait for a dedicated blog post - stay tuned!

Something you should definitely checkout with the Hot Deploy plugin is the Maven CLI plugin. See the great post from Dan here, or the integration in the sample POM.

As usual, feedback and contributions are very welcome!

CTP @ JavaOne 2009

2009-05-15T17:30:00.002+02:00

Only three weeks until Java One! Can't believe it's less than one month away!!
So let's have a look at what we think is hot this year. As every year, the conference has a certain umbrella topic where this year's JavaOne is certainly in the light of Java EE 6:

JavaEE6: JSF 2.0 @ TS-4640 (by Ed Burns)
JavaEE6: Servlet 3.0 @ TS-3790
JavaEE6: JPA 2.0 @ TS-5214
JavaEE6: Contexts & Dependency Injection (WebBeans) @ TS-6726 (by Gavin King)
JavaEE6: EJB3.1 @ TS-4605
JavaEE6: Developing JPA Applications with NetBeans and EclipseLink @ TS-5018
JavaEE6: JAX-RS (REST) @ BOF-4878
JavaEE6: Glassfish v3 (JavaEE6 Reference Implementation) @ TS-4923
JavaEE6: JCA 1.6 @ TS-4733
JBoss Seam: Conversations and Page Flows on the JSF Platform @ TS-5045 (by Seam in Action author Dan Allen)
Java Posse BOF @ BOF-4418 with Dick Wall (he likes the Groovy! :-), Joe Nuxoll and Carl Quinn, why is Tor Norbye not listed? Probably still digesting Snoracle!
Google App Engine @ TS-3817
Building JavaEE based Web Apps with Google Open-Source Technology @ TS-4062
Effective Java: Still effective after all these years @ TS-5127 (by Joshua Bloch!)
Defective Java Code: Mistakes that matter @ TS-5335
Metro Web Services Security @ TS-4402
Enterprise Integration Patterns in Practice @ TS-4839
SOA at Enterprise Scale @ TS-5123
Spring 3.0 @ TS-5225 (by Rod Johnson)

Of course there are much much more topics addressed like Scala, JavaFX, Java Mobile including Bluray Disc Java, lots of sessions about Cloud Computing, GWT, Groovy, OSGi and many more...

Interesting sessions at the CommunityOne West Conference (starting 1 day before JavaOne):

Oracle EclipseLink: S308133
SUN Glassfish Portfolio: Where is it going?: S307894
Architecting robust Applications for Amazon EC2: S304314

How to get updates:

Follow Balz live from JavaOne via his Twitter account (also see widget at the end of this post)
Follow other twitworks: Kevin Farnham or the JavaOne official twitwork
Java.net will produce again lots of Podcasts (not Pencasts!):
The Schedule has been published already.
And: Check this blog after JavaOne for a summary!

Cheers!

CTP Java Pencast #1

2009-05-08T14:03:00.006+02:00

Welcome to the first pencast!
Switch on audio to fully enjoy the show!
Be aware that this has been recorded in one single shot and without any post-processing...

Shownotes:

JavaME enabled pen by Livescribe
Customer Technology Stack: JSF 1.2, JBoss Seam 2.1 (with jBPM), Hibernate 3, WebLogic Server 10.3 or JBoss Application Server 5
Java EE5 : JSF 1.2, EJB 3.0, JPA 1.0, Glassfish v2
Java EE6 : JSF 2.0, EJB 3.1, JPA 2.0, Glassfish v3

So come back to visit us for checking details on the discussed web technology stacks!

Portal Update March / April 2009

2009-04-20T17:05:00.003+02:00

Winter has turned into Spring, at least here in Switzerland... and in parallel to the brighter days, let's bring some light into the Java Portal area as well: What products are interesting these days and which should be followed for sure in 2009?

From the commercial side, major players are:

Oracle WebLogic Portal 10.3:
formerly known as BEA WebLogic Portal
Oracle WebCenter Suite 11g TP4:
WebCenter Suite also includes the formerly known product AquaLogic Interaction by BEA, now called WCI, WebCenter Interaction. Longterm, WLP will probably fully converge with WebCenter Suite where nowadays integration happens via the WebCenter Services.
IBM WebSphere Portal 6.1

Open Source portals that have the most promising potential at the moment are:

Liferay Portal 5.2:
back in August 2008, SUN and Liferay announced their partnership to work jointly on the next portal generation and presented their roadmap, Liferay keeping their Liferay Portal and SUN continuing their WebSynergy project).
SUN's brand new Web Space Server:
Since February 2009, SUN has released Web Space Server version 10 which is including all the efforts from the internal Project WebSynergy. WebSpace Server is not only a portal product, it is a full fletched portal platform and has been integrated into the Glassfish Portfolio.
For more info, read their first documentations.

JBoss Portal 2.7.2:
- On March 12th, JBoss has released the latest version of its portal product and is available for download.
- On Apr 3rd, JBoss released the JSR-301 compliant Portlet Bridge CR1. Currently the bridge supports any combination of JSF, Seam, and RichFaces to run inside a portlet.
eXo Portal 2.5.1
Jetspeed 2: no updates since version 2.1.3 from December 2007.

From a portal technology point of view, it is interesting to see the product's maturity with regards to the following standards:

JSR-168 - Portlet Specification (final since Oct 2003)
JSR-286 - Portlet Specification 2.0 (final since June 2008)
WSRP 1.0 - The first specification of Web Services for Remote Portlets (final since August 2003)
WSRP 2.0 (final since April 2008)
JSR-301: Portlet 1.0 (JSR-168) Bridge Specification for JSF 1.x:
Current Status: proposed final draft in Jan 2009
Currently available implementations of JSR-301:
- MyFaces Portlet Bridge
- OpenPortal Portlet Bridge (used in Liferay Portal)
- JBoss Portlet Bridge (used by JBoss Portal)
JSR-329: Portlet 2.0 (JSR-286) Bridge Specification for JSF 1.2:
too early for products to support this JSR as it has been created in January 2009 and is in the status "Early Draft Review" as of March 2009.
Note that this specification is led by Oracle exclusively at the moment.
JSR-314: JSF 2.0:
The support of JSF 2.0 in a portlet container is not yet officially addressed. There is no JSR around like "Portlet 2.0 Bridge for JSF 2.0".

Besides the Portal related activities, let's have a look on Java related quick news:

SUN has announced that Glassfish v3 Milestone 2 will be ready by Java One 2009 in June.
For the complete schedule, click on this link.
Liferay 5.2 is now fully supporting WSRP 2.0 with the release of the WSRP 2.0 FCS binary.
Oracle & SUN: Oracle buys SUN as of the announcement on April 20th 2009.
It will be very interesting what will happen to SUN's products like
- The whole Glassfish Portfolio
- MySQL
- Netbeans
- OpenSolaris and
- JavaFX
Java EE 6: The JSR-316 has passed the Public Review state. See its results.

Java People Spotlight: Domenico Crescenti

2009-04-17T21:08:00.003+02:00

In this edition of the "CTP People Spotlight" series we introduce Domenico, one of the CTP competences for content related topics.

Java Competence Role:
Messica (insider)
My Master Kung-Fu Skills:
They call me Mr. Bean
I'd be excited to get my hands dirty on:
JCR 2.0 (JSR-283)

Q&A

Q: Hi Domenico, how would your message look like if you would have to tell it via Twitter what you are currently doing?
A: I'm buying some insecticide to feed the bug in my code :)

Q: What was the greatest piece of code you have ever written so far?
A: That was definitely the play fair chiffre

Q: What is the best quote you have ever heard about programming?
A: "Cool!!! You didn't mess up my code"

Q: What is the best quote you have heard from our managers?
A: "........."

Q: What is the most cutting-edge technology or framework you actually used on projects?
A: Vamosa!

Q: What is your favorite podcast?
A: Discovery Channel Video Podcast – the US original of course – and the Java Posse Podcast

Q: Which Java book can you recommend and for what reason?
A: Java (Taschenbuch) by far the best Java book I’ve ever read.

JBoss Seam on Google App Engine - First Steps

2009-04-16T19:33:00.008+02:00

[UPDATE] The latest Morjarra release 1.2_13 as well as the latest Appengine SDK 1.2.2 seem to fix a couple of problems described below. My task backlog is actually growing :-) but I hope I find some time to look again how things work with these new versions.

I spent the last three weeks in a repetition course of the Swiss army - far away from any Java code. Naturally my fingers started to itch while reading the announcement of Google that their App Engine now supports Java! So I grabbed my MacBook to enjoy the sun, Java coding and Eastern holidays.

As I usually write web applications with JBoss Seam, I decided to give the framework a try in the Google cloud - preparing for a bumpy road as Seam founds on standards which are mostly listed as either not or not known to be working. The following article describes the (bad) tweaks I had to do to get something basic running - I guess if you start doing serious development, you might hit more walls.

First, install the Eclipse Plugin for App Engine and create a new project. I'll base my descriptions on this initial setup. Switch on sessions in appengine-web.xml:

<sessions-enabled>true</sessions-enabled>

Setting up JSF 1.2

Download the latest Mojarra 1.2 release [1.2_12] and put it in the WEB-INF/lib directory. You can configure the Faces servlet in web.xml as usual

<servlet>
   <servlet-name>Faces Servlet</servlet-name>
   <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
   <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
   <servlet-name>Faces Servlet</servlet-name>
   <url-pattern>*.seam</url-pattern>
</servlet-mapping>

Starting Jetty with only this will fail due to some incompatibilities of Jetty and Mojarra. As with Seam we will need JBoss EL anyway, we can configure Mojarra to use the JBoss EL ExpressionFactory. Add the JBoss EL JAR to WEB-INF/lib and the following XML to your web.xml:

<context-param>
   <param-name>com.sun.faces.expressionFactory</param-name>
   <param-value>org.jboss.el.ExpressionFactoryImpl</param-value>
</context-param>

Now it's already patch time. Jetty in the Google environment seems to have a bug in its Servlet API implementation, missing the ServletContext.getContextPath() method (new in version 2.5). Also, Mojarra tries to be clever about initialization work and uses Threads in the ConfigManager - the App Engine SecurityManager will let the whole thing blow up. Something similar happens in the JBoss ReferenceCache class. All patched classes can be found here. Drop the Java code in your source folder, Jettys classloader will pick it up.

This will at least make the whole thing start up. I also added facelets (JAR file, view handler in faces-config.xml and view suffix in web.xml).

Unfortunately, using RichFaces components is an absolute no go on App Engine. RichFaces is full of references to AWT or JAI classes, which Google blocks completely. If anybody wants to try ICEFaces - good luck!

Adding Seam

Now it's time to add all the Seam stuff. Quite a couple of JARs to put into the application. I basically used Seam 2.1.1.GA and libraries from JBoss 4.2.3.GA. The complete list of what should go into WEB-INF/lib is shown in the screenshot below.

JTA is not even on the list of APIs Google gives a recommendation, so let's fall back on Java SE behavior. Configure components.xml with:

<transaction:entity-transaction entity-manager="#{entityManager}"/>

Although we cannot use Hibernate as persistence provider, Seam has a couple of dependencies to it (e.g. when using Hibernate Validators). As soon as we have it in the classpath, Seam activates its HibernatePersistenceProvider component. This will behave pretty bad, and for simplicity we just override this component:

@Name("org.jboss.seam.persistence.persistenceProvider")
@Scope(ScopeType.STATELESS)
@BypassInterceptors
@Install(precedence = Install.APPLICATION,
      classDependencies={"org.hibernate.Session", "javax.persistence.EntityManager"})
public class OverrideHibernatePersistenceProvider extends PersistenceProvider {
}

Now also add a persistence provider as described in the Google docs and disable DataNucleus checking for multiple PersistenceContextFactory instantiations with this property in appengine-web.xml.

<property name="appengine.orm.disable.duplicate.emf.exception" value="true"/>

As before, also Seam needs a couple of patches. Main reasons for those are references to javax.naming.NamingException (which is not white listed, credits to Toby for the hint) and session/conversation components not implementing Serializable correctly. The last point is probably something not hitting Seam or your application the last time.

Identity

As a next step I tried to add some users to the application. Seam's Identity module builds around the javax.security.auth.Subject and Principal classes. Even though those classes are white listed, the SecurityManager blocks any attempt to add a Principal to a Subject. Well, how useful is that... As a quick fallback I integrated the Google Accounts API:

@Name("org.jboss.seam.security.identity")
@Scope(SESSION)
@Install(precedence = Install.APPLICATION)
@BypassInterceptors
@Startup
public class AppEngineIdentity extends Identity {

  private static final long serialVersionUID = -9111123179634646677L;

  public static final String ROLE_USER = "user";
  public static final String ROLE_ADMIN = "admin";

  private transient UserService userService;

  @Create
  @Override
  public void create() {      
      userService = UserServiceFactory.getUserService();
  }

  @Override
  public boolean isLoggedIn() {
      return getUserService().isUserLoggedIn();
  }

  @Override
  public Principal getPrincipal() {
      if (isLoggedIn())
          return new SimplePrincipal(getUserService().getCurrentUser().getNickname());
      return null;
  }

  @Override
  public void checkRole(String role) {
      if (!isLoggedIn())
          throw new NotLoggedInException();
      if ((ROLE_ADMIN.equals(role) && !getUserService().isUserAdmin()) || !ROLE_USER.equals(role))
          throw new AuthorizationException(String.format(
                  "Authorization check failed for role [%s]", role));
  }

  @Override
  public boolean hasRole(String role) {
      if (!isLoggedIn())
          return false;
      return ((ROLE_ADMIN.equals(role) && getUserService().isUserAdmin()) || ROLE_USER.equals(role));
  }

  @Override
  public String getUsername() {
      if (isLoggedIn())
          return getUserService().getCurrentUser().getNickname();
      return null;
  }

  public String createLoginURL(String destination) {
      return getUserService().createLoginURL(destination);
  }

  public String createLogoutURL(String destination) {
      return getUserService().createLogoutURL(destination);
  }

  public User getUser() {
      if (isLoggedIn())
          return getUserService().getCurrentUser();
      return null;
  }

  private UserService getUserService() {
      if (userService == null)
          userService = UserServiceFactory.getUserService();
      return userService;
  }

}

Both create... methods can be used in the UI for generating login/logout URLs. Destination defines the URL the user gets redirected after successful login/logout. Also make sure that the identity configuration is removed from components.xml

Wrap up

Running this setup should give you a base for a very simple Seam app like in the screenshot below.

This first step has not been doing any persistence work, and my first tries with DataNucleus were not as straight forward as I had expected from a JPA implementation. Hope Google will catch up here with something more mature. Also, even the simple setup required a couple of nasty tweaks on the frameworks. Another big hurdle here are the runtime differences from production to local environment. For some serious work on App Engine, it's so far more recommendable to look into GWT.

Anyway, if you found this useful - looking forward to hear from your next steps in the cloud.

JBoss Seam Hot Deploy with Maven - Update

2009-03-20T13:46:00.009+01:00

I just published an updated version of the Seam Hotdeploy Maven Plugin (see my previous post here). For a detailed description on how to use it, have a look at the Google Code Wiki. I also updated the sample Maven POM featuring JBoss Seam 2.1.1.GA.

The new version should be easier to configure and play nicer with e.g. the Eclipse Maven plugin (I'm not using NetBeans/IntelliJ too often, but I hope this works also fine there). The new Eclipse builder configuration looks like shown in the image below:

Note: The Eclipse Maven plugin using its embedded Maven had somehow problems with the extended lifecycle of the Hotdeploy Plugin. Using an external Maven installation (2.0.10) felt not only faster but was also not having problems with it.

Java People Spotlight: Daniel Käppeli

2009-02-13T13:00:00.003+01:00

The "People Spotlight" series continues with a Java fellow who is at Cambridge Technology Partners since years now: Dani is continuously working in projects that most often deal with Open Source technology stacks.

Java Competence Role:
Senior Developer
My Master Kung-Fu Skills:
... there are so many to choose from ...
I'd be excited to get my hands dirty on:
Java EE 6 : see how all the bits and pieces fit together

Q&A

Q: Hi Dani, how would your message look like if you would have to tell it via Twitter what you are currently doing?
A: Recovering from a busy week and from yesterday’s dinner.

Q: What was the greatest piece of code you have ever written so far?
A: Parsing an XML document in 1 LoC with Spring OXM. Isn't that cool?


@SuppressWarnings("unchecked")
JAXBElement<GpxType> object = (JAXBElement<GpxType>)this.getUnmarshaller().unmarshal(new StreamSource(inputStream));

Q: What is the best quote you have ever heard about programming?
A: “These performance improvements are quite slow!”, K. K. 02.09

Q: What is the best quote you have heard from our managers?
A: "In the next quarter the hockey stick effect will kick in."

Q: What is the most cutting-edge technology or framework you actually used on projects?
A: RESTful Web Services with Jersey
Q: Wow! I actually didn't know that CTP uses that already... so we belong to the very early adopters of JSR-311 in customer projects! Nice Dani... when are you doing a Knowledge Share on this? ... Ok let's keep on with this short questionnaire first.

Q: What is your favorite podcast?
A: Discovery Channel Video Podcast – the US original of course – and the Java Posse Podcast

Q: Which Java book can you recommend and for what reason?
A: Joshua Bloch’s Effective Java Second Edition, by far the best Java book I’ve ever read

Portal Update January 2009

2009-01-30T10:53:00.025+01:00

After the snowy december we are back with new posts this year and we are looking forward to an interesting year! Java EE 6 is the late christmas present for many of us Java aficionados and it is going to be released probably around JavaOne in June...

In the portal corner, the following was important this month:

SUN: no updates
Liferay:
- One UI to rule them all: Check out this introduction of a new management console in Liferay Portal. This portal product is definitely going to be more and more interesting among the free portal products!
Oracle:
- Oracle Fusion Middleware Radio has released some talks about portal product roadmaps. No much news if you followed all our portal updates so far ;-). But if you are interested in to listen to them, here they are:
Oracle WebLogic Portal Roadmap (formerly BEA WebLogic Portal)
Oracle WebCenter Interaction Roadmap (formerly BEA AquaLogic User Interaction)
Oracle Portal Roadmap
JBoss:
- Release of JBoss Portal 2.7.1 which is a maintenance release for the 2.7 series that support JSR-286 portlets. The detailed release notes can be found here.
- The JBoss Portlet Bridge has reached Beta 6 and it integrates Seam and RichFaces. Documentation on this Beta release can be found here.
- Next-Gen Identity API for JBoss Portal is in public review. Check their documentation here.
eXo:
- eXo Portal 2.5.1, a maintenance release, is now available and has finalized its support of Right-To-Left languages like arabic. See video here.
- eXo Portal and Spring Security: This is a very nice documentation released in January about how to integrate Spring Security 2.5.x into eXo Portal.
Other portal and Java related quick news:

Jan-26: JSR-299: WebBeans is dead. Long live Java Contexts and Dependency Injection!

Jan-23: Java EE 6 has gone Public Review!
- WebBeans (Gavin King, JSR 299, @TA )
- Bean Validation (Emmanuel Bernard, JSR 303, @TA )
- JSF 2.0 (Ed Burns & Roger Kitain, JSR 314, @TA )
- Servlet 3.0 (Rajiv Mordani, JSR 315, @TA )
- JPA 2.0 (Linda DeMichiel, JSR 317, @TA )
- EJB 3.1 (Ken Saks, JSR 318 @TA )
- JCA 1.6 (Binod PG & Sivakumar Thyagarajan, JSR 322, @TA )

Jan-18: Performance Analysis: VisualVM 1.1 has been released!
Dec-16: JBoss Application Server 5.0 has gone GA. So JBoss has finally joined the list of "Java EE 5 Compatible Implementations".
NetBeans:
- Portal Pack 3.0 Beta is now available
IBM: no portal news
Eclipse: no portal news
IntelliJIDEA: no portal news