返回列表
发布日期: 2008-11-30 发布者: cobra 中文编程图书最低价热卖  English Programming Books 1#
在spring.net中集成nHibernate可以获得许多值得称道的特性。比如：基于元标记(meta Attributes)的事务支持、对物理数据库的抽象、对数据层进行切面式拦截。

　　好处是不少，但首先要学会配置。为了这个集成的环境，建立一个配置文件 applicationContext.xml :
  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <objects xmlns="http://www.springframework.net"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xsi:schemaLocation="http://www.springframework.net [url]http://www.springframework.net/xsd/spring-objects.xsd[/url]"
  5. >
  6.   <!--spring集合nHibernate-->
  7.   <object id="DbProvider" type="woodigg.DAO.SQLProvider,woodigg.DAO">
  8.     <property name="ConnectionString"
  9.           value="Server=(local);database=Music;User Id=sa;Password=******;Trusted_Connection=False" />
  10.   </object>

  12.   <!--session工厂-->
  13.   <object id="SessionFactory"
  14.           type="Spring.Data.NHibernate.LocalSessionFactoryObject, Spring.Data.NHibernate12">
  15.     <property name="DbProvider" ref="DbProvider" />
  16.     <property name="MappingAssemblies">
  17.       <list>
  18.         <value>woodigg.DAO</value>
  19.         <value>woodigg.model</value>
  20.       </list>
  21.     </property>
  22.     <property name="HibernateProperties">
  23.       <dictionary>
  24.         <entry key="hibernate.connection.provider" value="NHibernate.Connection.DriverConnectionProvider" />
  25.         <entry key="hibernate.dialect" value="NHibernate.Dialect.MsSql2000Dialect" />
  26.         <entry key="hibernate.connection.driver_class" value="NHibernate.Driver.SqlClientDriver" />
  27.         <entry key="show_sql" value="false" />
  28.         <entry key="hibernate.current_session_context_class" value="Spring.Data.NHibernate.SpringSessionContext, Spring.Data.NHibernate12"/>
  29.         <entry key="hibernate.query.factory_class" value="NHibernate.Hql.Classic.ClassicQueryTranslatorFactory" />
  30.         <entry key="hibernate.cache.provider_class" value="NHibernate.Caches.SysCache.SysCacheProvider, NHibernate.Caches.SysCache" />
  31.         <entry key="relativeExpiration" value="5" />
  32.       </dictionary>
  33.     </property>
  34.   </object>
  35.   <!--事务管理器-->
  36.   <object id="HibernateTransactionManager"
  37.           type="Spring.Data.NHibernate.HibernateTransactionManager, Spring.Data.NHibernate12">
  38.     <property name="DbProvider" ref="DbProvider" />
  39.     <property name="SessionFactory" ref="SessionFactory" />
  40.   </object>
  41.   <!--事务拦截器-->
  42.   <object id="TransactionInterceptor"
  43.           type="Spring.Transaction.Interceptor.TransactionInterceptor, Spring.Data">
  44.     <property name="TransactionManager" ref="HibernateTransactionManager" />
  45.     <property name="TransactionAttributeSource">
  46.       <object type="Spring.Transaction.Interceptor.AttributesTransactionAttributeSource, Spring.Data" />
  47.     </property>
  48.   </object>
  49.   <!--HibernateTemplate-->
  50.   <object id="HibernateTemplate"
  51.           type="Spring.Data.NHibernate.HibernateTemplate,Spring.Data.NHibernate12">
  52.     <property name="SessionFactory" ref="SessionFactory" />
  53.   </object>
  54.   <!--Dao代理模板-->
  55.   <object id="DaoTemplate" type="woodigg.DAO.DaoTemplate, woodigg.DAO">
  56.     <property name="SessionFactory" ref="SessionFactory" />
  57.   </object>
  58.  
  59. </objects>
