如何在多个窗口中使用一个连接数据库的类

Question

你说的是web编程方面??
那就用JavaBean

Answer 1

我是在作c/s开发的
 tijichen(chenzhi）能详细点吗，最好有个例子
我马上给分

Answer 2

我也做过，但是没有做成静态的，每次用到时就new，用完就closeimport java.sql.*;
import java.io.*;public class dbConn
{
Connection con=null;
PreparedStatement ps=null;
ResultSet rs=null;
public Statement sta;
/*=======================================================================================================
    
                                数据库驱动加载=======================================================================================================*/
public void db_load() //数据库驱动加载
{
try  //载入数据库驱动类库
{
    Class.forName ("oracle.jdbc.driver.OracleDriver"); //
}
catch (ClassNotFoundException ce)
{
System.out.println("没有相应的数据库驱动："+ce.getMessage());
}
}
/*=======================================================================================================
    
                                连接数据库=======================================================================================================*/
public Connection db_con() //
{
try  //连接数据库 {
con=DriverManager.getConnection("jdbc:oracle:thin:@10.68.3.14:1521:bill","user","pass");//通过
con.setAutoCommit(true); //自动提交
}
catch (SQLException e)
{
System.out.println("数据库连接出错："+e.getMessage());
}
return con;
}
/*=======================================================================================================
    
                                数据库事务提交=======================================================================================================*/    public void commit() throws java.sql.SQLException
    {
    con.commit();
    }};

Answer 3

你可以做成一个类呀，在类中连接数据库。然后在每个需要的页面上import这个类进行实例化不就可以。

Answer 4

把连接Connection声明为实例变量。 
public class conn()
{private Connection conn=null;public Connection getConnect()
{
 if(conn==null)
 {
  //从数据库中新建立一个连接
 }
 else
 {
  return this.conn;
 }
 
}
}

Answer 5

做到javabean 中吧，静态。

Answer 6

