MVC3+Spring.net+NHibernate+ExtJs的简单架构

对于MVC3、Spring.net、NHibernate、ExtJs等单个的技术点使用起来，并不是很复杂，出问题比较多的还是配置相关的问题；下面我们来一步一步的实现4个框架的融合配置；

首先我们来谈谈4个框架的各自负责的事情：

1.MVC3：最开始是用 MVC2搭建框架，后来用VS12后，只支持MVC3的模板，就改为MVC3搭建了，MVC3兼容MVC2并且多加入了一种Razor视图引擎，但我们这个框架还是用ASPX视图引擎，言归正传；MVC的概念我个人的理解就是一种约定俗成，更深层次的理解还得各位看其他文章和多做练习来加深理解，在这个框架中，我们主要是用到Controller去后台取数，然后呈现到View上面；当然还有很多MVC中的一些技巧和MVC的注意点，我们代码或其他文章慢慢讲解；View层的框架主要是ExtJs;

2. ExtJs：ExtJs主要是用于前台的页面展示，属于MVC中View层的框架，就是ExtJs写URL指向Controller中的action取得数据然后展现到ExtJs控件中；

3. NHibernate：主要是用于底层数据的ORM框架，属于国外的开源框架，最开始是JAVA那边的“特有”，后来被完美移植到.NET平台，我们主要是用来做底层数据的持久化操作；

4.Spring.NET：也是有Java平台上完美移植过来的一个框架，我们这里面只用到Spring.NET的依赖注入，就是创建对象有Spring.NET来统一管理，对对象进行注入操作，推崇决不重新造轮子的原则！我们架构中主要用来对Controller中需要的对象进行注入；

继续我们的架构，下面我们从代码结构来说明我们该如何来完成这每一步；

首先，我们去spring.net网站下载最新的源代码，在源文件中找到Spring.NET-1.3.2\Spring.NET\examples \Spring下面的Spring.Data.NHibernate.Northwind这个项目，这个是Spring.NET官方出的一个示例，用于 Spring.NET和NHibernate集成的示例，下面还有MVC2及MVC3的相关示例，大家可以先熟悉了解下；

最开始搭建框架，可能最恼火的是引用的相关DLL不好找，即使找到了，也有可能相关的版本不对，这个也很头疼，我找DLL的办法是将Spring.NET全部重新编译一遍，然后找到编译后的相关需要的源码生成的DLL；

我们开始搭建如下图的结构：

简述下，BLL、Common、DAL、Model四个类库和一个MVCMain的MVC3的网站；

我们从每一个层里面来简述相关的代码

Model：

我们以Student为例，代码如下

View Code 
 protected string stuGUID;
         public virtual string StuGUID
         {
             get { return stuGUID; }
             set { stuGUID = value; }
         }
         protected int stuNo;
         public virtual int StuNo
         {
             get { return stuNo; }
             set { stuNo = value; }
         }
         protected string stuName;
         public virtual string StuName
         {
             get { return stuName; }
             set { stuName = value; }
         }
等等

因为我们要使用NHibernate所以在定义对象的时候，属性要用virtual来修饰，我们定义的对象然后，要把对象和数据的表对应起来，就要用到xml来描述Student对象和数据表Student的对应关系；

下面我们来看看相对应的描述，一定要记住一点，对于我们的整个项目中的xml(除了网站下面的xml)都是把文件设置嵌入式资源

View Code 
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
                    assembly="Model "
                   namespace="Model.Student">
  <class name="Model.Student, Model" table="Student" lazy="false">
    <id name="StuGUID">
      <column name="StuGUID" length="40" sql-type="uniqueidentifier"  not-null="true"/>
      <generator class="assigned" />
      <!--native、assigned、-->
    </id>
    <property name="StuNo" type="int">
      <column name="StuNo" length="4" sql-type="int" not-null="false"/>
    </property>
    <property name="StuName" type="String">
      <column name="StuName" length="30" sql-type="varchar" not-null="false"/>
    </property>
    <property name="StuSex" type="String">
      <column name="StuSex" length="1" sql-type="char" not-null="false"/>
</property>  
</hibernate-mapping>

