Spring JdbcTemplate Beispiel

Tutorials
Spring

Die Spring JdbcTemplate ist die wichtigste Klasse im Spring JDBC Paket.

Spring JdbcTemplate

  • JDBC erzeugt viel Boilerplate-Code, wie das Öffnen/Schließen einer Verbindung zur Datenbank, das Behandeln von SQL-Ausnahmen usw. Dadurch wird der Code äußerst umständlich und schwer lesbar.
  • Die Implementierung von JDBC im Spring Framework kümmert sich um viele Low-Level-Operationen (Öffnen/Schließen von Verbindungen, Ausführen von SQL-Abfragen usw.).
  • Dank dessen müssen wir, wenn wir mit der Datenbank im Spring Framework arbeiten, nur die Verbindungsparameter aus der Datenbank definieren und die SQL-Abfrage registrieren. Den Rest der Arbeit erledigt Spring für uns.
  • JDBC in Spring hat mehrere Klassen (mehrere Ansätze) für die Interaktion mit der Datenbank. Am häufigsten wird die JdbcTemplate-Klasse verwendet. Dies ist die Basisklasse, die die Verarbeitung aller Ereignisse und Datenbankverbindungen verwaltet.
  • Die JdbcTemplate-Klasse führt SQL-Abfragen aus, iteriert über den ResultSet und ruft die aufgerufenen Werte ab, aktualisiert die Anweisungen und Prozeduraufrufe, „fängt“ die Ausnahmen ab und übersetzt sie in die in dem Paket org.springframwork.dao definierten Ausnahmen.
  • Instanzen der JdbcTemplate-Klasse sind threadsicher. Dies bedeutet, dass wir durch Konfiguration einer einzelnen Instanz der JdbcTemplate-Klasse diese für mehrere DAO-Objekte verwenden können.
  • Bei Verwendung von JdbcTemplate wird es in der Regel in der Spring-Konfigurationsdatei konfiguriert. Danach wird es mit dem Bean in DAO-Klassen implementiert.

Spring JdbcTemplate Beispiel

Werfen wir einen Blick auf das Beispielprogramm Spring JdbcTemplate. Ich verwende hier eine Postgresql-Datenbank, aber Sie können auch eine andere relationale Datenbank wie MySQL und Oracle verwenden. Alles, was Sie tun müssen, ist die Datenbankkonfigurationen zu ändern, und es sollte funktionieren. Zunächst benötigen wir einige Beispieldaten, mit denen wir arbeiten können. Die folgenden SQL-Abfragen erstellen eine Tabelle und füllen sie mit einigen Daten für uns zum Verwenden.

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

Das folgende Bild zeigt die endgültige Projektstruktur in Eclipse.

Spring JDBC Maven-Abhängigkeiten

Wir benötigen folgende Abhängigkeiten – spring-core, spring-context, spring-jdbc und postgresql. Wenn Sie eine andere relationale Datenbank wie MySQL verwenden, fügen Sie die entsprechenden Java-Treiberabhängigkeiten hinzu. Hier ist unsere endgültige pom.xml-Datei.

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

Der nächste Schritt besteht darin, eine Spring-Konfigurationsklasse zu erstellen, um das DataSource-Bean zu definieren. Ich verwende eine auf Java basierende Konfiguration; Sie können dies auch über eine Spring Bean-Konfigurations-XML-Datei tun.

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 – gibt an, dass diese Klasse eine Konfiguration für den Spring-Kontext ist.
  • @ComponentScan(„com.journaldev.spring“) – gibt das Paket an, das nach Komponentenklassen durchsucht werden soll.
  • @PropertySource(„classpath:database.properties“) – gibt an, dass die Eigenschaften aus der Datei database.properties gelesen werden.

Der Inhalt der Datei database.properties wird unten angezeigt.

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

Wenn Sie MySQL oder eine andere relationale Datenbank verwenden, ändern Sie die obigen Konfigurationen entsprechend.

Spring JDBC-Modellklassen

Nächster Schritt ist das Erstellen von Modellklassen zur Zuordnung unserer Datenbanktabelle.

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

Um Daten aus der Datenbank abzurufen, müssen wir das Interface RowMapper implementieren. Dieses Interface hat nur eine Methode mapRow(ResultSet resultSet, int i), die eine Instanz unserer Modellklasse (d.h. Person) zurückgibt.

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

Der letzte Schritt besteht darin, DAO-Klassen zu erstellen, um unsere Modellklasse mit der Datenbanktabelle über SQL-Abfragen zu verknüpfen. Wir werden auch den DataSource mit der @Autowired-Annotation konfigurieren und einige APIs freigeben.

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

Die Klasse PersonDAOImpl ist mit der @Component-Annotation versehen, und in dieser Klasse haben wir ein Feld vom Typ JdbcTemplate. Wenn der Konstruktor dieser Klasse aufgerufen wird, wird eine Instanz von DataSource darin injiziert, und wir können eine Instanz von JdbcTemplate erstellen. Danach können wir sie in unseren Methoden verwenden.

Spring JdbcTemplate Testprogramm

Unser Beispielprojekt für Spring JdbcTemplate ist bereit, lassen Sie uns dies mit einer Testklasse testen. 

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

Das untenstehende Bild zeigt die Ausgabe, die beim Ausführen des obigen Programms erzeugt wird. Die Ausgabe variiert je nach Beispieldaten und bei mehreren Ausführungen. Die Idee hier ist es, zu lernen, wie man Spring JdbcTemplate durch ein Beispielprogramm verwendet. Das ist alles über Spring JdbcTemplate, Sie können das finale Projekt über den untenstehenden Link herunterladen.

Spring JdbcTemplate Beispielprojekt herunterladen

Referenz: API-Dokumentation

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