我看你要的是连接池，干脆贴给你好了
---------------------------------------------------
package conn;
/*此类用于管理多个连接池对象，它支持对一个或多个由属性文件定义的数据库连接池的访问,客户程序可以调用getInstance()方法访问本类的唯一实例。它提供以下功能：
1.装载和注册JDBC驱动程序
2.根据在属性文件中定义的属性创建连接池对象
3.实现连接池名字与其实例之间的映射
4.跟踪客户程序对连接池的引用,保证在最后一个客户程序结束时安全地关闭所有连接池
*/
import java.io.*;
import java.sql.*;
import java.util.*;
//import com.supersoftintl.intranet.common.DBConnectionPool;//import java.util.Date;/**
* 管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接
* 池的访问.客户程序可以调用getInstance()方法访问本类的唯一实例.
*/
public class DBConnectionManager
{
static private DBConnectionManager instance;/*唯一实例*/
static private int clients; /*该计数代表引用DBConnectionManager唯一实例的客户程序总数，
                                      它将被用于控制连接池的关闭操作 */
  //Added by leo on 2001-5-23
static private String DEFAULTCONNECTIONPOOL = "homepage";private Vector drivers = new Vector();
private PrintWriter logPrint;
private Hashtable pools = new Hashtable();/**
返回唯一实例。如果是第一次调用此方法，则创建实例
*/
static synchronized public DBConnectionManager getInstance()
{
if(instance == null)
{
instance = new DBConnectionManager();
}
clients++;
    return instance;
}/**
建构函数私有以防止其它对象创建本类实例
*/
public DBConnectionManager()
{
init();
}/** Added by leo on 2001-5-23
使用默认的连接池名,创建并返回新连接
*
* @return Connection 可用连接或null
*/
public Connection getConnection()
{
return getConnection(DEFAULTCONNECTIONPOOL);
}
/**
获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数
限制,则创建并返回新连接
*
* @param name 在属性文件中定义的连接池名字
* @return Connection 可用连接或null
*/
public Connection getConnection(String name)
{
DBConnectionPool pool = (DBConnectionPool)pools.get(name);
if(pool != null)
{
return pool.getConnection();
}
return null;
}/**
获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制,
则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.
*
* @param name 连接池名字
* @param time 以毫秒计的等待时间
* @return Connection 可用连接或null
*/
public Connection getConnection(String name, long time)
{
DBConnectionPool pool = (DBConnectionPool)pools.get(name);
if(pool != null)
{
return pool.getConnection(time);
}
return null;
}
/** Added by leo on 2001-5-23
  将连接对象返回给默认的连接池
  *
  * @param con 连接对象
  */
public void freeConnection(Connection con)
{
String name = DEFAULTCONNECTIONPOOL;
freeConnection(name,con);
}  /**
  将连接对象返回给由名字指定的连接池
  *
  * @param name 在属性文件中定义的连接池名字
  * @param con 连接对象
  */
public void freeConnection(String name, Connection con)
{
DBConnectionPool pool = (DBConnectionPool)pools.get(name);
if(pool != null)
{
pool.freeConnection(con);
}
}/**
关闭所有连接,撤销驱动程序的注册
*/
public synchronized void release()
{       // 等待直到最后一个客户程序调用
if(--clients != 0)
{
return;
}
Enumeration allPools = pools.elements();
while(allPools.hasMoreElements())
{
DBConnectionPool pool = (DBConnectionPool)allPools.nextElement();
pool.release();
}
Enumeration allDrivers = drivers.elements();
while(allDrivers.hasMoreElements())
{
Driver driver = (Driver)allDrivers.nextElement();
try
{
DriverManager.deregisterDriver(driver);
log("撤消JDBC驱动程序" + driver.getClass().getName() + "的注册");
}
catch(SQLException e)
{
log(e, "无法撤消下列JDBC驱动程序的注册" + driver.getClass().getName());
}
}
}
 /**
 根据指定属性创建连接池实例.
 *
 * @param props 连接池属性
 */
 private void createPools(Properties props)
 {
 Enumeration propNames = props.propertyNames();
 while(propNames.hasMoreElements())
 {
 String name = (String)propNames.nextElement();
 if(name.endsWith(".url"))
 {
 String poolName = name.substring(0, name.lastIndexOf("."));
 String url = props.getProperty(poolName + ".url");
 if(url == null)
 {
 log("没有为连接池" + poolName + "指定URL");
 continue;
 }
 String user = props.getProperty(poolName + ".user");
 String password = props.getProperty(poolName + ".password");
 String maxconn = props.getProperty(poolName + ".maxconn", "0"); int max;
 try
 {
 max = Integer.valueOf(maxconn).intValue();
 }
 catch(NumberFormatException e)
 {
 log("错误的最大连接数限制：" + maxconn + ".连接池：" + poolName);
 log("自动改变设置为0--即无限制");
 max = 0;
 }
 DBConnectionPool pool = new DBConnectionPool(poolName, url, user, password, max);
 pools.put(poolName, pool);
 log("成功创建连接池" + poolName);
 }
 }
 } /**
 读取属性完成初始化
 */
 private void init()
 { InputStream is = getClass().getResourceAsStream("/db.properties");
 Properties dbProps = new Properties();
 try
 {
 dbProps.load(is);
 }
 catch(Exception e)
 {
 System.err.println("不能读取属性文件." + "请确保db.properties在CLASSPATH指定的路径中");
 return;
 } String logFile = dbProps.getProperty("Managerlogfile", "DBConnectionManager.log");
 try
 {
 logPrint = new PrintWriter(new FileWriter(logFile, true), true);
 }
 catch(IOException e)
 {
 System.err.println("无法打开日志文件：" + logFile);
 logPrint = new PrintWriter(System.err);
 }
 loadDrivers(dbProps);
 createPools(dbProps);
 } /**
 装载和注册所有JDBC驱动程序
 *
 * @param props 属性
 */
 private void loadDrivers(Properties props)
 {
 String driverClasses = props.getProperty("drivers");
 StringTokenizer st = new StringTokenizer(driverClasses);
 while(st.hasMoreElements())
 {
 String driverClassName = st.nextToken().trim();
 try
 {
 Driver driver = (Driver)Class.forName(driverClassName).newInstance();
 DriverManager.registerDriver(driver);
 drivers.addElement(driver);
 log("成功JDBC注册驱动程序" + driverClassName);
 }
 catch(Exception e)
 {
 log("无法注册JDBC驱动程序；" + driverClassName + "，错误：" + e);
 }
 }
 } /**
 将文本信息写入日志文件
 缺省为packaged
 */
 void log(String msg)
 {
 logPrint.println(new java.util.Date() + ": " + msg);
 } /**
 将文本信息与异常写入日志文件
 */
 void log(Throwable e, String msg)
 {
 logPrint.println(new java.util.Date() + ": " + msg);
 e.printStackTrace(logPrint);
 } }

