初识Spring JdbcTemplate

JdbcTemplate

概述

JdbcTemplate是Spring提供的一个模板类,它是对jdbc的封装.用于支持持久层的操作.具有简单,方便等特点.

pom.xml

<!--依赖版本-->
<properties>
    <!-- spring版本 -->
    <spring.version>5.0.2.RELEASE</spring.version>
    <!-- mysql版本 -->
    <mysql.version>5.1.30</mysql.version>
</properties>

<!--依赖包-->
<dependencies>
    <!--spring ioc依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--spring jdbc依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!-- mysql数据库依赖 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>

</dependencies>

入门案例

/**
 * spring JdbcTemplate入门案例
 */
public class JdbcTemplateDemo {

    public static void main(String[] args) {
        /**
         * 需求：通过JdbcTemplate实现添加一条账户记录，到账户表account中
         */
        // 创建JdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate();

        // 设置数据源对象
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/spring");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

        jdbcTemplate.setDataSource(dataSource);

        // 添加账户信息
        jdbcTemplate.update("insert into account(name,money) values('小黄',2000)");
    }
}

SpringIOC管理JdbcTemplate

bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入数据源对象-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置数据源对象-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!--注入连接数据库的四个基本要素-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

</beans>

案例

/**
 * spring JdbcTemplate入门案例
 */
public class JdbcTemplateDemo {

    public static void main(String[] args) {
        /**
         * 通过spring IOC容器管理JdbcTemplate对象
         */
        // 1.加载spring配置文件，创建spring IOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean.xml");

        // 2.从spring IOC容器中，获取JdbcTemplate
        JdbcTemplate jdbcTemplate = (JdbcTemplate)context.getBean("jdbcTemplate");

        // 3.添加账户
        jdbcTemplate.update("insert into account(name,money) values('小敏',2000)");

    }
}

整合数据源

在使用JdbcTemplate的时候,需要设置一个数据源对象才能完成数据库操作

内置数据源

<!-- 内置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <!--注入连接数据库的四个基本要素-->
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/spring"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

c3p0数据源

<!-- pom.xml -->
<!--c3p0版本-->
<c3p0.version>0.9.5</c3p0.version>

<!--c3p0依赖-->
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>${c3p0.version}</version>
</dependency>

<!-- c3p0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <!--注入连接数据库的四个基本要素-->
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/spring"></property>
    <property name="user" value="root"></property>
    <property name="password" value="root"></property>
</bean>

dbcp数据源

<!-- pom.xml -->
<!--dbcp版本-->
<dbcp.version>1.4</dbcp.version>

<!--dbcp依赖-->
<dependency>
    <groupId>commons-dbcp</groupId>
    <artifactId>commons-dbcp</artifactId>
    <version>${dbcp.version}</version>
</dependency>

<!-- dbcp数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <!--注入连接数据库的四个基本要素-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
</bean>

druid数据源

<!-- pom.xml -->
<!--druid版本-->
<druid.version>1.0.29</druid.version>

<!--druid依赖-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>${druid.version}</version>
</dependency>

<!-- druid数据源 -->
 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--注入连接数据库的四个基本要素-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
 </bean>

RoeMapper

在JdbcTemplate中query方法有一个参数:RowMapper用于对结果集进行封装

public <T> List<T> query(String sql, RowMapper<T> rowMapper) throws DataAccessException{
    return ....
}

BeanPropertyRowMapper

Spring框架提供的RowMapper通用实现类

// 类结构
public class BeanPropertyRowMapper<T> implements RowMapper<T>{
    .....
}

/**
 * 关键方法一
 *      1.根据传递进来的类型信息,通过反射技术,获取类的全部成员变量,以及set方法
 *      2.把类的成员变量名称,和对应的set方法,存在集合Map中
 *      3.等待执行完成数据库操作后,把对应字段的值,赋值到对应的成员变量上
 */
protected void initialize(Class<T> mappedClass){
    ......
}

/**
 * 关键方法二
 *      1.执行完成数据库操作后,拿到结果集ResultSet
 *      2.循环遍历ResultSet,每一行记录,调用一次该方法,进行结果集的封装
 */
 public T mapRow(ResultSet rs, int rowNumber) throws SQLException{
     ......
 }

自定义RowMapper

有时候为了代码更加简洁,会考虑使用自定义的RowMapper

/**
 * 自定义结果集隐射:RowMapper
 */
public class CustomRowMapper implements RowMapper<T>{
    /**
     * 实现结果集封装方法: mapRow
     * 该方法每一行结果集记录就调用一次
     */
    public T mapRow(ResultSet rs, int rowNumber) throws SQLException{
    Object object = new Object();

    object.setXXX(XXX);

    return object;
    }
}

SpringIOC案例实现

pom.xml

<properties>
    <!--spring版本-->
    <spring.version>5.0.2.RELEASE</spring.version>
    <!--druid版本-->
    <druid.version>1.0.29</druid.version>
    <!--mysql驱动版本-->
    <mysql.version>5.1.30</mysql.version>
</properties>

