JDBC es el API Java para el acceso a base de datos. Es un solución difícil debido varios inconvenientes o limitaciones:

• Trabaja a bajo nivel.
• Como consecuencia de lo anterior, la gestión del ciclo de vida de los recursos (conexiones, resultSet, etc.) no esta exenta de dificultades.
• La gestión de transacciones puede resultar pesada.
• La gestión de excepciones.
• El cambio del modelo de datos afecta al cambio de sentencias, que obligan a modificar diversos archivos de código fuente y a la recompilación. Es necesario centrarse en estrategias más declarativas y menos programáticas.

Todo lo anterior hace que una sólución basada en el puro JDBC resulte difícil de mantener. Por ello se ha popularizado el uso de frameworks como iBatis o Hibernate. Spring puede trabajar con otros frameworks, fiel a su filosofía no invasiva.

Ya sabemos la importancia de que una aplicación no gestione de forma directa la creación y liberación de conexiones, sino que debe utilizar un pool de conexiones que actúa como un sistema de caché de conexiones.

La solución clásica en JDBC implica definir la fuente de datos (DataSource) en server.xml y definir su correspondiente entrada en web.xml. La aplicación usa JNDI para buscar y acceder a la fuente de datos, es decir, al pool de conexiones.

Con Spring la fuente de datos se puede definir como un bean de nuestro contexto de aplicación. En nuestro siguiente ejemplo usaremos el BasicDataSource de Apache:

<?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:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
		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/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
			http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
			http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<!-- Las propiedades del dataSource tienen como valor properties -->
	<bean id="dataSource" class="org.apache.tomcat.dbcp.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}"/>
		<property name="url" value="${jdbc.url}"/>
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	...
</beans>

En este ejemplo hay que destacar:

• Necesitamos tener commons-logging-api.jar (ver Tomcat)
• Las propiedades de la fuente de datos hacen referencia a un archivo properties, por ejemplo:

	jdbc.driverClassName=com.mysql.jdbc.Driver
	jdbc.url=jdbc:mysql://localhost:3306/basedatos?autoReconnect=true
	jdbc.username=user
	jdbc.password=pass
	

El archivo de propiedades se carga como un bean ("location" hace referencia al lugar del archivo properties):

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location">
       <value>/WEB-INF/jdbc.properties</value>
    </property>
</bean>

Existe la posibilidad de usar properties de forma programática:

	public GestorCarga() throws Exception {
		XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("../application-context.xml"));
		PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
		cfg.setLocation(new ClassPathResource("../configuracion.properties"));
		cfg.postProcessBeanFactory(factory);
	}

Este código inyecta las properties (cfg) en la factoria, cuando se han cargado las definiciones de bean (pero todavía no se han instanciado).