复制代码
ＯＫ，这里有几处需要说明：
　　一、woodigg.DAO.SQLProvider　是一个数据结构类，用以描述物理数据库的相关信息，诸如连接串、元数据信息等。这里其实就用到了连接串，在配置中植入位置、帐号信息等就能连接到数据源。这个SQLProvider类结构如下：
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Data;
  5. using Spring.Data.Common;

  7. namespace woodigg.DAO
  8. {
  9.     public class SQLProvider : IDbProvider
  10.     {
  11.         #region IDbProvider 成员
  12.         private string _connectionString = "";
  13.         public string ConnectionString
  14.         {
  15.             get
  16.             {
  17.                 return this._connectionString;
  18.             }
  19.             set
  20.             {
  21.                 this._connectionString = value;
  22.             }
  23.         }

  25.         public IDbCommand CreateCommand()
  26.         {
  27.             return null;
  28.         }

  30.         public object CreateCommandBuilder()
  31.         {
  32.             return null;
  33.         }

  35.         public IDbConnection CreateConnection()
  36.         {
  37.             return null;
  38.         }

  40.         public IDbDataAdapter CreateDataAdapter()
  41.         {
  42.             return null;
  43.         }

  45.         public IDbDataParameter CreateParameter()
  46.         {
  47.             return null;
  48.         }

  50.         public string CreateParameterName(string name)
  51.         {
  52.             return null;
  53.         }

  55.         public string CreateParameterNameForCollection(string name)
  56.         {
  57.             return null;
  58.         }

  60.         public IDbMetadata DbMetadata
  61.         {
  62.             get
  63.             {
  64.                 return null;
  65.             }
  66.         }

  68.         public string ExtractError(Exception e)
  69.         {
  70.             return null;
  71.         }

  73.         public bool IsDataAccessException(Exception e)
  74.         {
  75.             return false;
  76.         }

  78.         #endregion
  79.     }

  81. }
复制代码
二、在SessionFactory配置中，指明需要环境映射的程序集名称，通俗说法是：哪些层会在集成环境中，被直接引用？这里以示例项目来说是：woodigg.DAO和woodigg.Model，分别为实体（上一节中生成的一堆.cs实体）层，和数据映射文件（被嵌入在项目中的hbm.xml文件）所在的数据访问层。

　　三、HibernateProperties节中，可以指定调试时是否显示生成的sql语句。同时，能配置缓存事宜：此处用到的是NHibernate.Caches.SysCache。

　　四、配置HibernateTemplate。nHibernate的模板，既nHibernate项目已经为开发者写好了一套通用的方法，能便捷的操作数据库，此处将SessionFactory植入引用即能让它工作起来。（并不是所有的复杂SQL，它都能做到，不能完成的功能，我们得自己写，这个马上会交待）。

