C3P0连接池的实现-多种方式

最新推荐文章于 2023-10-23 10:49:58 发布
最新推荐文章于 2023-10-23 10:49:58 发布
阅读量398 收藏
点赞数
分类专栏： C3P0

用到的jar包：

                 mysql-connector-java-5.1.30-bin.jar

                 c3p0-0.9.5.2.jar

                 mchange-commons-java-0.2.11.jar


直接设置参数:

C3P0Inner.java 

[java]  view plain  copy
  1. package com.song.c3p0.db.inner;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7.   
  8. import com.mchange.v2.c3p0.ComboPooledDataSource;  
  9.   
  10. public class C3P0Inner {  
  11.       
  12.     private static ComboPooledDataSource ds;  
  13.       
  14.     //静态初始化块进行初始化  
  15.     static{  
  16.         try {  
  17.             ds = new ComboPooledDataSource();//创建连接池实例  
  18.               
  19.             ds.setDriverClass("com.mysql.jdbc.Driver");//设置连接池连接数据库所需的驱动  
  20.               
  21.             ds.setJdbcUrl("jdbc:mysql://localhost:3306/cloudhospital");//设置连接数据库的URL  
  22.               
  23.             ds.setUser("root");//设置连接数据库的用户名  
  24.               
  25.             ds.setPassword("admin");//设置连接数据库的密码  
  26.               
  27.             ds.setMaxPoolSize(40);//设置连接池的最大连接数  
  28.               
  29.             ds.setMinPoolSize(2);//设置连接池的最小连接数  
  30.               
  31.             ds.setInitialPoolSize(10);//设置连接池的初始连接数  
  32.               
  33.             ds.setMaxStatements(100);//设置连接池的缓存Statement的最大数              
  34.         } catch (Exception e) {  
  35.             e.printStackTrace();  
  36.         }  
  37.     }  
  38.       
  39.     //获取与指定数据库的连接  
  40.     public static ComboPooledDataSource getInstance(){  
  41.         return ds;  
  42.     }   
  43.   
  44.     //从连接池返回一个连接  
  45.     public static Connection getConnection(){  
  46.         Connection conn = null;  
  47.         try {  
  48.             conn = ds.getConnection();  
  49.         } catch (Exception e) {  
  50.             e.printStackTrace();  
  51.         }  
  52.         return conn;  
  53.     }  
  54.       
  55.     //释放资源  
  56.     public static void realeaseResource(ResultSet rs,PreparedStatement ps,Connection conn){  
  57.         if(null != rs){  
  58.             try {  
  59.                 rs.close();  
  60.             } catch (SQLException e) {  
  61.                 e.printStackTrace();  
  62.             }  
  63.         }  
  64.           
  65.         if(null != ps){  
  66.             try {  
  67.                 ps.close();  
  68.             } catch (SQLException e) {  
  69.                 e.printStackTrace();  
  70.             }  
  71.         }  
  72.   
  73.         try {  
  74.             conn.close();  
  75.         } catch (SQLException e) {  
  76.             e.printStackTrace();  
  77.         }  
  78.     }  
  79. }  

C3P0InnerMain.java

