NHibernate 配置文件的处理和使用多数据库的多层架构思路(第一部分)

 

 开发环境： windows server 2003 sp2 + VS2005 + SQL Server 2005 + NHibernate-1.2.0.GA

(1) 配置文件的处理
        主要是谈NHibernate的配置文件的数据库连接字符串的加密处理方法.关于配置文件的设置, renrenqq 的文章《NHibernate的灵活配置》   讲的非常详细，大家可以看看！

        NHibernate的配置文件的代码部分可以放在程序的配置文件中(Win Forms的App.config,Web Forms 的Web.config)，然后使用企业库管理工具来加密，但是有个问题，该配置方式不能配置映射类，需要通过程序的方式加入，而且也造成应用程序配置文件信息过大！当然，你需要程序的方式加入，而且程序配置文件信息量的大小不是考虑的问题，无疑这个方法可用。

        但是，如果我需要在NHibernate的配置文件中配置映射类呢？就需要为之建一个名为hibernate.cfg.xml的文件。配置映射类的问题解决了！但是数据库连接字符串直接放在里面，没有被加密，很不安全。如果我们把NHibernate的配置文件作为资源嵌入到程序集，似乎可用解决安全问题，但是又出现新的问题，那就是部署。因为用户部署时，是需要重新设置数据库地址，名称，用户名，密码等值的。

        那么解决方案如下：

        在NHibernate的配置文件不加入数据库连接字符串，而仍旧把数据库连接字符串还是放在原来的程序的配置文件中，这样可以使用企业库管理工具来加密。然后在程序中，取出该值后用Configuration的方法AddProperties()加进去，就解决问题了。建议此时的NHibernate的配置文件还是采用资源嵌入到程序集的方式。(没有秘密也不想让你看见！)

        我再多说一个问题，然后我们可以通过对程序配置文件中字符串的增、删、改来完成多个数据库连接字符串的信息，然后再Configuration的方法AddProperties()，来加入需要的数据库连接字符串，就可以完成Hibernate的对多数据库的应用。可能实际的应用中可能需要配置映射类重新处理，或者说在NHibernate的配置文件中不加入配置映射类，然后通过Configuration的方法AddAssembly来加入。

这样就Game Over 了！

详细代码见下面！

呵呵，也许大家早就想到这个方法了，献丑了！

(2) 多层架构思路

一、底层

       包含三个类：

        首先是 Session 的创建类 SessionFactory，由它来提供各个数据库 Session 的创建，并缓存所有Session。每个数据库对应建一个项目的持久层，该项目的程序集名称就是可以来唯一标识各个Session。

    然后是实体的通用操作类，提供一些通用的操作，最基本CRUD，还有列出所有对象等等一些操作。它代替不了数据访问层，但是在数据访问层中使用它既方便，整体的结构也清晰。该类采用范型的理由是，得到的对象获得对象列表都是直接转换了的，不需要在数据访问层中再转换。但是这也意味在数据访问层中，操作每个实体时各个建一个该通用类的对象。权衡利弊，我认为采用采用范型是值得的！我们在后面的数据访问层中可以看到。

     由于是针对多个数据库操作，所以提供了这个类对外提供各个数据操作的各个通用实体对象！(有点拗口！)
在该类中，我们只举了操作一个数据库的例子，如果你看了代码，发现扩充到多个数据库也是非常简单的！但是，这里提醒以下，针对多个数据库的概念是多个数据库已经存在，不是动态创建的！因为动态创建数据库的话，那么持久层类和其配置文件也动态创建吗？或许有其它解决办法，但是本文不针对动态创建数据库。

        以下便是三个类的代码,里面有详细的注释：

