第四章 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 的方法被调用。如下图：

 

 

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

using System;
using Spring.Objects.Factory;
using Spring.Context;

namespace CnblogLesson_4_9.Model
{
    public class Person : IPerson, IObjectNameAware, IObjectFactoryAware, IApplicationContextAware
    {
        private string _objectName;
        private IObjectFactory _iObjectFactory;
        private IApplicationContext applicationContext;

        public Person() {
            Console.WriteLine("调用Person的构造函数");
        }

        public void Init() {
            Console.WriteLine("调用Person的Init方法");
        }

        public void Destroy() {
            Console.WriteLine("调用Person的Destroy方法");
        }

        public string ObjectName
        {
            set { 
                _objectName = value;
                Console.WriteLine("调用IObjectNameAware的设置ObjectName方法");
            }
        }

        public IObjectFactory ObjectFactory
        {
            set
            {
                _iObjectFactory = value;
                Console.WriteLine("调用IObjectFactoryAware的设置ObjectFactory方法");
            }
        }

        public IApplicationContext ApplicationContext
        {
            set
            {
                applicationContext = value;
                Console.WriteLine("调用IApplicationContextAware的设置ApplicationContext方法");
            }
        }
    }
}

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

using System;
using Spring.Objects.Factory.Config;

namespace CnblogLesson_4_9.Model
{
    class HexuObjectPostProcessor : IObjectPostProcessor
    {
        public object PostProcessAfterInitialization(object instance, string objectName)
        {
            Console.WriteLine("调用了IObjectPostProcessor的PostProcessAfterInitialization方法");
            return instance;

        }

        public object PostProcessBeforeInitialization(object instance, string name)
        {
            Console.WriteLine("调用了IObjectPostProcessor的PostProcessBeforeInitialization方法");
            return instance;
        }
    }
}

　　HexuObjectPostProcessor 实现了 IObjectPostProcessor 接口。

　　Objects.xml 的配置如下：

<?xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net">

  <object id="hexu" type="CnblogLesson_4_9.Model.Person,CnblogLesson_4_9" init-method="Init" destroy-method="Destroy"/>

  <object type="CnblogLesson_4_9.Model.HexuObjectPostProcessor,CnblogLesson_4_9"/>
</objects>

　　然后我们来运行程序:

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

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

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

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

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

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