PS：对于NHibernate的实体映射，网上有更多的相关专题，我们现在主要讨论的是把这几项东西结合，所以对于各自技术，都可以去找相关的技术专题；这篇文章只是以最简单的方式实现框架的融合，融合后对于技术本身的特性没有任何影响；

Model就可以可以说已经完成；下面我们来看DAL层

DAL：

对重要的是Helper文件夹中的东西，就是NHibernate的相关的使用(这个里面的东西，大家可以参考Spring.net中的spring.net+NHibernate的实现示例)，我们作一下简单的介绍

NHelper类主要是对ISessionFactory和ISession的注册，session就是相当于我们的DBHelper类一样，提供强大的数据访问支持，只要继承NHelper类就可以对数据库进行访问，但ISession需要通过Spring.NET进行注入；

View Code 
public abstract class NHelper
    {
        private ISessionFactory sessionFactory;
        /// <summary>
        /// Session factory for sub-classes.
        /// </summary>
        public ISessionFactory SessionFactory
        {
            protected get { return sessionFactory; }
            set { sessionFactory = value; }
        }
        /// <summary>
        /// Get's the current active session. Will retrieve session as managed by the 
        /// Open Session In View module if enabled.
        /// </summary>
        protected ISession CurrentSession
        {
            get { return sessionFactory.GetCurrentSession(); }
        }
        protected IList<TEntity> GetAll<TEntity>() where TEntity : class
        {
            ICriteria criteria = CurrentSession.CreateCriteria<TEntity>();
            return criteria.List<TEntity>();
        }
    }

然后就是IDAL, ISupportsDeleteDAL, ISupportsSaveDAL等一些接口，主要提供对数据库的增删改查的接口

View Code 
public interface ISupportsSaveDAL<TEntity,TId>
    {
        /// <summary>
        /// 保存一个实体
        /// </summary>
        /// <param name="entity">需要保存的实体</param>
        /// <returns>返回保存实体的主键ID</returns>
        TId Save(TEntity entity);
        /// <summary>
        /// 更新一个实体
        /// </summary>
        /// <param name="entity">更新一个实体</param>
        void Update(TEntity entity);
        /// <summary>
        /// 保存或更新一个实体
        /// </summary>
        /// <param name="entity">保存或更新一个实体</param>
        void SaveOrUpdate(TEntity entity);
    }

因为我们对要操作的具体类不明确，所以我们用泛型接口来约束接口中的方法；TEntity代表一个实体类型，TId代表实体的主键类型，下面还有删除和查找，就不一一列举；

然后就是ICommonDAL接口，这个接口主要是实现其他定义好的增删改查的相关接口，在定义个性化查询的及个性化方法的时候，就可以定义在此定义，而增删改查的接口，可以对应的去继承；

View Code 
public interface ICommonDAL<TEntity,TId>:IDAL<TEntity,TId>,ISupportsSaveDAL<TEntity,TId>,ISupportsDeleteDAL<TEntity>
{
/// <summary>
        /// 根据HQL和参数查询实体
        /// </summary>
        /// <param name="hqlQuery">HQL</param>
        /// <param name="commonParam">参数</param>
        /// <returns>实体</returns>
        IList<TEntity> GetCommonByHql(string hqlQuery, CommonParam [] commonParams);
        /// <summary>
        /// 根据HQL和参数查询实体
        /// </summary>
        /// <param name="hqlQuery">HQL</param>
        /// <returns>实体</returns>
        IList<TEntity> GetCommonByHql(string hqlQuery);        /// <summary>
        /// 标准查询实体
        /// </summary>
        /// <typeparam name="TEntity">指定对象</typeparam>
        /// <returns>查询到的实体</returns>
        IList<TEntity> GetCommonByCriteria();
        /// <summary>
        /// 标准查询实体
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns>查询到的实体</returns>
        IList<TEntity> GetCommonByCriteria(TId id);
}

当然这里不只局限于，这些查询了，NHibernate给我们提供的相关查询，都可以在接口中定义好，让子类去实现就行了；

CommonParam这个东西，是在Common中定义的一个类，主要是按照ADO.NET中的sqlparameter来简单的定义了简单的key和value

在往下面就是实现ICommonDAL接口了

CommonDAL类，如下

