java 使用jdbctemplate_关于JdbcTemplate使用的实例详解

JdbcTemplate 是在JDBC API基础上提供了更抽象的封装，并提供了基于方法注解的事务管理能力。 通过使用SpringBoot自动配置功能并代替我们自动配置beans，下面给大家介绍spring boot中使用JdbcTemplate相关知识，一起看看吧

本文将介绍如何将spring boot 与 JdbcTemplate一起工作。

Spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。 JdbcTemplate 是在JDBC API基础上提供了更抽象的封装，并提供了基于方法注解的事务管理能力。 通过使用SpringBoot自动配置功能并代替我们自动配置beans.

数据源配置

在maven中，我们需要增加spring-boot-starter-jdbc模块

org.springframework.boot

spring-boot-starter-jdbc

通过这个模块为我们做了以下几件事

tomcat-jdbc－{version}.jar为我们自动配置DataSource.

如果你没有定义任何DataSource，SpringBoot将会自动配置一个内存的数据库资源设置

如果没有设置任一个beans，SpringBoot会自动注册它

初始化数据库

如果我们在classpath里定义了schema.sql和data.sql文件，springBoot将会使用这些文件自动初始化数据库(但你必须选建库)

除了载入schema.sql和data.sql外，SpringBoot也会载入schema-${platform}.sql和data-${platform}.sql，如果在你的classpath下存在的话。spring.datasource.schema=xxxx-db.sql 可以定义你的建库文件

spring.datasource.data=xxxx-data.sql 可以定义你的数据文件

spring.datasource.initialize＝true|false 可以决定是不是要初始化这些数据库文件

spring.datasource.continueOnError＝true|false 有了错误是否继续运行

嵌入式数据库支持

嵌入式数据库通常用于开发和测试环境，不推荐用于生产环境。Spring Boot提供自动配置的嵌入式数据库有H2、HSQL、Derby，你不需要提供任何连接配置就能使用。

比如，我们可以在pom.xml中引入如下配置使用HSQL

org.hsqldb

hsqldb

runtime

连接生产数据源配置

以MySQL数据库为例，先引入MySQL连接的依赖包，在pom.xml中加入：

mysql

mysql-connector-java

5.1.21

在src/main/resources/application.properties中配置数据源信息spring.datasource.url=jdbc:mysql://localhost:3306/test

spring.datasource.username=dbuser

spring.datasource.password=dbpass

spring.datasource.driver-class-name=com.mysql.jdbc.Driver

连接JNDI数据源配置

当你将应用部署于应用服务器上的时候想让数据源由应用服务器管理，那么可以使用如下配置方式引入JNDI数据源。spring.datasource.jndi-name=java:jboss/datasources/customers

自定义数据源配置

如果你不想用默认的配置数据源，如你想用阿里巴巴的数据池管理数据源，你也可以自己配置

先排除tomcat-jdbc的默认配置dataSource

org.springframework.boot

spring-boot-starter-jdbc

org.apache.tomcat

tomcat-jdbc

定义自己的数据资源 这里使用了阿里巴巴的数据池管理,你也可以使用BasicDataSource

com.alibaba

druid

1.0.19

package com.example;

import javax.sql.DataSource;import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.web.servlet.FilterRegistrationBean;

import org.springframework.boot.web.servlet.ServletComponentScan;

import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;

import org.springframework.boot.web.servlet.ServletRegistrationBean;

import org.springframework.context.annotation.Bean;

import org.springframework.core.env.Environment;

import org.springframework.web.servlet.DispatcherServlet;

import com.alibaba.druid.pool.DruidDataSource;

import com.example.Listener.IndexListener;

import com.example.filter.IndexFilter;

import com.example.servlet.MyServlet;

@SpringBootApplication

public class SpringBootSimpleApplication {

@Autowired

private Environment env;

@Bean

public DataSource dataSource() {

DruidDataSource dataSource = new DruidDataSource();

dataSource.setUrl(env.getProperty("spring.datasource.url"));

dataSource.setUsername(env.getProperty("spring.datasource.username"));//用户名

dataSource.setPassword(env.getProperty("spring.datasource.password"));//密码

dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));

dataSource.setInitialSize(2);

dataSource.setMaxActive(20);

dataSource.setMinIdle(0);

dataSource.setMaxWait(60000);

dataSource.setValidationQuery("SELECT 1");

dataSource.setTestOnBorrow(false);

dataSource.setTestWhileIdle(true);

dataSource.setPoolPreparedStatements(false);

return dataSource;

}

public static void main(String[] args) {

SpringApplication.run(SpringBootSimpleApplication.class, args);

}

}

你也可以用别的：

commons-dbcp

commons-dbcp

1.4

@Bean

public DataSource dataSource() {

BasicDataSource dataSource = new BasicDataSource();

dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));

