服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|

服务器之家 - 编程语言 - JAVA教程 - java常用工具类之数据库连接类(可以连接多种数据库)

java常用工具类之数据库连接类(可以连接多种数据库)

2019-11-24 15:25junjie JAVA教程

这篇文章主要介绍了java常用工具类之数据库连接类,可以连接多种数据库,代码中包含详细注释,需要的朋友可以参考下

依赖包下载

数据库连接类源码:

  1. package com.itjh.javaUtil; 
  2.   
  3. import java.sql.Connection; 
  4. import java.sql.DriverManager; 
  5. import java.sql.PreparedStatement; 
  6. import java.sql.ResultSet; 
  7. import java.sql.ResultSetMetaData; 
  8. import java.sql.SQLException; 
  9. import java.util.ArrayList; 
  10. import java.util.Collections; 
  11. import java.util.HashMap; 
  12. import java.util.List; 
  13. import java.util.Map; 
  14.   
  15. import org.apache.commons.dbcp.ConnectionFactory; 
  16. import org.apache.commons.dbcp.DriverManagerConnectionFactory; 
  17. import org.apache.commons.dbcp.PoolableConnectionFactory; 
  18. import org.apache.commons.dbcp.PoolingDriver; 
  19. import org.apache.commons.dbutils.DbUtils; 
  20. import org.apache.commons.dbutils.QueryRunner; 
  21. import org.apache.commons.dbutils.handlers.MapListHandler; 
  22. import org.apache.commons.pool.ObjectPool; 
  23. import org.apache.commons.pool.impl.GenericObjectPool; 
  24.   
  25. /** 
  26.  * 连接数据库的综合类。</br> 
  27.  * 依赖jar包:commons.dbcp-1.4,commons.dbutils-1.3,commons.pool-1.5.4包。 
  28.  *  
  29.  * @author 宋立君 
  30.  * @date 2014年07月03日 
  31.  */ 
  32.   
  33. public class DBUtil { 
  34.   
  35.     private String dri = null
  36.     private String url = null
  37.     private String username = null
  38.     private String password = null
  39.     private String poolName = null// 连接池名称 
  40.     private ObjectPool connectionPool = null// 连接池 
  41.     // 对应的定时查询类 
  42.     private QueryThread queryThread = null
  43.   
  44.     /** 
  45.      * 功能:构造函数 
  46.      *  
  47.      * @author 宋立君 
  48.      * @date 2014年07月03日 
  49.      * @param dri 
  50.      *      驱动全类名,例如:com.mysql.jdbc.Driver。 
  51.      * @param url 
  52.      *      数据库url连接,例如: 
  53.      *      "jdbc:mysql://127.0.0.1:3306/test?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8" 
  54.      * @param userName 
  55.      *      数据库用户名,例如:root 
  56.      * @param password 
  57.      *      数据库密码,例如:abc 
  58.      * @param poolName 
  59.      *      创建的数据库连接池的名称,例如mypool,注意一个web容器此名称不能重复。 
  60.      */ 
  61.     public DBUtil(String dri, String url, String userName, String password, 
  62.             String poolName) { 
  63.         this.dri = dri; 
  64.         this.url = url; 
  65.         this.username = userName; 
  66.         this.password = password; 
  67.         this.poolName = poolName; 
  68.     } 
  69.   
  70.     /** 
  71.      * 执行sql。 
  72.      *  
  73.      * @param conn 
  74.      *      连接 
  75.      * @param pstm 
  76.      *      PreparedStatement 
  77.      * @return int 执行sql对应的影响行。 
  78.      * @throws SQLException 
  79.      * @author 宋立君 
  80.      * @date 2014年07月03日 
  81.      */ 
  82.     public int execute(Connection conn, PreparedStatement pstm) 
  83.             throws SQLException { 
  84.         try { 
  85.             return pstm.executeUpdate(); 
  86.         } finally { 
  87.             Close(conn); 
  88.         } 
  89.     } 
  90.   
  91.     /** 
  92.      * 查询sql。 
  93.      *  
  94.      * @param conn 
  95.      *      连接 
  96.      * @param pstm 
  97.      *      PreparedStatement 
  98.      * @return List<Map<String,Object>> 查询的结果集 
  99.      * @throws SQLException 
  100.      * @author 宋立君 
  101.      * @date 2014年07月03日 
  102.      */ 
  103.     public List<Map<String, Object>> query(Connection conn, 
  104.             PreparedStatement pstm) throws SQLException { 
  105.         try { 
  106.             return resultSetToList(pstm.executeQuery()); 
  107.         } finally { 
  108.             Close(conn); 
  109.         } 
  110.     } 
  111.   
  112.     /** 
  113.      * 功能:ResultSet 转为List<Map<String,Object>> 
  114.      *  
  115.      *  
  116.      * @param rs 
  117.      *      ResultSet 原始数据集 
  118.      * @return List<Map<String,Object>> 
  119.      * @throws java.sql.SQLException 
  120.      * @author 宋立君 
  121.      * @date 2014年07月03日 
  122.      */ 
  123.     private List<Map<String, Object>> resultSetToList(ResultSet rs) 
  124.             throws java.sql.SQLException { 
  125.         if (rs == null
  126.             return Collections.EMPTY_LIST; 
  127.   
  128.         ResultSetMetaData md = rs.getMetaData(); // 得到结果集(rs)的结构信息,比如字段数、字段名等 
  129.         int columnCount = md.getColumnCount(); // 返回此 ResultSet 对象中的列数 
  130.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>(); 
  131.         Map<String, Object> rowData = new HashMap<String, Object>(); 
  132.         while (rs.next()) { 
  133.             rowData = new HashMap<String, Object>(columnCount); 
  134.             for (int i = 1; i <= columnCount; i++) { 
  135.                 rowData.put(md.getColumnName(i), rs.getObject(i)); 
  136.             } 
  137.             list.add(rowData); 
  138.         } 
  139.         return list; 
  140.     } 
  141.   
  142.     /** 
  143.      * 查询sql语句。 
  144.      *  
  145.      * @param sql 
  146.      *      被执行的sql语句 
  147.      * @return List<Map<String,Object>> 
  148.      * @throws SQLException 
  149.      * @author 宋立君 
  150.      * @date 2014年07月03日 
  151.      */ 
  152.     public List<Map<String, Object>> query(String sql) throws SQLException { 
  153.         List<Map<String, Object>> results = null
  154.         Connection conn = null
  155.         try { 
  156.             conn = getConnection(); 
  157.             QueryRunner qr = new QueryRunner(); 
  158.             results = qr.query(conn, sql, new MapListHandler()); 
  159.         } finally { 
  160.             Close(conn); 
  161.         } 
  162.         return results; 
  163.     } 
  164.   
  165.     /** 
  166.      * 根据参数查询sql语句 
  167.      *  
  168.      * @param sql 
  169.      *      sql语句 
  170.      * @param param 
  171.      *      参数 
  172.      * @return List<Map<String,Object>> 
  173.      * @throws SQLException 
  174.      * @author 宋立君 
  175.      * @date 2014年07月03日 
  176.      */ 
  177.     public List<Map<String, Object>> query(String sql, Object param) 
  178.             throws SQLException { 
  179.         List<Map<String, Object>> results = null
  180.         Connection conn = null
  181.         try { 
  182.             conn = getConnection(); 
  183.             QueryRunner qr = new QueryRunner(); 
  184.             results = (List<Map<String, Object>>) qr.query(conn, sql, param, 
  185.                     new MapListHandler()); 
  186.         } catch (SQLException e) { 
  187.             e.printStackTrace(); 
  188.         } finally { 
  189.             Close(conn); 
  190.         } 
  191.         return results; 
  192.     } 
  193.   
  194.     /** 
  195.      * 执行sql语句 
  196.      *  
  197.      * @param sql 
  198.      *      被执行的sql语句 
  199.      * @return 受影响的行 
  200.      * @throws Exception 
  201.      * @author 宋立君 
  202.      * @date 2014年07月03日 
  203.      */ 
  204.     public int execute(String sql) throws Exception { 
  205.         Connection conn = getConnection(); 
  206.         int rows = 0; 
  207.         try { 
  208.             QueryRunner qr = new QueryRunner(); 
  209.             rows = qr.update(conn, sql); 
  210.         } finally { 
  211.             Close(conn); 
  212.         } 
  213.         return rows; 
  214.     } 
  215.   
  216.     /** 
  217.      * 执行含参数的sql语句 
  218.      *  
  219.      * @param sql 
  220.      *      被执行的sql语句 
  221.      * @param params 
  222.      *      参数 
  223.      * @return 返回受影响的行 
  224.      * @throws Exception 
  225.      * @author 宋立君 
  226.      * @date 2014年07月03日 
  227.      */ 
  228.     public int execute(String sql, Object[] params) throws Exception { 
  229.         Connection conn = getConnection(); 
  230.         int rows = 0; 
  231.         try { 
  232.             QueryRunner qr = new QueryRunner(); 
  233.             rows = qr.update(conn, sql, params); 
  234.         } finally { 
  235.             Close(conn); 
  236.         } 
  237.         return rows; 
  238.     } 
  239.   
  240.     /** 
  241.      * 关闭连接 
  242.      *  
  243.      * @param conn 
  244.      * @throws SQLException 
  245.      * @author 宋立君 
  246.      * @date 2014年07月03日 
  247.      */ 
  248.     public void Close(Connection conn) throws SQLException { 
  249.         if (conn != null) { 
  250.             conn.close(); 
  251.         } 
  252.         DbUtils.closeQuietly(conn); 
  253.     } 
  254.   
  255.     /** 
  256.      * 启动连接池 
  257.      *  
  258.      * @author 宋立君 
  259.      * @date 2014年07月03日 
  260.      */ 
  261.     private void StartPool() { 
  262.         try { 
  263.             Class.forName(dri); 
  264.         } catch (ClassNotFoundException e1) { 
  265.             e1.printStackTrace(); 
  266.         } 
  267.         if (connectionPool != null) { 
  268.             ShutdownPool(); 
  269.         } 
  270.         try { 
  271.             connectionPool = new GenericObjectPool(null); 
  272.             ConnectionFactory connectionFactory = new DriverManagerConnectionFactory( 
  273.                     url, username, password); 
  274.             PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory( 
  275.                     connectionFactory, connectionPool, null"SELECT 1"false
  276.                     true); 
  277.             Class.forName("org.apache.commons.dbcp.PoolingDriver"); 
  278.             PoolingDriver driver = (PoolingDriver) DriverManager 
  279.                     .getDriver("jdbc:apache:commons:dbcp:"); 
  280.             driver.registerPool(poolName, poolableConnectionFactory.getPool()); 
  281.   
  282.         } catch (Exception e) { 
  283.             e.printStackTrace(); 
  284.         } 
  285.         // 开启查询程序 
  286.         queryThread = new QueryThread(this); 
  287.         queryThread.start(); 
  288.     } 
  289.   
  290.     /** 
  291.      * 关闭连接池 
  292.      *  
  293.      * @author 宋立君 
  294.      * @date 2014年07月03日 
  295.      */ 
  296.     private void ShutdownPool() { 
  297.         try { 
  298.             PoolingDriver driver = (PoolingDriver) DriverManager 
  299.                     .getDriver("jdbc:apache:commons:dbcp:"); 
  300.             driver.closePool(poolName); 
  301.             // 关闭定时查询 
  302.             queryThread.setStartQuery(false); 
  303.         } catch (SQLException e) { 
  304.             e.printStackTrace(); 
  305.         } 
  306.     } 
  307.   
  308.     /** 
  309.      * 得到一个连接 
  310.      *  
  311.      * @return 
  312.      * @author 宋立君 
  313.      * @date 2014年07月03日 
  314.      */ 
  315.     public synchronized Connection getConnection() { 
  316.         Connection conn = null
  317.         try { 
  318.             if (connectionPool == null
  319.                 StartPool(); 
  320.             conn = DriverManager.getConnection("jdbc:apache:commons:dbcp:" 
  321.                     + poolName); 
  322.         } catch (Exception e) { 
  323.             e.printStackTrace(); 
  324.         } 
  325.         return conn; 
  326.     } 
  327.   
  328. /** 
  329.  * 当连接池启动后会自动定时查询数据库,防止数据库连接超时。 
  330.  *  
  331.  * @author 宋立君 
  332.  * @date 2014年07月03日 
  333.  */ 
  334. class QueryThread extends Thread { 
  335.   
  336.     private DBUtil dbUtil = null
  337.     // 是否开启查询 
  338.     private boolean startQuery = true
  339.   
  340.     /** 
  341.      * 功能:对应的数据库连接。 
  342.      *  
  343.      * @author 宋立君 
  344.      * @date 2014年07月03日 
  345.      * @param dbUtil 
  346.      *      数据库连接 
  347.      */ 
  348.     public QueryThread(DBUtil dbUtil) { 
  349.         this.dbUtil = dbUtil; 
  350.     } 
  351.   
  352.     public void run() { 
  353.         while (true) { 
  354.             try { 
  355.                 if (startQuery) { 
  356.                     this.dbUtil.query("select 1"); 
  357.                 } 
  358.                 // System.out.println(startQuery+"  123"); 
  359.             } catch (Exception e) { 
  360.                 e.printStackTrace(); 
  361.             } finally { 
  362.                 try { 
  363.                     Thread.sleep(120000); 
  364.                 } catch (InterruptedException e) { 
  365.                     e.printStackTrace(); 
  366.                 } 
  367.             } 
  368.         } 
  369.     } 
  370.   
  371.     public void setStartQuery(boolean startQuery) { 
  372.         // System.out.println("startQuery shut:"+startQuery); 
  373.         this.startQuery = startQuery; 
  374.     } 

延伸 · 阅读

精彩推荐