Voorbeeld van Spring JdbcTemplate

Handleidingen
Spring

Spring JdbcTemplate is de belangrijkste klasse in het Spring JDBC-pakket.

Spring JdbcTemplate

  • JDBC genereert veel boilerplate-code, zoals het openen/sluiten van een verbinding met een database, omgaan met SQL-uitzonderingen, enzovoort. Dit maakt de code buitengewoon omslachtig en moeilijk leesbaar.
  • Het implementeren van JDBC in het Spring Framework zorgt voor de omgang met veel laag-niveau operaties (openen/sluiten van verbindingen, uitvoeren van SQL-query’s, enzovoort).
  • Dankzij dit hoeven we, bij het werken met de database in het Spring Framework, alleen de verbindingsparameters van de database te definiëren en de SQL-query te registreren; de rest van het werk wordt voor ons gedaan door Spring.
  • JDBC in Spring heeft verschillende klassen (verschillende benaderingen) voor de interactie met de database. De meest voorkomende hiervan is het gebruik van de JdbcTemplate-klasse. Dit is de basisklasse die de verwerking van alle gebeurtenissen en databaseverbindingen beheert.
  • De klasse JdbcTemplate voert SQL-query’s uit, itereert over de ResultSet, haalt de opgeroepen waarden op, werkt instructies en procedure-oproepen bij, “vangt” uitzonderingen op en vertaalt ze naar de uitzonderingen gedefinieerd in het org.springframwork.dao-pakket.
  • Instanties van de JdbcTemplate-klasse zijn thread-safe. Dit betekent dat door een enkele instantie van de JdbcTemplate-klasse te configureren, we deze vervolgens kunnen gebruiken voor verschillende DAO-objecten. Bij het gebruik van JdbcTemplate wordt deze meestal geconfigureerd in het Spring-configuratiebestand. Daarna wordt het geïmplementeerd met behulp van bean in DAO-klassen.

Voorbeeld van Spring JdbcTemplate

Laten we eens kijken naar een voorbeeldprogramma van Spring JdbcTemplate. Ik gebruik hier een PostgreSQL-database, maar je kunt ook een andere relationele database gebruiken, zoals MySQL en Oracle. Het enige wat je hoeft te doen is de databaseconfiguraties aanpassen en het zou moeten werken. Allereerst hebben we wat voorbeeldgegevens nodig om mee te werken. Onderstaande SQL-query’s zullen een tabel maken en deze vullen met wat gegevens die we kunnen gebruiken.

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);

Onderstaande afbeelding toont de uiteindelijke projectstructuur in Eclipse.

Spring JDBC Maven-afhankelijkheden

We hebben de volgende afhankelijkheden nodig – `spring-core`, `spring-context`, `spring-jdbc` en `postgresql`. Als u een andere relationele database zoals MySQL gebruikt, voeg dan de overeenkomstige Java-driverafhankelijkheden toe. Hier is ons uiteindelijke pom.xml-bestand.

<?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>

Spring DataSource Configuratie

De volgende stap is het maken van een Spring-configuratieklasse om de DataSource-bean te definiëren. Ik gebruik configuratie op basis van Java, u kunt dit ook doen met behulp van het XML-bestand voor de configuratie van de Spring-bean.

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 – geeft aan dat deze klasse configuratie is voor de Spring-context.
  • @ComponentScan(“com.journaldev.spring”) – geeft aan welk pakket moet worden gescand op componentklassen.
  • @PropertySource(“classpath:database.properties”) – geeft aan dat eigenschappen worden gelezen uit het bestand database.properties.

De inhoud van het bestand database.properties wordt hieronder weergegeven.

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

Als u MySQL of een andere relationele database gebruikt, pas dan de bovenstaande configuraties dienovereenkomstig aan.

Lentemodelklassen voor Spring JDBC

De volgende stap is het creëren van modelklassen om onze databasetabel te mappen.

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
				+ '\'' + '}';
	}
}

Om gegevens uit de database op te halen, moeten we de interface RowMapper implementeren. Deze interface heeft slechts één methode, namelijk mapRow(ResultSet resultSet, int i), die één instantie van onze modelklasse zal retourneren (bijv. Persoon).

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;
	}
}

Spring JDBC DAO-klassen

De laatste stap is het maken van DAO-klassen om onze modelklasse naar de databasetabel te mappen met behulp van SQL-query’s. We zullen ook de DataSource configureren met de @Autowired-annotatie en enkele API’s blootstellen.

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;
	}
}

De klasse PersonDAOImpl is geannoteerd met @Component en in deze klasse hebben we een veld van het type JdbcTemplate. Wanneer de constructor van deze klasse wordt aangeroepen, wordt er een instantie van DataSource in geïnjecteerd en kunnen we een instantie van JdbcTemplate maken. Daarna kunnen we het gebruiken in onze methoden.

Spring JdbcTemplate Testprogramma

Ons Spring JdbcTemplate voorbeeldproject is klaar, laten we dit testen met een testklasse.

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();
	}
}

Onderstaande afbeelding toont de output die wordt geproduceerd wanneer we het bovenstaande programma uitvoeren. De output zal variëren op basis van voorbeeldgegevens en bij meerdere uitvoeringen, het idee is hier om te leren hoe je Spring JdbcTemplate gebruikt aan de hand van een voorbeeldprogramma. Dat is alles over Spring JdbcTemplate, je kunt het eindproject downloaden via onderstaande link.

Download Spring JdbcTemplate Voorbeeldproject

Referentie: API Documentatie

Source:
https://www.digitalocean.com/community/tutorials/spring-jdbctemplate-example