使用设计模式构建通用数据库访问类

在应用程序的设计中，数据库的访问是非常重要的，我们通常需要将对数据库的访问集中起来，以保证良好的封装性和可维护性。在.Net中，数据库的访问，对于微软自家的SqlServer和其他数据库（支持OleDb），采用不同的访问方法，这些类分别分布于System.Data.SqlClient和System.Data.OleDb名称空间中。微软后来又推出了专门用于访问Oracle数据库的类库。我们希望在编写应用系统的时候，不因这么多类的不同而受到影响，能够尽量做到数据库无关，当后台数据库发生变更的时候，不需要更改客户端的代码。  
    
  　　有的时候，为了性能和其他原因，我们也希望提供对数据库访问的缓存，特别是数据库连接的缓存。虽然微软给我们内置了数据库缓存，但是，自己控制缓存，无疑可以提供更大的灵活性和效率。  
    
  　　这就需要我们在实际开发过程中将这些数据库访问类再作一次封装。这里，介绍一种在实际应用中得到了非常好的效果的实作策略。Factory和Silgleton设计模式是使用的主要方法。  
    
  　　我们先来看看Factory的含义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory　Method使一个类的实例化延迟到其子类。我们这里可能会处理对多种数据库的操作，因此，需要首先定义一个操纵数据库的接口，然后，根据数据库的不同，由类工厂决定实例化哪个类。  
    
  　　下面，我们首先来定义这个访问接口。为了方便说明问题，我们为这个类定义了比较少的方法，其他的方法是很容易参照添加的。同时注意，我这里使用了abstract　class来定义这个访问接口，而不是interface，理由在后面可以看到。  
    
  public abstract class DBOperator  
   {  
   public abstract IDbConnection Connection{get;} //得到数据库连接  
   public abstract void Open(); //打开数据库连接  
   public abstract void Close(); //关闭数据库连接  
   public abstract void BeginTrans(); //开始一个事务  
   public abstract void CommitTrans(); //提交一个事务  
   public abstract void RollbackTrans(); //回滚一个事务  
   public abstract void exeSql(string strSql,string[] strParams,object[] objValues);  
   //执行Sql语句，没有返回值  
   public abstract DataSet exeSqlForDataSet(string QueryString);//执行Sql，返回DataSet  
   }  
    
    
    
  　　然后，我们分别为Sql Server和OleDb数据库编写两个数据访问的具体实现类：  
    
  　　Sql Server的数据库访问类：  
    
  internal class SqlDBOperator: DBOperator  
   {  
   private SqlConnection conn; //数据库连接  
   private SqlTransaction trans; //事务处理类  
   private bool inTransaction=false; //指示当前是否正处于事务中  
   public override IDbConnection Connection  
   {  
   　　get{return this.conn;}  
   }  
   public SqlDBOperator(string strConnection)  
   {  
   　　this.conn= new SqlConnection(strConnection);  
   }  
   public override void Open()  
   {  
   　　if(conn.State.ToString().ToUpper()!="OPEN")  
  　　　　 this.conn.Open();  
   }  
   public override void Close()  
   {  
   　　if (conn.State.ToString().ToUpper()=="OPEN")  
   this.conn.Close();  
   }  
   public override void BeginTrans()  
   {  
   　　trans=conn.BeginTransaction() ;  
   　　　　inTransaction=true;  
   }  
   public override void CommitTrans()  
   {  
   　　trans.Commit();  
   　　　　inTransaction=false;  
   }  
   public override void RollbackTrans()  
   {  
   　　trans.Rollback();  
   　　　　inTransaction=false;  
   }  
   public override void exeSql(string strSql,string[] strParams,object[] strValues)  
   {  
   　　SqlCommand cmd=new SqlCommand();  
   　　cmd.Connection=this.conn ;  
   　　if(inTransaction)  
   　　　　cmd.Transaction=trans;  
   　　if((strParams!=null)&&(strParams.Length!=strValues.Length) )  
   throw new ParamValueNotMatchException("查询参数和值不对应!");  
   cmd.CommandText=strSql;  
   　　if(strParams!=null)  
   {  
   　　for(int i=0;i<strParams.Length;i++)  
   cmd.Parameters.Add(strParams[i],strValues[i]);  
   }  
   　 cmd.ExecuteNonQuery();  
   }  
   public override DataSet exeSqlForDataSet(string QueryString)  
   {  
   　　SqlCommand cmd=new SqlCommand();  
   cmd.Connection=this.conn ;  
   　　if(inTransaction)  
   　cmd.Transaction=trans;  
   　　DataSet ds = new DataSet();  
   　　SqlDataAdapter ad = new SqlDataAdapter();  
   　　cmd.CommandText=QueryString;  
   　　ad.SelectCommand =cmd;  
   　　ad.Fill(ds);  
   　　return ds;  
   　　}  
  　　　　}  
    
    
    
  　　OleDb数据库操作的类同Sql Server数据库操作的类非常相似，只是把相应的Sql类替换成OleDb类。需要注意的是，因为OleDb和Sql　Server的参数传递方式不一致，所以，这里需要做一点小小的转换，将"@参数名"类型的参数转换成"？"，这个细节希望读者能够注意到。代码如下：  
    
  internal class OleDBOperator : DBOperator  
   {  
   private OleDbConnection conn;  
   private OleDbTransaction trans;  
   private bool inTransaction=false;  
   public OleDBOperator(string strConnection)  
   {  
   　this.conn= new OleDbConnection(strConnection);  
   }  
   public override IDbConnection Connection  
   {  
   　get{return this.conn;}  
   }  
   public override void Open()  
   {  
   if(conn.State.ToString().ToUpper()!="OPEN")  
   this.conn.Open();  
   }  
   public override void Close()  
   {  
   　　if (conn.State.ToString().ToUpper()=="OPEN")  
   this.conn.Close();  
   }  
   public override void BeginTrans()  
   {  
   　　trans=conn.BeginTransaction() ;  
   　　　inTransaction=true;  
   }  
   public override void CommitTrans()  
   {  
   　　trans.Commit();  
   　　inTransaction=false;  
   }  
   public override void RollbackTrans()  
   {  
   　　trans.Rollback();  
   　　inTransaction=false;  
   }  
   public override void exeSql(string strSql,string[] strParams,object[] strValues)  
   {  
   OleDbCommand cmd=new OleDbCommand();  
  　 cmd.Connection=this.conn ;  
   if(inTransaction)  
   　　cmd.Transaction=trans;  
   if((strParams!=null)&&(strParams.Length!=strValues.Length) )  
   throw new ParamValueNotMatchException("查询参数和值不对应!");  
   cmd.CommandText=this.ChangeQueryString(strSql);  
   if(strParams!=null)  
   {  
   for(int i=0;i<strParams.Length;i++)  
   cmd.Parameters.Add(strParams[i],strValues[i]);  
   }  
   　　cmd.ExecuteNonQuery();  
   }  
   public override DataSet exeSqlForDataSet(string QueryString)  
   {  
   　　OleDbCommand cmd=new OleDbCommand();  
   cmd.Connection=this.conn ;  
   　　if(inTransaction)  
   　　　　cmd.Transaction=trans;  
   　　DataSet ds = new DataSet();  
   　　OleDbDataAdapter ad = new OleDbDataAdapter();  
   cmd.CommandText=QueryString;  
   　　ad.SelectCommand =cmd;  
   　　ad.Fill(ds);  
   　　return ds;  
   　　}  
   }  
    
    
    
  　　现在我们已经完成了所要的功能，下面，我们需要创建一个Factory类，来实现自动数据库切换的管理。这个类很简单，主要的功能就是根据数据库连接字符串，判断使用什么数据库，然后，返回适当的数据库操纵类。在这里，判断的方法很简单，只是根据两种数据库连接字符串的不同来判断。在实际中，随着数据库类的增加，判断的方法可能会有所变化，读者应当根据自己的实际情况来做相应的调整。  
    
  public class DBOperatorFactory  
   {  
   public static DBOperator GetDBOperator(string strConnection)  
   {  
  　　if(strConnection.IndexOf("provider=")<0) //SqlServer  
   {  
  　　return new SqlDBOperator(strConnection);  
   }  
  　　else //other database  
   {  
  　　return new OleDBOperator(strConnection);  
   }  
   }  
   }  
    
    
    
  　　好了，现在，一切都完成了，客户端在代码调用的时候，可能就是采用如下形式：  
    
  DBOperator db=DBOperatorFactory.GetDBOperator(strConnection)  
  db.Open();  
  db.需要的操作  
  db.Close();  
    
  或者：  
  DBOperator db=DBOperatorFactory.GetDBOperator(strConnection)  
  db.Open();db.BeginTrans();  
  try  
  {  
  db.需要的操作  
  db.CommitTrans();  
  }  
  catch  
  {  
  db.RollbackTrans();  
  }  
  db.Close();  
    
    
    
  　　当数据库发生变化的时候，DBOperatorFactory会根据数据库连接字符串自动调用相应的类，客户端不会感觉到变化，也不用去关心。这样，实现了良好的封装性。当然，前提是，你在编写程序的时候，没有用到特定数据库的特性，例如，Sql Server的专用函数。  
    
  　　实际上，Factory模式也可以不使用Factory类来实现，而是让接口抽象类自己来管理，这可以称作自管理的Factory，是Factory模式的一种变形。这么做的好处，是可以免去一个Factory类，使代码更加简练。这么做，我们需要对DBOperator类做一些改变，增加一个Instance方法。这也是对DBOperator采用抽象类而不是接口的原因（接口的方法不能有实现），代码如下：  
    
  public static DBOperator Instance(string strConnection)  
   {  
   if(strConnection.IndexOf("provider=")<0) //SqlServer  
   {  
   return new SqlDBOperator(strConnection);  
   }  
   else //other database  
   {  
   return new OleDBOperator(strConnection);  
   }  
   }  
    
    
    
  　　然后，客户端代码就可能是类似于下面的形式：  
    
  DBOperator db= DBOperator.Instance(strConnection)  
  db.Open();  
  db.需要的操作  
  db.Close();  
    
    
    
  　　下面来看看连接池的做法，方法就是Singleton。  
    
  　　先看Singleton模式的经典含义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。推而广之，当我们需要精确控制类在系统中的实例的个数的时候，就可以使用Singleton模式。现在，我们需要构建一个缓冲池，保存数据库类的实例，正好是Singleton模式发挥作用的时候。  
    
  　　我们仍然让DBOperator类自己来管理这个缓冲池，为了实现这个目的，我们需要对DBOperator类做一些变化：  
    
  　　首先，增加两个变量：  
    
  　static DBOperator[] ConnectionPool=new  
   DBOperator[int.Parse(ConfigurationSettings.AppSettings["PoolCount"])];  
  　static int CurrentPosition=-1;  
    
    
    
  　　然后，对Instance方法做一些改变：  
    
  public static DBOperator Instance(string strConnection)  
   {  
   if(ApplicationConfiguration.PooledConnectionCount<1) //没有缓冲  
   {  
   return CreateNewDBOperator(strConnection);  
   }  
   else  
   {  
   CurrentPosition++;  
   if(CurrentPosition==ApplicationConfiguration.PooledConnectionCount)  
   CurrentPosition=0;  
   if(ConnectionPool[CurrentPosition]==null)  
   {  
   ConnectionPool[CurrentPosition]=CreateNewDBOperator(strConnection);  
   }  
   return ConnectionPool[CurrentPosition];  
   }  
   }  
   private static DBOperator CreateNewDBOperator(string strConnection)  
   {  
   if(strConnection.IndexOf("provider=")<0) //SqlServer  
   {  
   return new SqlDBOperator(strConnection);  
   }  
   else //other database  
   {  
   return new OleDBOperator(strConnection);  
   }  
   }   
          
  　　这里使用的算法比较简单，只是为了能够比较清楚地说明问题，读者应当能够在实际使用过程中，实现更好的算法。  
    
  　　以上，介绍了一种通用数据库操作类的实现设计方法，希望能够对大家有所启发。笔者设计Websharp中间件的时候，在数据库处理层，采用了上面的方法，取得了很好的效果。