简易高重用的jdbcutils工具封装实现类以及简易连接池实现

最新推荐文章于 2022-04-25 00:29:44 发布

转载最新推荐文章于 2022-04-25 00:29:44 发布 · 801 阅读

文章标签：

#jdbc

java 专栏收录该内容

171 篇文章

订阅专栏

本文介绍了一个简易的JDBC实现与连接池构造方法，包括接口定义、类实现及测试验证，旨在提供轻量级的数据库操作解决方案。

由于现在发现做个小项目都是导入n多的依赖包,很烦琐,只想快点开发完一个个的小需求项目,这个时候真心不想用框架,只能自己写个jdbcutils,虽然网上有很多有apache的,阿里的,但是感觉用过后都不怎么顺手,然后自己花了点时间写个新的,不喜勿喷

1.我们要写个resultset集合转成bean的回调接口,这个用过spring jdbc的人都知道这玩意

[java]view plaincopy 
    
 package org.simple.mvc.jdbc.bean;  
   
 import java.sql.ResultSet;  
 import java.sql.SQLException;  
   
 public interface RowMapper<T> {  
   
     public abstract T mapRow(ResultSet rs) throws SQLException;  
   
 }

2.先来个基本的jdbc操作接口吧,这样好规范点

[java]view plaincopy 
    
 package org.simple.mvc.jdbc;  
   
 import java.sql.Connection;  
 import java.sql.PreparedStatement;  
 import java.sql.ResultSet;  
 import java.sql.SQLException;  
 import java.sql.Statement;  
 import java.util.List;  
 import java.util.Map;  
   
 import javax.sql.DataSource;  
   
 import org.simple.mvc.jdbc.bean.RowMapper;  
   
 public interface JdbcOperation {  
   
     /** 
      * update或delete功能 
      *  
      * @param sql 
      * @param params 
      * @return 变更记录数 
      * @throws SQLException 
      */  
     public abstract int execute(String sql, Object[] params) throws SQLException;  
   
     /** 
      * update或delete功能 
      *  
      * @param sql 
      * @return 变更记录数 
      * @throws SQLException 
      */  
     public abstract int execute(String sql) throws SQLException;  
   
     /** 
      * 批处理update或delete功能 
      *  
      * @param sql 
      * @param params 
      * @return 变更记录数 
      * @throws SQLException 
      */  
     public abstract int executeBatch(String sql, List<Object[]> params) throws SQLException;  
   
     /** 
      * 批处理update或delete功能 
      *  
      * @param sql 
      * @param params 
      * @return 变更记录数 
      * @throws SQLException 
      */  
     public abstract int executeBatch(String sql) throws SQLException;  
   
     /** 
      * select功能 
      *  
      * @param sql 
      * @param params 
      * @return 原生ResultSet数据集合 
      * @throws SQLException 
      */  
     public abstract ResultSet queryForResultSet(String sql, Object[] params) throws SQLException;  
   
     /** 
      * select功能 
      *  
      * @param sql 
      * @return 原生ResultSet数据集合 
      * @throws SQLException 
      */  
     public abstract ResultSet queryForResultSet(String sql) throws SQLException;  
   
     /** 
      * select功能 
      *  
      * @param sql 
      * @param params 
      * @return List<?>数据集合 
      * @throws SQLException 
      */  
     public abstract List<?> queryForBean(String sql, Object[] params, RowMapper<?> mapper) throws SQLException;  
   
     /** 
      * select功能 
      *  
      * @param sql 
      * @param params 
      * @return List<?>数据集合 
      * @throws SQLException 
      */  
     public abstract List<?> queryForBean(String sql, RowMapper<?> mapper) throws SQLException;  
   
     /** 
      * select功能 
      *  
      * @param sql 
      * @param params 
      * @return List<Map<String, Object>>数据集合 
      * @throws SQLException 
      */  
     public abstract List<Map<String, Object>> queryForMap(String sql, Object[] params) throws SQLException;  
   
     /** 
      * select功能 
      *  
      * @param sql 
      * @param params 
      * @return List<Map<String, Object>>数据集合 
      * @throws SQLException 
      */  
     public abstract List<Map<String, Object>> queryForMap(String sql) throws SQLException;  
   
     /** 
      * select功能 
      *  
      * @param sql 
      * @return 统计单列记录数 
      * @throws SQLException 
      */  
     public abstract int queryForInt(String sql, Object[] params) throws SQLException;  
   
     /** 
      * select功能 
      *  
      * @param sql 
      * @return 统计单列记录数 
      * @throws SQLException 
      */  
     public abstract int queryForInt(String sql) throws SQLException;  
   
     /** 
      * 释放Connection资源 
      *  
      * @param x 
      */  
     public abstract void free(Connection x);  
   
     /** 
      * 释放Statement资源 
      *  
      * @param x 
      */  
     public abstract void free(Statement x);  
   
     /** 
      * 释放PreparedStatement资源 
      *  
      * @param x 
      */  
     public abstract void free(PreparedStatement x);  
   
     /** 
      * 释放ResultSet资源 
      *  
      * @param x 
      */  
     public abstract void free(ResultSet x);  
   
     /** 
      * 设置数据源 
      *  
      * @param dataSource 
      */  
     public abstract void setDataSource(DataSource dataSource);  
   
     /** 
      * 获取数据库链接 
      *  
      * @return Connection 
      */  
     public abstract Connection getConnection();  
   
     /** 
      * 获取数据库链接 
      *  
      * @param autoCommit 
      * @return Connection 
      */  
     public Connection getConnection(boolean autoCommit);  
   
 }  

