mysql数据库连接工具类C3P0

 package com.dl.network_flow.db;

 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.sql.Timestamp;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.apache.log4j.Logger;

 /*oracle和mysql的分页区别：
  * 1、语句的记录起始部分不一样，oralce是“记录查询结果的结束行”和“查询结果的开始行”，mysql是从“记录起始行”和“该页显示的条数”
  * 2、数据基数：oracle是从1开始，mysql是从0开始
  * */
 public class BaseDao {

     protected Logger log = Logger.getLogger(this.getClass());

     /**
      * 执行新增和修改的数据库操作,不用处理返回的ResultSet结果集
      *
      * @param sql
      *            sql语句
      * @param params
      *            参数，若为日期，需要特别处理
      * @return
      */
     public int executeSql(String sql, Object[] params) {
         Connection connection = null;
         PreparedStatement preparedStatement = null;
         ResultSet resultSet = null;

         try {
             connection = ConnectionFactory.getInstance().getConnection();
             preparedStatement = connection.prepareStatement(sql);
             // log.debug("executeSql sql = " + sql);
             // log.debug("params = " + params);
             if (params != null) {
                 // 设置sql语句参数
                 for (int i = 0; i < params.length; i++) {
                     // log.debug("params[i] = " + params[i]);
                     if (params[i] != null) {
                         if (params[i] instanceof java.util.Date) {
                             preparedStatement
                                     .setTimestamp(i + 1, new Timestamp(
                                             ((Date) params[i]).getTime()));
                         } else {
                             preparedStatement.setObject(i + 1, params[i]);
                         }
                     } else {
                         preparedStatement.setString(i + 1, "");
                     }
                 }
             }
             return preparedStatement.executeUpdate();
         } catch (SQLException e) {
             log.error(e.getMessage() + "code = " + e.getErrorCode()+",sql:"+sql);
             // /throw new RuntimeException(e.getMessage() + "code = " +
             // e.getErrorCode());
             return -1;
         } finally {
             ConnectionFactory.getInstance().closeConnection(connection,
                     preparedStatement, resultSet);
         }

     }

     /*
      * 批量执行sql语句 paramsArr是个2维数组，第一维度表示各条记录，第二维度表示各条记录里的各个parameter值
      */
     public int[] executeBatchSql(String sql, Object[][] paramsArr) {
         Connection connection = null;
         PreparedStatement preparedStatement = null;
         ResultSet resultSet = null;
         try {
             connection = ConnectionFactory.getInstance().getConnection();
             preparedStatement = connection.prepareStatement(sql);

             if (paramsArr != null) {
                 for (int s = 0; s < paramsArr.length; s++) {
                     Object[] params = paramsArr[s];
                     if (params != null) {
                         // 设置sql语句参数
                         for (int i = 0; i < params.length; i++) {
                             if (params[i] != null) {
                                 if (params[i] instanceof java.util.Date) {
                                     preparedStatement.setTimestamp(
                                             i + 1,
                                             new Timestamp(((Date) params[i])
                                                     .getTime()));
                                 } else {
                                     preparedStatement.setObject(i + 1,
                                             params[i]);
                                 }
                             } else {
                                 preparedStatement.setString(i + 1, "");
                             }
                         }
                         preparedStatement.addBatch();// /批量增加1条
                     }
                 }
             }
             return preparedStatement.executeBatch();// /批量执行
         } catch (SQLException e) {
             e.printStackTrace();
 //            log.error(e.getMessage() + "code = " + e.getErrorCode());
             log.error(e.getMessage() + "code = " + e.getErrorCode()+",sql:"+sql);
         } finally {
             ConnectionFactory.getInstance().closeConnection(connection,preparedStatement, resultSet);
         }
         return null;
     }

     /**
      *   批量执行不同的sql语句 不包含查询
      * executeBatchSql
      * @time 2015年9月23日下午4:23:16
      * @packageName com.dl.ios6
      * @param sql  多个sql语句的数组
      * @return
      */
     public int[] executeBatchSql(String[] sql){
         Connection connection = null;
         PreparedStatement preparedStatement = null;
         ResultSet resultSet = null;

         connection = ConnectionFactory.getInstance().getConnection();
         Statement state = null;
         try {
             if(sql!=null&&sql.length>0){
                 boolean autoCommit = connection.getAutoCommit();
                 connection.setAutoCommit(false);
                 state = connection.createStatement();
                 for (int i = 0; i < sql.length; i++) {
                     state.addBatch(sql[i]);
                 }
                 int j[] = state.executeBatch();
                 connection.commit();
                 connection.setAutoCommit(autoCommit);
                 state.close();
                 ConnectionFactory.getInstance().closeConnection(connection, preparedStatement, resultSet);
                 return j;
             }
         } catch (SQLException e) {
             state = null;
             ConnectionFactory.getInstance().closeConnection(connection, preparedStatement, resultSet);
         }
         return null;
     }

     /*
      * 批量执行sql语句 paramsArr是个2维数组，第一维度表示各条记录，第二维度表示各条记录里的各个parameter值
      */
     public int[] executeBatchSql(String sql, List<Object[]> paramsList) {
         Connection connection = null;
         PreparedStatement preparedStatement = null;
         ResultSet resultSet = null;
         try {

             connection = ConnectionFactory.getInstance().getConnection();
             preparedStatement = connection.prepareStatement(sql);

             if (paramsList == null){
                 return null;
             }
             // /遍历所有记录
             for (int i = 0; i < paramsList.size(); i++) {
                 Object[] tObj = paramsList.get(i);
                 if (tObj == null) {
                     continue;
                 }
                 // /遍历记录中的每个字段
                 for (int j = 0; j < tObj.length; j++) {
                     Object curObj = tObj[j];
                     if (curObj != null) {
                         if (curObj instanceof java.util.Date) {
                             preparedStatement.setTimestamp(j + 1,
                                     new Timestamp(((java.util.Date) curObj).getTime()));
                         } else {
                             preparedStatement.setObject(j + 1, curObj);
                         }
                     } else{
                         preparedStatement.setString(j + 1, "");
                     }
                 }// /遍历记录中的每个字段
                 preparedStatement.addBatch();// /添加一条记录
             }// /遍历所有记录

             return preparedStatement.executeBatch();// /批量执行
         } catch (SQLException e) {
             e.printStackTrace();
             log.error(e.getMessage() + "code = " + e.getErrorCode()+",sql:"+sql);
         } finally {
             ConnectionFactory.getInstance().closeConnection(connection,
                     preparedStatement, resultSet);
         }
         return null;
     }

     /*
      * 执行sql操作，把sql和params结合成一个sql语句
      * 执行sql查询的结果集交给sqlExecute这个接口函数处理，处理后封装的对象放到List里
      */
     public List<Map<String, Object>> queryForList(String sql, Object[] params) {
         Connection connection = null;
         PreparedStatement preparedStatement = null;
         ResultSet resultSet = null;

         try {
             connection = ConnectionFactory.getInstance().getConnection();
             preparedStatement = connection.prepareStatement(sql);
             // 设置sql语句参数
             if (params != null) {
                 for (int i = 0; i < params.length; i++) {
                     // log.debug("params[i] = " + params[i]);
                     preparedStatement.setObject(i + 1, params[i]);
                 }
             }
             resultSet = preparedStatement.executeQuery();
             ResultSetMetaData md = resultSet.getMetaData(); // 得到结果集(rs)的结构信息，比如字段数、字段名等
             int columnCount = md.getColumnCount();
             List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
             Map<String, Object> rowData = new HashMap<String, Object>();
             while (resultSet.next()) {
                 rowData = new HashMap<String, Object>(columnCount);
                 for (int i = 1; i <= columnCount; i++) {
                     rowData.put(md.getColumnLabel(i), resultSet.getObject(i));
                 }
                 list.add(rowData);
             }

             return list;
         } catch (SQLException e) {
 //            log.error(e.getMessage());
             log.error(e.getMessage() + "code = " + e.getErrorCode()+",sql:"+sql);
         } finally {
             ConnectionFactory.getInstance().closeConnection(connection,
                     preparedStatement, resultSet);
         }
         return null;
     }

     public Map<String, Object> queryForMap(String sql, Object[] params) {
         Connection connection = null;
         PreparedStatement preparedStatement = null;
         ResultSet resultSet = null;

         try {
             connection = ConnectionFactory.getInstance().getConnection();
             preparedStatement = connection.prepareStatement(sql);
             // 设置sql语句参数
             if (params != null) {
                 for (int i = 0; i < params.length; i++) {
                     // log.debug("params[i] = " + params[i]);
                     preparedStatement.setObject(i + 1, params[i]);
                 }
             }
             resultSet = preparedStatement.executeQuery();
             ResultSetMetaData md = resultSet.getMetaData(); // 得到结果集(rs)的结构信息，比如字段数、字段名等
             int columnCount = md.getColumnCount();
             Map<String, Object> rowData = new HashMap<String, Object>();
             while (resultSet.next()) {
                 rowData = new HashMap<String, Object>(columnCount);
                 for (int i = 1; i <= columnCount; i++) {
                     rowData.put(md.getColumnLabel(i), resultSet.getObject(i));
                 }
                 break;
             }

             return rowData;
         } catch (SQLException e) {
             log.error(e.getMessage() + "code = " + e.getErrorCode()+",sql:"+sql);
         } finally {
             ConnectionFactory.getInstance().closeConnection(connection,preparedStatement, resultSet);
         }
         return null;
     }

 }

 package com.dl.network_flow.db;

 import java.beans.PropertyVetoException;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import com.dl.network_flow.utils.PropertyUtils;
 import com.mchange.v2.c3p0.ComboPooledDataSource;
 /*使用C3P0连接池
  * 从C3P0连接池ComboPooledDataSource中获得Connection
  * 关闭Connection
  * */
 public class ConnectionFactory
 {

 //    private static Logger log = Logger.getLogger(ConnectionFactory.class);

     public static ConnectionFactory connectionFactory = new ConnectionFactory();

     private ComboPooledDataSource ds; ///C3P0连接池

     ///初始化数据库连接池的参数：5个
     ///给C3P0连接池指定DriverClass、JdbcUrl、User、Password、InitialPoolSize、MaxPoolSize、CheckoutTimeout
     private ConnectionFactory() {
         ds = new ComboPooledDataSource();
         try {
             String DriverClass = PropertyUtils.getValue("DriverClass");
             //log.debug("DriverClass = " + DriverClass);
             if (DriverClass != null) {
                 ds.setDriverClass(DriverClass);
             }
         }
         catch (PropertyVetoException e) {
         }
         String JdbcUrl = PropertyUtils.getValue("JdbcUrl");
         //log.debug("JdbcUrl = " + JdbcUrl);
         if (JdbcUrl != null) {
             ds.setJdbcUrl(JdbcUrl);
         }

         String User = PropertyUtils.getValue("User");
         //log.debug("User = " + User);
         if (User != null) {
             ds.setUser(User);
         }

         String Password = PropertyUtils.getValue("Password");
         //log.debug("Password = " + Password);
         if (Password != null) {
             ds.setPassword(Password);
         }

         String InitialPoolSize = PropertyUtils.getValue("InitialPoolSize");
         //log.debug("InitialPoolSize = " + InitialPoolSize);
         if (InitialPoolSize != null) {
             ds.setInitialPoolSize(Integer.parseInt(InitialPoolSize));
         }

         String MaxPoolSize = PropertyUtils.getValue("MaxPoolSize");
         //log.debug("MaxPoolSize = " + MaxPoolSize);
         if (MaxPoolSize != null) {
             ds.setMaxPoolSize(Integer.parseInt(MaxPoolSize));
         }

         String CheckoutTimeout = PropertyUtils.getValue("CheckoutTimeout");
         //log.debug("CheckoutTimeout = " + CheckoutTimeout);
         if (CheckoutTimeout != null) {
            ds.setCheckoutTimeout(Integer.parseInt(CheckoutTimeout));
         }

         String MaxIdleTime = PropertyUtils.getValue("MaxIdleTime");
         if(MaxIdleTime != null){
              ds.setMaxIdleTime(Integer.parseInt(MaxIdleTime));
         }

     }

     public static ConnectionFactory getInstance() {
         return connectionFactory;
     }

     /**
      * 获得数据库连接
      *
      * @return
      */
     public Connection getConnection() {
         try {

             return ds.getConnection();
         } catch (SQLException e) {
             throw new RuntimeException(e.getMessage() + "code = " + e.getErrorCode());
         }
     }

     /**
      * 关闭数据库连接
      *
      * @param connection
      * @param prepareStatement
      * @param resultSet
      */
     public void closeConnection(Connection connection, PreparedStatement prepareStatement, ResultSet resultSet) {

         try {
             if (resultSet != null) {
                 resultSet.close();
             }
             if (prepareStatement != null) {
                 prepareStatement.close();
             }
             if (connection != null) {
                 connection.close();
             }
         } catch (SQLException e) {
             throw new RuntimeException(e.getMessage() + "code = " + e.getErrorCode());
         }
     }

     public static void main(String[] args)
     {

     }
 }

 package com.dl.network_flow.utils;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.Properties;

 /**
  * Created by IntelliJ IDEA.
  * User: Administrator
  * Date: 2010-4-23
  * Time: 18:02:11
  * To change this template use File | Settings | File Templates.
  */
 public class PropertyUtils {
     private Properties pro = new Properties();
     private static PropertyUtils propertyUtils = new PropertyUtils();

     private PropertyUtils() {
         InputStream in = null;
         try {
 //          pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
             in = Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties");
             BufferedReader bf = new BufferedReader(new InputStreamReader(in));
             pro.load(bf);
         } catch (IOException e) {
             throw new RuntimeException(e.getMessage());
         } finally {
             try {
                 if(in!=null){
                     in.close();
                 }
             } catch (IOException e) {
             }
         }
     }

     public static PropertyUtils getInstance(){
         return propertyUtils;
     }

     public static String getValue(String key) {
             return (String)getInstance().pro.get(key);
     }

     public static void main(String[] args) throws Exception {
         System.out.println(getValue("abcd"));
     }

 }

db.properties 文件内容

#本地
JdbcUrl=jdbc:mysql://IP地址:3306/数据库名称?autoReconnect=true&autoReconnectForPools=true
DriverClass=com.mysql.jdbc.Driver
User=用户名
Password=数据库密码

#初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3 initialPoolSize
InitialPoolSize=15

#连接池中保留的最大连接数。Default: 15 maxPoolSize
MaxPoolSize=30
#sp计费信息实时入库，每次入库的数量
spsynCacheSize=30

#最大空闲时间
MaxIdleTime=120