抽取JDBCTemplate

抽取JDBCTemplate

为了解决DAO实现类中代码的重复问题，另外使得代码更通用，所以抽取一个公共的模板，使其更具有通用性。

DAO实现类的代码

public class StudentDAOImpl implements IStudentDAO {
	public void save(Student stu) {
		String sql = "INSERT INTO s_student(name,age) VALUES(?,?)";
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			//加载注册驱动，获取连接对象
			conn = JdbcUtil.getConn();
			ps = conn.prepareStatement(sql);
			ps.setString(1, stu.getName());
			ps.setInt(2, stu.getAge());
			ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//释放资源
			JdbcUtil.close(conn, ps, null);
		}
	}

	public void delete(Long id) {
		String sql = "DELETE FROM s_student WHERE id = ?";
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			//加载注册驱动
			//获取连接对象
			conn = JdbcUtil.getConn();
			//获取语句对象
			ps = conn.prepareStatement(sql);
			ps.setLong(1, id);
			//执行sql语句
			ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//释放资源
			JdbcUtil.close(conn, ps, null);
		}
	}
	public void update(Student newStu) {
		String sql = "UPDATE s_student SET name = ?,age = ? WHERE id = ?;";
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			//加载注册驱动
			//获取连接对象
			conn = JdbcUtil.getConn();
			//获取语句对象
			ps = conn.prepareStatement(sql);
			ps.setString(1, newStu.getName());
			ps.setInt(2, newStu.getAge());
			ps.setLong(3, newStu.getId());
			//执行sql语句
			ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//释放资源
			JdbcUtil.close(conn, ps, null);
		}
	}

	public Student get(Long id) {
		String sql = "SELECT * FROM s_student WHERE id = ? "; 
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			//加载注册驱动
			//获取连接对象
			conn = JdbcUtil.getConn();
			// 获取语句对象
			ps = conn.prepareStatement(sql);
			ps.setLong(1, id);
			// 执行SQL语句
			rs = ps.executeQuery();
			if (rs.next()) {
				Student stu = new Student();
				Long sid = rs.getLong("id");
				String name = rs.getString("name");
				Integer age = rs.getInt("age");

				stu.setId(sid);
				stu.setName(name);
				stu.setAge(age);

				return stu;
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JdbcUtil.close(conn, ps, rs);
		}
		return null;
	}

	public List<Student> list() {
		List<Student> list = new ArrayList<>();
		String sql = "SELECT * FROM s_student";
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			//加载注册驱动
			//获取连接对象
			conn = JdbcUtil.getConn();
			//获取语句对象
			ps = conn.prepareStatement(sql);
			//执行sql语句
			rs = ps.executeQuery(sql);
			//查询操作
			while(rs.next()){
				Student stu = new Student();
				Long id = rs.getLong("id");
				String name = rs.getString("name");
				Integer age = rs.getInt("age");
				
				stu.setName(name);
				stu.setId(id);
				stu.setAge(age);
				
				list.add(stu);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JdbcUtil.close(conn, ps, rs);
		}
		return list;
	}
}

发现save，delete，update方法的代码只有sql不同，所以，把公共的代码提出来放在模板类中的update方法中，把sql作为参数传到方法中。因为存在sql语句中的占位符并且站位符的个数并不确定，可以采用可变参数进行传参，把需要给站位符设置的站放在一个Object数组中，作为参数传到update方法中，在update方法中又把数组中的值迭代出来赋给特定的sql语句

public void save(Student stu) {
		String sql = "INSERT INTO  s_student(name,age) VALUES(?,?)";
		JdbcTemplate.update(sql,stu.getName(),stu.getAge());
	}

	public void delete(Long id) {
		String sql = "DELETE FROM s_student WHERE id = ?";
		JdbcTemplate.update(sql, id);
	}
	
	public void update(Student newStu) {
		String sql = "UPDATE s_student SET name = ?,age = ? WHERE id = ?;";
		JdbcTemplate.update(sql, newStu.getName(),newStu.getAge(),newStu.getId());
	}

模板中的update方法：

	/**
	 * DML语句的操作的模板
	 * @param sql  sql语句 ：UPDATE INSERT DELETE
	 * @param params sql语句中的站位符? 对应值的数组
	 * @return		返回受影响的行数
	 */
public static int update(String sql,Object...params){
    Connection conn = null;
    PreparedStatement ps = null;
    try {
        //加载注册驱动，获取连接对象
        conn = JdbcUtil.getConn();
        ps = conn.prepareStatement(sql);
        //
        for(int i = 0; i < params.length; i++){
            ps.setObject(i + 1, params[i]);
        }
        return ps.executeUpdate();
    } catch (Exception e) {
        e.printStackTrace();
    }finally{
        //释放资源
        JdbcUtil.close(conn, ps, null);
    }
    return 0;
}

