Spring.Net 框架(一)(二)(三)

Spring.NET是一个应用程序框架,其目的是协助开发人员创建企业级的.NET应用程序。它提供了很多方面的功能,比如依赖注入、面向方面编程(AOP)、数据访问抽象及ASP.NET扩展等等。Spring.NET以Java版的Spring框架为基础,将Spring.Java的核心概念与思想移植到了.NET平台上。

企业级应用一般由多个物理层组成,每个物理层也经常划分为若干功能层。不同层次之间需要相互协作,例如,业务服务层一般需要使用数据访问层的对象来实现某个用例。不管应用程序如何构建,最终都会表现为一系列相互协作的对象,这些对象一起组成了完整的应用程序。所以我们说,应用程序中的对象之间相互具有依赖性。

.NET平台为构建应用程序提供了丰富的功能,从非常基础的基元类型和基础类库(以及定义新类的方法),到功能完善的应用程序服务器和Web框架,都有很好的支持。但.NET平台本身并没有提供任何方式来管理基础的应用模块并将它们组合为一个相互协作的整体,只能依靠架构师或开发人员去创建(一系列)应用程序。诚然,目前有很多设计模式可用于业务系统的设计,我们可以使用这些模式将各种类或对象组合成能够正常工作的完整应用。工厂、抽象工厂、 Builder、装饰及服务定位器(Service Locator)等模式已被现今的软件开发行业广泛接受和采用(这也许正是这些模式最早被定型为模式的原因)。这些模式都非常好,但也不过是些已命名的最佳编程方法,在对这些模式的介绍中一般还会说明它们是作什么用的、最好应用到什么场合、可以解决什么问题等等。我们可以从许多书籍和wiki上找到这些模式,然后仔细研读,然后实现在我们自己的应用中。

Spring.NET的IoC容器所解决的,正是如何在企业应用中将类、对象和服务组合成应用程序的问题。IoC容器通过很正统(按: formalized,言下之意是这些方式都是已经定型了的、经过了业界多年考验的)的方式将分散的组件组合成完整的应用程序。Spring.NET框架所采用的,都是被业界无数应用程序考验多年的、已经被定型为设计模式的最佳编程方式,实际上,这些模式已经成为我们架构和开发时的法典,而通过 Spring.NET,我们可以直接将它们整合到自己的应用程序中。目前已有很多组织和机构用Spring框架开发出了强壮的、维护性好的应用程序,这确实是一件非常好的事情。

 

Spring.NET框架包括很多功能,这些功能被很好的组织进一系列模块当中,如下图所示。Spring.NET 1.0包括完整的IoC容器和AOP类库。1.1版将加入Web、ORM和数据模块。Spring.NET的下载包中并不包含与其它类库(如 NHibernate,TIBCO EMS,Anthem,和IIOP.NET)集成的模块,如果需要您可以单独下载。下图为Spring.NET的各个核心模块。灰色阴影部分在1.0版中已经可用了,其它模块会在未来版本中陆续发布。目前可以从我们的网站上单独下载这些新的模块。


Spring.Core作为整个框架的基础,实现了依赖注入的功能。Spring.NET的大部分模块都要依赖或扩展该模块。 Spring.Core的基础是IObjectFactory接口,该接口用一个简单而优雅的方式实现了工厂模式,使我们可以无需自行编写 singleton类型和众多的服务定位器,并允许将对象配置及其依赖关系与具体的程序逻辑解耦。该模块中的IApplicationContext接口是IObjectFactory的扩展,增加了诸多企业级功能,包括使用资源文件进行文本本地化、事件传播和资源装载等等。

Spring.AOP为业务对象提供面向方面编程(AOP)的支持。AOP完善了IoC容器的功能,为创建企业应用和使用声明式服务奠定了坚实的基础。

Spring.Web对ASP.NET进行了一系列功能扩展,包括对ASP.NET页面进行依赖注入、双向数据绑定、在ASP.NET 1.1中使用Master page、以及增强的本地化功能支持等。

Spring.Services允许将任意的“普通”对象(意为没有继承任何指定基类型的对象)发布为企业服务(COM+)或远程对象。通过依赖注入和特性元数据覆盖等功能,该模块可使.NET的Web服务获得极大的灵活性。同时也支持Windows后台服务。

