Ejemplo de Spring JdbcTemplate

El Spring JdbcTemplate es la clase más importante en el paquete Spring JDBC.

Spring JdbcTemplate

• JDBC produce mucho código repetitivo, como abrir/cerrar una conexión a una base de datos, manejar excepciones de SQL, etc. Esto hace que el código sea extremadamente engorroso y difícil de leer.
• Implementar JDBC en el Framework Spring se encarga de trabajar con muchas operaciones de bajo nivel (abrir/cerrar conexiones, ejecutar consultas SQL, etc.).
• Gracias a esto, al trabajar con la base de datos en el Framework Spring, solo necesitamos definir los parámetros de conexión desde la base de datos y registrar la consulta SQL, el resto del trabajo es realizado por Spring.
• JDBC en Spring tiene varias clases (varios enfoques) para interactuar con la base de datos. El más común de estos es usando la clase JdbcTemplate. Esta es la clase base que gestiona el procesamiento de todos los eventos y conexiones de la base de datos.
• La clase JdbcTemplate ejecuta consultas SQL, itera sobre el ResultSet, y recupera los valores llamados, actualiza las instrucciones y llamadas a procedimientos, “atrapa” las excepciones, y las traduce en las excepciones definidas en el paquete org.springframwork.dao.
• Las instancias de la clase JdbcTemplate son seguras para subprocesos. Esto significa que al configurar una única instancia de la clase JdbcTemplate, luego podemos usarla para varios objetos DAO.
• Cuando se utiliza JdbcTemplate, la mayoría de las veces se configura en el archivo de configuración de Spring. Después de eso, se implementa utilizando un bean en las clases DAO.

Ejemplo de Spring JdbcTemplate

Veamos un programa de ejemplo de Spring JdbcTemplate. Aquí estoy usando la base de datos Postgresql, pero también puedes usar cualquier otra base de datos relacional, como MySQL y Oracle. Todo lo que necesitas es cambiar las configuraciones de la base de datos y debería funcionar. En primer lugar, necesitamos algunos datos de muestra para trabajar. Las consultas SQL a continuación crearán una tabla y la llenarán con algunos datos para que los usemos.

create table people (
id serial not null primary key,
first_name varchar(20) not null,
last_name varchar(20) not null,
age integer not null
);

insert into people (id, first_name, last_name, age) values
(1, 'Vlad', 'Boyarskiy', 21),
(2,'Oksi', ' Bahatskaya', 30),
(3,'Vadim', ' Vadimich', 32);

La imagen a continuación muestra la estructura final del proyecto en Eclipse.

Dependencias de Maven para Spring JDBC

Necesitamos las siguientes dependencias – `spring-core`, `spring-context`, `spring-jdbc` y `postgresql`. Si estás utilizando alguna otra base de datos relacional como MySQL, entonces agrega las dependencias correspondientes del controlador de Java. Aquí está nuestro archivo `pom.xml` final.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.journaldev.spring</groupId>
	<artifactId>JdbcTemplate</artifactId>
	<version>1.0-SNAPSHOT</version>
	<properties>
		<spring.framework>4.3.0.RELEASE</spring.framework>
		<postgres.version>42.1.4</postgres.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.postgresql</groupId>
			<artifactId>postgresql</artifactId>
			<version>${postgres.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.framework}</version>
		</dependency>
	</dependencies>

</project>

Configuración del Origen de Datos de Spring

El siguiente paso es crear una clase de configuración de Spring para definir el bean `DataSource`. Estoy utilizando configuración basada en Java, también puedes hacer esto usando un archivo de configuración XML de beans de Spring.

package com.journaldev.spring.config;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

@Configuration
@ComponentScan("com.journaldev.spring")
@PropertySource("classpath:database.properties")
public class AppConfig {

	@Autowired
	Environment environment;

	private final String URL = "url";
	private final String USER = "dbuser";
	private final String DRIVER = "driver";
	private final String PASSWORD = "dbpassword";

	@Bean
	DataSource dataSource() {
		DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
		driverManagerDataSource.setUrl(environment.getProperty(URL));
		driverManagerDataSource.setUsername(environment.getProperty(USER));
		driverManagerDataSource.setPassword(environment.getProperty(PASSWORD));
		driverManagerDataSource.setDriverClassName(environment.getProperty(DRIVER));
		return driverManagerDataSource;
	}
}

• @Configuration – indica que esta clase es una configuración para el contexto de Spring.
• @ComponentScan(“com.journaldev.spring”) – especifica el paquete a escanear para las clases de componente.
• @PropertySource(“classpath:database.properties”) – indica que las propiedades se leerán desde el archivo `database.properties`.

El contenido del archivo `database.properties` se muestra a continuación.

driver=org.postgresql.Driver
url=jdbc:postgresql://127.0.0.1:5432/school
dbuser=postgres
dbpassword=postgres

Si estás utilizando MySQL u otra base de datos relacional, cambia las configuraciones anteriores en consecuencia.

Clases de modelo Spring JDBC

El siguiente paso es crear clases de modelo para mapear nuestra tabla de base de datos.

package com.journaldev.model;

public class Person {
	private Long id;
	private Integer age;
	private String firstName;
	private String lastName;

	public Person() {
	}