我们要继承NHelper才能通过Session来访问数据库，所以我们必须继承

View Code 
/// <summary>
        /// 根据HQL和参数查询实体
        /// </summary>
        /// <param name="hqlQuery">HQL</param>
        /// <param name="commonParam">参数</param>
        /// <returns>实体</returns>
        public IList<TEntity> GetCommonByHql(string hqlQuery, CommonParam [] commonParams)
        {
            IQuery iquery = CurrentSession.CreateQuery(hqlQuery);
            if (commonParams != null)
            {
                foreach (var item in commonParams)
                {
                    iquery.SetString(item.Key, item.Val);
                }
            }
            return iquery.List<TEntity>();
        }
/// <summary>
        /// 标准查询实体
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns>查询到的实体</returns>
        public IList<TEntity> GetCommonByCriteria(TId id)
        {
            ICriteria icriteria = CurrentSession.CreateCriteria(typeof(TEntity));
            icriteria.Add(Restrictions.IdEq(id));
            return icriteria.List<TEntity>();
        }
/// <summary>
        /// 保存对象
        /// </summary>
        /// <param name="entity">形参对象</param>
        /// <returns></returns>
        public TId Save(TEntity entity)
        {
            var id=(TId)CurrentSession.Save(entity);
            CurrentSession.Flush();
            return id;
        }

里面列举了一些简单的方法实现，都是使用 CurrentSession进行实现，CurrentSession就是NHelper里面定义的东西，是通过spring.net注入进行的；对于保存数据的相关操作，在一定要加CurrentSession.Flush();提交到数据库，否则无法保持到数据库；

在接着就是具体的表的操作，以Student表为例(上面我们已经建立了Model类)

我们定义IStudentDAL接口

public interface IStudentDAL:ICommonDAL<Student,string>
    {
    }

这个接口啥都不用写，只用继承ICommonDAL接口就行，因为我们已经知道是Student的DAL接口类，所以我们不用定义形参接口，当然，如果你有个性化的方法，依然，可以定义在IStudent接口中；

我们在来完成IStudentDAL接口的实现

StudentDAL

public class StudentDAL :CommonDAL<Student, string>,IStudentDAL
    {
    }

只用继承CommonDAL和实现IStudentDAL接口就行，一定要是CommonDAL在前，实现接口在后，因为IStudentDAL是继承ICommonDAL的，而CommonDAL又是实现 ICommonDAL的，所以我们这里面基本一句话都不用，就实现了，Student的之前在ICommonDAL中的所有方法；

接口和继承的好处很明显的体现出来，当然要泛型的支撑，如果我们在一个class班级表，只用加一个接口，继承ICommonDAL，然后在加一个类，继承CommonDAL，实现接口就可以实现所有的增删改查，当然你也可以在IStudentDAL中，提供自定义化的方法，让StudentDAL去实现，StudentDAL继承CommonDAL，而CommonDAL也继承NHelper，所以StudentDAL也可以通过 CurrentSession来访问数据库

DAL到这里也基本写完了；

BLL

在来看BLL，如果项目中没有BLL层，可以完全抛开这层，但是我们还是简单的叙述一下，

BLL中也有Helper，这个主要是来定义BLL中的特殊化查询方法；

我们主要看CommonBLL的实现操作，因为其他的与DAL中的没有差异，但我们这个BLL中没有NHelper，因为BLL负责业务逻辑，不负责数据访问，故没有NHelper，不提供CurrentSession来访问数据库

View Code 
public class CommonBLL<TEntity, TId> : ICommonBLL<TEntity, TId>
    {
        private ICommonDAL<TEntity, TId> comDAL;
        public ICommonDAL<TEntity, TId> ComDAL
        {
            set { comDAL=value; }
        }
        public IList<TEntity> GetCommonByHql(string hqlQuery, CommonParam[] commonParams)
        {
           return comDAL.GetCommonByHql(hqlQuery,commonParams);
        }
}

我们是通过创建ICommonDAL的实例进行DAL中的CommonDAL中的实现调用，至于ComDAL我们只是定义了，根本没有创建对象，这个我们是通过Spring.net来注入对象的，所以我们这里也暂时这么写；

