JDBC 连接数据库（增，删，改，查）公用类及DAO类实现

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Hashtable;

public class DbHelper {
	
	/**
	 * 常见错误
	 * 1、在ResultSet迭代的时候，没有用<=导致没有获得当前数据行的列的最后的一列数据，
	 *    这个错误会导致，在获取之以后给实体bean对象赋值的时候抛出空指针异常
	 * 2、pstmt.setObject(i + 1, params.get(i));正确的
	 *   pstmt.setObject(i, params.get(i));错误的写法没有把数据参数的索引从1开始
	 * 
	 * 
	 */
	
	// 连接数据库
	private static Connection connection;
	// 执行带预处理的sql语句
	private static PreparedStatement pstmt;

	// 接受数据的查询的返回结果集
	private static ResultSet rs;
	// jdbc:jtds:sqlserver://<hostname>[:<port>]/<dbname>
	private static String sqlurlString = "jdbc:jtds:sqlserver://localhost:1433/First";

	private static String dbname = "sa";
	private static String dbpwd = "";

	/**
	 * 
	 * 获得数据库的连接的方法
	 * 
	 * @return
	 */
	public static Connection getConnction() {

		// 获得驱动连接数据库
		try {
			Class.forName("net.sourceforge.jtds.jdbc.Driver");
			connection = java.sql.DriverManager.getConnection(sqlurlString,
					dbname, dbpwd);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return connection;
	}

	/**
	 * 执行查询的通用方法
	 * @param sql
	 * @param params
	 * @return
	 */
	public static ArrayList<Hashtable<String, Object>> executeQuery(String sql,
			ArrayList<Object> params) {

		ArrayList<Hashtable<String, Object>> resultArrayList = null;
		// 执行查询，必须先判断是否有正常的数据连接
		try {
			if (null == connection || connection.isClosed()) {
				getConnction();
			}
			pstmt = connection.prepareStatement(sql);
			if (null != params) {
				if (params.size() > 0) {
					for (int i = 0; i < params.size(); i++) {
						//System.out.println(params.set(1, 0));
						//预处理的pstmt对象设置值
						pstmt.setObject(i + 1, params.get(i));
					}
				}
			}
			rs = pstmt.executeQuery();
			if (null != rs) {
				resultArrayList = new ArrayList<Hashtable<String, Object>>();
				while (rs.next()) {
					// 获得数据库表的结构
					ResultSetMetaData rsmdData = rs.getMetaData();
					Hashtable<String, Object> rowHashtable = new Hashtable<String, Object>();
					for (int j = 1; j <= rsmdData.getColumnCount(); j++) {
						rowHashtable.put(rsmdData.getColumnName(j)
								.toLowerCase(), rs.getObject(j));
					}
					resultArrayList.add(rowHashtable);
				}
			}

		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			closeAll();
		}

		return resultArrayList;
	}

	/**
	 * 该方法执行数据库数据的添加，删除，和修改的操作
	 * @param sql  执行的T-SQL 语句，也就是结构化查询语句
	 * @param params  执行sql语句有可能用到的参数的集合
	 * @return int
	 */
	public static int executeSave(String sql, ArrayList<Object> params){
		int result  = 0;
		
		/**
		 * 1、判断数据库的连接状态，如果没有连接则连接数据库，先获得数据库的连接
		 * 2、执行预处理的sql语句对象，PreparedStatement，有可能该sql有相关的参数
		 * 3、判断是否有参数，如果有则进行参数的绑定
		 * 4、执行sql语句，获得返回的执行结果，会是int返回数据中受影响的行数
		 * 5、执行资源的回收
		 * 
		 */
		
		try {
			//1、判断数据库的连接状态，如果没有连接则连接数据库，先获得数据库的连接
			if(null == connection || connection.isClosed()){
				getConnction();
			}
			//2、执行预处理的sql语句对象，PreparedStatement，有可能该sql有相关的参数
			//执行该对象，需要一个有效的SQL语句
			pstmt = connection.prepareStatement(sql);
			//3、判断是否有参数，如果有则进行参数的绑定
			if(null != params){
				if(params.size()>0){
					for(int i=0; i<params.size();i++){
						pstmt.setObject(i+1, params.get(i));
					}
				}
			}
			//4、执行sql语句，获得返回的执行结果，会是int返回数据中受影响的行数
			result = pstmt.executeUpdate();
			
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			//5、执行资源的回收
			closeAll();
		}
		
		return result;
	}
	
	
	
	public static void closeAll() {
		try {
			if (null != rs) {
				rs.close();
				rs = null;
			}
			if(null !=pstmt){
				pstmt.close();
				pstmt = null;
			}
			if (null != connection) {
				connection.close();
				connection= null;
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

测试：

@Test public void textGetConnection(){
//	java.sql.Connection con = DbHelper.getConnection();
//	System.out.println(con);
		
	String sqlString = "select * from Users WHERE UName=? AND UPwd=?";
	ArrayList<Object> params = new ArrayList<Object>();
	params.add("李四");
	params.add("234");		
	
	ArrayList<Hashtable<String, Object>> tempresult = DbHelper.executeQuery(sqlString,params);
	
	for (Hashtable<String, Object> row: tempresult) {
		for(String key: row.keySet()){
			System.out.println(row.get(key));
		}
	}
}

DAO类实现方法：

登录：

public Users login(String uname) {
	Users result = null;
	String sqlString = "select * from Users where UName=?";
	ArrayList<Object> params = new ArrayList<Object>();
	params.add(uname);
	
	ArrayList<Hashtable<String, Object>> templist = DbHelper.executeQuery(sqlString, params);
	if(null != templist){
		if(templist.size()==1){
			result = getModelByHashtable(templist.get(0));
		}
	}
	return result;
}

查询所有：

public ArrayList<Users> findAll() {
	ArrayList<Users> result = null ;
	//执行查询所有用户的SQl
	String sql = "SELECT * FROM [Users]";
	//调用数据库的底层类，通过查询方法获得数据库中的所有用户信息
	ArrayList<Hashtable<String, Object>> tempList = DbHelper.executeQuery(sql, null);
	//判断执行查询是否成功
	if(null != tempList){
		//如果数据执行查询成功则判断查询是否获得相关的数据
		if(tempList.size()>0){
			//如果查询获得相关的数据则创建用于封装数据返回的对象实例
			result = new ArrayList<Users>();
			//通过循环遍历查询的集合，获得集合中的每个数据，并封装成用户对象
			for (Hashtable<String, Object> hashtable : tempList) {
				Users users = getModelByHashtable(hashtable);
				result.add(users);
			}
		}
	}
	return result;
}

private Users getModelByHashtable(Hashtable<String, Object> ht){  
    Users users = new Users();  
    users.setuId(ht.get("uid").toString());  
    users.setuName(ht.get("uname").toString());  
    System.out.println(ht);  
    System.out.println(users);  
    users.setuPwd(ht.get("upwd").toString());  
    return users;  
}

或者：

private Users getModelUsersByHashtable(Hashtable<String, Object> row){
	Users result = new Users();
	//获得当前类的所有的私有字段
	Field[] fileds = result.getClass().getDeclaredFields();
	for (Field field : fileds) {
		//设置私有的属性可以被调用
		field.setAccessible(true);
		try {
			field.set(result, row.get(field.getName().toLowerCase()));
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}
	return result;
}

删除：

public int delete(String id) {
	String sql = "DELETE [Users] WHERE [Uid]=? ";
	ArrayList<Object> params = new ArrayList<Object>();
	params.add(id);		
	int result = DbHelper.executeSave(sql, params);
	return result;
}

增加：

public int save(Users t) {
	int result = 0 ;
	String sql= "INSERT INTO Users(UName,UPwd) VALUES(?,?)";
	ArrayList<Object> params = new ArrayList<Object>();
	params.add(t.getuName());
	params.add(t.getuPwd());
	
	result = DbHelper.executeSave(sql, params);
	
	return result;
}

修改：

public int update(Users obj) {
	String sql = "update [User Info] set username=?,Age=?,Address=? where LoginName=?";
	ArrayList<Object> params = new ArrayList<Object>();
      
	params.add(obj.getUserName());
	params.add(obj.getAge());
	params.add(obj.getAddress());
	params.add(obj.getLoginName());
	int result = DbHelper.excuteSave(sql, params);
	return result;
}