Jdbc的普通封装
嗯，大家肯定是经常使用jdbc完成一些基本的数据库操作，但是每次有没有发现都是差不多同样子的操作呢？为了解决这个问题，下面给出一个基本的jdbc封装。在这个列子中，
采用了单例设计模式，并且很好的控制了线程并发问题。因为数据的操作，每个Connection, Statement, PreparedStatement,ResultSet对象，都可能造成线程并发问题，所以在这个
类里面，全部的对象都是在方法里面定义，这样子，每个方法都拥有自己的运行堆栈，从而在使用单列模式的情况下，也不会有线程并发问题。有时候，在我们刚开始使用jdbc的
时候，会直接把Connetion, Statement, PreparedStatement, ResultSet的对象定义为一个类的属性...那样子很容易造成并发问题。
这个类同样把数据库的配置，放在一个xml文件中，这样子更具有灵活性。在修改xml的情况下，既可以完成数据库的更换。
下面是xml的内容：
url=jdbc:mysql://localhost:3306/ username=itaem password=imitaem dbName=gdou_gym driver=org.gjt.mm.mysql.Driver
下面是封装的JdbcTool工具类:
package net.itaem.tool;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
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.HashSet;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import net.itaem.po.Field;
/**
* 操作数据库的工具类，这个类负责建立于数据库的连接，负责执行update, insert, delete等基本的数据库操作
* 这个类大家可以直接使用，不需要考虑过多的线程问题
* 这个类写了通用的update, insert, delete等数据库访问方法，具体到特殊的查询，以及含有事务的sql组合
* 大家可以直接写在自己的dao中
* 注意点：调用了getConnection()之后，记得在宿主程序中关闭你所获得的Connection变量
* @author luohong
* @date 2014-03-09
* */
public class JdbcTool {
private static JdbcTool instance = new JdbcTool();
//这些属性不可以修改，只允许直接从 jdbc.cfg.properties读取
private static String dbName; //数据库名字
private static String url; //数据库连接的url
private static String username; //数据库用户名
private static String password; //密码
/**
* 解析数据库的配置文件
* 从配置文件中读取数据库连接的 url, username, password, driver, database name等各种信息
* 以后要修改数据库的链接地址，直接修改配置文件，不要修改该类
* */
static{
try {
Properties properties = new Properties();
InputStream inputStream = JdbcTool.class.getClassLoader().getResourceAsStream("jdbc.cfg.properties");
properties.load(inputStream);
//加载数据库驱动
Class.forName((String)properties.get("driver"));
dbName = (String)properties.getProperty("dbName");
url = (String)properties.getProperty("url");
password = (String)properties.getProperty("password");
username = (String)properties.getProperty("username");
} catch (Exception e) {
throw new RuntimeException("加载mysql驱动失败");
}
}
/**
* 这个类的访问接口，返回这个类的实例，每次访问，返回的都是同一个实例
* */
public static JdbcTool getJdbcToolInstance(){
return instance;
}
/**
* 采用单列设计模式
* */
private JdbcTool(){
}
/**
* 获取数据库连接
* 返回的每个Connection都是 new 出来的唯一Connection
* @return Connection 返回数据库的链接
* @exception RuntimeException 如果获取数据库连接失败，直接抛出运行时异常，调用者不需要捕获该异常
* */
public Connection getConnection(){
try {
Connection conn = DriverManager.getConnection(url + dbName, username, password);
return conn;
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException("获取数据库连接失败" + ",url:" + url + dbName + ",username:" + username + ", password:" + password);
}
}
/**
* 执行insert, update, delete的sql语句，如果操作影响结果
* @param sql 要执行的sql语句，形式：insert into student(name, number) values (?,?)
* @param args 要执行数据库的sql参数，如果为null，直接执行sql语句
* @return 返回记录修改的数目，如果出现异常，返回 -1
* */
public int executeUpdate(String sql, Object[] args){
Connection conn = getConnection();
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(sql);
if(args != null && args.length > 0)
//注入sql ？ 的实际内容
for(int i=0; i<args.length; i++)
ps.setObject(i + 1, args[i]);
//如果没有参数，直接执行
return ps.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
return -1;
}finally{
//关闭数据库连接
try {
ps.close();
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 批量执行sql语句，调用该方法之间，必须组装好sql语句
* sql语句只能是增加，删除，修改三种类型的语句
* @param sqlArray 要批量执行的sql语句
* @return 返回批量执行后的int数组
* @exception SQLException
* */
public int[] executeUpdateBatch(String[] sqlArray){
Connection conn = getConnection();
Statement statement = null;
try {
statement = conn.createStatement();
for(String sql : sqlArray)
statement.addBatch(sql);
return statement.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}finally{
//关闭数据库连接
try {
statement.close();
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return null;
}
/**专门用于插入主键自动增长的数据库表的操作,返回值为自动增长的主键值
* @author 少钦
* @param sql
* @param objs
* @return 插入成功的自动增长的主键,如果没有成功则返回-1
*/
public int add(String sql,Object[] objs){
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
JdbcTool tool=JdbcTool.getJdbcToolInstance();
conn = tool.getConnection();
st = conn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);
for (int i = 0; objs != null && i < objs.length; i++) {
st.setObject(i + 1, objs[i]);
}
st.executeUpdate();
rs = st.getGeneratedKeys();
if (rs.next()) {
return rs.getInt(1);
}else
return -1;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("获取数据过程中出现异常" + e);
} finally {
JdbcTool.release(conn,st,rs);
}
}
/**专门用来关闭数据库连接的方法,st可以PreparedStatement(Statement是pt的父类)
* @author 少钦
* @param conn
* @param st PreparedStatement或者Statement
* @param rs
*/
public static void release(Connection conn,Statement st,ResultSet rs){
try{
if(rs!=null){
try{
rs.close();
}catch(SQLException e){
throw e;
}
}
if(st!=null){
try{
st.close();
}catch(SQLException e){
throw e;
}
}
if(conn!=null){
try{
conn.close();
}catch(SQLException e){
throw e;
}
}
}catch (SQLException e) {
throw new RuntimeException("关闭数据库连接时发生异常!异常信息:"+e);
}
}
public static void main(String[] args) throws Exception{
System.out.println(getTableList("select * from field where field_id>?", new Object[]{10}, new Field()));
}
/**
* 根据sql，返回对象的集合
* 这个方法的使用要求：传入的sql属于预处理的sql
* args可以为null，或者是一个没有内容的Object[]数组
* object是要封装的数据类型，在每次方法返回的时候，必须要转换为你所需要的数据类型，当然，读者可以自己修改为泛型方法，那样子封装更加完美
*
* bug:因为封装过程中，每次只是修改Object的内容，然后添加到集合中，所以这个集合中的所有对象都是同一个对象...不可以使用Set进行转换
*
* @param args sql的参数
* @param object 要封装的类型
*
* @throws SQLException
* @throws InvocationTargetException
* @throws IllegalAccessException
* @throws IllegalArgumentException
* */
public static List<Object> getTableList(String sql, Object[] args, Object object) throws SQLException,
IllegalArgumentException, IllegalAccessException, InvocationTargetException{
Connection conn = getJdbcToolInstance().getConnection();
PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = null;
if(args == null || args.length ==0){ //没有参数
rs = ps.executeQuery(); //查询
}else{ //有参数
for(Object obj: args){
ps.setObject(1, obj);
}
rs = ps.executeQuery();
}
ResultSetMetaData rsmd = rs.getMetaData();
int columnCount = rsmd.getColumnCount(); //the column of the table
@SuppressWarnings("rawtypes")
Class clazz = object.getClass();
//获得所有的属性
java.lang.reflect.Field[] fields = clazz.getDeclaredFields();
String[] methodNames = new String[fields.length];
//get all object method
Method[] methods = object.getClass().getDeclaredMethods();
//获得所有的方法名
for(int i=0; i<fields.length; i++){
methodNames[i] = "set" + fields[i].getName().substring(0, 1).toUpperCase() + fields[i].getName().substring(1);
}
//封装存在的问题：因为这里每次都把参数object加入到集合中，所以这里所有的集合对象都是同一个对象
List<Object> objList = new ArrayList<Object>();
Set<Object> objSet = new HashSet<Object>();
while(rs.next()){
for(int i=0; i<columnCount; i++){
String methodName = methodNames[i];
for(Method method: methods){
if(method.getName().equalsIgnoreCase(methodName)){
//设置对象的属性
method.invoke(object, rs.getObject(rsmd.getColumnName(i+1)));
}
}
objList.add(object);
}
}
//objSet.addAll(objList);
//System.out.println("the set size is " + objSet.size()); //打印的结果为1！！！！
return objList;
}
}
//使用到的Field类对象
package net.itaem.po;
import java.util.HashSet;
import java.util.Set;
/**
*
* @Description:场地po类
* @operate:
* @author sen
* @date 2014-3-11
*/
public class Field implements java.io.Serializable {
// Fields
private int fieldId; //ID
private int fieldTypeId; //对应的场地类型ID
private String fieldNumber; //场地序号 /场地名称
private boolean fieldStatus; //场地的状态 fieldStatus=true为开启状态 fieldStatus=false为关闭状态
private String fieldPic; //场地存放图片路径
private String fieldRemark; //场地备注
private Set fieldParttimes = new HashSet(0); //场地对应的场地时间段
// Constructors
/** default constructor */
public Field() {
}
/** minimal constructor */
public Field(int fieldId) {
this.fieldId = fieldId;
}
/** full constructor */
public Field(int fieldId, int fieldTypeId, String fieldNumber,
boolean fieldStatus, String fieldPic, String fieldRemark,
Set fieldParttimes) {
this.fieldId = fieldId;
this.fieldTypeId = fieldTypeId;
this.fieldNumber = fieldNumber;
this.fieldStatus = fieldStatus;
this.fieldPic = fieldPic;
this.fieldRemark = fieldRemark;
this.fieldParttimes = fieldParttimes;
}
public Field(int fieldId, int fieldTypeId, String fieldNumber,
String fieldPic, String fieldRemark) {
this.fieldId = fieldId;
this.fieldTypeId = fieldTypeId;
this.fieldNumber = fieldNumber;
this.fieldPic = fieldPic;
this.fieldRemark = fieldRemark;
}
public Field(int fieldTypeId, String fieldNumber,
String fieldPic, String fieldRemark) {
this.fieldTypeId = fieldTypeId;
this.fieldNumber = fieldNumber;
this.fieldPic = fieldPic;
this.fieldRemark = fieldRemark;
}
// Property accessors
public int getFieldId() {
return this.fieldId;
}
public void setFieldId(int fieldId) {
this.fieldId = fieldId;
}
public int getFieldTypeId() {
return fieldTypeId;
}
public void setFieldTypeId(int fieldTypeId) {
this.fieldTypeId = fieldTypeId;
}
public String getFieldNumber() {
return this.fieldNumber;
}
public void setFieldNumber(String fieldNumber) {
this.fieldNumber = fieldNumber;
}
public boolean getFieldStatus() {
return this.fieldStatus;
}
public void setFieldStatus(boolean fieldStatus) {
this.fieldStatus = fieldStatus;
}
public String getFieldPic() {
return this.fieldPic;
}
public void setFieldPic(String fieldPic) {
this.fieldPic = fieldPic;
}
public String getFieldRemark() {
return this.fieldRemark;
}
public void setFieldRemark(String fieldRemark) {
this.fieldRemark = fieldRemark;
}
public Set getFieldParttimes() {
return this.fieldParttimes;
}
public void setFieldParttimes(Set fieldParttimes) {
this.fieldParttimes = fieldParttimes;
}
@Override
public String toString() {
return "Field [fieldId=" + fieldId + ", fieldTypeId=" + fieldTypeId
+ ", fieldNumber=" + fieldNumber + ", fieldStatus="
+ fieldStatus + ", fieldPic=" + fieldPic + ", fieldRemark="
+ fieldRemark + ", fieldParttimes=" + fieldParttimes + "]";
}
}