在接着就是IStudentBLL，也是继承ICommonBLL就可以了，然后就是StudentBLL，实现CommonBLL类，并且实现接口 IStudentBLL；这时我们的StudentBLL中，有一个ComDAL只是定义了，没有创建对象，因为我们是通过spring.net注入对象的

BLL完了后，就是Common了，这个里面目前就是一个CommonParam类，定义了一个key和value来传递HQL的参数

MVCMain

然后在看MVCMain网站，我们做的简单一些吧，在我们输入地址http://localhost:8001/Home/Index的时候，就是默认访 HomeController下的Index方法，我们在HomeController下面写东西来后台访问我们刚写好的BLL

View Code 
public class HomeController : Controller
    {
        public string Message { get; set; }
        private IStudentBLL<Student> studentBLL;
        public IStudentBLL<Student> StudentBLL
        {
            set { studentBLL = value; }
        }
}

我们只用定义IStudentBLL的对象就行，我们创建对象是通过Spring.net注入的；所以我们来看看最最重要的配置吧；

首先当然是从web.config里面开始，首先在configuration节点中加入(加入log4net日志记录)

View Code 
<configSections>
    <sectionGroup name="common">
      <section name="logging" type="Common.Logging.ConfigurationSectionHandler, Common.Logging"/>
    </sectionGroup>
    <sectionGroup name="spring">
      <section name="context" type="Spring.Context.Support.MvcContextHandler, Spring.Web.Mvc3"/>
      <section name="parsers" type="Spring.Context.Support.NamespaceParsersSectionHandler, Spring.Core"/>
    </sectionGroup>
  </configSections>

在接着下面写

View Code 
<common>
    <logging>
      <factoryAdapter type="Common.Logging.Log4Net.Log4NetLoggerFactoryAdapter, Common.Logging.Log4Net">
       <!-- choices are INLINE, FILE, FILE-WATCH, EXTERNAL-->
       <!-- otherwise BasicConfigurer.Configure is used   -->
       <!-- log4net configuration file is specified with key configFile-->
        <arg key="configType" value="FILE-WATCH"/>
        <arg key="configFile" value="~/Config/Log4Net.xml"/>
      </factoryAdapter>
    </logging>
  </common>
  <spring>
    <parsers>
      <parser type="Spring.Data.Config.DatabaseNamespaceParser, Spring.Data"/>
      <parser type="Spring.Transaction.Config.TxNamespaceParser, Spring.Data"/>
    </parsers>
    <context>
      <!--<resource uri="file://~/Config/Aspects.xml"/>-->
      <resource uri="file://~/Dao.xml"/>
      <!--<resource uri="assembly://Spring.Northwind.Service/Spring.Northwind.Service/Services.xml"/>-->
      <resource uri="file://~/Web.xml"/>
      <!--<resource uri="file://~/Config/controllers.xml"/>-->
    </context>
  </spring>

这里是指定log4net的相关配置和spring.net的相关配置，context节点下，是其他xml注入描述的相关文件

在appsettings中一定要加这句话，用于注册NHibernate的SessionFactory

<add key="Spring.Data.NHibernate.Support.OpenSessionInViewModule.SessionFactoryObjectName" value="NHibernateSessionFactory"/>

在system.web节点下的httpModules节点中加入

<add name="OpenSessionInView" type="Spring.Data.NHibernate.Support.OpenSessionInViewModule, Spring.Data.NHibernate21"/>
      <add name="Spring" type="Spring.Context.Support.WebSupportModule, Spring.Web" />

用于注册spring.net和nhibernate

如果你的网站用vs打开没问题，发布到IIS上出现问题，可以调整IIS的应用程序池的模式为集成，或者修改system.webServer

View Code 
<system.webServer>
    <modules runAllManagedModulesForAllRequests="true">
      <add name="Spring" type="Spring.Context.Support.WebSupportModule, Spring.Web" />
      <add name="OpenSessionInView" type="Spring.Data.NHibernate.Support.OpenSessionInViewModule, Spring.Data.NHibernate21" />
    </modules>
    <handlers>
      <add name="Spring.WebPageHandler" path="*.aspx" verb="*" type="Spring.Web.Support.PageHandlerFactory, Spring.Web" />
      <add name="Spring.WebSupportHandler" path="ContextMonitor.ashx" verb="*" type="Spring.Web.Support.ContextMonitor, Spring.Web" />
    </handlers>
  </system.webServer>