dataSource.setUrl(env.getProperty("spring.datasource.url"));

dataSource.setUsername(env.getProperty("spring.datasource.username"));

dataSource.setPassword(env.getProperty("spring.datasource.password"));

return dataSource;

}

代码示例

创建实体对象

/src/main/java/com/example/domain/User.javapackage com.example.domain;

public class User

{

private Integer id;

private String name;

private String email;

public User()

{

}

public User(Integer id, String name, String email)

{

this.id = id;

this.name = name;

this.email = email;

}

public Integer getId()

{

return id;

}

public void setId(Integer id)

{

this.id = id;

}

public String getName()

{

return name;

}

public void setName(String name)

{

this.name = name;

}

public String getEmail()

{

return email;

}

public void setEmail(String email)

{

this.email = email;

}

@Override

public String toString() {

return "User{" +

"id=" + id +

", name='" + name + '\'' +

", email='" + email + '\'' +

'}';

}

}

创建持久层

有了上面的数据源配置，我们可以注入JdbcTemplate到数据访问组件并与数据库交互。

/src/main/java/com/example/repositories/UserRepository.javapackage com.example.repositories;

import com.example.domain.User;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.PreparedStatementCreator;

import org.springframework.jdbc.core.RowMapper;

import org.springframework.jdbc.support.GeneratedKeyHolder;

import org.springframework.jdbc.support.KeyHolder;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

import java.sql.*;

import java.util.List;

@Repository

public class UserRepository {

@Autowired

private JdbcTemplate jdbcTemplate;

@Transactional(readOnly = true)

public List findAll() {

return jdbcTemplate.query("select * from users", new UserRowMapper());

}

@Transactional(readOnly = true)

public User findUserById(int id) {

return jdbcTemplate.queryForObject("select * from users where id=?", new Object[]{id}, new UserRowMapper());

}

public User create(final User user) {

final String sql = "insert into users(name,email) values(?,?)";

KeyHolder holder = new GeneratedKeyHolder();

jdbcTemplate.update(new PreparedStatementCreator() {

@Override

public PreparedStatement createPreparedStatement(Connection connection)

throws SQLException {

PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);

ps.setString(1, user.getName());

ps.setString(2, user.getEmail());

return ps;

}

}, holder);

int newUserId = holder.getKey().intValue();

user.setId(newUserId);

return user;

}

public void delete(final Integer id) {

final String sql = "delete from users where id=?";

jdbcTemplate.update(sql,

new Object[]{id},

new int[]{java.sql.Types.INTEGER});

}

public void update(final User user) {

jdbcTemplate.update(

"update users set name=?,email=? where id=?",

new Object[]{user.getName(), user.getEmail(), user.getId()});

}

}

class UserRowMapper implements RowMapper {

@Override

public User mapRow(ResultSet rs, int rowNum) throws SQLException {

User user = new User();

user.setId(rs.getInt("id"));

user.setName(rs.getString("name"));

user.setEmail(rs.getString("email"));

return user;

}

}

你或许己注意到，大多数时候，我们都在应用中做这些配置的事。

创建单元测试测试我们的持久层方法

/src/test/java/SpringBootJdbcDemoApplicationTests.javaimport com.example.SpringBootJdbcDemoApplication;

import com.example.domain.User;

import com.example.repositories.UserRepository;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.SpringApplicationConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

import static org.junit.Assert.*;

import static org.junit.Assert.assertEquals;

@RunWith(SpringJUnit4ClassRunner.class)

@SpringApplicationConfiguration(SpringBootJdbcDemoApplication.class)

public class SpringBootJdbcDemoApplicationTests

{

Logger logger= LoggerFactory.getLogger(SpringBootJdbcDemoApplicationTests.class);

@Autowired

private UserRepository userRepository;

@Test public void testAll(){

findAllUsers();

findUserById();

createUser();

}

@Test

public void findAllUsers() {

List users = userRepository.findAll();

assertNotNull(users);

assertTrue(!users.isEmpty());

}

@Test

public void findUserById() {

User user = userRepository.findUserById(1);

assertNotNull(user);

}

private void updateById(Integer id) {

User newUser = new User(id, "JackChen", "JackChen@qq.com");

userRepository.update(newUser);

User newUser2 = userRepository.findUserById(newUser.getId());

assertEquals(newUser.getName(), newUser2.getName());

assertEquals(newUser.getEmail(), newUser2.getEmail());

}

@Test

public void createUser() {

User user = new User(0, "tom", "tom@gmail.com");

User savedUser = userRepository.create(user);

logger.debug("{}",savedUser);

User newUser = userRepository.findUserById(savedUser.getId());

assertEquals("tom", newUser.getName());

assertEquals("tom@gmail.com", newUser.getEmail());

updateById(newUser.getId());

userRepository.delete(newUser.getId());

}

}

【相关推荐】