JDBC 连接池封装

最新推荐文章于 2022-07-29 10:20:18 发布
最新推荐文章于 2022-07-29 10:20:18 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： java 文章标签： java mysql jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wtuyzh/article/details/72782603
版权
  1. jdbc.properties
   driver=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/
    charset=?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
    username=root
    password=root
    dbname=student

2.连接池数据源SimpleDataSource

 package dbTools;

    import java.io.*;
    import java.lang.reflect.InvocationHandler;  
    import java.lang.reflect.Method;  
    import java.lang.reflect.Proxy;  
    import java.sql.*;
    import java.util.*;
    import java.util.logging.Logger;
    import javax.sql.DataSource;

    public class SimpleDataSource implements DataSource
    {
            private static int poolSize = 10;       
            private LinkedList<Connection> pool = new LinkedList<Connection>();  

            public SimpleDataSource(String driver, String url, String name, String pwd) {  
                this(driver, url, name, pwd, poolSize);  
            }  

            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);  
                    }  
                }  

            }

            @Override
            public Logger getParentLogger() throws SQLFeatureNotSupportedException
            {
                return null;
            }  
    }

3 jdbc封装DBUtil

        package dbTools;

import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.*;
import javax.sql.DataSource;

public class DBUtil
{
    private static String USERNAME = null;
    private static String PASSWORD = null;
    private static String DRIVER = null;
    private static String URL = null;
    public static String DBNAME = null;
    public static String CHARSET = null;
    private static Connection conn = null;
    private PreparedStatement pst = null;
    private ResultSet rs = null;
    private static DataSource dataSource = null;
    private static final boolean AUTO_COMMIT = true;
    private String SQLTables = "show tables";