// -----------------------------------------------------------------------------------------
//  模块编号：
//  文件名: SessionFactory.cs
//  描述: SessionFactory 类
//  作者：ChenJie 
//  编写日期：2007-5-11
//  Copyright 2007
// -----------------------------------------------------------------------------------------
using  System;
using  System.Collections;
using  System.Collections.Generic;
using  System.Reflection;
using  System.Data;
using  NHibernate;
using  NHibernate.Cfg;
using  NHibernate.Tool.hbm2ddl;

namespace  Novelty.CustomSystem.NHibernateOperation.NHibernateModule
{
    /**//// <summary>
    /// Session的创建类，属于单件模式（Singleton Pattern）
    /// </summary>
    public sealed class SessionFactory
    {
        私有变量#region 私有变量
        //保存所有Session
        private Dictionary<string, ISession> dicSessions = new Dictionary<string, ISession>(StringComparer.InvariantCultureIgnoreCase);
        #endregion

        构造函数#region 构造函数
        /**//// <summary>
        /// 构造函数
        /// </summary>
        SessionFactory()
        {            
        }
        #endregion

        嵌套类#region 嵌套类
        class Nested
        {
            static Nested()
            {
            }
            internal static readonly SessionFactory instance = new SessionFactory();
        }
        #endregion

        属性#region 属性
        /**//// <summary>
        /// 唯一实例
        /// </summary>
        public static SessionFactory Instance
        {
            get
            {
                return Nested.instance;
            }
        }
        #endregion

        实现方法#region 实现方法
        /**//// <summary>
        /// 通过 NHibernate 的配置文件(hibernate.cfg.xml)读取 NHibernate 配置信息。本例中采用的是将 NHibernate 的配置文件附加到该项目的程序集中。
        /// 该配置文件中不包含程序集名称，通过 cfg.AddAssembly(assemblyName); 语句来添加。
        /// 针对一个数据库就缓存了一个session， 本例中是通过程序集名称标识唯一的session。
        /// </summary>
        /// <param name="assemblyName">配置映射类的程序集名称</param>
        /// <param name="nhibernateConfigName">NHibernate 的配置文件名称</param>
        /// <param name="connectionString">数据路字符串连接</param>
        /// <returns>ISession</returns>
        public ISession OpenSession(string assemblyName, string nhibernateConfigName, string connectionString)
        {
            ISession session = null;
            if (string.IsNullOrEmpty(connectionString) || string.IsNullOrEmpty(nhibernateConfigName) || string.IsNullOrEmpty(connectionString))
            {
                return null;
            }
            //锁定 dicSessions 字典
            lock (dicSessions)
            {
                Configuration cfg = GetConfiguration(assemblyName, nhibernateConfigName, connectionString);
                if (dicSessions.ContainsKey(assemblyName))
                {
                    session = dicSessions[assemblyName];
                }
                else
                {                    
                    ISessionFactory sessions = cfg.BuildSessionFactory();
                    session = sessions.OpenSession();
                    dicSessions.Add(assemblyName, session);
                }
            }
            return session;
        }

        /**//// <summary>
        /// 获得 Configuration 对象
        /// </summary>
        /// <param name="assemblyName">配置映射类的程序集名称</param>
        /// <param name="nhibernateConfigName">NHibernate 的配置文件名称</param>
        /// <param name="connectionString">数据路字符串连接</param>
        /// <returns>Configuration 对象</returns>
        public Configuration GetConfiguration(string assemblyName, string nhibernateConfigName, string connectionString)
        {
            //复制到应用程序的 bin 目录下
            //Configuration cfg = new Configuration().Configure();                    
            //附加在程序集中
            Configuration cfg = new Configuration().Configure(Assembly.GetExecutingAssembly(), nhibernateConfigName);
            //添加程序集
            //如果程序集很大，将导致速度很慢！解决方案如下：
            //把该方法该为范型方法: public Configuration GetConfiguration<T>(string nhibernateConfigName, string connectionString)
            //然后在写一个方法添加类： (1)首先cfg.AddClass(typeof(T)); (2)将与T相关的类一并添加进去！(一对一,一对多或是多对多的类之间都是有关系的)
            if (!string.IsNullOrEmpty(assemblyName))
            {
                cfg.AddAssembly(assemblyName);
            }            
            if (!string.IsNullOrEmpty(connectionString))
            {
                Hashtable properties = new Hashtable();
                properties.Add(NHibernate.Cfg.Environment.ConnectionString, connectionString);
                cfg.AddProperties(properties);
            }
            return cfg;
        }
        #endregion
    }
}

 