　　五、DaoTemplate，就是我自己写的一个基于以上配置的复杂模板，能完成诸如Distinct，top，调用分页存储过程等一干复杂SQL功能，抛出来做点贡献吧：
  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Text;
  5. using System.Data;
  6. using NHibernate;
  7. using NHibernate.Cfg;
  8. using NHibernate.Engine;
  9. using NHibernate.Expression;
  10. using Spring.Dao;
  11. using Spring.Data.NHibernate.Support;
  12. using woodigg.model;
  13. using log4net;

  15. namespace woodigg.DAO
  16. {
  17.     #region ParamInfo结构
  18.     public struct ParamInfo
  19.     {
  20.         public string Name;
  21.         public object Value;
  22.     }
  23.     #endregion

  25.     /// <summary>
  26.     /// 继续自HibernateDaoSupport抽象类
  27.     /// HibernateDaoSupport基类拥有HibernateTemplate
  28.     /// </summary>
  29.     public class DaoTemplate : HibernateDaoSupport
  30.     {       
  31.         /// <summary>
  32.         /// 泛型读取
  33.         /// </summary>
  34.         /// <param name="obj"></param>
  35.         /// <param name="id"></param>
  36.         #region T LoadFromId<T>(object id)
  37.         public T LoadFromId<T>(object id)
  38.         {
  39.             try
  40.             {               
  41.                 T obj =
  42.                     (T)HibernateTemplate.Load(typeof(T), id);
  43.                 return obj;
  44.             }
  45.             catch (Exception ex)
  46.             {
  47.                 ILog log = LogManager.GetLogger(typeof(T));
  48.                 log.Error(ex.Message, ex);
  49.                 return default(T);
  50.             }
  51.         }
  52.         #endregion

  54.         /// <summary>
  55.         /// 泛型存储
  56.         /// </summary>
  57.         /// <typeparam name="T"></typeparam>
  58.         /// <param name="obj"></param>
  59.         #region bool Save<T>(T obj)
  60.         public bool Save<T>(T obj)
  61.         {
  62.             try
  63.             {
  64.                 HibernateTemplate.Save(obj);
  65.                 return true;
  66.             }
  67.             catch (DataAccessException ex)
  68.             {
  69.                 ILog log = LogManager.GetLogger(typeof(T));
  70.                 log.Error(ex.Message, ex);
  71.                 return false;
  72.             }
  73.         }
  74.         #endregion

  76.         /// <summary>
  77.         /// 泛型更新
  78.         /// </summary>
  79.         /// <typeparam name="T"></typeparam>
  80.         /// <param name="obj"></param>
  81.         #region bool Update<T>(T obj)
  82.         public bool Update<T>(T obj)
  83.         {
  84.             try
  85.             {
  86.                 HibernateTemplate.Update(obj);
  87.                 return true;
  88.             }
  89.             catch (DataAccessException ex)
  90.             {
  91.                 ILog log = LogManager.GetLogger(typeof(T));
  92.                 log.Error(ex.Message, ex);
  93.                 return false;
  94.             }
  95.         }
  96.         #endregion

  98.         /// <summary>
  99.         /// 泛型删除
  100.         /// </summary>
  101.         /// <typeparam name="T"></typeparam>
  102.         /// <param name="obj"></param>
  103.         #region bool Delete<T>(T obj)
  104.         public bool Delete<T>(T obj)
  105.         {
  106.             try
  107.             {
  108.                 HibernateTemplate.Delete(obj);
  109.                 return true;
  110.             }
  111.             catch (DataAccessException ex)
  112.             {
  113.                 ILog log = LogManager.GetLogger(typeof(T));
  114.                 log.Error(ex.Message, ex);
  115.                 return false;
  116.             }
  117.         }
  118.         #endregion

  120.         /// <summary>
  121.         /// 条件删除
  122.         /// </summary>
  123.         /// <typeparam name="T"></typeparam>
  124.         /// <param name="where"></param>
  125.         #region bool Delete<T>(string where)
  126.         public bool Delete<T>(string where)
  127.         {
  128.             try
  129.             {
  130.                 string sql =string.Format("from {0} {1}",
  131.                     typeof(T).ToString(),
  132.                     where.ToUpper().StartsWith("WHERE") ? where : "WHERE " + where);
  133.                 HibernateTemplate.Delete(sql);
  134.                 return true;
  135.             }
  136.             catch (DataAccessException ex)
  137.             {
  138.                 ILog log = LogManager.GetLogger(typeof(T));
  139.                 log.Error(ex.Message, ex);
  140.                 return false;
  141.             }
  142.         }
  143.         #endregion

  145.         /// <summary>
  146.         /// 泛型搜索
  147.         /// </summary>
  148.         /// <typeparam name="T"></typeparam>
  149.         /// <param name="where"></param>
  150.         #region IList<T> Search<T>(string where)
  151.         public IList<T> Search<T>(string where)
  152.         {
  153.             try
  154.             {
  155.                 //有意思的模板反射哟~
  156.                 T obj = (T)System.Reflection.Assembly.GetAssembly(typeof(T)).CreateInstance(typeof(T).ToString());

  158.                 string hql = string.Format("from {0} {1}",
  159.                     obj.GetType().ToString(),
  160.                     where.ToUpper().StartsWith("WHERE") ? where : "WHERE " + where);

  162.                 IList alist =  HibernateTemplate.Find(hql);

  164.                 IList<T> list = new List<T>();
  165.                 if (alist != null && alist.Count > 0)
  166.                 {
  167.                     foreach (T t in alist)
  168.                     { list.Add(t); }
  169.                     return list;
  170.                 }
  171.                 else
  172.                     return null;
  173.                
  174.             }
  175.             catch (Exception ex)
  176.             {
  177.                 ILog log = LogManager.GetLogger(typeof(T));
  178.                 log.Error(ex.Message, ex);
  179.                 return null;
  180.             }
  181.         }
  182.         #endregion

  184.         /// <summary>
  185.         /// 泛型搜索 - DISTINCT
  186.         /// </summary>
  187.         /// <typeparam name="T"></typeparam>
  188.         /// <param name="field">列名，用","分开，不带别名</param>
  189.         /// <param name="where"></param>
  190.         /// <param name="alias">别名</param>
  191.         #region IList<T> SearchDistinct<T>(string where,string field,string alias)
  192.         public IList<T> SearchDistinct<T>(string where, string field, string alias)
  193.         {
  194.             try
  195.             {
  196.                 //有意思的模板反射哟~
  197.                 T obj = (T)System.Reflection.Assembly.GetAssembly(typeof(T)).CreateInstance(typeof(T).ToString());
  198.                 // 反射DTO对象的各字段,必须把字段和DB中字段同名
  199.                 System.Reflection.PropertyInfo[] pps = obj.GetType().GetProperties();

  201.                 //拆分成别名+列名
  202.                 string[] cols = field.Split(',');
  203.                 string columns = string.Empty;
  204.                 foreach (string col in cols)
  205.                     columns += string.Format("{0}.{1},", alias, col);
  206.                 columns = columns.TrimEnd(',');

  208.                 //hql
  209.                 string hql = string.Format("select distinct {2} from {0} {3} {1}",
  210.                     obj.GetType().ToString(),
  211.                     where.ToUpper().StartsWith("WHERE") ? where : "WHERE " + where
  212.                     , columns
  213.                     , alias);

  215.                 IList alist = HibernateTemplate.Find(hql);

  217.                 IList<T> list = new List<T>();
  218.                 if (alist != null && alist.Count > 0)
  219.                 {
  220.                     //是否为数组
  221.                     bool isArray = (cols.Length == 1 ? false : true);

  223.                     foreach (object arr in alist)
  224.                     {
  225.                         //产生一个类实例
  226.                         T t = (T)System.Reflection.Assembly.GetAssembly(typeof(T)).CreateInstance(typeof(T).ToString());


  229.                         for (int i = 0; i < cols.Length; i++)
  230.                         {
  231.                             //逐字段检查名称
  232.                             foreach (System.Reflection.PropertyInfo pi in pps)
  233.                             {
  234.                                 if(pi.Name.Equals(cols))
  235.                                 {
  236.                                     //数组与object对象
  237.                                     pi.SetValue(t, (isArray ? (arr as object[]) : arr), null);
  238.                                 }
  239.                             }
  240.                         }                     

  242.                         list.Add(t);
  243.                     }

  245.                     return list;
  246.                 }
  247.                 else
  248.                     return null;

  250.             }
  251.             catch (Exception ex)
  252.             {
  253.                 ILog log = LogManager.GetLogger(typeof(T));
  254.                 log.Error(ex.Message, ex);
  255.                 return null;
  256.             }
  257.         }
  258.         #endregion

  260.         /// <summary>
  261.         /// 基于表达式的排序查询
  262.         /// </summary>
  263.         /// <typeparam name="T"></typeparam>
  264.         /// <param name="where"></param>
  265.         /// <param name="propertyName"></param>
  266.         /// <param name="ascending"></param>
  267.         #region IList<T> SearchWithOrder<T>(string where, string propertyName, bool ascending)
  268.         public IList<T> SearchWithOrder<T>(string where, string propertyName, bool ascending)
  269.         {
  270.             try
  271.             {
  272.                 //排序
  273.                 Order order = new Order(propertyName, ascending);
  274.                 //排序
  275.                 ICriteria ic = Session.CreateCriteria(typeof(T));
  276.                 ic.AddOrder(order);
  277.                 //表达式
  278.                 ICriterion exp = Expression.Sql(where);
  279.                 ic.Add(exp);

  281.                 return ic.List<T>();
  282.             }
  283.             catch (Exception ex)
  284.             {
  285.                 ILog log = LogManager.GetLogger(typeof(T));
  286.                 log.Error(ex.Message, ex);
  287.                 return null;
  288.             }
  289.         }
  290.         #endregion

  292.         /// <summary>
  293.         /// 执行存储过程(返回bool)
  294.         /// </summary>
  295.         /// <param name="spName">名称</param>
  296.         /// <param name="paramInfos">参数表</param>
  297.         #region bool ExecuteStoredProc2(string spName, ICollection paramInfos)
  298.         public bool ExecuteStoredProc2(string spName, ICollection paramInfos)
  299.         {
  300.             bool result = true;

  302.             IDbCommand cmd = Session.Connection.CreateCommand();

  304.             cmd.CommandText = spName;
  305.             cmd.CommandType = CommandType.StoredProcedure;

  307.             // 加入参数
  308.             if (paramInfos != null)
  309.             {
  310.                 foreach (ParamInfo info in paramInfos)
  311.                 {
  312.                     IDbDataParameter parameter = cmd.CreateParameter();
  313.                     parameter.ParameterName = info.Name; // driver.FormatNameForSql( info.Name );
  314.                     parameter.Value = info.Value;
  315.                     cmd.Parameters.Add(parameter);
  316.                 }
  317.             }

  319.             IDbConnection conn = Session.Connection;
  320.             if(conn.State == ConnectionState.Closed)
  321.                 conn.Open();
  322.             try
  323.             {
  324.                 cmd.Connection = conn;
  325.                 IDataReader rs = cmd.ExecuteReader();
  326.                 result = true;
  327.             }
  328.             catch (Exception ex)
  329.             {
  330.                 ILog log = LogManager.GetLogger(typeof(DaoTemplate));
  331.                 log.Error(ex.Message, ex);
  332.                 result = false;
  333.             }
  334.             finally
  335.             {
  336.                 Session.Connection.Close();
  337.             }

  339.             return result;
  340.         }
  341.         #endregion

  343.         /// <summary>
  344.         /// 执行存储过程(返回ILIST)
  345.         /// </summary>
  346.         /// <param name="spName">名称</param>
  347.         /// <param name="paramInfos">参数表</param>
  348.         #region IList ExecuteStoredProc(string spName, ICollection paramInfos)
  349.         public IList ExecuteStoredProc(string spName, ICollection paramInfos)
  350.         {
  351.             IList result = new ArrayList();

  353.             IDbCommand cmd = Session.Connection.CreateCommand();               

  355.             cmd.CommandText = spName;
  356.             cmd.CommandType = CommandType.StoredProcedure;           

  358.             // 加入参数
  359.             if (paramInfos != null)
  360.             {
  361.                 foreach (ParamInfo info in paramInfos)
  362.                 {
  363.                     IDbDataParameter parameter = cmd.CreateParameter();
  364.                     parameter.ParameterName = info.Name; // driver.FormatNameForSql( info.Name );
  365.                     parameter.Value = info.Value;
  366.                     cmd.Parameters.Add(parameter);
  367.                 }
  368.             }

  370.             IDbConnection conn = Session.Connection;
  371.             conn.Open();
  372.             try
  373.             {
  374.                 cmd.Connection = conn;
  375.                 IDataReader rs = cmd.ExecuteReader();

  377.                 while (rs.Read())
  378.                 {
  379.                     int fieldCount = rs.FieldCount;
  380.                     object[] values = new Object[fieldCount];
  381.                     for (int i = 0; i < fieldCount; i++)
  382.                         values = rs.GetValue(i);
  383.                     result.Add(values);
  384.                 }
  385.             }
  386.             finally
  387.             {
  388.                 Session.Connection.Close();
  389.             }

  391.             return result;
  392.         }
  393.         #endregion

  395.         /// <summary>
  396.         /// 获取记录数
  397.         /// </summary>
  398.         /// <typeparam name="T"></typeparam>
  399.         /// <returns></returns>
  400.         #region  int GetRecordCount<T>(string where)
  401.         public int GetRecordCount<T>(string where)
  402.         {
  403.             return GetRecordCount<T>(where, "*");
  404.         }
  405.         #endregion

  407.         /// <summary>
  408.         /// 获取记录数
  409.         /// </summary>
  410.         /// <typeparam name="T"></typeparam>
  411.         /// <returns></returns>
  412.         #region  int GetRecordCount<T>(string where,string cols)
  413.         public int GetRecordCount<T>(string where,string cols)
  414.         {
  415.             try
  416.             {
  417.                 //DISTINCT统计
  418.                 bool distinct = false;
  419.                 if (cols.ToLower().StartsWith("distinct"))
  420.                 {
  421.                     distinct = true;
  422.                     string[] columns = cols.Replace("distinct", "").Split(',');
  423.                     StringBuilder sb = new StringBuilder();
  424.                     sb.Append("distinct ");
  425.                     for (int i = 0; i < columns.Length; i++)
  426.                         sb.Append("alia." + columns.Trim());
  427.                     cols = sb.ToString().TrimEnd(',');
  428.                 }

  430.                 T obj = (T)System.Reflection.Assembly.GetAssembly(typeof(T)).CreateInstance(typeof(T).ToString());
  431.                 string hql = "";
  432.                 if (where.Trim() == String.Empty)
  433.                 {
  434.                     hql = string.Format("select count({1}) from {0} {2}",
  435.                         obj.GetType().ToString(),cols
  436.                         ,(distinct ? "alia":"")
  437.                         );
  438.                 }
  439.                 else
  440.                 {
  441.                     hql = string.Format("select count({2}) from {0} {3} {1}",
  442.                         obj.GetType().ToString(),
  443.                         where.ToUpper().StartsWith("WHERE") ? where : "WHERE " + where
  444.                         , cols, (distinct ? "alia" : ""));
  445.                 }

  447.                 IQuery query = Session.CreateQuery(hql);               
  448.                 object o = query.UniqueResult();
  449.                 return int.Parse(o.ToString());
  450.             }
  451.             catch (Exception ex)
  452.             {
  453.                 ILog log = LogManager.GetLogger(typeof(T));
  454.                 log.Error(ex.Message, ex);
  455.                 return 0;
  456.             }
  457.             finally
  458.             {
  459.                 Session.Close();
  460.             }
  461.         }
  462.         #endregion

  464.         /// <summary>
  465.         /// 获取记录数（全文检索）
  466.         /// </summary>
  467.         /// <typeparam name="T"></typeparam>
  468.         /// <returns></returns>
  469.         #region int GetRecordCount4Fulltext<T>(string where,string tbName)
  470.         public int GetRecordCount4Fulltext<T>(string where, string tbName)
  471.         {
  472.             try
  473.             {
  474.                 string hql = string.Format("select count(*) as CountNum from {0} {1}",
  475.                         tbName,
  476.                         where.ToUpper().StartsWith("WHERE") ? where : "WHERE " + where);

  478.                 IQuery query = Session.CreateSQLQuery(hql)
  479.                     .AddScalar("CountNum", NHibernateUtil.Int32);
  480.                 object o = query.UniqueResult();
  481.                 return int.Parse(o.ToString());
  482.             }
  483.             catch (Exception ex)
  484.             {
  485.                 ILog log = LogManager.GetLogger(typeof(T));
  486.                 log.Error(ex.Message, ex);
  487.                 return 0;
  488.             }
  489.             finally
  490.             {
  491.                 Session.Close();
  492.             }
  493.         }
  494.         #endregion

  496.         /// <summary>
  497.         ///  通过where条件查询获取分页数据
  498.         /// </summary>
  499.         /// <typeparam name="T"></typeparam>
  500.         /// <param name="where"></param>
  501.         /// <param name="varQuerysort">排序</param>
  502.         /// <param name="Start"></param>
  503.         /// <param name="Max"></param>
  504.         /// <returns></returns>
  505.         #region  IList<T> GetPageEntites<T>(string where,string varQuerysort, int Start, int Max)
  506.         public IList<T> GetPageEntites<T>(string where, string varQuerysort, int Start, int Max)
  507.         {
  508.             try
  509.             {
  510.                 T obj = (T)System.Reflection.Assembly.GetAssembly(typeof(T)).CreateInstance(typeof(T).ToString());
  511.                 string hql = "";
  512.                 if (where.Trim() == String.Empty)
  513.                 {
  514.                     hql = string.Format("from {0}",
  515.                         obj.GetType().ToString());
  516.                 }
  517.                 else
  518.                 {
  519.                     hql = string.Format("from {0} {1}",
  520.                         obj.GetType().ToString(),
  521.                         where.ToUpper().StartsWith("WHERE") ? where : "WHERE " + where);
  522.                 }

  524.                 if (varQuerysort != String.Empty) hql += " " + varQuerysort;

  526.                 IQuery query = Session.CreateQuery(hql);

  528.                 IList<T> list = query.SetFirstResult(Start).SetMaxResults(Max).List<T>();

  530.                 return list;
  531.             }
  532.             catch (Exception ex)
  533.             {
  534.                 ILog log = LogManager.GetLogger(typeof(T));
  535.                 log.Error(ex.Message, ex);
  536.                 return null;
  537.             }
  538.             finally
  539.             {
  540.                 Session.Close();
  541.             }

  543.         }
  544.         #endregion

  546.         /// <summary>
  547.         /// 通过存储过程查询分页信息
  548.         /// </summary>
  549.         /// <param name="tableName">表名</param>
  550.         /// <param name="Primarykeyname"></param>
  551.         /// <param name="colName">列名集合</param>
  552.         /// <param name="orderCol">排序列名</param>
  553.         /// <param name="pageSize">页尺寸</param>
  554.         /// <param name="pageIdx">当前页</param>
  555.         /// <param name="orderType">升降序，true-0为升序，false-非0为降序</param>
  556.         /// <param name="condition">条件</param>
  557.         /// <returns></returns>
  558.         #region  public DataTable GetPageEntitesByStoredProc(string tableName, string Primarykeyname, string colName, string orderCol,int pageSize, int pageIdx, bool orderType, string condition)
  559.         public DataTable GetPageEntitesByStoredProc(string tableName, string Primarykeyname, string colName, string orderCol,
  560.             int pageSize, int pageIdx, bool orderType, string condition)
  561.         {
  562.             IList result = new ArrayList();

  564.             ISessionFactoryImplementor imp = (ISessionFactoryImplementor)SessionFactory;
  565.             IDbConnection conn = imp.ConnectionProvider.GetConnection();
  566.             IDbCommand cmd = imp.ConnectionProvider.GetConnection().CreateCommand();

  568.             cmd.CommandText = "pagination";
  569.             cmd.CommandType = CommandType.StoredProcedure;

  571.             IDbDataParameter parameter = cmd.CreateParameter();
  572.             parameter.ParameterName = "@tblName";
  573.             parameter.Value = tableName;
  574.             cmd.Parameters.Add(parameter);

  576.             parameter = cmd.CreateParameter();
  577.             parameter.ParameterName = "@PrimaryKey";
  578.             parameter.Value = Primarykeyname;
  579.             cmd.Parameters.Add(parameter);

  581.             parameter = cmd.CreateParameter();
  582.             parameter.ParameterName = "@strGetFields";
  583.             parameter.Value = colName;
  584.             cmd.Parameters.Add(parameter);

  586.             parameter = cmd.CreateParameter();
  587.             parameter.ParameterName = "@fldName";
  588.             parameter.Value = orderCol;
  589.             cmd.Parameters.Add(parameter);

  591.             parameter = cmd.CreateParameter();
  592.             parameter.ParameterName = "@PageSize";
  593.             parameter.Value = pageSize;
  594.             cmd.Parameters.Add(parameter);

  596.             parameter = cmd.CreateParameter();
  597.             parameter.ParameterName = "@PageIndex";
  598.             parameter.Value = pageIdx;
  599.             cmd.Parameters.Add(parameter);

  601.             parameter = cmd.CreateParameter();
  602.             parameter.ParameterName = "@OrderType";
  603.             parameter.Value = orderType;
  604.             cmd.Parameters.Add(parameter);

  606.             parameter = cmd.CreateParameter();
  607.             parameter.ParameterName = "@strWhere";
  608.             parameter.Value = condition;
  609.             cmd.Parameters.Add(parameter);

  611.             try
  612.             {
  613.                 cmd.Connection = conn;
  614.                 IDataReader rs = cmd.ExecuteReader();
  615.                 // 分割列
  616.                 string[] cols = SplitsColumnNames(colName, ',');
  617.                 // 数据表
  618.                 DataTable dt = new DataTable(tableName);
  619.                 foreach (string col in cols)
  620.                     dt.Columns.Add(col);

  622.                 // 取数据

  624.                 while (rs.Read())
  625.                 {
  626.                     // 创建行
  627.                     DataRow row = dt.NewRow();
  628.                     for (int i = 0; i < cols.Length; i++)
  629.                         row[cols] = rs.GetValue(i);
  630.                     // 插入行
  631.                     dt.Rows.Add(row);
  632.                 }
  633.                 // 返回结果集
  634.                 return dt;
  635.             }
  636.             catch (Exception ex)
  637.             {
  638.                 ILog log = LogManager.GetLogger(typeof(DaoTemplate));
  639.                 log.Error(ex.Message, ex);
  640.                 return null;
  641.             }
  642.             finally
  643.             {
  644.                 imp.CloseConnection(conn);
  645.             }
  646.         }
  647.         #endregion

  649.         /// <summary>
  650.         /// 将字符里的列表分解出来
  651.         /// </summary>
  652.         /// <returns></returns>
  653.         #region  internal static string[] SplitsColumnNames(string columns, char separator)
  654.         internal static string[] SplitsColumnNames(string columns, char separator)
  655.         {
  656.             return columns.Split(new char[] { separator });
  657.         }
  658.         #endregion
  659.     }
  660. }
