博客分类：
连接池的管理用了了享元模式，这里对连接池进行简单设计。
一、设计思路
1.连接池配置属性DBbean：里面存放可以配置的一些属性
2.连接池接口IConnectionPool：里面定义一些基本的获取连接的一些方法
3.接口实现ConnectionPool：对上面操作进行实现，并加入一些其他方法
4.连接池管理ConnectionPoolManager：管理所有的不同的连接池，所有的连接都能通过这里进行获得连接
5.另外还有几个测试类，和连接信息模拟的类，这里就不进行xml 和配置文件信息的读取了
* 这是外部可以配置的连接池属性
* 可以允许外部配置，拥有默认值
* @author Ran
public class DBbean {
// 连接池属性
private String driverN
private String userN
// 连接池名字
private String poolN
private int minConnections = 1; // 空闲池，最小连接数
private int maxConnections = 10; // 空闲池，最大连接数
private int initConnections = 5;// 初始化连接数
private long connTimeOut = 1000;// 重复获得连接的频率
private int maxActiveConnections = 100;// 最大允许的连接数，和数据库对应
private long connectionTimeOut = ;// 连接超时时间，默认20分钟
private boolean isCurrentConnection = // 是否获得当前连接，默认true
private boolean isCheakPool = // 是否定时检查连接池
private long lazyCheck = ;// 延迟多少时间后开始 检查
private long periodCheck = ;// 检查频率
public DBbean(String driverName, String url, String userName,
String password, String poolName) {
this.driverName = driverN
this.url =
this.userName = userN
this.password =
this.poolName = poolN
public DBbean() {
public String getDriverName() {
if(driverName == null){
driverName = this.getDriverName()+"_"+this.getUrl();
return driverN
public void setDriverName(String driverName) {
this.driverName = driverN
public String getUrl() {
public void setUrl(String url) {
this.url =
public String getUserName() {
return userN
public void setUserName(String userName) {
this.userName = userN
public String getPassword() {
public void setPassword(String password) {
this.password =
public String getPoolName() {
return poolN
public void setPoolName(String poolName) {
this.poolName = poolN
public int getMinConnections() {
return minC
public void setMinConnections(int minConnections) {
this.minConnections = minC
public int getMaxConnections() {
return maxC
public void setMaxConnections(int maxConnections) {
this.maxConnections = maxC
public int getInitConnections() {
return initC
public void setInitConnections(int initConnections) {
this.initConnections = initC
public int getMaxActiveConnections() {
return maxActiveC
public void setMaxActiveConnections(int maxActiveConnections) {
this.maxActiveConnections = maxActiveC
public long getConnTimeOut() {
return connTimeO
public void setConnTimeOut(long connTimeOut) {
this.connTimeOut = connTimeO
public long getConnectionTimeOut() {
return connectionTimeO
public void setConnectionTimeOut(long connectionTimeOut) {
this.connectionTimeOut = connectionTimeO
public boolean isCurrentConnection() {
return isCurrentC
public void setCurrentConnection(boolean isCurrentConnection) {
this.isCurrentConnection = isCurrentC
public long getLazyCheck() {
return lazyC
public void setLazyCheck(long lazyCheck) {
this.lazyCheck = lazyC
public long getPeriodCheck() {
return periodC
public void setPeriodCheck(long periodCheck) {
this.periodCheck = periodC
public boolean isCheakPool() {
return isCheakP
public void setCheakPool(boolean isCheakPool) {
this.isCheakPool = isCheakP
import java.sql.C
import java.sql.SQLE
public interface IConnectionPool {
// 获得连接
public Connection
getConnection();
// 获得当前连接
public Connection getCurrentConnecton();
// 回收连接
public void releaseConn(Connection conn) throws SQLE
// 销毁清空
public void destroy();
// 连接池是活动状态
public boolean isActive();
// 定时器，检查连接池
public void cheackPool();
import java.sql.C
import java.sql.DriverM
import java.sql.SQLE
import java.util.L
import java.util.T
import java.util.TimerT
import java.util.V
public class ConnectionPool implements IConnectionPool {
// 连接池配置属性
private DBbean dbB
private boolean isActive = // 连接池活动状态
private int contActive = 0;// 记录创建的总的连接数
// 空闲连接
private List&Connection& freeConnection = new Vector&Connection&();
// 活动连接
private List&Connection& activeConnection = new Vector&Connection&();
// 将线程和连接绑定，保证事务能统一执行
private static ThreadLocal&Connection& threadLocal = new ThreadLocal&Connection&();
public ConnectionPool(DBbean dbBean) {
this.dbBean = dbB
cheackPool();
public void init() {
Class.forName(dbBean.getDriverName());
for (int i = 0; i & dbBean.getInitConnections(); i++) {
conn = newConnection();
// 初始化最小连接数
if (conn != null) {
freeConnection.add(conn);
contActive++;
isActive =
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
// 获得当前连接
public Connection getCurrentConnecton(){
// 默认线程里面取
Connection conn = threadLocal.get();
if(!isValid(conn)){
conn = getConnection();
// 获得连接
public synchronized Connection getConnection() {
Connection conn =
// 判断是否超过最大连接数限制
if(contActive & this.dbBean.getMaxActiveConnections()){
if (freeConnection.size() & 0) {
conn = freeConnection.get(0);
if (conn != null) {
threadLocal.set(conn);
freeConnection.remove(0);
conn = newConnection();
// 继续获得连接,直到从新获得连接
wait(this.dbBean.getConnTimeOut());
conn = getConnection();
if (isValid(conn)) {
activeConnection.add(conn);
contActive ++;
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
// 获得新连接
private synchronized Connection newConnection()
throws ClassNotFoundException, SQLException {
Connection conn =
if (dbBean != null) {
Class.forName(dbBean.getDriverName());
conn = DriverManager.getConnection(dbBean.getUrl(),
dbBean.getUserName(), dbBean.getPassword());
// 释放连接
public synchronized void releaseConn(Connection conn) throws SQLException {
if (isValid(conn)&& !(freeConnection.size() & dbBean.getMaxConnections())) {
freeConnection.add(conn);
activeConnection.remove(conn);
contActive --;
threadLocal.remove();
// 唤醒所有正待等待的线程，去抢连接
notifyAll();
// 判断连接是否可用
private boolean isValid(Connection conn) {
if (conn == null || conn.isClosed()) {
} catch (SQLException e) {
e.printStackTrace();
// 销毁连接池
public synchronized void destroy() {
for (Connection conn : freeConnection) {
if (isValid(conn)) {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
for (Connection conn : activeConnection) {
if (isValid(conn)) {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
isActive =
contActive = 0;
// 连接池状态
public boolean isActive() {
return isA
// 定时检查连接池情况
public void cheackPool() {
if(dbBean.isCheakPool()){
new Timer().schedule(new TimerTask() {
public void run() {
// 1.对线程里面的连接状态
// 2.连接池最小 最大连接数
// 3.其他状态进行检查，因为这里还需要写几个线程管理的类，暂时就不添加了
System.out.println("空线池连接数："+freeConnection.size());
System.out.println("活动连接数：："+activeConnection.size());
System.out.println("总的连接数："+contActive);
},dbBean.getLazyCheck(),dbBean.getPeriodCheck());
import java.sql.C
import java.sql.SQLE
import java.util.H
* 连接管理类
* @author Ran
public class ConnectionPoolManager {
// 连接池存放
public Hashtable&String,IConnectionPool& pools = new Hashtable&String, IConnectionPool&();
private ConnectionPoolManager(){
// 单例实现
public static ConnectionPoolManager getInstance(){
return Singtonle.
private static class Singtonle {
private static ConnectionPoolManager instance =
new ConnectionPoolManager();
// 初始化所有的连接池
public void init(){
for(int i =0;i&DBInitInfo.beans.size();i++){
DBbean bean = DBInitInfo.beans.get(i);
ConnectionPool pool = new ConnectionPool(bean);
if(pool != null){
pools.put(bean.getPoolName(), pool);
System.out.println("Info:Init connection successed -&" +bean.getPoolName());
// 获得连接,根据连接池名字 获得连接
public Connection
getConnection(String poolName){
Connection conn =
if(pools.size()&0 && pools.containsKey(poolName)){
conn = getPool(poolName).getConnection();
System.out.println("Error:Can't find this connecion pool -&"+poolName);
// 关闭，回收连接
public void close(String poolName,Connection conn){
IConnectionPool pool = getPool(poolName);
if(pool != null){
pool.releaseConn(conn);
} catch (SQLException e) {
System.out.println("连接池已经销毁");
e.printStackTrace();
// 清空连接池
public void destroy(String poolName){
IConnectionPool pool = getPool(poolName);
if(pool != null){
pool.destroy();
// 获得连接池
public IConnectionPool getPool(String poolName){
IConnectionPool pool =
if(pools.size() & 0){
pool = pools.get(poolName);
import java.util.ArrayL
import java.util.L
* 初始化，模拟加载所有的配置文件
* @author Ran
public class DBInitInfo {
static List&DBbean&
beans = new ArrayList&DBbean&();
// 这里数据 可以从xml 等配置文件进行获取
// 为了测试，这里我直接写死
DBbean beanOracle = new DBbean();
beanOracle.setDriverName("oracle.jdbc.driver.OracleDriver");
beanOracle.setUrl("jdbc:oracle:thin:@7MEXGLUY95W1Y56:1521:orcl");
beanOracle.setUserName("mmsoa");
beanOracle.setPassword("password1234");
beanOracle.setMinConnections(5);
beanOracle.setMaxConnections(100);
beanOracle.setPoolName("testPool");
beans.add(beanOracle);
import java.sql.C
* 模拟线程启动，去获得连接
* @author Ran
public class ThreadConnection implements Runnable{
private IConnectionP
public void run() {
pool = ConnectionPoolManager.getInstance().getPool("testPool");
public Connection getConnection(){
Connection conn =
if(pool != null && pool.isActive()){
conn = pool.getConnection();
public Connection getCurrentConnection(){
Connection conn =
if(pool != null && pool.isActive()){
conn = pool.getCurrentConnecton();
public class Client {
public static void main(String[] args) throws InterruptedException {
// 初始化连接池
Thread t = init();
t.start();
ThreadConnection a = new ThreadConnection();
ThreadConnection b = new ThreadConnection();
ThreadConnection c = new ThreadConnection();
Thread t1 = new Thread(a);
Thread t2 = new Thread(b);
Thread t3 = new Thread(c);
// 设置优先级，先让初始化执行，模拟 线程池 先启动
// 这里仅仅表面控制了，因为即使t 线程先启动，也不能保证pool 初始化完成，为了简单模拟，这里先这样写了
t1.setPriority(10);
t2.setPriority(10);
t3.setPriority(10);
t1.start();
t2.start();
t3.start();
System.out.println("线程A-& "+a.getConnection());
System.out.println("线程B-& "+b.getConnection());
System.out.println("线程C-& "+c.getConnection());
public static Thread init() {
Thread t = new Thread(new Runnable() {
public void run() {
IConnectionPool
pool = initPool();
while(pool == null || !pool.isActive()){
pool = initPool();
public static IConnectionPool initPool(){
return ConnectionPoolManager.getInstance().getPool("testPool");
1.连接池诞生原因是，如果每次都从数据库获得连接，时间比较长，因此我们提前做建立一些连接，放在连接池里面，每次都从里面取
2.上面仅仅写了连接池基本原理，关于多线程下连接池的管理没写，后面对多线程操作熟练了添加吧
浏览 76238
cywhoyi 写道cywhoyi 写道在之前的blog文中也已经略微提到过pool的实现http://cywhoyi.iteye.com/blog/1966606 & http://cywhoyi.iteye.com/admin/blogs/1954393，建议LZ多多的采用exectue framework，new Time()的方式在mutli thread下unsafe，而且效率低下。写错地址了http://cywhoyi.iteye.com/blog/1954393，boneCP framework代码比较易读，你不放从boneCP吸取些知识，分区 guava 模拟回放功能...谢谢哥们提醒，我这里仅仅模拟了简单的连接池功能，没有采用多线程的一些工具，那些工具我还不熟悉，后面会把源码实现都了解了之后再进行操作。这里也想自己写写才能看出问题。关于boneCP 我了解了一下源码的框架，对具体实现 也没进行具体分析，逻辑上没理解透，就暂时没像那样写了，怕写得四不像的。我的想法是 从一些基础开始写，主要了解一些流程，然后和现在开源的一些东西比较，看看他们的有点是什么，然后改进，总结优点，从而写一些更加适应的东西，也能让自己从一个简单的问题，慢慢扩展深入，理解整个演变过程嗯，多探讨
cywhoyi 写道在之前的blog文中也已经略微提到过pool的实现http://cywhoyi.iteye.com/blog/1966606 & http://cywhoyi.iteye.com/admin/blogs/1954393，建议LZ多多的采用exectue framework，new Time()的方式在mutli thread下unsafe，而且效率低下。写错地址了http://cywhoyi.iteye.com/blog/1954393，boneCP framework代码比较易读，你不放从boneCP吸取些知识，分区 guava 模拟回放功能...谢谢哥们提醒，我这里仅仅模拟了简单的连接池功能，没有采用多线程的一些工具，那些工具我还不熟悉，后面会把源码实现都了解了之后再进行操作。这里也想自己写写才能看出问题。关于boneCP 我了解了一下源码的框架，对具体实现 也没进行具体分析，逻辑上没理解透，就暂时没像那样写了，怕写得四不像的。我的想法是 从一些基础开始写，主要了解一些流程，然后和现在开源的一些东西比较，看看他们的有点是什么，然后改进，总结优点，从而写一些更加适应的东西，也能让自己从一个简单的问题，慢慢扩展深入，理解整个演变过程
在之前的blog文中也已经略微提到过pool的实现http://cywhoyi.iteye.com/blog/1966606 & http://cywhoyi.iteye.com/admin/blogs/1954393，建议LZ多多的采用exectue framework，new Time()的方式在mutli thread下unsafe，而且效率低下。写错地址了http://cywhoyi.iteye.com/blog/1954393，boneCP framework代码比较易读，你不放从boneCP吸取些知识，分区 guava 模拟回放功能...
greemranqq
浏览: 723157 次
来自: 重庆
16/11/18 16:21:17 ERROR SparkDe ...
什么情况下会有 p!=t ?
给个我实现的代码，需要自己写一个类继承之～
public ab ...
100%发生死锁！
if (isValid(conn))
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'java实现将远程数据ftp上传到本地，并存入到mysql数据库里
package com.lianlife.
import java.text.SimpleDateF
import java.util.D
public class Config {
public static final String ftpPath=&/PIftp/Yzps/ps001/ps&;
//public static final String ftpPath=&/PIftp/test01/ps&;
public static final String c1 = &17:30:00&;
public static final
String c2 = &17:29:00&;
public static final String ftpIP = &10.20.28.138&;
public static final int ftpPort = 21;
public static final String ftpuser = &ftpuser&;
public static final String ftpassword = &ftpuser&;
//public static String localDirPath=&H:\\yx1\\yq\\ps&;
public static String localDirPath=&I:\\影像2\\ps&;
public static String date = &&;
public static String date2 = &&;
public static final String url = &jdbc:://10.20.28.138:3306/mysql&;
public static final String driver = &com.mysql.jdbc.Driver&;
public static final String user = &root&;
public static final String password = &123&;
public static boolean isUploadTimePeriod()
SimpleDateFormat df = new SimpleDateFormat(&HH:mm:ss&);
String timenow = df.format(new Date());
if (timenow.compareTo(Config.c1) & 0
|| timenow.compareTo(Config.c2) & 0){
package com.lianlife.
import java.sql.C
import java.sql.DriverM
import java.sql.PreparedS
import java.sql.ResultS
public class DbUtil {
public static Connection getConnection()
Class.forName(Config.driver);//指定连接类型
} catch (Throwable e) {
throw new RuntimeException(e);
return DriverManager.getConnection(Config.url, Config.user, Config.password);//获取连接
} catch (Throwable e) {
e.printStackTrace();
return DriverManager.getConnection(Config.url, Config.user, Config.password);//获取连接
} catch (Throwable e2) {
e2.printStackTrace();
return DriverManager.getConnection(Config.url, Config.user, Config.password);//获取连接
} catch (Throwable e3) {
throw new RuntimeException(e3);
public static
void close(Connection c)
if(c!=null)
c.close();
} catch (Throwable e) {
e.printStackTrace();
public static
void close(PreparedStatement c)
if(c!=null)
c.close();
} catch (Throwable e) {
e.printStackTrace();
public static
void close(ResultSet c)
if(c!=null)
c.close();
} catch (Throwable e) {
e.printStackTrace();用java实现对MySql数据库中数据的读取、插入、修改和删除
1、实现eclipse同的连接
2、在eclipse中用java实现对数据库的控制
初学java和数据库，本文是参考这篇文章的思路的学习笔记，代码实现了将4个控制函数（读取、插入、修改和删除）分别写成4个静态方法调用。
1. 关于java和MySQL的连接&&&&下载并添加JDBC.
2. 在数据库中导入数据
3. 编写并执行代码
package sql_
import java.sql.*;
//加入sql中本程序所需要的类，以实现链接功能
import java.text.DateF
//插入数据中有日期时需要用到
import java.text.SimpleDateF
import java.util.D
public class sqlconn
public static void fetchdata(Connection conn)
//读取数据函数
Statement statement = conn.createStatement();
//用statement 来执行sql语句
String sql = &select * from emp&;
//这是sql语句中的查询某个表，注意后面的emp是表名！！！
ResultSet rs = statement.executeQuery(sql);
//用于返回结果
System.out.println(&---------------------------------------------------&);
System.out.println(&表中的数据有:&);
System.out.println(&英语姓名& + &\t\t& + &工作职业& + &\t\t& + &入职日期&);
System.out.println(&---------------------------------------------------&);
String job =
String id =
String date =
while(rs.next()){
job = rs.getString(&job&);
id = rs.getString(&ename&);
date = rs.getString(&hiredate&);
System.out.println(id + &\t\t& + job + &\t& + date);
rs.close();
}catch(SQLException e){
e.printStackTrace();
}catch (Exception e) {
e.printStackTrace();
System.out.println(&数据库数据读取成功！&+&\n&);
public static void insertdata(Connection conn)
//插入数据函数
PreparedStatement psql = conn.prepareStatement(&insert into emp (empno,ename,job,hiredate,sal)&+&values(?,?,?,?,?)&);
//用preparedStatement预处理来执行sql语句
psql.setInt(1, 5555);
//给其五个参量分别&赋值&
psql.setString(2, &Tony&);
psql.setString(3, &doctor&);
DateFormat mydateFormat = new SimpleDateFormat(&yyyy-MM-dd&);
Date mydate = mydateFormat.parse(&&);
psql.setDate(4, new java.sql.Date(mydate.getTime()));
psql.setFloat(5,(float)7999.9);
psql.executeUpdate();
//参数准备后执行语句
psql.close();
}catch(SQLException e){
e.printStackTrace();
}catch (Exception e) {
e.printStackTrace();
System.out.println(&数据库数据插入成功！&+&\n&);
public static void updatedata(Connection conn)
//修改数据函数
psql = conn.prepareStatement(&update emp set sal = ? where ename = ?&);
psql.setFloat(1, (float)5000.0);
psql.setString(2, &Mark&);
psql.executeUpdate();
psql.close();
}catch(SQLException e){
e.printStackTrace();
}catch (Exception e) {
e.printStackTrace();
System.out.println(&数据库数据修改成功！&+&\n&);
public static void deletedata(Connection conn)
//删除数据函数
//还是用预处理
psql = conn.prepareStatement(&delete from emp where sal & ?&);
psql.setFloat(1, 3000.00F);
//删除sal值小于3000的所有数据
psql.executeUpdate();
psql.close();
}catch(SQLException e){
e.printStackTrace();
}catch (Exception e) {
e.printStackTrace();
System.out.println(&数据库数据删除成功！&+&\n&);
public static void main(String[] args)
//与特定数据库的连接（会话）的变量
String driver = &com..jdbc.Driver&;
//驱动程序名？？？
String url = &jdbc:mysql://localhost:3306/job_test&;
//指向要访问的数据库！注意后面跟的是数据库名称
String user = &root&;
//navicat for sql配置的用户名
String password = &123456&;
//navicat for sql配置的密码
Class.forName(driver);
//用class加载动态链接库&&驱动程序？？？
conn = DriverManager.getConnection(url,user,password);
//利用信息链接数据库
if(!conn.isClosed())
System.out.println(&Succeeded connecting to the Database!&);
fetchdata(conn);
//读取数据
insertdata(conn);
//插入数据
updatedata(conn);
//修改数据
deletedata(conn);
//删除数据
conn.close();
}catch(ClassNotFoundException e){
//catch不同的错误信息，并报错
System.out.println(&Sorry,can`t find the Driver!&);
e.printStackTrace();
}catch(SQLException e){
e.printStackTrace();
System.out.println(&数据库各项操作顺利进行！&);
依次进行4项操作后：没有更多推荐了，
不良信息举报
举报内容：
Java实现Oracle到MySQL的表迁移
举报原因：
原文地址：
原因补充：
最多只允许输入30个字
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！Java中如何实现将数据库中的数据写入JTable中？我用的是Oracle数据库_百度知道
Java中如何实现将数据库中的数据写入JTable中？我用的是Oracle数据库
我有更好的答案
用的是mySQL，不过感觉差不多...只要你先查询数据表，设置DefaultTableModel型的一个变量，在把查询出来的结果插入到model变量中，再设置JTabel的model就行..
采纳率：50%
查出来一条一条的加到表的model里面去就行了。。
为您推荐：
其他类似问题
oracle数据库的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。}