query的抽取有些麻烦，因为它会返回一个结果集，处理结果集的行为,不应该作为模板中的代码,而是应该交给给自的DAO来完成,因为给自的DAO才知道各自表的列有哪一些，作为模板肯定只有在模板中调用DAO中处理完成后的结果集，但是为了保证传入query方法的参数是一致的，肯定需要定义一个规范，在程序中也就是定义一个接口，把这个接口就叫做结果集处理器，每一个DAO的实现类中要有一个处理结果的内部类，这个内部类去实现结果处理器接口，返回一个结果集供模板调用. 也就是,模板中query方法表面调用接口中的方法,实际调用的是各个DAO实现类中的结果集.这就是多态思想

//结果集处理器
public interface IResultSetHandler<T> {
	T handle(ResultSet rs) throws Exception;
}

学生结果集处理器 实现了结果处理器接口

public class StudentHandler implements IResultSetHandler<List<Student>>{

    @Override
    public List<Student> handle(ResultSet rs) throws Exception {

        List<Student> list = new ArrayList<>();
        while(rs.next()){
            Student stu = new Student();
            stu.setAge(rs.getInt("age"));
            stu.setId(rs.getLong("id"));
            stu.setName(rs.getString("name"));

            list.add(stu);
        }
        return list;
    }
}

DAO实现类中的get方法和list方法变成了：

public Student get(Long id) {
    String sql = "SELECT * FROM s_student WHERE id = ? "; 
    List<Student> list = JdbcTemplate.query(sql,new StudentHandler(), id);
    return list.size() == 1?list.get(0) : null;
}

public List<Student> list() {
    String sql = "SELECT * FROM s_student";
    return JdbcTemplate.query(sql,new StudentHandler());
}

模板中的qurey方法：

//DQL语句的操作模板
public static <T> T query(String sql,IResultSetHandler<T> ih,Object...params){
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        conn = JdbcUtil.getConn();
        //获取语句对象
        ps = conn.prepareStatement(sql);
        for(int i = 0; i < params.length; i++){
            ps.setObject(i + 1, params[i]);
        }
        //执行sql语句
        rs = ps.executeQuery();

        //处理结果集
        return ih.handle(rs);

    } catch (Exception e) {
        e.printStackTrace();
    }finally{
        JdbcUtil.close(conn, ps, rs);
    }
    return null;
}

上述qurey方法抽取还存在一个问题就是，每个DAO实现类都得实现接口编写各自的结果处理器，如果DAO比较多，这个也就很麻烦了，能不能抽取值抽取一个更加通用的呢，那就得满足一定的规范，比如可以通过内省机制可以完成，但是列名必须和JavaBean的属性名相同。

public class BeanHandler<T> implements IResultSetHandler<T>{
	
	private Class<T> classType = null;
	public BeanHandler(Class<T> classType){
		this.classType = classType;
	}
	@Override
	public T handle(ResultSet rs) throws Exception {
		//创建对应类的对象
		T obj = classType.newInstance();
		if(rs.next()){
			BeanInfo info = Introspector.getBeanInfo(classType,Object.class);
			PropertyDescriptor[] pds = info.getPropertyDescriptors();
			for (PropertyDescriptor ps : pds) {
				String column = ps.getName();
				Object val = rs.getObject(column);
				ps.getWriteMethod().invoke(obj,val);
			}
		}
		return obj;
	}
}

public class BeanListHandler<T> implements IResultSetHandler<List<T>>{
	private Class<T> classType = null;
	public BeanListHandler(Class<T> classType){
		this.classType = classType;
	}
	@Override
	public List<T> handle(ResultSet rs) throws Exception {
		List<T> list = new ArrayList<>();
		//创建对象
		//获取对象描述器
		while(rs.next()){
			T obj = classType.newInstance();
			BeanInfo info = Introspector.getBeanInfo(classType,Object.class);
			PropertyDescriptor[] pds = info.getPropertyDescriptors();
			for (PropertyDescriptor ps : pds) {
				//获取对象的属性名，属性名和列名相同就调用setter方法把某一列的数据设置到对象中
				String columnName = ps.getName();
				Object val = rs.getObject(columnName);
				ps.getWriteMethod().invoke(obj, val);
			}
			list.add(obj);
		}
		return list;
	}

}

这时候的DAO实现类中方法可以这样来：

public Student get(Long id) {
    String sql = "SELECT * FROM s_student WHERE id = ? "; 
    return JdbcTemplate.query(sql,new BeanHandler<>(Student.class), id);
}

public List<Student> list() {
    String sql = "SELECT * FROM s_student";
    return JdbcTemplate.query(sql, new BeanListHandler<>(Student.class));
}