JDBC连接池

最新推荐文章于 2023-06-11 20:35:15 发布
最新推荐文章于 2023-06-11 20:35:15 发布
阅读量559 收藏
点赞数
分类专栏： 数据库
  1. 引言
    　　近年来，随着Internet/Intranet建网技术的飞速发展和在世界范围内的迅速普及，计算机
    　　应用程序已从传统的桌面应用转到Web应用。基于B/S（Browser/Server）架构的3层开发模式逐渐取代C/S（Client/Server）架构的开发模式，成为开发企业级应用和电子商务普遍采用的技术。在Web应用开发的早期，主要使用的技术是CGI﹑ASP﹑PHP等。之后，Sun公司推出了基于Java语言的Servlet+Jsp+JavaBean技术。相比传统的开发技术，它具有跨平台﹑安全﹑有效﹑可移植等特性，这使其更便于使用和开发。
    　　Java应用程序访问数据库的基本原理
    　　在Java语言中，JDBC（Java DataBase Connection）是应用程序与数据库沟通的桥梁,
    　　即Java语言通过JDBC技术访问数据库。JDBC是一种“开放”的方案，它为数据库应用开发人员﹑数据库前台工具开发人员提供了一种标准的应用程序设计接口，使开发人员可以用纯Java语言编写完整的数据库应用程序。JDBC提供两种API，分别是面向开发人员的API和面向底层的JDBC驱动程序API，底层主要通过直接的JDBC驱动和JDBC-ODBC桥驱动实现与数据库的连接。
    　　一般来说，Java应用程序访问数据库的过程（如图1所示）是：
    　　①装载数据库驱动程序；
    　　②通过JDBC建立数据库连接；
    　　③访问数据库，执行SQL语句；
    　　④断开数据库连接。

JDBC作为一种数据库访问技术，具有简单易用的优点。但使用这种模式进行Web应用
　　程序开发，存在很多问题：首先，每一次Web请求都要建立一次数据库连接。建立连接是一个费时的活动，每次都得花费0.05s～1s的时间，而且系统还要分配内存资源。这个时间对于一次或几次数据库操作，或许感觉不出系统有多大的开销。可是对于现在的Web应用，尤其是大型电子商务网站，同时有几百人甚至几千人在线是很正常的事。在这种情况下，频繁的进行数据库连接操作势必占用很多的系统资源，网站的响应速度必定下降，严重的甚至会造成服务器的崩溃。不是危言耸听，这就是制约某些电子商务网站发展的技术瓶颈问题。其次，对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将不得不重启数据库。还有，这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。

　　数据库连接池（connection pool）的工作原理
　　1、基本概念及原理
由上面的分析可以看出，问题的根源就在于对数据库连接资源的低效管理。我们知道，
　　对于共享资源，有一个很著名的设计模式：资源池（Resource Pool）。该模式正是为了解决资源的频繁分配﹑释放所造成的问题。为解决上述问题，可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量﹑使用情况，为系统开发﹑测试及性能调整提供依据。连接池的基本工作原理见下图2。

图2 连接池的基本工作原理
　　2、服务器自带的连接池
　　JDBC的API中没有提供连接池的方法。一些大型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere等提供了连接池的机制，但是必须有其第三方的专用类方法支持连接池的用法。
　　连接池关键问题分析
　　1、并发问题
　　为了使连接管理服务具有最大的通用性，必须考虑多线程环境，即并发问题。这个问题相对比较好解决，因为Java语言自身提供了对并发管理的支持，使用synchronized关键字即可确保线程是同步的。使用方法为直接在类方法前面加上synchronized关键字，如：
public synchronized Connection getConnection（）
　　2、多数据库服务器和多用户
　　对于大型的企业级应用，常常需要同时连接不同的数据库（如连接Oracle和Sybase）。如何连接不同的数据库呢？我们采用的策略是：设计一个符合单例模式的连接池管理类，在连接池管理类的唯一实例被创建时读取一个资源文件，其中资源文件中存放着多个数据库的url地址（

