關于數據庫連接
2024-07-21 02:06:39
供稿：網友
對于數據庫的連接，有一些共性的東西；積累了幾個方法，可以作為一個可復用的模塊。
/********************************************************************/
類jbfcmsconnect ：
import java.io.*;
import java.util.*;
import java.sql.*;
import java.text.*;
import java.lang.*;
/**
* @author *
* to change this generated comment edit the template variable "typecomment":
* window>preferences>java>templates.
* to enable and disable the creation of type comments go to
* window>preferences>java>code generation.
*/
public class jbfcmsconnect {
private string drive = "";
private string dburl = "";
private string prop_server_name = "";
private string prop_db_name = "";
private string dbusername = "";
private string dbuserpassword = "";
private string prop_db_provider;
/**
* onstructor for dbconnect
*/
public jbfcmsconnect() {
init();
}
/**
* method init.
*/
private void init() {
system.out.println("enter init");
properties defaultsettings = new properties();
defaultsettings.put("db_name", "jbmms");
defaultsettings.put("db_provider","db2");
defaultsettings.put("username", "root");
defaultsettings.put("passwerd", " ");
defaultsettings.put("driver_type", "net");
system.out.println("put default settings");
string prop_driver_type = defaultsettings.getproperty("driver_type");
prop_db_name = defaultsettings.getproperty("db_name");
prop_db_provider=defaultsettings.getproperty("db_provider");
dbusername = defaultsettings.getproperty("username");
dbuserpassword = defaultsettings.getproperty("password");
system.out.println("set default settings");
properties settings = new properties();
try {
system.out.println("start search properties file");
fileinputstream sf = new fileinputstream("c://jbfcmsconnect.prop");
settings.load(sf);
prop_driver_type = settings.getproperty("driver_type");
prop_db_name = settings.getproperty("db_name");
prop_db_provider=settings.getproperty("db_provider");
dbusername = settings.getproperty("username");
dbuserpassword = settings.getproperty("password");
prop_server_name = settings.getproperty("server_name");
sf.close();
system.out.println("properties file exist");
} catch (filenotfoundexception e) {
system.out.println("properties file was not found!");
} catch (ioexception e) {
system.out.println("ioexception is found!");
}
/////////////////
if (prop_db_provider.equalsignorecase("db2"))
{ if(prop_driver_type.equalsignorecase("net"))
{ //system.out.println("be in-----");
drive="com.ibm.db2.jdbc.net.db2driver";
string prop_server_name=settings.getproperty("server_name");
dburl="jdbc:db2://" + prop_server_name + "/" + prop_db_name;
}else{
drive="com.ibm.db2.jdbc.app.db2driver";
dburl="jdbc:db2:" + prop_db_name;
}
system.out.println("db2 connection ==> /n drivername="+ drive + "/n url="+dburl+"/n");}
//mysql數據庫連接
else if (prop_db_provider.equalsignorecase("mysql"))
{ if(prop_driver_type.equalsignorecase("net"))
{
drive="com.mysql.jdbc.driver";
string prop_server_name=settings.getproperty("server_name");
dburl="jdbc:mysql://" + prop_server_name + "/" + prop_db_name;
}else{
drive="com.mysql.jdbc.driver";
dburl="jdbc:mysql:" + prop_db_name;
}
system.out.println("mysql connection ==> /n drivername="+ drive + "/n url="+dburl+"/n");}
//sqlserver數據庫連接
else if(prop_db_provider.equalsignorecase("sqlserver"))
{if(prop_driver_type.equalsignorecase("net"))
{
drive="com.microsoft.jdbc.sqlserver.sqlserverdriver";
string prop_server_name=settings.getproperty("server_name");
dburl="jdbc:microsoft:sqlserver://" + prop_server_name + "/" + prop_db_name;
}else{
drive="com.microsoft.jdbc.sqlserver.sqlserverdriver";
dburl="jdbc:microsoft:sqlserver://" + prop_db_name;
}
system.out.println("sqlserver connection ==> /n drivername="+ drive + "/n url="+dburl+"/n");}
}
connection conn = null;
private void connectpool() {
try {
class.forname(drive).newinstance();
conn =
drivermanager.getconnection(dburl, dbusername, dbuserpassword);
} catch (classnotfoundexception ec) {
system.out.println("數據庫驅動裝載存在問題");
} catch (illegalaccessexception ei) {
system.out.println("數據庫訪問異常");
} catch (instantiationexception ei) {
system.out.println(ei.getmessage());
} catch (sqlexception e) {
system.out.println(
"/n***********************數據庫連接異常**********************/n");
while (e != null) {
system.out.println("sqlstate:" + e.getsqlstate());
system.out.println("message:" + e.getmessage());
system.out.println("vendor:" + e.geterrorcode());
e = e.getnextexception();
}
}
}
public connection getconnect() {
connectpool();
return conn;
}
}
//此類負責數據庫的連接部分
類：jbsqlexecute
import java.io.*;
import java.util.*;
import java.util.date;
import java.sql.*;
import java.text.*;
/**
* @author
*
* to change this generated comment edit the template variable "typecomment":
* window>preferences>java>templates.
* to enable and disable the creation of type comments go to
* window>preferences>java>code generation.
*/
public class jbsqlexecute {
private static connection con = null;
private preparedstatement pstmt = null;
/**
* constructor for jbsqlexecute.
*/
public jbsqlexecute() {
jbfcmsconnect connect = new jbfcmsconnect();
con = connect.getconnect();
}
/**
* method sqlinsert.
* @param strinsert
* @
*/
public void sqlinsert(string strinsert) {
try {
pstmt = con.preparestatement(strinsert);
pstmt.execute();
} catch (sqlexception sqle) {
system.out.println("jbmms數據庫插入異常:" + sqle.getmessage());
}
}
/**
* method strupdata.
* @param strupdata
* @
*/
public void sqlupdata(string strupdata) {
try {
pstmt = con.preparestatement(strupdata);
pstmt.execute();
} catch (sqlexception sqle) {
system.out.println("jbmms數據庫更新異常:" + sqle.getmessage());
}
}
/**
* method executequery.
* @param strquery
* @return resultset
*/
public resultset executequery(string strquery) {
resultset rset = null;
try {
system.out.println(strquery);
pstmt = con.preparestatement(strquery);
rset=pstmt.executequery();
system.out.println("over");
} catch (sqlexception sqle) {
system.out.println("jbmms數據庫查詢異常:" + sqle.getmessage());
}
system.out.println("rset");
return rset;
}
/**
* method executedelete.
* @param strdelete
*/
public void executedelete(string strdelete) {
try {
pstmt = con.preparestatement(strdelete);
pstmt.execute();
} catch (sqlexception sqle) {
system.out.println("jbmms數據庫刪除異常:" + sqle.getmessage());
}
}
}
//數據庫操作的執行，在使用時直接調用此類中的方法即可。
/******************************************************************/
一個關于數據庫連接池的實現---借鑒于網友
源代碼
//connectionpool.java
package com.abner.dbconnector;
import java.sql.*;
import java.util.*;
/**
* connectionpool 類創建了一個對特定數據庫指定大小的連接池。連接池對象
* 允許客戶端指定 jdbc 驅動程序，數據庫，使用數據庫的用戶名和密碼。而且，
* 客戶端能指定連接池的在初始創建是產生數據庫連接的數量，和指定當連接
* 不夠時每次自動增加連接的數量及連接池最多的數據庫連接的數量。
*
* 對外提供的方法有： connectionpool ：構造函數
* getinitialconnections: 返回連接池初始化大小
* setinitialconnections: 設置連接池初始化大小
* getincrementalconnections: 返回連接池自動增加的增量
* setincrementalconnections: 設置連接池自動增加的大小
* getmaxconnections ：獲得連接池的最大可允許的連接數
* setmaxconnections ：設置連接池的最大可允許的連接數
* gettesttable ：獲得測試表的名字
* settesttable ：設置測試表的名字
* createpool: 創建連接池 , 線程己同步
* getconnection: 從連接池中獲得一個數據庫連接
* returnconnection: 返回一個連接到連接池中
* refreshconnections: 刷新連接池
* closeconnectionpool: 關閉連接池
*
*/
public class connectionpool {
private string jdbcdriver = ""; // 數據庫驅動
private string dburl = ""; // 數據 url
private string dbusername = ""; // 數據庫用戶名
private string dbpassword = ""; // 數據庫用戶密碼
private string testtable = ""; // 測試連接是否可用的測試表名，默認沒有測試表
private int initialconnections = 10; // 連接池的初始大小
private int incrementalconnections = 5;// 連接池自動增加的大小
private int maxconnections = 50; // 連接池最大的大小
private vector connections = null; // 存放連接池中數據庫連接的向量 , 初始時為 null
// 它中存放的對象為 pooledconnection 型
/**
* 構造函數
*
* @param jdbcdriver string jdbc 驅動類串
* @param dburl string 數據庫 url
* @param dbusername string 連接數據庫用戶名
* @param dbpassword string 連接數據庫用戶的密碼
*
*/
public connectionpool(string jdbcdriver,string dburl,string dbusername,string dbpassword) {
this.jdbcdriver = jdbcdriver;
this.dburl = dburl;
this.dbusername = dbusername;
this.dbpassword = dbpassword;
}
/**
* 返回連接池的初始大小
*
* @return 初始連接池中可獲得的連接數量
*/
public int getinitialconnections() {
return this.initialconnections;
}
/**
* 設置連接池的初始大小
*
* @param 用于設置初始連接池中連接的數量
*/
public void setinitialconnections(int initialconnections) {
this.initialconnections = initialconnections;
}
/**
* 返回連接池自動增加的大小 、
*
* @return 連接池自動增加的大小
*/
public int getincrementalconnections() {
return this.incrementalconnections;
}
/**
* 設置連接池自動增加的大小
* @param 連接池自動增加的大小
*/
public void setincrementalconnections(int incrementalconnections) {
this.incrementalconnections = incrementalconnections;
}
/**
* 返回連接池中最大的可用連接數量
* @return 連接池中最大的可用連接數量
*/
public int getmaxconnections() {
return this.maxconnections;
}
/**
* 設置連接池中最大可用的連接數量
*
* @param 設置連接池中最大可用的連接數量值
*/
public void setmaxconnections(int maxconnections) {
this.maxconnections = maxconnections;
}
/**
* 獲取測試數據庫表的名字
*
* @return 測試數據庫表的名字
*/
public string gettesttable() {
return this.testtable;
}
/**
* 設置測試表的名字
* @param testtable string 測試表的名字
*/
public void settesttable(string testtable) {
this.testtable = testtable;
}
/**
*
* 創建一個數據庫連接池，連接池中的可用連接的數量采用類成員
* initialconnections 中設置的值
*/
public synchronized void createpool() throws exception {
// 確保連接池沒有創建
// 如果連接池己經創建了，保存連接的向量 connections 不會為空
if (connections != null) {
return; // 如果己經創建，則返回
}
// 實例化 jdbc driver 中指定的驅動類實例
driver driver = (driver) (class.forname(this.jdbcdriver).newinstance());
drivermanager.registerdriver(driver); // 注冊 jdbc 驅動程序
// 創建保存連接的向量 , 初始時有 0 個元素
connections = new vector();
// 根據 initialconnections 中設置的值，創建連接。
createconnections(this.initialconnections);
system.out.println(" 數據庫連接池創建成功！ ");
}
/**
* 創建由 numconnections 指定數目的數據庫連接 , 并把這些連接
* 放入 connections 向量中
*
* @param numconnections 要創建的數據庫連接的數目
*/
private void createconnections(int numconnections) throws sqlexception {
// 循環創建指定數目的數據庫連接
for (int x = 0; x < numconnections; x++) {
// 是否連接池中的數據庫連接的數量己經達到最大？最大值由類成員 maxconnections
// 指出，如果 maxconnections 為 0 或負數，表示連接數量沒有限制。
// 如果連接數己經達到最大，即退出。
if (this.maxconnections > 0 && this.connections.size() >= this.maxconnections) {
break;
}
//add a new pooledconnection object to connections vector
// 增加一個連接到連接池中（向量 connections 中）
try{
connections.addelement(new pooledconnection(newconnection()));
}catch(sqlexception e){
system.out.println(" 創建數據庫連接失敗！ "+e.getmessage());
throw new sqlexception();
}
system.out.println(" 數據庫連接己創建 ......");
}
}
/**
* 創建一個新的數據庫連接并返回它
*
* @return 返回一個新創建的數據庫連接
*/
private connection newconnection() throws sqlexception {
// 創建一個數據庫連接
connection conn = drivermanager.getconnection(dburl, dbusername, dbpassword);
// 如果這是第一次創建數據庫連接，即檢查數據庫，獲得此數據庫允許支持的
// 最大客戶連接數目
//connections.size()==0 表示目前沒有連接己被創建
if (connections.size() == 0) {
databasemetadata metadata = conn.getmetadata();
int drivermaxconnections = metadata.getmaxconnections();
// 數據庫返回的 drivermaxconnections 若為 0 ，表示此數據庫沒有最大
// 連接限制，或數據庫的最大連接限制不知道
//drivermaxconnections 為返回的一個整數，表示此數據庫允許客戶連接的數目
// 如果連接池中設置的最大連接數量大于數據庫允許的連接數目 , 則置連接池的最大
// 連接數目為數據庫允許的最大數目
if (drivermaxconnections > 0 && this.maxconnections > drivermaxconnections) {
this.maxconnections = drivermaxconnections;
}
}
return conn; // 返回創建的新的數據庫連接
}
/**
* 通過調用 getfreeconnection() 函數返回一個可用的數據庫連接 ,
* 如果當前沒有可用的數據庫連接，并且更多的數據庫連接不能創
* 建（如連接池大小的限制），此函數等待一會再嘗試獲取。
*
* @return 返回一個可用的數據庫連接對象
*/
public synchronized connection getconnection() throws sqlexception {
// 確保連接池己被創建
if (connections == null) {
return null; // 連接池還沒創建，則返回 null
}
connection conn = getfreeconnection(); // 獲得一個可用的數據庫連接
// 如果目前沒有可以使用的連接，即所有的連接都在使用中
while (conn == null){
// 等一會再試
wait(250);
conn = getfreeconnection(); // 重新再試，直到獲得可用的連接，如果
//getfreeconnection() 返回的為 null
// 則表明創建一批連接后也不可獲得可用連接
}
return conn;// 返回獲得的可用的連接
}
/**
* 本函數從連接池向量 connections 中返回一個可用的的數據庫連接，如果
* 當前沒有可用的數據庫連接，本函數則根據 incrementalconnections 設置
* 的值創建幾個數據庫連接，并放入連接池中。
* 如果創建后，所有的連接仍都在使用中，則返回 null
* @return 返回一個可用的數據庫連接
*/
private connection getfreeconnection() throws sqlexception {
// 從連接池中獲得一個可用的數據庫連接
connection conn = findfreeconnection();
if (conn == null) {
// 如果目前連接池中沒有可用的連接
// 創建一些連接
createconnections(incrementalconnections);
// 重新從池中查找是否有可用連接
conn = findfreeconnection();
if (conn == null) {
// 如果創建連接后仍獲得不到可用的連接，則返回 null
return null;
}
}
return conn;
}
/**
* 查找連接池中所有的連接，查找一個可用的數據庫連接，
* 如果沒有可用的連接，返回 null
*
* @return 返回一個可用的數據庫連接
*/
private connection findfreeconnection() throws sqlexception {
connection conn = null;
pooledconnection pconn = null;
// 獲得連接池向量中所有的對象
enumeration enum = connections.elements();
// 遍歷所有的對象，看是否有可用的連接
while (enum.hasmoreelements()) {
pconn = (pooledconnection) enum.nextelement();
if (!pconn.isbusy()) {
// 如果此對象不忙，則獲得它的數據庫連接并把它設為忙
conn = pconn.getconnection();
pconn.setbusy(true);
// 測試此連接是否可用
if (!testconnection(conn)) {
// 如果此連接不可再用了，則創建一個新的連接，
// 并替換此不可用的連接對象，如果創建失敗，返回 null
try{
conn = newconnection();
}catch(sqlexception e){
system.out.println(" 創建數據庫連接失敗！ "+e.getmessage());
return null;
}
pconn.setconnection(conn);
}
break; // 己經找到一個可用的連接，退出
}
}
return conn;// 返回找到到的可用連接
}
/**
* 測試一個連接是否可用，如果不可用，關掉它并返回 false
* 否則可用返回 true
*
* @param conn 需要測試的數據庫連接
* @return 返回 true 表示此連接可用， false 表示不可用
*/
private boolean testconnection(connection conn) {
try {
// 判斷測試表是否存在
if (testtable.equals("")) {
// 如果測試表為空，試著使用此連接的 setautocommit() 方法
// 來判斷連接否可用（此方法只在部分數據庫可用，如果不可用 ,
// 拋出異常）。注意：使用測試表的方法更可靠
conn.setautocommit(true);
} else {// 有測試表的時候使用測試表測試
//check if this connection is valid
statement stmt = conn.createstatement();
stmt.execute("select count(*) from " + testtable);
}
} catch (sqlexception e) {
// 上面拋出異常，此連接己不可用，關閉它，并返回 false;
closeconnection(conn);
return false;
}
// 連接可用，返回 true
return true;
}
/**
* 此函數返回一個數據庫連接到連接池中，并把此連接置為空閑。
* 所有使用連接池獲得的數據庫連接均應在不使用此連接時返回它。
*
* @param 需返回到連接池中的連接對象
*/
public void returnconnection(connection conn) {
// 確保連接池存在，如果連接沒有創建（不存在），直接返回
if (connections == null) {
system.out.println(" 連接池不存在，無法返回此連接到連接池中 !");
return;
}
pooledconnection pconn = null;
enumeration enum = connections.elements();
// 遍歷連接池中的所有連接，找到這個要返回的連接對象
while (enum.hasmoreelements()) {
pconn = (pooledconnection) enum.nextelement();
// 先找到連接池中的要返回的連接對象
if (conn == pconn.getconnection()) {
// 找到了 , 設置此連接為空閑狀態
pconn.setbusy(false);
break;
}
}
}
/**
* 刷新連接池中所有的連接對象
*
*/
public synchronized void refreshconnections() throws sqlexception {
// 確保連接池己創新存在
if (connections == null) {
system.out.println(" 連接池不存在，無法刷新 !");
return;
}
pooledconnection pconn = null;
enumeration enum = connections.elements();
while (enum.hasmoreelements()) {
// 獲得一個連接對象
pconn = (pooledconnection) enum.nextelement();
// 如果對象忙則等 5 秒 ,5 秒后直接刷新
if (pconn.isbusy()) {
wait(5000); // 等 5 秒
}
// 關閉此連接，用一個新的連接代替它。
closeconnection(pconn.getconnection());
pconn.setconnection(newconnection());
pconn.setbusy(false);
}
}
/**
* 關閉連接池中所有的連接，并清空連接池。
*/
public synchronized void closeconnectionpool() throws sqlexception {
// 確保連接池存在，如果不存在，返回
if (connections == null) {
system.out.println(" 連接池不存在，無法關閉 !");
return;
}
pooledconnection pconn = null;
enumeration enum = connections.elements();
while (enum.hasmoreelements()) {
pconn = (pooledconnection) enum.nextelement();
// 如果忙，等 5 秒
if (pconn.isbusy()) {
wait(5000); // 等 5 秒
}
//5 秒后直接關閉它
closeconnection(pconn.getconnection());
// 從連接池向量中刪除它
connections.removeelement(pconn);
}
// 置連接池為空
connections = null;
}
/**
* 關閉一個數據庫連接
*
* @param 需要關閉的數據庫連接
*/
private void closeconnection(connection conn) {
try {
conn.close();
}catch (sqlexception e) {
system.out.println(" 關閉數據庫連接出錯： "+e.getmessage());
}
}
/**
* 使程序等待給定的毫秒數
*
* @param 給定的毫秒數
*/
private void wait(int mseconds) {
try {
thread.sleep(mseconds);
} catch (interruptedexception e) {
}
}
/**
*
* 內部使用的用于保存連接池中連接對象的類
* 此類中有兩個成員，一個是數據庫的連接，另一個是指示此連接是否
* 正在使用的標志。
*/
class pooledconnection {
connection connection = null;// 數據庫連接
boolean busy = false; // 此連接是否正在使用的標志，默認沒有正在使用
// 構造函數，根據一個 connection 構告一個 pooledconnection 對象
public pooledconnection(connection connection) {
this.connection = connection;
}
// 返回此對象中的連接
public connection getconnection() {
return connection;
}
// 設置此對象的，連接
public void setconnection(connection connection) {
this.connection = connection;
}
// 獲得對象連接是否忙
public boolean isbusy() {
return busy;
}
// 設置對象的連接正在忙
public void setbusy(boolean busy) {
this.busy = busy;
}
}
}
