Spring JdbcTemplate 与 事务管理 学习(转)

也许不会看见 2010-09-28

Spring的JDBC框架能够承担资源管理和异常处理的工作,从而简化我们的JDBC代码,

让我们只需编写从数据库读写数据所必需的代码。Spring把数据访问的样板代码隐藏到模板类之下,

结合Spring的事务管理,可以大大简化我们的代码.

Spring提供了3个模板类：

JdbcTemplate：Spring里最基本的JDBC模板，利用JDBC和简单的索引参数查询提供对数据库的简单访问。

NamedParameterJdbcTemplate：能够在执行查询时把值绑定到SQL里的命名参数，而不是使用索引参数。

SimpleJdbcTemplate：利用Java5的特性，比如自动装箱、通用（generic）和可变参数列表来简化JDBC模板的使用。

具体使用哪个模板基本上取决于个人喜好。

使用Spring的JdbcTemplate来实现简单的增删改查,首先建立测试数据表person

createtableperson(

idintnotnullprimarykeyauto_increment,

namevarchar(20)notnull

)

导入依赖的jar包,由于测试中数据源使用的是dbcp数据源,需要以下jar包支持:

commons-logging.jar

commons-pool.jar

commons-dbcp.jar

同时还必须导入数据库驱动jar包:mysql-connector-java-3.1.8-bin.jar

建立实体bean

Person.java
package com.royzhou.jdbc;   
  

public class PersonBean {   


    private int id;   


    private String name;   

  

    public PersonBean() {   

    }   
       

    public PersonBean(String name) {   


        this.name = name;   

    }   
       

    public PersonBean(int id, String name) {   


        this.id = id;   


        this.name = name;   

    }   
        

    public int getId() {   


        return id;   

    }   
  

    public void setId(int id) {   


        this.id = id;   

    }   
  

    public String getName() {   


        return name;   

    }   
  

    public void setName(String name) {   


        this.name = name;   

    }   
       

    public String toString() {   


        return this.id + ":" + this.name;   

    }   
}  
package com.royzhou.jdbc;

public class PersonBean {
	private int id;
	private String name;

	public PersonBean() {
	}
	
	public PersonBean(String name) {
		this.name = name;
	}
	
	public PersonBean(int id, String name) {
		this.id = id;
		this.name = name;
	}
	 
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public String toString() {
		return this.id + ":" + this.name;
	}
}

接口类:

PersonService.java
package com.royzhou.jdbc;   
  

import java.util.List;   

  

public interface PersonService {   

       

    public void addPerson(PersonBean person);   

       

    public void updatePerson(PersonBean person);   

       

    public void deletePerson(int id);   

       

    public PersonBean queryPerson(int id);   

       

    public List<PersonBean> queryPersons();   

}  
package com.royzhou.jdbc;

import java.util.List;

public interface PersonService {
	
	public void addPerson(PersonBean person);
	
	public void updatePerson(PersonBean person);
	
	public void deletePerson(int id);
	
	public PersonBean queryPerson(int id);
	
	public List<PersonBean> queryPersons();
}

实现类:

PersonServiceImpl.java
package com.royzhou.jdbc;   
  

import java.util.List;   

  

import javax.sql.DataSource;   


import java.sql.Types;   

  

import org.springframework.jdbc.core.JdbcTemplate;   

  

public class PersonServiceImpl implements PersonService {   

  

    private JdbcTemplate jdbcTemplate;   

       

    /**  
     * 通过Spring容器注入datasource  
     * 实例化JdbcTemplate,该类为主要操作数据库的类  
     * @param ds  
     */  

    public void setDataSource(DataSource ds) {   


        this.jdbcTemplate = new JdbcTemplate(ds);   

    }   
       

