Load-Time Weaving for Spring-DM with JPA/EclipseLink [step1]

Martin Lippert has created org.eclipse.equinox.weaving.springweaver (version 0.1.1) bundle to manage Spring LoadTimeWeaver into OSGi context (Equinox only) which is based on Equinox Aspects.

I have tried to use org.eclipse.equinox.weaving.springweaver (version 0.1.1) into JPA context with EclipseLink, but weaving doesn’t work very well ( see SpringWeaver (0.1.1) -JPA problem for more information). I think (but not sure) that Martin Lippert has tested org.eclipse.equinox.weaving.springweaver only with Spring @Configurable.

So I decided to create a new version of org.eclipse.equinox.weaving.springweaver (version 0.1.2) to manage LoadTimeWeaver into JPA context, that you can find on Dynaresume SVN – SpringWeaver.

SpringWeaver (0.1.1) -JPA problem

EclipseLink weaving

EclipseLink is ORM which manage several features like « lazy-loading« . Here a basic sample of JPA lazy-loading done for the login property with @Basic(fetch=FetchType.LAZY) JPA annotation :

@Entity
@Table(name = "T_USER")
public class User {

...
	@Column(name = "USR_LOGIN_C")
	@Basic(fetch=FetchType.LAZY)
	private String login;

	public String getLogin() {
		return login;
	}

	public void setLogin(String login) {
		this.login = login;
	}
...
}

If User#getLogin() is called, SQL Select Query will be executed to get the value of the property into Database (only if login property has been not already loaded).

To manage « lazy-loading », EclipseLink transform the bytecode of the Domain class which must be persisted to add listener into getter/setter and call EclipseLink code (open connection…). (I think it’s more elegant solution than Hibernate which use CGLIB/Javasssit Proxy, and it works better into OSGi context). Bytecode transformation is done with Java Agent into NOT OSGi context and with Equinox Hook into OSGi context. So with EclipseLink, every Domain bundle classes must be transformed (« woven »).

To check if EclipseLink weaving is done, you can test if the instance of domain class implements the EclipseLink interface org.eclipse.persistence.internal.weaving.PersistenceWeaved :

User  user = ...
if (user instanceof PersistenceWeaved) {
  // Weaving was done
} 

SpringWeaver (0.1.1) -JPA problem

The problem with org.eclipse.equinox.weaving.springweaver (version 0.1.1) into OSGi context is that the weaving classes is done ONLY for classes belong to the bundle which declare the LoadTimeWeaver bean :

<bean class="org.eclipse.equinox.weaving.springweaver.EquinoxAspectsLoadTimeWeaver"/>

Into JPA context, you have :

• one or several « Domain Bundle » which contains domain (model) classes.
• a « JPA Bundle » which contains :
  • JPA persistence.xml
  • declare JPA entityManagerFactory bean
  • declare org.eclipse.equinox.weaving.springweaver.EquinoxAspectsLoadTimeWeaver bean (which is used by entityManagerFactory bean).

Into JPA context it’s « Domain Bundle » which must be woven, but EquinoxAspectsLoadTimeWeaver is declared into JPA Bundle (only classes from JPA Bundle can be woven).

If you use SpringWeaver (0.1.1) with EclipseLink, EquinoxAspectsLoadTimeWeaver allow you to avoid having Spring LoadTimeWeaver error :

But domain classes weaving is not done! It’s the same result than when you deactivate weaving EclipseLink with eclipselink.weaving property :

<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
...		
	<property name="jpaProperties">
		<bean id="jpaProperties"
			class="org.springframework.beans.factory.config.PropertiesFactoryBean">
			<property name="properties">
				<props>
					<prop key="eclipselink.weaving">true</prop>
				</props>
			</property>
		</bean>
	</property> 
...

SpringWeaver (0.1.2) -JPA solution