// -----------------------------------------------------------------------------------------
//  模块编号：
//  文件名: EntityControl.cs
//  描述: EntityControl 实体类
//  作者：ChenJie 
//  编写日期：2007-5-11
//  Copyright 2007
// -----------------------------------------------------------------------------------------
using  System;
using  System.Reflection;
using  System.Collections;
using  System.Collections.Generic;
using  System.Text;
using  System.Data;
using  NHibernate;
using  NHibernate.Cfg;
using  NHibernate.Expression;
using  NHibernate.Engine;
using  NHibernate.SqlTypes;
using  NHibernate.SqlCommand;

namespace  Novelty.CustomSystem.NHibernateOperation.NHibernateModule
{
    /**//// <summary>
    /// 实体通用操作类
    /// </summary>
    public class EntityControl<T>
    {
        私有变量#region 私有变量
        private ISession session;
        #endregion

        内部成员变量#region 内部成员变量
        private string _assemblyName;
        private string _nhibernateConfigName;
        private string _connectionString;
        #endregion

        构造函数#region 构造函数
        /**//// <summary>
        /// 默认的构造函数
        /// </summary>
        public EntityControl()
        {            
        }

        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="assemblyName">程序集名称</param>
        /// <param name="nhibernateConfigName">NHibernate 的配置文件名称</param>
        /// <param name="connectionString">数据路字符串连接</param>
        public EntityControl(string assemblyName, string nhibernateConfigName, string connectionString)
        {
            session = SessionFactory.Instance.OpenSession(assemblyName, nhibernateConfigName, connectionString);
            _assemblyName = assemblyName;
            _nhibernateConfigName = nhibernateConfigName;
            _connectionString = connectionString;
        }
        #endregion

        属性#region 属性
        /**//// <summary>
        /// 程序集名称
        /// </summary>
        public string AssemblyName
        {
            get
            {
                return _assemblyName;
            }
            set
            {
                if (_assemblyName == value)
                    return;
                _assemblyName = value;
            }
        }

        /**//// <summary>
        /// NHibernate 的配置文件名称
        /// </summary>
        public string NhibernateConfigName
        {
            get
            {
                return _nhibernateConfigName;
            }
            set
            {
                if (_nhibernateConfigName == value)
                    return;
                _nhibernateConfigName = value;
            }
        }

        /**//// <summary>
        /// 数据路字符串连接
        /// </summary>
        public string ConnectionString
        {
            get
            {
                return _connectionString;
            }
            set
            {
                if (_connectionString == value)
                    return;
                _connectionString = value;
            }
        }
        #endregion

        方法#region 方法       
        /**//// <summary>
        /// 增加实体对象
        /// </summary>
        /// <param name="entity">实体对象</param>
        public void AddEntity(T entity)
        {            
            using (ITransaction transaction = session.BeginTransaction())
            {
                try
                {
                    session.Save(entity);
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    //记录日志, 抛出异常, 不包装异常 
                    ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
                }
            }
        }

        /**//// <summary>
        /// 更新实体对象
        /// </summary>
        /// <param name="entity">实体对象</param>
        /// <param name="key">关键字</param>
        public void UpdateEntity(T entity, Object key)
        {            
            using (ITransaction transaction = session.BeginTransaction())
            {
                try
                {
                    session.Update(entity, key);
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    //记录日志, 抛出异常, 不包装异常 
                    ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
                }
            }
        }

