精华内容
下载资源
问答
  • 2022-03-11 22:33:42

    连接池:是用来管理数据库连接的一种技术。在做数据库操作时,反复的创建连接和关闭连接耗费时间。

    连接池的工作过程:

    创建连接池时,在连接池中初始化一定数量的连接,当应用程序获得连接时,某个连接变为忙状态,根据配置的最 小空闲连接数,连接池创建新的连接,但连接数量不能超过配置的最大连接数。当应用程序用完连接后,连接变为 空闲状态,当所有的连接都是忙状态,应用程序获得连接时将等待。

    常用的连接池有:

    1. dbcp连接池:老牌的连接池

    2. c3p0连接池:先对dbcp连接池稳定,但速度慢。

    3. hirake连接池:springboot框架默认使用这个连接池,速度比druid快

    4. druid德鲁伊连接池:阿里巴巴开发的连接池,对SQL语句进行监控、拦截的功能。

    当然也可以自己写连接池,但通常不这么做,用写好的成熟的连接池

    DBCP连接池:

    
    public class Test {
        public static void main(String[] args) {
            BasicDataSource pool = new BasicDataSource();
            pool.setDriverClassName("com.mysql.jdbc.Driver");
            pool.setUrl("jdbc:mysql://localhost:3306/java2113?characterEncoding=utf8");
            pool.setUsername("root");
            pool.setPassword("root");
            pool.setInitialSize(3);
            pool.setMinIdle(3);
            pool.setMaxActive(5);
            try {
                Connection conn = pool.getConnection();
                System.out.println(conn.isClosed());
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    package com.oracle.dao;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.ResourceBundle;
    import org.apache.commons.dbcp.BasicDataSource;
    import com.oracle.vo.Student;
    //通用的数据库操作类
    public class BaseDao {
        Connection conn;
        PreparedStatement stmt;
        ResultSet rs;
        ResultSetMetaData rsmd;
        static String driver ;
        static String url;
        static String user;
        static String password;
        static String initSize;
        static String minIdle;
        static String maxActive;
        static BasicDataSource pool;
        static {
            ResourceBundle bundle = ResourceBundle.getBundle("db");
            driver = bundle.getString("driver");
            url = bundle.getString("url");
            user = bundle.getString("user");
            password = bundle.getString("password");
            initSize = bundle.getString("initSize");
            minIdle = bundle.getString("minIdle");
            maxActive = bundle.getString("maxActive");
            pool = new BasicDataSource();
            pool.setDriverClassName(driver);
            pool.setUrl(url);
            pool.setUsername(user);
            pool.setPassword(password);
            pool.setInitialSize(Integer.parseInt(initSize));
            pool.setMinIdle(Integer.parseInt(minIdle));
            pool.setMaxActive(Integer.parseInt(maxActive));
        }
        public int insert(String sql,Object[] values) {
            getConnection();
            int result = 0;
            try {
                stmt = conn.prepareStatement(sql);
                for(int i = 0;i<values.length;i++) {
                    stmt.setObject(i+1, values[i]);
                }
                result = stmt.executeUpdate();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
        }
            return result;
            }
        public int update(String sql,Object[] values) {
            return insert(sql,values);
            }
        public int delete(String sql,Object[] values) {
            return insert(sql,values);
            }
        //按条件查询
        //结果集的数据向 vo中填充属性 通过接口 描述填充的过程
        public <T> List<T> select(String sql,Object[] values,Convert<T> convert){
            List<T> list = new ArrayList<T>();
            getConnection();
            try {
            stmt = conn.prepareStatement(sql);
            for(int i = 0;i<values.length;i++) {
            stmt.setObject(i+1, values[i]);
            }
            rs = stmt.executeQuery();
            while(rs.next()) {
            T t = convert.convert(rs);
            list.add(t);
            }
            } catch (SQLException e) {
    
            e.printStackTrace();
            } finally {
            try {
            conn.close();
            } catch (SQLException e) {
    
            e.printStackTrace();
            }
            }
            return list;
            }
        //按id查询
        public <T> T selectById(String sql,Object[] values,Convert<T> convert) {
            getConnection();
            try {
            stmt = conn.prepareStatement(sql);
            for(int i = 0;i<values.length;i++) {
            stmt.setObject(i+1, values[i]);
            }
            rs = stmt.executeQuery();
            if(rs.next()) {
            return convert.convert(rs);
            }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
            try {
            conn.close();
            } catch (SQLException e) {
            e.printStackTrace();
            }
            }
            return null;
            }
        //获得连接
        public Connection getConnection() {
            try {
            conn = pool.getConnection();
            } catch (SQLException e) {
    
            e.printStackTrace();
            }
            return conn;
            }
        public static void main(String[] args) {
        //向学生表插入一条记录
        /*String sql = "insert into student(sname,tel,amt) values(?,?,?)";
        Object[] values = new Object[] {"abc","13111111111",1000};
        CommonData cdata = new CommonData();
            System.out.println(cdata.insert(sql, values));*/
        //id是35的学生电话修改为11111111111
        /*String sql = "update student set tel=? where id=?";
        Object[] values = new Object[] {"11111111111",35};
        CommonData cdata = new CommonData();
            System.out.println(cdata.update(sql, values));*/
            String sql = "delete from student where id = ?";
            Object[] values = new Object[] {35};
            BaseDao cdata = new BaseDao();
                System.out.println(cdata.delete(sql, values));
            //显示所有学生的姓名和电话号
            List<Student> list = cdata.select("select * from student", new Object[] {}, new
            StudentConvert());
            for(Student s:list) {
                System.out.println(s.getSname());
            }
            Student s = cdata.selectById("select * from student where id=?", new Object[] {21}, new
            StudentConvert());
            System.out.println(s.getSname());
        /* List<Student> list = cdata.select("select * from student", new Object[] {},(rs)->            {
        Student s = new Student();
        try {
            s.setId(rs.getInt("id"));
            s.setAmt(rs.getInt("amt"));
            s.setSname(rs.getString("sname"));
        } catch (SQLException e) {
                e.printStackTrace();
            }
            return s;
            });*/
            }
        }
    class StudentConvert implements Convert<Student> {
        @Override
        public Student convert(ResultSet rs) {
            Student s = new Student();
            try {
                s.setId(rs.getInt("id"));
                s.setAmt(rs.getInt("amt"));
                s.setSname(rs.getString("sname"));
                s.setBirthday(rs.getDate("birthday"));
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return s;
        }
    }
    

    更多相关内容
  • java配置dbcp连接池示例分享,大家参考使用吧
  • 单独使用DBCP需要导入三个dbcp相关jar包,commons-dbcp-1.4.jar,commons-collections-3.2.1.jar,commons-pool-1.5.4jar
  • dbcp连接池

    2018-08-15 19:33:52
    dbcp连接池的JAR commons-dbcp提供给开发者一个可用的数据库连接池,顾名思义commons-dbcp缓存了很多数据库的连接。难么这个缓存的功能是在dbcp中实现的吗?不是的,其实dbcp中的数据库的缓存的功能是有commons-...
  • 主要介绍了dbcp 连接池不合理的锁导致连接耗尽解决方案的相关资料,需要的朋友可以参考下
  • 用于实现DBCP连接池所用的JAR依赖文件,包括数据库驱动及创建连接池所需的其他依赖: * commons-collections  * commons-dbcp2  * commons-logging  * commons-pool2  * mysql-connector
  • 用于实现DBCP连接池所用的JAR依赖文件,包括数据库驱动及创建连接池所需的其他依赖: * commons-collections * commons-dbcp2 * commons-logging * commons-pool2 * mysql-connector 用于实现DBCP连接池所用的...
  • 包含commons-dbcp-1.4.jar,commons-dbutils-1.6.jar,commons-pool-1.5.6.jar三个jar包
  • DBCP连接池的jar包

    2021-02-26 15:39:28
    DBCP连接池的jar包,欢迎下载
  • dbcp连接池的jar包

    2013-10-23 11:00:43
    dbcp连接池的jar包,希望能给大家带来帮助。
  • DBCP连接池所有jar包

    2018-04-03 09:42:29
    DBCP连接池三个jar包,在web项目开发中,连接数据库,使用更加方便。
  • Dbcp连接池

    2020-07-31 16:34:25
    为什么使用连接池? 简言之:减少没必要的系统开销 凡是涉及到数据库访问的web应用,数据库连接管理是一个难点,也是未来大型应用性能优化的重点,如果对于连接资源管理混乱,将会使系统资源开销过大。制约大型...

    为什么使用连接池?

    简言之:减少没必要的系统开销

    凡是涉及到数据库访问的web应用,数据库连接管理是一个难点,也是未来大型应用性能优化的重点,如果对于连接资源管理混乱,将会使系统资源开销过大。制约大型应用性能的提升。

    优化方案:使用连接池技术,将创建好的连接资源管理起来,当需要使用连接时,从连接池中获取,使用完毕之后将连接还回连接池,避免重复的创建和销毁连接资源,较少系统的开销。

    怎样简单的使用连接池?

    引入文件。百度云链接容易失效就不放,本博客仅用于个人学习,有想学的可以找我要文件,私信就行。

     

    Dbcp 是连接池的一种实现方式

     1 导入dbcp 相关的jar包

    2  导入dbcp的配置文件, 的dbcp.properties .

    方法和前面一样。

    再导入一个新的对应键。

     对工具类进行升级,稍后会对工具类那篇文章进行更新。

    package util;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Properties;
    
    import javax.sql.DataSource;
    
    import org.apache.commons.dbcp.BasicDataSourceFactory;
    
    
    
    public class jdbcUtil3 {
    	//创建连接池
    		static DataSource pool = null;
    		//创建properties
    		 static Properties  pro =  new Properties();
    		 //创建Thread	local<Connection>,可以为同一个线程保存同一个连接,为不同线程保存不同的连接
    		 private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    		 
    		 //加载配置文件到流对象后创建连接池
    		 static{
    			InputStream is = null;
    			try {
    				//加载properties文件到properties对象中
    				is = jdbcUtil3.class.getResourceAsStream("/conf/dbcp.properties");
    				pro.load(is);
    			//	Class.forName(pro.getProperty("driverClassName"));
    			//创建连接池
    				pool = BasicDataSourceFactory.createDataSource(pro);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			} 	
    			finally{
    				try {
    					is.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    		//获取连接
    		public static  Connection getConnection() throws Exception{
    			Connection conn = tl.get();//获得当前线程中的连接
    			//如果当前线程中没有连接,就获取连接(使用连接池)
    			if(conn == null){//如果当前线程中没有连接
    				String url = pro.getProperty("url");
    				String user = "root";
    				String password = "root123";	
    				//创建连接
    			    conn = pool.getConnection();
    			    //将连接保存到当前线程
    			    tl.set(conn);
    			}
    			return conn;	
    		}
    		//释放资源/关闭连接
    		public static void release(ResultSet rs,PreparedStatement psm,Connection conn) throws SQLException{
    			if(rs!=null){
    				rs.close();
    			}
    			if(psm!=null){
    				psm.close();
    			}
    			if(conn!=null){
    				conn.close();
    				//关闭连接时,将连接从当前线程中移出,防止,内存溢出
    				tl.remove();
    			}	
    		}
    }
    

    测试一下吧:

    package jdbc;
    
    import java.sql.Connection;
    
    import util.jdbcUtil3;
    
    public class TestjdbcUtil3 {
    	public static void main(String[] args) throws Exception {
    		Connection conn = jdbcUtil3.getConnection();
    		System.out.println(conn);
    		Connection conn1 = jdbcUtil3.getConnection();
    		System.out.println(conn1);
    		Connection conn2 = jdbcUtil3.getConnection();
    		System.out.println(conn2);
    		Thread t1 = new Thread(){
    			public void run(){
    				Connection conn3;
    				try {
    				 conn3 =	jdbcUtil3.getConnection();
    					System.out.println("t1: " +conn3);
    				} catch (Exception e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		};
    		t1.start();
    	}
    }

    结果为:,,你没有看错,用连接池连接的,会有点不一样,不是干瘪的一行地址了

    展开全文
  • dbcp连接池依赖包.rar

    2019-08-09 09:58:48
    commons-dbcp-1.4.jar,commons-pool-1.5.6.jar DBCP(DataBase Connection Pool)数据库连接池,是java数据库连接池的一种
  • dbcp连接池整合jar包

    2018-08-09 11:45:43
    里面包含了commons-collections-3.1.jar commons-dbcp-1.2.2.jar commons-pool.jar ojdbc6.jar commons-dbcp-1.2.2 连接池的实现 commons-pool 连接池的依赖库 ojdbc6 orcale数据库驱动 到手即用
  • DBCP连接池原理分析

    2015-08-25 16:45:29
    DBCP连接池介绍 ----------------------------- 目前 DBCP 有两个版本分别是 1.3 和 1.4。 DBCP 1.3 版本需要运行于 JDK 1.4-1.5 ,支持 JDBC 3。 DBCP 1.4 版本需要运行于 JDK 1.6 ,支持 JDBC 4。 1.3和1.4基于...
  • dbcp连接池jar

    2017-11-15 17:01:46
    dbcp连接池jar,其中有commons-dbcp-1.2.2.jar,commons-pool-1.3.jar
  • DBCP连接池配制文件

    2018-05-22 09:30:16
    DBCP连接池配制文件................................
  • dbcp连接池jar包

    2018-07-29 23:18:03
    dbcp连接池jar包,文件里包含两个dbcp包和一个配置文件。 [图片]
  • JBDC连接数据库使用dbcp连接池,实现各种增加修改删除功能
  • DBCP(DataBase connection pool),数据库连接池。是 apache 上的一个 java 连接池项目,也是 tomcat 使用的连接池组件。单独使用dbcp需要2个包:commons-dbcp.jar,commons-pool.jar由于建立数据库连接是一个非常耗时耗...
  • 1首先在下面地址下载两个jar包 DBCP连接池所用到的两个jar包下载地址_ximexi的博客-CSDN博客DBCP连接池所用到的两个jar包下载地址commons-dbcp.jar:...

    1首先在下面地址下载两个jar包

    DBCP连接池所用到的两个jar包下载地址_ximexi的博客-CSDN博客DBCP连接池所用到的两个jar包下载地址commons-dbcp.jar:http://commons.apache.org/proper/commons-dbcp/download_dbcp.cgicommons-pool.jar:http://commons.apache.org/proper/commons-pool/download_pool.cgihttps://blog.csdn.net/ximexi/article/details/112609042由于DBCP2需要添加一个commons-logging,所以还要下载一个

    然后导入jar包

    2写一个dbcp的配置文件dbcpconfig.properties(数据来自B站up:遇见狂神说)

    #连接设置
    driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3333/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true
    username=root
    password=My123
    
    #<!-- 初始化连接 -->
    initialSize=10
    
    #最大连接数量
    maxActive=50
    
    #<!-- 最大空闲连接 -->
    maxIdle=20
    
    #<!-- 最小空闲连接 -->
    minIdle=5
    
    #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
    maxWait=60000#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样:【属性名=property;】 
    #注意:"user" 与 "password" 两个属性会被明确地传递,因此这里不需要包含他们。
    connectionProperties=useUnicode=true;characterEncoding=utf8
    
    #指定由连接池所创建的连接的自动提交(auto-commit)状态。
    defaultAutoCommit=true
    
    #driver default 指定由连接池所创建的连接的只读(read-only)状态。
    #如果没有设置该值,则“setReadOnly”方法将不被调用。(某些驱动并不支持只读模式,如:Informix)
    defaultReadOnly=
    
    #driver default 指定由连接池所创建的连接的事务级别(TransactionIsolation)。
    #可用值为下列之一:(详情可见javadoc。)NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
    defaultTransactionIsolation=READ_COMMITTED​

     3编写jdbcUtils_dbcp进行连接(相当于之前进行调用的对象jdbcUtils)

    package com.haoran.lesson5;
    
    import org.apache.commons.dbcp2.BasicDataSourceFactory;
    
    import javax.sql.DataSource;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    import java.util.Properties;
    
    public class jdbcUtils_dbcp {
        private static DataSource dataSource=null;
        static {
            try{
                InputStream resourceAsStream = jdbcUtils_dbcp.class.getClassLoader().getResourceAsStream("dbqpconfig.properties");
                //读取配置文件
                Properties properties = new Properties();
                properties.load(resourceAsStream);//下载资源
    
                //创建数据源
                dataSource = BasicDataSourceFactory.createDataSource(properties);
    
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    
        public static Connection getConnection() throws SQLException {
            return dataSource.getConnection();
        }
    
    
    
        //新建一个release的方法类来实现 释放连接资源 的功能
        public static void release(Connection conn, Statement st, ResultSet rs){
            if (rs!=null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (st!=null){
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
        }
    
    }
    

    4进行测试

    package com.haoran.lesson5;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class Testdbcp {
        public static void main(String[] args) {
            Connection conn = null;
            PreparedStatement pst = null;
            ResultSet rs =null;
    
    
            try {
                conn= jdbcUtils_dbcp.getConnection();
    
                String sql="SELECT * FROM `users` WHERE id=?";
                //预编译SQL,先写SQL,不执行,用占位符?
                pst=conn.prepareStatement(sql);
    
                //手动给参数赋值
                pst.setInt(1,2);
    
    
                rs=pst.executeQuery();
                if (rs.next()){
                    System.out.println(rs.getString("NAME"));
                }
    
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                jdbcUtils_dbcp.release(conn,pst,rs);
            }
        }
    }
    
    dbcp它的原理是维护多个连接对象Connection,在web项目要连接数据库时直接使用它维护的对象进行连接,省去每次都要创建连接对象的麻烦。提高效率和减少内存使用。
    

    使用数据库连接池,在项目开发中就不需要编写连接数据库的代码

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,419
精华内容 18,567
关键字:

dbcp连接池

友情链接: FormatoXlsx.zip