Their project page starts off with showing the Maven repositories and dependency descriptors (in case you are using Maven). Obviously the first thing is to replace the hades artifact by the spring-data-jpa artifact.

Domain classes, JPA entities

The project’s domain classes implement the org.synyx.hades.domain.Persistable interface which has to be replaced by org.springframework.data.domain.Persistable (takes a single generics parameter for the id type).

CRUD repositories

DAO interfaces extending org.synyx.hades.dao.GenericDao have to be modified to extend org.springframework.data.repository.CrudRepository. With this modification you will face a couple of compile problems. read*-methods have been renamed to find*-methods. Also you are loosing the paging and sorting capable find* – methods (which I didn’t use). If those are required then extend the org.springframework.data.repository.PagingAndSortingRepository interface.

find* – methods now return iterables rather than list types requiring minor adjustments to existing codebase. To get around this, the interface can also extend from JpaRepository. Using this base interface hands you a pretty powerful DAO that goes far beyond a simple CRUD repository.

CRUD repository instantiation

When I started off with hades many month ago I used an explicit XML-based configuration of DAO components.

<bean id="addressDao" class="org.synyx.hades.dao.orm.GenericDaoFactoryBean" p:daoInterface="at.martinahrer.training.spring.jpa.dao.hades.AddressDao" />

For migration the factory bean class has to be changed:

<bean id="addressDao" class="org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean" p:daoInterface="at.martinahrer.training.spring.jpa.dao.hades.AddressDao" />

With these changes in place all tests were showing the green bar again. However, today I would recommend using repository namespace http://www.springframework.org/schema/data/jpa which significantly reduces the amount of configuration needed by utilizing class path scanning to detect repository components.

<repository:repositories base-package="at.martinahrer.training.spring.jpa.dao" />

Certainly you might encounter more steps during migration depending on the features you have used from the old hades code base. In my case I only had used named JPA queries which just continued to work like before.

A simple use-case showing how to detect classes annotated as components

This use-case is using a few Spring APIs and some home grown code that controls resource matching (ClassResourceResolver and AnnotationMetadataMatcher).

import java.io.IOException;

import org.junit.Assert;
import org.junit.Test;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import org.springframework.util.ClassUtils;

public class ClassResourceResolverTest {
	@Test
	public void testSelect() throws IOException {
		// given
		ClassResourceResolver scanner = new ClassResourceResolver(
				ClassUtils.convertClassNameToResourcePath(AComponent.class.getPackage().getName()));
		final MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(
				new PathMatchingResourcePatternResolver());

		// when
		String[] classNames = scanner.select(new AnnotationMetadataMatcher(metadataReaderFactory, false,
				Component.class));
		// then
		Assert.assertArrayEquals(new String[] { AComponent.class.getName() }, classNames);
		Assert.assertTrue(metadataReaderFactory.getMetadataReader(classNames[0]).getAnnotationMetadata()
				.isAnnotated(Component.class.getName()));
	}
}

@Component
class AComponent {
}

@Repository
class ARepository {
}

ClassResourceResolver is doing the resource matching all from a set of resource paths

	public String[] select(ClassResourceMetadataMatcher matcher) throws IOException {
		List<String> result = new ArrayList<String>();

		for (String path : resourcePath) {
			String resourcePattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + path + "/**/*.class";
			Resource[] resources = this.resourcePatternResolver.getResources(resourcePattern);
			for (Resource resource : resources) {
				if (resource.isReadable()) {
					MetadataReader reader = matcher.match(resource, resourcePatternResolver);
					if (reader != null) {
						result.add(reader.getClassMetadata().getClassName());
					}
				}
			}
		}
		return result.toArray(new String[result.size()]);
	}

A ClassResourceMetadataMatcher is looking at the annotations present on a class resource

	@Override
	public MetadataReader match(Resource resource, ResourceLoader resolver) throws IOException {
		for (Class<? extends Annotation> annotationType : annotationTypes) {
			MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
			if (new AnnotationTypeFilter(annotationType, considerMetaAnnotations).match(metadataReader,
					metadataReaderFactory)) {
				return metadataReader;
			}
		}
		return null;
	}

Under the hood Spring is using the ASM bytecode library for looking into the class files. Not that no class examined by the code above is actually loading any of the class objects so it is fairly lightweight and not filling up your perm gen space. Still you need to make up useful search paths so you don’t end up scanning through you full classpath.

The full code just is available as a gist

git clone git@gist.github.com:73f21e68d24032ad7672.git