Web.config中的东西写完了，在web.config中我们提到来几个文件

第一个是log4net的相关配置文件，这个基本就是把log4net的配置写进行就行了

View Code 
<?xml version="1.0" encoding="utf-8" ?>
<log4net debug="false">
  
  <appender name="AspNetTraceAppender" type="log4net.Appender.AspNetTraceAppender">
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="[%thread] %-5level - %message" />
    </layout>
  </appender>
  
  <appender name="RollingFileAppender" type="log4net.Appender.RollingFileAppender">
    <file value="Logs/log.txt" />
    <appendToFile value="true" />
    <rollingStyle value="Size" />
    <maxSizeRollBackups value="10" />
    <maximumFileSize value="100KB" />
    <staticLogFileName value="true" />
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
    </layout>
  </appender>
  <appender name="TraceAppender" type="log4net.Appender.TraceAppender">
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%-5level %M - %message%newline" />
      </layout>
  </appender>
  <appender name="MemoryAppender" type="log4net.Appender.MemoryAppender">
     <!-- simple appender to get results to UI -->
  </appender>
  <!-- Set default logging level to DEBUG -->
  <root>
    <level value="DEBUG" />
    <!--<appender-ref ref="AspNetTraceAppender" />-->
    <appender-ref ref="TraceAppender" />
    <appender-ref ref="RollingFileAppender" />
  </root>
  <!--
    In Spring.NET there is a 1-1 correspondence between the logger name and
    the namespace of the class doing the logging...
  -->
  <logger name="Spring">
    <level value="DEBUG" />
  </logger>
  <logger name="NHibernate">
    <level value="INFO" />
  </logger>
  <logger name="Spring.Transaction>">
    <level value="INFO" />
    <appender-ref ref="MemoryAppender" />
  </logger>
  <logger name="Spring.Northwind">
    <level value="INFO" />
    <appender-ref ref="MemoryAppender" />
  </logger>
</log4net>

第二个是NHibernate的配置文件

View Code 
<?xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net"
         xmlns:db="http://www.springframework.net/database">
  <!-- Referenced by main application context configuration file -->
  <description>
    The Northwind object definitions for the Data Access Objects.
  </description>
  <!-- Property placeholder configurer for database settings -->
  <object type="Spring.Objects.Factory.Config.PropertyPlaceholderConfigurer, Spring.Core">
    <property name="ConfigSections" value="databaseSettings"/>
  </object>
  <!-- Database Configuration -->
  <db:provider id="DbProvider"
                   provider="SqlServer-2.0"
                   connectionString="server=.\SQL08;database=School;uid=sa;pwd=chhj;"/>
  <!-- NHibernate Configuration -->
  <object id="NHibernateSessionFactory" type="MVCMain.Controllers.LocalSessionFactoryObjects, MVCMain">
    <property name="DbProvider" ref="DbProvider"/>
    <property name="MappingAssemblies">
      <list>
        <value>Model</value>
      </list>
    </property>
    <property name="HibernateProperties">
      <dictionary>
        <entry key="hibernate.connection.provider" value="NHibernate.Connection.DriverConnectionProvider"/>
        <entry key="dialect" value="NHibernate.Dialect.MsSql2008Dialect"/>
        <entry key="connection.driver_class" value="NHibernate.Driver.SqlClientDriver"/>
        <entry key="use_proxy_validator" value="false" />
      </dictionary>
    </property>
    <!-- provides integation with Spring's declarative transaction management features -->
    <property name="ExposeTransactionAwareSessionFactory" value="true" />
  </object>
  <!-- Transaction Management Strategy - local database transactions -->
  <object id="transactionManager"
        type="Spring.Data.NHibernate.HibernateTransactionManager, Spring.Data.NHibernate21">
    <property name="DbProvider" ref="DbProvider"/>
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>
  <!-- Exception translation object post processor -->
  <object type="Spring.Dao.Attributes.PersistenceExceptionTranslationPostProcessor, Spring.Data"/>
  <!-- Data Access Objects -->
  <object id="StudentBLL" type="BLL.StudentBLL, BLL">
    <property name="ComDAL" ref="ComStudentDAL" />
  </object>
  <object id="ComStudentDAL" type="DAL.StudentDAL, DAL">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>
