jdbc增删改查，java连接数据库JDBC工具类,Java连接数据库通用增删改查

import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import org.apache.log4j.Logger;



/**
 * 数据库连接JDBC工具类
 * 
 * @author key
 *
 */
public class JDBCUtil {
	// 私有构造
	private JDBCUtil() {
	}

	private static String URL = null;//
	private static String USERNAME = null;
	private static String PASSWORD = null;

	private static Connection conn = null;// 连接对象
	private static PreparedStatement ps = null;// 执行对象
	private static ResultSet rs = null;// 数据库查询结果集
	private static ResultSetMetaData rsd = null;// 保存结果集中列的信息

	private static Logger log = Logger.getLogger(JDBCUtil.class);
	// 静态块，类加载是只执行一次
	static {
		try {
			// 创建输出流对象
			InputStream is = JDBCUtil.class
					.getResourceAsStream("/mysql.properties");
			// 获取properties对象
			Properties pts = new Properties();
			// 加载配置文件
			pts.load(is);
			Class.forName(pts.getProperty("forName"));
			URL = pts.getProperty("url");
			USERNAME = pts.getProperty("user");
			PASSWORD = pts.getProperty("password");
		} catch (Exception e) {
			System.out.println("数据库连接失败！");
			e.printStackTrace();
		}
	}

	// static 静态修饰可以不用new也可以获取方法
	/**
	 * @return 数据库连接对象
	 */
	public static Connection getConnection() {
		try {
			conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);// 数据库连接对象
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}

	/**
	 * 关闭数据库
	 * 
	 * @param conn
	 *            连接数据库对象
	 * @param stat
	 *            执行对象
	 */
	public static void Close(Connection conn, Statement stat) {
		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
			}
		}
		if (stat != null) {
			try {
				stat.close();
			} catch (SQLException e) {
			}
		}
	}

	/**
	 * 关闭数据库
	 * 
	 * @param conn
	 *            数据库连接对象
	 * @param stat
	 *            执行者对象
	 * @param rst
	 *            查询结果集对象
	 */
	public static void Close(Connection conn, Statement stat, ResultSet rst) {

		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
			}
		}
		if (stat != null) {
			try {
				stat.close();
			} catch (SQLException e) {
			}
		}
		if (rst != null) {
			try {
				rst.close();
			} catch (SQLException e) {
			}
		}
	}

	/**
	 * 通用增删改
	 * 
	 * @param sql
	 *            数据库预编译语句
	 * @param param
	 *            预编译语句参数
	 * @return 受影响行数
	 */
	public static int executeUpdate(String sql, Object[] param) {
		Connection conn = getConnection();
		ps = null;
		int count = 0;
		try {
			ps = conn.prepareStatement(sql);
			setParameter(param);
			count = ps.executeUpdate();
		} catch (SQLException e) {
			log.error(e);
		} finally {
			Close(conn, ps);
		}
		return count;
	}
	/**
	 * 将数据库中获取的列名格式，以下划线命名的格式转换为Java属性名格式的小驼峰命名的格式
	 * @param str 以“_”分割出来的str字符串数组
	 * @return 小驼峰命名格式的字符串
	 */
	public static String columnFormat(String[] str){
		// 定义一个字符串类型的fieldName用来保存转换过的字段名
		String fieldName = "";
		// 循环这个数组中的字符串（以“_”分割出来的单词），转成java中的属性名（小驼峰命名法），第一个单词不用首字母不用大写，之后的每个单词首字母大写
		for (int j = 0; j < str.length; j++) {
			// 判断，如果不是第一个那就字符串截取，截取首字母把他转成大写，再拼接起来
			if (j != 0) {
				str[j] = str[j].substring(0, 1).toUpperCase()
						+ str[j].substring(1);
			}
			// 拼接起来保存到这个变量中，就是类中的属性名（注意这里的必须要保证数据库和java属性名之间的转换规范，把mysql中的字段名转成属性名是见了“_”就去掉“_”然后首字母大写）
			fieldName += str[j];
		}
		return fieldName;
	}
	/**
	 * 数据库通用查询
	 * 
	 * @param sql
	 *            语句
	 * @param param
	 *            语句参数
	 * @param clz
	 *            类对象
	 * @return 对象数组
	 */
	public static List<Object> executeQuery(String sql, Object[] param,
			Class<Object> clz) {
		List<Object> list = new ArrayList<Object>();// 保存查询的数据库中的对象
		Object obj = null;// 声明Object类型的变量，用来引用class对象

		try {
			// 数据库查询
			conn = getConnection();
			ps = conn.prepareStatement(sql);
			setParameter(param);
			// 获取查询结果集
			rs = ps.executeQuery();
			// 获取结果集中的列信息
			rsd = rs.getMetaData();
			// 知道列的数量
			int columnCount = rsd.getColumnCount();

			// 查询行
			while (rs.next()) {
				obj = clz.newInstance();// 实例化传入的class对象
				// 获取列名和值
				for (int i = 1; i <= columnCount; i++) {
					// 把获取到的字段名全部先转成小写
					// 把以“_”分割出来的字符保存到str字符串数组中（因为mysql中的字段名每个单词之间用“_”分割），分割出每个单词
					String[] str = rsd.getColumnName(i).toLowerCase()
							.split("_");
					// 定义一个字符串类型的fieldName用来保存转换过的字段名
					String fieldName = columnFormat(str);
					
					// 根据列名获取类对象中的成员变量
					Field filed = clz.getDeclaredField(fieldName);

					// 如果类对象中的成员变量是用private修饰的，则必须将此改为true，否则报错
					filed.setAccessible(true);
					
					String columnName = rsd.getColumnName(i); // 根据获取的列信息获取列名
					Object value = rs.getObject(columnName);// 根据列名获取值
					// 设置类中的成员变量的值
					filed.set(obj, value);
				}
				// 将对象添加至数组中
				list.add(obj);
			}

		} catch (SQLException e) {
			log.error(e);
		} catch (NoSuchFieldException e) {
			log.error(e);
		} catch (SecurityException e) {
			log.error(e);
		} catch (IllegalArgumentException e) {
			log.error(e);
		} catch (IllegalAccessException e) {
			log.error(e);
		} catch (InstantiationException e) {
			log.error(e);
		} finally {
			Close(conn, ps, rs);
		}
		return list;
	}

	/**
	 * 预编译语句参数设置
	 * 
	 * @param param
	 *            参数数组
	 * @throws SQLException
	 *             预编译语句参数设置异常
	 */
	public static void setParameter(Object[] param) throws SQLException {
		for (int i = 1; i <= param.length; i++) {
			ps.setObject(i, param[i - 1]);
		}
	}
}