3.实现我们接口里面的方法

[java]view plaincopy 
    
 package org.simple.mvc.jdbc.impl;  
   
 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.util.ArrayList;  
 import java.util.HashMap;  
 import java.util.List;  
 import java.util.Map;  
   
 import javax.sql.DataSource;  
   
 import org.simple.mvc.jdbc.JdbcOperation;  
 import org.simple.mvc.jdbc.bean.RowMapper;  
   
 /** 
  * 简易JDBC实现类 
  *  
  * @author shadow 
  *  
  */  
 public class SimpleJdbc implements JdbcOperation {  
   
     private static final boolean AUTO_COMMIT = true;  
   
     private DataSource dataSource;  
   
     public SimpleJdbc() {  
   
     }  
   
     public SimpleJdbc(DataSource dataSource) {  
         this.dataSource = dataSource;  
     }  
   
     public Connection getConnection() {  
         return getConnection(AUTO_COMMIT);  
     }  
   
     public Connection getConnection(boolean autoCommit) {  
         try {  
             Connection conn = dataSource.getConnection();  
             if (!autoCommit)  
                 conn.setAutoCommit(autoCommit);  
             return conn;  
         } catch (SQLException e) {  
             e.printStackTrace();  
         }  
         return null;  
     }  
   
     @Override  
     public int execute(String sql, Object[] params) throws SQLException {  
         Connection conn = getConnection(false);  
         PreparedStatement stmt = null;  
         int result = -1;  
         try {  
             stmt = createPreparedStatement(conn, sql, params);  
             result = stmt.executeUpdate();  
             conn.commit();  
         } catch (Exception e) {  
             conn.rollback();  
             e.printStackTrace();  
         } finally {  
             free(stmt);  
             free(conn);  
         }  
         return result;  
     }  
   
     @Override  
     public int execute(String sql) throws SQLException {  
         return execute(sql, new Object[] {});  
     }  
   
     @Override  
     public ResultSet queryForResultSet(String sql, Object[] params) throws SQLException {  
         Connection conn = getConnection();  
         PreparedStatement stmt = null;  
         try {  
             stmt = createPreparedStatement(conn, sql, params);  
             return stmt.executeQuery();  
         } catch (Exception e) {  
             e.printStackTrace();  
         } finally {  
             free(stmt);  
             free(conn);  
         }  
         return null;  
     }  
   
     @Override  
     public ResultSet queryForResultSet(String sql) throws SQLException {  
         return queryForResultSet(sql, new Object[] {});  
     }  
   
     @Override  
     public int queryForInt(String sql, Object[] params) throws SQLException {  
         Connection conn = getConnection();  
         PreparedStatement stmt = null;  
         ResultSet rs = null;  
         try {  
             stmt = createPreparedStatement(conn, sql, params);  
             rs = createResultSet(stmt);  
             while (rs.next()) {  
                 return rs.getInt(1);  
             }  
         } catch (Exception e) {  
             e.printStackTrace();  
         } finally {  
             free(rs);  
             free(stmt);  
             free(conn);  
         }  
         return 0;  
     }  
   
     @Override  
     public int queryForInt(String sql) throws SQLException {  
         return queryForInt(sql, new Object[] {});  
     }  
   
     @Override  
     public List<?> queryForBean(String sql, Object[] params, RowMapper<?> mapper) throws SQLException {  
         Connection conn = getConnection();  
         PreparedStatement stmt = null;  
         ResultSet rs = null;  
         List<Object> list = null;  
         try {  
             stmt = createPreparedStatement(conn, sql, params);  
             rs = createResultSet(stmt);  
             list = new ArrayList<Object>();  
             while (rs.next()) {  
                 list.add(mapper.mapRow(rs));  
             }  
         } catch (Exception e) {  
             e.printStackTrace();  
         } finally {  
             free(rs);  
             free(stmt);  
             free(conn);  
         }  
         return list;  
     }  
   
     @Override  
     public List<?> queryForBean(String sql, RowMapper<?> mapper) throws SQLException {  
         return queryForBean(sql, new Object[] {}, mapper);  
     }  
   
     @Override  
     public List<Map<String, Object>> queryForMap(String sql, Object[] params) throws SQLException {  
         Connection conn = getConnection();  
         PreparedStatement stmt = null;  
         ResultSet rs = null;  
         try {  
             stmt = createPreparedStatement(conn, sql, params);  
             rs = createResultSet(stmt);  
   
             List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
             Map<String, Object> map = null;  
             ResultSetMetaData rsd = rs.getMetaData();  
             int columnCount = rsd.getColumnCount();  
   
             while (rs.next()) {  
                 map = new HashMap<String, Object>(columnCount);  
                 for (int i = 1; i < columnCount; i++) {  
                     map.put(rsd.getColumnName(i), rs.getObject(i));  
                 }  
                 list.add(map);  
             }  
   
             return list;  
         } catch (Exception e) {  
             e.printStackTrace();  
         } finally {  
             free(rs);  
             free(stmt);  
             free(conn);  
         }  
         return null;  
     }  
   
     @Override  
     public List<Map<String, Object>> queryForMap(String sql) throws SQLException {  
         return queryForMap(sql, new Object[] {});  
     }  
   
     @Override  
     public int executeBatch(String sql, List<Object[]> params) throws SQLException {  
         int result = 0;  
         Connection conn = getConnection(false);  
         PreparedStatement stmt = null;  
         try {  
             stmt = conn.prepareStatement(sql);  
             for (int i = 0; i < params.size(); i++) {  
                 Object[] param = params.get(i);  
                 for (int j = 0; j < param.length; j++)  
                     stmt.setObject(j + 1, param[j]);  
                 stmt.addBatch();  
                 if (i % 1000 == 0) {  
                     stmt.executeBatch();  
                     stmt.clearBatch();  
                 }  
             }  
             stmt.executeBatch();  
             conn.commit();  
             result = params.size();  
         } catch (Exception e) {  
             conn.rollback();  
             e.printStackTrace();  
         } finally {  
             free(stmt);  
             free(conn);  
         }  
         return result;  
     }  
   
     @Override  
     public int executeBatch(String sql) throws SQLException {  
         return executeBatch(sql, new ArrayList<Object[]>());  
     }  
   
     public DataSource getDataSource() {  
         return dataSource;  
     }  
   
     public void setDataSource(DataSource dataSource) {  
         this.dataSource = dataSource;  
     }  
   
     @Override  
     public void free(Connection x) {  
         if (x != null)  
             try {  
                 x.close();  
             } catch (SQLException e) {  
                 e.printStackTrace();  
             }  
     }  
   
     @Override  
     public void free(Statement x) {  
         if (x != null)  
             try {  
                 x.close();  
             } catch (SQLException e) {  
                 e.printStackTrace();  
             }  
     }  
   
     @Override  
     public void free(PreparedStatement x) {  
         if (x != null)  
             try {  
                 x.close();  
             } catch (SQLException e) {  
                 e.printStackTrace();  
             }  
     }  
   
     @Override  
     public void free(ResultSet x) {  
         if (x != null)  
             try {  
                 x.close();  
             } catch (SQLException e) {  
                 e.printStackTrace();  
             }  
     }  
   
     public PreparedStatement createPreparedStatement(Connection conn, String sql, Object[] params) throws SQLException {  
         PreparedStatement stmt = conn.prepareStatement(sql);  
         for (int i = 0; i < params.length; i++)  
             stmt.setObject(i + 1, params[i]);  
         return stmt;  
     }  
   
     public ResultSet createResultSet(PreparedStatement stmt) throws SQLException {  
         return stmt.executeQuery();  
     }  
 }  

