3.spring学习小结-jdbc

一、Spring Date JDBC 简介

Spring Data JDBC, part of the larger Spring Data family, makes it easy to implement JDBC based repositories. This module deals with enhanced support for JDBC based data access layers. It makes it easier to build Spring powered applications that use data access technologies.
Spring Data JDBC aims at being conceptually easy. In order to achieve this it does NOT offer caching, lazy loading, write behind or many other features of JPA. This makes Spring Data JDBC a simple, limited, opinionated ORM.

1.1、JDBCTemplate核心类

  为了使 JDBC 更加易于使用,Spring 在 JDBCAPI 上定义了一个抽象层, 以此建立一个JDBC存取框架，作为 SpringJDBC 框架的核心, JDBC 模板的设计目的是为不同类型的JDBC操作提供模板方法. 每个模板方法都能控制整个过程,并允许覆盖过程中的特定任务.通过这种方式，可以在尽可能保留灵活性的情况下,将数据库存取的工作量降到最低。
  其实就是Spring对数据库的操作在jdbc上面做了深层次的封装，使用Spring的注入功能，可以把DataSource（数据库连接池）注册到jdbcTemplate中
1.2、JdbcTemplate主要提供以下五类方法

1. execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；
2. update方法：update方法用于执行新增、修改、删除等语句；
3. batchUpdate方法：batchUpdate方法用于执行批处理相关语句；
4. query方法及queryForXXX方法：用于执行查询相关语句；
5. call方法：用于执行存储过程、函数相关语句。
   1.3、Spring提供的数据访问模板，分别适用于不同的持久化机制
   
   1.4、了解Spring数据访问过程
   Spring将数据访问过程中固定的和可变的部分明确划分为两个不同的类：
   1.模板(template) ：模板管理过程中固定的部分
   2.回调(callback) ：回调处理自定义的数据访问代码
   1.5、了解数据库连接池
   1、普通的JDBC连接数据库每次向数据库建立连接的时候都将connection加载到内存，再验证用户名等信息，这样会消耗一定的时间，每次的数据库连接，使用完后再断开，这样的方式会消耗大量的资源和时间。同时上千人访问的话将占用很多系统资源，导致服务器崩溃
   2、数据库连接池其实就是一个为数据库连接建立的一个“缓存池”,预先在数据库连接池中放入一定数量的连接。当需要数据库连接时，从连接池中拿就是了，用完再放回。数据库连接池负责分配、管理、释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立
   3、数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中(initialPoolSize).无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量
   4、连接池的最大数据库连接数量限定了这个连接池占有的最大连接数(maxPoolSize)。当应用程序向连接池请求的连接数超过最大连接数时，这些请求将加入到等待队列中
   5、数据库连接池相对于无连接池的优点
   资源重用，避免频繁创建
   更快的系统反应速度
   实现某一应用最大可用数据库连接数的限制避免某一应用独占所有的数据库资源
   统一的连接管理，避免数据库连接泄露
   6、常用的数据库连接池
   1）c3p0（常用）
   2）dbcp
   3）proxool

二、Spring实现JDBC

2.1、下面是使用C3P0连接JDBC方式与基本JdbcTemplate模板

package com.zhx.test;
import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.zhx.pojo.User;

