第四章 Spring.Net 如何管理您的类___自定义对象行为

Spring.Net 一直讲求 ” 配置应用程序“，有一种需求在实际开发中不太常用，却非常有用 -> 配置对象的行为，Spring.Net 也能够完美的实现。Spring.Net 通过几个专门的接口来控制容器中对象的行为。比如说，我们可以自定义对象初始化行为，自定义对象销毁行为，抽象对象定义和子对象定义等。在下面会介绍常用的几中 自定义对象行为：

① 自定义对象初始化行为

② 自定义对象销毁行为

③ 抽象对象定义

④ 子对象定义

⑤ IObjectPostProcessor及扩展类(对象后处理器)

一 . 自定义初始化行为和销毁行为

Spring.Net 通过几个专门的接口来控制容器中对象的行为，这些接口包括 Spring.Net 定义的 IInitializingObject接口 和标准的 System.IDisposable 接口。容器会在实现了这两个接口的对象上调用 AfterPropertyiesSet()方法 和 Dispose()方法，这样我们就有机会在对象初始化和销毁时做一些额外的工作。

通过 Spring.Net 定义的 IInitializingObject接口 可以实现自定义初始化行为。在VS中通过对象浏览器我们可以看到 Spring.Objects.Factory.IInitializingObject 接口，只有一个方法:

void AfterPropertiesSet：在对象的所有属性被设置之后由容器调用。在该方法中，我们可以检查必需的属性是否都已被正确设值，或者可以执行进一步的初始化工作。此方法可以抛出任何异常以标识配置错误、初始化失败等情况。

我们前面讨论了如何初始化，接下来我们讨论通过标准的 System.IDisposable接口 可以实现自定义销毁行为。通过 System.IDisposable接口 使我们有机会在容器被销毁时，通过对象的回调方法来处理容器中对象的销毁工作。该接口只有一个方法：

void Dispose()：当容器被销毁时调用。在此可释放对象保留的任何资源（比如数据库连接）。可在此方法中抛出任何异常，但是此处抛出的任何异常都不会阻止容器的销毁，只会被记录到日志中。

来看一下代码：