    public void addPerson(PersonBean person) {   


        /**  
         * 第一个参数为执行sql  
         * 第二个参数为参数数据  
         * 第三个参数为参数类型  
         */  

        jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});   

    }   
  

    public void deletePerson(int id) {   


        jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});   

    }   
  

    public PersonBean queryPerson(int id) {   


        /**  
         * new PersonRowMapper()是一个实现RowMapper接口的类,  
         * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回  
         */  

        PersonBean pb = (PersonBean) jdbcTemplate.queryForObject("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());   


        return pb;   

    }   
  

    @SuppressWarnings("unchecked")   


    public List<PersonBean> queryPersons() {   


        List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());   


        return pbs;   

    }   
  

    public void updatePerson(PersonBean person) {   


        jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});   

    }   
}  
package com.royzhou.jdbc;

import java.util.List;

import javax.sql.DataSource;
import java.sql.Types;

import org.springframework.jdbc.core.JdbcTemplate;

public class PersonServiceImpl implements PersonService {

	private JdbcTemplate jdbcTemplate;
	
	/**
	 * 通过Spring容器注入datasource
	 * 实例化JdbcTemplate,该类为主要操作数据库的类
	 * @param ds
	 */
	public void setDataSource(DataSource ds) {
		this.jdbcTemplate = new JdbcTemplate(ds);
	}
	
	public void addPerson(PersonBean person) {
		/**
		 * 第一个参数为执行sql
		 * 第二个参数为参数数据
		 * 第三个参数为参数类型
		 */
		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
	}

	public void deletePerson(int id) {
		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
	}

	public PersonBean queryPerson(int id) {
		/**
		 * new PersonRowMapper()是一个实现RowMapper接口的类,
		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
		 */
		PersonBean pb = (PersonBean) jdbcTemplate.queryForObject("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
		return pb;
	}

	@SuppressWarnings("unchecked")
	public List<PersonBean> queryPersons() {
		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
		return pbs;
	}

	public void updatePerson(PersonBean person) {
		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
	}
}

PersonRowMapper.java

package com.royzhou.jdbc;   
  

import java.sql.ResultSet;   


import java.sql.SQLException;   

  

import org.springframework.jdbc.core.RowMapper;   

  

public class PersonRowMapper implements RowMapper {   


    //默认已经执行rs.next(),可以直接取数据   


    public Object mapRow(ResultSet rs, int index) throws SQLException {   


        PersonBean pb = new PersonBean(rs.getInt("id"),rs.getString("name"));   


        return pb;   

    }   
}  
package com.royzhou.jdbc;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

public class PersonRowMapper implements RowMapper {
	//默认已经执行rs.next(),可以直接取数据
	public Object mapRow(ResultSet rs, int index) throws SQLException {
		PersonBean pb = new PersonBean(rs.getInt("id"),rs.getString("name"));
		return pb;
	}
}

我们需要在bean.xml中配置DataSource,并且将datasource注入到我们的业务类中

driverClassName=org.gjt.mm.mysql.Driver   

url=jdbc:mysql://localhost:3306/royzhou?useUnicode=true&characterEncoding=UTF-8   

username=root   

password=123456  


initialSize=1  


maxActive=500  


maxIdle=2  


minIdle=1  
driverClassName=org.gjt.mm.mysql.Driver
url=jdbc:mysql://localhost:3306/royzhou?useUnicode=true&characterEncoding=UTF-8
username=root
password=123456
initialSize=1
maxActive=500
maxIdle=2
minIdle=1

编写我们的测试类:TestJdbcTemplate.java

package com.royzhou.jdbc;   
  

import org.springframework.context.ApplicationContext;   


import org.springframework.context.support.ClassPathXmlApplicationContext;   

  

public class TestJdbcTemplate {   


    public static void main(String[] args) {   


        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");   


        PersonService ps = (PersonService)ctx.getBean("personService");   


        ps.addPerson(new PersonBean("royzhou"));   


        PersonBean pb = ps.queryPerson(1);   

        System.out.println(pb);   

        pb.setName("haha");   

        ps.updatePerson(pb);   

        pb = ps.queryPerson(1);   

        System.out.println(pb);   

        ps.deletePerson(1);   


        pb = ps.queryPerson(1);   

        System.out.println(pb);   
    }   
}  
package com.royzhou.jdbc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestJdbcTemplate {
	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
		PersonService ps = (PersonService)ctx.getBean("personService");
		ps.addPerson(new PersonBean("royzhou"));
		PersonBean pb = ps.queryPerson(1);
		System.out.println(pb);
		pb.setName("haha");
		ps.updatePerson(pb);
		pb = ps.queryPerson(1);
		System.out.println(pb);
		ps.deletePerson(1);
		pb = ps.queryPerson(1);
		System.out.println(pb);
	}
}