1),DBConnectionPool.java　　　　　数据库连接池类 
2),DBConnectionManager.java　　　 数据库管理类 
3),DSConfigBean .java            单个数据库连接信息Bean 
4),ParseDSConfig.java      操作多(这个'多'包括不同的数据库和同一种数据库有多个数据库)数据 配置文件xml 
5),ds.config.xml           数据库配置文件xml
DBConnectionPool.java
package com.tony.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Timer;

/**
 * Created with IntelliJ IDEA.数据库连接池类
 * User: Tony.Wang
 * Date: 12-9-24
 * Time: 上午8:59
 * To change this template use File | Settings | File Templates.
 */
public class DBConnectionPool {
    private Connection con = null;
    private int inUsed = 0;    //使用的连接数
    private ArrayList freeConnections = new ArrayList();//容器，空闲连接
    private int minConn;     //最小连接数
    private int maxConn;     //最大连接
    private String name;     //连接池名字
    private String password; //密码
    private String url;      //数据库连接地址
    private String driver;   //驱动
    private String user;     //用户名
    public Timer timer;      //定时

    /**
     *
     */
    public DBConnectionPool() {
        // TODO Auto-generated constructor stub
    }

    /**
     * 创建连接池
     *
     * @param driver
     * @param name
     * @param URL
     * @param user
     * @param password
     * @param maxConn
     */
    public DBConnectionPool(String name, String driver, String URL, String user, String password, int maxConn) {
        this.name = name;
        this.driver = driver;
        this.url = URL;
        this.user = user;
        this.password = password;
        this.maxConn = maxConn;
    }

    /**
     * 用完，释放连接
     *
     * @param con
     */
    public synchronized void freeConnection(Connection con) {
        this.freeConnections.add(con);//添加到空闲连接的末尾
        this.inUsed--;
    }

    /**
     * timeout  根据timeout得到连接
     *
     * @param timeout
     * @return
     */
    public synchronized Connection getConnection(long timeout) {
        Connection con = null;
        if (this.freeConnections.size() > 0) {
            con = (Connection) this.freeConnections.get(0);
            if (con == null) con = getConnection(timeout); //继续获得连接
        } else {
            con = newConnection(); //新建连接
        }
        if (this.maxConn == 0 || this.maxConn < this.inUsed) {
            con = null;//达到最大连接数，暂时不能获得连接了。
        }
        if (con != null) {
            this.inUsed++;
        }
        return con;
    }

    /**
     * 从连接池里得到连接
     *
     * @return
     */
    public synchronized Connection getConnection() {
        Connection con = null;
        if (this.freeConnections.size() > 0) {
            con = (Connection) this.freeConnections.get(0);
            this.freeConnections.remove(0);//如果连接分配出去了，就从空闲连接里删除
            if (con == null) con = getConnection(); //继续获得连接
        } else {
            con = newConnection(); //新建连接
        }
        if (this.maxConn == 0 || this.maxConn < this.inUsed) {
            con = null;//等待 超过最大连接时
        }
        if (con != null) {
            this.inUsed++;
            System.out.println("得到　" + this.name + "　的连接，现有" + inUsed + "个连接在使用!");
        }
        return con;
    }

    /**
     * 释放全部连接
     */
    public synchronized void release() {
        Iterator allConns = this.freeConnections.iterator();
        while (allConns.hasNext()) {
            Connection con = (Connection) allConns.next();
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

        }
        this.freeConnections.clear();

    }

    /**
     * 创建新连接
     *
     * @return
     */
    private Connection newConnection() {
        try {
            Class.forName(driver);
            con = DriverManager.getConnection(url, user, password);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("sorry can't find db driver!");
        } catch (SQLException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
            System.out.println("sorry can't create Connection!");
        }
        return con;

    }

    /**
     * 定时处理函数
     */
    public synchronized void TimerEvent() {
        //暂时还没有实现以后会加上的
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }

    /**
     * @return the driver
     */
    public String getDriver() {
        return driver;
    }

    /**
     * @param driver the driver to set
     */
    public void setDriver(String driver) {
        this.driver = driver;
    }

    /**
     * @return the maxConn
     */
    public int getMaxConn() {
        return maxConn;
    }

    /**
     * @param maxConn the maxConn to set
     */
    public void setMaxConn(int maxConn) {
        this.maxConn = maxConn;
    }