using System; 2 using System.Collections.Generic; 3  4 namespace CnblogLesson_4_5.Model 5 { 6     /// <summary> 7     /// 人类 8     /// </summary> 9     public class Person : Spring.Objects.Factory.IInitializingObject , System.IDisposable10     {11         public Person() {12             Console.WriteLine("Person 的构造函数");13         }14 15         public void AfterPropertiesSet()16         {17             Console.WriteLine("实现Spring.Objects.Factory.IInitializingObject");18         }19 20 21         public void Dispose()22         {23             Console.WriteLine("实现System.IDisposable接口");24         }25     }26 }

运行程序，看一下结果：

using System; 2 using Spring.Context; 3 using Spring.Context.Support; 4 using CnblogLesson_4_5.Model; 5  6 namespace CnblogLesson_4_5 7 { 8     class Program 9     {10         static void Main(string[] args)11         {12             //通过IApplicationContext来配置13             IApplicationContext context = ContextRegistry.GetContext();14             Person hexu = context.GetObject("hexu") as Person;15 16             Console.ReadKey();17         }18     }19 }

可以看到  AfterPropertiesSet() 方法在 Person 类的构造函数之后调用。

注意:

Spring.Net 有一点好处就是，几乎所有的需求都可以通过配置来完成。一般来说，尽量不要使用 IInitializingObject接口 或 IDisposable接口 。我们可以在XML中配置object 节点的 init-method属性 或 destroy-method属性 。配置完成之后，Spring.Net 的 IOC 容器就会帮我们在该对象被实例时调用 init-method 设置的方法 ,在容器被销毁时调用 destroy-method 设置的方法。

来看一下代码：

using System; 2  3 namespace CnblogLesson_4_5.Model 4 { 5     public class Friend 6     { 7         public Friend() 8         { 9             Console.WriteLine("Friend 的构造函数");10         }11 12         public void Init()13         {14             Console.WriteLine("手动配置init-method=Init");15         }16 17         public void Destroy()18         {19             Console.WriteLine("手动配置destroy-method=Destroy");20         }21     }22 }

Objects.xml 配置：

<?xml version="1.0" encoding="utf-8" ?><objects xmlns="http://www.springframework.net">  <!---手动配置 初始化方法和销毁方法-->  <object id="jeery" type="CnblogLesson_4_5.Model.Friend,CnblogLesson_4_5" init-method="Init" destroy-method="Destroy">      </object>  </objects>

Program.cs 文件：

using System; 2 using Spring.Context; 3 using Spring.Context.Support; 4 using CnblogLesson_4_5.Model; 5  6 namespace CnblogLesson_4_5 7 { 8     class Program 9     {10         static void Main(string[] args)11         {12             Console.WriteLine("\n\n\n");13 14             //通过IApplicationContext来配置15             IApplicationContext context = ContextRegistry.GetContext();16             17             Person hexu = context.GetObject("hexu") as Person;18             Friend jeery = context.GetObject("jeery") as Friend; 19             20             Console.ReadKey();21         }22     }23 }

通过运行程序，可以看到 jeery 对象的 Init 方法被调用：

二 . 抽象对象定义和子对象定义

在 Spring.Net 对象定义中，对象定义可能会包含大量的信息，比如与容器相关的信息（即初始化方法、静态工厂方法名等）、构造器参数和属性值等。也许有很多很多的信息是重复的，这个时候如果我们把每一个定义都写在配置文件中，那么配置文件就会很大啊。

而根据面向对象的方式，有很多重复的工作，我们可以使用继承来实现。

好在 Spring.Net 中也帮我们提供了类似继承这样的机制。但是 Spring.Net 中这里说的继承和面向对象的继承是不一样的，在这里的继承不是真正的继承，它类似设计模式中的模板方法模式，子对象定义是指从一个父对象定义中继承了配置数据的对象定义。子对象定义可以根据需要重写或添加某些配置的值。使用父对象和子对象的定义方式可能会节省大量的键入工作。子对象和父对象实质上并没有继承的关系，只是使用了父对象的一些信息。

在 Spring.NET，子对象定义由 ChildObjectDefintion类 处理。但用户一般不会直接接触到该类，仍可使用 XML 对象定义进行配置。在 XML 对象定义中，通过 parent属性 标识一个对象定义是子对象定义，该属性的值即为父对象定义的名称。

来看一下示例代码:

using System; 2 using System.Collections.Generic; 3  4 namespace CnblogLesson_4_6.Model 5 { 6     /// <summary> 7     /// Child 类，没有继承Parent，它比Parent类多一个Age的属性 8     /// </summary> 9     public class Child10     {11         public string Name { get; set; }12         public int Age { get; set; }13     }14 15 }

using System; 2  3 namespace CnblogLesson_4_6.Model 4 { 5     /// <summary> 6     /// Parent类，为一个抽象类，有一个Name属性 7     /// </summary> 8     public abstract class Parent 9     {10         public string Name { get; set; }11     }12 13 }

我们通过常规方式，来装载对象时，Child 和 Parent 类都需要装载 Name 属性。而Spring提供了一种模板方法的方式来配置对象。

配置文件如:

<?xml version="1.0" encoding="utf-8" ?> 2 <objects xmlns="http://www.springframework.net"> 3  4   <!--抽象对象定义和子对象定义--> 5   <object id="parent" type="CnblogLesson_4_6.Model.Parent, CnblogLesson_4_6" abstract="true"> 6     <property name="Name" value="parent"/> 7   </object> 8  9   <object id="child" type="CnblogLesson_4_6.Model.Child, CnblogLesson_4_6" parent="parent">10     <property name="Age" value="18"/>11   </object>12 13 </objects>

通过 parent 我们可以指定 id="child" 的对象，是使用 id="parent" 对象的配置。

通过运行程序，监视变量，我们来看一下，child 和 parent并没有继承关系，只是使用了 parent 的配置而已。

我们可以通过上面的例子看到，没有在子对象定义中显式指定的属性会从父对象定义中继承值；同时子对象定义也可覆盖父对象定义的属性值。这种情况来说，子对象必须与父对象兼容，也就是说，子对象必须能够接受父对象的属性值。子对象定义可继承或覆盖父对象定义的构造器参数、属性值及方法，也可以添加新值。如果子对象指定了初始化方法、销毁方法和/或静态工厂方法，就会覆盖父对象定义中的相应配置。

但是还有一些设置，子对象是不会从父对象继承过来的。比如：depends-on属性的值、自动装配模式、依赖检查模式、singleton和lazy-init属性的值等。即子对象定义不会从父对象定义继承这些属性，举例来说，若父对象（抽象）定义了depends-on，而子对象未定义，那么子对象就没有依赖项。

如果父对象定义未指定类型...

比如:

<object id="parent">2     <property name="Name" value="parent"/>3 </object>

那么父对象肯定是不能被初始化的，因为它的定义是不完整的。这种定义也被隐式的看作为抽象定义。对象定义也可通过 abstract 属性显式指定为抽象定义，该属性的有效值是 true 或者 false。前面我们对父对象设置过 abstract="true" 属性，就是一个抽象定义。

一个抽象的定义仅仅是为用做模版，或者说是作为子对象定义的父对象定义而存在。将对象定义声明为抽象可防止容器创建该对象。在试图创建实例化或获取该对象的时候，系统就抛出 ObjectIsAbstractException 异常。而在 Spring 容器内负责预创建对象的 PreInstantiateSingletons 方法会忽略抽象的对象定义。

特别要注意的是: IApplicationContext（应用程序上下文） 接口的实现类，而非简单的对象工厂。在默认情况下会预先创建所有的 singleton 对象。所以，对应用程序上下文来说，下面一点非常重要（至少对于 singleton对象 来说）：如果要定义一个仅用做模版的（父）对象定义，而且在该定义中指定了类型，那么就必须保证将其 abstract属性 设为true，否则应用程序上下文会尝试预创建这个对象。

这里写了太多了，IObjectPostProcessor及扩展类(对象后处理器)就留在下篇写吧!

 示例代码 ： http://download.csdn.net/detail/cilence6788/5108211