上面代码先插入一条记录,然后修改,之后删除,运行之后出现异常,异常信息:

EmptyResultDataAccessException:Incorrectresultsize:expected1,actual0

难道Spring的queryForObject在查找不到记录的时候会抛出异常,看了一下Spring的源代码 发现确实如此:
public Object queryForObject(String sql, Object[] args, int[] argTypes, RowMapper rowMapper) throws DataAccessException {   

        List results = (List) query(sql, args, argTypes, new RowMapperResultSetExtractor(rowMapper, 1));   


        return DataAccessUtils.requiredUniqueResult(results);   

    }   
  

    public Object queryForObject(String sql, Object[] args, RowMapper rowMapper) throws DataAccessException {   


        List results = (List) query(sql, args, new RowMapperResultSetExtractor(rowMapper, 1));   


        return DataAccessUtils.requiredUniqueResult(results);   

    }   
  

    public Object queryForObject(String sql, RowMapper rowMapper) throws DataAccessException {   

        List results = query(sql, rowMapper);   

        return DataAccessUtils.requiredUniqueResult(results);   

    }   
  

    public static Object requiredUniqueResult(Collection results) throws IncorrectResultSizeDataAccessException {   


        int size = (results != null ? results.size() : 0);   


        if (size == 0) {   


            throw new EmptyResultDataAccessException(1); // 问题在这里   

        }   

        if (!CollectionUtils.hasUniqueObject(results)) {   


            throw new IncorrectResultSizeDataAccessException(1, size);   

        }   

        return results.iterator().next();   

    }  
public Object queryForObject(String sql, Object[] args, int[] argTypes, RowMapper rowMapper) throws DataAccessException {
		List results = (List) query(sql, args, argTypes, new RowMapperResultSetExtractor(rowMapper, 1));
		return DataAccessUtils.requiredUniqueResult(results);
	}

	public Object queryForObject(String sql, Object[] args, RowMapper rowMapper) throws DataAccessException {
		List results = (List) query(sql, args, new RowMapperResultSetExtractor(rowMapper, 1));
		return DataAccessUtils.requiredUniqueResult(results);
	}

	public Object queryForObject(String sql, RowMapper rowMapper) throws DataAccessException {
		List results = query(sql, rowMapper);
		return DataAccessUtils.requiredUniqueResult(results);
	}

	public static Object requiredUniqueResult(Collection results) throws IncorrectResultSizeDataAccessException {
		int size = (results != null ? results.size() : 0);
		if (size == 0) {
			throw new EmptyResultDataAccessException(1); // 问题在这里
		}
		if (!CollectionUtils.hasUniqueObject(results)) {
		    throw new IncorrectResultSizeDataAccessException(1, size);
		}
		return results.iterator().next();
	}

发现当查找不到记录是,requiredUniqueResult方法做了判断,抛出异常,想不明白为什么Spring要在这里做这样的判断,为啥不返回null????

重新修改PersonServiceImple类,把queryPerson方法改为使用列表查询的方式再去根据index取

PersonServiceImpl.java
package com.royzhou.jdbc;   
  

import java.util.List;   

  

import javax.sql.DataSource;   


import java.sql.Types;   

  

import org.springframework.jdbc.core.JdbcTemplate;   

  

public class PersonServiceImpl implements PersonService {   

  

    private JdbcTemplate jdbcTemplate;   

       

    /**  
     * 通过Spring容器注入datasource  
     * 实例化JdbcTemplate,该类为主要操作数据库的类  
     * @param ds  
     */  

