c3p0，DBCP连接池 和DBUtils工具类 使用介绍

c3p0的使用

== c3p0使用xml配置问文件
配置文件，配置文件一定到放置到src下，命名为：c3p0-config.xml ==

<c3p0-config>
<!-- This app is massive! -->
  <named-config name="mvcapp">
   <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/students</property>
    <property name="user">root</property>
    <property name="password">abcdef</property>


    <property name="acquireIncrement">5</property>
    <property name="initialPoolSize">10</property>
    <property name="minPoolSize">10</property>
    <property name="maxPoolSize">50</property>


    <!-- intergalactoApp adopts a different approach to configuring statement caching -->
    <property name="maxStatements">20</property>
    <property name="maxStatementsPerConnection">5</property>
   </named-config>
</c3p0-config>

ComboPooledDataSource ds = new ComboPooledDataSource();使用默认配置文件·
ComboPooledDataSource ds = new ComboPooledDataSource(“BarryLee”);//2.带参–指定名称的配置

纯java不使用配置文件

import java.sql.Connection;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class ConnectionFactory {
    private static ComboPooledDataSource ds = null;
    static {
        try {
            String driver = "oracle.jdbc.driver.OracleDriver";
            String url = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";
            String user = "phonesurvey";
            String password = "world";


            ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(user);
            ds.setPassword(password);


            ds.setMaxPoolSize(200);
            ds.setMinPoolSize(20);


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static synchronized Connection getConnection(){
        Connection conn = null;
        try{
            conn = ds.getConnection();
        }catch(Exception e){
            e.printStackTrace();
        }
        return conn;
    }
    
    

DBCP的简单使用

配置文件 名称必须是 .propertises结尾
文件位置任意 建议是 src路径
配置文件不能编写中文不支持在sts中修改 必须使用记事本修改内容否则注释乱码

DBCP配置文件
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
username=账号
password=密码
initialSize=2              //连接池建立时创建的连接的数量
maxActive=15          //连接池同一时间内最多能够分配的活动连接的数量
maxIdle=2                //在其他连接没有被释放的情况下，连接池中最多能够保留的闲置连接
minIdle=1                //在没有其他连接被创建的情况下，连接池中最少可以保留的闲置连接
maxWait=30000      //当遇到请求，而连接池中没有连接可以被分配，连接池最大等待时间，超过这个时间将会抛出一个异常。为-1时，将会无限期等待。

dbcp使用

private static DataSource dataSource;
    static{
        try {
            //1.加载找properties文件输入流
            InputStream is = DBCPUtils.class.getClassLoader().getResourceAsStream("database.properties");
            //2.加载输入流
            Properties props = new Properties();
            props.load(is);
            //3.创建数据源
            dataSource = BasicDataSourceFactory.createDataSource(props);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    public static DataSource getDataSource(){
        return dataSource;
    }
    
    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

DButils jdbc的简化开发工具包

JavaBean组件
1，需要实现java.io.Serializable
2, 提供私有字段 private 类型字段名
3，提供setter 和geter方法
核心类· QueryRunner 提供了 对sql语句操控的api
ResultSetHandler接口 定义操作后 select查询后 怎么封装结果集
DbUtils 工具类定义了关闭资源和事物处理的方式
QueryRunner核心类
QueryRunner（DataSoutce ds）提供数据源（连接池）自动维护connection
update（String sql，Object…params）执行更新操作
query（String sql,ResultSetHandler rsh,Object…params）执行查询 第二个参数 BeanHandler 将第一条 结果封装到Bean中 BeanListHandler 讲所有记录封装到javaBean的list集合中 ScalarHandler它用于返回一个数据还有l很多封装见下面实例

public static void arrayHandler()throws SQLException{
49         QueryRunner qr = new QueryRunner();
50         String sql = "SELECT * FROM classmate";
51         //调用方法query执行查询,传递连接对象,SQL语句,结果集处理方式的实现类
52         //返回对象数组
53         Object[] result = qr.query(con, sql, new ArrayHandler());
54         for(Object obj : result){
55             System.out.print(obj);
56         }
57     }
58     
59     
60     
61     /*
62      *  结果集第二种处理方法,ArrayListHandler
63      *  将结果集的每一行,封装到对象数组中, 出现很多对象数组
64      *  对象数组存储到List集合
65      */
66     public static void arrayListHandler()throws SQLException{
67         QueryRunner qr = new QueryRunner();
68         String sql = "SELECT * FROM classmate";        
69         //调用query方法,结果集处理的参数上,传递实现类ArrayListHandler
70         //方法返回值 每行是一个对象数组,存储到List
71         List<Object[]> result=  qr.query(con, sql, new ArrayListHandler());
72         
73         //集合的遍历
74         for( Object[] objs  : result){
75             //遍历对象数组
76             for(Object obj : objs){
77                 System.out.print(obj+",");
78             }
79             System.out.println();
80         }
81     }
82     
83     
84     /*
85      *  结果集第三种处理方法,BeanHandler
86      *  将结果集的第一行数据,封装成JavaBean对象
87      *  注意: 被封装成数据到JavaBean对象, Sort类必须有空参数构造
88      */
89     public static void beanHandler()throws SQLException{
90         QueryRunner qr = new QueryRunner();
91         String sql = "SELECT * FROM classmate";
92         //调用方法,传递结果集实现类BeanHandler
93         //BeanHandler(Class<T> type)
94         Student s = qr.query(con, sql, new BeanHandler<Student>(Student.class));
95         System.out.println(s);
96     }
97     
98     
99     
100     /*
101      *  结果集第四种处理方法, BeanListHandler
102      *  结果集每一行数据,封装JavaBean对象
103      *  多个JavaBean对象,存储到List集合
104      */
105     public static void beanListHander()throws SQLException{
106         QueryRunner qr = new QueryRunner();
107         String sql = "SELECT * FROM classmate ";
108         //调用方法query,传递结果集处理实现类BeanListHandler
109         List<Student> list = qr.query(con, sql, new BeanListHandler<Student>(Student.class));
110         for(Student s : list){
111             System.out.println(s);
112         }
113     }
114     
115     /*
116      *  结果集第五种处理方法,ColumnListHandler
117      *  结果集,指定列的数据,存储到List集合
118      *  List<Object> 每个列数据类型不同
119      */
120     public static void columnListHandler()throws SQLException{
121         QueryRunner qr = new QueryRunner();
122         String sql = "SELECT * FROM classmate ";        
123         //调用方法 query,传递结果集实现类ColumnListHandler
124         //实现类构造方法中,使用字符串的列名
125         List<Object> list = qr.query(con, sql, new ColumnListHandler<Object>("name"));
126         for(Object obj : list){
127             System.out.println(obj);
128         }
129     }
130     
131     
132     /*
133      *  结果集第六种处理方法,ScalarHandler
134      *  对于查询后,只有1个结果
135      */
136     public static void scalarHandler()throws SQLException{
137         QueryRunner qr = new QueryRunner();
138         String sql = "SELECT COUNT(*) FROM classmate";
139         //调用方法query,传递结果集处理实现类ScalarHandler
140         long count = qr.query(con, sql, new ScalarHandler<Long>());
141         System.out.println(count);
142     }
143     
144     /*
145      *  结果集第七种处理方法,MapHandler
146      *  将结果集第一行数据,封装到Map集合中
147      *  Map<键,值> 键:列名  值:这列的数据
148      */
149     public static void mapHandler()throws SQLException{
150         QueryRunner qr = new QueryRunner();
151         //注意，这里是可以用占位符哟,我下面就对他进行了传参，参数为11
152         String sql = "SELECT  * FROM classmate where id = ?";
153         //调用方法query,传递结果集实现类MapHandler
154         //返回值: Map集合,Map接口实现类, 泛型
155         Map<String,Object> map = qr.query(con, sql, new MapHandler(),11);
156         //遍历Map集合
157         for(String key : map.keySet()){
158             System.out.println(key+".."+map.get(key));
159         }
160     }
161     
162     /*
163      *  结果集第八种处理方法,MapListHandler
164      *  将结果集每一行存储到Map集合,键:列名,值:数据
165      *  Map集合过多,存储到List集合
166      */
167     public static void mapListHandler()throws SQLException{
168         QueryRunner qr = new QueryRunner();
169         String sql = "SELECT  * FROM classmate";
170         //调用方法query,传递结果集实现类MapListHandler
171         //返回值List集合, 存储的是Map集合
172         List<Map<String,Object>> list = qr.query(con, sql, new MapListHandler());
173         //遍历集合list
174         for( Map<String,Object> map : list ){
175             for(String key : map.keySet()){
176                 System.out.print(key+"..."+map.get(key)+", ");
177             }
178             System.out.println();
179         }
180         
181     }
182 }