Answer 7

package conn;
/**
此内部类定义了一个连接池。它能够根据要求创建新连接，直到预定的最大连接数为止。在返回连接给客户程序之前，它能够
验证连接的有效性。此类提供以下功能：
1.从连接池获取(或创建)可用连接
2.把连接返回给连接池
3.在系统关闭时释放所有资源,关闭所有连接
4.处理无效连接(原来登记为可用的连接,由于某种原因不再可用,如超时,通讯问题)
5.限制连接池中的连接总数不超过某个预定值
*/
import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;class DBConnectionPool
{
private int checkedOut;
private PrintWriter logPrint;
private Vector freeConnections = new Vector();
private int maxConn;
private String name;
private String password;
private String URL;
private String user;/**
创建新的连接池
*@param name  连接池名字
*@param URL  数据库的JDBC URL
*@param user  数据库帐号,或null
*@param password  密码,或null
*@param maxConn  此连接池允许建立的最大连接数
*/
public DBConnectionPool(String name, String URL, String user, String password, int maxConn)
{
this.name = name;
this.URL = URL;
this.user = user;
this.password = password;
this.maxConn = maxConn;InputStream is = getClass().getResourceAsStream("/db.properties");
Properties dbProps = new Properties();
try
{
dbProps.load(is);
}
catch(Exception e)
{
System.err.println("不能读取属性文件." + "请确保db.properties在CLASSPATH指定的路径中");
return;
}
String logFile = dbProps.getProperty("Poollogfile", "DBConnectionPool.log");
try
{
logPrint = new PrintWriter(new FileWriter(logFile, true), true);
}
catch(IOException e)
{
System.err.println("无法打开日志文件：" + logFile);
logPrint = new PrintWriter(System.err);
}
}/**
将不再使用的连接返回给连接池
*@param con  客户程序释放的连接
*/
public synchronized void freeConnection(Connection con)
{
freeConnections.addElement(con);
checkedOut--;
notifyAll();
}/**
从连接池获得一个可用连接，如没有空闲的连接且当前连接数小于最大连接数，则创建新连接，
        如原来登记为可用的连接不再有效，则从向量删除之，然后递归调用自己以尝试新的可用连接
*/
public synchronized Connection getConnection()
{
Connection con = null;
if(freeConnections.size() > 0)
{// 获取向量中第一个可用连接
con = (Connection)freeConnections.firstElement();
freeConnections.removeElementAt(0);
try
{
if(con.isClosed())
{
log("从连接池" + name + "删除一个无效连接");
con = getConnection();
}
}
catch(SQLException e)
{
log("从连接池" + name + "删除一个无效连接");
con = getConnection();
}
}
else if(maxConn == 0 || checkedOut < maxConn)
{
con = newConnection();
}
if(con != null)
{
checkedOut++;
}
return con;
}/**
从连接池获取可用连接，可以指定客户程序能够等待的最长时间
*@param timeout 以毫秒计的等待时间限制
*/
public synchronized Connection getConnection(long timeout)
{
long startTime = new Date().getTime();
Connection con;
while((con = getConnection()) == null)
{
try
{
wait(timeout);
}
catch(InterruptedException e){}
if((new Date().getTime() - startTime) >= timeout)
{
return null;
}
}
return con;
}/**
关闭所有连接
*/
public synchronized void release()
{
Enumeration allConnections = freeConnections.elements();
while(allConnections.hasMoreElements())
{
Connection con = (Connection)allConnections.nextElement();
try
{
con.close();
log("关闭连接池" + name + "中的一个连接");
}
catch(SQLException e)
{
log(e, "无法关闭连接池" + name + "中的连接");
}
}
freeConnections.removeAllElements();
}/**
创建新的连接
*/
private Connection newConnection()
{
Connection con = null;
try
{
if(user == null)
{
con = DriverManager.getConnection(URL);
}
else
{
con = DriverManager.getConnection(URL, user, password);
}
log("连接池" + name + "创建一个新的连接");
}
catch(SQLException e)
{
log(e, "无法创建下列URL的连接" + URL);
return null;
}
return con;
}
/**
将文本信息写入日志文件
缺省为packaged
*/
void log(String msg)
{
logPrint.println(new Date() + ": " + msg);
}/**
将文本信息与异常写入日志文件
*/
void log(Throwable e, String msg)
{
logPrint.println(new Date() + ": " + msg);
e.printStackTrace(logPrint);
}
}