דוגמה ל־Spring JdbcTemplate

Spring

Spring JdbcTemplate היא המחלקה החשובה ביותר בחבילת Spring JDBC.

Spring JdbcTemplate

JDBC מייצרת הרבה קוד חסר תועלת, כמו פתיחה/סגירה של חיבור למסד נתונים, טיפול בחריגות של SQL וכו'. זה מפקח על קוד קשה במיוחד לקריאה ומבלם את הפיתוח.
יישום JDBC במסגרת ה- Spring Framework מתייחס לעבודה עם הרבה פעולות של רמה נמוכה (פתיחה/סגירה של חיבורים, ביצוע שאילתות SQL וכו').
בזכות זה, כאשר אנחנו עובדים עם מסד נתונים ב-Spring Framework, אנחנו רק צריכים להגדיר את פרמטרי החיבור מהמסד נתונים ולרשום את השאילתה SQL, שאר העבודה נעשית על ידי ה-Spring.
JDBC ב-Spring ישנם מספר מחלקות (מספר גישות) לאינטראקציה עם מסד הנתונים. הנפוצה ביותר מביניהן היא באמצעות מחלקת JdbcTemplate. זו המחלקה הבסיסית שמנהלת את עיבוד כל האירועים וחיבורי מסד הנתונים.
מחלקת JdbcTemplate מבצעת שאילתות SQL, מתעברת על תוצאות ה- ResultSet, ומושכת את הערכים הקרואים, מעדכנת את ההוראות וקריאות הפעולות, "תופסת" את החריגות, ומתרגמת אותן לחריגות המוגדרות בחבילת org.springframework.dao.
מופעי המחלקה JdbcTemplate הם בטוחים לסריקה. זה אומר שעל ידי הגדרת מופע יחיד של מחלקת JdbcTemplate, נוכל להשתמש בה עבור כמה עצמי DAO.
בעת השימוש ב-JdbcTemplate, נפוץ ביותר להגדיר אותו בקובץ התצורה של Spring. לאחר מכן, מיושם באמצעות פונקצית סוג במחלקות DAO.

בואו נסתכל על דוגמת תוכנית Spring JdbcTemplate. אני משתמש במסד הנתונים Postgresql כאן, אך ניתן להשתמש גם במסדי נתונים רלציוניים אחרים, כמו MySQL ו-Oracle. כל מה שנדרש הוא לשנות את התצורות של מסד הנתונים וזה יעבוד. לפני הכל, נזדקק למספר נתונים לדוגמה עליהם נוכל לעבוד. השאילתות SQL להלן יצורפו טבלה וימלאו אותה בנתונים לשימוש.

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

התמונה למטה מציגה את מבנה הפרויקט הסופי ב-Eclipse.

תלויות Maven של Spring JDBC

אנחנו צריכים את התלויות הבאות – spring-core, spring-context, spring-jdbc ו-postgresql. אם אתה משתמש במסד נתונים רלציוני אחר כמו MySQL, אז יש להוסיף את התלויות של דרייבר Java המתאימות. כאן הוא קובץ ה-pom.xml הסופי שלנו.

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

השלב הבא הוא ליצור מחלקת תצורה של Spring כדי להגדיר את ה-bean של DataSource. אני משתמש בתצורה בהתבסס על Java, אפשר גם לעשות זאת באמצעות קובץ תצורת XML של תצורת ה-Bean של 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 – אומר שמדובר במחלקת תצורה עבור ההקשר של Spring.
@ComponentScan("com.journaldev.spring") – מציין את החבילה שבה יופעלו תכונות הרכיב.
@PropertySource("classpath:database.properties") – אומר שהתכונות ייקראו מקובץ database.properties.

תוכן הקובץ database.properties מוצג להלן.

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

אם אתה משתמש ב-MySQL או מסד נתונים רלציוני אחר, יש לשנות את התצורות לפי הצורך.

מחלקות המודל JDBC של Spring

השלב הבא הוא ליצור מחלקות מודל כדי למפות את טבלת המסד נתונים שלנו.

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

על מנת לאחזר נתונים ממסד הנתונים, אנחנו צריכים לממש את הממשק RowMapper. בממשק זה יש לנו רק שיטה אחת mapRow(ResultSet resultSet, int i), אשר תחזיר מופע אחד של מחלקת המודל שלנו (כלומר, אדם).

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

מחלקות DAO JDBC של Spring

השלב הסופי הוא ליצור מחלקות DAO כדי למפות את מחלקת המודל שלנו לטבלת המסד נתונים באמצעות שאילתות sql. אנחנו גם נגדיר מקור נתונים באמצעות האנוטציה @Autowired ונחשוף כמה APIים.

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

מחלקת PersonDAOImpl מסומנת באנוטציה @Component ובמחלקה יש לנו שדה עם טיפוס JdbcTemplate. כאשר ייקרא בנאי של מחלקה זו, מופע של DataSource ייכנס כהזרקה לתוכו ויכולים ליצור מופע של JdbcTemplate. לאחר מכן נוכל להשתמש בו בשיטות שלנו.

תוכנית בדיקה של Spring JdbcTemplate

הפרויקט שלנו לדוגמת Spring JdbcTemplate מוכן, בואו נבדוק את זה עם כיתת בדיקה.

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

התמונה למטה מראה את הפלט שמתקבל כאשר אנחנו מריצים את התוכנית שלמעלה. הפלט עשוי להשתנות בהתאם לנתוני הדוגמה ולביצועים מרובים, הרעיון הוא ללמוד כאן איך להשתמש ב-Spring JdbcTemplate דרך תוכנית דוגמה. זהו כל מה שקשור ל-Spring JdbcTemplate, תוכלו להוריד את הפרויקט הסופי מהקישור למטה.

הורד פרויקט דוגמה של Spring JdbcTemplate

הפניה: מסמך API

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