    public void setDataSource(DataSource ds) {   


        this.jdbcTemplate = new JdbcTemplate(ds);   

    }   
       

    public void addPerson(PersonBean person) {   


        /**  
         * 第一个参数为执行sql  
         * 第二个参数为参数数据  
         * 第三个参数为参数类型  
         */  

        jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});   

    }   
  

    public void deletePerson(int id) {   


        jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});   

    }   
  

    @SuppressWarnings("unchecked")   


    public PersonBean queryPerson(int id) {   


        /**  
         * new PersonRowMapper()是一个实现RowMapper接口的类,  
         * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回  
         */  

        List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());   


        PersonBean pb = null;   


        if(pbs.size()>0) {   


            pb = pbs.get(0);   

        }   

        return pb;   

    }   
  

    @SuppressWarnings("unchecked")   


    public List<PersonBean> queryPersons() {   


        List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());   


        return pbs;   

    }   
  

    public void updatePerson(PersonBean person) {   


        jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});   

    }   
}  
package com.royzhou.jdbc;

import java.util.List;

import javax.sql.DataSource;
import java.sql.Types;

import org.springframework.jdbc.core.JdbcTemplate;

public class PersonServiceImpl implements PersonService {

	private JdbcTemplate jdbcTemplate;
	
	/**
	 * 通过Spring容器注入datasource
	 * 实例化JdbcTemplate,该类为主要操作数据库的类
	 * @param ds
	 */
	public void setDataSource(DataSource ds) {
		this.jdbcTemplate = new JdbcTemplate(ds);
	}
	
	public void addPerson(PersonBean person) {
		/**
		 * 第一个参数为执行sql
		 * 第二个参数为参数数据
		 * 第三个参数为参数类型
		 */
		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
	}

	public void deletePerson(int id) {
		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
	}

	@SuppressWarnings("unchecked")
	public PersonBean queryPerson(int id) {
		/**
		 * new PersonRowMapper()是一个实现RowMapper接口的类,
		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
		 */
		List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
		PersonBean pb = null;
		if(pbs.size()>0) {
			pb = pbs.get(0);
		}
		return pb;
	}

	@SuppressWarnings("unchecked")
	public List<PersonBean> queryPersons() {
		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
		return pbs;
	}

	public void updatePerson(PersonBean person) {
		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
	}
}

再次运行测试类,输出:

1:royzhou

1:haha

null

得到预期的结果.

从上面代码可以看出,使用Spring提供的JDBCTemplate类很大程度减少了我们的代码量,

比起以前我们写JDBC操作,需要先获取Connection,然后是PreparedStatement,再到Result,

使用SpringJDBCTemplate写出来的代码看起来更加简洁,开发效率也比较快.

在数据库的操作中,事务是一个重要的概念,举个例子:

大概每个人都有转账的经历。当我们从A帐户向B帐户转100元后，银行的系统会从A帐户上扣除100而在B帐户上加100，这是一般的正常现象。

但是一旦系统出错了怎么办呢，这里我们假设可能会发生两种情况：

（1）A帐户上少了100元，但是B帐户却没有多100元。

（2）B帐户多了100元钱，但是A帐户上却没有被扣钱。

这种错误一旦发生就等于出了大事，那么再假如一下，你要转账的是1亿呢？

所以上面的两种情况分别是你和银行不愿意看到的，因为谁都不希望出错。那么有没有什么方法保证一旦A帐户上没有被扣钱而B帐户上也没有被加钱；

或者A帐户扣了100元而B帐户准确无误的加上100元呢。也就是说要么转账顺利的成功进行，要么不转账呢？可以，这就是数据库事务机制所要起到的作用和做的事情。

Spring对事务的管理有丰富的支持,Spring提供了编程式配置事务和声明式配置事务:

声明式事务有以下两种方式

一种是使用Annotation注解的方式(官方推荐)

一种是基于Xml的方式

