Usare JBoss JPA 2.1 e Hibernate 4.3 su JBoss EAP 6.

2 (JBoss
As 7) e integrare Spring (JPA Spring e JBoss Integration )
Oggi parleremo di come integrare Spring e JBoss AS 7 (JBoss EAP 6). Dato che la nuova
versione di JBoss ignetta in modo implicito I propri moduli OSGi (logging, JPA, Hibernate), pu
essere a volte ripetitivo ed inutile doverli gestire a livello applicativo. Quindi presentiamo un
esempio su come integrare Spring con JBoss lasciando che JBoss ignetti le proprie librerie,
oppure usando JPA 2.1 che non ancora nativamente supportato da JBoss, e si dovr
impedire che JBoss implementi linjection automatic di JPA e Hibernate.

Step 1 : Persistence.xml
La creazione del file persistence.xml dipender dal fatto se lEntity Manager verr gestito dal
container (JBoss, qundi JPA 2.0) o da Spring (nel qual caso useremo JPA 2.1).

- JBoss gestisce lEntityManager: Uso di JPA 2.0

In questo caso, il Transaction Type deve essere JTA. JBoss EAP 6.2 (basato su JBoss 7.3)
viene rilasciato con JPA2.0 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

<persistence version="2.0"
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">
<persistence-unit name="module_enterprise" transaction-type="JTA">
<jta-data-source>java:/myDS</jta-data-source>
<properties>
<property name="hibernate.dialect"
value="org.hibernate.dialect.PostgreSQLDialect"/>
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="validate"/>
</properties>
</persistence-unit>
</persistence>

- Spring gestisce l EntityManager: Uso di JPA2.1

Avendo bisogno di escludere i moduli OSGi di JPA e di Hibernate rilasciati con la versione
originale di JBoss, e volendo usare JPA2.1, abiamo bisogno di :
- Creare un file jpa-persistence.xml. In questo caso, dove non vogliamo che JBoss ignetti le
proprie librerie, meglio cambiare il nome del file che di norma si chiama persistence.xml
( JBoss caricher il proprio modulo JPA in modo implicito se intercetta un file chiamato
persistence.xml).
- Usare RESOURCE_LOCAL e non JTA, se non avete realmente bisogno di accedere a
molteplici data sources (usate JTA in quel caso): Usando RESOURCE_Local quando il
persistence unit inizializzato da Spring o lapplicazione basata su un servlet-continer.

- Usere "org.hibernate.jpa.HibernatePersistenceProvider" come provider

- Aggiungere la seguente property al file persitence.xml (jpa-persistence.xml)
<property name="jboss.as.jpa.managed" value="false"/>
In effetti, in accord con le JBoss Reference, jboss.as.jpa.managed pu essere impostato
a false per disabilitare laccesso JPA gestito dal container al persistence
unit. Il default true, che abilita laccesso JPA gestito dal al persistence unit.
Tipicamente viene impostato a false per Seam 2.x o le applicazione basate su
Spring.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

<persistence version="2.1" 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_1.xsd">
<persistence-unit name="mdd_module_enterprise" transactiontype="RESOURCE_LOCAL">
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<jta-data-source>java:/myDS</jta-data-source>
<properties>
<property name="jboss.as.jpa.managed" value="false" />
<property name="hibernate.dialect"
value="org.hibernate.dialect.PostgreSQLDialect"/>
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="validate"/>
</properties>
</persistence-unit>
</persistence>

Un modo pi drastico di escludere i moduli OSGi che JBoss utilizza di default attraverso il file
jboss-deployment-structure.xml che sar di questo tipo:

<?xml version="1.0"?>
<jboss-deployment-structure xmlns="urn:jboss:deploymentstructure:1.0">
<deployment>
<exclusions>
<module name="javax.persistence.api" />
<module name="org.hibernate" />
</exclusions>
</deployment>
</jboss-deployment-structure>
Questa una modalit in best-practice per utilizzare delle librerie con version diverse da quelle di
JBoss senza dover sovrascrivere la cartella /modules.

Step 2 : Spring Configuration

Stessa cosa qui:

- JBoss gestisce lEntityManager o EntityManagerFactory e Spring hanno solo il

riferimento ad un jndi name. Il Transaction Type deve essere JTA.
LApplicationContext sar cos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<?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:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
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/jee
http://www.springframework.org/schema/jee/spring-jee.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- post-processors for all standard config annotations -->
<tx:annotation-driven />
<context:annotation-config />
<context:component-scan base-package="org.test"/>
<jee:jndi-lookup id="myDataSource" jndi-name="java:/myDS"/>
<jee:jndi-lookup id="entityManagerFactory_module" jndiname="java:comp/env/test/myfact" expectedtype="javax.persistence.EntityManagerFactory"/>
<tx:jta-transaction-manager/>
</beans>

In questo caso, lapplicazione usa una persistence unit deployata sul server. Quindi le
classi javax.persistence ed il persistence provider (Hibernate) sono contenuti allinterno di
moduli in JBoss
(in JBOSS_HOME\modules\system\layers\base\javax\persistence\api\main) e aggiunti
automaticamente dallapplicazione durante il deploy (Quando viene intercettato il file
persistence.xml o il persistence-unit, JBoss ignetta Hibernate in modo implicito).
Usando una persistence unit deploata sul server, dovrete anche dichiarare un JNDI
persistence context nel Web.xml:
NB: Il nome della persistence-unit specificato nel web.xml deve essere lo stesso di
quello dichiarato nel file persitence.xml (<persistence-unit name="module_enterprise")
1
2
3
4
5
6
7
8

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

<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" metadata-complete="true">
<listener>
<listener-

9
10
11
12

class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<persistence-unit-ref>
<persistence-unit-ref-name>test/myfact</persistence-unit-ref-name>
<persistence-unit-name>module_enterprise</persistence-unit-name>
</persistence-unit-ref>
</web-app>

Notate che il nome che abbiamo dichiarato nell applicationcontext java:comp/env/test/myfact, e nel web.xml, dobbiamo mettere solo test/myfact
Se Spring non pu trovare il transaction Manager di default di JBoss, pu essere esplicitato
come spiegato in questo articolo.
- Spring gestisce lEntityManager.
Usando JPA2.0, possiamo abilitare il modulo JPA incluso allinterno di JBoss ed usare la prima
possibilit. Ma abbiamo disabilitato il modulo OSGi JPA e deciso di lavorare con JPA2.1 (E
vogliamo che Spring gestisca il persistence unit), quindi lEntityManagerFactory verr definito
usando Spring.
Il nostro applicationContext sar:

Questo tutto, adesso dovreste essere in grado di integrare JBoss e Spring sia abilitando la
gestione del persistence unit da parte di JBoss, o lasciandolo fare a Spring e ESCLUDENDO I
MODULI JBOSS JPA e Hibernate.