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

Am 4.Mai 2011 gibt es erstmals in Österreich einen Git Workshop mit Matthew McCullough (offizieller GitHub Trainer) und somit eine einmalige Gelegenheit zu erfahren was denn hinter dem Erfolg von Git steckt.

• mit Matthew McCullough
• am 4. Mai 2011, von 9:00-16:30
• Spitz Hotel – Raum “Round Table 2”
  Fiedlerstrasse 6, 
4040 Linz
  http://
www.spitzhotel.at
• Trainingsprogramm (Broschüre)
• €330,00 (zuzüglich Mwst.)

Anmeldung per EMail (mit Name und Adresse des anzumeldenden Teilnehmers) an office@martinahrer.at.
 Zum Workshop in Englisch werden maximal 20 Teilnehmer zugelassen, ein eigener Laptop ist mitzunehmen.

Anmeldung von Gruppen ab 3 Personen zu ermäßigtem Preis auf Anfrage. Im Preis enthalten sind Getränke sowie ein Brötchenbuffet zu Mittag! Ermäßigtes Parken in der Hoteltiefgarage ist möglich.

Zur Anmeldung

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

Anmeldung

Apache Tapestry ist ein komponentenorientiertes Web-Framework zur Entwicklung von skalierbaren Web-Anwendungen in Java. In dieser Session wird Tapestry vorgestellt und ein innovativer Ansatz zur Entwicklung von Web 2.0 – Anwendungen diskutiert. Es wird demonstriert, wie Tapestry 5 die Mächtigkeit von Java mit der Einfachheit und der Produktivität von Scripting-Lösungen wie Ruby on Rails oder Django kombiniert. Mit Tapestry bekommt man das Beste aus den beiden Welten. Tapestry stellt eine Menge von Features zur Steigerung der Produktivität bereit, die ich in einigen Demos zeigen werde. Weiterhin wird der Vorteil eines komponentenorientierten Frameworks wie Tapestry erläutert.

Dipl.-Informatiker Igor Drobiazko ist Committer und PMC von Apache Tapestry. Igor verfügt über extensive Erfahrung in Web-Entwicklung, OSGi, Test-Frameworks und JEE-Architekturen. Er hat das erste deutschsprachige Buch über Tapestry 5 geschrieben und arbeitet gerade an einer Übersetzung seines Buches für Manning Publications. Igor hält Vorträge über das Framework und bloggt auf http://tapestry5.de/.

Agenda

Tapestry-Schnelleinstieg

- Überblick über Tapestry
- Aufsetzen einer Entwicklungsumgebung
- Erstellen der ersten Tapestry-Anwendung

Tapestry für Einsteiger

- Produktivität mit Tapestry während der Entwicklung: Live Class Realoding und Fehlerberichte
- Navigation zwischen Seiten
- Entwicklung von zustandsbehafteten Anwedungen
- Lokalisierung und Internationalisierung
- Entwicklung von Formularen, Validierung von Benutzereingaben
- Behandeln von Anfragen und Actions (Feuern und Behandeln von Ereignissen)

Tapestry für Fortgeschrittene

- Entwicklung von wiederverwendbaren Komponenten
- Ajax
- Integration von Hibernate, Java Persistenz API und Spring
- Entwicklung von Benutzerschnittstellen für JavaBeans

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.