zoukankan      html  css  js  c++  java
  • 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中我们提到来几个文件

    <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

    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[转]

  • 相关阅读:
    android 中文 api (43) —— Chronometer
    SVN客户端清除密码
    Android 中文 API (35) —— ImageSwitcher
    Android 中文API (46) —— SimpleAdapter
    Android 中文 API (28) —— CheckedTextView
    Android 中文 API (36) —— Toast
    Android 中文 API (29) —— CompoundButton
    android 中文 API (41) —— RatingBar.OnRatingBarChangeListener
    Android 中文 API (30) —— CompoundButton.OnCheckedChangeListener
    Android 中文 API (24) —— MultiAutoCompleteTextView.CommaTokenizer
  • 原文地址:https://www.cnblogs.com/Raywang80s/p/3103580.html
Copyright © 2011-2022 走看看