Spring JdbcTemplate示例
时间：2020-02-23 14:35:53 来源:igfitidea点击:
Spring JdbcTemplate是Spring JDBC包中最重要的类。
SpringJdbcTemplate
JDBC产生了许多样板代码，例如打开/关闭与数据库的连接，处理sql异常等。
这使代码极其繁琐且难以阅读。在Spring Framework中实现JDBC需要处理许多低级操作(打开/关闭连接，执行SQL查询等)。
因此，当在Spring Framework中使用数据库时，我们只需要从数据库中定义连接参数并注册SQL查询，剩下的工作将由Spring完成。
Spring中的JDBC具有几种与数据库进行交互的类(几种方法)。
其中最常见的是使用JdbcTemplate类。
这是管理所有事件和数据库连接的处理的基类。JdbcTemplate类执行SQL查询，在
ResultSet上进行迭代，并检索所调用的值，更新指令和过程调用，"捕获"异常，并将它们转换为org.springframwork.dao包中定义的异常。JdbcTemplate类的实例是线程安全的。
这意味着通过配置JdbcTemplate类的单个实例，我们可以将其用于多个DAO对象。使用JdbcTemplate时，通常是在Spring配置文件中进行配置。
之后，它在DAO类中使用bean来实现。
Spring JdbcTemplate示例
让我们看一下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中的最终项目结构。
Spring JDBC Maven依赖关系
我们需要以下依赖项：" 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.theitroad.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配置
下一步是创建spring配置类来定义" DataSource" bean。
我正在使用基于Java的配置，也可以使用spring bean配置xml文件来完成此操作。
package com.theitroad.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.theitroad.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.theitroad.spring")-指定要扫描组件类的包。
@PropertySource(" classpath：database.properties")-表示将从数据库.properties文件读取属性。
" database.properties"文件的内容如下所示。
driver=org.postgresql.Driver url=jdbc:postgresql://127.0.0.1:5432/school dbuser=postgres dbpassword=postgres
如果您使用的是MySQL或者其他关系数据库，请相应地更改上述配置。
Spring JDBC模型类
下一步是创建模型类以映射我们的数据库表。
package com.theitroad.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)，它将返回模型类的一个实例(即Person)。
package com.theitroad.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类
最后一步是创建DAO类，以使用sql查询将我们的模型类映射到数据库表。
我们还将使用@Autowired批注配置DataSource并公开一些API。
package com.theitroad.spring.dao;
import java.util.List;
import com.theitroad.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.theitroad.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.theitroad.model.Person;
import com.theitroad.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.theitroad;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.theitroad.model.Person;
import com.theitroad.spring.config.AppConfig;
import com.theitroad.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。