复制代码
这是内个配合使用的sql server分页存储过程，原来从网上摘的，动手改过两次以适配distinct取数据：
  1. -- 获取指定页的数据
  2. CREATE PROCEDURE pagination
  3. @tblName varchar(255), -- 表名
  4. @PrimaryKey varchar(100), --主键
  5. @strGetFields varchar(1000) = '*', -- 需要返回的列
  6. @fldName varchar(255)='', -- 排序的字段名
  7. @PageSize int = 10, -- 页尺寸
  8. @PageIndex int = 1, -- 页码
  9. @doCount bit = 0, -- 返回记录总数, 非 0 值则返回
  10. @OrderType bit = 0, -- 设置排序类型, 非 0 值则降序
  11. @strWhere varchar(1500) = '' -- 查询条件 (注意: 不要加 where)
  12. AS
  13. declare @strSQL varchar(5000) -- 主语句
  14. declare @strTmp varchar(110) -- 临时变量
  15. declare @strOrder varchar(400) -- 排序类型
  16. if @doCount != 0
  17. begin
  18. if @strWhere !=''
  19. set @strSQL = "select count(*) as Total from " + @tblName + " where "+@strWhere
  20. else
  21. set @strSQL = "select count(*) as Total from " + @tblName + ""
  22. end
  23. --以上代码的意思是如果@doCount传递过来的不是0，就执行总数统计。以下的所有代码都是@doCount为0的情况
  24. else
  25. begin
  26. if @OrderType != 0
  27. begin
  28. --set @strTmp = "<(select min"
  29. set @strTmp = " not in "
  30. set @strOrder = " order by [" + @fldName +"] desc"
  31. --如果@OrderType不是0，就执行降序，这句很重要！
  32. end
  33. else
  34. begin
  35. --set @strTmp = ">(select max"
  36. set @strTmp = " not in "
  37. set @strOrder = " order by [" + @fldName +"] asc"
  38. end
  39. if @PageIndex = 1
  40. begin
  41. if @strWhere != ''
  42. set @strSQL = "select top " + str(@PageSize,3) +" "+@strGetFields+ " from " + @tblName + " where " + @strWhere + @strOrder
  43. else
  44. set @strSQL = "select top " + str(@PageSize,3) +" "+@strGetFields+ " from "+ @tblName + " "+ @strOrder
  45. --如果是第一页就执行以上代码，这样会加快执行速度
  46. end
  47. else
  48. begin
  49. --以下代码赋予了@strSQL以真正执行的SQL代码
  50. set @strSQL = "select top " + str(@PageSize,3) +" "+@strGetFields+ " from "
  51. + @tblName + " where [" + @PrimaryKey + "]" + @strTmp + "  (select top " + str((@PageIndex-1)*@PageSize,3) + " ["+ @PrimaryKey + "] from " + @tblName + "" + @strOrder + ") "+ @strOrder
  52. if @strWhere != ''
  53. set @strSQL = "select top " + str(@PageSize,3) +" "+@strGetFields+ " from "
  54. + @tblName + " where [" + @PrimaryKey + "]" + @strTmp
  55. + "  (select top " + str((@PageIndex-1)*@PageSize,3) + " ["
  56. + @PrimaryKey + "] from " + @tblName + " where " + @strWhere + " "
  57. + @strOrder + ")  and " + @strWhere + " " + @strOrder
  58. end
  59. end
  60. print @strSQL
  61. exec (@strSQL)
  62. GO