	public Person(Long id, Integer age, String firstName, String lastName) {
		this.id = id;
		this.age = age;
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	@Override
	public String toString() {
		return "Person{" + "id=" + id + ", age=" + age + ", firstName='" + firstName + '\'' + ", lastName='" + lastName
				+ '\'' + '}';
	}
}

Para obtener datos de la base de datos, necesitamos implementar la interfaz RowMapper. Esta interfaz tiene solo un método mapRow(ResultSet resultSet, int i), que devolverá una instancia de nuestra clase de modelo (es decir, Persona).

package com.journaldev.model;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

public class PersonMapper implements RowMapper<Person> {

	public Person mapRow(ResultSet resultSet, int i) throws SQLException {

		Person person = new Person();
		person.setId(resultSet.getLong("id"));
		person.setFirstName(resultSet.getString("first_name"));
		person.setLastName(resultSet.getString("last_name"));
		person.setAge(resultSet.getInt("age"));
		return person;
	}
}

Clases DAO Spring JDBC

El paso final es crear clases DAO para mapear nuestra clase de modelo a la tabla de base de datos mediante consultas SQL. También configuraremos el DataSource usando la anotación @Autowired y expondremos algunas APIs.

package com.journaldev.spring.dao;

import java.util.List;

import com.journaldev.model.Person;

public interface PersonDAO {
	Person getPersonById(Long id);

	List<Person> getAllPersons();

	boolean deletePerson(Person person);

	boolean updatePerson(Person person);

	boolean createPerson(Person person);
}

package com.journaldev.spring.dao;

import java.util.List;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import com.journaldev.model.Person;
import com.journaldev.model.PersonMapper;

@Component
public class PersonDAOImpl implements PersonDAO {

	JdbcTemplate jdbcTemplate;

	private final String SQL_FIND_PERSON = "select * from people where id = ?";
	private final String SQL_DELETE_PERSON = "delete from people where id = ?";
	private final String SQL_UPDATE_PERSON = "update people set first_name = ?, last_name = ?, age  = ? where id = ?";
	private final String SQL_GET_ALL = "select * from people";
	private final String SQL_INSERT_PERSON = "insert into people(id, first_name, last_name, age) values(?,?,?,?)";

	@Autowired
	public PersonDAOImpl(DataSource dataSource) {
		jdbcTemplate = new JdbcTemplate(dataSource);
	}

	public Person getPersonById(Long id) {
		return jdbcTemplate.queryForObject(SQL_FIND_PERSON, new Object[] { id }, new PersonMapper());
	}

	public List<Person> getAllPersons() {
		return jdbcTemplate.query(SQL_GET_ALL, new PersonMapper());
	}

	public boolean deletePerson(Person person) {
		return jdbcTemplate.update(SQL_DELETE_PERSON, person.getId()) > 0;
	}

	public boolean updatePerson(Person person) {
		return jdbcTemplate.update(SQL_UPDATE_PERSON, person.getFirstName(), person.getLastName(), person.getAge(),
				person.getId()) > 0;
	}

	public boolean createPerson(Person person) {
		return jdbcTemplate.update(SQL_INSERT_PERSON, person.getId(), person.getFirstName(), person.getLastName(),
				person.getAge()) > 0;
	}
}

La clase PersonDAOImpl está anotada con @Component y en esta clase tenemos un campo de tipo JdbcTemplate. Cuando se invoque el constructor de esta clase, se inyectará una instancia de DataSource en ella y podremos crear una instancia de JdbcTemplate. Después de eso, podemos usarlo en nuestros métodos.

Programa de prueba Spring JdbcTemplate

Nuestro proyecto de ejemplo de Spring JdbcTemplate está listo, probémoslo con una clase de prueba.

package com.journaldev;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.journaldev.model.Person;
import com.journaldev.spring.config.AppConfig;
import com.journaldev.spring.dao.PersonDAO;

public class Main {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

		PersonDAO personDAO = context.getBean(PersonDAO.class);

		System.out.println("List of person is:");

		for (Person p : personDAO.getAllPersons()) {
			System.out.println(p);
		}

		System.out.println("\nGet person with ID 2");

		Person personById = personDAO.getPersonById(2L);
		System.out.println(personById);

		System.out.println("\nCreating person: ");
		Person person = new Person(4L, 36, "Sergey", "Emets");
		System.out.println(person);
		personDAO.createPerson(person);
		System.out.println("\nList of person is:");

		for (Person p : personDAO.getAllPersons()) {
			System.out.println(p);
		}

		System.out.println("\nDeleting person with ID 2");
		personDAO.deletePerson(personById);

		System.out.println("\nUpdate person with ID 4");

		Person pperson = personDAO.getPersonById(4L);
		pperson.setLastName("CHANGED");
		personDAO.updatePerson(pperson);

		System.out.println("\nList of person is:");
		for (Person p : personDAO.getAllPersons()) {
			System.out.println(p);
		}

		context.close();
	}
}

La imagen a continuación muestra la salida producida cuando ejecutamos el programa anterior. La salida variará según los datos de muestra y las ejecuciones múltiples, la idea es aprender aquí cómo usar Spring JdbcTemplate a través de un programa de ejemplo. Eso es todo sobre Spring JdbcTemplate, puedes descargar el proyecto final desde el siguiente enlace.

Descargar Proyecto de Ejemplo de Spring JdbcTemplate

Referencia: Documentación de la API