Spring-JdbcTemplate使用

JdbcTemplate

1. 为了使 JDBC 更加易于使用, Spring 在 JDBC API 上定义了一个抽象层, 以此建立一个 JDBC 存取框架.
2. 作为 Spring JDBC 框架的核心, JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法. 每个模板方法都能控制整个过程, 并允许覆盖过程中的特定任务. 通过这种方式, 可以在尽可能保留灵活性的情况下, 将数据库存取的工作量降到最低.

1. 配置JdbcTemplate（C3P0缓冲池）

涉及架包：

//	配置Jdbc所需架包
c3p0-0.9.1.2.jar
com.springsource.net.sf.cglib-2.2.0.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
mysql-connector-java-5.1.7-bin.jar
spring-jdbc-4.0.0.RELEASE.jar

commons-logging-1.1.3.jar
spring-aop-4.0.0.RELEASE.jar
spring-aspects-4.0.0.RELEASE.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar
spring-orm-4.0.0.RELEASE.jar
spring-tx-4.0.0.RELEASE.jar
spring-web-4.0.0.RELEASE.jar
spring-webmvc-4.0.0.RELEASE.jar

1.1 添加db.properties文件

//	数据库用户名
jdbc.user = root 
//	数据库用户密码
jdbc.password = 1234	
//	驱动
jdbc.driverClass = com.mysql.jdbc.Driver
//	连接URL：jdbc:mysql:/// -数据库名
jdbc.jdbcUrl = jdbc:mysql:///spring

//	连接数
jdbc.initPoolSize=5
//	最大连接数
jdbc.maxPoolSize=10

1.2 配置xml文件

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx 
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context      
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <context:property-placeholder location="classpath:db.properties"/>
    

	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${jdbc.user}">property>
        <property name="password" value="${jdbc.password}">property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}">property>
        <property name="driverClass" value="${jdbc.driverClass}">property>

        <property name="initialPoolSize" value="${jdbc.initPoolSize}">property>
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}">property>
	bean>


	<bean id="jdbc" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource">property>
	bean>
beans>

1.3 Test测试类

package com.nchu.test;

import java.sql.SQLException;
import javax.sql.DataSource;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class jdbcText {
    private ApplicationContext context = null;
    private JdbcTemplate jdbcTemplate; 
     //初始化连接池
    {
    	context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取jdbcTemplate的bean
    	jdbcTemplate = (JdbcTemplate) context.getBean("jdbc");
    }
     //测试是否连接数据库
    @Test
    public void testIsConnect() throws SQLException {
    	DataSource dataSource = (DataSource) context.getBean("dataSource");
        System.out.println("连接成功"+dataSource.getConnection());
        
    }
}

连接成功：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s7vFbnhx-1570362647692)(C:\Users\Leisure\AppData\Roaming\Typora\typora-user-images\1570263788168.png[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P1v0yFKn-1570362648076)(C:\Users\Leisure\AppData\Roaming\Typora\typora-user-images\1570263914802.png)]]

2. JdbcTemplate使用

2.1 update

// 执行update
@Test
public void TestUpdate(){
	String sql = "Update book set bprice=? where bid = ?";
	jdbcTemplate.update(sql,222,1);
}

2.2 delete

// 执行delete
@Test
public void TestDelete(){
	String sql = "delete from book where bid = ?";
	jdbcTemplate.update(sql,2);
}

2.3 insert

// 执行insert
@Test
public void TestInsert(){
	String sql = "Insert into book(bname,bnumber,bprice) values(?,?,?)";
	jdbcTemplate.update(sql,"C++",23,23);
}

2.4 select

 // query：查询多行
    @Test
    public void testQueryForObject(){
    	String sql = "select bid,bname from book where bid> ?";
    	RowMapper<Book> rowMapper = new BeanPropertyRowMapper<>(Book.class);
    	List<Book> books = jdbcTemplate.query(sql, rowMapper,2);
    	
    	System.out.println(books);
    }