Obviously java.io.EOFException: Chunk stream does not exist at page: 0 sounds like some temporary file data was corrupt. JobSchedulerStore creates a directory activemq-data/localhost/scheduler for storing scheduler data. Clean/delete that and it should be startable again. If you don’t need that then you are better off with completely deactivating that feature.

	<amq:broker useJmx="true" persistent="false" start="false" schedulerSupport="true">
		<amq:transportConnectors>
			<amq:transportConnector uri="${amq.brokerURL}" />
		</amq:transportConnectors>
	</amq:broker>

Also its helpful to disable automatic start of the queue container so the test can fully control it.

public class ServiceOperationsJmsProducerTest extends AbstractJUnit4SpringContextTests implements BrokerServiceAware {
	private BrokerService brokerService;

	@Test
	public void testProducer() throws Exception {
		try {
			brokerService.start();
			// do the testing
		} finally {
			brokerService.stop();
			brokerService.waitUntilStopped();
		}
	}

	@Override
	@Resource
	public void setBrokerService(BrokerService brokerService) {
		this.brokerService = brokerService;
	}
}

<plugin>
	<artifactId>maven-dependency-plugin</artifactId>
	<executions>
		<execution>
			<id>copy</id>
			<phase>process-sources</phase>
			<goals>
				<goal>copy</goal>
			</goals>
			<configuration>
				<artifactItems>
					<artifactItem>
						<groupId>org.springframework</groupId>
						<artifactId>spring-instrument</artifactId>
						<version>3.0.3.RELEASE</version>
					</artifactItem>
				</artifactItems>
			</configuration>
		</execution>
	</executions>
</plugin>

We have to pass in the weaving agent to surefire.

<plugin>
	<artifactId>maven-surefire-plugin</artifactId>
	<configuration>
		<argLine>-javaagent:${project.build.directory}/dependency/spring-instrument-3.0.3.RELEASE.jar</argLine>
	</configuration>
</plugin>

In the “Advanced” settings choose “Research in Motion” as vendor, “BlackBerry IP Modem (GSM)” as model, “a1.net” as APN!

Looks like with eclipse 3.6 that does not work anymore, I was not able to actually use a JAR file as location like I used to set this up with eclipse 3.4.
So I’m directly associating the AMQ namespace with the XML schema available from the AMQ project.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jms="http://www.springframework.org/schema/jms"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:amq="http://activemq.apache.org/schema/core"

	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms.xsd
		http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd">

	<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
		p:locations="classpath:jms.properties">
	</bean>
	<amq:broker useJmx="true" persistent="false">
		<amq:transportConnectors>
			<amq:transportConnector uri="${amq.brokerURL}" />
		</amq:transportConnectors>
	</amq:broker>
</beans>

Go to the eclipse XML catalog editor and add a custom entry:

Location: http://activemq.apache.org/schema/core/activemq-core-5.4.1.xsd
Key type: Schema location
Key: http://activemq.apache.org/schema/core/activemq-core.xsd

That tool performs the following steps

1. Detect the current software version from the artifact metadata that is embedded into any Maven-built artifact
2. Query Nexus for available artifacts for the installed software (identified by Maven groupId and artifactId).
3. Test if any of the available artfacts has a version number higher than the installed one
4. If a newer version is available then download it
5. Move the new version to the target directory (e.g. the deployment folder of the application server)

The Nexus REST url for a simple query for some artifact looks like http://localhost/nexus/service/local/data_index/repositories/releases/content?q=commons-lang. This query asks for the commons-lang artifact from the releases repository.

More URL schemes are documented here and there.

The result from this query is like (only the latest versions are included for brevity):

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

<search-results>
	<totalCount>5</totalCount>
	<from>-1</from>
	<count>-1</count>
	<tooManyResults>false</tooManyResults>
	<data>
		<artifact>

			<resourceURI>http://localhost/nexus/service/local/repositories/central/content/commons-lang/commons-lang/2.4/commons-lang-2.4.jar</resourceURI>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.4</version>
			<packaging>jar</packaging>
			<extension>jar</extension>

			<repoId>central</repoId>
			<contextId>Maven Central (Cache)</contextId>
			<pomLink>http://localhost/nexus/service/local/artifact/maven/redirect?r=central&g=commons-lang&a=commons-lang&v=2.4&e=pom</pomLink>
			<artifactLink>http://localhost/nexus/service/local/artifact/maven/redirect?r=central&g=commons-lang&a=commons-lang&v=2.4&e=jar</artifactLink>

		</artifact>
		<artifact>
			<resourceURI>http://localhost/nexus/service/local/repositories/central/content/commons-lang/commons-lang/2.4/commons-lang-2.4-sources.jar</resourceURI>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.4</version>
			<classifier>sources</classifier>

			<packaging>jar</packaging>
			<extension>jar</extension>
			<repoId>central</repoId>
			<contextId>Maven Central (Cache)</contextId>
			<pomLink></pomLink>
			<artifactLink>http://localhost/nexus/service/local/artifact/maven/redirect?r=central&g=commons-lang&a=commons-lang&v=2.4&e=jar&c=sources</artifactLink>

		</artifact>

	</data>