</objects>

大家要仔细看，其中的

<list>

<value>Model</value>

</list>

</property>

节点是指NHibernate的关系映射在哪个程序集中，这里面有一个type="MVCMain.Controllers.LocalSessionFactoryObjects, MVCMain"，这个是用来创建NHibernateSessionFactory对象的

LocalSessionFactoryObjects类的写法如下(可以找spring.net提供的S+N的集成来写)

View Code 
public class LocalSessionFactoryObjects : LocalSessionFactoryObject
    {
        /// <summary>
        /// Overwritten to return Spring's bytecode provider for entity injection to work.
        /// </summary>
        public override IBytecodeProvider BytecodeProvider
        {
            get { return new BytecodeProvider(ApplicationContext); }
            set { }
        }
    }

在然后，就是一些NHibernate的标准配置

</object>

</object>

这两个节点就是创建DAL中的StudentDAL的对象了，然后注入到BLL中的StudentBLL中的ComDAL中，因为我们的ComDAL是 CommonBLL中定义的ICommonDAL的对象，现在通过StudentDAL注入给ComDAL，因为StudentDAL是继承 IStudentDAL，而IStudentDAL又是继承ICommonDAL的，所以可以注入，这也就是面向接口的编程了；

Dao.xml中主要是NHibernate的相关配置文件，和后台对象通过Spring.net创建；然后在看第三个web.xml

View Code 
<?xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net">
  <!-- Referenced by main application context configuration file -->
  <description>
    The Northwind web layer definitions
  </description>
  <object type="MVCMain.Controllers.HomeController, MVCMain" singleton="false" >
    <property name="StudentBLL" ref="StudentBLL" />
    <property name="Message" value="Welcome to ASP.NET MVC powered by Spring.NET tttt3" />
  </object>
  <object type="MVCMain.Controllers.AccountController, MVCMain" singleton="false" >
  </object>
    
</objects>

这个里面主要是对HomeController中的相关对象和属性进行注入，对于其他Controller如果没有属性需要注入也要创建对象才能访问，否则会报找不到的错误；

到这里基本的配置基本已经完了，但还有最重要的一点，容易被忽视，就是配置文件写了后，如何注入的了？

我们还有最后一步就是在Global中修改一点东西

修改Global为如下

View Code 
public class MvcApplication : SpringMvcApplication
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new HandleErrorAttribute());
        }
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            );
        }
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);
        }
    }

就是Global的Application要继承SpringMVCApplication才行；

到这里基本已经完成，里面需要引入的DLL没有详细的说明，在此截图一下

一定要去spring.net的源代码中把这些东西找齐，然后在引入就行；

还有一点就是ExtJs或者是Jquery easyui等框架，访问后台时

View Code 
var eastPanel = new Ext.Panel({
        region: 'east',
        title: 'East Side',
        collapsible: true,
        split: true,
         225,
        minSize: 175,
        maxSize: 400,
        layout: 'fit',
        margins: '0 0 0 0',
        items: {
            autoScroll: true,
            autoLoad: {
                url: "/Home/Index"
            }
        }
    });

只用指定url就可以，这个代表是访问HomeController下的Index方法；

至此框架搭建好了，如果你报错了，你可以对应这篇文章及spring.net提供的S+N的集成示例和里面的MVC3的示例进行相应的修改，你也一定能搭建出此框架！后面会继续对此框架进行优化处理，并完善各单个框架的的功能点优化！对于spring.net和nhibernate的相关使用大家不太好理解的多去网上搜搜文章！博客园上也有相关的专题；

在此多说一点，架构只是为了应付某种需求才出现的，好的架构可以让程序员更多的去关心程序的业务逻辑，而不是成天的写代码；好的架构在初期设计好架构，初期写好架构代码，即使初期写架构代码的时间很长，只要后期程序员进行实现的时候，写少量的代码，可以做多量的事情，那么架构就是合理的！

2013.03.22[转]