插件式Web框架

转载构建高性能插件式Web框架

基于MVC插件模式构建支持数据库集群、数据实时同步、数据发布与订阅的Web框架系统。如下图：

　　1、基于插件式开发

　　　　 采用插件模式开发的优点是使得系统框架和业务模式有效地进行分离，系统更新也比较简单，只需更新业务插件，不需要动整个框架，开发人员无需关心整个框架结构。

但插件模式调试稍微麻烦一点，比不采用插件模式开发的效率上也要差一点，因为它采用反射进行动态加载插件。

登录插件示例：

namespace LoginPlugin
{
    public class Plugin : NetUML.Portal.Framework.AbstractPlugin
    {

        public Plugin()
        {

            this.Title = "系统登录";
            this.Description = "登录插件";
        }

        public override string Name
        {
            get { return "LoginPlugin"; }
            set { }
        }

        public override int StartLevel
        {
            get { return 2; }
            set { }
        }

        public override void Start(NetUML.Portal.Framework.IBundleContext context)
        {

        }

        public override void Stop(NetUML.Portal.Framework.IBundleContext context)
        {

        }
        public override string SymbolicName
        {
            set { }
            get { return "System.Login"; }
        }

        public override List<NetUML.Portal.Framework.MenuItem> MenuItems
        {
            get { return null; }
        }

        public override NetUML.Portal.Framework.PluginType PluginType
        {
            get
            {
                return NetUML.Portal.Framework.PluginType.Login;
            }
        }

        public override string Title
        {
            get;
            set;
        }

        public override string Description
        {
            get;
            set;
        }
    }
}

　　　　所有插件必须实现 NetUML.Portal.Framework.AbstractPlugin 这个插件抽象类。

　　       当加载插件的时候会执行Start方法，停止插件的时候会执行Stop方法。

　　2、数据库引擎

