体现的是一种思想，一种写法。涉及增删改查，供参考。数据库使用的是MySQL5.7。

自定义数据库连接工具类


package dao;

import java.lang.reflect.Field;
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.List;
import java.util.Map;
import java.util.Map.Entry;

import entity.User;
import util.C3p0DBUtil;
import util.DBUtil;

public class DBDao {

	private Connection conn = null; 		// 数据库连接对象
	private PreparedStatement ps = null; 	        // SQL语句预编译对象
	private ResultSet rs = null; 			// 查询数据库反馈结果集
	private static DBDao dao = new DBDao();         // 数据库操作类对象

	private DBDao() {
	};

	/**
	 * 获取数据库操作类DBDao对象的方法。
	 * 
	 * @return DBDao对象
	 */
	public static DBDao getInstance() {
		return dao;
	}

	/**
	 * 正确关闭连接，释放所有资源。单独调用executeQueryRS方法获取结果集时，请务必用完后调用此方法。
	 */
	public void closeAll() {
		// C3p0DBUtil.closeAll(conn, ps, rs);
		DBUtil.closeAll(conn, ps, rs);
	}

	/**
	 * 更新数据库，操作包括增删改
	 * 
	 * @param sql
	 *            SQL语句
	 * @param params
	 *            占位符参数列表
	 * @return -1表示传入参数错误，0表示0行受影响，大于0表示N行受影响
	 */
	public int executeUpdateSQL(String sql, List<Object> params) {
		try {
			// conn = C3p0DBUtil.getConnection(); // 获取连接对象
			conn = DBUtil.getConnection();
			ps = conn.prepareStatement(sql); // 格式化SQL语句
			if (params != null && !params.isEmpty()) {
				for (int i = 0; i < params.size(); i++) {
//					System.out.println(params.get(i));
					ps.setObject(i + 1, params.get(i)); // 填充占位符
				}
			}
			return ps.executeUpdate(); // 返回执行受影响行数
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// C3p0DBUtil.closeAll(conn, ps, rs); // 关闭连接，释放资源
			DBUtil.closeAll(conn, ps, rs);
		}
		return 0; // 执行错误就是没有结果，返回0。
	}

	/**
	 * 动态执行多事物处理，不做查询处理，查询不需要事物处理。
	 * @param params 多条SQL事物语句集
	 * 		MapMap<String,List<Object>>是已要执行的SQL语句为键，占位符参数列表List<Object>为值的集合
	 */
	public int executeUpdateByThing(List<Map<String,List<Object>>> params) {
		
		int count = 0;
		try {
//			conn = C3p0DBUtil.getConnection();
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	//使用事物处理，先存放内容，不自动提交给数据库执行
			for (Map<String, List<Object>> map : params) {
				for (Entry<String, List<Object>> enmap : map.entrySet()) {
					//执行SQL语句
					ps = conn.prepareStatement(enmap.getKey());
					//配置占位符参数，如果没占位符，就配置对应的参数
					List<Object> sqlParams = enmap.getValue();
					if (sqlParams != null && !sqlParams.isEmpty()) {
						for (int i = 0; i < sqlParams.size(); i++) {
							ps.setObject(i + 1, sqlParams.get(i));
						}
					}
					//记录执行受影响行数
					count = ps.executeUpdate();
				}
			}
			//最终提交给数据库执行
			conn.commit();
			//返回总受影响行数
			return count;
		} catch (SQLException e) {
			//如果出现异常全部回滚
			if(conn != null) {	
				e.printStackTrace();
				try {
					conn.rollback();
				} catch (SQLException e1) {
					e1.printStackTrace();
				}
			}
		} finally {
//			C3p0DBUtil.closeAll(conn, ps, rs);
			DBUtil.closeAll(conn, ps, rs);
		}
		
		return count;
	}