        /**//// <summary>
        /// 删除实体对象
        /// </summary>
        /// <param name="entity">实体对象</param>
        public void DeleteEntity(T entity)
        {            
            using (ITransaction transaction = session.BeginTransaction())
            {
                try
                {
                    session.Delete(entity);
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    //记录日志, 抛出异常, 不包装异常 
                    ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
                }
            }
        }

        /**//// <summary>
        /// 获得实体对象
        /// </summary>
        /// <param name="key">关键字</param>
        /// <returns></returns>
        public T GetEntity(Object key)
        {
            T entity = default(T);            
            try
            {
                entity = session.Load<T>(key);
            }
            catch (Exception ex)
            {
                //记录日志, 抛出异常, 不包装异常 
                ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
            }
            return entity;
        }


        /**//// <summary>
        /// 获得首行首列的值，类似执行 ExecuteScalar
        /// 查询结果一般只有一条
        /// 举例：hql = "SELECT MAX(systemLog.SystemLogId) FROM SystemLogInfo AS systemLog";
        /// </summary>
        /// <typeparam name="Y">类型</typeparam>
        /// <param name="hql">NHibernate 查询语句</param>
        /// <param name="defaultVale">默认值</param>
        /// <returns></returns>
        public Y GetDataFieldValue<Y>(string hql, Y defaultVale)
        {
            Y dataFieldValue = defaultVale;            
            try
            {
                IQuery query = session.CreateQuery(hql);
                IEnumerator<Y> itor = query.Enumerable<Y>().GetEnumerator();
                itor.MoveNext();
                try
                {
                    dataFieldValue = itor.Current;
                }
                catch { }
            }
            catch (Exception ex)
            {
                //记录日志, 抛出异常, 不包装异常 
                ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
            }
            return dataFieldValue;
        }

        /**//// <summary>
        /// 获得实体的数目
        /// </summary>
        /// <param name="entityName">实体名称</param>
        /// <returns>实体的数目</returns>
        public int GetCountOfEntities(string entityName)
        {
            int count = 0;
            StringBuilder sb = new StringBuilder();
            sb.Append("SELECT COUNT(*) FROM ");
            sb.Append(entityName);            
            try
            {
                IQuery query = session.CreateQuery(sb.ToString());
                IEnumerator itor = query.Enumerable().GetEnumerator();
                itor.MoveNext();
                count = Convert.ToInt32(itor.Current);
            }
            catch (Exception ex)
            {
                //记录日志, 抛出异常, 不包装异常 
                ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
            }
            return count;
        }

        /**//// <summary>
        /// 获得所有的实体对象列表
        /// </summary>
        /// <returns>对象列表</returns>
        public IList<T> GetEntities()
        {
            IList<T> entities = null;            
            try
            {
                entities = session.CreateCriteria(typeof(T)).List<T>();
            }
            catch (Exception ex)
            {
                //记录日志, 抛出异常, 不包装异常 
                ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
            }
            return entities;
        }

        /**//// <summary>
        /// 通过条件获得实体对象列表
        /// </summary>
        /// <param name="propertyName">属性</param>
        /// <param name="value">属性值</param>
        /// <returns>对象列表</returns>
        public IList<T> GetEntities(string propertyName, object value)
        {
            IList<T> entities = null;            
            try
            {
                ICriteria criteria = session.CreateCriteria(typeof(T));
                criteria.Add(Expression.Eq(propertyName, value));
                entities = criteria.List<T>();
            }
            catch (Exception ex)
            {
                //记录日志, 抛出异常, 不包装异常 
                ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
            }
            return entities;
        }