4.然后实现我们一个连接池吧,不喜欢dbcp,c3p0的话,那些要依赖包的导致项目重量上去了

[java]view plaincopy 
    
 package org.simple.mvc.jdbc.source;  
   
 import java.io.PrintWriter;  
 import java.lang.reflect.InvocationHandler;  
 import java.lang.reflect.Method;  
 import java.lang.reflect.Proxy;  
 import java.sql.Connection;  
 import java.sql.DriverManager;  
 import java.sql.SQLException;  
 import java.util.LinkedList;  
   
 import javax.sql.DataSource;  
   
 /** 
  * 简易连接池实现类 
  *  
  * @author shadow 
  *  
  */  
 public class SimpleDataSource implements DataSource {  
   
     private int poolSize = 5;  
   
     private LinkedList<Connection> pool = new LinkedList<Connection>();  
   
     public SimpleDataSource(String driver, String url, String name, String pwd) {  
         this(driver, url, name, pwd, 5);  
     }  
   
     public SimpleDataSource(String driver, String url) {  
         this(driver, url, "", "", 5);  
     }  
   
     public SimpleDataSource(String driver, String url, String name, String pwd, int poolSize) {  
         try {  
             Class.forName(driver);  
             this.poolSize = poolSize;  
             if (poolSize <= 0) {  
                 throw new RuntimeException("初始化池大小失败: " + poolSize);  
             }  
   
             for (int i = 0; i < poolSize; i++) {  
                 Connection con = DriverManager.getConnection(url, name, pwd);  
                 con = ConnectionProxy.getProxy(con, pool);// 获取被代理的对象  
                 pool.add(con);// 添加被代理的对象  
             }  
         } catch (Exception e) {  
             throw new RuntimeException(e.getMessage(), e);  
         }  
   
     }  
   
     /** 获取池大小 */  
     public int getPoolSize() {  
         return poolSize;  
   
     }  
   
     /** 不支持日志操作 */  
     public PrintWriter getLogWriter() throws SQLException {  
         throw new RuntimeException("Unsupport Operation.");  
     }  
   
     public void setLogWriter(PrintWriter out) throws SQLException {  
         throw new RuntimeException("Unsupport operation.");  
     }  
   
     /** 不支持超时操作 */  
     public void setLoginTimeout(int seconds) throws SQLException {  
         throw new RuntimeException("Unsupport operation.");  
     }  
   
     public int getLoginTimeout() throws SQLException {  
         return 0;  
     }  
   
     @SuppressWarnings("unchecked")  
     public <T> T unwrap(Class<T> iface) throws SQLException {  
         return (T) this;  
     }  
   
     public boolean isWrapperFor(Class<?> iface) throws SQLException {  
         return DataSource.class.equals(iface);  
     }  
   
     /** 从池中取一个连接对象,使用了同步和线程调度 */  
     public Connection getConnection() throws SQLException {  
         synchronized (pool) {  
             if (pool.size() == 0) {  
                 try {  
                     pool.wait();  
                 } catch (InterruptedException e) {  
                     throw new RuntimeException(e.getMessage(), e);  
                 }  
                 return getConnection();  
             } else {  
                 return pool.removeFirst();  
             }  
         }  
     }  
   
     public Connection getConnection(String username, String password) throws SQLException {  
         throw new RuntimeException("不支持接收用户名和密码的操作");  
     }  
   
     /** 实现对Connection的动态代理 */  
     static class ConnectionProxy implements InvocationHandler {  
   
         private Object obj;  
         private LinkedList<Connection> pool;  
   
         private ConnectionProxy(Object obj, LinkedList<Connection> pool) {  
             this.obj = obj;  
             this.pool = pool;  
         }  
   
         public static Connection getProxy(Object o, LinkedList<Connection> pool) {  
             Object proxed = Proxy.newProxyInstance(o.getClass().getClassLoader(), new Class[] { Connection.class },  
                     new ConnectionProxy(o, pool));  
             return (Connection) proxed;  
         }  
   
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
             if (method.getName().equals("close")) {  
                 synchronized (pool) {  
                     pool.add((Connection) proxy);  
                     pool.notify();  
                 }  
                 return null;  
             } else {  
                 return method.invoke(obj, args);  
             }  
         }  
   
     }  
   
 }  

5.开始测试下我们刚刚写的玩意,simplejdbc主要是有datasource提供给他就可以了,其他的一律无视,测试里面的user对象我就不提供,里面就是两个属性,id和username,然后生成set和get方法即可,当然这个是演示resultset转成bean的,当然也可以直接使用queryForMap直接查询出map集合,我想接口提供的方法已经足够使用了

[java]view plaincopy 
    
 public static void main(String[] args) throws SQLException {  
         SimpleDataSource dataSource = new SimpleDataSource("org.sqlite.JDBC", "jdbc:sqlite:/E:p1010.db");  
         SimpleJdbc jdbc = new SimpleJdbc(dataSource);  
         List<User> list = (List<User>) jdbc.queryForBean("select * from t_user", new RowMapper<User>() {  
             User user = null;  
   
             @Override  
             public User mapRow(ResultSet rs) throws SQLException {  
                 user = new User();  
                 user.setId(rs.getInt("id"));  
                 user.setUsername(rs.getString("username"));  
                 return user;  
             }  
         });  
         for (User user : list) {  
             System.out.println(user.getId() + "---" + user.getUsername());  
         }  
     }  