	/**
	 * 执行数据库查询，获取数据库结果集。单独调用executeQueryRS方法获取结果集时，请务必手动关闭连接。
	 * 
	 * @param sql
	 *            SQL语句字符串
	 * @param params
	 *            占位符对应的参数列表，如果没有占位符传空集合即可
	 * @return 数据库结果集
	 */
	public ResultSet executeQueryRS(String sql, List<Object> params) {
		try {
			// conn = C3p0DBUtil.getConnection();
			conn = DBUtil.getConnection();
			ps = conn.prepareStatement(sql);
			// 如果没占位符，就配置对应的参数
			if (params != null && !params.isEmpty()) {
				for (int i = 0; i < params.size(); i++) {
					ps.setObject(i + 1, params.get(i));
				}
			}
			return ps.executeQuery();
		} catch (SQLException e) {
			if (sql.contains("?") && (params == null || params.isEmpty())) {
				System.err.println("SQL语句中有占位符“?”，请问是否忘记加参数了？");
			}
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 获取单个实体对象，数据通过结果集提取
	 * 
	 * @param sql
	 *            SQL语句字符串
	 * @param params
	 *            占位符对应的参数列表
	 * @param c
	 *            实体对象对应的类，如：User.class
	 * @return 对应的实体对象
	 */
	public <T> T getOneObject(String sql, List<Object> params, Class<T> c) {

		rs = executeQueryRS(sql, params);
		try {
			if (rs != null) {
				T obj = null;
				ResultSetMetaData rsm = rs.getMetaData();
				int count = rsm.getColumnCount();
				while (rs.next()) {
					obj = c.newInstance(); // 创建一个实体对象
					for (int i = 1; i <= count; i++) {
						String columnName = rsm.getColumnName(i);
						Object columnValue = rs.getObject(i);

						// System.out.println(columnName + " " + columnValue);
						if (columnName != null && !columnName.equals("")) {
							Field field = c.getDeclaredField(columnName);
							field.setAccessible(true);
							if (columnValue == null) {
								columnValue = "";
							}
							field.set(obj, columnValue); // 初始化实体对象属性
						}
					}
				}
				return obj;
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// C3p0DBUtil.closeAll(conn, ps, rs);
			DBUtil.closeAll(conn, ps, rs);
		}
		return null;
	}

	/**
	 * 获取所有实体对象，数据通过结果集提取
	 * 
	 * @param sql
	 *            SQL语句字符串
	 * @param params
	 *            占位符对应的参数列表
	 * @param c
	 *            实体对象对应的类，如：User.class
	 * @return 存储所有实体对象的集合
	 */
	public <T> List<T> getObjectList(String sql, List<Object> params, Class<T> c) {

		rs = executeQueryRS(sql, params);
		try {
			if (rs != null) {
				List<T> list = new ArrayList<T>();
				ResultSetMetaData rsm = rs.getMetaData();
				int count = rsm.getColumnCount();
				while (rs.next()) {
					T obj = c.newInstance(); // 创建一个实体对象
					for (int i = 1; i <= count; i++) {
						String columnName = rsm.getColumnName(i);
						Object columnValue = rs.getObject(i);

						if (columnName != null && !columnName.equals("")) {
							Field field = c.getDeclaredField(columnName);
							field.setAccessible(true);
							if (columnValue == null) {
								columnValue = "";
							}
							field.set(obj, columnValue); // 初始化实体对象属性
						}
					}
					list.add(obj); // 把单条数据存入集合
				}
				return list;
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// C3p0DBUtil.closeAll(conn, ps, rs);
			DBUtil.closeAll(conn, ps, rs);
		}
		return null;
	}
	
	/**
	 * 获取表头列名
	 * @param tableName 表名
	 * @return
	 */
	public List<String> getTableColumns(String tableName) {

		List<String> list = null;
		String sql = "SELECT * FROM " + tableName + "LIMIT 0,1";
		ResultSet rs = dao.executeQueryRS(sql, null);
		try {
			ResultSetMetaData rsm = rs.getMetaData();
			int count = rsm.getColumnCount();
			list = new ArrayList<String>();
			for (int i = 1; i <= count; i++) {
				list.add(rsm.getColumnName(i));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			dao.closeAll();
		}
		return list;
	}
	
	/**
	 * 获取数据库表总记录数
	 * @param tableName 表名
	 * @return -1表示查询出错，0表示没记录
	 */
	public int getTotalRecord(String tableName) {
		
		try {
			String sql = "SELECT count(*) totals FROM (" + tableName + ") a";
			ResultSet rs = dao.executeQueryRS(sql, null);
			if(rs.next()) {
				return rs.getInt("totals");
			}
		} catch (SQLException e) {
			e.printStackTrace();
			return -1;
		}finally {
			dao.closeAll();
		}
		return 0;
	}

	public static void main(String[] args) throws SQLException {

		DBDao dbd = new DBDao();

		String sql = "select * from user";

		// ResultSet rs = dbd.executeQueryRS(sql,null);
		// if(rs == null){
		// return;
		// }
		// ResultSetMetaData rsm = rs.getMetaData();
		// int count = rsm.getColumnCount();
		// while(rs.next()){
		// for (int i = 1; i <= count; i++) {
		// System.out.print(rs.getObject(i) + " ");
		// }
		// System.out.println();
		// }

		List<User> userlist = dbd.getObjectList(sql, null, User.class);
		for (User user : userlist) {
			System.out.println(user);
		}

		// String sql1 = "select * from user where userAccount=?";
		// List<Object> params = new ArrayList<Object>();
		// params.add("admin");
		// User user = dbd.getOneObject(sql1, params, User.class);
		// System.out.println(user);

		dbd.closeAll();
	}
}

数据库表：

CREATE TABLE `user` (
  `userId` int(10) NOT NULL AUTO_INCREMENT,
  `userName` varchar(50) DEFAULT NULL,
  `userAccount` varchar(50) NOT NULL,
  `userPassword` varchar(200) NOT NULL,
  PRIMARY KEY (`userId`),
  UNIQUE KEY `userAccount` (`userAccount`)
) ENGINE=InnoDB AUTO_INCREMENT=101 DEFAULT CHARSET=utf8

实体类：

package entity;

public class User {

	private int userId;							//用户编号
	private String userName;					//用户名
	private String userAccount;					//用户账号
	private String userPassword;				//账号密码
	public int getUserId() {
		return userId;
	}
	public void setUserId(int userId) {
		this.userId = userId;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getUserAccount() {
		return userAccount;
	}
	public void setUserAccount(String userAccount) {
		this.userAccount = userAccount;
	}
	public String getUserPassword() {
		return userPassword;
	}
	public void setUserPassword(String userPassword) {
		this.userPassword = userPassword;
	}
	@Override
	public String toString() {
		return "{\"id\":\"" + userId + "\",\"userName\":\"" + userName + "\",\"userAccount\":\"" + userAccount + "\",\"userPassword\":\""
				+ userPassword + "\",\"status\":1}";
	}
	
}