public class Test01 {
	User u=new User();
	/**
	 * 1.使用cp30连接池核心类获取datasource
	 * 2.设置数据库参数
	 * 3.获取Connection连接对象
	 * 4.写sql语句
	 * 5.通过连接对象获取statement执行sql对象
	 * 6.返回ResultSet对象
	 * @throws Exception
	 */
	@Test
	public void testPoll() throws Exception{
		//cp30连接池核心类
		ComboPooledDataSource datasource=new ComboPooledDataSource();
		//设置数据库参数
		datasource.setDriverClass("com.mysql.jdbc.Driver");
		datasource.setJdbcUrl("jdbc:mysql://localhost:3308/db1");
		datasource.setUser("root");
		datasource.setPassword("123456");
		String sql="select * from user";
		Connection con=datasource.getConnection();
		Statement st=con.createStatement();
		ResultSet rs=st.executeQuery(sql);
		while(rs.next()){
			int id=rs.getInt("id");
			String name=rs.getString("name");
			String password=rs.getString("password");
			u.setId(id);
			u.setName(name);
			u.setPasword(password);
			System.out.println(u);
		}
		rs.close();
		st.close();
		con.close();
	}
	/**
	 * jdbcTemplate模板
	 * @throws PropertyVetoException 
	 */
	@Test
	public void test1() throws PropertyVetoException{
		//1.连接池
		ComboPooledDataSource datasource=new ComboPooledDataSource();
		datasource.setDriverClass("com.mysql.dbc.Driver");
		datasource.setJdbcUrl("jdbc:mysql://localhost:3308/db1");
		datasource.setUser("root");
		datasource.setPassword("123456");
		//2.JdbcTemplate模板
		JdbcTemplate jt=new JdbcTemplate();
		//3.把连接池放入模板
		jt.setDataSource(datasource);
		String sql = "INSERT INTO user VALUES (20,'模板','007');";
		int rows=jt.update(sql);
		System.out.println("数据库影响了"+rows+"行");	
	}
	@Test
	public void test2() throws Exception{
			//1.连接池
			ComboPooledDataSource datasource=new ComboPooledDataSource();
			datasource.setDriverClass("com.mysql.jdbc.Driver");
			datasource.setJdbcUrl("jdbc:mysql://localhost:3308/db1");
			datasource.setUser("root");
			datasource.setPassword("123456");
			//2.JdbcTemplate模板
			JdbcTemplate jt=new JdbcTemplate();
			jt.setDataSource(datasource);
			String sql="select *from user";
			List<User> list=jt.query(sql, new RowMapper<User>(){
				@Override
				public User mapRow(ResultSet rs, int num) throws SQLException {
                    int id=rs.getInt("id");
                    String name=rs.getString("name");
                    String possword=rs.getString("password");
                    User u=new User(id,name,possword);
					return u;
				}
			});
			System.out.println(list);
	}
}

2.2、 spring收编连接池，jdbc模板，dao对象

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns="http://www.springframework.org/schema/beans" 
	xmlns:context="http://www.springframework.org/schema/context" 
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.2.xsd 
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-4.2.xsd ">
	
	<!-- 连接池对象 -->
<!-- 	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3308/db1" ></property>
		<property name="user" value="root" ></property>
		<property name="password" value="123456" ></property>
	</bean> -->
	<!-- 引入db.properties配置文件 -->
	 <context:property-placeholder location="classpath:db.properties"  />
	
	<!-- 连接池对象 -->
	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
		<property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
		<property name="driverClass" value="${jdbc.driverClass}" ></property>
		<property name="user" value="${jdbc.user}" ></property>
		<property name="password" value="${jdbc.password}" ></property>
	</bean> 
	
	<!-- JdbcTemplate对象 -->
	 <bean name="jt" class="org.springframework.jdbc.core.JdbcTemplate" >
		<property name="dataSource" ref="dataSource" ></property>
	</bean> 
	<!-- dao对象 -->
	 <bean name="userDaoImpl" class="com.zhx.daoimpl.userDaoImpl" >
		<property name="jdbcTemplate" ref="jt" ></property>
	</bean> 
	<bean name="userDaoImpl2" class="com.zhx.daoimpl.userDaoImpl2">
	    <property name="dataSource" ref="dataSource"></property>
	</bean>
	
</beans>

package com.zhx.daoimpl;

import java.util.List;

import org.springframework.jdbc.core.JdbcTemplate;

import com.zhx.dao.userDao;
import com.zhx.pojo.User;
/**
 *  jdbc方式
 *	mybatis方式
 *	jdbc模板方式（spring）
 * @author lenovo
 *
 */
public class userDaoImpl implements userDao {
	/**
	 * 直接使用jdbc操作数据库
	 */
	private JdbcTemplate jdbcTemplate;

	@Override
	public int save(User user) {
		String sql = "insert into user values(?,?,?)";
		// 增
		int rows = jdbcTemplate.update(sql, user.getId(), user.getName(), user.getPasword());
		System.out.println("影响了：" + rows);
		return rows;
	}

/**
 * Dao2类。
 * JdbcDaoSupport类的使用！
 *
 */
public class ProductDao2 extends JdbcDaoSupport implements IProductDao {
	
	// 已经不定义JDBCTemplate的对象了！

	@Override
	public void save(Product product) {
		// sql
		String sql = "insert into product values(?,?,?)";

		// 增
		int rows = getJdbcTemplate().update(sql, product.getId(), product.getName(), product.getPrice());
		System.out.println("影响了：" + rows);
	}

package com.zhx.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.zhx.pojo.User;
import com.zhx.daoimpl.userDaoImpl;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test02 {
	@Resource(name="userDaoImpl")
	private userDaoImpl userDaoImpl;
	
	@Test
	public void test1(){
		User u=new User(10,"模板","123456");
		userDaoImpl.save(u);
		System.out.println("ok");
	}

}