</search-results>

That only needs to be parsed using a SAX parser for extracting the most important elements. This is the Maven GAV, packaging, classifier, and the download url which are stored in a POJO. This POJO implements the algorithm for selecting the latest version by its compareTo method.

public class MavenArtifactMetadata implements Comparable<MavenArtifactMetadata> {
	private String groupId;
	private String artifactId;
	private String version;
	private String resourceURI;
	private String packaging;
	private String classifier;

	@Override
	public int compareTo(MavenArtifactMetadata o) {
		if (!this.groupId.equals(o.groupId) || !this.artifactId.equals(o.artifactId)) {
			return -1;
		}
		return versionCompareTo(o.version);
	}

	int versionCompareTo(String version) {
		Integer[] thatVersion = versionComponents(version);
		Integer[] thisVersion = versionComponents(this.version);
		int length = Math.min(thatVersion.length, thisVersion.length);
		for (int i = 0; i < length; i++) {
			if (thatVersion[i].equals(thisVersion[i])) {
				continue;
			}
			return thisVersion[i].compareTo(thatVersion[i]);
		}
		return thisVersion.length - thatVersion.length;
	}

	Integer[] versionComponents(String version) {
		String[] splitted = StringUtils.delimitedListToStringArray(version, ".");
		if (splitted.length>0 && splitted[splitted.length-1].endsWith("-SNAPSHOT")) {
			splitted[splitted.length-1]=splitted[splitted.length-1].replaceAll("-SNAPSHOT", "");
		}
		Integer[] components = new Integer[splitted.length];
		for (int i = 0; i < splitted.length; i++) {
			components[i] = (Integer.valueOf(splitted[i]));
		}
		return components;
	}
}

While implementing the download part I had learned an important lesson. For downloading and moving large files it is much more efficient to use the Java NIO API.

public class EntityFormController<T> extends FormController<T> {
	private Class<T> entityClass;

	public String create() {
		Object instance=getEntityClass().newInstance();
		...
	}
}

So for every specific instance of the property entityClass must be initialized explicitely by implementing a proper constructor, using dependency injection, etc.

public class AddressFormController extends EntityFormController<Address> {
	public class AddressFormController() {
		super(Address.class);
	}
}

This is kind of violating the DRY principle. The actual type is already given through the type parameter. So I was trying to eliminate this few lines of code and come up with a solution that can analyze any parameterized type from a class declaration (super class hierarchy + interfaces).

/**
 * @author Martin Ahrer
 *
 */
public class GenericTypeArgumentExtractor {
	private final Class<?> candidateClass;

	public GenericTypeArgumentExtractor(Class<?> candidateClass) {
		super();
		this.candidateClass = candidateClass;
	}

	public Class<?>[] getGenericTypeArguments(Class<?> clazz) {
		// TODO: hopefully clazz.getGenericSuperclass() == clazz.getSuperclass()
		Type[] types = Arrays.copyOf(clazz.getGenericInterfaces(), clazz.getGenericInterfaces().length
				+ (clazz.getGenericSuperclass() != null ? 1 : 0));
		if (clazz.getGenericSuperclass() != null) {
			types[types.length - 1] = clazz.getGenericSuperclass();
		}
		// Iterate all types from which the clazz inherits. i.e all generic
		// interfaces and the generic super class.
		for (Type type : types) {
			Class<?>[] arguments = getGenericTypeArguments(type);
			if (arguments != null) {
				return arguments;
			}
		}
		return null;
	}

	private Class<?>[] getGenericTypeArguments(Type type) {
		if (type instanceof ParameterizedType) {
			ParameterizedType parameterizedType = (ParameterizedType) type;
			if (isCandidate(parameterizedType)) {
				Type[] arguments = parameterizedType.getActualTypeArguments();
				Class<?>[] result = new Class<?>[arguments.length];
				for (int i = 0; i < result.length; i++) {
					result[i] = (Class<?>) (arguments[i] instanceof ParameterizedType ? ((ParameterizedType) arguments[i])
							.getRawType()
							: arguments[i]);
				}
				return result;
			}
		} else if (type != null) {
			Class<?>[] result = getGenericTypeArguments((Class<?>) type);
			return result;
		}
		return null;
	}

