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()：当容器被销毁时调用。在此可释放对象保留的任何资源（比如数据库连接）。可在此方法中抛出任何异常，但是此处抛出的任何异常都不会阻止容器的销毁，只会被记录到日志中。
来看一下代码：
1 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.IDisposable
10 {
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 }
运行程序，看一下结果：
1 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 设置的方法。
来看一下代码：
1 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 文件：
1 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("
");
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属性 标识一个对象定义是子对象定义，该属性的值即为父对象定义的名称。
来看一下示例代码:
1 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 Child
10 {
11 public string Name { get; set; }
12 public int Age { get; set; }
13 }
14
15 }
1 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提供了一种模板方法的方式来配置对象。
配置文件如:
1 <?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，而子对象未定义，那么子对象就没有依赖项。
如果父对象定义未指定类型...
比如:
1 <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及扩展类(对象后处理器)就留在下篇写吧!