    /**
     * @return the minConn
     */
    public int getMinConn() {
        return minConn;
    }

    /**
     * @param minConn the minConn to set
     */
    public void setMinConn(int minConn) {
        this.minConn = minConn;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the password
     */
    public String getPassword() {
        return password;
    }

    /**
     * @param password the password to set
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * @return the url
     */
    public String getUrl() {
        return url;
    }

    /**
     * @param url the url to set
     */
    public void setUrl(String url) {
        this.url = url;
    }

    /**
     * @return the user
     */
    public String getUser() {
        return user;
    }

    /**
     * @param user the user to set
     */
    public void setUser(String user) {
        this.user = user;
    }
}
DBConnectionManager.java
package com.tony.db;

import java.sql.Connection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;

/**
 * Created with IntelliJ IDEA.数据库连接池管理类
 * User: Tony.Wang
 * Date: 12-9-24
 * Time: 上午8:59
 * To change this template use File | Settings | File Templates.
 */
public class DBConnectionManager {
    static private DBConnectionManager instance;//唯一数据库连接池管理实例类
    static private int clients;                 //客户连接数
    private Vector drivers = new Vector();//驱动信息
    private Hashtable pools = new Hashtable();//连接池

    /**
     * 实例化管理类
     */
    public DBConnectionManager() {
        // TODO Auto-generated constructor stub
        this.init();
    }

    /**
     * 得到唯一实例管理类
     *
     * @return
     */
    static synchronized public DBConnectionManager getInstance() {
        if (instance == null) {
            instance = new DBConnectionManager();
        }
        return instance;

    }

    /**
     * 释放连接
     *
     * @param name
     * @param con
     */
    public void freeConnection(String name, Connection con) {
        DBConnectionPool pool = (DBConnectionPool) pools.get(name);//根据关键名字得到连接池
        if (pool != null)
            pool.freeConnection(con);//释放连接
    }

    public void freeConnection() {

    }

    /**
     * 得到一个连接根据连接池的名字name
     *
     * @param name
     * @return
     */
    public Connection getConnection(String name) {
        DBConnectionPool pool = null;
        Connection con = null;
        pool = (DBConnectionPool) pools.get(name);//从名字中获取连接池
        con = pool.getConnection();//从选定的连接池中获得连接
        if (con != null)
            System.out.println("得到连接。。。");
        return con;
    }

    /**
     * 得到一个连接，根据连接池的名字和等待时间
     *
     * @param name
     * @param timeout
     * @return
     */
    public Connection getConnection(String name, long timeout) {
        DBConnectionPool pool = null;
        Connection con = null;
        pool = (DBConnectionPool) pools.get(name);//从名字中获取连接池
        con = pool.getConnection(timeout);//从选定的连接池中获得连接
        System.out.println("得到连接。。。");
        return con;
    }

    /**
     * 释放所有连接
     */
    public synchronized void release() {
        Enumeration allpools = pools.elements();
        while (allpools.hasMoreElements()) {
            DBConnectionPool pool = (DBConnectionPool) allpools.nextElement();
            if (pool != null) pool.release();
        }
        pools.clear();
    }

    /**
     * 创建连接池
     *
     * @param dsb
     */
    private void createPools(DSConfigBean dsb) {
        DBConnectionPool dbpool = new DBConnectionPool();
        dbpool.setName(dsb.getName());
        dbpool.setDriver(dsb.getDriver());
        dbpool.setUrl(dsb.getUrl());
        dbpool.setUser(dsb.getUsername());
        dbpool.setPassword(dsb.getPassword());
        dbpool.setMaxConn(dsb.getMaxconn());
        System.out.println("ioio:" + dsb.getMaxconn());
        pools.put(dsb.getName(), dbpool);
    }

    /**
     * 初始化连接池的参数
     */
    private void init() {
        //加载驱动程序
        this.loadDrivers();
        //创建连接池
        Iterator alldriver = drivers.iterator();
        while (alldriver.hasNext()) {
            this.createPools((DSConfigBean) alldriver.next());
            System.out.println("创建连接池。。。");

        }
        System.out.println("创建连接池完毕。。。");
    }