	/**
	 * Detects the type from which we want the type arguments. Can be overridden
	 * in subclasses.
	 *
	 * @param type
	 *            the parameterized type to check for.
	 * @return true if type arguments of the passed type are reqeusted.
	 */
	protected boolean isCandidate(ParameterizedType type) {
		return candidateClass.isAssignableFrom((Class<?>) type.getRawType());
	}
}

Using the above class for extracting type parameters would return an array containing the Address class object.

Class[] genericTypeArguments = new GenericTypeArgumentExtractor(EntityFormController.class)
		.getGenericTypeArguments(AddressFormController.class);

In many projects I found the situation that the client didn’t want to pull in another framework just for that little feature. Also for distributing responsibilities, I usually have multiple managed beans per view. So another “artificial” page bean is required just for controlling the others. So I came up with a fairly simple solution that allows to directly invoke those life-cycle callbacks on any managed bean used on a single page.

The <f:phaseListener> tag allows to bind a JSF PhaseListener. You can even bind multiple phase listeners (one for each managed bean; you get the idea).

<f:phaseListener binding="#{bean1.viewControllerPhaseListener}" />
<f:phaseListener binding="#{bean2.viewControllerPhaseListener}" />

So each of the beans would provide a reference to a phase listener that would take care to perform the proper processing for the bean itself. Every bean then would use a set of annotations (like @PreRenderView, @PostRestoreView, @PreInvokeApplication, etc.) to mark those methods that should be called during a specific phase.

public class EntityListController<T> {
	private volatile ViewControllerPhaseListener viewControllerPhaseListener;

	public ViewControllerPhaseListener getViewControllerPhaseListener() {
		if (viewControllerPhaseListener == null) {
			viewControllerPhaseListener = new ViewControllerPhaseListener(this);
		}
		return viewControllerPhaseListener;
	}

	@PreRenderView
	public void updateModel() {
		...
	}

	...

The code above is partially showing a base class from which many of my managed bean are subclassed. Key is the ViewControllerPhaseListener which hides all of the details of doing the reflection job for finding (and then caching) the annotated methods to invoke during a specific phase. For brevity I’m showing only the key elements of this class.

public class ViewControllerPhaseListener implements PhaseListener {
	private final Object target;

	public ViewControllerPhaseListener(Object target) {
		super();
		this.target = target;
	}

	private final Class<Annotation>[] LIFECYCLE_ANNOTATIONS = new Class[] { PreRenderView.class, PostRestoreView.class,
		PreInvokeApplication.class };

	private final static Map<Class<?>, Map<Class<? extends Annotation>, Set<Method>>> controllerClasses = new ConcurrentHashMap<Class<?>, Map<Class<? extends Annotation>, Set<Method>>>();

	static Map<Class<?>, Map<Class<? extends Annotation>, Set<Method>>> getControllerClasses() {
		return controllerClasses;
	}

	@Override
	public void beforePhase(PhaseEvent event) {
		if (PhaseId.RENDER_RESPONSE.equals(event.getPhaseId())) {
			invokeAnnotatedMethod(PreRenderView.class, target);
		} else if (PhaseId.INVOKE_APPLICATION.equals(event.getPhaseId())) {
			invokeAnnotatedMethod(PreInvokeApplication.class, target);
		}
	}

	@Override
	public void afterPhase(PhaseEvent event) {
		if (PhaseId.RESTORE_VIEW.equals(event.getPhaseId())) {
			invokeAnnotatedMethod(PostRestoreView.class, target);
		}
	}

	@Override
	public PhaseId getPhaseId() {
		return PhaseId.ANY_PHASE;
	}

	void invokeAnnotatedMethod(Class<? extends Annotation> annotation, Object targetObject) {
		if (!controllerClasses.containsKey(targetObject.getClass())) {
			registerController(targetObject.getClass());
		}
		for (Method method : controllerClasses.get(targetObject.getClass()).get(annotation)) {
			try {
				method.invoke(targetObject);
			} catch (Exception e) {
				LOGGER.error("Error invoking @{} annotated method {} on {}", new Object[] { annotation.getSimpleName(),
						method, targetObject });
				throw new RuntimeException(e);
			}
		}
	}

	public void registerController(Class<?> controllerClass) {
		// do the reflection work
	}
}

In a few projects this has proven to be quite versatile. Currently I have a couple of interesting phase listener components, from the simple DebugPhaseListener to the OpenTransactionInViewPhaseListener. I can just throw them into any view as they are required.