<dependencies>
    <!--spring ioc依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!--spring jdbc依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!--druid依赖-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
    </dependency>
    <!--mysql驱动依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>
</dependencies>

完全xml版本

bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置客户service-->
    <bean id="Service" class="com.XXX.service.impl.ServiceImpl">
        <!--注入客户dao-->
        <property name="Dao" ref="Dao"></property>
    </bean>

    <!--配置客户dao-->
    <bean id="Dao" class="com.XXX.dao.impl.DaoImpl">
        <!--注入JdbcTemplate-->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

    <!--配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入数据源对象-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置数据源对象DataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--注入四个基本属性-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>

        <!--数据库连接池常用属性-->
        <!-- 初始化连接数量 -->
        <property name="initialSize" value="6" />
        <!-- 最小空闲连接数 -->
        <property name="minIdle" value="3" />
        <!-- 最大并发连接数(最大连接池数量) -->
        <property name="maxActive" value="50" />
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="60000" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
    </bean>

</beans>

dao

public class Dao{
    // 定义JdbcTemplate
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate){
        this.jdbcTemplate = jdbcTemplate;
    }

    public List<T> findAll(){
        // 定义sql
        String sql = "select * from table";

        // 返回执行结果
        return jdbcTemplate.query(sql, new CustomRowMapper());
    }
}

service

public class Service{
    // 定义dao
    private Dao dao;

    public void setDao(Dao dao){
        this.dao = dao;
    }

    public List<T> findAll(){
        return dao.findAll();
    }
}

Controller

public class Controller {
    public static void main(String[] args) {
        // 1.加载spring配置文件，创建spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean.xml");

        // 2.获取客户service对象
        Service Service = (Service) context.getBean("Service");

        // 3.查询全部客户列表数据
        List<T> list = Service.findAll();
        for(T t:list){
            System.out.println(t);
        }
    }
}

xml与注解混合版本

bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置包扫描dao/service，说明：
        第一步：导入context名称空间和约束
        第二步：通过<context:component-scan>标签配置包扫描，spring框架在
        初始化IOC容器的时候，会扫描指定的包和它的子包
    -->
    <context:component-scan base-package="com.XXX"></context:component-scan>

    <!--配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入数据源对象-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置数据源对象DataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--注入四个基本属性-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>

        <!--数据库连接池常用属性-->
        <!-- 初始化连接数量 -->
        <property name="initialSize" value="6" />
        <!-- 最小空闲连接数 -->
        <property name="minIdle" value="3" />
        <!-- 最大并发连接数(最大连接池数量) -->
        <property name="maxActive" value="50" />
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="60000" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
    </bean>

</beans>

dao

@Repository("dao")
public class Dao{
    // 定义JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<T> findAll(){
        // 定义sql
        String sql = "select * from table";

        // 返回查询结果
        return jdbcTemplate.query(sql, new CustomRowMapper());
    }
}

service

@Service("service")
public class Service{
    // 定义dao
    private Dao dao;

    public List<T> findAll(){
        return dao.findAll();
    }
}

完全注解基础版本

Spring配置类

/**
 * 注解说明
 *      @Configuration: 标记当前java类是一个Spring的配置类
 *      @ComponentScan: 配置扫描包,相当于xml配置中<context:component-scan/>标签
 */
@Configuration
@ComponentScan(value = {"com.XXX"})
public class SpringConfiguration{
    // 配置JdbcTemplate
    @Bean(value = "jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource){
        // 创建JdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    // 配置DataSource
    @Bean(value = "dataSource")
    public DataSource createDataSource(){
        // 创建DataSource
        DruidDataSource dataSource = new DruidDataSource();

        // 注入属性
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/spring");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

        dataSource.setInitialSize(6);
        dataSource.setMinIdle(3);
        dataSource.setMaxActive(50);
        dataSource.setMaxWait(60000);
        dataSource.setTimeBetweenEvictionRunsMillis(60000);

        return dataSource;
    }
}

Controller

public class Controller{
    public static void main(String[] args){
        // 1.加载Spring配置类,创建Spring容器
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfiguration.class);

        // 2.获取service对象
        Service service = (Service)context.getBean("service");

        // 调用方法得到结果
        List<T> list = service.findAll();
        for(T t : list){
            System.out.println(t);
        }
    }
}

完全注解优化版本

建立配置类之间关系

/**
 * spring配置类：
 *  注解说明：
 *      [email protected]：标记当前java类，是一个spring的配置类
 *      [email protected]：配置扫描包。相当于xml配置中<context:component-scan/>标签
 *      [email protected]：导入其他模块配置类
 *      [email protected]：导入属性资源文件
 */
@Configuration
@ComponentScan(value = {"com.XXX"})
@Import(value={DaoConfiguration.class})
@PropertySource(value={"classpath:jdbc.properties"})

jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring
jdbc.username=root
jdbc.password=root

jdbc.initialSize=6
jdbc.minIdle=3
jdbc.maxActive=50
jdbc.maxWait=60000
jdbc.timeBetweenERM=60000

Dao

public class DaoConfiguration {
    @Bean(value="jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource){
        // 创建JdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);

        return jdbcTemplate;
    }

