|
|
马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。
您需要 登录 才可以下载或查看，没有帐号？立即注册
x
有了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;
}
}
}
因此我们的保存数据方法就是：在删除的动作开始之前，把表数据备份起来，然后留一个空表，在空表上执行“删除”操作。 |
|
|Archiver|手机版|仓酷云
鄂ICP备14007578号-2
发表于 2015-1-16 22:36:35
收藏
转播
分享
淘帖
顶
踩
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
千斤顶
照妖镜
楼主