對於MVC3、Spring.net、NHibernate、ExtJs等單個的技術點使用起來，並不是很復雜，出問題比較多的還是配置相關的問題；下面我們來一步一步的實現4個框架的融合配置；
首先我們來談談4個框架的各自負責的事情：
- MVC3：最開始是用MVC2搭建框架，后來用VS12后，只支持MVC3的模板，就改為MVC3搭建了，MVC3兼容MVC2並且多加入了一種Razor視圖引擎，但我們這個框架還是用ASPX視圖引擎，言歸正傳；MVC的概念我個人的理解就是一種約定俗成，更深層次的理解還得各位看其他文章和多做練習來加深理解，在這個框架中，我們主要是用到Controller去后台取數，然后呈現到View上面；當然還有很多MVC中的一些技巧和MVC的注意點，我們代碼或其他文章慢慢講解；View層的框架主要是ExtJs;
- ExtJs：ExtJs主要是用於前台的頁面展示，屬於MVC中View層的框架，就是ExtJs寫URL指向Controller中的action取得數據然后展現到ExtJs控件中；
- NHibernate：主要是用於底層數據的ORM框架，屬於國外的開源框架，最開始是JAVA那邊的“特有”，后來被完美移植到.NET平台，我們主要是用來做底層數據的持久化操作；
- 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
1 protected string stuGUID; 2 public virtual string StuGUID 3 { 4 get { return stuGUID; } 5 set { stuGUID = value; } 6 } 7 protected int stuNo; 8 public virtual int StuNo 9 { 10 get { return stuNo; } 11 set { stuNo = value; } 12 } 13 protected string stuName; 14 public virtual string StuName 15 { 16 get { return stuName; } 17 set { stuName = value; } 18 } 19 •••••等等
因為我們要使用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接口
View Code
public interface IStudentDAL:ICommonDAL<Student,string> { }
這個接口啥都不用寫，只用繼承ICommonDAL接口就行，因為我們已經知道是Student的DAL接口類，所以我們不用定義形參接口，當然，如果你有個性化的方法，依然，可以定義在IStudent接口中；
我們在來完成IStudentDAL接口的實現
StudentDAL
View Code
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
View Code
<add key="Spring.Data.NHibernate.Support.OpenSessionInViewModule.SessionFactoryObjectName" value="NHibernateSessionFactory"/>
在system.web節點下的httpModules節點中加入
View Code
<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中我們提到來幾個文件
<arg key="configFile" value="~/Config/Log4Net.xml"/>
<resource uri="file://~/Dao.xml"/>
<resource uri="file://~/Web.xml"/>
第一個是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>
大家要仔細看，其中的
<object id="NHibernateSessionFactory" type="MVCMain.Controllers.LocalSessionFactoryObjects, MVCMain">
<property name="DbProvider" ref="DbProvider"/>
<property name="MappingAssemblies">
<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 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>
這兩個節點就是創建DAL中的StudentDAL的對象了，然后注入到BLL中的StudentBLL中的ComDAL中，因為我們的ComDAL是CommonBLL中定義的ICommonDAL的對象，現在通過StudentDAL注入給ComDAL，因為StudentDAL是繼承IStudentDAL，而IStudentDAL又是繼承ICommonDAL的，所以可以注入，這也就是面向接口的編程了；
Dao.xml中主要是NHibernate的相關配置文件，和后台對象通過Spring.net創建；然后在看第三個web.xml
Web.xml中主要是定義MVCMain中要使用的對象，因為我們的對象都要交給spring.net來管理，並且還要訪問BLL中的對象，間接的訪問數據
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, width: 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的相關使用大家不太好理解的多去網上搜搜文章！博客園上也有相關的專題；
在此多說一點，架構只是為了應付某種需求才出現的，好的架構可以讓程序員更多的去關心程序的業務邏輯，而不是成天的寫代碼；好的架構在初期設計好架構，初期寫好架構代碼，即使初期寫架構代碼的時間很長，只要后期程序員進行實現的時候，寫少量的代碼，可以做多量的事情，那么架構就是合理的！
文章出處：博客園 http://www.cnblogs.com/RegicideGod/archive/2012/06/25/2562871.html