[java]  view plain  copy
  1. package com.song.c3p0.db.inner;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7.   
  8. public class C3P0InnerMain {  
  9.   
  10.     public PreparedStatement setStatement(Connection conn,String sql){  
  11.         PreparedStatement ps = null;  
  12.         try {  
  13.             ps = conn.prepareStatement(sql);  
  14.         } catch (SQLException e) {  
  15.             e.printStackTrace();  
  16.         }  
  17.         return ps;  
  18.     }  
  19.       
  20.     public PreparedStatement setParameter(PreparedStatement ps,Object...values){  
  21.         try {  
  22.             if(null != values){  
  23.                 for(int i=1;i<=values.length;i++){  
  24.                     ps.setObject(i, values[i-1]);  
  25.                 }  
  26.             }  
  27.         } catch (Exception e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.         return ps;  
  31.     }  
  32.       
  33.     public static void main(String[] args) {  
  34.         Connection conn = null;  
  35.         PreparedStatement ps = null;  
  36.         ResultSet rs = null;  
  37.         try {  
  38.             conn = C3P0Inner.getConnection();  
  39.               
  40.             C3P0InnerMain c3P0InnerMain = new C3P0InnerMain();  
  41.               
  42.             String sql = "SELECT * FROM tb_user WHERE ID < ? ";  
  43.               
  44.             ps = c3P0InnerMain.setStatement(conn, sql);  
  45.             ps = c3P0InnerMain.setParameter(ps, new Object[]{20});  
  46.               
  47.             rs = ps.executeQuery();  
  48.               
  49.             while(rs.next()){  
  50.                 Object ob = rs.getObject(1);  
  51.                 Object name = rs.getObject(4);  
  52.                 System.out.println("ID: " + ob + ",NAME:" + name);  
  53.             }  
  54.               
  55.         } catch (Exception e) {  
  56.             e.printStackTrace();  
  57.         }finally{  
  58.             //释放资源  
  59.             C3P0Inner.realeaseResource(rs, ps, conn);  
  60.         }  
  61.     }  
  62. }  

用配置文件设置参数：

1.从配置文件中逐条获取参数

config.properties

[plain]  view plain  copy
  1. DriverClass = com.mysql.jdbc.Driver  
  2. JdbcUrl = jdbc:mysql://localhost:3306/cloudhospital  
  3. User = root  
  4. Password = admin  
  5. MaxPoolSize = 20  
  6. MinPoolSize = 2  
  7. InitialPoolSize = 5  
  8. MaxStatements = 30  
  9. MaxIdleTime = 100  

C3P0Properties.java

[java]  view plain  copy
  1. package com.song.c3p0.db.properties;  
  2.   
  3. import java.sql.Connection;  
  4. import java.util.Properties;  
  5.   
  6. import com.mchange.v2.c3p0.ComboPooledDataSource;  
  7.   
  8. public class C3P0Properties {  
  9.   
  10.     private ComboPooledDataSource cpds;  
  11.       
  12.     private static C3P0Properties c3P0Properties;  
  13.       
  14.     static{  
  15.         c3P0Properties = new C3P0Properties();  
  16.     }  
  17.   
  18.     public C3P0Properties() {  
  19.         try {  
  20.             cpds = new ComboPooledDataSource();  
  21.               
  22.             //加载配置文件  
  23.             Properties props = new Properties();  
  24.             props.load(C3P0Properties.class.getClassLoader().getResourceAsStream("config.properties"));  
  25.               
  26.             cpds.setDriverClass(props.getProperty("DriverClass"));  
  27.             cpds.setJdbcUrl(props.getProperty("JdbcUrl"));  
  28.             cpds.setUser(props.getProperty("User"));  
  29.             cpds.setPassword(props.getProperty("Password"));  
  30.               
  31.             cpds.setMaxPoolSize(Integer.parseInt(props.getProperty("MaxPoolSize")));  
  32.             cpds.setMinPoolSize(Integer.parseInt(props.getProperty("MinPoolSize")));  
  33.             cpds.setInitialPoolSize(Integer.parseInt(props.getProperty("InitialPoolSize")));  
  34.             cpds.setMaxStatements(Integer.parseInt(props.getProperty("MaxStatements")));  
  35.             cpds.setMaxIdleTime(Integer.parseInt(props.getProperty("MaxIdleTime")));  
  36.               
  37.         } catch (Exception e) {  
  38.             e.printStackTrace();  
  39.         }  
  40.     }  
  41.       
  42.     public static C3P0Properties getInstance(){  
  43.         return c3P0Properties;  
  44.     }  
  45.       
  46.     public Connection getConnection(){  
  47.         Connection conn = null;  
  48.         try {  
  49.             conn = cpds.getConnection();  
  50.         } catch (Exception e) {  
  51.             e.printStackTrace();  
  52.         }  
  53.         return conn;  
  54.     }  
  55. }  

C3POPropertiesMain.java

[java]  view plain  copy
  1. package com.song.c3p0.db.properties;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7.   
  8. public class C3POPropertiesMain {  
  9.   
  10.     public PreparedStatement getPrepareStatement(Connection conn,String sql){  
  11.         PreparedStatement ps = null;  
  12.         try {  
  13.             ps = conn.prepareStatement(sql);  
  14.         } catch (SQLException e) {  
  15.             e.printStackTrace();  
  16.         }  
  17.         return ps;  
  18.     }  
  19.       
  20.     public PreparedStatement setPrepareStatementParameter(PreparedStatement ps,Object... values){  
  21.         try {  
  22.             if (null != values) {  
  23.                 for (int i = 1; i <= values.length; i++) {  
  24.                     ps.setObject(i, values[i - 1]);  
  25.                 }  
  26.             }  
  27.         } catch (SQLException e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.         return ps;  
  31.     }  
  32.       
  33.     //释放资源  
  34.     public static void realeaseResource(ResultSet rs,PreparedStatement ps,Connection conn){  
  35.         if(null != rs){  
  36.             try {  
  37.                 rs.close();  
  38.             } catch (SQLException e) {  
  39.                 e.printStackTrace();  
  40.             }  
  41.         }  
  42.           
  43.         if(null != ps){  
  44.             try {  
  45.                 ps.close();  
  46.             } catch (SQLException e) {  
  47.                 e.printStackTrace();  
  48.             }  
  49.         }  
  50.   
  51.         try {  
  52.             conn.close();  
  53.         } catch (SQLException e) {  
  54.             e.printStackTrace();  
  55.         }  
  56.     }  
  57.       
  58.     public static void main(String[] args) {  
  59.         Connection conn = null;  
  60.         PreparedStatement ps = null;  
  61.         ResultSet rs = null;  
  62.         try {  
  63.             conn = C3P0Properties.getInstance().getConnection();  
  64.               
  65.             String sql = "SELECT * FROM tb_user WHERE ID < ? ";  
  66.               
  67.             C3POPropertiesMain c3p0Instance = new C3POPropertiesMain();  
  68.               
  69.             ps = c3p0Instance.getPrepareStatement(conn, sql);  
  70.             c3p0Instance.setPrepareStatementParameter(ps, new Object[]{20});  
  71.               
  72.             rs = ps.executeQuery();  
  73.               
  74.             while(rs.next()){  
  75.                 Object obj1 = rs.getObject(1);  
  76.                 Object obj4 = rs.getObject(4);  
  77.                   
  78.                 System.out.println("ID: " + obj1 + ",NAME: " + obj4);  
  79.             }  
  80.         } catch (SQLException e) {  
  81.             e.printStackTrace();  
  82.         }finally{  
  83.             //释放资源  
  84.             C3POPropertiesMain.realeaseResource(rs, ps, conn);  
  85.         }  
  86.     }  
  87. }  

2.不用显式的从配置文件中获取参数

c3p0.properties

[plain]  view plain  copy
  1. c3p0.driverClass = com.mysql.jdbc.Driver  
  2. c3p0.jdbcUrl = jdbc:mysql://localhost:3306/cloudhospital  
  3. c3p0.user = root  
  4. c3p0.password = admin  
  5. c3p0.maxPoolSize = 20  
  6. c3p0.minPoolSize = 3  
  7. c3p0.maxStatements = 30  
  8. c3p0.maxIdleTime = 150  

C3P0PropertiesSimplify.java

[java]  view plain  copy
  1. package com.song.c3p0.db.properties;  
  2.   
  3. import java.sql.Connection;  
  4.   
  5. import com.mchange.v2.c3p0.ComboPooledDataSource;  
  6.   
  7. public class C3P0PropertiesSimplify {  
  8.       
  9.     private static C3P0PropertiesSimplify c3P0PropertiesSimplify;  
  10.       
  11.     private ComboPooledDataSource cpds;  
  12.       
  13.     static{  
  14.         c3P0PropertiesSimplify = new C3P0PropertiesSimplify();  
  15.     }  
  16.   
  17.     public C3P0PropertiesSimplify() {  
  18.         cpds = new ComboPooledDataSource();  
  19.     }  
  20.       
  21.     public static C3P0PropertiesSimplify getInstance(){  
  22.         return c3P0PropertiesSimplify;  
  23.     }  
  24.       
  25.     public Connection getConnection(){  
  26.         Connection conn = null;  
  27.         try {  
  28.             conn = cpds.getConnection();  
  29.         } catch (Exception e) {  
  30.             e.printStackTrace();  
  31.         }  
  32.         return conn;  
  33.     }  
  34. }  

C3P0PropertiesSimplifyMain.java

[java]  view plain  copy
  1. package com.song.c3p0.db.properties;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7.   
  8. public class C3P0PropertiesSimplifyMain {  
  9.   
  10.     public PreparedStatement createStatement(Connection conn,String sql){  
  11.         PreparedStatement ps = null;  
  12.         try {  
  13.             ps = conn.prepareStatement(sql);  
  14.         } catch (SQLException e) {  
  15.             e.printStackTrace();  
  16.         }  
  17.         return ps;  
  18.     }  
  19.       
  20.     public PreparedStatement setParameters(PreparedStatement ps,Object...values){  
  21.         try {  
  22.             if(null != values){  
  23.                 for(int i=1;i<=values.length;i++){  
  24.                     ps.setObject(i, values[i-1]);  
  25.                 }  
  26.             }  
  27.         } catch (Exception e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.         return ps;  
  31.     }  
  32.       
  33.     public static void main(String[] args) {  
  34.         Connection conn = null;  
  35.         PreparedStatement ps = null;  
  36.         ResultSet rs = null;  
  37.         try {  
  38.             conn = C3P0PropertiesSimplify.getInstance().getConnection();  
  39.               
  40.             C3P0PropertiesSimplifyMain c3p0Instance = new C3P0PropertiesSimplifyMain();  
  41.             String sql = "SELECT * FROM tb_user WHERE ID < ? ";  
  42.             ps = c3p0Instance.createStatement(conn, sql);  
  43.             ps = c3p0Instance.setParameters(ps, new Object[]{20});  
  44.               
  45.             rs = ps.executeQuery();  
  46.             while(rs.next()){  
  47.                 Object obj1 = rs.getObject(1);  
  48.                 Object obj4 = rs.getObject(4);  
  49.                   
  50.                 System.out.println("ID: " + obj1 + ",Name: " + obj4);  
  51.             }  
  52.         } catch (Exception e) {  
  53.         }finally{  
  54.             try {  
  55.                 if(null != rs){  
  56.                     try {  
  57.                         rs.close();  
  58.                     } catch (SQLException e) {  
  59.                         e.printStackTrace();  
  60.                     }  
  61.                 }  
  62.                   
  63.                 if(null != ps){  
  64.                     try {  
  65.                         ps.close();  
  66.                     } catch (SQLException e) {  
  67.                         e.printStackTrace();  
  68.                     }  
  69.                 }  
  70.                   
  71.                 try {  
  72.                     conn.close();  
  73.                 } catch (SQLException e) {  
  74.                     e.printStackTrace();  
  75.                 }  
  76.             } catch (Exception e2) {  
  77.                 e2.printStackTrace();  
  78.             }  
  79.         }  
  80.     }  
  81. }  

用xml文件设置参数：

c3p0-config.xml
[html]  view plain  copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <c3p0-config>  
  3.     <named-config name="myc3p0xml">  
  4.         <property name="driverClass">com.mysql.jdbc.Driver</property>  
  5.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/cloudhospital</property>  
  6.         <property name="user">root</property>  
  7.         <property name="password">admin</property>  
  8.         <property name="maxPoolSize">20</property>  
  9.         <property name="minPoolSize">3</property>  
  10.         <property name="maxStatements">30</property>  
  11.         <property name="maxIdleTime">150</property>  
  12.     </named-config>  
  13. </c3p0-config>  
C3P0XmlSimplify.java
[java]  view plain  copy
  1. package com.song.c3p0.db.xml;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7.   
  8. import com.mchange.v2.c3p0.ComboPooledDataSource;  
  9.   
  10. public class C3P0XmlSimplify {  
  11.       
  12.     private static C3P0XmlSimplify c3P0XmlSimplify;  
  13.   
  14.     private ComboPooledDataSource cpds;  
  15.       
  16.     static{  
  17.         c3P0XmlSimplify = new C3P0XmlSimplify();  
  18.     }  
  19.   
  20.     public C3P0XmlSimplify() {  
  21.         cpds = new ComboPooledDataSource("myc3p0xml");  
  22.     }  
  23.       
  24.     public static C3P0XmlSimplify getInstance(){  
  25.         return c3P0XmlSimplify;  
  26.     }  
  27.       
  28.     public Connection getConnection(){  
  29.         Connection conn = null;  
  30.         try {  
  31.             conn = cpds.getConnection();  
  32.         } catch (Exception e) {  
  33.             e.printStackTrace();  
  34.         }  
  35.         return conn;  
  36.     }  
  37.       
  38.     public static PreparedStatement setStatement(Connection conn, String sql){  
  39.         PreparedStatement ps = null;  
  40.         try {  
  41.             ps = conn.prepareStatement(sql);  
  42.         } catch (SQLException e) {  
  43.             e.printStackTrace();  
  44.         }  
  45.         return ps;  
  46.     }  
  47.       
  48.       
  49.     public static PreparedStatement setSQLParameters(PreparedStatement ps,Object...values){  
  50.         try {  
  51.             if (null != values) {  
  52.                 for (int i = 1; i <= values.length; i++) {  
  53.                     ps.setObject(i, values[i-1]);  
  54.                 }  
  55.             }  
  56.         } catch (Exception e) {  
  57.             e.printStackTrace();  
  58.         }  
  59.         return ps;  
  60.     }  
  61.       
  62.     public static void releaseSources(Connection conn, PreparedStatement ps, ResultSet rs){  
  63.         if(null != rs){  
  64.             try {  
  65.                 rs.close();  
  66.             } catch (Exception e) {  
  67.                 e.printStackTrace();  
  68.             }  
  69.         }  
  70.           
  71.         if(null != ps){  
  72.             try {  
  73.                 ps.close();  
  74.             } catch (Exception e) {  
  75.                 e.printStackTrace();  
  76.             }  
  77.         }  
  78.           
  79.         if(null != conn){  
  80.             try {  
  81.                 conn.close();  
  82.             } catch (Exception e) {  
  83.                 e.printStackTrace();  
  84.             }  
  85.         }  
  86.     }  
  87. }  
C3P0XmlSimplifyMain.java
[java]  view plain  copy
  1. package com.song.c3p0.db.xml;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6.   
  7. public class C3P0XmlSimplifyMain {  
  8.   
  9.     public static void main(String[] args) {  
  10.         Connection conn = null;  
  11.         PreparedStatement ps = null;  
  12.         ResultSet rs = null;  
  13.         try {  
  14.             conn = C3P0XmlSimplify.getInstance().getConnection();  
  15.               
  16.             String sql = " SELECT * FROM tb_user WHERE ID < ? ";  
  17.             ps = C3P0XmlSimplify.setStatement(conn, sql);  
  18.             ps = C3P0XmlSimplify.setSQLParameters(ps, new Object[]{20});  
  19.               
  20.             rs = ps.executeQuery();  
  21.               
  22.             while(rs.next()){  
  23.                 Object obj1 = rs.getObject(1);  
  24.                 Object obj4 = rs.getObject(4);  
  25.                   
  26.                 System.out.println("ID: " + obj1 + ",Name: " + obj4);  
  27.             }  
  28.         } catch (Exception e) {  
  29.             e.printStackTrace();  
  30.         }finally{  
  31.             C3P0XmlSimplify.releaseSources(conn, ps, rs);  
  32.         }  
  33.     }  
  34. }  
PID_918
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C3P0连接池的操作方法
weixin_49496988的博客
08-05 403
步骤: 拷贝jar 拷贝配置文件(c3p0-config.xml)到src目录【名字不要改】 创建C3P0连接池对象【自动的读取】 从池子里面获得连接 配置文件： <c3p0-config> <default-config> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc
C3P0连接池配置
Summer_Xi的博客
09-16 571
C3P0的连接池配置以及MySQL8.0.20的配置 报错信息和问题： 由于学习中，遇到MySQL版本不同造成C3P0连接池连接超时问题，百度之后总结出相关配置文件： 九月 16, 2020 3:15:15 下午 com.mchange.v2.log.MLog 信息: MLog clients using java 1.4+ standard logging. 九月 16, 2020 3:15:16 下午 com.mchange.v2.c3p0.C3P0Registry 信息: Initializing
C3P0连接池参数配置
07-05
C3P0连接池参数配置
C3P0连接池的基本配置与使用
weixin_50216991的博客
10-15 6355
上一期我写了一篇Druid连接池的基本配置与使用，今天我要介绍一下C3P0连接池的基本使用。因为是介绍基本使用，所以我打算用一个非常简单的java应用来教大家如何对C3P0连接池进行基本配和使用。所以你只要有jdbc和Java基础就能看懂这篇文章，并学会如何使用。 一.C3P0连接池简介 C3P0连接池也是一款开源的连接池，它与阿里巴巴的Druid的使用方法都差不多。不同之处在于Driud连接池的数据库配置是写在druid-config.properties的属性配置文件中，而C3P0连接池把数据库配置
C3P0数据库连接池的配置
m0_74162514的博客
01-05 1068
输出下面语句表示成功！其中红色的不是报错，而是日志。
【Java 进阶篇】JDBC 数据库连接池 C3P0 详解
繁依Fanyi的博客
10-05 4948
在了解 C3P0 数据库连接池之前，让我们先明确什么是数据库连接池。数据库连接池是一个维护数据库连接的池子，它预先创建一定数量的数据库连接，并将这些连接保存在池中，以便应用程序在需要时可以从池中获取连接，而不是每次都创建新的连接。数据库连接是一种昂贵的资源，创建和销毁连接的开销很大。通过使用连接池，可以避免频繁地创建和销毁连接，提高了数据库访问的性能和效率。连接池还可以控制连接的数量，防止连接数过多导致数据库性能下降，同时还可以管理连接的状态、超时和异常处理。
数据库连接池
sichenss的博客
03-10 138
学习笔记
C3P0连接池.zip
06-06
C3P0连接池是一个广泛使用的Java数据库连接池实现，它允许程序在多个数据库操作之间重用数据库连接，从而提高应用程序的性能和效率。数据库连接池管理着数据库连接的创建、分配、回收和销毁，避免了频繁的创建和关闭...
DBCP,c3p0连接池所需要的包
07-01
DBCP（Jakarta DBCP）和c3p0是两种常用的开源数据库连接池实现。 DBCP，全称Jakarta Commons DBCP，是Apache软件基金会下的一个项目，它基于Apache的Jakarta POI项目中的DBUtils模块发展而来。DBCP提供了一个可配置...
c3p0连接池jar包
03-28
6. 分布式环境支持：在分布式系统中，C3P0可以通过配置实现连接池的负载均衡，提高系统的伸缩性和可用性。 7. 异常处理：C3P0提供了详细的日志记录和异常处理机制，方便开发者诊断和解决问题。 使用C3P0连接池的...
C3P0连接池.rar
07-09
C3P0是Miguel Grinberg所开发的一个开源项目，它实现了JDBC规范中的DataSource接口，允许开发者通过配置参数来调整连接池的行为，如最大连接数、最小连接数、超时时间等。C3P0的核心功能包括： 1. **连接创建与回收...
java_c3p0配置_c3p0.properties配置文件
qq_41921378的博客
09-04 972
1、下载c3p0的jar包，并导入项目中 2、书写属性配置文件 (1) 属性配置文件名必须叫c3p0.properties (2) 属性文件中的属性名也必须按要求写，不能更改 必须有前缀 c3p0. (3) 该属性配置文件必须放在源文件夹路径下 src # 基础配置 c3p0.driverClass=com.mysql.jdbc.Driver c3p0.jdbcUrl=jdbc:mysql://127.0.0.1:3306/offcn?useSSL=false&cha.
c3p0数据库连接池的三种配置方式(java代码、xml文件、properties文件)
很简单_的博客
03-09 4368
数据库连接池 JDBC开发流程 加载驱动（只加载一次） 获取数据库连接（Connection） 执行 SQL 语句（Statement） ResultSet 接收结果集 断开连接，释放资源 数据库连接对象是通过 DriverManager 得到的，每次获取都要向数据库申请获取连接，并验证用户名、密码，执行完 SQL 语句后，断开连接，这样的方式会造成资源的浪费，因为连接对象只使用了一次就释放掉了，下一次连接还要继续向数据库申请，相当于用一部手机打电话，打了一通电话就把手机扔掉了，需要下一次通话时，在买一
C3P0（数据库连接池）详解
qq_30436011的博客
03-06 1653
是一个开源的JDBC连接池，它实现了数据源与JNDI绑定，支持JDBC3规范和实现了JDBC2的标准扩展说明的Connection和Statement池的DataSources对象。即将用于连接数据库的连接整合在一起形成一个随取随用的。
C3P0数据库连接池的三种配置方式以及访问数据库的简单实现
浅时光|初如梦
06-15 2147
1.配置方式 c3p0的三种配置方式： 1.setters一个个地设置各个配置项 2.类路径下提供一个c3p0.properties文件 3.类路径下提供一个c3p0-config.xml文件 注意：编写配置文件,要求有固定的格式和固定的名字(c3p0-config.xml和c3p0.properties)该配置文件要放到项目的src目录下 三中配置的优先级为：setters>c3p0-config.xml>c3p0.properties 优先级的验证： 情况一： 无论如何配置c
C3P0数据库连接池的使用及总结
m0_68721674的博客
05-13 655
其中，src下的配置文件为：【c3p0-config.xml】①通过本身自由的set方式，一个个的设置驱动以及账号密码。②封装.xml文件放到Src目录下，直接调用。是一个开源组织提供的一个数据库连接池，(1).先在项目中导入所需的jar包。hibernate官方推荐使用。(3)创建C3P0连接池对象。
c3p0连接池配置
最新发布
sun13212715744的博客
10-23 622
这只是一个基本的C3P0连接池配置示例。你可以根据你的项目需求和数据库配置进行更多高级设置。确保在你的项目中正确管理数据库连接，以防止连接泄漏，并优化性能。C3P0是一个流行的Java连接池库，用于管理数据库连接，以提高应用程序性能并有效地处理数据库连接的开启和关闭。在你的应用程序中创建一个C3P0连接池配置文件，通常是一个.properties文件，例如c3p0-config.properties。首先，确保你已经将C3P0库添加到你的项目中。# 重新尝试获取连接的次数，如果连接被占用。
JDBC连接池C3P0(一)：使用properties文件进行配置
总有一天，你的日积月累，会成为别人的望尘莫及
07-07 3986
1、在src下新建一个properties文件，名字随便符合命名规范即可，我这里的名称为：c3p0config.properties，内容如下： jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/test jdbc.username=root jdbc.pwd=root 2、新建类进行连接测试：...
数据库连接池详解：DBCP、C3P0与JNDI配置及原理
"本章主要探讨数据库连接池的原理及应用，特别关注DBCP、C3P0和JNDI连接池的配置方法。通过学习，你可以了解如何优化...DBCP、C3P0和JNDI都是常见的连接池实现，选择合适的连接池并正确配置，是优化数据库访问的关键。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值