精华内容
下载资源
问答
  • 下面小编就为大家带来一篇jdbc结合dpcp连接池的封装实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • dpcp连接池工具类

    2013-08-15 11:33:22
    导入jar包,针对自己连接的数据库,修改url,user,pwd,driver等值。即可连接使用。
  • 而且用c3p0数据库连接池,项目发布的时候,特别卡慢,一度把tomcat的timeout增大到450s, 最后没办法了,我把c3p0换成dpcp的了,项目就正常可以运行了 c3p0连接配置 ...

    部分错误信息如下:
    
    Struts has detected an unhandled exception:
    Messages:	
    A ResourcePool could not acquire a resource from its primary factory or source.
    Connections could not be acquired from the underlying database!
    Could not open connection
    Could not open Hibernate Session for transaction; nested exception is org.hibernate.exception.GenericJDBCException: Could not open connection
    File:	com/mchange/v2/resourcepool/BasicResourcePool.java
    Line number:	1,418
    Stacktraces
    
    org.springframework.transaction.CannotCreateTransactionException: Could not open Hibernate Session for transaction; nested exception is org.hibernate.exception.GenericJDBCException: Could not open connection
        org.springframework.orm.hibernate4.HibernateTransactionManager.doBegin(HibernateTransactionManager.java:544)
        org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction(AbstractPlatformTransactionManager.java:373)
        org.springframework.transaction.interceptor.TransactionAspectSupport.createTransactionIfNecessary(TransactionAspectSupport.java:457)
        org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:276)
        org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
        org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
        org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:207)
        com.sun.proxy.$Proxy22.validateMailAndPass(Unknown Source)
        com.smart.agriculture.action.UserAction.login(UserAction.java:82)
        sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)

    这个Bug花了我整个周末,直到周日晚上才解决,其实也没有解决,只是绕开了。

    看到这个Bug我第一反应就是数据库可能没有正确连接,于是坚持了用户名、密码、数据库名,包括有没有非法字符空格之类的,之后检查相应的数据库驱动包有没有加入build  path,果然tomcat下的lib目录里没有相应的jar。

    折腾了一番还是没有结果,相应的c3p0 jar包也导入进去了,但是数据库总是连接不上。

    而且用c3p0数据库连接池,项目发布的时候,特别卡慢,一度把tomcat的timeout增大到450s,

    最后没办法了,我把c3p0换成dpcp的了,项目就正常可以运行了


    c3p0连接配置

     	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
     		<property name="driverClass" value="org.gjt.mm.mysql.Driver"/> 
     		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/smart_argriculture_system"/> 
     		<property name="user" value="root"/> 
    		<property name="password" value="root1314"/> 
    		<property name="maxPoolSize" value="50"/>
    		<property name="minPoolSize" value="3"/> 
    		<property name="maxIdleTime" value="30"/> 
    		<property name="initialPoolSize" value="3"/> 
    	</bean> -->

    改为dpcp配置

    	<bean id="dataSource"
    		class="org.apache.commons.dbcp.BasicDataSource">
    		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    		<property name="url" value="jdbc:mysql://localhost:3306/smart_argriculture_system"></property>
    		<property name="username" value="root"></property>
    		<property name="password" value="root1314"></property>
    	</bean>



    展开全文
  • 参考 https://blog.csdn.net/god_v/article/details/80656827 ... 获取连接工具类 import org.apache.commons.dbcp2.BasicDataSourceFactory; impor...

    参考

        https://blog.csdn.net/god_v/article/details/80656827

        https://www.oschina.net/question/2272552_2269641?sort=time 

    获取连接工具类 

    
    import org.apache.commons.dbcp2.BasicDataSourceFactory;
    import org.springframework.core.io.ClassPathResource;
    
    import javax.sql.DataSource;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.InputStream;
    import java.net.URL;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.Properties;
    
    /**
     * @Auther: liyue
     * @Date: 2019/4/28 14:17
     * @Description:
     */
    public class DbcpUtil {
    
    
        private static Properties properties = null;
        private static DataSource dataSource = null;
        private static Connection connection = null;
    
        static {
            try {
                //获取配置文件,转换成流
                String propertiesPath = "db.properties";
                InputStream in = null;
                try {
                    // 开发环境
                    URL url = CoonPoolLzmesServiceImpl.class.getClassLoader().getResource(propertiesPath);
                    File file = new File(url.getFile());
                    in = new FileInputStream(file);
                } catch (Exception e) {
    
                }
                if (in == null) {
                    // 达成jar包部署之后
                    ClassPathResource classPathResource = new ClassPathResource(propertiesPath);
                    in = classPathResource.getInputStream();
                }
                //创建properties对象
                properties = new Properties();
                //加载流
                properties.load(in);
                //创建dataSource对象
                dataSource = BasicDataSourceFactory.createDataSource(properties);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static Connection getCoon() {
            try {
                //得到connection对象
                connection = dataSource.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return connection;
        }
    
    }
    

    配置文件 db.properties

    
    driverClassName=com.mysql.jdbc.Driver
    
    url=jdbc:mysql://localhost:3306/mybd
    
    username=root
    
    password=root
    
    initialSize=30
    
    maxTotal=30
    
    maxIdle=10
    
    minIdle=5
    
    maxWaitMillis=1000
    
    testOnBorrow=true
    
    validationQuery=select 1

    配置说明

    initialSize  
    
         初始化连接,连接池启动时创建的初始化连接数量(默认值为0)
    
    maxActive  
         最大活动连接,连接池中可同时连接的最大的连接数(默认值为8)
    
    minIdle 
         最小空闲连接,连接池中最小的空闲的连接数,低于这个数量会被创建新的连接(默认为0,该参数越接近maxIdle,性能越好,因为连接的创建和销毁,都是需要消耗资源的;但是不能太大,因为在机器很空闲的时候,也会创建低于minidle个数的连接,类似于jvm参数中的Xmn设置)
    
    maxIdle   
         最大空闲连接,连接池中最大的空闲的连接数,超过的空闲连接将被释放,如果设置为负数表示不限制(默认为8个,maxIdle不能设置太小,因为假如在高负载的情况下,连接的打开时间比关闭的时间快,会引起连接池中idle的个数上升超过maxIdle,而造成频繁的连接销毁和创建,类似于jvm参数中的Xmx设置)
    
    maxWait 
         从池中取连接的最大等待时间,单位ms.当没有可用连接时,连接池等待连接释放的最大时间,超过该时间限制会抛出异常,如果设置-1表示无限等待(默认为无限)
    
    validationQuery 
         验证使用的SQL语句
    
    testWhileIdle    
         指明连接是否被空闲连接回收器(如果有)进行检验.如果检测失败,则连接将被从池中去除.
    
    testOnBorrow    
         借出连接时不要测试,否则很影响性能。一定要配置,因为它的默认值是true。false表示每次从连接池中取出连接时,不需要执行validationQuery = "SELECT 1" 中的SQL进行测试。若配置为true,对性能有非常大的影响,性能会下降7-10倍。
    
    timeBetweenEvictionRunsMillis
         每30秒运行一次空闲连接回收器,配置timeBetweenEvictionRunsMillis = "30000"后,每30秒运行一次空闲连接回收器(独立线程)。并每次检查3个连接,如果连接空闲时间超过30分钟就销毁。销毁连接后,连接数量就少了,如果小于minIdle数量,就新建连接,维护数量不少于minIdle,过行了新老更替。
    
    minEvictableIdleTimeMillis
         池中的连接空闲30分钟后被回收
    
    numTestsPerEvictionRun
         在每次空闲连接回收器线程(如果有)运行时检查的连接数量
    
    removeAbandoned
         连接泄漏回收参数,当可用连接数少于3个时才执行
    
    removeAbandonedTimeout
         连接泄漏回收参数,180秒,泄露的连接可以被删除的超时值
    

    maven依赖

    
                <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
                <dependency>
                    <groupId>org.apache.commons</groupId>
                    <artifactId>commons-dbcp2</artifactId>
                    <version>2.6.0</version>
                </dependency>

     

     

    END。

    展开全文
  • jdbc java操作数据库.jdbc是oracle公司指定的一套规范(一套接口) ... 连接数据库 发送sql语句 处理结果 jdbc操作步骤:★ 1.数据库和表 2.创建一个项目 3.导入驱动jar包 4.编码: 注册驱动 获取连接 编写...

    jdbc

    java操作数据库.jdbc是oracle公司指定的一套规范(一套接口)
    驱动:jdbc的实现类.由数据库厂商提供.
    我们就可以通过一套规范操作不同的数据库了(多态)
    jdbc作用:
        连接数据库
        发送sql语句
        处理结果

    jdbc操作步骤:★

    1.数据库和表
    2.创建一个项目
    3.导入驱动jar包
    4.编码:
        注册驱动
        获取连接
        编写sql
        创建预编译的语句执行者
        设置参数
        执行sql
        处理结果
        释放资源

    初始化数据库和表:
        CREATE DATABASE day07;
        USE day07;    
        
        create table category(
            cid varchar(20) primary key,
            cname varchar(20)
        );
        
        insert into category values('c001','电器');
        insert into category values('c002','服饰');
        insert into category values('c003','化妆品');
        insert into category values('c004','书籍');

    IDE打开之后
        1.修改字符集 utf-8
        2.新建 java项目
        3.使用的jdk为自己的jdk 不用使用内置

    使用junit单元测试
        要求:
            1.方法是public void xxx(){}
            2.在方法上添加 @Test
            3.在@Test 按下 ctrl+1(快速锁定错误)
            4.在方法上右键 run as  -->junit 就可以执行方法了.
    jdbc-api详解:
    所有的包 都是 java.sql 或者 javax.sql

    DriverManager:管理了一组jdbc的操作 类

        常用方法:
            了解:注册驱动    
                static void registerDriver(Driver driver) :
                    通过查看 com.mysql.jdbc.Driver的源码 有如下代码
                         static {
                            try {
                                java.sql.DriverManager.registerDriver(new Driver());//这段代码我们已经写过
                            } catch (SQLException E) {
                                throw new RuntimeException("Can't register driver!");
                            }
                        }
                    驱动注册了两次.我们只需要将静态代码块执行一次,类被加载到内存中会执行静态代码块,并且只执行一次.
                    现在只需要将类加载到内存中即可:
                        方式1:
                            ★Class.forName("全限定名");//包名+类名   com.mysql.jdbc.Driver
                        方式2:
                            类名.class;
                        方式3:
                            对象.getClass();

            掌握:获取连接
                static Connection getConnection(String url, String user, String password) 
                    参数1:告诉我们连接什么类型的数据库及连接那个数据库
                                协议:数据库类型:子协议 参数
                        mysql:    jdbc:mysql://localhost:3306/数据库名称
                        oracle:    jdbc:oracle:thin@localhost:1521@实例
                        
                    参数2:账户名 root
                    参数3:密码


    (了解)Driver:java.sql 接口 驱动
    Connection:连接 接口

        常用方法:
            获取语句执行者:
                (了解)Statement createStatement() :获取普通的语句执行者  会出现sql注入问题
                ★PreparedStatement prepareStatement(String sql) :获取预编译语句执行者
                (了解)CallableStatement prepareCall(String sql):获取调用存储过程的语句执行者

            了解:
                setAutoCommit(false) :手动开启事务
                commit():提交事务
                rollback():事务回滚

     

    Statement:语句执行者 接口

    PreparedStatement:预编译语句执行者 接口
        常用方法:
            设置参数:
                setXxx(int 第几个问号,Object 实际参数);
                    常见的方法:
                         setInt
                         setString
                         setObject
            
            执行sql:
                 ResultSet executeQuery() :执行 r 语句 返回值:结果集
                 int executeUpdate() :执行cud 语句 返回值:影响的行数


    ResultSet:结果集 接口

        执行查询语句之后返回的结果
            常用方法:
                boolean next():判断是否有下一条记录,若有返回true且将光标移到下一行,若没有呢则返回false
                    光标一开始处于第一条记录的上面
                
                获取具体内容
                    getXxx(int|string)
                        若参数为int :第几列
                        若参数为string:列名(字段名)
                    例如:
                        获取cname的内容可以通过
                            getString(2)
                            getString("cname")
                    常用方法:
                        getInt
                        getString 也可以获取int值
                        getObject 可以获取任意
    ///
    常见的配置文件格式:
    1.properties
        里面内容的格式 key=value
    2.xml
    /
    若我们的配置文件为properties,并且放在src目录下.
    我们可以通过 ResourceBundle工具快速获取里面的配置信息
    使用步骤:
        1.获取ResourceBundle 对象:
            static ResourceBundle getBundle("文件名称不带后缀名") 
        2.通过ResourceBundle 对象获取配置信息 
            String getString(String key) :通过执行key获取指定的value

    // 获取ResourceBundle ctrl+2 l
    ResourceBundle bundle = ResourceBundle.getBundle("文件名");
    // 获取指定的内容
    DRIVERCLASS = bundle.getString("driverClass");
    URL = bundle.getString("url");
    USER = bundle.getString("user");
    PASSWORD = bundle.getString("password");  



    //
    案例2-通过连接池(数据源)优化我们的操作.
    需求:
    使用jdbc的时候,没操作一次都需要获取连接(创建)用完之后把连接释放掉了(销毁),通过连接池来优化curd操作.


    连接池

    连接池概述:
    管理数据库的连接,
    作用:
        提高项目的性能.
    就是在连接池初始化的时候存入一定数量的连接,用的时候通过方法获取,不用的时候归还连接即可.
    所有的连接池必须实现一个接口 javax.sql.DataSource接口获取连接方法:
        Connection getConnection() 
    归还连接的方法就是以前的释放资源的方法.调用connection.close();
    自定义一个连接池(理解思想)

    package com.itheima.b_datasourc.b_myds;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.LinkedList;
    
    import com.itheima.utils.JdbcUtils;
    
    /**
     * 简易的连接池
     * @author Administrator
     *
     */
    public class MyDataSource {
        static LinkedList<Connection> pool=new LinkedList<>();
        static{
            //初始化的时候 需要放入3个连接
            for (int i = 0; i < 3; i++) {
                try {
                    Connection conn = JdbcUtils.getConnection();
                    pool.addLast(conn);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    
        //从连接池中获取连接
        public static Connection getConnection(){
            //获取连接的时候需要判断list是否为空
            if(pool.isEmpty()){
                //在添加2个连接进去
                for (int i = 0; i < 3; i++) {
                    try {
                        Connection conn = JdbcUtils.getConnection();
                        pool.addLast(conn);
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("从池中获取一个连接");
            return pool.removeFirst();
        }
        
        //归还连接的方法
        public static void addBack(Connection conn){
            //将conn放入到list的最后面即可
            pool.addLast(conn);
            System.out.println("连接已归还");
        }
    }

    常用连接池:
    DBCP
    C3P0
    ///
    增强方法
    1.继承
    2.装饰者模式(静态代理)
    3.动态代理


    装饰者模式:★★★

    使用步骤:
        1.装饰者和被装饰者实现同一个接口或者继承同一个类
        2.装饰者中要有被装饰者的引用
        3.对需要增强的方法进行加强
        4.对不需要加强的方法调用原来方法    

        举例:改造QQ车速度5秒破百。
        package com.itheima.b_datasourc.c_warp;
        public interface Car {
            void run();
            void stop();
        }
    
        package com.itheima.b_datasourc.c_warp;
        public class QQ implements Car {
            @Override
            public void run() {
                System.out.println("qq在跑");
            }
    
    
            @Override
            public void stop() {
                System.out.println("刹得住车");
            }
        }
    
        package com.itheima.b_datasourc.c_warp;
        public class CarWarp implements Car {
    
    
            private Car car;
    
    
            public CarWarp(Car car){
                this.car=car;
            }
            @Override
            public void run() {
                System.out.println("加上核电池");
                System.out.println("我终于可以5秒破百了..");
            }
            @Override
            public void stop() {
                car.stop();
            }
        }



    常用的连接池:


    DBCP:(理解)

        apache组织
        使用步骤:
            1.导入jar包(commons-dbcp-1.4.jar和commons-pool-1.5.6.jar)
            2.使用api
                a.硬编码
                    //创建连接池
                    BasicDataSource ds = new BasicDataSource();
                    
                    //配置信息
                    ds.setDriverClassName("com.mysql.jdbc.Driver");
                    ds.setUrl("jdbc:mysql:///day07");
                    ds.setUsername("root");
                    ds.setPassword("1234");
                b.配置文件
                    实现编写一个properties文件
                    //存放配置文件
                    Properties prop = new Properties();
                    prop.load(new FileInputStream("src/dbcp.properties"));
                    //设置
                    //prop.setProperty("driverClassName", "com.mysql.jdbc.Driver");
                    
                    //创建连接池
                    DataSource ds = new BasicDataSourceFactory().createDataSource(prop);                
     

                    package com.itheima.b_datasourc.e_dbcp;
    
                    import java.io.FileInputStream;
                    import java.sql.Connection;
                    import java.sql.PreparedStatement;
                    import java.sql.SQLException;
                    import java.util.Properties;
    
                    import javax.sql.DataSource;
    
                    import org.apache.commons.dbcp.BasicDataSource;
                    import org.apache.commons.dbcp.BasicDataSourceFactory;
                    import org.junit.Test;
    
                    import com.itheima.utils.JdbcUtils;
    
                    public class DbcpDemo {
                        @Test
                        //硬编码
                        public void f1() throws Exception{
                            //创建连接池
                            BasicDataSource ds = new BasicDataSource();
                            
                            //配置信息
                            ds.setDriverClassName("com.mysql.jdbc.Driver");
                            ds.setUrl("jdbc:mysql:///day07");
                            ds.setUsername("root");
                            ds.setPassword("1234");
                            
                            Connection conn=ds.getConnection();
                            String sql="insert into category values(?,?);";
                            PreparedStatement st=conn.prepareStatement(sql);
                            
                            //设置参数
                            st.setString(1, "c011");
                            st.setString(2, "饮料");
                            
                            int i = st.executeUpdate();
                            System.out.println(i);
                            JdbcUtils.closeResource(conn, st, null);
                        }
                        
                        @Test
                        public void f2() throws Exception{
                            //存放配置文件
                            Properties prop = new Properties();
                            prop.load(new FileInputStream("src/dbcp.properties"));
                            //设置
                            //prop.setProperty("driverClassName", "com.mysql.jdbc.Driver");
                            
                            //创建连接池
                            DataSource ds = new BasicDataSourceFactory().createDataSource(prop);
                            
                            Connection conn=ds.getConnection();
                            String sql="insert into category values(?,?);";
                            PreparedStatement st=conn.prepareStatement(sql);
                            
                            //设置参数
                            st.setString(1, "c012");
                            st.setString(2, "饮料1");
                            
                            int i = st.executeUpdate();
                            System.out.println(i);
                            JdbcUtils.closeResource(conn, st, null);
                        }
                    }

    C3P0:(★)

        hibernate和spring使用
        有自动回收空闲连接的功能.
        使用步骤:
            1.导入jar包(c3p0-0.9.1.2.jar)
            2.使用api
                a.硬编码(不推荐)
                    new ComboPooledDataSource()
                b.配置文件
                    配置文件的名称:c3p0.properties 或者 c3p0-config.xml
                    配置文件的路径:src下
                
                    编码只需要一句话
                        new ComboPooledDataSource()//使用默认的配置
                        new ComboPooledDataSource(String configName)//使用命名的配置 若配置的名字找不到,使用默认的配置
                        

                    package com.itheima.b_datasourc.f_c3p0;
    
                    import java.beans.PropertyVetoException;
                    import java.sql.Connection;
                    import java.sql.PreparedStatement;
                    import java.sql.SQLException;
    
                    import org.junit.Test;
    
                    import com.itheima.utils.JdbcUtils;
                    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
                    public class C3p0Demo {
                        @Test
                        //硬编码
                        public void f1() throws Exception{
                            ComboPooledDataSource ds = new ComboPooledDataSource();
                            
                            //设置基本参数
                            ds.setDriverClass("com.mysql.jdbc.Driver");
                            ds.setJdbcUrl("jdbc:mysql:///day07");
                            ds.setUser("root");
                            ds.setPassword("1234");
                            
                            Connection conn=ds.getConnection();
                            String sql="insert into category values(?,?);";
                            PreparedStatement st=conn.prepareStatement(sql);
                            
                            //设置参数
                            st.setString(1, "c013");
                            st.setString(2, "毒药");
                            
                            int i = st.executeUpdate();
                            System.out.println(i);
                            JdbcUtils.closeResource(conn, st, null);
                        }
                        
                        @Test
                        public void f2() throws Exception{
                            //ComboPooledDataSource ds = new ComboPooledDataSource();
                            ComboPooledDataSource ds =new ComboPooledDataSource("itcast12321");//若查找不到命名的配置 使用默认的配置
                            Connection conn=ds.getConnection();
                            String sql="insert into category values(?,?);";
                            PreparedStatement st=conn.prepareStatement(sql);
                            
                            //设置参数
                            st.setString(1, "c124");
                            st.setString(2, "解药");
                            
                            int i = st.executeUpdate();
                            System.out.println(i);
                            JdbcUtils.closeResource(conn, st, null);
                        }
                    }      

         


    案例3-使用dbutils完成curd操作

    技术分析:
    dbutils
    dbutils:
    是apache组织的一个工具类,jdbc的框架,更方便我们使用
    使用步骤:
        1.导入jar包(commons-dbutils-1.4.jar)
        2.创建一个queryrunner类
            queryrunner作用:操作sql语句
                构造方法:
                    new QueryRunner(Datasource ds);
        3.编写sql
        4.执行sql
            query(..):执行r操作
            update(...):执行cud操作

    核心类或接口
    QueryRunner:类名
        作用:操作sql语句
        构造器:
            new QueryRunner(Datasource ds);
        注意:
            底层帮我们创建连接,创建语句执行者 ,释放资源.
        常用方法:
            query(..):
            update(..):DbUtils:释放资源,控制事务 类
        closeQuietly(conn):内部处理了异常
        commitAndClose(Connection conn):提交事务并释放连接
        ....

    package com.itheima.c_dbuits.g_curd;
    import java.sql.SQLException;
    import org.apache.commons.dbutils.DbUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.junit.Test;
    
    import com.itheima.utils.DataSourceUtils;
    
    public class CURDDemo {
        @Test
        public void insert() throws SQLException{
            //1.创建queryrunner类
            QueryRunner qr = new QueryRunner(DataSourceUtils.getDataSource());
            
            //2.编写sql
            String sql="insert into category values(?,?)";
            
            
            //3.执行sql
            qr.update(sql, "c201","厨房电器");
            
        }
        
        @Test
        public void update() throws SQLException{
            QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
            
            String sql="update category set cname = ? where cid = ?";
            
            qr.update(sql, "达电器","c000");
        }
    }

    ResultSetHandler:封装结果集 接口

        ArrayHandler, ArrayListHandler, BeanHandler, BeanListHandler, ColumnListHandler, KeyedHandler, MapHandler, MapListHandler, ScalarHandler
         
         (了解)ArrayHandler, 将查询结果的第一条记录封装成数组,返回
         (了解)ArrayListHandler, 将查询结果的每一条记录封装成数组,将每一个数组放入list中返回
         ★★BeanHandler, 将查询结果的第一条记录封装成指定的bean对象,返回
         ★★BeanListHandler, 将查询结果的每一条记录封装成指定的bean对象,将每一个bean对象放入list中 返回.
         (了解)ColumnListHandler, 将查询结果的指定一列放入list中返回 
         (了解)MapHandler, 将查询结果的第一条记录封装成map,字段名作为key,值为value 返回
         ★MapListHandler, 将查询结果的每一条记录封装map集合,将每一个map集合放入list中返回
         ★ScalarHandler,针对于聚合函数 例如:count(*) 返回的是一个Long值

        package com.itheima.c_dbuits.g_curd;
        import java.sql.SQLException;
        import java.util.Arrays;
        import java.util.List;
        import java.util.Map;
        import org.apache.commons.dbutils.QueryRunner;
        import org.apache.commons.dbutils.handlers.ArrayHandler;
        import org.apache.commons.dbutils.handlers.ArrayListHandler;
        import org.apache.commons.dbutils.handlers.BeanHandler;
        import org.apache.commons.dbutils.handlers.BeanListHandler;
        import org.apache.commons.dbutils.handlers.MapHandler;
        import org.apache.commons.dbutils.handlers.MapListHandler;
        import org.apache.commons.dbutils.handlers.ScalarHandler;
        import org.junit.Test;
    
        import com.itheima.domain.Category;
        import com.itheima.utils.DataSourceUtils;
    
        public class ResultHandleDemo {
            @Test
            public void arrayHandler() throws SQLException{
                QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
                
                String sql="select * from category";
                
                Object[] query = qr.query(sql, new ArrayHandler());
                System.out.println(Arrays.toString(query));
            }
            
            @Test
            public void arrayListHandler() throws SQLException{
                QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
                
                String sql="select * from category";
                List<Object[]> list = qr.query(sql, new ArrayListHandler());
                for (Object[] obj : list) {
                    System.out.println(Arrays.toString(obj));
                }
            }
            
            
            @Test
            public void beanHandler() throws SQLException{
                QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
                
                String sql="select * from category";
                
                Category bean = qr.query(sql, new BeanHandler<>(Category.class));
                
                System.out.println(bean);
            }
            
            @Test
            public void beanListHandler() throws SQLException{
                QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
                
                String sql="select * from category";
                
                List<Category> list = qr.query(sql, new BeanListHandler<>(Category.class));
                
                for (Category bean : list) {
                    
                    System.out.println(bean);
                }
            }
            
            @Test
            public void mapHandler() throws SQLException{
                QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
                
                String sql="select * from category";
                
                Map<String, Object> map = qr.query(sql, new MapHandler());
                System.out.println(map);
            }
            
            @Test
            public void mapListHandler() throws SQLException{
                QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
                
                String sql="select * from category";
                
                List<Map<String, Object>> list = qr.query(sql, new MapListHandler());
                for (Map<String, Object> map : list) {
                    System.out.println(map);
                }
            }
            
            @Test
            public void scalarHandler() throws SQLException{
                QueryRunner qr=new QueryRunner(DataSourceUtils.getDataSource());
                
                String sql="select count(*) from category";
                
                Object obj = qr.query(sql, new ScalarHandler());
                System.out.println(obj.getClass().getName());
            }
            
        }


     

    展开全文
  • 一,首先创建一个连接池工具类 package cn.itcast.jdbcutils; /* * 使用DBCP实现数据库的连接池 * 连接池配置,自定义类, * 最基本四项完整 * 对于数据库连接池其他配置,自定义 */ import javax.sql....

    一,首先创建一个连接池工具类

    package cn.itcast.jdbcutils;
    /*
     *  使用DBCP实现数据库的连接池
     *  连接池配置,自定义类,
     *  最基本四项完整
     *  对于数据库连接池其他配置,自定义
     */
    
    import javax.sql.DataSource;
    
    import org.apache.commons.dbcp.BasicDataSource;
    public class JDBCUtils{
        //创建出BasicDataSource类对象
    	private static BasicDataSource datasource = new BasicDataSource();
    	
    	//静态代码块,对象BasicDataSource对象中的配置,自定义
    	static{
    		//数据库连接信息,必须的
    		datasource.setDriverClassName("com.mysql.jdbc.Driver");
    		datasource.setUrl("jdbc:mysql://localhost:3306/day33_user");
    		datasource.setUsername("root");
    		datasource.setPassword("123");
    		//对象连接池中的连接数量配置,可选的
    		datasource.setInitialSize(10);//初始化的连接数
    		datasource.setMaxActive(8);//最大连接数量
    		datasource.setMaxIdle(5);//最大空闲数
    		datasource.setMinIdle(1);//最小空闲
    	}
    	
    	
    	//定义静态方法,返回BasicDataSource类的对象
    	public static DataSource getDataSource(){
    		return datasource;
    	}
    }
    二,利用上面的连接池工具类进行数据库的改查操作

    package cn.itcast.demo;
    /*
     *  测试写好的工具类,
     *  提供的是一个DataSource接口的数据源
     *  QueryRunner类构造方法,接收DataSource接口的实现类
     *  后面,调用方法update,query,无需传递他们Connection连接对象
     */
    
    import java.sql.SQLException;
    import java.util.List;
    
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.ArrayListHandler;
    
    import cn.itcast.jdbcutils.JDBCUtils;
    public class QueryRunnerDemo{
        public static void main(String[] args) {
        	select();
    	}
    	//定义2个方法,实现数据表的添加,数据表查询
    	//QueryRunner类对象,写在类成员位置
    	private static QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource()); 
    	
    	//数据表查询
    	public static void select(){
    		String sql = "SELECT * FROM sort";
    		try{
    		List<Object[]> list = qr.query(sql, new ArrayListHandler());
    		for(Object[] objs : list){
    			for(Object obj : objs){
    				System.out.print(obj+"\t");
    			}
    			System.out.println();
    		}
    		}catch(SQLException ex){
    			throw new RuntimeException("数据查询失败");
    		}
    	}
    	
    	//数据表添加数据
    	public static void insert(){
    		String sql = "INSERT INTO sort (sname,sprice,sdesc)VALUES(?,?,?)";
    		Object[] params = {"水果",100.12,"刚刚上市的核桃"};
    		try{
    			int row = qr.update(sql, params);
    			System.out.println(row);
    		}catch(SQLException ex){
    			throw new RuntimeException("数据添加失败");
    		}
    	}
    	
    }
    


    展开全文
  • 手写连接池的类主要是针对DataSource接口中的getConnection()方法的重写以及回收connection对象,即不再是jdbc连接数据库中直接close()关闭connection对象。 手写连接池的步骤如下: //1.创建1个容器用于存储...
  • 连接池 dpcp c3p0

    2017-05-14 12:48:00
    在实际开发中,发现对象的方法满足不了...连接池 连接会经常用,但是每次都要调用,程序过于冗杂,所以用连接池优化 dbcp c3p0tomcat内置的(dbcp) 只介绍dpcp和c3p0 dpcp和c3p0代码类似,所以用dpcp 1、导入dpcp...
  • try { Properties properties = PropertiesLoaderUtils.loadAllProperties("db/local.properties"); DataSource dataSource = BasicDataSourceFactory.createDataSource(properties); } catch (Exception e) { ...
  • Dpcp,c3p0,Druid连接池的配置文件 Dbcp:#连接设置 driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/school username=root password=root # initialSize=10 #最大连接数量 maxTotal=50 # ...
  • java + 连接池dpcp(一)

    千次阅读 2017-06-06 19:43:13
    //BasicDataSource类就是DBCP连接池的核心类 也就是这个库中的连接池类 //我们要用的连接对象,就是通过这个类获取的 //1, 创建一个对象 BasicDataSource bds = new BasicDataSource(); //2, 配置各种...
  • 连接池详解

    千次阅读 多人点赞 2015-06-01 08:35:14
    数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从“缓冲池”中取出一个,使用完毕之后再放回去。我们可以通过设定连接池最大连接数来...
  • DBCP连接池TestOnBorrow的坑

    万次阅读 2016-08-15 11:03:04
    分析如下:TestOnBorrow=false时,由于不检测池里连接的可用性,于是假如连接池中的连接被数据库关闭了,应用通过连接池getConnection时,都可能获取到这些不可用的连接,且这些连接如果不被其他线程回收的话,它们...
  • 数据库连接池

    2017-09-03 21:45:23
    数据库连接池
  • java 连接池

    2017-04-10 20:03:54
    感谢文章转自:...为解决我们的问题,可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接,当需要建
  • 文章目录前言:为什么使用连接池需要注意的问题:1、并发问题2、事务处理3、连接池的分配与释放4、连接池的配置与维护几种常见的连接池使用方式:Tomcat连接池DBCP连接池C3P0连接池后记: 前言: 对于共享资源,有一个...
  • 连接池

    2019-09-18 12:25:15
    对于共享资源,有一个很著名的...为解决我们的问题,可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从...
  • Java连接池详解

    2017-04-05 17:59:26
    Java连接池详解
  • 转载自这里!!!感谢大哥! 本文使用的是springboot2.0(在配置数据...首先:springboot默认支持的连接池有dbcp,dbcp2, tomcat, hikari四种连接池 由于Tomcat数据源连接池的性能和并发,在tomcat可用时,我们总是优...
  • Java数据库连接池学习

    2014-05-13 11:35:37
    数据库连接池的原理是: 连接池基本的思想是在系统初始化的时候,将数据库连接作为对象存储在内存中,当用户需要访问数据库时,并非建立一个新的连接,而是从连接池中取出一个已建立的空闲连接对象。使用完毕后,...
  • 在实际开发中 不会自己实现连接池,因为自己写的连接池会有很多bug,而且现在有很多开源的数据库连接池供我们使用,因此我们可以使用开源的数据库连接池, 有两种常见的数据库连接池 1.Apache commons-dbcp连接池 ...
  • tomcat服务器端自带的dpcp数据库连接池,速度较C3P0快 C3P0:是一个开源组织提供的一个数据库连接池,速度相对较慢,稳定性还可以 Druid:是阿里提供的数据库连接池 JDBC的数据库连接池使用javax.sql.DataSource...
  • Java连接池详解 tomcat

    千次阅读 2016-11-23 20:36:41
    为解决我们的问题,可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从“缓冲池”中取出一个,使用完毕之后...
  • 主要介绍了Tomcat 7-dbcp配置数据库连接池详解的相关资料,需要的朋友可以参考下
  • 说到druid,这个是在开源中国开源项目中看到的,说是比较好的数据连接池。于是乎就看看。扯淡就到这。  下面就讲讲用的比较多的数据库连接池。(其实我最先接触的是dbc...
  • 自定义连接池

    2011-01-28 08:17:08
    最近自己写了一个数据库连接池,本来想用dpcp、c3p0数据库连接池,但是产品用的是oracle的数据仓库,给的驱动是jdbc驱动,但不是数据库连接驱动,不用以上连接池,自己写了一个,请大家看一下有问题没? public ...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 297
精华内容 118
关键字:

dpcp连接池