　　　　 数据库引擎NetUML.DataEngine类，采用IBatisNet底层访问数据库原理，动态创建IDbConnection连接池，核心代码如下

  1 namespace NetUML.DataEngine
  2 {
  3     public class DbSession : MarshalByRefObject, IDalSession
  4     {
  5
  6         #region Fields
  7         private IDataSource _dataSource = null;
  8         private bool _isTransactionOpen = false;
  9         private bool _consistent = false;
 10         private IDbConnection _connection = null;
 11         private IDbTransaction _transaction = null;
 12         #endregion
 13         public DbSession(IDataSource dataSource)
 14         {
 15             _dataSource = dataSource;
 16         }
 17         public IDataSource DataSource
 18         {
 19             get { return _dataSource; }
 20         }
 21
 22         public System.Data.IDbConnection Connection
 23         {
 24             get { return _connection; }
 25         }
 26
 27         public System.Data.IDbTransaction Transaction
 28         {
 29             get { return _transaction; }
 30         }
 31
 32         public bool IsTransactionStart
 33         {
 34             get { return _isTransactionOpen; }
 35         }
 36         private bool Consistent
 37         {
 38             set { _consistent = value; }
 39         }
 40         public void Complete()
 41         {
 42             this.Consistent = true;
 43         }
 44
 45         public void OpenConnection()
 46         {
 47             this.OpenConnection(_dataSource.ConnectionString);
 48         }
 49         public void OpenConnection(string connectionString)
 50         {
 51             if (_connection == null)
 52             {
 53                 CreateConnection(connectionString);
 54                 try
 55                 {
 56                     _connection.Open();
 57                     //if (_logger.IsDebugEnabled)
 58                     //{
 59                     //    _logger.Debug(string.Format("Open Connection \"{0}\" to \"{1}\".", _connection.GetHashCode().ToString(), _dataSource.DbProvider.Description));
 60                     //}
 61                 }
 62                 catch (Exception ex)
 63                 {
 64                     //DataMapperException
 65                     throw new Exception(string.Format("Unable to open connection to \"{0}\".", _dataSource.DbProvider.Description), ex);
 66                 }
 67             }
 68             else if (_connection.State != ConnectionState.Open)
 69             {
 70                 try
 71                 {
 72                     _connection.Open();
 73                     //if (_logger.IsDebugEnabled)
 74                     //{
 75                     //    _logger.Debug(string.Format("Open Connection \"{0}\" to \"{1}\".", _connection.GetHashCode().ToString(), _dataSource.DbProvider.Description));
 76                     //}
 77                 }
 78                 catch (Exception ex)
 79                 {
 80                     throw new Exception(string.Format("Unable to open connection to \"{0}\".", _dataSource.DbProvider.Description), ex);
 81                 }
 82             }
 83         }
 84         public void CreateConnection()
 85         {
 86             CreateConnection(_dataSource.ConnectionString);
 87         }
 88         /// <summary>
 89         /// Create the connection
 90         /// </summary>
 91         public void CreateConnection(string connectionString)
 92         {
 93             _connection = _dataSource.DbProvider.CreateConnection();
 94             _connection.ConnectionString = connectionString;
 95         }
 96
 97         public void CloseConnection()
 98         {
 99             if ((_connection != null) && (_connection.State != ConnectionState.Closed))
100             {
101                 _connection.Close();
102                 //if (_logger.IsDebugEnabled)
103                 //{
104                 //    _logger.Debug(string.Format("Close Connection \"{0}\" to \"{1}\".", _connection.GetHashCode().ToString(), _dataSource.DbProvider.Description));
105                 //}
106                 _connection.Dispose();
107             }
108             _connection = null;
109         }
110
111         public void BeginTransaction()
112         {
113             this.BeginTransaction(_dataSource.ConnectionString);
114         }
115
116         public void BeginTransaction(string connectionString)
117         {
118             if (_connection == null || _connection.State != ConnectionState.Open)
119             {
120                 this.OpenConnection(connectionString);
121             }
122             _transaction = _connection.BeginTransaction();
123             //if (_logger.IsDebugEnabled)
124             //{
125             //    _logger.Debug("Begin Transaction.");
126             //}
127             _isTransactionOpen = true;
128         }
129         public void BeginTransaction(bool openConnection)
130         {
131             if (openConnection)
132             {
133                 this.BeginTransaction();
134             }
135             else
136             {
137                 if (_connection == null || _connection.State != ConnectionState.Open)
138                 {
139                     this.OpenConnection();
140                 }
141                 _transaction = _connection.BeginTransaction();
142                 //if (_logger.IsDebugEnabled)
143                 //{
144                 //    _logger.Debug("Begin Transaction.");
145                 //}
146                 _isTransactionOpen = true;
147             }
148         }
149         public void BeginTransaction(System.Data.IsolationLevel isolationLevel)
150         {
151             this.BeginTransaction(_dataSource.ConnectionString, isolationLevel);
152         }
153         public void BeginTransaction(string connectionString, System.Data.IsolationLevel isolationLevel)
154         {
155             if (_connection == null || _connection.State != ConnectionState.Open)
156             {
157                 this.OpenConnection(connectionString);
158             }
159             _transaction = _connection.BeginTransaction(isolationLevel);
160             //if (_logger.IsDebugEnabled)
161             //{
162             //    _logger.Debug("Begin Transaction.");
163             //}
164             _isTransactionOpen = true;
165         }
166         public void BeginTransaction(bool openConnection, System.Data.IsolationLevel isolationLevel)
167         {
168             this.BeginTransaction(_dataSource.ConnectionString, openConnection, isolationLevel);
169         }
170         public void BeginTransaction(string connectionString, bool openConnection, System.Data.IsolationLevel isolationLevel)
171         {
172             if (openConnection)
173             {
174                 this.BeginTransaction(connectionString, isolationLevel);
175             }
176             else
177             {
178                 if (_connection == null || _connection.State != ConnectionState.Open)
179                 {
180                     //DataMapperException
181                     throw new Exception("SqlMapSession could not invoke StartTransaction(). A Connection must be started. Call OpenConnection() first.");
182                 }
183                 _transaction = _connection.BeginTransaction(isolationLevel);
184                 //if (_logger.IsDebugEnabled)
185                 //{
186                 //    _logger.Debug("Begin Transaction.");
187                 //}
188                 _isTransactionOpen = true;
189             }
190         }
191         public void CommitTransaction()
192         {
193             //if (_logger.IsDebugEnabled)
194             //{
195             //    _logger.Debug("Commit Transaction.");
196             //}
197             _transaction.Commit();
198             _transaction.Dispose();
199             _transaction = null;
200             _isTransactionOpen = false;
201
202             if (_connection.State != ConnectionState.Closed)
203             {
204                 this.CloseConnection();
205             }
206         }
207
208         public void CommitTransaction(bool closeConnection)
209         {
210             if (closeConnection)
211             {
212                 this.CommitTransaction();
213             }
214             else
215             {
216                 //if (_logger.IsDebugEnabled)
217                 //{
218                 //    _logger.Debug("Commit Transaction.");
219                 //}
220                 _transaction.Commit();
221                 _transaction.Dispose();
222                 _transaction = null;
223                 _isTransactionOpen = false;
224             }
225         }
226
227         public void RollBackTransaction()
228         {
229             //if (_logger.IsDebugEnabled)
230             //{
231             //    _logger.Debug("RollBack Transaction.");
232             //}
233             _transaction.Rollback();
234             _transaction.Dispose();
235             _transaction = null;
236             _isTransactionOpen = false;
237             if (_connection.State != ConnectionState.Closed)
238             {
239                 this.CloseConnection();
240             }
241         }
242
243         public void RollBackTransaction(bool closeConnection)
244         {
245             if (closeConnection)
246             {
247                 this.RollBackTransaction();
248             }
249             else
250             {
251                 //if (_logger.IsDebugEnabled)
252                 //{
253                 //    _logger.Debug("RollBack Transaction.");
254                 //}
255                 _transaction.Rollback();
256                 _transaction.Dispose();
257                 _transaction = null;
258                 _isTransactionOpen = false;
259             }
260         }
261
262         public IDbCommand CreateCommand(CommandType commandType)
263         {
264             IDbCommand command = _dataSource.DbProvider.CreateCommand();
265             command.CommandType = commandType;
266             command.Connection = _connection;
267             if (_transaction != null)
268             {
269                 try
270                 {
271                     command.Transaction = _transaction;
272                 }
273                 catch
274                 { }
275             }
276             if (_connection != null)
277             {
278                 try
279                 {
280                     command.CommandTimeout = _connection.ConnectionTimeout;
281                 }
282                 catch (NotSupportedException e)
283                 {
284                     //if (_logger.IsInfoEnabled)
285                     //{
286                     //    _logger.Info(e.Message);
287                     //}
288                 }
289             }
290             return command;
291         }
292
293         public System.Data.IDbDataParameter CreateDataParameter()
294         {
295             return _dataSource.DbProvider.CreateDataParameter();
296         }
297         public System.Data.IDbDataAdapter CreateDataAdapter()
298         {
299             return _dataSource.DbProvider.CreateDataAdapter();
300         }
301         public System.Data.IDbDataAdapter CreateDataAdapter(System.Data.IDbCommand command)
302         {
303             IDbDataAdapter dataAdapter = null;
304             dataAdapter = _dataSource.DbProvider.CreateDataAdapter();
305             dataAdapter.SelectCommand = command;
306             return dataAdapter;
307         }
308         public void Dispose()
309         {
310             //if (_logger.IsDebugEnabled)
311             //{
312             //    _logger.Debug("Dispose SqlMapSession");
313             //}
314             if (_isTransactionOpen == false)
315             {
316                 if (_connection.State != ConnectionState.Closed)
317                 {
318                     this.CloseConnection();
319                 }
320             }
321             else
322             {
323                 if (_consistent)
324                 {
325                     this.CommitTransaction();
326                     _isTransactionOpen = false;
327                 }
328                 else
329                 {
330                     if (_connection.State != ConnectionState.Closed)
331                     {
332                         this.RollBackTransaction();
333                         _isTransactionOpen = false;
334                     }
335                 }
336             }
337         }
338     }
339 }