        /**//// <summary>
        /// 执行 SQL 语句并返回对象列表
        /// 这个方法不能用，原因有二：
        /// 一、这里NH的地盘，下面两个方法能完成这个功能。
        /// 二、对于一对多的情况，反射的对象有问题，因为无法处理处理构造函数。
        /// 这个方法放在这里是为了开阔一下思路。比如说，需要批量删除。当然，这个又涉及到参数的问题了！
        /// 我不喜欢直接将参数拼到 sql 语句中，而是采用后来加载的方式！
        /// </summary>
        /// <param name="sql">SQL 语句</param>
        /// <returns>查询的结果列表</returns>
        [Obsolete("Do not call this method.")]
        public IList<T> GetEntitiesByExecuteSQL(string sql)
        {
            IList<T> entities = new List<T>();
            Configuration cfg = SessionFactory.Instance.GetConfiguration(_assemblyName, _nhibernateConfigName, _connectionString);
            try
            {
                using (ISessionFactoryImplementor s = (ISessionFactoryImplementor)cfg.BuildSessionFactory())
                {
                    using (IDbConnection conn = s.OpenConnection())
                    {
                        IDbCommand cmd = conn.CreateCommand();
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = sql;
                        using (IDataReader dr = cmd.ExecuteReader())
                        {
                            int fieldCount = 0;
                            object[] values = null;
                            while (dr.Read())
                            {
                                if (fieldCount == 0)
                                {
                                    fieldCount = dr.FieldCount;
                                    values = new Object[fieldCount];
                                }
                                for (int i = 0; i < fieldCount; i++)
                                {
                                    values[i] = dr.GetValue(i);
                                }
                                Type t = typeof(T);
                                T obj = (T)Activator.CreateInstance(t, values);
                                entities.Add(obj);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                //记录日志, 抛出异常, 不包装异常 
                ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
            }
            return entities;
        }

        /**//// <summary>
        /// 执行 sql 语句查询获得实体对象列表  
        /// 举例：
        /// sql = "SELECT * FROM SystemLog";
        /// 注意：FROM 后是表的名称
        /// /// </summary>
        /// <param name="sql">sql 查询语句</param>
        /// <returns>对象列表</returns>
        public IList<T> GetEntitiesBySQL(string sql)
        {
            IList<T> entities = null;            
            try
            {
                entities = session.CreateSQLQuery(sql).AddEntity(typeof(T)).List<T>();
            }
            catch (Exception ex)
            {
                //记录日志, 抛出异常, 不包装异常 
                ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
            }
            return entities;
        }

        /**//// <summary>
        /// 通过 NHibernate 查询语句获得实体对象列表
        /// 举例：hql = "FROM SystemLogInfo WHERE UserSerial =1";     
        /// 注意：FROM 后是实体的名称
        /// </summary>
        /// <param name="hql">NHibernate 查询语句</param>
        /// <returns></returns>
        public IList<T> GetEntitiesByHQL(string hql)
        {
            IList<T> entities = null;            
            try
            {
                entities = session.CreateQuery(hql).List<T>();
            }
            catch (Exception ex)
            {
                //记录日志, 抛出异常, 不包装异常 
                ExceptionFacade.LogAndThrowAndNoWrapPolicy(ex);
            }
            return entities;
        }

        /**//// <summary>
        /// 将Ilist<T> 转换成 DataSet
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public DataSet ConvertToDataSet(IList<T> list)
        {
            if (list == null || list.Count <= 0)
            {
                return null;
            }
            DataSet ds = new DataSet();
            DataTable dt = new DataTable(typeof(T).Name);
            DataColumn column;
            DataRow row;
            PropertyInfo[] myPropertyInfo = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (T t in list)
            {
                if (t == null)
                {
                    continue;
                }
                row = dt.NewRow();
                for (int i = 0, j = myPropertyInfo.Length; i < j; i++)
                {
                    PropertyInfo pi = myPropertyInfo[i];
                    string name = pi.Name;                    
                    if (dt.Columns[name] == null)
                    {
                        column = new DataColumn(name, pi.PropertyType);
                        dt.Columns.Add(column);
                    }
                    row[name] = pi.GetValue(t, null);
                }
                dt.Rows.Add(row);
            }
            ds.Tables.Add(dt);
            return ds;
        }

        #endregion
    }
}

 

// -----------------------------------------------------------------------------------------
//  模块编号：
//  文件名: CommonDatabaseOperation.cs
//  描述: CommonDatabaseOperation实体类
//  作者：ChenJie 
//  编写日期：2007-5-11
//  Copyright 2007
// -----------------------------------------------------------------------------------------
using  System;
using  System.Collections.Generic;
using  System.Configuration;
using  Microsoft.Practices.EnterpriseLibrary.Common.Configuration;
using  Microsoft.Practices.EnterpriseLibrary.Data;
using  Microsoft.Practices.EnterpriseLibrary.Data.Configuration;
using  Novelty.CustomSystem.NHibernateOperation.NHibernateModule;

namespace  Novelty.CustomSystem.NHibernateOperation
{
    /**//// <summary>
    /// 提供各个实体的类
    /// </summary>
    public class CommonDatabaseOperation<T>
    {
        常量#region 常量
        <summary>
        /**//// 默认的数据库标识符
        /// </summary>
        private const string DEFAULT_DATABASE_IDENTIFIER = "SystemDatabase";

        /**//// <summary>
        /// 配置映射类的程序集名称
        /// </summary>
        private const string ASSESMBLY_NAME = "Novelty.Model";   

        /**//// <summary>
        /// NHibernate 的配置文件名称
        /// </summary>
        private const string NHIBERNATE_CONFIG_NAME = "Novelty.CustomSystem.NHibernateOperation.hibernate.cfg.xml";

        /**//// <summary>
        /// 数据路字符串连接
        /// </summary>
        private readonly string connectionString;        
        #endregion

         构造函数#region 构造函数
        /**//// <summary>
        /// 构造函数
        /// </summary>
        CommonDatabaseOperation()
        {   
            SystemConfigurationSource systemConfigurationSource = new SystemConfigurationSource();
            DatabaseConfigurationView databaseConfigurationView = new DatabaseConfigurationView(systemConfigurationSource);
            ConnectionStringSettings connectionStringSettings = databaseConfigurationView.GetConnectionStringSettings(databaseConfigurationView.DefaultName);
            connectionString = connectionStringSettings.ConnectionString;
        }
        #endregion

        嵌套类#region 嵌套类
        class Nested
        {
            static Nested()
            {
            }
            internal static readonly CommonDatabaseOperation<T> instance = new CommonDatabaseOperation<T>();
        }
        #endregion

        属性#region 属性
         /**//// <summary>
        /// 唯一实例
        /// </summary>
        public static CommonDatabaseOperation<T> Instance
        {
            get
            {
                return Nested.instance;
            }
        }
        #endregion

        实现方法#region 实现方法
        /**//// <summary>
        /// 获得 EntityControl 对象。
        /// 如果有多个数据库，就有多个对象。
        /// 通过实现约定的 name 来读取。
        /// 该方法仅实现了一个例子，可以扩展成多个例子。
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public EntityControl<T> GetEntityControl(string name)
        {
            EntityControl<T> entityControl = null;
            if (string.IsNullOrEmpty(name))
            {
                return null;
            }
            switch (name)
            {
                case DEFAULT_DATABASE_IDENTIFIER:
                    entityControl = new EntityControl<T>(ASSESMBLY_NAME, NHIBERNATE_CONFIG_NAME, connectionString);
                    break;
                default:
                    break;
            }
            return entityControl;
        }
        #endregion

    }
}

NHibernate 配置文件的处理和使用多数据库的多层架构思路(第二部分)
http://www.cnblogs.com/scucj/archive/2007/05/15/747695.html
NHibernate 配置文件的处理和使用多数据库的多层架构思路(第三部分)
http://www.cnblogs.com/scucj/archive/2007/05/15/747698.html
 

转载于:https://www.cnblogs.com/scucj/archive/2007/05/15/747688.html