    // 定义连接数据库的成员变量
    /**
     * 使用@Value注解，进行赋值
     * 使用格式：@Value("${}")
     */
    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Value("${jdbc.initialSize}")
    private Integer initialSize;
    @Value("${jdbc.minIdle}")
    private Integer minIdle;
    @Value("${jdbc.maxActive}")
    private Integer maxActive;
    @Value("${jdbc.maxWait}")
    private Integer maxWait;
    @Value("${jdbc.timeBetweenERM}")
    private Integer timeBetweenERM;

    @Bean(value="dataSource")
    public DataSource createDataSource(){
        // 创建DataSource
        DruidDataSource dataSource = new DruidDataSource();

        // 注入属性
        // 注入属性
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);

        dataSource.setInitialSize(initialSize);
        dataSource.setMinIdle(minIdle);
        dataSource.setMaxActive(maxActive);
        dataSource.setMaxWait(maxWait);
        dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenERM);

        return dataSource;
    }
}

原文地址：https://www.cnblogs.com/unrecognized/p/11622700.html

时间： 2024-08-30 14:34:21

初识Spring JdbcTemplate的相关文章

Spring JDBCTemplate使用JNDI数据源

xml配置: 1 <bean id="dataSource" 2 class="org.springframework.jdbc.datasource.DriverManagerDataSource"> 3 <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" /> 4 <property name=&qu

spring jdbcTemplate源码剖析

本文浅析 spring jdbcTemplate 源码,主要是学习其设计精髓.模板模式.巧妙的回调 一.jdbcTemplate 类结构 ①.JdbcOperations : 接口定义了方法,如 <T> T execute(StatementCallback<T> action) throws DataAccessException; void execute(String sql) throws DataAccessException; <T> T query(Str

Spring JdbcTemplate 的使用与学习(转)

Spring JdbcTemplate 的使用与学习 JDBCTemplate 是SPRING 框架自带的一种对sql 语句查询的封装 ,封装非常完善,虽然与Hibernate比起来有一点麻烦,但是学号JDBCTemplate可以让我们用Spirngmvc框架去代替SSH,降低了 我们的学习成本.用起来也更加方便,测试代码如下,包括执行mysql 语句,分页,调用存储过程,返回对象数组,返回整数数组,返回单个对象等 package com.tz.jdbctemplate; import java

Spring JdbcTemplate的queryForList(String sql , Class&lt;T&gt; elementType)易错使用--转载

原文地址: http://blog.csdn.net/will_awoke/article/details/12617383 一直用ORM,今天用JdbcTemplate再次抑郁了一次. 首先看下这个方法: 乍一看,我想传个泛型T(实际代码执行中,这个T可以是我自定义的一个Bean),然后就能返回个List<T>,也即泛型的集合(纯ORM思想啊!殊不知又挖了个大坑~) 于是乎,出现下面代码: [java] view plaincopy List<Student> list = jd

spring jdbcTemplate批量更新数据

方法:先实现BatchPreparedStatementSetter接口,然后再调用JdbcTemplate的batchUpdate(sql,setter)操作,参数sql是预编译语句 ,setter是BatchPreparedStatementSetter的一个实例.或者使用内部匿名类方式. BatchPreparedStatementSetter接口 public interface BatchPreparedStatementSetter{ public int getBatchSize(

Spring JdbcTemplate框架（1）——基本原理

JDBC已经能够满足大部分用户擦欧洲哦数据库的需求,但是在使用JDBC时,应用必须自己来管理数据库资源.spring对数据库操作需求提供了很好的支持,并在原始JDBC基础上,构建了一个抽象层,提供了许多使用JDBC的模板和驱动模块,为Spring应用操作关系数据库提供了更大的便利. Spring封装好的模板,封装了数据库存取的基本过程,方便用户. 一.模板方法 Spring JDBCTemplate从名字来说,这就是一个模板,的确是,它确实实现了涉及模式中的模板模式.如下: JDBCTempla

Spring JdbcTemplate框架（2）——动态建表

本篇博客使用Spring JdbcTemplate实现动态建表.前面介绍了,它封装了数据库的基本操作,让我们使用起来更加灵活,下面来实战. 1.准备工作 引入jar包 2.applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi

Spring JdbcTemplate 查询分页

1.大家都有的page类 [java] view plaincopy public class CurrentPage<E> { private int pageNumber; private int pagesAvailable; private List<E> pageItems = new ArrayList<E>(); public void setPageNumber(int pageNumber) { this.pageNumber = pageNumber

Spring JdbcTemplate 与 事务管理

Spring的JDBC框架能够承担资源管理和异常处理的工作,从而简化我们的JDBC代码, 让我们只需编写从数据库读写数据所必需的代码.Spring把数据访问的样板代码隐藏到模板类之下, 结合Spring的事务管理,可以大大简化我们的代码. Spring提供了3个模板类: JdbcTemplate:Spring里最基本的JDBC模板,利用JDBC和简单的索引参数查询提供对数据库的简单访问. NamedParameterJdbcTemplate:能够在执行查询时把值绑定到SQL里的命名参数,而不是使