程序结构如下图：

　　3、数据库集群服务

　　　　 NetUML.DataEngine支持多数据库连接，主持数据库读写分离操作，哪些数据表需要读写分离可以进行相应的配置和管理，类似于MVC中的路由概念，咱们可以配置多条路由表，路由表内容包括数

据表名，数据对象关键词以及数据库信息，用户保存数据的时候，系统根据要保存的数据表以及数据对象去寻找路由，再根据路由中的配置信息进行提交到数据库。

进在开发中。。。。。。。。

　　4、数据同步、发布和订阅服务

　　　　 如果第三方系统接入当前系统当中来，当前系统中的数据发生变化，需要立马通知接入进来的系统，把变化的数据提交给第三方系统，第三方系统接入到数据进行相应的处理。

　　　　 第三方系统只需要提供给当前系统一个URL地址，当前系统把数据POST到URL地址。

进在开发中。。。。。。。。

　　5、插件管理

系统框架支持上传插件包，不需要到服务器进行更新程序，上传完插件包之后，系统自动把插件包解压出来，进行动态编译加载插件。

系统框架也支持停止和卸载插件。如下图：

　　6、海量文档资料+全文搜索插件

　　　　文档管理插件支持office等文档在线浏览以及文件转换，把文档转换成HTML文件，支持全文解析和全文搜索功能

进在开发中。。。。。。。。

　　7、微信公共帐号订制插件

进在开发中。。。。。。。。

　　8、待续.....

　　

 

分类: .Net