Spring.Data定义了一个抽象的数据访问层,可以跨越各种数据访问技术(从ADO.NET到各种ORM)进行数据访问。该模块包含一个ADO.NET的抽象层,减少了使用传统ADO.NET进行编码和事务管理时的工作量。

Spring.ORM为时下流行的ORM类库提供了一个整合层,其中包含声明式事务管理等诸多功能。

IObjectFactory是初始化、配置及管理对象的实际容器(按:它是所有容器的父接口)。对象间通常会相互协作,我们也可以说它们相互间具有依赖性。这些依赖性通过IObjectFactory的配置数据反映出来。(但某些依赖性从配置数据中是看不到的,比如运行时对象之间的方法调用。)

Spring.Objects.Factory.IObjectFactory接口有多个实现类。最常用的是 Spring.Objects.Factory.Xml.XmlObjectFactory。关于如何在代码中与IObjectFactory交互,与IObjectFactory交互。IApplicationContext接口所定义的增强功能将在IApplicationContext简介中讨论。

前文提到过,Spring.NET框架的核心原则是非侵入性。简单的说,就是应用程序的代码不需要对Spring.NET的API有任何依赖。然而,如果要通过IObjectFactory或Spring.Context.IApplicationContext接口充分利用IoC容器的功能,有时候还必须要初始化这两个接口的某个实现类。为此,可以在代码中使用new操作符来显式创建容器(在C#中,VB开发人员则使用New操作符。按:后文中,举凡涉及到含义为“管理对象的容器”而非特指接口的名称时,将原文中的IObjectFactory或IApplicationContext称为 “容器”或“IoC容器”);另一种更为简单的方式是在.NET应用程序的标准配置文件中用一个自定义节点来配置容器。一旦容器建立,应用程序代码就可能不再需要与之发生显式的交互了。

下面代码创建了XmlObjectFactory类的一个实例,XmlObjectFactory是IObjectFactory的实现类之一。我们假定在objects.xml文件中定义了要装配(按:装配的概念见后文)和发布的服务对象。将该文件的信息传递给XmlObjectFactory的构造器,即可创建一个容器,参见如下代码:

 
 
IResource input =  new FileSystemResource ("objects.xml"); IObjectFactory factory =  new XmlObjectFactory(input);

代码中使用了Spring.NET的IResource接口。IResource能以简单统一的方式访问许多可用System.IO.Stream表示的IO资源。 IResource接口中将对IResource接口展开讨论。这些IO资源一般是独立的文件或者URL,但也可以是.NET程序集的内嵌资源。通过IResource接口,可以用简单的URI格式来描述资源的位置,比如可用file://object.xml来表示一个文件。此外,IResource也支持很多其它协议,如 http等。

前文提到IApplicationContext是IObjectFactory的超集,我们一般都会用IApplicationContext来作为容器。在创建容器时可以像上例一样用IResource实例化IApplicationContext接口的任何一个实现类。另外, IApplicationContext支持用多个配置文件创建容器(按:此处的配置文件是指包括了Spring.NET对象定义的XML文件,而非特指.config文件,下同):
IApplicationContext context =  new XmlApplicationContext(
    "file://objects.xml",
    "assembly://MyAssembly/MyProject/objects-dal-layer.xml");

//  of course, an IApplicationContext is also an IObjectFactory...
IObjectFactory factory = (IObjectFactory) context;
 

下面是引用.NET程序集内嵌资源时的URI语法:assembly://<AssemblyName>/<NameSpace>/<ResourceName>
注意

若要在VS中创建一个内嵌的资源,必须在文件属性编辑器中将xml文件的Build Action设为Embedded Resource。并且,如果自上次成功建立项目之后,该属性的变更是本次所做的唯一更改,则需要显式的重新生成项目。如果使用NAnt建立项目,需要在 csc任务中添加一个<resources>节点。可参见Spring.Core.Tests项目中的build文件,该项目随 Spring.NET一起发布。

更好的创建方式是在标准.NET应用程序配置文件中(App.config或Web.config)添加自定义配置节点。以下的XML节点可以创建与前例相同的容器:

 
 
< spring >    < context  type ="Spring.Context.Support.XmlApplicationContext, Spring.Core" >      < resource  uri ="file://objects.xml" />      < resource  uri ="assembly://MyAssembly/MyProject/objects-dal-layer.xml" />    </ context > </ spring >

<context>节点的type属性是可选的,在Windows应用中,其默认值就是Spring.Context.Support.XmlApplicationContext,所以下面的配置和上面完全相同:

 
 
< spring >    < context >      < resource  uri ="file://objects.xml" />      < resource  uri ="assembly://MyAssembly/MyProject/objects-dal-layer.xml" />    </ context > </ spring > 

spring和context节点的名称不是任意的,必须是"spring"和"context",Spring.NET本身将 "spring/context"作为字符串常量定义在了AbstractApplicationContext类中以表示上下文的节点名称。若要引用由以上配置创建的容器,可使用下面的代码:

 
 
IApplicationContext ctx = ContextRegistry.GetContext();

ContextRegistry类既可用来初始化应用程序上下文,也可用来以服务定位器风格对容器中的对象进行访问。注意,使这一切成为可能的是Spring.Context.Support.ContextHandler类,该类实现了FCL的IConfigurationSectionHandler接口。必须在.NET配置文件的<configSections> 节点中注册这个类,如下所示:

 
 
< configSections >    < sectionGroup  name ="spring" >      < section  name ="context"  type ="Spring.Context.Support.ContextHandler, Spring.Core" />    </ sectionGroup > </ configSections >

注册了这个节点处理器后,配置文件中的<spring>节点才能起作用。

在某些情况下,用户不需要以任何方式显式创建容器,Spring.NET可以自行创建。例如,Spring.NET中的Spring.Web模块可以将 IApplicationContext作为Web应用程序正常启动进程的一部分进行自动装载。目前正在研究如何为WinForms应用程序提供类似的支持
关于如何通过编程方式管理IObjectFactory,稍后再讲。下面我们先讨论IObjectFactory接口所使用的对象配置格式。(按:凡适用于IObjectFactory的内容,必定也适用于IApplicationContext)

基本上,IObjectFactory的配置信息由一个或多个对象定义构成。在基于XML的工厂中,这些对象定义表现为一个或多个< object>子节点,它们的父节点必须是<objects>(按:objects节点的xmlns元素是必需的,必须根据不同的应用添加不同的命名空间,请留意各个章节中的相关内容。

 
 
< objects  xmlns ="http://www.springframework.net"       xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation ="http://www.springframework.net         http://www.springframework.net/xsd/spring-objects.xsd" >    < object  id ="..."  type ="..." >   ...    </ object >    < object  id ="...."  type ="..." >   ...    </ object >   ... </ objects >

随Spring.NET一起发布的schema文档可以简化对XML对象定义的验证过程。该文档是完全开放的(参见附录A,Spring.NET的spring-objects.xsd)。目前,除了验证XML文档外,该文档还有一个用途,就是在具备XSD感知能力的编辑器(比如VS.NET)内进行代码提示。可参考第二十四章,与Visual Studio.NET集成。在Spring.NET的网站上可以下载到spring-objects.xsd的最新版本。

XML对象定义也可以放在.NET的标准应用程序配置文件中。此时也需要为<objects>节点预先注册相应的节点处理器,类型为 Spring.Context.Support.DefaultSectionHandler。然后,就可以在.NET的.config文件中为一或多个容器配置对象定义了,如下所示:

 
 
< configuration >    < configSections >      < sectionGroup  name ="spring" >        < section  name ="context"  type ="Spring.Context.Support.ContextHandler, Spring.Core" />        < section  name ="objects"  type ="Spring.Context.Support.DefaultSectionHandler, Spring.Core"   />      </ sectionGroup >    </ configSections >    < spring >      < context >        < resource  uri ="config://spring/objects" />      </ context >              < objects  xmlns ="http://www.springframework.net" >         ...      </ objects >    </ spring > </ configuration >

上下文嵌套和从其它文件中导入对象定义会讨论创建配置文件时可用的其它节点。

我们也可以在配置文件中为IApplicationContext注册自定义的资源处理器、schema解析器、类型转换器和类型别名等等。IApplicationContext配置一节中将讨论这些内容。

容器所管理的对象由对象定义来配置,一个对象定义包含以下信息:

  • 对象类型,即所定义对象的实际类型。
  • 对象行为,用来规定对象在IoC容器中的行为(例如,是否布署为singleton,自动装配的模式,依赖检查的模式,初始化和销毁方法等)。
  • 对象创建后要设置的属性值。例如,一个线程池管理对象的可用线程数,或者用来创建线程池的类型信息,* 对象所需要的其它对象,例如一个对象的协作对象(同样可通过属性或构造器设置)。这些对象也可以叫做依赖项。

上面提到了用属性和构造器参数来设置依赖项。Spring.NET支持两种类型的IoC:类型2和类型3(分别是构造器参数注入和属性注入)。也就是说,当一个对象被IoC容器创建时,既可以使用常规的属性设值方法为属性设值,也可以直接向构造器传递参数来为属性赋值。(按:对.NET来说,“属性注入” 似乎比“设值方法注入”更贴切)

上述概念直接对应对象定义中的一系列xml子节点,这些节点及相关的章节如下表所示:

 对象定义内容
内容详细信息
对象类型对象的创建
id和name对象标识符(id和name)
singleton或prototypeSingleton和Prototype
对象属性设置对象的属性和协作对象
构造器参数设置对象的属性和协作对象
自动装配模式自动装配协作对象
依赖检查模式检查依赖项
初始化方法生命周期接口
销毁(destruction)方法生命周期接口

 

对象定义会包含对象的类型信息(也有例外,通过实例工厂方法创建对象和,抽象及子对象定义)。多数情况下,容器会根据对象定义中的type属性值去直接调用相应类型的某个构造器。另外,容器也可以调用工厂方法来创建对象,这时type属性的值就应该是包含工厂方法的类型(按:而不是要创建的类型,但通过该对象定义的名称获取的则是由工厂方法所创建的对象)。工厂方法的产品对象可以是工厂方法所在的类型,也可以是其它类型(按:很多情况下工厂方法位于单独的类型中),这无关紧要。
 

使用构造器创建对象时,并不要求对象必须是某种特定的类型,也不需要了解它的实现方式(按:也就是说,类型不必去实现某个接口或扩展某个基类以求和 Spring.NET兼容,任何对象都可以布署在容器中)。只要指明对象类型(以及它所在的程序集名称)就可以了。不过,根据不同IoC容器的要求,可能需要为类型(显式的)定义默认构造器(即无参的构造器)。(按:由于.NET只会为没有构造器的类型自动添加默认构造器,所以Spring.NET允许类型不定义任何构造器;但如果在定义了含参构造器后仍需使用无参构造器,则必须进行显式定义。)

XmlObjectFactory类实现了IObjectFactory接口,它可以处理XML文件中的对象定义,例如:

 
 
< object  id ="exampleObject"  type ="Examples.ExampleObject, ExamplesLibrary" />


这个节点定义了一个名为exampleObject的对象,它的类型是位于ExamplesLibrary程序集中的 Examples.ExampleObject类。请特别留心一下type属性的格式:类型的全名,然后是一个逗号,最后是类型所在的程序集名称。在上面的例子中,ExampleObject类定义在Examples命名空间,且位于ExamplesLibrary程序集中。

type属性值必须包含类型所在的程序集名称。另外,如果需要确保Spring.NET能按照预期的类型创建对象,则推荐使用程序集的强命名。不过,一般只有在用到GAC中的程序集时,才需要使用强命名。(按,例如,type="System.Windows.Forms.Form, System.Windows.Forms, Version=2.0.0.0, Culture=neutral,PublicKeyToken=b77a5c561934e089")

如果需要为嵌套类型创建对象,可以使用+号。例如,如果在类型Examples.ExampleObject嵌套定义了类型Person,就可以用下面的方式创建对象定义:

< object  id ="exampleObject"  type ="Examples.ExampleObject+Person, ExamplesLibrary" />


如果应用程序能够以标准的程序集探测机制访问程序集(例如ASP.NET中的bin文件夹),那么type属性的值只需包括类型全名即可。这样,当程序集改变后,不需要去修改每个对象定义的type属性(主要是改些版本号等等),Spring.NET就会自动使用最新的程序集。


  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring.NET是一个应用程序框架,其目的是协助开发人员创建企业级的.NET应用程序。它提供了很多方面的功能,比如依赖注入、面向方面编程(AOP)、数据访问抽象及ASP.NET扩展等等。Spring.NET以Java版的Spring框架为基础,将Spring.Java的核心概念与思想移植到了.NET平台上。 第一章 序言 第章 简介 2.1.概述 2.2.背景 2.3.模块 2.4.许可证信息 2.5.支持 第章 背景 3.1.控制反转 第一部分 核心技术 第四章 对象、对象工厂和应用程序上下文 4.1.简介 4.2.IObjectFactory,IApplicationContext和IObjectDefinition接口介绍 4.2.1.The IObjectFactory和IApplicationContext 4.2.2.对象定义 4.2.3.对象的创建 4.2.3.1.通过构造器创建对象 4.2.3.2.通过静态工厂方法创建对象 4.2.3.3.通过实例工厂方法创建对象 4.2.4.泛型类的对象创建 4.2.4.1.通过构造器创建泛型类的对象 4.2.4.2.通过静态工厂方法创建泛型类的对象 4.2.4.3.通过实例工厂方法创建泛型类的对象 4.2.5.对象标识符(id和name) 4.2.6.Singleton和Prototype 4.3.属性,协作对象,自动装配和依赖检查 4.3.1.设置对象的属性和协作对象 4.3.2.构造器参数解析 4.3.2.1.根据参数类型匹配构造器参数 4.3.2.2.根据参数索引匹配构造器参数 4.3.2.3.根据名称匹配构造器参数 4.3.3.详细讨论对象属性和构造器参数 4.3.3.1.设置空值 4.3.3.2.设置集合值 4.3.3.3.设置泛型集合的值 4.3.3.4.设置索引器属性 4.3.3.5.内联对象定义 4.3.3.6.idref节点 4.3.3.7.引用协作对象 4.3.3.8.value和ref节点的简短格式 4.3.3.9.复合属性名 4.3.4.方法注入 4.3.4.1.查询方法注入 4.3.4.2.替换任意方法 4.3.5.引用其他对象或类型的成员 4.3.5.1.使用对象或类的属性值进行注入 4.3.5.2.使用字段值进行注入 4.3.5.3.使用方法的返回值进行注入 4.3.6.IFactoryObject接口的其它实现 4.3.6.1.Log4Net 4.3.7.使用depends-on 4.3.8.自动装配协作对象 4.3.9.检查依赖项 4.4.类型转换 4.4.1.枚举类型的转换 4.4.2.内置的类型转换器 4.4.3.自定义类型转换器 4.4.3.1.使用CustomConverterConfigurer类 4.5.自定义对象的行为 4.5.生命周期接口 4.5.1.1.IInitializingObject接口和init-method属性 4.5.1.2.IDisposable接口和destroy-method属性 4.5.2.让对象了解自己的容器 4.5.2.1.IObjectFactoryAware接口 4.5.2.2.IObjectNameAware接口 4.5.3.IFactoryObject接口 4.6.抽象与子对象定义 4.7.与IObjectFactory接口交互 4.7.1.获得IFactoryObject对象本身,而非其产品 4.8.使用IObjectPostProcessor接口自定义对象 4.9.使用IObjectFactoryPostProcessor定制对象工厂 4.9.1.PropertyPlaceholderConfigurer类 4.9.1.1.使用环境变量进行替换 4.9.2.PropertyOverrideConfigurer类 4.10.使用alias节点为对象添加别名 4.11.IApplicationContext简介 4.12.配置应用程序上下文 4.12.1.注册自定义解析器 4.12.2.创建自定义资源处理器 4.12.3.配置类型别名 4.12.4.注册类型转换器 4.13.IApplicationContext接口的扩展功能 4.13.1.上下文继承 4.13.2.使用IMessageSource接口 4.13.3.在Spring.NET内部使用资源 4.13.4.松耦合事件模型 4.13.5.IApplicationContext的事件通知 4.14.定制IApplicationContex中对象的行为 4.14.1.IApplicationContextAware标识接口 4.14.2.IObjectPostProcessor接口 4.14.3.IObjectFactoryPostProcessor接口 4.14.4.PropertyPlaceholderConfigurer类 4.15.从其它文件中导入对象定义 4.16.服务定位器访问 第五章. IObjectWrapper接口和类型转换 5.1.简介 5.2.使用IObjectWrapper接口管理对象 5.2.1.读、写普通及嵌套的属性 5.2.2.其它功能 5.3.类型转换 5.3.1.转换枚举类型 5.4.内置类型转换器 第六章. IResource接口 6.1.简介 6.2.IResource接口 6.3.内置的IResource实现类 6.4.IResourceLoader接口 6.5.IResourceLoaderAware接口 6.6.应用程序上下文和IResource路径 第七章. 多线程和并发操作 7.1.简介 7.2.线程本地存储 7.3.同步基础 7.3.1.ISync 7.3.2.SyncHolder 7.3.3.Latch 7.3.4.Semaphore 第八章. 对象池 8.1.简介 8.2.接口和实现 第九章. Spring.NET杂记 9.1.简介 9.2.PathMatcher 9.2.1.通用规则 9.2.2.匹配文件名 9.2.3.匹配子目录 9.2.4.大小写需要考虑,斜线可以任意 第十章. 表达式求值 10.1.简介 10.2.表达式求值 10.3.语言参考 10.3.1.文字表达式 10.3.2.属性,数组,列表,字典,索引器 10.3.2.1.定义内联的数组、列表和词典 10.3.3.方法 10.3.4.操作符 10.3.4.1.关系操作符 10.3.4.2.逻辑操作符 10.3.4.3.算术运算符 10.3.5.赋值 10.3.6.表达式列表 10.3.7.类型 10.3.8.类型注册 10.3.9.构造器 10.3.10.变量 10.3.10.1.'#this'和'#root'变量 10.3.11.元操作符(If-Then-Else) 10.3.12.列表的投影(Projection)和选择(Selection) 10.3.13. 集合处理器和聚合器 10.3.13.1.Count聚合器 10.3.13.2.Sum聚合器 10.3.13.3.Average聚合器 10.3.13.4.Minimum聚合器 10.3.13.5.Maximum聚合器 10.3.13.6.nonNull处理器 10.3.13.7.distinct处理器 10.3.13.8.sort处理器 10.3.14.引用容器中的对象 10.3.15.Lambda表达式 10.3.16.空目标 10.4.本章使用的示例类型 第十一章. 验证框架 11.1.简介 11.2.用法示例 11.3.验证对象组 11.4.验证对象 11.4.1.条件验证对象 11.4.2.必需性验证对象 11.4.3.正则表达式验证对象 11.4.4.通用验证对象 11.4.5.条件型验证 11.5.验证行为 11.5.1.错误消息行为 11.5.2.通用行为 11.6.引用验证对象 11.7.在ASP.NET中的使用技巧 11.7.1.显示验证错误 11.7.1.1.配置错误显示类 第十章. 使用Spring.NET进行面向方面的编程 12.1.简介 12.1.1.AOP基本概念 12.1.2.Spring.NET AOP的功能 12.1.3.Spring.NET的AOP代理 12.2.Spring.NET中的切入点 12.2.1.概念 12.2.2.切入点的操作 12.2.3.Spring.NET提供的切入点实现类 12.2.3.1.静态切入点 12.2.3.2.动态切入点 12.2.4.自定义切入点 12.3.Spring.NET的通知类型 12.3.1.通知的生命周期 12.3.2.通知类型 12.3.2.1.拦截环绕通知 12.3.2.2.前置通知 12.3.2.3.异常通知 12.3.2.4.后置通知 12.3.2.5.引入通知 12.4.Spring.NET中的Advisor 12.5.使用ProxyFactoryObject创建AOP代理 12.5.1.基本原理 12.5.2.ProxyFactoryObject的属性 12.5.3.代理接口 12.5.4.代理一个类 12.6.使用ProxyFactory类以编程方式创建AOP代理 12.7.管理目标对象 12.8.使用“自动代理”功能 12.8.1.自动代理对象的定义 12.8.1.1.ObjectNameAutoProxyCreator 12.8.1.2.DefaultAdvisorAutoProxyCreator 12.8.1.3.AbstractAutoProxyCreator 12.8.2.使用特性驱动的自动代理 12.9.使用TargetSources 12.9.1.动态切换TargetSource 12.9.2.池化TargetSource 12.9.3.PrototypeTargetSource 12.10.定义新的通知类型 12.11.参考资源 第十章.通用日志抽象层 13.1.简介 13.1.1.Logging API 13.2.实现与配置 13.2.1.控制台Logger 13.3.Log4Net 第部分. 中间层数据访问 第十四章. 事务管理 14.1.简介 14.2.动机 14.3.核心接口 14.4.用事务进行资源同步 14.4.1.高层次方法 14.4.2.低层次方法 14.5.声明式事务管理 14.5.1.理解Spring.NET声明式事务管理的实现 14.5.2.第一个例子 14.5.3.Transaction特性的设置 14.5.4.通过AutoProxyCreator使用声明式事务 14.5.5.通过TransactionProxyFactoryObject使用声明式事务 14.5.6. 通过ProxyFactoryObject使用声明式事务 14.5.7. Using Abstract object definitions 14.5.8. Declarative Transactions using ProxyFactoryObject 14.6. 编程方式的事务管理 14.6.1.使用TransactionTemplate 14.6.2.使用IPlatformTransactionManager 14.7.选择编程方式还是声明方式 第十五章. 数据访问对象 15.1.简介 15.2.统一的异常体系 15.3.为数据访问对象提供的统一抽象基类 第十六章. DbProvider 16.1.简介 16.1.1.IDbProvider和DbProviderFactory 16.1.2. XML配置 16.1.3.管理连接字符串 第十七章. 使用ADO.NET进行数据访问 17.1.简介 17.2.动机 17.3.Provider抽象 17.3.1.创建IDbProvider类型的实例 17.4.命名空间 17.5.数据访问的方式 17.6.AdoTemplate简介 17.6.1.执行回调 17.6.2.在.NET 2.0中执行回调 17.6.3. .NET 1.1 17.6.4.AdoTemplate方法指南 17.7.异常翻译 17.8.参数管理 17.8.1. IDbParametersBuilder 17.8.2. IDbParameters 17.9. Mapping DBNull values 17.10. Basic data access operations 17.10.1. ExecuteNonQuery 17.10.2. ExecuteScalar 17.11. Queries and Lightweight Object Mapping 17.11.1. ResultSetExtractor 17.11.2. RowCallback 17.11.3. RowMapper 17.11.4. Query for a single object 17.11.5. Query using a CommandCreator 17.12. DataTable and DataSet 17.12.1. DataTables 17.12.2. DataSets 17.13. Deriving Stored Procedure Parameters 17.14. Database operations as Objects 17.14.1. AdoNonQuery 17.14.2. AdoQuery 17.14.3. MappingAdoQuery 17.14.4. Stored Procedure 17.14.5. DataSetOperation 18. ORM集成 18.1. 简介 第部分. Web框架 第十九章. Web框架 19.1.简介 19.2.自动装载应用程序上下文和应用程序上下文嵌套 19.2.1. 配置 19.2.2.上下文嵌套 19.3.为ASP.NET页面进行依赖注入 19.3.1.为Web控件进行依赖注入 19.4.Master Page 19.4.1.将子页面与Master Page关联 19.5.双向数据绑定 19.5.1.数据绑定的后台实现 19.5.1.1.绑定方向 19.5.1.2.Formatters 19.5.1.3.类型转换 19.5.1.4.数据绑定事件 19.6.本地化 19.6.1.使用Localizer进行自动本地化(“推”模型) 19.6.2.使用Localizer 19.6.3.手动应用资源(“拉”模型的本地化) 19.6.4.在Web应用程序中进行图像本地化 19.6.5.全局资源 19.6.6.用户语言文化管理 19.6.6.1. DefaultWebCultureResolver 19.6.6.2. RequestCultureResolver 19.6.6.3. SessionCultureResolver 19.6.6.4. CookieCultureResolver 19.6.7.更改语言文化 19.7.结果映射 19.8.客户端脚本 19.8.1.在HTML的head节点内注册客户端脚本 19.8.2.向节点中添加CSS定义 19.8.3.全局目录(Well-Known Directories) 第四部分. 服务 第十章. .NET Remoting 20.1.简介 20.2.在服务端发布SAO 20.2.1.SAO Singleton 20.2.2.SAO SingleCall 20.2.3.IIS应用程序配置 20.3.在客户端访问SAO 20.4.CAO 最佳实践 20.5.在服务端注册CAO 20.5.1.向CAO对象应用AOP通知 20.6.在客户端访问CAO 20.6.1.向客户端的CAO对象应用AOP通知 20.7. XML Schema for configuration 20.8.参考资源 第十一章. .NET企业服务 21.1.简介 21.2.服务组件 21.3.服务端 21.4.客户端 第章. Web服务 22.1.服务端 22.1.1.消除对.asmx文件的依赖 22.1.2.向web服务中注入依赖项 22.1.3.将PONO发布为web服务 22.1.4.将AOP代理发布为web服务 22.1.5.客户端的问题 22.2.客户端 22.2.1.WebServiceProxyFactory 22.2.2.WebServiceClientFactory 第章. Windows后台服务 23.1.备注 23.2.简介 23.3.Spring.Services.WindowsService.Process.exe应用程序 23.3.1.安装 23.3.2.配置 23.4.将应用程序上下文发布为Windows服务 23.4.1.service.config 23.4.1.1.让应用程序了解自身的位置 23.4.2.watcher.xml - 可选的配置 23.4.3.bin目录 - 可选 23.5.自定义或扩展 23.5.1. .config文件 第五部分. 与Visual Studio.NET集成 第十四章. 与Visual Studio.NET集成 24.1.XML编辑与验证 24.2.XML Schema的版本 24.3.集成API文档 第六部分. 快速入门程序 第十五章. IoC快速入门 25.1.简介 25.2.Movie Finder 25.2.1.开始建立MovieFinder应用程序 25.2.2.第一个对象定义 25.2.3.属性注入 25.2.4.构造器参数注入 25.2.5.总结 25.2.6.日志 25.3.应用程序上下文和IMessageSource接口 25.3.1.简介 25.4.应用程序上下文和IEventRegistry接口 25.4.1.简介 25.5.对象池示例 25.5.1.实现Spring.Pool.IPoolableObjectFactory 25.5.2.使用池中的对象 25.5.3.利用executor执行并行的grep 25.6.AOP 第十六章. AOP指南 26.1.简介 26.2.基础知识 26.2.1.应用通知 26.2.2.使用切入点-基本概念 26.3.深入探讨 26.3.1.其它类型的通知 26.3.1.1.前置通知 26.3.1.2.后置通知 26.3.1.3.异常通知 26.3.1.4.引入(mixins) 26.3.1.5.通知链 26.3.1.6.配置通知 26.3.2.使用特性定义切入点 26.4.The Spring.NET AOP Cookbook 26.4.1.缓存 26.4.2.性能监视 26.4.3.重试规则 Spring.NET AOP最佳实践 第十七章. .NET Remoting快速入门 27.1.简介 27.2.Remoting实例程序 27.3.实现 27.4.运行程序 27.5.Remoting Schema 27.6.参考资源 第十八章. Web框架快速入门 28.1.简介 第十九章. SpringAir - 参考程序 29.1.简介 29.2.架构 29.3.实现 29.3.1.业务层 29.3.2.服务层 29.3.3.Web层 29.4.总结 第十章. 数据访问快速入门 30.1.简介 第十一章. 事务管理快速入门 31.1.简介 31.2.应用程序概述 31.2.1.接口 第七部分. Java开发人员必读 第章. Java开发人员必读 32.1.简介 32.2.Beans和Objects 32.3.PropertyEditor和TypeConverter 32.4.ResourceBundle和ResourceManager 32.5.异常 32.6.应用程序配置 32.7.AOP框架
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值