The solution is that the weaving must be done for the whole classes of each bundles. I have managed that into the SpringWeaver (0.1.2) by adding weaverScope property into EquinoxAspectsLoadTimeWeaver.

weaverScope=BUNDLE

If you declare EquinoxAspectsLoadTimeWeaver like this :

<bean class="org.eclipse.equinox.weaving.springweaver.EquinoxAspectsLoadTimeWeaver">
  <property name="weaverScope" value="BUNDLE" />
</bean>

It means that the weaving is done ONLY for the classes belong to the bundle which declare Spring bean EquinoxAspectsLoadTimeWeaver. BUNDLE weaverScope is the default value, so you can write just :

<bean class="org.eclipse.equinox.weaving.springweaver.EquinoxAspectsLoadTimeWeaver">
</bean>

weaverScope=APPLICATION

If you declare EquinoxAspectsLoadTimeWeaver like this :

<bean class="org.eclipse.equinox.weaving.springweaver.EquinoxAspectsLoadTimeWeaver">
  <property name="weaverScope" value="APPLICATION" />
</bean>

It means that the weaving is done for the whole classes of each bundles.

SpringWeaver (0.1.2) – JPA Eclipselink – Example

You can find a basic sample with EclipseLink and EquinoxAspectsLoadTimeWeaver (0.1.2) on Dynaresume SVN – SpringWeaver. You will find a Domain bundle and JPA Bundle. Here the entityManagerFactory bean decalaration :

<!-- entityManagerFactory created before DAO -->
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
                ...
		<property name="loadTimeWeaver">
			<bean
				class="org.eclipse.equinox.weaving.springweaver.EquinoxAspectsLoadTimeWeaver">
				<property name="weaverScope" value="APPLICATION" />
			</bean>
		</property>
	</bean>

Here the Spring XML file module-context.xml used into the bundle JPA org.dynaresume.dao.jpa.eclipselink :

<?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:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<!-- entityManagerFactory created before DAO -->
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="persistenceUnitName" value="dynaresume" />
		<property name="dataSource" ref="dataSource" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter">
				<property name="database" value="H2" />
				<property name="generateDdl" value="false" />
				<property name="showSql" value="true" />
			</bean>
		</property>
		<property name="loadTimeWeaver">
			<bean
				class="org.eclipse.equinox.weaving.springweaver.EquinoxAspectsLoadTimeWeaver">
				<property name="weaverScope" value="APPLICATION" />
			</bean>
		</property>
	</bean>

	<bean id="userDAO" class="org.dynaresume.dao.jpa.UserDAOJpa"></bean>

	<bean
		class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

	<tx:annotation-driven transaction-manager="txManager" />

	<bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>

</beans>

Into [step2], I explain how test and describe the content of SpringWeaver (0.1.2) – JPA Eclipselink – Example.

SpringWeaver (0.1.2) – Recipe

To use SpringWeaver (0.1.2), you must follow several rules :

1. only the bundle org.eclipse.equinox.weaving.hook from Equinox Aspects is required. Indeed this Equinox Hook (fragment linked to org.eclipse.osgi bundle) doesn’t depends on AspectJ. So you can use SpringWeaver without AspectJ.
2. org.eclipse.equinox.weaving.springweaver bundle must be started (Start level=3) BEFORE the another bundles which use Domain classes which must be woven. Once a Class is loaded, woven cannot be applied.
3. the launch must add to the JVM parameters the content :

   -Dosgi.framework.extensions=org.eclipse.equinox.weaving.hook

4. with PDE, the bundle org.eclipse.osgi must be imported (as binary) into the workspace.
5. don’t use <context:load-time-weaver like this :

   <context:load-time-weaver class="org.eclipse.equinox.weaving.springweaver.EquinoxAspectsLoadTimeWeaver"/>

6. DAO must be declared AFTER the entityManagerFactory, otherwise the Domain classes will be loaded (by the DAO) before the creation of the entityManagerFactory and Domain classes will not be woven.

You can read [step2] article.