复制代码
最后，要让这个环境在程序中生效，得在web.config中加载它：
  1.     <configSections>
  2.         <sectionGroup name="spring">
  3.             <section name="context" type="Spring.Context.Support.WebContextHandler, Spring.Web"/>
  4.             <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core"/>
  5.         </sectionGroup>
  6.         <section name="SpringOverrideProperty" type="System.Configuration.NameValueSectionHandler"/>
  7.         <section name="nhibernate" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
  8.         <!--log4net-->
  9.         <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net"/>
  10.     </configSections>   
  11.     <spring>
  12.         <context>
  13.             <resource uri="config://spring/objects"/>
  14.             <resource uri="~/config/applicationContext.xml"/>
  15.             <resource uri="~/config/business.xml"/>
  16.             <resource uri="~/config/controllers.xml"/>
  17.             <resource uri="~/config/pageConfig.xml"/>
  18.             <resource uri="~/config/serviceConfig.xml"/>
  19.         </context>
  20.         <objects xmlns="http://www.springframework.net"/>
  21.     </spring>
复制代码
先写到这里吧，博客园的编辑器对机器配置要求不低，粘贴几段代码，界面几乎不能动弹，做罢了。下一回，将介绍怎么应用这个集成的环境。 （文/莫耶）

上一篇：.net企业级架构实战之3——业务对象建模及codesmith模板

下一篇：.net企业级架构实战之5——基于接口的访问层实现

--------------------------------------------------------------------------------
　　这里放出一个项目的mini demo:精简版spring.net集成Demo,点击下载：
.net企业级架构实战之4——Spring.net下的NHibernate数据访问模板
TOP
返回列表