JDBC之使用Spring提供的JdbcTemplate进行数据库操作

Spring的JdbcTemplate：
①查询带有参数，和行映射方法:
public Object queryForObject(String sql, Object[] args, RowMapper rowMapper),使用自定义的UserRowMapper完成映射。
②一个RowMapper的常用实现BeanPropertyRowMapper,该实现可将结果集转换成一个Java Bean(字段名与Java Bean属性名不符合规范，可用别名处理)。
③public List query(String sql, Object[] args, RowMapper rowMapper)返回多个结果。
④public int queryForInt(String sql)(如:select count(*) from user),其他结果比如String可用queryForObject方法向下转型。
⑤public Map queryForMap(String sql, Object[] args)返回若类型的Map（key：字段名或别名，value：列值）。
⑥public List queryForList(String sql, Object[] args)返回多Map。
⑦更新public int update(String sql, Object[] args)。
⑧插入数据并获得结果:

public Object execute(ConnectionCallback action)

1、在类路径下添加Spring的两个包，这里使用的是Spring2.5.6版本的

spring.jar、commons-logging.jar

2、实体类User类中的代码

package cn.itcast.jdbc.domain;

import java.util.Date;

/**
 * 用户对象
 */
public class User {
	private int id;
	private String name;
	private Date birthday;
	private float money;

	public User() {
	}

	public User(String name) {
		this.name = name;
	}

	public User(float money) {
		this.money = money;
	}

	public void showName() {
		System.out.println(this.name);
	}

	public int 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 Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public float getMoney() {
		return money;
	}

	public void setMoney(Float money) {
		this.money = money;
	}

}

3、JdbcUtils.java中的代码(数据源的使用请参考博客DBCP数据源的使用)

package cn.itcast.jdbc;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;

/**
 * Jdbc工具类
 */
public final class JdbcUtils {
	
	private static DataSource dataSource = null;
	
	/**
	 * 构造器私用,防止直接创建对象,
	 * 当然通过反射可以创建
	 */
	private JdbcUtils(){
		
	}
	
	//保证只是注册一次驱动
	static{
		try {
			Class.forName("com.mysql.jdbc.Driver");
			//获取DBCP数据源
			Properties props = new Properties();
			InputStream is = JdbcUtils.class.getClassLoader()
					.getResourceAsStream("dbcpconfig.properties");
			props.load(is);
			//使用工厂方法创建数据库,这样即使要改,也只用修改某一处
			dataSource = BasicDataSourceFactory.createDataSource(props);
		} catch (Exception e) {
			throw new ExceptionInInitializerError(e);
		} 
	}
	
	public static DataSource getDataSource() {
		return dataSource;
	}
	
	/**
	 * 获取连接
	 * @return
	 * @throws SQLException
	 */
	public static Connection getConnection() throws SQLException {
		//从数据源中获取数据,也就是从数据库连接池中获取数据
		return dataSource.getConnection();
	}
	
