Creación de Datasource en JBoss 7

Retomo mi blog, luego de un corto periodo de vacaciones. 

Durante un repaso desarrollando una aplicación empresarial para un curso de JEE, usando JBoss 7 como servidor de aplicaciones, debí enfrentarme a realizar un datasource para asociarlo al persistence_unit de mi proyecto EJB. Haciéndolo me hice consciente de cómo varía con respecto a las previas versiones de JBoss, me decidí entonces crear este artículo documentando 2 medios, uno que para mí es "el fácil" y el otro, "el difícil".

1. La forma fácil

• Registrar el driver.

Simplemente se debe ubicar la librería en standalone/deployments

Ubicar el driver de la fuente de datos en standalone/deployments

• Arrancar el servidor.

En la consola se puede observar que el driver ha sido cargado:

14:38:59,757 INFO  [org.jboss.as.server.deployment] (MSC service thread 1-1) Starting deployment of "ojdbc6.jar" 

14:39:00,012 INFO  [org.jboss.as.connector.deployers.jdbc] (MSC service thread 1-14) Deploying JDBC-compliant driver class oracle.jdbc.OracleDriver (version 11.2) 

14:39:00,039 INFO  [org.jboss.as.server.controller] (DeploymentScanner-threads - 2) Deployed "ojdbc6.jar"

• Crear el datasource desde la consola de administración, por defecto localhost:9990/console/

Ubicar el botón "Nuevo Datasource"

• Darle nombre al datasource

Dar un nombre al datasource y a JNDI

• Seleccionar el nuevo Driver

El driver aparece en el listado

• Ingresar los datos de conexión y finalizar.

Diligenciar los datos de conexión

2. La forma difícil

Iba a nombrarla "manual", pero en ninguno de los 2 casos el datasource se genera "automáticamente", simplemente la nombré difícil debido a que requiere pasos más tediosos. 

• Crear un nuevo módulo para el driver que usará el datasource.

JBoss 7 hace gala de su diseño modular para aislar ciertos servicios de la aplicación que se está desplegando. El caso del datasource no es una excepción, este será soportado por un módulo. Para este ejemplo creé el módulo para soportar un datasource basado en Postgresql.
Para crear un módulo se debe crear una estructura de carpetas, bajo la carpeta module, donde lo más importante es que incluya una con el nombre main. 

En mi caso creé la estructura org/postgresql/main

Crear la estructura de carpetas para el módulo

• Incluir libería y archivo de configuración.

Dentro de dicha estructura, en la carpeta main, ubicar el driver jdbc de la fuente de datos y crear un nuevo archivo con el nombre module.xml.

module.xml y librería

• Registrar el módulo.

El archivo module.xml contiene la información acerca del módulo que soportará el datasource. El archivo debe contener las siguientes líneas, donde es importante resaltar la ruta relativa donde se encuentra el .jar del driver jdbc y el nombre del módulo que lo contiene:

<module xmlns="urn:jboss:module:1.0" name="org.postgresql">

<resources>

<resource-root path="postgresql-9.3-1100.jdbc3.jar"/>

</resources>

<dependencies>

<module name="javax.api"/>

<module name="javax.transaction.api"/>

</dependencies>

</module>

• Registrar el Datasource

Ya con el módulo creado, es necesario registrar el datasource. Esto se hace en el archivo de configuración de JBoss, en mi caso standalone.xml, el cual se encuentra ubicado en standalone/configuration/. Se incluye entonces la referencia del driver y la definición específica dentro de los tags <driver><datasources>.

<datasources>

<datasource jndi-name="[cadena jndi, generalmente java:jboss/fuente]" pool-name="postgresDS" enabled="true" jta="false" use-java-context="true">

<connection-url>jdbc:postgresql://[server]:5432/[database]</connection-url>

<driver-class>org.postgresql.Driver</driver-class>

<driver>postgresql</driver>

<pool>

<min-pool-size>2</min-pool-size>

<max-pool-size>20</max-pool-size>

<prefill>false</prefill>

<use-strict-min>false</use-strict-min>

<flush-strategy>FailingConnectionOnly</flush-strategy>

</pool>

<security>

<user-name>[usuario]</user-name>

<password>[password]</password>

</security>

<validation>

<validate-on-match>false</validate-on-match>

<background-validation>false</background-validation>

<useFastFail>false</useFastFail>

</validation>

<statement>

<prepared-statement-cache-size>0</prepared-statement-cache-size>

</statement>

</datasource>

<drivers>

<driver name="postgresql" module="org.postgresql"/>

</drivers>

</datasources>

3. Referenciar en el persistence_unit.

Para lograrlo, simplemente se relaciona la cadena jndi utilizada en el archivo META-INF/persistente.xml (descriptor para JPA) y se detalla el tag persistence_unit:

<persistence-unit name="persistenceunit" transaction-type="JTA">

<jta-data-source>java:jboss/fuente</jta-data-source>

</persistence-unit>

Al reiniciar el server, el datasource está registrado y funcional.

Note que al finalizar cualquiera de las dos formas, el archivo standalone.xml es modificado y mientras la primera registra el datasource a partir del driver en el contexto, la segunda lo registra a partir de la definición de un módulo.