Java数据库操作实用工具类-CSDN博客

package com.shxt.util;

import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;

/**
* 用户数据库访问的类
*/
public class DButil {

private Connection conn;
private Statement st;
private PreparedStatement pps;
private ResultSet rs;
private DataSource ds;
/*public String url="jdbc:oracle:thin:@think-THINK:1521:orcl";
private String user="shxt";
private String password="shxt";

static{
  try {
   Class.forName("oracle.jdbc.driver.OracleDriver");
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }
}*/

public DButil(){

}
/**
* 获取连接的方法
* @return Connection 一个有效的数据库连接
*/
/*public Connection getConnection()
{
  try {
   //
   Date date=new Date();
   long start=date.getTime();
   Connection con=DriverManager.getConnection(url,user,password);
   long end=new Date().getTime();
   System.out.println("建立连接耗时"+(end-start)+"ms");
   return con;
  } catch (SQLException e) {
   e.printStackTrace();
  }
  return null;
}*/

public Connection getConnection() {
   try {
    ds = setupDataSource("jdbc.properties");
       Connection con = ds.getConnection();
    return con;
   } catch (SQLException e) {
    e.printStackTrace();
   }
   return null;
  }

public static DataSource setupDataSource(String configFile) {
         BasicDataSource ds = new BasicDataSource();
         try {
             Properties prop = new Properties();
             prop.load(DButil.class.getResourceAsStream(configFile));
             ds.setDriverClassName(prop.getProperty("driverClassName"));
             ds.setUrl(prop.getProperty("url"));
             ds.setUsername(prop.getProperty("username"));
             ds.setPassword(prop.getProperty("password"));
            // ds.setMaxActive(maxActive);
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }

         return ds;
     }

/**
* 用于执行更新的方法
* @param sql String 类型的SQL语句（insert delete update）
* @return Integer 表示受影响的行数
*/
public int update(String sql)
{
  int row=-1;
  try {
   if(conn==null||conn.isClosed()){
     conn=getConnection();
   }
   st=conn.createStatement();
   row=st.executeUpdate(sql);
  } catch (SQLException e) {
   e.printStackTrace();
  }
  finally{
   close();
  }
  return row;
}

/**
* 基于PreparedStatement的修改方法
* @param sql String 类型的SQL语句（insert delete update）
* @param obj 动态参数可以是一个数组
* @return Integer 表示受影响的行数
*/
public int update(String sql,Object ...obj)
{
  try {
   conn=getConnection();
   pps=conn.prepareStatement(sql);
   int length=0;

   //length=obj.length; //依据数组的长度获取到预处理的sql语句中的参数个数
   //通过 ParameterMetaData 获取到预处理的sql语句中的参数个数
   ParameterMetaData pmd=pps.getParameterMetaData();
   length=pmd.getParameterCount();
   for(int i=0;i<length;i++)
   {
    pps.setObject(i+1, obj[i]);
   }
   return pps.executeUpdate();
  } catch (SQLException e) {
   e.printStackTrace();
  }finally{
   close();
  }

  return -1;
}

public Map<String,Object> getOneRow(String sql)
{
  List<Map<String,Object>> list=queryToList(sql);
  return list.size()>0?list.get(0):null;
}

public List<Map<String,Object>> queryToList(String sql)
{

  List<Map<String, Object>> data=new LinkedList<Map<String, Object>>();
  try {
   conn=getConnection();
   st=conn.createStatement();
   rs=st.executeQuery(sql);
   //ResultSetMetaData 是结果集元数据他可以获取到结果中的信息例如：结果集中共包括多少列，每列的名称和类型等信息
   ResultSetMetaData rsmd=rs.getMetaData();
   int columncount=rsmd.getColumnCount();
   //while条件成立表明结果集中存在数据
   while(rs.next())
   {
    //创建一个HashMap用于存储一条数据
    HashMap<String, Object> onerow=new HashMap<String, Object>();
    //for循环每循环一次表示获取到一条数据的一个属性（字段）
    for(int i=0;i<columncount;i++)
    {
     String columnName=rsmd.getColumnName(i+1);
     onerow.put(columnName, rs.getObject(i+1));
    }
    data.add(onerow);
   }
  } catch (SQLException e) {
   e.printStackTrace();
  }
  finally{
   close();
  }
  return data;
}

/**
* 返回查询结果列表,使用的是预编绎SQL 语句对象PreparedStatement
* 形如：[{TEST_NAME=aaa, TEST_NO=2, TEST_PWD=aaa}, {TEST_NAME=bbb, TEST_NO=3, TEST_PWD=bbb}]
* @param sql
* @param paramValues
* @return List<Map<String,Object>>
*/
public List<Map<String,Object>> queryWithParam(String sql,Object ...paramValues){
  //创建集合列表用以保存所有查询到的记录
  List<Map<String, Object>> list=new LinkedList<Map<String, Object>>();
  try {
   if(conn==null||conn.isClosed()){
     conn=getConnection();
   }
   pps = conn.prepareStatement(sql);
   for (int i = 0; i < paramValues.length; i++) {
    pps.setObject(i + 1, paramValues[i]);
   }
   rs = pps.executeQuery();
   //ResultSetMetaData 是结果集元数据，可获取关于 ResultSet 对象中列的类型和属性信息的对象例如：结果集中共包括多少列，每列的名称和类型等信息
   ResultSetMetaData rsmd=rs.getMetaData();
   //获取结果集中的列数
   int columncount=rsmd.getColumnCount();
   //while条件成立表明结果集中存在数据
   while (rs.next()) {
    //创建一个HashMap用于存储一条数据
    HashMap<String, Object> onerow=new HashMap<String, Object>();
    //循环获取结果集中的列名及列名所对应的值，每次循环都得到一个对象，形如：{TEST_NAME=aaa, TEST_NO=2, TEST_PWD=aaa}
    for(int i=0;i<columncount;i++)
    {
     //获取指定列的名称，注意orcle中列名的大小写
     String columnName=rsmd.getColumnName(i+1);
     onerow.put(columnName, rs.getObject(i+1));
    }
    //将获取到的对象onewrow={TEST_NAME=aaa, TEST_NO=2, TEST_PWD=aaa}放到集合列表中
    list.add(onerow);
   }
  }catch (SQLException e) {
   e.printStackTrace();
  }
  finally{
   close();
  }
  return list;
}

public PageBean getPage(String sql,int pagesize,int pagenow)
{
  PageBean pb=new PageBean();
  int end=pagenow*pagesize;
  int start=end-pagesize+1;
  String exesql="select a.* from (select t.*,rownum as rowindex from ("+sql+") t where rownum<="+end+" ) a where a.rowindex>="+start;
  String countsql="select count(*) as rowcount from ("+sql+")";
  pb.setResult(queryToList(exesql));
  pb.setPagenow(pagenow);
  pb.setPagesize(pagesize);
  Map<String,Object> map=this.getOneRow(countsql);
  int rows=Integer.parseInt(map.get("ROWCOUNT").toString());
  pb.setRows(rows);
  int pages=rows%pagesize==0?rows/pagesize:rows/pagesize+1;
  pb.setPages(pages);
  pb.setSql(sql);
  return pb;
}
private void close()
{
     if(rs!=null)
     {
     try {
    rs.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
     }

     if(st!=null)
     {
     try {
       st.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
     }
     if(pps!=null){
     try {
       pps.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
     }
     try {
   if(conn!=null&&!conn.isClosed())
   {
    try {
     conn.close();
    } catch (SQLException e) {
     e.printStackTrace();
    }
   }
  } catch (SQLException e) {
   e.printStackTrace();
  }
}

}

一个使用简单的工具类