	/**
	 * 释放资源
	 */
	public static void free(ResultSet rs, Statement st, Connection conn) {
		//规范的关系连接的方式
		try{
			if(rs != null) {
				rs.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			try{
				if(st != null) {
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}finally {
				if(conn != null) {
					try {
						conn.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}

4、编写JdbcTemplate的案例

package cn.itcast.jdbc.spring;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.List;
import java.util.Map;

import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.ConnectionCallback;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import cn.itcast.jdbc.JdbcUtils;
import cn.itcast.jdbc.domain.User;

/**
 * 测试Spring中的JdbcTemplate类
 */
public class JdbcTemplateCases {

	//在构造JdbcTemplate时需要传入数据源
	static JdbcTemplate jdbc = new JdbcTemplate(JdbcUtils.getDataSource());
	
	/**
	 * 添加用户
	 * @param user
	 * @return
	 */
	static int addUser(final User user) {
		//该方法接收的是一个回调接口
		jdbc.execute(new ConnectionCallback() {

			public Object doInConnection(Connection con) throws SQLException,
					DataAccessException {
				String sql = "insert into user(name, birthday, money) "
						+ "values(?, ?, ?)";
				PreparedStatement ps = con.prepareStatement(sql, 
						Statement.RETURN_GENERATED_KEYS);
				ps.setString(1, user.getName());
				ps.setDate(2, new java.sql.Date(user.getBirthday().getTime()));
				ps.setFloat(3, user.getMoney());
				ps.executeUpdate();
				
				ResultSet rs = ps.getGeneratedKeys();
				if(rs.next()) {
					user.setId(rs.getInt(1));
				}
				return null;
			}
			
		});
		return 0;
	}
	
	/**
	 * 返回一个Map,对应于数据库中的一条记录
	 * @param id
	 * @return
	 */
	static Map getData(int id) {
		String sql = "select id as userId, name, money, birthday"
				+ " from user where id = " + id;
		return jdbc.queryForMap(sql);
	}  
	
	/**
	 * 只查询用户的姓名
	 * @param id
	 * @return
	 */
	static String getUserName(int id) {
		String sql = "select name from user where id = " + id;
		Object name = jdbc.queryForObject(sql, String.class);
		return (String) name;
	}
	
	/**
	 * 查询有多少条记录
	 * @return
	 */
	static int getUserCount() {
		String sql = "select count(*) from user";
		return jdbc.queryForInt(sql);
	}
	
	/**
	 * 查询多条记录
	 * @param id
	 * @return
	 */
	static List findUsers(int id) {
		String sql = "select id, name, money "
				+ "from user where id < ?";
		Object[] args = new Object[]{id};
		int[] argTypes = new int[]{Types.INTEGER};
		//这里的BeanPropertyRowMapper使用了反射机制
		//进行了封装,这里使用的是query方法
		List users = jdbc.query(sql, args, argTypes, 
			new BeanPropertyRowMapper(User.class));
		
		return users;
	}
	
	/**
	 * 根据姓名查询用户,使用Spring提供的行映射器
	 * @param name
	 * @return
	 */
	static User findUser(String name) {
		//SQL语句中的字段值与java类中的值对应相同
		String sql = "select id, name, money, birthday "
				+ "from user where name=?";
		Object[] args = new Object[] { name };
		//这里使用的是queryForObject方法
		Object user = jdbc.queryForObject(sql, args,
				new BeanPropertyRowMapper(User.class));
		return (User) user;
	}
	
	/**
	 * 根据用户名查询用户,使用自定义的行映射器
	 * @param name
	 * @return
	 */
	static User findUser1(String name) {
		String sql = "select id, name, money, birthday "
				+ "from user where name = ?";
		Object[] args = new Object[]{name};
		//这里使用自定义的行映射器
		Object user = jdbc.queryForObject(sql, args, new RowMapper(){

			public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
				User user = new User();
				user.setId(rs.getInt("id"));
				user.setName(rs.getString("name"));
				user.setMoney(rs.getFloat("money"));
				user.setBirthday(rs.getDate("birthday"));
				return user;
			}
			
		});
		
		return (User) user;
	}
}

5、编写测试类进行测试

package cn.itcast.jdbc.spring;

import java.util.Date;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import cn.itcast.jdbc.domain.User;

public class TestJdbcTemplateCases {
	
	@Test
	public void testUser() {
		User user = new User();
		user.setBirthday(new Date());
		user.setMoney(5f);
		user.setName("sunfeng");
		JdbcTemplateCases.addUser(user);
	}
	
	/**
	 * 测试根据id获取Map
	 */
	@Test
	public void testGetMap() {
		Map map = JdbcTemplateCases.getData(3);
		System.out.println(map);
	}
	
	/**
	 * 测试根据id获取用户名
	 */
	@Test
	public void testGetUserName() {
		String name = JdbcTemplateCases.getUserName(2);
		System.out.println(name);
	}
	
	/**
	 * 查询用户表的所有记录
	 */
	@Test
	public void testGetUserCount() {
		int count = JdbcTemplateCases.getUserCount();
		System.out.println(count);
	}
	
	/**
	 * 测试查询List
	 */
	@Test
	public void testFindUsers() {
		List list = JdbcTemplateCases.findUsers(5);
		System.out.println(list);
	}

	/**
	 * 测试使用Spring提供的行映射器查询用户
	 */
	@Test
	public void testFindUser() {
		User user = JdbcTemplateCases.findUser("lisi");
		System.out.println(user);
	}
	
	/**
	 * 测试使用自定义的行映射器查询用户
	 */
	@Test
	public void testFindUser1() {
		User user = JdbcTemplateCases.findUser1("lisi");
		System.out.println(user);
	}
}