// queryForObject：查询单个列的值，或做统计查询
    @Test
    public void testQueryForObject2(){
    	String sql = "select bid from book ";
    	int count =  jdbcTemplate.queryForObject(sql, Integer.class);
    	System.out.println(count);
    }

2.5 batchUpate

// 执行批量更新：批量的Insert、update、delete
    // 最后一个参数是Object[] 的list类型：因为修改一条为一个Object的数组，多条就是多个Object的数组
    @Test
    public void TestBatchUpdate(){
    	String sql = "Insert into book(bname,bnumber,bprice) values(?,?,?) ";
//    	jdbcTemplate.execute(sql);
    	List<Object[]> ls = new ArrayList<>();
    	ls.add(new Object[]{"C",20,18});
    	ls.add(new Object[]{"C",20,18});
    	ls.add(new Object[]{"C",20,18});
    	ls.add(new Object[]{"C",20,18});
    	ls.add(new Object[]{"C",20,18});
    	jdbcTemplate.batchUpdate(sql,ls);
    }

补充：

// execute:不能插入参数，功能上，update与其相似
jdbcTemplate.execute(sql);

3. Jdbc中使用具名参数

1. 在经典的 JDBC 用法中, SQL 参数是用占位符 ? 表示,并且受到位置的限制. 定位参数的问题在于, 一旦参数的顺序发生变化, 就必须改变参数绑定.
2. 在 Spring JDBC 框架中, 绑定 SQL 参数的另一种选择是使用具名参数(named parameter).
3. 具名参数: SQL 按名称(以冒号开头)而不是按位置进行指定. 具名参数更易于维护, 也提升了可读性. 具名参数由框架类在运行时用占位符取代
4. 具名参数只在 NamedParameterJdbcTemplate 中得到支持

3.1 配置xml文件

	
	<bean id="namedParameterJdbcTemplate" 
		class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
		<constructor-arg ref="dataSource">constructor-arg>
	bean>

3.2 Test测试类

方法一：

    @Test
    public void TestInsert(){
    	//	传统方式
//    	String sql = "Insert into book(bname,bnumber,bprice) values(?,?,?)";
//    	jdbcTemplate.update(sql,"C++",23,23);
    	
    	//	使用具名参数
    	//	可以为参数起名字。好处：利于后期维护；坏处：使用麻烦
        
        //	获取 namedParameterJdbcTemplate的bean
        NamedParameterJdbcTemplate namedParameterJdbcTemplate = (NamedParameterJdbcTemplate) context.getBean("namedParameterJdbcTemplate");
    	String sql = "Insert into book(bname,bnumber,bprice) values(:b_name,:b_number,:b_price)";
    	Map<String,Object> paramMap = new HashMap<>();
    	paramMap.put("b_name", "English");
    	paramMap.put("b_number", 25);
    	paramMap.put("b_price", 30);
    	namedParameterJdbcTemplate.update(sql,paramMap);
    }

方法二：

    @Test
    public void TestInsert2(){
    	//	传统方式
//    	String sql = "Insert into book(bname,bnumber,bprice) values(?,?,?)";
//    	jdbcTemplate.update(sql,"C++",23,23);
    	
    	//	使用具名参数
    	//	可以为参数起名字。好处：利于后期维护；坏处：使用麻烦
    	String sql = "Insert into book(bname,bnumber,bprice) values(:bname,:bnumber,:bprice)";
    	//	使用Book对象来当载体时，具名参数要和类中参数名字一致
    	Book book =new Book();
    	book.setBname("P.E");
    	book.setBnumber(23);
    	book.setBprice(20);
    	//	使用BeanPropertySqlParameterSource将book类传给paramSource
    	SqlParameterSource paramSource = new BeanPropertySqlParameterSource(book);
    	namedParameterJdbcTemplate.update(sql,paramSource);
    }
``