采用任何一种方式我们都需要在我们的bean.xml中添加事务支持:
Xml代码 Spring JdbcTemplate 与 事务管理 学习(转)
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:context="http://www.springframework.org/schema/context"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop"  
  6.     xmlns:tx="http://www.springframework.org/schema/tx"  
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
  8.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  9.            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd   
  10.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd   
  11.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
  12.   
  13.     <context:property-placeholder location="classpath:jdbc.properties" color: #
也许不会看见

也许不会看见

相关推荐

基于Fitnesse的接口自动化测试-关键字设计-样例-mysql操作

编写全流程接口测试用例时，有时候需要进行一些数据操作，用于校验系统落地数据的准确性。logger.info("type: {} , hostName: {} , port: {} , instance: {} , userName: {} ,pa

adsadadaddadasda / 0评论 2020-08-19

Sharding-JDBC:查询量大如何优化？

主人公小王入职了一家刚起步的创业公司，公司正在研发一款App。为了快速开发出能够投入市场进行宣传的版本，小王可是天天加班到很晚，忙了一段时间后终于把第一个版本赶出来了。初期功能不多，表也不多，用的MySql存储业务数据。就一个节点，当然每天凌晨有定时备份机

yongyoumengxiang / 0评论 2020-08-02

JavaWeb - 数据库连接池、C3P0、Druid、JDBCTemplate

　　　　当系统初始化好后，容器被创建，容器会申请一些连接对象，当用户来访问数据库时，从容器中连接对象，用户访问完后，会将连接对象归还给容器。　　　　　　　　*归还连接：如果连接对象Connection是从连接池中获取的，那么调用Connection的clo

thunderstorm / 0评论 2020-06-06

Spring整合JDBC temple

　 Spring为了提供对Jdbc的支持，在Jdbc API的基础上封装了一套实现，以此建立一个 JDBC 存取框架。　　作为 Spring JDBC 框架的核心, JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法. 每个模板方法都能

幸运小侯子 / 0评论 2020-05-25

Spring + JdbcTemplate + JdbcDaoSupport examples

In this tutorial, we will reuse the lastSpring + JDBC example, to see the different between a before and after example.Witout

白净垃圾桶 / 0评论 2020-05-02

spring中JdbcTemplate使用

--解决IDEA maven变更后自动重置LanguageLevel和JavaCompiler版本的问题-->

宿命java / 0评论 2020-02-22

Spring的数据库开发

Spring的JDBC模块负责数据库资源管理和错误处理，大大简化了开发人员对数据库的操作，使得开发人员可以从烦琐的数据库操作中解脱出来，从而将更多的精力投入到编写业务逻辑中。接下来的两个小节，将针对Spring中的JDBC模块内容进行详细的讲解。针对数据库

csuzxm000 / 0评论 2020-01-08

Spring JDBC入门

spring中提供了一个可以操作数据库的对象，对象封装了jdbc技术。

whbing / 0评论 2019-11-01

Hibernate 与spring jdbcTemplate共享事物的管理

公司的项目框架搭建可以说是几经周折。之前的项目一直用的SSH框架，老总觉得这种架构开发效率太低了，建议把hibernate去掉或者换成是其他的持久层框架。我把原有的项目中hibernate的部分给去掉，用spring的jdbcTemplate来操作数据库。

空杯心态虚怀若谷 / 0评论 2012-08-24

超详细讲解SpringBoot——数据访问

用spring开发时我们常用的ORM框架有JDBC、Mybatis，Hibernate，现在最常用的应该是Mybatis。在Springboot中对于数据访问层，无论是SQL还是NOSQL，都默认采用整合Spring Data的方式进行统一处理，Sprin

JudeJoo / 0评论 2019-07-01

SpringBoot高级篇JdbcTemplate之数据查询上篇

前面一篇介绍如何使用JdbcTemplate实现插入数据，接下来进入实际业务中，最常见的查询篇。由于查询的姿势实在太多，对内容进行了拆分，本篇主要介绍几个基本的使用姿势。I. 环境准备环境依然借助前面一篇的配置，链接如： 190407-SpringBoot

seawaycao / 0评论 2019-07-01

Spring Boot多数据源配置之JdbcTemplate

多数据源配置也算是一个常见的开发需求，Spring和SpringBoot中，对此都有相应的解决方案，不过一般来说，如果有多数据源的需求，我还是建议首选分布式数据库中间件MyCat去解决相关问题，之前有小伙伴在我的知识星球上提问，他的数据根据条件的不同，可能

cyAspNet / 0评论 2019-07-01

重拾-Spring Transaction

问题面试中是不是有时经常会被问到 “Spring 事务如何管理的了解吗？”，“Spring 事务的传播性有哪些，能聊聊它们的使用场景吗？”， “事务回滚的时候是所有异常下都会回滚吗？”； 下面我们就带着这些问题来看看 Spring 事务是如何实现的吧。

tangxiong0 / 0评论 2019-07-01

分布式事务中间件 Fescar—RM 模块源码解读

我所在的团队也遇到了这个问题，为解决这个问题上，团队采用的是阿里开源的分布式中间件Fescar的解决方案，并详细了解了Fescar内部的工作原理，解决在使用Fescar中间件过程中的一些疑虑的地方，也为后续团队在继续使用该中间件奠定理论基础。Fescar就

xiaoxiangyu / 0评论 2019-06-30

Spring源码分析：声明式事务梳理

-- spring提供的jdbcTemplate模块 -->. -- mysql链接驱动包 -->

zhangyayun0 / 0评论 2019-06-30

Spring之在开发中使用SpringJDBC

JdbcTemplate类被设计成为线程安全的，所以可以在IOC 容器中声明它的单个实例，并将这个实例注入到所有的 DAO 实例中。JdbcTemplate也利用了Java 1.5 的特定来简化开发。Spring JDBC 框架还提供了一个 JdbcDao

剑铭 / 0评论 2015-07-13

Spring4.1新特性——数据库集成测试

</bean>此处使用jdbc:embedded嵌入数据库来完成测试，数据库使用HSQL。@SqlConfig(encoding = "utf-8", separator = ";", commentPr

oxuzhenyi / 0评论 2014-08-20

spring配置Hibernate和JdbcTemplate

<property name="username" value="root"></property>. <property name="password" value

愤怒的砖头 / 0评论 2013-10-11

Spring的JdbcTemplate对数据库的增删改操作（备忘）

String sql = "insert into spjkwxd values (?String sql = "delete from spjkwxd where xh = '" + xh + "'";

Excalibur0 / 0评论 2013-08-06

JdbcTemplate中的模板方法模式

如工厂方法模式，代理模式，模板模式等等。还有如JndiTemplate,JmsTempate.其原理都是一样的。对于非共性的逻辑暴露出来。由子类来覆盖重写或实现。

longdan0 / 0评论 2013-07-30

Spring jdbc 批量JDBC操作、ORM映射

Spring提供了一个强有力的模板类JdbcTemplate简化JDBC操作，DataSource,JdbcTemplate都可以以Bean的方式定义在想xml配置文件，JdbcTemplate创建只需注入一个DataSource，应用程序Dao层只需要继

scdnzhoulu / 0评论 2013-07-01

oracle 执行批处理sql，部署遇到的驱动不兼容问题

同一份代码，部署到两个测试环境，一个运行正常一个运行报错，错误信息如下：

zgxzowen / 0评论 2013-06-06

SpringBoot-JdbcTemplates-MySQL

INSERT INTO `account` VALUES ;三. 使用IDEA 创建 springBoot项目,选择 web,MySQL,jpa四. 配置相关的文件。String sql = "delete from account where

网络连接世界 / 0评论 2019-06-28

Hibernate与JdbcTemplate共享事务管理

</bean>但是这种方式有个局限性，如果该方法中既有调用Hibernate进行存储，也有通过JdbcTemplate进行数据库的写操作，如果在方法执行过程中，写数据发生异常时，只有纳入了事务管理的通过Hibernate进行存储的数据才会回滚，

netHibernate / 0评论 2012-06-27

jdbcTmeplate和hibernate 共用时事务配置

</bean>但是这种方式有个局限性，如果该方法中既有调用Hibernate进行存储，也有通过JdbcTemplate进行数据库的写操作，如果在方法执行过程中，写数据发生异常时，只有纳入了事务管理的通过Hibernate进行存储的数据才会回滚，

meleto / 0评论 2012-05-10

【第七章】 对JDBC的支持 之 7.5 集成Spring JDBC及最佳实践 ——跟我学spring3

通过配置方式使用Spring JDBC。Spring JDBC通过实现DaoSupport来支持一致的数据库访问。private static final String INSERT_SQL = "insert into test values&

牧场SZShepherd / 0评论 2012-02-29

spring 入门 3 整合JDBC和AOP事务

// 与DBUtils中的QueryRunner非常相似.String sql = "insert into t_user values ";public class UserDaoImpl extends JdbcDaoSupport

oradbm / 0评论 2019-06-28

一起来学SpringBoot | 第五篇：使用JdbcTemplate访问数据库

SpringBoot 是为了简化 Spring 应用的创建、运行、调试、部署等一系列问题而诞生的产物，自动装配的特性让我们可以更好的关注业务本身而不是外部的XML配置，我们只需遵循规范，引入相关的依赖就可以轻易的搭建出一个 WEB 工程Spring Fra

qingjiuquan / 0评论 2019-06-27

给spring jdbctemplate加上一层“华丽外衣”－动态SQL&&SQL语句以文件存放

用hibernate用得多了，忽然怀念起自己直接写sql 的轻巧类库了。看过MyBatis文档，写过demo， 相对于hibernate这个强大的ORM工具，MyBatis可控性更好,然而今天它不主角,今天的主角是spring jdbc.spring jd

mrsuddenflash / 0评论 2011-05-09

利用spring mvc,hibernate重构系统（3）

本章节继续讲解如何使用spring mvc和Iframe进行类似ajax的数据提交页面无刷新的效果！！-- 删除结果页面-->list.jsp 代码如下：。<html> <body>我是列表页面</body>&l

LetonLIU / 0评论 2011-04-29

spring jdbctemplate

了JDBC操作的复杂性。并且得益于Spring良好的隔离设计，JDBC封装类库可以脱离。也可以单独使用Spring的JDBC部分来改善我们的代码。类似上面的代码非常常见。为了执行一个SQL语句，我们必须编写22行代码，而其中。种典型的改进方案。JDBC模板

剑铭 / 0评论 2011-03-30

分页查询SQL jdbcDAO oracle JdbcTemplate 【给我发表点意见】

Stringsql="";Stringtsql="";intstartNum=-1;intpageSize=-1;intcount=0;this.tsql=sql;this.startNum=startNum;thi

pfpfpfpfpf / 0评论 2011-03-18

spring JdbcTemplate批量更新

一次执行多个sql语句;

fayeyiwang / 0评论 2011-02-24

DB2Oracle数据库对clob的处理

spring定义了一个以统一的方式操作各种数据库的Lob类型数据的LobCreator,同时提供了一个LobHandler为操作二进制字段和大文本字段提供统一接口访问。举例，例子里面的t_post表中post_text字段是CLOB类型,而post_att

步行者 / 0评论 2011-02-14

POI导出EXCEL

*/public class ExportExcelUtils {private JdbcTemplate jdbcTemplate;public JdbcTemplate getJdbcTemplate() {return jdbcTemplate;}

dinux / 0评论 2014-05-06

hibernate配置

--配置事务管理器-->

Gbug00 / 0评论 2010-10-08

BeanPropertyRowMapper

spring2.5+提供了BeanPropertyRowMapper/ParameterizedBeanPropertyRowMapper，如果PO和数据库模型的字段完全对应（字段名字一样或者驼峰式与下划线式对应），如果使用JdbcTemplate则可以使

huangzhe0 / 0评论 2010-10-07

JdbcTemplate batchUpdate 批量操作加事务

疑问：基于TransactionManager的编程式事务管理和声明式事务管理都不起作用,为何？

mxcsdn / 0评论 2010-09-20

Spring Boot中使用Flyway来管理数据库版本

久违了的Spring Boot系列，今天抽空更新一篇。去年写过很多篇关于数据访问的文章了，比如下面这些：。在上面的使用JdbcTemplate一文中，主要通过spring提供的JdbcTemplate实现对用户表的增删改查操作。下面我们就通过本文来学习一下

sqlican / 0评论 2019-06-26

spring的JdbcTemplate、NamedParameterJdbcTemplate和SimpleJdbcTemplate

使用spring自己对数据库操作时，可以使用这三个数据库操作模板。JdbcTemplate中方法主要传递sql,和数组参数，其方法要求sql占位符和参数数组位置需要对应，参考代码：。String sql = "select id as userI

jacklife / 0评论 2010-07-21

Spring 事务管理高级应用难点剖析: 第 3 部分

对于应用开发者来说，数据连接泄漏无疑是一个可怕的梦魇。如果存在数据连接泄漏问题，应用程序将因数据连接资源的耗尽而崩溃，甚至还可能引起数据库的崩溃。Spring DAO 对所有支持的数据访问技术框架都使用模板化技术进行了薄层的封装。这个数据连接从数据源获取及

yhahaha / 0评论 2010-06-10

使用Spring的JdbcTemplate调用Oracle的存储过程

Spring的SimpleJdbcTemplate将存储过程的调用进行了良好的封装，但可惜只能用于jdk1.5的环境，无法再jdk1.4环境下使用，而JdbcTemplate则完全适用于jdk1.4下的环境，下面列出使用JdbcTemplate调用Orac

landdin0 / 0评论 2010-06-05

Spring JdbcTemplate实现update或insert

String sql="insert into user (name,age) values(?)";ps.setString(1,name);ps.setInt(2,age);return ps;public void setValu

tangxiong0 / 0评论 2010-06-04

Spring源代码解析(一) spring JDBC

下面我们看看SpringJDBC相关的实现，不过往往Spring通过这种回调函数的实现已经为我们提供了许多现成的方法供客户使用。一般来说回调函数的用法采用匿名类的方式来实现，比如：。} 在模板中嵌入的是需要客户化的代码，由Spring来作或者需要客户程序亲

Kingonion / 0评论 2010-05-12

Spring源代码解析(三）：Spring JDBC

下面我们看看SpringJDBC相关的实现，不过往往Spring通过这种回调函数的实现已经为我们提供了许多现成的方法供客户使用。一般来说回调函数的用法采用匿名类的方式来实现，比如：。//我们知道，Spring做了一个有意义的工作是把这些数据库异常统一到自己

jacklife / 0评论 2010-05-12

SpringCloud（第 041 篇）链接Mysql数据库,通过JdbcTemplate编写数据库访问

SpringCloud链接Mysql数据库,通过JdbcTemplate编写数据库访问-

bluetears / 0评论 2019-06-25

Spring管理JDBC连接

不过往往Spring通过这种回调函数的实现已经为我们提供了许多现成的方法供客户使用。一般来说回调函数的用法采用匿名类的方式来实现，比如：。}在模板中嵌入的是需要客户化的代码，由Spring来作或者需要客户程序亲自动手完成。//如果捕捉到数据库异常，把数据库

尘封飞扬 / 0评论 2010-03-18

Spring、Spring Boot和TestNG测试指南 - 测试关系型数据库

Spring Test Framework提供了对JDBC的支持，能够让我们很方便对关系型数据库做集成测试。本章节为了方便起见，本章节使用了H2作为测试数据库。如果想要在maven打包的时候跳过集成测试，只需要mvn clean install -Dski

欢子 / 0评论 2019-06-21

Spring 数据库

Spring的所有的模板类都是线程安全的.Spring的数据访问框架都结合了模板类.使用JdbcTemplate模板,每一个DAO类都需要配置一个JdbcTemplate的实例.

mowengaoboa / 0评论 2010-03-15