    /**
     * 加载驱动程序
     *
     */
    private void loadDrivers() {
        ParseDSConfig pd = new ParseDSConfig();
//读取数据库配置文件
        drivers = pd.readConfigInfo("ds.config.xml");
        System.out.println("加载驱动程序。。。");
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}
ParseDSConfig.java
package com.tony.db;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

/**
 * Created with IntelliJ IDEA.操作配置文件类 读、写、修改、删除等操作
 * User: Tony.Wang
 * Date: 12-9-24
 * Time: 上午9:01
 * To change this template use File | Settings | File Templates.
 */
public class ParseDSConfig {
    /**
     * 构造函数
     */
    public ParseDSConfig() {
        // TODO Auto-generated constructor stub
    }

    /**
     * 读取xml配置文件
     *
     * @param path
     * @return
     */
    public Vector readConfigInfo(String path) {
        String rpath = this.getClass().getResource("").getPath().substring(1) + path;
        Vector dsConfig = null;
        FileInputStream fi = null;
        try {
            fi = new FileInputStream(rpath);//读取路径文件
            dsConfig = new Vector();
            SAXBuilder sb = new SAXBuilder();
            Document doc = sb.build(fi);
            Element root = doc.getRootElement();
            List pools = root.getChildren();
            Element pool = null;
            Iterator allPool = pools.iterator();
            while (allPool.hasNext()) {
                pool = (Element) allPool.next();
                DSConfigBean dscBean = new DSConfigBean();
                dscBean.setType(pool.getChild("type").getText());
                dscBean.setName(pool.getChild("name").getText());
                System.out.println(dscBean.getName());
                dscBean.setDriver(pool.getChild("driver").getText());
                dscBean.setUrl(pool.getChild("url").getText());
                dscBean.setUsername(pool.getChild("username").getText());
                dscBean.setPassword(pool.getChild("password").getText());
                dscBean.setMaxconn(Integer.parseInt(pool.getChild("maxconn").getText()));
                dsConfig.add(dscBean);
            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JDOMException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fi.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return dsConfig;
    }

    /**
     * 修改配置文件 没时间写 过段时间再贴上去 其实一样的
     */
    public void modifyConfigInfo(String path, DSConfigBean dsb) throws Exception {
        String rpath = this.getClass().getResource("").getPath().substring(1) + path;
        FileInputStream fi = null; //读出
        FileOutputStream fo = null; //写入

    }

    /**
     * 增加配置文件
     */
    public void addConfigInfo(String path, DSConfigBean dsb) {
        String rpath = this.getClass().getResource("").getPath().substring(1) + path;
        FileInputStream fi = null;
        FileOutputStream fo = null;
        try {
            fi = new FileInputStream(rpath);//读取xml流

            SAXBuilder sb = new SAXBuilder();

            Document doc = sb.build(fi); //得到xml
            Element root = doc.getRootElement();
            List pools = root.getChildren();//得到xml子树

            Element newpool = new Element("pool"); //创建新连接池

            Element pooltype = new Element("type"); //设置连接池类型
            pooltype.setText(dsb.getType());
            newpool.addContent(pooltype);

            Element poolname = new Element("name");//设置连接池名字
            poolname.setText(dsb.getName());
            newpool.addContent(poolname);

            Element pooldriver = new Element("driver"); //设置连接池驱动
            pooldriver.addContent(dsb.getDriver());
            newpool.addContent(pooldriver);

            Element poolurl = new Element("url");//设置连接池url
            poolurl.setText(dsb.getUrl());
            newpool.addContent(poolurl);

            Element poolusername = new Element("username");//设置连接池用户名
            poolusername.setText(dsb.getUsername());
            newpool.addContent(poolusername);

            Element poolpassword = new Element("password");//设置连接池密码
            poolpassword.setText(dsb.getPassword());
            newpool.addContent(poolpassword);

            Element poolmaxconn = new Element("maxconn");//设置连接池最大连接
            poolmaxconn.setText(String.valueOf(dsb.getMaxconn()));
            newpool.addContent(poolmaxconn);
            pools.add(newpool);//将child添加到root
            Format format = Format.getPrettyFormat();
            format.setIndent("");
            format.setEncoding("utf-8");
            XMLOutputter outp = new XMLOutputter(format);
            fo = new FileOutputStream(rpath);
            outp.output(doc, fo);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JDOMException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {

        }
    }

    /**
     * 删除配置文件
     */
    public void delConfigInfo(String path, String name) {
        String rpath = this.getClass().getResource("").getPath().substring(1) + path;
        FileInputStream fi = null;
        FileOutputStream fo = null;
        try {
            fi = new FileInputStream(rpath);//读取路径文件
            SAXBuilder sb = new SAXBuilder();
            Document doc = sb.build(fi);
            Element root = doc.getRootElement();
            List pools = root.getChildren();
            Element pool = null;
            Iterator allPool = pools.iterator();
            while (allPool.hasNext()) {
                pool = (Element) allPool.next();
                if (pool.getChild("name").getText().equals(name)) {
                    pools.remove(pool);
                    break;
                }
            }
            Format format = Format.getPrettyFormat();
            format.setIndent("");
            format.setEncoding("utf-8");
            XMLOutputter outp = new XMLOutputter(format);
            fo = new FileOutputStream(rpath);
            outp.output(doc, fo);

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JDOMException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fi.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        ParseDSConfig pd = new ParseDSConfig();
        String path = "ds.config.xml";
        pd.readConfigInfo(path);
        //pd.delConfigInfo(path, "tj012006");
        DSConfigBean dsb = new DSConfigBean();
        dsb.setType("oracle");
        dsb.setName("yyy004");
        dsb.setDriver("org.oracle.jdbc");
        dsb.setUrl("jdbc:oracle://localhost");
        dsb.setUsername("sa");
        dsb.setPassword("");
        dsb.setMaxconn(1000);
        pd.addConfigInfo(path, dsb);
        pd.delConfigInfo(path, "yyy001");
    }
}
ds.config.xml
<ds-config>
    <pool>
        <type>mysql</type>
        <name>user</name>
        <driver>com.mysql.jdbc.driver</driver>
        <url>jdbc:mysql://localhost:3306/user</url>
        <username>sa</username>
        <password>123456</password>
        <maxconn>100</maxconn>
    </pool>
    <pool>
        <type>mysql</type>
        <name>user2</name>
        <driver>com.mysql.jdbc.driver</driver>
        <url>jdbc:mysql://localhost:3306/user2</url>
        <username>sa</username>
        <password>1234</password>
        <maxconn>10</maxconn>
    </pool>
    <pool>
        <type>sql2000</type>
        <name>books</name>
        <driver>com.microsoft.sqlserver.driver</driver>
        <url>jdbc:sqlserver://localhost:1433/books:databasename=books</url>
        <username>sa</username>
        <password></password>
        <maxconn>100</maxconn>
    </pool>
</ds-config>

  1. 连接池的使用

    　　1. Connection 的获得与释放

Test.java
package com.tony.db;

import java.sql.Connection;

/**
 * Created with IntelliJ IDEA.
 * User: Tony.Wang
 * Date: 12-9-24
 * Time: 上午9:34
 * To change this template use File | Settings | File Templates.
 */
public class Test {

    public static void main(String[] args) {
        DBConnectionManager connectionManager = DBConnectionManager.getInstance();
        String name = "mysql";//从上下文得到你要访问的数据库的名字

        Connection connection = connectionManager.getConnection(name);
        //使用

        //使用结束
        connectionManager.freeConnection(name, connection);//释放，但并未断开连接
    }

}

2。数据库连接的动态增加和连接池的动态增加
1。调用xml操作增加类

2。重新实例华连接池管理池类

Java-jdbc数据库连接池总结.doc
03-20
Java应用程序访问数据库的基本原理 　　在Java语言中，JDBC（Java DataBase Connection）是应用程序与数据库沟通的桥梁, 　　即Java语言通过JDBC技术访问数据库。JDBC是一种“开放”的方案，它为数据库应用开发人员﹑数据库前台工具开发人员提供了一种标准的应用程序设计接口，使开发人员可以用纯Java语言编写完整的数据库应用程序。JDBC提供两种API，分别是面向开发人员的API和面向底层的JDBC驱动程序API，底层主要通过直接的JDBC驱动和JDBC-ODBC桥驱动实现与数据库的连接。
自定义一个简单的JDBC连接池实现方法
08-28
自定义一个简单的JDBC连接池实现方法 知识点一：什么是JDBC连接池？ JDBC连接池是一种优化数据库连接的方法，在传统的JDBC连接中，每次获得一个Connection连接都需要加载通过一些繁杂的代码去获取，这样繁杂的...
JAVA之JDBC数据库连接池（超详细介绍）
热门推荐
weixin_43520450的博客
07-09 3万+
JDBC数据库连接池一、JDBC数据库连接池的必要性二、数据库连接池技术三、多种开源的数据库连接池3.1 C3P0数据库连接池3.2 DBCP数据库连接池3.3 Druid（德鲁伊）数据库连接池 一、JDBC数据库连接池的必要性 1、在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤： （1）在主程序（如servlet、beans）中建立数据库连接 （2）进行sql操作 （3）断开数据库连接 2、这种模式开发，存在的问题: （1）普通的JDBC数据库连接使用 DriverManager 来
几个主流的Java连接池整理 （转） (2012-01-04 23:48:02)转载▼
zhhp0754的专栏
11-25 1023
池(Pool)技术在一定程度上可以明显优化服务器应用程序的性能，提高程序执行效率和降低系统资源开销。这里所说的池是一种广义上的池，比如数据库连接池、线程池、内存池、对象池等。其中，对象池可以看成保存对象的容器，在进程初始化时创建一定数量的对象。需要时直接从池中取出一个空闲对象，用完后并不直接释放掉对象，而是再放到对象池中以方便下一次对象请求可以直接复用。其他几种池的设计思想也是如此，池技术的优势是，
主流java连接池管理工具
zhannk的专栏
09-25 1246
几个主流的Java连接池整理 池(Pool)技术在一定程度上可以明显优化服务器应用程序的性能，提高程序执行效率和降低系统资源开销。这里所说的池是一种广义上的池，比如数据库连接池、线程池、内存池、对象池等。其中，对象池可以看成保存对象的容器，在进程初始化时创建一定数量的对象。需要时直接从池中取出一个空闲对象，用完后并不直接释放掉对象，而是再放到对象池中以方便下一次对象请求可以直接复用。其他几种池的...
关于java中的jdbc、数据库驱动、数据库连接池的学习与理解
码农小默
04-19 3262
一、什么是jdbc 1.JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。 2.jdbc的java api有哪些，四个常用的接口和一个类（Conn...
HikariCP JDBC连接池 v3.4.5.zip
最新发布
03-21
HikariCP是一款高效、高性能的Java JDBC连接池，它被设计为替代传统连接池如C3P0和DBCP，以提供更快、更稳定的数据访问性能。在HikariCP v3.4.5这个版本中，我们可以深入探讨其在数据库连接管理、性能优化以及配置...
java实现jdbc连接池+相关jar包
03-02
本文将详细介绍如何使用Java实现JDBC连接池，以及涉及到的相关库和jar包。 首先，Java JDBC（Java Database Connectivity）是Java平台中用于与各种数据库进行交互的一组标准API。要实现JDBC连接池，我们需要引入几...
JDBC连接池使用工具 C3P0 连接池 and druid-1.0.9
04-11
C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。C3P0的主要特点包括： 1. **连接测试**：C3P0提供了多种测试策略，确保获取到的连接是可用的。 2. **连接池初始化和最大...
JDBC连接池驱动.zip
02-25
JDBC（Java Database Connectivity）是Java平台中用于与数据库交互的一组接口和类，而JDBC连接池就是在这个基础上实现的一种优化策略。本文将详细介绍JDBC连接池驱动的相关知识，主要涉及`mysql-connector-java-...
连接数据库（java驱动连接和连接池连接）
Ace_2的博客
07-20 1382
使用java驱动连接数据库： String url ="jdbc:mysql://localhost:3306/zhongruan"; String username ="root"; String password ="123456"; //配置环境，jar一个架包 //JDBC ： JAVA DATABASE CO...
JDBC各数据库的加载驱动和c3p0的设置
福建开源社区创始人www.fjkysq.com
04-30 1334
在项目中，会用到各个数据库，有时候客户也会提出更换数据库，只要项目开发时没把数据库层写死写耦合的话，很轻松更换。在此，我整理了下自己项目开发的例子和从网上找来的常用的几种数据库连接写在这里。以便自己将来开发时用到，也分享给大家。因为我也算是自学出来的，现已经工作了。有福建厦门的同行没，不管是新手还是前辈，欢迎做个朋友QQ348843576 在Spring配置数据源：
【JDBC】-- Druid数据库连接池技术的实现
张修宇的博客
07-28 549
可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)Druid是阿里提供的数据库连接池，集DBCP、C3P0、Proxool优点于一身的数据库连接池；数据库连接池开源组织实现有很多，这里使用Druid，也是开发中常用的一种；将驱动文件复制到lib文件下并添加为库。下面使用idea+mysql8实现。封装连接数据库的基本信息。用于封装连接数据库方法。...
DriverMananger和DateSource和数据库连接池
Chen4852010的博客
01-21 2066
DriverManager是数据库驱动，用它可以打开通道，获得connection dateSource实际是封装了，driverManager,用它获取连接，其实也是用driverManager打开通道，然后获取连接 数据库连接池，就是dateSource中封装了，连接池和driverManager,在getConnection之前，就用driverMananger获取了很多conn,存在连接池中
Druid的简介
山鹰的专栏
08-01 698
Druid的简介 Druid首先是一个数据库连接池。Druid是目前最好的数据库连接池，在功能、性能、扩展性方面，都超过其他数据库连接池，包括DBCP、C3P0、BoneCP、Proxool、JBoss DataSource。Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。 同时Druid不仅仅是一个数据库连接池，它包括四个部分：     
几个主流的Java连接池整理
squall140
03-31 104
池 (Pool)技术在一定层度上可以明显优化服务器应用程序的性能，提高程序执行效率和降低系统 资源开销。这里所说的池是一种广义上的池，比如数据库连接池、线程池、内存池、对象池等。其中，对象池可以看成保存对象的容器，在进程初始化时创建一定数 量的对象。需要时直接从池中取出一个空闲对象，用完后并不直接释放掉对象，而是再放到对象池中以方便下一次对象请求可以直接复用。其他几种池的设计思想...
解密：Druid数据库连接池的driverClassName驱动类可以不用配置原因
weixin_44796239的博客
05-27 2896
Druid数据库连接池的driverClassName驱动类竟然可以不用配置附上源代码：druid.propertiesDruidUtils解密开始1 查看 createDataSource 创建数据源的细节2 找到了创建数据源对象的代码 继续跟进3 构造方法中没有什么发现，线索断了... 但是发现了初始化的方法，柳暗花明又一村，继续跟进4 源代码的555行找打了，如果不配置驱动类的时候，会根据jdbcUrl来获取，继续跟进5 答案已找到......总结： 一次偶然的机会，不小心修改了drive
JDBC 连接池 详解（通俗易懂）
Cyan_RA9的博客
06-11 7446
JDBC 第五节 详解连接池 通俗易懂！
Java jdbc数据库连接池总结!
Pump Liu
01-16 1241
1. 引言 　　近年来，随着Internet/Intranet建网技术的飞速发展和在世界范围内的迅速普及，计算机　　应用程序已从传统的桌面应用转到Web应用。基于B/S（Browser/Server）架构的3层开发模式逐渐取代C/S（Client/Server）架构的开发模式，成为开发企业级应用和电子商务普遍采用的技术。在Web应用开发的早期，主要使用的技术是CGI﹑ASP﹑PHP等。之后，Su...
Spring JDBC连接池深度解析
"本文深入探讨了Spring框架下的JDBC连接池使用，包括基本框架搭建、CRUD操作以及读取配置文件。重点讲述了数据库连接池的重要性和工作原理，并列举了几个主流的数据库连接池实现，如dbcp、c3p0和Proxool。" 在...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值