第四章 Spring.Net 如何管理您的类___对象的生命周期链

各位，实在不好意思，因为有事，博客几天没更新了。前面有童鞋提到，配置 Objects.xml 路径的相关问题，这些东西是 IResource 接口的一些内容。在下一章会详细介绍。

　　传统的Net应用中，对象的生命周期非常简单。.Net中的关键词 new 用来实例化对象（或许它是非序列化的）。这样就够用了。相反，对象 的生命周期在 Spring.Net 容器中更加细致。理解 Spring.Net 对象的生命周期非常重要，因为你或许要利用 Spring.Net 提供的机制来订制对象的创建过程。我们在前面几章讨论了 Spring.Net 对象生命周期中大部分常用的细节。本小节我们来把前面零零散散的这些细节汇总一下。

一 . IObjectFactory 中的生命周期

　　下面这附图是 Spring.Net 对象在 IObjectFactory 中的生命周期:

(1)     容器寻找到对象的 定义信息 并且将其实例化。

(2)     受用依赖注入，Spring.Net 按照对象定义信息配置对象的所有属性。

(3)     如果对象实现了 IObjectNameAware 接口，工厂调用对象的设置 ObjectName 的方法传入对象名称。

(4)     如果对象实现了 IObjectFactoryAware 接口，工厂调用对象的设置 ObjectFactory 的方法传入工厂自身。

(5)     如果 IObjectPostProcessor 实现类和对象关联，那么它们的 PostProcessBeforeInitialization 方法将被调用。

(6)     如果对象指定了 init-method 方法，它将被调用。

(7)     如果有 IObjectPostProcessor 实现类和对象关联，那么它们的 PostProcessAfterInitialization 方法将被调用。 到这个时候，对象已经可以被应用系统使用了，并且将被保留在 IObjectFactory 中。如果知道它不再需要了，则有两种常见的方法可以把它从 对象 Factory 中删除掉。

　　① 如果对象实现了 System.IDisposable 接口，Dispose() 方法被调用。

　　② 如果指定了订制的销毁方法，就调用这个方法。

二 . IApplicationContext的生命周期

　　对象在 IApplicationContext 的生命周期与在 IObjectFactory 中的生命周期只有一点不同，唯一不同的是，如果对象实现了 IApplicationContextAware 接口，设置ApplicationContext 的方法被调用。如下图：

　　下面，我们用代码的方式来看下 对象的生命周期链 。废话不多说，直接上代码，来看：

 1 using System;
 2 using Spring.Objects.Factory;
 3 using Spring.Context;
 4
 5 namespace CnblogLesson_4_9.Model
 6 {
 7     public class Person : IPerson, IObjectNameAware, IObjectFactoryAware, IApplicationContextAware
 8     {
 9         private string _objectName;
10         private IObjectFactory _iObjectFactory;
11         private IApplicationContext applicationContext;
12
13         public Person() {
14             Console.WriteLine("调用Person的构造函数");
15         }
16
17         public void Init() {
18             Console.WriteLine("调用Person的Init方法");
19         }
20
21         public void Destroy() {
22             Console.WriteLine("调用Person的Destroy方法");
23         }
24
25         public string ObjectName
26         {
27             set {
28                 _objectName = value;
29                 Console.WriteLine("调用IObjectNameAware的设置ObjectName方法");
30             }
31         }
32
33         public IObjectFactory ObjectFactory
34         {
35             set
36             {
37                 _iObjectFactory = value;
38                 Console.WriteLine("调用IObjectFactoryAware的设置ObjectFactory方法");
39             }
40         }
41
42         public IApplicationContext ApplicationContext
43         {
44             set
45             {
46                 applicationContext = value;
47                 Console.WriteLine("调用IApplicationContextAware的设置ApplicationContext方法");
48             }
49         }
50     }
51 }

　　Person 这个类实现 ，IPerson, IObjectNameAware, IObjectFactoryAware, IApplicationContextAware 接口。

 1 using System;
 2 using Spring.Objects.Factory.Config;
 3
 4 namespace CnblogLesson_4_9.Model
 5 {
 6     class HexuObjectPostProcessor : IObjectPostProcessor
 7     {
 8         public object PostProcessAfterInitialization(object instance, string objectName)
 9         {
10             Console.WriteLine("调用了IObjectPostProcessor的PostProcessAfterInitialization方法");
11             return instance;
12
13         }
14
15         public object PostProcessBeforeInitialization(object instance, string name)
16         {
17             Console.WriteLine("调用了IObjectPostProcessor的PostProcessBeforeInitialization方法");
18             return instance;
19         }
20     }
21 }

　　HexuObjectPostProcessor 实现了 IObjectPostProcessor 接口。

　　Objects.xml 的配置如下：

1 <?xml version="1.0" encoding="utf-8" ?>
2 <objects xmlns="http://www.springframework.net">
3
4   <object id="hexu" type="CnblogLesson_4_9.Model.Person,CnblogLesson_4_9" init-method="Init" destroy-method="Destroy"/>
5
6   <object type="CnblogLesson_4_9.Model.HexuObjectPostProcessor,CnblogLesson_4_9"/>
7 </objects>

　　然后我们来运行程序:

　　通过结果，我们可以看到，Spring.Net 中 对象的生命周期链的全过程。

　　Spring.Net 提供了一个容器（大工厂），通过这个容器我们可以完成：组件实例化，依赖装配，生命周期控制；

　　有了这个容器后开发就变成这样：

　　① 使用和配置是分离的，程序关心是如何做事情，而不关心依赖从哪里来，程序只关心你把东西给我就行。由容器通过读取相应的配置来完成依赖注入。

　　② 配置分离后，我们可以通过更改配置来改变，程序的策略，而不需要重新编译代码。

　　③ 提供了一个对象生命周期链条，在这个链条上可以完成很多事情，如：装载，实例化，销毁等等。