    static
    {
        // 创建一个 Properties对象
        Properties pro = new Properties();
        try
        {
            // 通过类加载器将配置文件加载进来
            pro.load(DBUtil.class.getClassLoader()
                    .getResourceAsStream("jdbc.properties"));
            // 读取配置文件得到属性值
            DBNAME=pro.getProperty("dbname");
            USERNAME = pro.getProperty("username");
            PASSWORD = pro.getProperty("password");
            DRIVER = pro.getProperty("driver");
            CHARSET=pro.getProperty("charset");
            URL = pro.getProperty("url")+DBNAME+CHARSET;
            System.out.println(URL);
            // 加载驱动
            dataSource = new SimpleDataSource(DRIVER, URL, USERNAME, PASSWORD);
            conn = dataSource.getConnection();
            if (!AUTO_COMMIT)
                conn.setAutoCommit(AUTO_COMMIT);
        } catch (IOException e)
        {
            e.printStackTrace();
        } catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

/**
 *
 * @param sql 增删改sql语句
 * @return 更新成功返回true
 */
    public boolean update(String sql)
    {
        int result = -1;// 表示当用户执行添加删除和修改的时候所影响数据库的行数
        try
        {
            pst = conn.prepareStatement(sql);
            result = pst.executeUpdate();
        } catch (SQLException e)
        {
            e.printStackTrace();
        }
        return result > 0;
    }

    /**
     * @param sql 增删改sql语句
     * @param params 给sql中？传值，个数必须和sql中？匹配，
     * @return 更新成功返回true    
     */
    public boolean update(String sql, List<?> params)
    {
        // 表示当用户执行添加删除和修改的时候所影响数据库的行数
        int result = -1;
        try
        {
            pst = conn.prepareStatement(sql);
            int index = 1;
            // 填充sql语句中的占位符
            if (params != null && !params.isEmpty())
            {
                for (int i = 0; i < params.size(); i++)
                {
                    pst.setObject(index++, params.get(i));
                }
            }
            result = pst.executeUpdate();
        } catch (SQLException e)
        {

            e.printStackTrace();
        }

        return result > 0;
    }

    /**
     * @param sql 查询 sql语句
     * @return 成功返回ResultSet    
     */
    public ResultSet query(String sql)
    {
        try
        {
            pst = conn.prepareStatement(sql);
            rs = pst.executeQuery();// 返回查询结果
        } catch (SQLException e)
        {
            e.printStackTrace();
        }
        return rs;
    }

    /**
     * @param sql 查询sql语句
     * @param params 给sql中？传值，个数必须和sql中？匹配，
     * @return 成功返回ResultSet    
     */
    public ResultSet query(String sql, List<?> params)
    {
        try
        {
            int index = 1;
            pst = conn.prepareStatement(sql);
            if (params != null && !params.isEmpty())
            {
                for (int i = 0; i < params.size(); i++)
                {
                    pst.setObject(index++, params.get(i));
                }
            }
            rs = pst.executeQuery();// 返回查询结果
        } catch (SQLException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return rs;
    }

    /**
     * 关闭对象
     * @return
     */
    public void Close()
    {
        if (rs != null)
        {
            try
            {
                rs.close();
            } catch (SQLException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if (pst != null)
        {
            try
            {
                pst.close();
            } catch (SQLException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if (conn != null)
        {
            try
            {
                conn.close();
            } catch (SQLException e)
            {
                System.out.println("关闭数据库连接失败");
            }
        }
    }

    /**
     * 查询当前数据库所有表名称
     * @return list
     */
    public List<String> getTables()
    {
        List<String> list = new ArrayList<String>();
        try
        {
            PreparedStatement ps = conn.prepareStatement(SQLTables);
            ResultSet rs = ps.executeQuery();
            while (rs.next())
            {
                String tableName = rs.getString(1);
                list.add(tableName);
            }
            Close();
        } catch (SQLException e)
        {
            System.out.println("数据库查询表名失败了！");
        }

        return list;
    }

    /**
     * 根据表名返回字段属性
     * @param tableName 表名
     * @return
     */
    public List<String[]> getColumnDatas(String tableName)
    {
        String SQLColumns = "select column_name ,data_type,column_comment,numeric_scale,numeric_precision from information_schema.columns where table_name =  '"
                + tableName + "' " + "and table_schema =  '" + DBNAME + "'";

        List<String[]> columnList = new ArrayList<String[]>();
        try
        {
            PreparedStatement ps = conn.prepareStatement(SQLColumns);
            ResultSet rs = ps.executeQuery();

            while (rs.next())
            {
                String name = rs.getString(1);
                String type = rs.getString(2);
                String comment = rs.getString(3);
                String scale = rs.getString(4);
                String precision = rs.getString(5);
                type = getType(type, precision, scale);
                columnList.add(new String[] { name, type, comment });
            }

            Close();
        } catch (SQLException ex)
        {
            System.out.println(ex.getMessage());
        }
        return columnList;
    }

    /**
     * 根据sql字段属性转换为java数据类型
     * @param dataType
     * @param precision 精度
     * @param scale 大小
     * @return  java类型
     * @return
     */
    public String getType(String dataType, String precision, String scale)
    {
        dataType = dataType.toLowerCase();
        if (dataType.contains("char") || dataType.contains("text"))
            dataType = "String";
        else if (dataType.contains("bit"))
            dataType = "Boolean";
        else if (dataType.contains("bigint"))
            dataType = "Long";
        else if (dataType.contains("int"))
            dataType = "Integer";
        else if (dataType.contains("float"))
            dataType = "Float";
        else if (dataType.contains("double") || dataType.contains("real"))
            dataType = "Double";
        else if (dataType.contains("number"))
        {
            if ((scale.length() > 0) && (Integer.parseInt(scale) > 0))
                dataType = "Double";
            else if ((precision.length() > 0)
                    && (Integer.parseInt(precision) > 6))
                dataType = "Long";
            else
                dataType = "Integer";
        }
        else if (dataType.contains("decimal"))
            dataType = "Double";
        else if (dataType.contains("date"))
            dataType = "java.util.Date";
        else if (dataType.contains("time"))
            dataType = "java.sql.Timestamp";
        else if (dataType.contains("clob"))
            dataType = "java.sql.Clob";
        else
        {
            dataType = "Object";
        }
        return dataType;
    }

    /**
     * 根据列名生成set方法名称
     * @param colName
     * @return
     * @return
     */
   private  String createSetMethod(String colName)
   {
       return "set"+colName.substring(0, 1).toUpperCase()+ colName.substring(1);
   }

    /**
     * 把Resultset结果集转换为实体对象List
     * @方法名 ：rsToEntityList<br>
     * @方法描述 ：根据结果集（多条数据）映射 到 实体类集合<br>
     * @param <T>  泛型
     * @param clazz 实体类的Class
     * @param rs 查询的结果集
     * @return 返回类型 ：List<T>
     */
    public <T> List<T> rsToEntityList(Class<T> clazz, ResultSet rs)
    {
        ResultSetMetaData rsmd = null;
        List<T> list = new ArrayList<T>();
        String temp = "";
        Method s = null;
        T t = null;
        try
        {
            rsmd = rs.getMetaData();
            while (rs.next())
            {
                t = clazz.newInstance();
                for (int i = 1; i <= rsmd.getColumnCount(); i++)
                {
                    temp = rsmd.getColumnName(i);
                    String dataType = getType(rsmd.getColumnTypeName(i),
                            String.valueOf(rsmd.getPrecision(i)),
                            String.valueOf(rsmd.getScale(i)));
                    if (dataType.equals("Integer"))
                    {
                        s = clazz.getDeclaredMethod(createSetMethod(temp),Integer.class);
                        s.invoke(t, rs.getInt(temp));
                    }
                    else if (dataType.equals("String"))
                    {
                        s = clazz.getDeclaredMethod(createSetMethod(temp),
                                String.class);
                        s.invoke(t, rs.getString(temp));
                    }
                    else if (dataType.equals("Boolean"))
                    {
                        s = clazz.getDeclaredMethod(createSetMethod(temp),
                                Boolean.class);
                        s.invoke(t, rs.getBoolean(temp));
                    }
                    else if (dataType.equals("Long"))
                    {
                        s = clazz.getDeclaredMethod(createSetMethod(temp),
                                Long.class);
                        s.invoke(t, rs.getLong(temp));
                    }
                    else if (dataType.equals("Float"))
                    {
                        s = clazz.getDeclaredMethod(createSetMethod(temp),
                                Float.class);
                        s.invoke(t, rs.getFloat(temp));
                    }
                    else if (dataType.equals("Double"))
                    {
                        s = clazz.getDeclaredMethod(createSetMethod(temp),
                                Double.class);
                        s.invoke(t, rs.getDouble(temp));
                    }
                    else if (dataType.equals("java.util.Date"))
                    {
                        s = clazz.getDeclaredMethod(createSetMethod(temp),
                                java.util.Date.class);
                        s.invoke(t, rs.getDate(temp));
                    }
                    else if (dataType.equals("Object"))
                    {
                        s = clazz.getDeclaredMethod(createSetMethod(temp),
                                Object.class);
                        s.invoke(t, rs.getObject(temp));
                    }
                    else if (dataType.equals("java.sql.Clob"))
                    {
                        s = clazz.getDeclaredMethod(createSetMethod(temp),
                                java.sql.Clob.class);
                        s.invoke(t, rs.getClob(temp));
                    }
                }
                list.add(t);
            }
        } catch (SQLException e)
        {
            e.printStackTrace();
        } catch (IllegalArgumentException e)
        {
            e.printStackTrace();
        } catch (IllegalAccessException e)
        {
            e.printStackTrace();
        } catch (InvocationTargetException e)
        {
            e.printStackTrace();
        } catch (SecurityException e)
        {
            e.printStackTrace();
        } catch (NoSuchMethodException e)
        {
            e.printStackTrace();
        } catch (InstantiationException e)
        {
            e.printStackTrace();
        }
        return list;
    }
}

4.测试

package dbTools;
import java.util.*;
import yzh.ssm.model.Stu;
public class Test
{

    public static void main(String[] args)
    {
           DBUtil db=new DBUtil();
           String sql="select * from Stu";
           List<Stu> list=db.rsToEntityList(Stu.class, db.query(sql));
           System.out.println(list);

    }

}
wtuyzh
关注
专栏目录
JDBC、封装JDBC连接池、第三方连接池工具
程序小白的成长
12-13 632
主要内容：JDBC简介JDBC来源通过代码实现JDBCJDBC的改进需求JDBC改进的代码实现JDBC使用的设计模式封装连接池封装JDBC连接池ThreadLoacl的使用ThreadLocal常见方法第三方连接池工具（数据源）策略模式 JDBC简介 全称：Java DataBase Connection 译名：Java数据库连接 JDBC来源 JDBC的来源： 最早在Java提出连接数据库需求的...
Java的JDBC连接池底层封装
最新发布
weixin_55415300的博客
12-09 1566
目录一、JDBC回顾1.1 六个基本步骤1.2 问题的引出二、ORM框架三、JDBC连接池性能优化3.1 JDBC连接池在创建连接时优化3.2 将连接（桥梁）和状态进行绑定1、MyConnection3.3 设计连接池用于装连接1、ConnectionPool四、JDBC连接池性能的测试五、将JDBC整体优化5.1 问题的产生5.2 问题解决方案1、单例的连接池对象2、添加配置文件3、多个人同时访问4、防止多余的线程出现null5、代理模式（1）静态代理模式（2）缺省适配器模式5.3 完整的JDBC封装代码
jdbc连接池简单封装
royzhou1985
03-08 133
主要实现方法是: 使用一个容器(LinkedList),初始化的时候设定好连接数,生成Connection对象放在容器中 以后每次获取连接的时候都从容器中获取,但是这样有一个问题,当我们关闭连接的时候调用 Connection的close()方法的时候会直接将Connection关闭而不是重新放到容器中…… 在这里使用的是代理,真正使用的是通过代理生成的一个存放在内存中的类,在这个类拦截了...
封装一个简单的JDBC连接池
Littleofthenew的博客
12-11 253
封装一个简单的JDBC连接池 import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.sql.Connection; import java.sql.SQLException; import java.util.Properties; ...
封装JDBC连接
Gorilla的博客
09-29 851
封装一个JDBC连接的工具类 并使用了读取工程下的JDBC.Properties文件,这样只需要修改文件中的信息，实现了代码的复用。 public class JDBCUitl2 { private JDBCUitl2(){ } private static Connection connection; private static Properties prope...
java dpcp_jdbc结合dpcp连接池的封装实例
weixin_33682804的博客
02-13 303
demo需求：实现jdbc结合dpcp连接池的封装(以oracle数据库为例)并实现简单地查找demo主要技术：(1)Properties类加载.properties的方式(2)dpcp连接池建立数据库连接的方式(3)查询数据的方式(4)静态代码块的使用，分离驱动的加载和连接信息的载入，整个服务器生命周期只执行一次demo所用jar包：classes12.jarcommons-dbcp-1.4.j...
jdbc连接池封装及ORM框架jdbc.rar
11-17
在这个“jdbc连接池封装及ORM框架jdbc.rar”文件中，我们可以探讨几个核心概念和技术，包括设计模式的应用、注解的使用以及反射机制。 首先，**设计模式**在软件开发中起着至关重要的作用。例如，工厂模式可能被...
javaBean自动生成工具，jdbc连接池封装
05-27
JDBC（Java Database Connectivity）是Java与数据库交互的标准接口，而"jdbc连接池封装"则指的是对JDBC连接管理的优化。连接池是一种数据库资源复用机制，它可以预先创建并维护一定数量的数据库连接，当应用需要时...
自定义一个简单的JDBC连接池实现方法
08-28
JDBC连接池是一种优化数据库连接的方法，在传统的JDBC连接中，每次获得一个Connection连接都需要加载通过一些繁杂的代码去获取，这样繁杂的操作只为了获取一次连接，当然，我们可以将其封装成一个工具类来访问，但是...
JDBC数据库连接池的使用
wopoli的博客
07-29 1778
如果使用C3P0数据库连接池，配置文件为c3p0-config.xml，注意该文件必须放在src文件夹下，并且只能使用该名称。如果使用druid数据库连接池，配置文件为druid.properties，注意该文件可以使用任意名称和存放在任意位置，但是一般存放在src文件夹下，并且使用druid命名。...
JDBC封装类升级版，支持DBCP、C3P0连接池，Java连接数据库带例子
04-06
Java JDBC封装类升级版，带增删改查例子，支持oracle,MySql,hsqldb 等，支持事务，返回数据格式 支持二维数组，MAP格式，以及javabean对象。有利于初学者DbDemo.java为demo,Connect为jdbc封装类，可以作为项目共通类使用。
JDBC的封装
12-05
JDBC的封装，（含预编译，结果集等），执行DML有参、执行DML无参、执行DQL无参及有参
Jdbc的封装
冰冰凉的博客
07-18 1166
目录一、Jdbc的封装与分页 一、Jdbc的封装与分页 封装Jdbc类 public class JdbcUtils { private static String driver; private static String url; private static String username; private static String password; static { Properties pro = new Properties();
【mysql】JDBC高级封装和数据库连接池
九离的博客
04-03 285
JDBC高级封装和数据库连接池 1. JDBC高级封装 1.1 JDBC通用查询方法 方法分析: 权限修饰符: public 是否静态: 不需要static修饰 返回值类型: 1. 一定带有泛型 2. 数据量不确定 List<T> 方法名: query 形式参数列表: 1. String sql 对应的DQL语句 2. 对应当前查询SQL语句的参数 3. Class<T> c
JDBC类的封装 + 数据库连接池
天堂有路你不走，学海无涯苦作舟
01-09 593
context.xml WEB-INF/web.xml ${catalina.base}/conf/web.xml <Resource name="jdbc/oracles" auth="Container" type="javax.sql.DataSource" maxActive="100" maxIdle="30" maxWait="1000"
java jdbc连接池化封装
mr_lili_111的博客
04-06 4868
  /////////jdbc连接操作 private static String url; /** * 用户名 */ private static String userName; /** * 密码 */ private static String password;   private static String driver;   // 连接池 private...
java JDBC连接池简单封装
mtb的博客
12-25 1319
java JDBC简单封装（MySQL） 此次封装使用maven构建 目录结构 product数据库表建表语句 create table `product` ( `p_id` int(32) not null unique primary key auto_increment, `p_name` varchar(50) not null, `s_size` double ...
基础工具类_JDBC对数据库连接池封装-JDBCUtils
Fhakjfksakln的博客
09-17 167
使用前将properties文件放在web的src文件中 使用的数据库连接池是阿里巴巴提供的druid url=jdbc:mysql:///travel //连接的数据库 默认省略 端口8080 username=root //自己的数据库账户 password=123456 //以及密码 initialSize=5 //初始化提供的连接数量 maxActive=10 //连接池中提供的最大连接数 以实际情况配置 maxWai
JDBC连接的封装
melissa_hexiu的博客
09-05 239
import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.ResourceBundle;/** * 操作数据库的工具类 * @autho
Spring JDBC连接池深度解析
"本文深入探讨了Spring框架下的JDBC连接池使用，包括基本框架搭建、CRUD操作以及读取配置文件。重点讲述了数据库连接池的重要性和工作原理，并列举了几个主流的数据库连接池实现，如dbcp、c3p0和Proxool。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值