MSSQL网站制作之关于数据库毗连数据库连接,generated,creation,private,comment

山那边是海 发表于 2015-1-16 22:36:35

MSSQL网站制作之关于数据库毗连

有了rowbase的binlog后，我们来分析一下怎么实现闪回。平时的DML无非三种操作，增删改，先说三种操作的日志格式。数据|数据库|数据库毗连
关于数据库的毗连，有一些个性的器材；堆集了几个办法，能够作为一个可复用的模块。
/********************************************************************/
类JbfcmsConnect：
importjava.io.*;
importjava.util.*;
importjava.sql.*;
importjava.text.*;
importjava.lang.*;

/**
*@author*
*Tochangethisgeneratedcommenteditthetemplatevariable"typecomment":
*Window>Preferences>Java>Templates.
*Toenableanddisablethecreationoftypecommentsgoto
*Window>Preferences>Java>CodeGeneration.
*/
publicclassJbfcmsConnect{
privateStringdrive="";
privateStringdbURL="";
privateStringprop_server_name="";
privateStringprop_db_name="";
privateStringdbUserName="";
privateStringdbUserPassword="";
privateStringprop_db_provider;
/**
*onstructorforDBConnect
*/

publicJbfcmsConnect(){
init();
}

/**
*Methodinit.
*/
privatevoidinit(){
System.out.println("enterinit");
PropertiesdefaultSettings=newProperties();
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("putdefaultsettings");
Stringprop_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("setdefaultsettings");
Propertiessettings=newProperties();
try{
System.out.println("StartsearchPropertiesFile");
FileInputStreamsf=newFileInputStream("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("PropertiesFileexist");

}catch(FileNotFoundExceptione){
System.out.println("PropertiesFilewasnotfound!");
}catch(IOExceptione){
System.out.println("IOExceptionisfound!");
}

/////////////////
if(prop_db_provider.equalsIgnoreCase("db2"))
{if(prop_driver_type.equalsIgnoreCase("net"))
{//System.out.println("bein-----");
drive="COM.ibm.db2.jdbc.net.DB2Driver";
Stringprop_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("DB2Connection==>
driverName="+drive+"
url="+dbURL+"
");}

//MYSQL数据库毗连
elseif(prop_db_provider.equalsIgnoreCase("mysql"))
{if(prop_driver_type.equalsIgnoreCase("net"))
{
drive="com.mysql.jdbc.Driver";
Stringprop_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("MYSQLConnection==>
driverName="+drive+"
url="+dbURL+"
");}
//SQLserver数据库毗连
elseif(prop_db_provider.equalsIgnoreCase("SQLserver"))
{if(prop_driver_type.equalsIgnoreCase("net"))
{
drive="com.microsoft.jdbc.sqlserver.SQLServerDriver";
Stringprop_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("SQLserverConnection==>
driverName="+drive+"
url="+dbURL+"
");}

}
Connectionconn=null;
privatevoidconnectPool(){
try{
Class.forName(drive).newInstance();
conn=
DriverManager.getConnection(dbURL,dbUserName,dbUserPassword);

}catch(ClassNotFoundExceptionec){
System.out.println("数据库驱动装载存在成绩");
}catch(IllegalAccessExceptioneI){
System.out.println("数据库会见非常");
}catch(InstantiationExceptionei){
System.out.println(ei.getMessage());
}catch(SQLExceptione){
System.out.println(
"
***********************数据库毗连非常**********************
");
while(e!=null){
System.out.println("SQLState:"+e.getSQLState());
System.out.println("Message:"+e.getMessage());
System.out.println("Vendor:"+e.getErrorCode());
e=e.getNextException();
}
}
}

publicConnectiongetConnect(){
connectPool();
returnconn;

}

}
//此类卖力数据库的毗连部分

类：JbSqlExecute
importjava.io.*;
importjava.util.*;
importjava.util.Date;
importjava.sql.*;
importjava.text.*;

/**
*@author
*
*Tochangethisgeneratedcommenteditthetemplatevariable"typecomment":
*Window>Preferences>Java>Templates.
*Toenableanddisablethecreationoftypecommentsgoto
*Window>Preferences>Java>CodeGeneration.
*/
publicclassJbSqlExecute{

privatestaticConnectioncon=null;
privatePreparedStatementpstmt=null;

/**
*ConstructorforJbSqlExecute.
*/
publicJbSqlExecute(){
JbfcmsConnectConnect=newJbfcmsConnect();
con=Connect.getConnect();
}

/**
*MethodsqlInsert.
*@paramstrInsert
*@
*/
publicvoidsqlInsert(StringstrInsert){
try{
pstmt=con.prepareStatement(strInsert);
pstmt.execute();
}catch(SQLExceptionsqle){
System.out.println("Jbmms数据库拔出非常:"+sqle.getMessage());
}

}

/**
*MethodstrUpdata.
*@paramstrUpdata
*@
*/
publicvoidsqlUpdata(StringstrUpdata){
try{
pstmt=con.prepareStatement(strUpdata);
pstmt.execute();
}catch(SQLExceptionsqle){
System.out.println("Jbmms数据库更新非常:"+sqle.getMessage());
}

}

/**
*MethodexecuteQuery.
*@paramstrQuery
*@returnResultSet
*/
publicResultSetexecuteQuery(StringstrQuery){
ResultSetrset=null;
try{
System.out.println(strQuery);

pstmt=con.prepareStatement(strQuery);
rset=pstmt.executeQuery();
System.out.println("over");
}catch(SQLExceptionsqle){
System.out.println("Jbmms数据库查询非常:"+sqle.getMessage());
}
System.out.println("rset");
returnrset;
}

/**
*MethodexecuteDelete.
*@paramstrDelete
*/
publicvoidexecuteDelete(StringstrDelete){
try{
pstmt=con.prepareStatement(strDelete);
pstmt.execute();
}catch(SQLExceptionsqle){
System.out.println("Jbmms数据库删除非常:"+sqle.getMessage());
}

}
}

//数据库操纵的实行，在利用时间接挪用此类中的办法便可。

/******************************************************************/
一个关于数据库毗连池的完成---自创于网友
源代码
//ConnectionPool.java

packagecom.abner.dbconnector;

importjava.sql.*;

importjava.util.*;

/**

*ConnectionPool类创立了一个对特定命据库指定巨细的毗连池。毗连池工具

*同意客户端指定JDBC驱动程序，数据库，利用数据库的用户名和暗码。并且，

*客户端能指定毗连池的在初始创立是发生数据库毗连的数目，和指定当毗连

*不敷时每次主动增添毗连的数目及毗连池最多的数据库毗连的数目。

*

*对外供应的办法有：ConnectionPool：机关函数

*getInitialConnections:前往毗连池初始化巨细

*setInitialConnections:设置毗连池初始化巨细

*getIncrementalConnections:前往毗连池主动增添的增量

*setIncrementalConnections:设置毗连池主动增添的巨细

*getMaxConnections：取得毗连池的最年夜可同意的毗连数

*setMaxConnections：设置毗连池的最年夜可同意的毗连数

*getTestTable：取得测试表的名字

*setTestTable：设置测试表的名字

*createPool:创立毗连池,线程己同步

*getConnection:从毗连池中取得一个数据库毗连

*returnConnection:前往一个毗连到毗连池中

*refreshConnections:革新毗连池

*closeConnectionPool:封闭毗连池

*

*/

publicclassConnectionPool{

privateStringjdbcDriver="";//数据库驱动

privateStringdbUrl="";//数据URL

privateStringdbUsername="";//数据库用户名

privateStringdbPassword="";//数据库用户暗码

privateStringtestTable="";//测试毗连是不是可用的测试表名，默许没有测试表

privateintinitialConnections=10;//毗连池的初始巨细

privateintincrementalConnections=5;//毗连池主动增添的巨细

privateintmaxConnections=50;//毗连池最年夜的巨细

privateVectorconnections=null;//寄存毗连池中数据库毗连的向量,初始时为null

//它中寄存的工具为PooledConnection型

/**

*机关函数

*

*@paramjdbcDriverStringJDBC驱动类串

*@paramdbUrlString数据库URL

*@paramdbUsernameString毗连数据库用户名

*@paramdbPasswordString毗连数据库用户的暗码

*

*/

publicConnectionPool(StringjdbcDriver,StringdbUrl,StringdbUsername,StringdbPassword){

this.jdbcDriver=jdbcDriver;

this.dbUrl=dbUrl;

this.dbUsername=dbUsername;

this.dbPassword=dbPassword;

}

/**

*前往毗连池的初始巨细

*

*@return初始毗连池中可取得的毗连数目

*/

publicintgetInitialConnections(){

returnthis.initialConnections;

}

/**

*设置毗连池的初始巨细

*

*@param用于设置初始毗连池中毗连的数目

*/

publicvoidsetInitialConnections(intinitialConnections){

this.initialConnections=initialConnections;

}

/**

*前往毗连池主动增添的巨细、

*

*@return毗连池主动增添的巨细

*/

publicintgetIncrementalConnections(){

returnthis.incrementalConnections;

}

/**

*设置毗连池主动增添的巨细

*@param毗连池主动增添的巨细

*/

publicvoidsetIncrementalConnections(intincrementalConnections){

this.incrementalConnections=incrementalConnections;

}

/**

*前往毗连池中最年夜的可用毗连数目

*@return毗连池中最年夜的可用毗连数目

*/

publicintgetMaxConnections(){

returnthis.maxConnections;

}

/**

*设置毗连池中最年夜可用的毗连数目

*

*@param设置毗连池中最年夜可用的毗连数目值

*/

publicvoidsetMaxConnections(intmaxConnections){

this.maxConnections=maxConnections;

}

/**

*猎取测试数据库表的名字

*

*@return测试数据库表的名字

*/

publicStringgetTestTable(){

returnthis.testTable;

}

/**

*设置测试表的名字

*@paramtestTableString测试表的名字

*/

publicvoidsetTestTable(StringtestTable){

this.testTable=testTable;

}

/**

*

*创立一个数据库毗连池，毗连池中的可用毗连的数目接纳类成员

*initialConnections中设置的值

*/

publicsynchronizedvoidcreatePool()throwsException{

//确保毗连池没有创立

//假如毗连池己经创立了，保留毗连的向量connections不会为空

if(connections!=null){

return;//假如己经创立，则前往

}

//实例化JDBCDriver中指定的驱动类实例

Driverdriver=(Driver)(Class.forName(this.jdbcDriver).newInstance());

DriverManager.registerDriver(driver);//注册JDBC驱动程序

//创立保留毗连的向量,初始时有0个元素

connections=newVector();

//依据initialConnections中设置的值，创立毗连。

createConnections(this.initialConnections);

System.out.println("数据库毗连池创立乐成！");

}

/**

*创立由numConnections指定命目标数据库毗连,并把这些毗连

*放进connections向量中

*

*@paramnumConnections要创立的数据库毗连的数量

*/

privatevoidcreateConnections(intnumConnections)throwsSQLException{

//轮回创立指定命目标数据库毗连

for(intx=0;x<numConnections;x++){

//是不是毗连池中的数据库毗连的数目己经到达最年夜？最年夜值由类成员maxConnections

//指出，假如maxConnections为0或正数，暗示毗连数目没无限制。

//假如毗连数己经到达最年夜，即加入。

if(this.maxConnections>0&&this.connections.size()>=this.maxConnections){

break;

}

//addanewPooledConnectionobjecttoconnectionsvector

//增添一个毗连到毗连池中（向量connections中）

try{

connections.addElement(newPooledConnection(newConnection()));

}catch(SQLExceptione){

System.out.println("创立数据库毗连失利！"+e.getMessage());

thrownewSQLException();

}

System.out.println("数据库毗连己创立......");

}

}

/**

*创立一个新的数据库毗连并前往它

*

*@return前往一个新创立的数据库毗连

*/

privateConnectionnewConnection()throwsSQLException{

//创立一个数据库毗连

Connectionconn=DriverManager.getConnection(dbUrl,dbUsername,dbPassword);

//假如这是第一次创立数据库毗连，即反省数据库，取得此数据库同意撑持的

//最年夜客户毗连数量

//connections.size()==0暗示今朝没有毗连己被创立

if(connections.size()==0){

DatabaseMetaDatametaData=conn.getMetaData();

intdriverMaxConnections=metaData.getMaxConnections();

//数据库前往的driverMaxConnections若为0，暗示此数据库没有最年夜

//毗连限定，或数据库的最年夜毗连限定不晓得

//driverMaxConnections为前往的一个整数，暗示此数据库同意客户毗连的数量

//假如毗连池中设置的最年夜毗连数目年夜于数据库同意的毗连数量,则置毗连池的最年夜

//毗连数量为数据库同意的最年夜数量

if(driverMaxConnections>0&&this.maxConnections>driverMaxConnections){

this.maxConnections=driverMaxConnections;

}

}

returnconn;//前往创立的新的数据库毗连

}

/**

*经由过程挪用getFreeConnection()函数前往一个可用的数据库毗连,

*假如以后没有可用的数据库毗连，而且更多的数据库毗连不克不及创

*建（如毗连池巨细的限定），此函数守候一会再实验猎取。

*

*@return前往一个可用的数据库毗连工具

*/

publicsynchronizedConnectiongetConnection()throwsSQLException{

//确保毗连池己被创立

if(connections==null){

returnnull;//毗连池还没创立，则前往null

}

Connectionconn=getFreeConnection();//取得一个可用的数据库毗连

//假如今朝没有可使用的毗连，即一切的毗连都在利用中

while(conn==null){

//等一会再试

wait(250);

conn=getFreeConnection();//从头再试，直到取得可用的毗连，假如

//getFreeConnection()前往的为null

//则标明创立一批毗连后也不成取得可用毗连

}

returnconn;//前往取得的可用的毗连

}

/**

*本函数从毗连池向量connections中前往一个可用的的数据库毗连，假如

*以后没有可用的数据库毗连，本函数则依据incrementalConnections设置

*的值创立几个数据库毗连，并放进毗连池中。

*假如创立后，一切的毗连仍都在利用中，则前往null

*@return前往一个可用的数据库毗连

*/

privateConnectiongetFreeConnection()throwsSQLException{

//从毗连池中取得一个可用的数据库毗连

Connectionconn=findFreeConnection();

if(conn==null){

//假如今朝毗连池中没有可用的毗连

//创立一些毗连

createConnections(incrementalConnections);

//从头从池中查找是不是有可用毗连

conn=findFreeConnection();

if(conn==null){

//假如创立毗连后仍取得不到可用的毗连，则前往null

returnnull;

}

}

returnconn;

}

/**

*查找毗连池中一切的毗连，查找一个可用的数据库毗连，

*假如没有可用的毗连，前往null

*

*@return前往一个可用的数据库毗连

*/

privateConnectionfindFreeConnection()throwsSQLException{

Connectionconn=null;

PooledConnectionpConn=null;

//取得毗连池向量中一切的工具

Enumerationenum=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(SQLExceptione){

System.out.println("创立数据库毗连失利！"+e.getMessage());

returnnull;

}

pConn.setConnection(conn);

}

break;//己经找到一个可用的毗连，加入

}

}

returnconn;//前往找到到的可用毗连

}

/**

*测试一个毗连是不是可用，假如不成用，关失落它并前往false

*不然可用前往true

*

*@paramconn必要测试的数据库毗连

*@return前往true暗示此毗连可用，false暗示不成用

*/

privatebooleantestConnection(Connectionconn){

try{

//判别测试表是不是存在

if(testTable.equals("")){

//假如测试表为空，试着利用此毗连的setAutoCommit()办法

//来判别毗连否可用（此办法只在部分数据库可用，假如不成用,

//抛出非常）。注重：利用测试表的办法更牢靠

conn.setAutoCommit(true);

}else{//有测试表的时分利用测试表测试

//checkifthisconnectionisvalid

Statementstmt=conn.createStatement();

stmt.execute("selectcount(*)from"+testTable);

}

}catch(SQLExceptione){

//下面抛出非常，此毗连己不成用，封闭它，并前往false;

closeConnection(conn);

returnfalse;

}

//毗连可用，前往true

returntrue;

}

/**

*此函数前往一个数据库毗连到毗连池中，并把此毗连置为余暇。

*一切利用毗连池取得的数据库毗连均应在不利用此毗连时前往它。

*

*@param需前往到毗连池中的毗连工具

*/

publicvoidreturnConnection(Connectionconn){

//确保毗连池存在，假如毗连没有创立（不存在），间接前往

if(connections==null){

System.out.println("毗连池不存在，没法前往此毗连到毗连池中!");

return;

}

PooledConnectionpConn=null;

Enumerationenum=connections.elements();

//遍历毗连池中的一切毗连，找到这个要前往的毗连工具

while(enum.hasMoreElements()){

pConn=(PooledConnection)enum.nextElement();

//先找到毗连池中的要前往的毗连工具

if(conn==pConn.getConnection()){

//找到了,设置此毗连为余暇形态

pConn.setBusy(false);

break;

}

}

}

/**

*革新毗连池中一切的毗连工具

*

*/

publicsynchronizedvoidrefreshConnections()throwsSQLException{

//确保毗连池己立异存在

if(connections==null){

System.out.println("毗连池不存在，没法革新!");

return;

}

PooledConnectionpConn=null;

Enumerationenum=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);

}

}

/**

*封闭毗连池中一切的毗连，并清空毗连池。

*/

publicsynchronizedvoidcloseConnectionPool()throwsSQLException{

//确保毗连池存在，假如不存在，前往

if(connections==null){

System.out.println("毗连池不存在，没法封闭!");

return;

}

PooledConnectionpConn=null;

Enumerationenum=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必要封闭的数据库毗连

*/

privatevoidcloseConnection(Connectionconn){

try{

conn.close();

}catch(SQLExceptione){

System.out.println("封闭数据库毗连堕落："+e.getMessage());

}

}

/**

*使程序守候给定的毫秒数

*

*@param给定的毫秒数

*/

privatevoidwait(intmSeconds){

try{

Thread.sleep(mSeconds);

}catch(InterruptedExceptione){

}

}

/**

*

*外部利用的用于保留毗连池中毗连工具的类

*此类中有两个成员，一个是数据库的毗连，另外一个是唆使此毗连是不是

*正在利用的标记。

*/

classPooledConnection{

Connectionconnection=null;//数据库毗连

booleanbusy=false;//此毗连是不是正在利用的标记，默许没有正在利用

//机关函数，依据一个Connection构告一个PooledConnection工具

publicPooledConnection(Connectionconnection){

this.connection=connection;

}

//前往此工具中的毗连

publicConnectiongetConnection(){

returnconnection;

}

//设置此工具的，毗连

publicvoidsetConnection(Connectionconnection){

this.connection=connection;

}

//取得工具毗连是不是忙

publicbooleanisBusy(){

returnbusy;

}

//设置工具的毗连正在忙

publicvoidsetBusy(booleanbusy){

this.busy=busy;

}

}

}

因此我们的保存数据方法就是：在删除的动作开始之前，把表数据备份起来，然后留一个空表，在空表上执行“删除”操作。

蒙在股里 发表于 2015-1-19 07:09:35

索引视图2k就有。但是2005对其效率作了一些改进但是schema.viewname的作用域真是太限制了它的应用面。还有一大堆的环境参数和种种限制都让人对它有点却步。

山那边是海 发表于 2015-1-24 11:21:15

where子句的作用是在对查询结果进行分组前，将不符合where条件的行去掉，即在分组之前过滤数据，条件中不能包含聚组函数，使用where条件显示特定的行。

飘飘悠悠 发表于 2015-2-1 06:50:26

小女巫 发表于 2015-2-7 01:32:00

我是一个ERP初学者，对于前台运用基本熟悉，但对于后台SQLServer的运用一点也不懂，特想学习下相关资料。至少懂得一些基本的运用。希望各位能给于建议，小弟再谢过！

乐观发表于 2015-2-19 09:49:35

呵呵，这就是偶想说的

灵魂腐蚀 发表于 2015-3-6 14:52:57

如果是将来做数据库的开发设计，就应该详细学习T-SQL的各种细节，包括T-SQL的程序设计、存储过程、触发器以及具体使用某个开发语言来访问数据库。

分手快乐 发表于 2015-3-13 02:09:56

而写到本地,我又考虑到效率问题.大家来讨论讨论吧,分数不打紧,就给10分,十全十美,没啥对错,各抒己见,但是要有说服力的哦~

页: [1]

仓酷云's Archiver

MSSQL网站制作之关于数据库毗连