导航

• 首页

• 随机页
• 创建新页
• 所有页面
• 分类

• 系统管理
• 文件管理

• 登录/注销
• 选择语言
• 个人设置
• 创建账户

• Wiki 帮助

Spring.NET框架 1.1 参考文档：第四章 对象、对象工厂和应用程序上下文

4.1. 简介

4.2. IObjectFactory,IApplicationContext和IObjectDefinition接口介绍

4.2.1. IObjectFactory和IApplicationContext

[C#]
IResource input = new FileSystemResource ("objects.xml");
IObjectFactory factory = new XmlObjectFactory(input);

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;

<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>

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

IApplicationContext ctx = ContextRegistry.GetContext();

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

<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>

<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>

4.2.2.对象定义

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

4.2.3.对象的创建

4.2.3.1.通过构造器创建对象

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

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

4.2.3.2.通过静态工厂方法创建对象

<object id="exampleObject"
 type="Examples.ExampleObjectFactory, ExamplesLibrary"
 factory-method="CreateInstance"/>

4.2.3.3.通过实例工厂方法创建对象

<!-- the factory object, which contains an instance method called 'CreateInstance' -->
<object id="exampleFactory" type="..."/>
<!-- the object that is to be created by the factory object -->
<object id="exampleObject"
      factory-method="CreateInstance"
      factory-object="exampleFactory"/>

4.2.4.泛型类的对象创建

4.2.4.1.通过构造器创建泛型对象

namespace GenericsPlay
{
    public class FilterableList<T>
    {
        private List<T> list;
        
        private String name;

        public List<T> Contents
        {
            get { return list; }
            set { list = value; }
        }

        public String Name
        {
            get { return name; }
            set { name = value; }
        }
        
        public List<T> ApplyFilter(string filterExpression)
        {
            /// should really apply filter to list ;)
            return new List<T>();
        }

    }
}

<object id="myFilteredIntList" type="GenericsPlay.FilterableList<int>, GenericsPlay">
  <property name="Name" value="My Integer List"/>
</object>

<typeAliases>
 <alias name="GenericDictionary" type=" System.Collections.Generic.Dictionary<,>" />
 <alias name="myDictionary" type="System.Collections.Generic.Dictionary<int,string>" />
</typeAliases>

<object id="myGenericObject" 
        type="GenericsPlay.ExampleGenericObject<System.Collections.Generic.Dictionary<int , string>>, GenericsPlay" />

<object id="myOtherGenericObject" 
        type="GenericsPlay.ExampleGenericObject<GenericDictionary<int , string>>, GenericsPlay" />

<object id="myOtherOtherGenericObject" 
        type="GenericsPlay.ExampleGenericObject<MyIntStringDictionary>, GenericsPlay" />

4.2.4.2.通过静态工厂方法创建泛型类

public class TestGenericObject<T, U>
{
    public TestGenericObject()
    {
    }

    private IList<T> someGenericList = new List<T>();
    
    private IDictionary<string, U> someStringKeyedDictionary =
        new Dictionary<string, U>();

    public IList<T> SomeGenericList
    {
        get { return someGenericList; }
        set { someGenericList = value; }
    }

    public IDictionary<string, U> SomeStringKeyedDictionary
    {
        get { return someStringKeyedDictionary; }
        set { someStringKeyedDictionary = value; }
    }
}

public class TestGenericObjectFactory
{
    public static TestGenericObject<V, W> StaticCreateInstance<V, W>()
    {
        return new TestGenericObject<V, W>();
    }

    public TestGenericObject<V, W> CreateInstance<V, W>()
    {
        return new TestGenericObject<V, W>();
    }
}

<object id="myTestGenericObject"
        type="GenericsPlay.TestGenericObjectFactory, GenericsPlay"
        factory-method="StaticCreateInstance<System.Collections.Generic.List<int>,int>"/>

4.2.4.3.通过实例工厂方法创建泛型对象

<object id="exampleFactory" type="GenericsPlay.TestGenericObject<int,string>, GenericsPlay"/>
<object id="anotherTestGenericObject"
        factory-object="exampleFactory" 
        factory-method="CreateInstance<System.Collections.Generic.List<int>,int>"/>

4.2.5. 对象标识符（id和name）

4.2.6.Singleton和Prototype

<object id="exampleObject" type="Examples.ExampleObject, ExamplesLibrary"
  singleton="false"/>
<object name="yetAnotherExample" type="Examples.ExampleObjectTwo, ExamplesLibrary"
  singleton="true"/>

4.3.属性，协作对象，自动装配和依赖检查

4.3.1.设置对象的属性和协作对象

• 属性注入（按：即设值方法注入，setter-based dependency injection，但对于.NET来说，恐怕称为属性注入更为合适）：在创建对象以后，通过（调用）属性（的设值方法）将依赖项注入。 Spring.NET建议使用属性注入，因为构造器的参数如果太多的话，会使类的代码和对象定义变得很臃肿，特别是在某些属性为可选的时候（即不一定非要注入）。
• 构造器注入（constructor-based dependency injection）：调用含参构造器，在对象创建时将依赖项通过构造器参数注入。虽然Spring.NET建议尽量使用属性注入，但也完全支持构造器注入，因为有时候我们只能使用具有含参构造器且没有定义属性的旧类型。另外，对比较简单的对象来说，某些人可能更喜欢使用构造器注入，以确保对象在创建以后马上处于有效的状态。

• 根据包含对象定义的配置信息来创建和初始化容器。大多数用户都会使用支持XML配置文件的IObjectFactory或IApplicationContext实现类作为容器。
• 每个对象的依赖项都通过属性或构造器配置在对象定义中。当对象被创建时，容器会将依赖项注入给对象。
• 属性或构造器参数既可以设置为实际的值，也可以设为同一容器中其它对象的引用。如果用IApplicationContext作为容器，也可以引用父容器中的对象。
• 配置给属性或构造器参数的值必须能够转型为属性或参数的实际类型。默认情况下，Spring.NET可以将字符串值转型为任意基元类型，如int， long，bool等。另外，基于XML的容器也可以使用XML节点配置IList、IDictionary和Set等集合类型的值， Spring.NET会使用TypeConverter将字符串值转换为其它任意类型。可参考5.3,类型转换以了解TypeConverter的详细信息，以及使用Spring.NET自动转换自定义类型的方法。（按：Set是Spring.NET提供的集合类型）
• 在容器本身被创建的时候，Spring.NET会验证容器内每个对象的配置信息，并验证该对象的依赖项也是有效的（即：对象引用的对象也要定义在同一 IObjectFacotry中，对于IApplicationContext，也可以定义在父容器中）。但是属性的赋值仅在对象被创建时才会发生。对于一个以singleton模式布署、非惰性创建的对象（比如定义在IApplicationContext中的singleton对象）来说，对象的创建就发生在容器本身被创建的时候；否则（按：惰性创建，或非singleton时）就发生在对象被请求的时候。当一个对象被创建时，可能会导致其它一系列对象同时被创建，因为对象的依赖项，以及依赖项的依赖项此时都需要被创建并赋值。
• 一般情况下Spring.NET可以把这些事情做的很好。在载入容器时，Spring.NET会处理配置中出现的问题，比如引用了一个不存在的对象定义或发生循环依赖等等。而属性的设置和依赖项的解析（即在需要时创建所有依赖项的行为）则会推迟到对象实际被创建时才会执行。也就是说，如果某个对象或其依赖项无法正确创建，那么即便是容器可以正常创建，在请求这个对象时也会抛出异常。例如，如果遗漏了本该赋值的属性，或者所赋予的属性值无效时，会抛出异常而导致该对象无法正确创建。这也是IApplicationContext使用非惰性singleton模式作为默认布署方式的原因。所有对象都在实际需要前被创建，这种时间和空间上的开销可以保证IApplicationContext在创建时及早发现问题。如果愿意，可随时覆盖这一默认行为，将任意对象设置为惰性创建。

<object id="exampleObject" type="Examples.ExampleObject, ExamplesLibrary">
    <property name="objectOne" ref="anotherExampleObject"/>
    <property name="objectTwo" ref="yetAnotherObject"/>
    <property name="IntegerProperty" value="1"/>
</object>
<object id="anotherExampleObject" type="Examples.AnotherObject, ExamplesLibrary"/>
<object id="yetAnotherObject" type="Examples.YetAnotherObject, ExamplesLibrary"/>

[C#]
public class ExampleObject
{
  private AnotherObject objectOne;
  private YetAnotherObject objectTwo;
  private int i;
  
  public AnotherObject ObjectOne
  {
    set { this.objectOne = value; }
  }
  
  public YetAnotherObject ObjectTwo
  {
    set { this.objectTwo = value; }
  }
  
  public int IntegerProperty
  {
    set { this.i = value; }
  }  
}

<object id="exampleObject" type="Examples.ExampleObject, ExamplesLibrary">
    <constructor-arg name="objectOne" ref="anotherExampleObject"/>
    <constructor-arg name="objectTwo" ref="yetAnotherObject"/>
    <constructor-arg name="IntegerProperty" value="1"/>
</object>

<object id="anotherExampleObject" type="Examples.AnotherObject, ExamplesLibrary"/>

<object id="yetAnotherObject" type="Examples.YetAnotherObject, ExamplesLibrary"/>

Public Class ExampleObject

    Private myObjectOne As AnotherObject
    Private myObjectTwo As YetAnotherObject
    Private i As Integer
    
    Public Sub New (
        anotherObject as AnotherObject,
        yetAnotherObject as YetAnotherObject,
        i as Integer)
        
        myObjectOne = anotherObject
        myObjectTwo = yetAnotherObject
        Me.i = i
    End Sub
End Class

<object id="exampleObject" type="Examples.MixedIocObject, ExamplesLibrary">
    <constructor-arg name="objectOne" ref="anotherExampleObject"/>
    <property name="objectTwo" ref="yetAnotherObject"/>
    <property name="IntegerProperty" value="1"/>
</object>

<object id="anotherExampleObject" type="Examples.AnotherObject, ExamplesLibrary"/>

<object id="yetAnotherObject" type="Examples.YetAnotherObject, ExamplesLibrary"/>

[C#]
public class MixedIocObject
{
  private AnotherObject objectOne;
  private YetAnotherObject objectTwo;
  private int i;
  
  public MixedIocObject (AnotherObject obj)
  {
    this.objectOne = obj;
  }
  
  public YetAnotherObject ObjectTwo
  {
    set { this.objectTwo = value; }
  }
  
  public int IntegerProperty
  {
    set { this.i = value; }
  }  
}

<object id="exampleObject" type="Examples.ExampleFactoryMethodObject, ExamplesLibrary"
     factory-method="CreateInstance">
    <constructor-arg name="objectOne" ref="anotherExampleObject"/>
    <constructor-arg name="objectTwo" ref="yetAnotherObject"/>
    <constructor-arg name="intProp" value="1"/>
</object>

<object id="anotherExampleObject" type="Examples.AnotherObject, ExamplesLibrary"/>

<object id="yetAnotherObject" type="Examples.YetAnotherObject, ExamplesLibrary"/>

[C#]
public class ExampleFactoryMethodObject
{
  private AnotherObject objectOne;
  private YetAnotherObject objectTwo;
  private int i;
  
  // a private constructor
  private ExampleFactoryMethodObject()
  {
  }

  public static ExampleFactoryMethodObject CreateInstance(AnotherObject objectOne,
                               YetAnotherObject objectTwo,
                               int intProp)
  {
    ExampleFactoryMethodObject fmo = new ExampleFactoryMethodObject();
    fmo.AnotherObject = objectOne;
    fmo.YetAnotherObject = objectTwo;
    fmo.IntegerProperty = intProp;
    return fmo;
  }

  // Property definitions

}

4.3.2.构造器参数解析（按：构造子决议）

using System;

namespace SimpleApp
{
  public class ExampleObject
  {
    private int years;              //No. of years to the calculate the Ultimate Answer

    private string ultimateAnswer;  //The Answer to Life, the Universe, and Everything

    public ExampleObject(int years, string ultimateAnswer)
    {
       this.years = years;
       this.ultimateAnswer = ultimateAnswer;
    }

    public string UltimateAnswer
    {
      get { return this.ultimateAnswer; }
    }

    public int Years
    {
      get { return this.years; }
    }
  }
}

4.3.2.1.根据参数类型匹配构造器参数

<object name="exampleObject" type="SimpleApp.ExampleObject, SimpleApp">
  <constructor-arg type="int" value="7500000"/>
  <constructor-arg type="string" value="42"/>
</object>

4.3.2.2.根据参数索引匹配构造器参数

<object name="exampleObject" type="SimpleApp.ExampleObject, SimpleApp">
  <constructor-arg index="0" value="7500000"/>
  <constructor-arg index="1" value="42"/>
</object>

4.3.2.3.根据名称匹配构造器参数

<object name="exampleObject" type="SimpleApp.ExampleObject, SimpleApp">
  <constructor-arg name="years" value="7500000"/>
  <constructor-arg name="ultimateAnswer" value="42"/>
</object>

4.3.3.详细讨论对象属性和构造器参数

<objects xmlns="http://www.springframework.net">
  <object id="myConnection" type="System.Data.SqlClient.SqlConnection">
      <!-- results in a call to the setter of the ConnectionString property -->
      <property
          name="ConnectionString"
          value="Integrated Security=SSPI;database=northwind;server=mySQLServer"/>
  </object>
</objects>

4.3.3.1.设置空值

<object type="Examples.ExampleObject,
      ExamplesLibrary"> <property
      name="email"><value></value></property>
      <!-- equivalent, using value attribute as opposed to nested -->
      <value/> element... 
      <property name="email" value=""/> 
</object>

exampleObject.Email = "";

<object type="Examples.ExampleObject, ExamplesLibrary">
   <property name="email">
     <null/>
   </property>
</object>

exampleObject.Email = null;

4.3.3.2.设置集合值

<objects xmlns="http://www.springframework.net">
  <object id="moreComplexObject" type="Example.ComplexObject">
      <!--
      results in a call to the setter of the SomeList (System.Collections.IList) property
      -->
      <property name="SomeList">
          <list>
              <value>a list element followed by a reference</value>

              <ref object="myConnection"/>
          </list>
      </property>
      <!--
      results in a call to the setter of the SomeDictionary (System.Collections.IDictionary) property
      -->
      <property name="SomeDictionary">
          <dictionary>

              <entry key="a string => string entry" value="just some string"/>
              <entry key-ref="myKeyObject" value-ref="myConnection"/>
          </dictionary>
      </property>
      <!--
      results in a call to the setter of the SomeNameValue (System.Collections.NameValueCollection) property
      -->

      <property name="SomeNameValue">
          <name-values>
              <add key="HarryPotter" value="The magic property"/>
              <add key="JerrySeinfeld" value="The funny (to Americans) property"/>
          </name-values>
      </property>

      <!-- 
      results in a call to the setter of the SomeSet (Spring.Collections.ISet) property 
      -->
      <property name="someSet">
          <set>
              <value>just some string</value>
              <ref object="myConnection"/>

          </set>
      </property>
  </object>
</objects>

4.3.3.3.设置泛型集合的值

public class LotteryTicket
{
 List<int> list;
 DateTime date;
 public List<int> Numbers
 {
 set { list = value; }
 get { return list; }
 }

 public DateTime Date
 {
 get { return date; }
 set { date = value; }
 }
}

<object
      id="MyLotteryTicket"
      type="GenericsPlay.Lottery.LotteryTicket, GenericsPlay">
      <property name="Numbers">
          <list element-type="int"> 
              <value>11</value>
              <value>21</value> 
              <value>23</value>
              <value>34</value> 
              <value>36</value>
              <value>38</value> 
          </list> 
      </property>

      <property name="Date" value="4/16/2006"/>
</object>

public class GenericExpressionHolder
{
 private System.Collections.Generic.IList<IExpression> expressionsList;
 private System.Collections.Generic.IDictionary<string, IExpression> 
           expressionsDictionary;

 public System.Collections.Generic.IList<IExpression> ExpressionsList
 {
 set { this.expressionsList = value; }
 }

 public System.Collections.Generic.IDictionary<string,IExpression> 
      ExpressionsDictionary
 {
 set { this.expressionsDictionary = value; }
 }

 public IExpression this[int index]
 {
 get { return this.expressionsList[index]; }
 }

 public IExpression this[string key]
 {
 get { return this.expressionsDictionary[key]; }
 }
}

<object id="genericExpressionHolder" 
 type="Spring.Objects.Factory.Xml.GenericExpressionHolder, Spring.Core.Tests">
 <property name="ExpressionsList">
 <list element-type="Spring.Expressions.IExpression, Spring.Core">
 <value>1 + 1</value>
 <value>date('1856-7-9').Month</value>
 <value>'Nikola Tesla'.ToUpper()</value>
 <value>DateTime.Today > date('1856-7-9')</value>
 </list>
 </property>
 <property name="ExpressionsDictionary">
 <dictionary key-type="string" 
  value-type="Spring.Expressions.IExpression, Spring.Core">
 <entry key="zero">
 <value>1 + 1</value>
 </entry>
 <entry key="one">
 <value>date('1856-7-9').Month</value>
 </entry>
 <entry key="two">
 <value>'Nikola Tesla'.ToUpper()</value>
 </entry>
 <entry key="three">
 <value>DateTime.Today > date('1856-7-9')</value>
 </entry>
 </dictionary>
 </property>
</object>

4.3.3.4.设置索引器属性

public class Person
{
 private IList favoriteNames = new ArrayList();
 private IDictionary properties = new Hashtable();
 
 public Person()
 {
 favoriteNames.Add("p1");
 favoriteNames.Add("p2");
 }

 public string this[int index]
 {
 get { return (string)favoriteNames[index]; }
 set { favoriteNames[index] = value; }
 }
 public string this[string keyName]
 {
 get { return (string) properties[keyName]; }
 set { properties.Add(keyName,value); }
 }

}

 <object id="person" type="Test.Objects.Person, Test.Objects">
 <property name="[0]" value="Master Shake"/>
 <property name="['one']" value="uno"/>
 </object>

<object id="objectWithIndexer" type="Spring.Objects.TestObject, Spring.Core.Tests"> 
 <property name="Item[0]" value="my string value"/> 

4.3.3.5.内联对象定义

<object id="outer" type="...">
 <!-- Instead of using a reference to target, just use an inner object -->
 <property name="Target">
 <object type="ExampleApp.Person, ExampleApp">
 <property name="Name" value="Tony"/>
 <property name="Age" value="51"/>
 </object>
 </property>
</object>

4.3.3.6.idref节点

<object id="theTargetObject" type="...">
</object>
<object id="theClientObject" type="...">
 <property name="TargetName">
 <idref object="theTargetObject"/>
 </property>
</object>

<object id="theTargetObject" type="...">
</object>
<object id="theClientObject" type="...">
 <property name="TargetName" value="theTargetObject"/>
</object>

<property name="TargetName">
 <idref local="theTargetObject"/>
</property>

4.3.3.7.引用协作对象

<ref object="someObject"/>

<ref local="someObject"/>

<ref parent="someObject"/>

4.3.3.8.value和ref节点的简化格式

<property name="MyProperty">
 <value>hello</value>
</property>

<constructor-arg>
 <value>hello</value>
</constructor-arg>

<entry key="myKey">
 <value>hello</value>
</entry>

<property name="MyProperty" value="hello"/>

<constructor-arg value="hello"/>

<entry key="myKey" value="hello"/>

<property name="MyProperty">
 <ref object="anotherObject"/>
</property>

<constructor-arg index="0">
 <ref object="anotherObject"/>
</constructor-arg>

<property name="MyProperty" ref="anotherObject"/>

<constructor-arg index="0" ref="anotherObject"/>

<entry>
 <key><ref object="MyKeyObject"/></key>
 <ref object="MyValueObject"/>
</entry>

<entry key-ref="MyKeyObject" value-ref="MyValueObject"/>

4.3.3.9.复合属性名

<object id="foo" type="Spring.Foo, Spring.Foo">
 <property name="Bar.Baz.Name" value="Bingo"/>
</object>

4.3.4.方法注入

4.3.4.1.查询方法注入（Lookup Method Injection）

protected abstract SingleShotHelper CreateSingleShotHelper();

<!-- a stateful object deployed as a prototype (non-singleton) -->
<object id="singleShotHelper" class="..." singleton="false"/>

<!-- myobject uses singleShotHelper -->
<object id="myObject" type="...">
  <lookup-method name="CreateSingleShotHelper" object="singleShotHelper"/>
  <property>
    ...
  </property>

</object>

public abstract class MyClass //注意，可以直接在配置中定义这个类的对象
{
	public abstract SingleShotHelper CreateSingleShotHelper();
	//或者可以是一个虚方法
	//public virtual SingleShotHelper CreateSingleShotHelper()
	//{
	// return null;
	//}
	
	public void Process1()
	{
	//调用 this.CreateSingleShotHelper()
	}

	public void Process2()
	{ 
	//调用 this.CreateSingleShotHelper()
	}
}

public class SingleShotHelper
{
}

<object id="singleShotHelper" type="Sample1.SingleShotHelper, Sample1" singleton="false"/>

<object id="myObject" type="Sample1.MyClass, Sample1">
	<lookup-method name="CreateSingleShotHelper" object="singleShotHelper"/> 
</object>

4.3.4.2.替换任意方法

public class MyValueCalculator {

  public virtual string ComputeValue(string input) {
    // ... some real code
  }

  // ... some other methods
}

/// <summary>
/// Meant to be used to override the existing ComputeValue(string)
/// implementation in MyValueCalculator.
/// </summary>
public class ReplacementComputeValue : IMethodReplacer 
{
	public object Implement(object target, MethodInfo method, object[] arguments)
	{
		// get the input value, work with it, and return a computed result...
		string value = (string) arguments[0];
		// compute...
		return result;
	}
}

<object id="myValueCalculator" type="Examples.MyValueCalculator, ExampleAssembly">
  <!-- arbitrary method replacement -->
  <replaced-method name="ComputeValue" replacer="replacementComputeValue">
    <arg-type match="String"/>
  </replaced-method>
</object>

<object id="replacementComputeValue" type="Examples.ReplaceMentComputeValue, ExampleAssembly"/>

 System.String
 String
 Str

4.3.5.引用其他对象或类型的成员

4.3.5.1.使用对象或类的属性值进行注入

<object name="person" type="Spring.Objects.TestObject, Spring.Core.Tests">
  <property name="age" value="20"/>
  <property name="spouse">
    <object type="Spring.Objects.TestObject, Spring.Core.Tests">                      
      <property name="age" value="21"/>
    </object>

  </property>          
</object>
        
// will result in 21, which is the value of property 'spouse.age' of object 'person'        
<object name="theAge" type="Spring.Objects.Factory.Config.PropertyRetrievingFactoryObject, Spring.Core">
  <property name="TargetObject" ref="person"/>
  <property name="TargetProperty" value="spouse.age"/>
</object>

<object id="cultureAware" 
        type="Spring.Objects.Factory.Xml.XmlObjectFactoryTests+MyTestObject, Spring.Core.Tests">
  <property name="culture" ref="cultureFactory"/>
</object>

<object id="cultureFactory" 
        type="Spring.Objects.Factory.Config.PropertyRetrievingFactoryObject, Spring.Core">
  <property name="StaticProperty">
      <value>System.Globalization.CultureInfo.CurrentUICulture, Mscorlib</value>

  </property>
</object>

<object id="instancePropertyCultureAware" 
        type="Spring.Objects.Factory.Xml.XmlObjectFactoryTests+MyTestObject, Spring.Core.Tests">
  <property name="Culture" ref="instancePropertyCultureFactory"/>
</object>

<object id="instancePropertyCultureFactory" 
        type="Spring.Objects.Factory.Config.PropertyRetrievingFactoryObject, Spring.Core">
  <property name="TargetObject" ref="instancePropertyCultureAwareSource"/>
  <property name="TargetProperty" value="MyDefaultCulture"/>

</object>

<object id="instancePropertyCultureAwareSource" 
        type="Spring.Objects.Factory.Xml.XmlObjectFactoryTests+MyTestObject, Spring.Core.Tests"/>

4.3.5.2.使用字段值进行注入

<object id="withTypesField" 
        type="Spring.Objects.Factory.Xml.XmlObjectFactoryTests+MyTestObject, Spring.Core.Tests">
  <property name="Types" ref="emptyTypesFactory"/>
</object>

<object id="emptyTypesFactory" 
        type="Spring.Objects.Factory.Config.FieldRetrievingFactoryObject, Spring.Core">
  <property name="TargetType" value="System.Type, Mscorlib"/>
    <property name="TargetField" value="EmPTytypeS"/>

</object>

<object id="instanceCultureAware" 
        type="Spring.Objects.Factory.Xml.XmlObjectFactoryTests+MyTestObject, Spring.Core.Tests">
  <property name="Culture" ref="instanceCultureFactory"/>
</object>

<object id="instanceCultureFactory"
  type="Spring.Objects.Factory.Config.FieldRetrievingFactoryObject, Spring.Core">
  <property name="TargetObject" ref="instanceCultureAwareSource"/>
  <property name="TargetField" value="Default"/>

</object>

<object id="instanceCultureAwareSource" 
         type="Spring.Objects.Factory.Xml.XmlObjectFactoryTests+MyTestObject, Spring.Core.Tests"/>

4.3.5.3.使用方法的返回值进行注入

<object id="force-init"
 type="Spring.Objects.Factory.Config.MethodInvokingFactoryObject, Spring.Core">
 <property name="TargetMethod" value="Initialize">
 <property name="TargetType" value="ExampleNamespace.ExampleInitializerClass, ExampleAssembly">
</object>

<object id="myService" type="MyService" depends-on="force-init"/>

<object id="myObject" type="Spring.Objects.Factory.Config.MethodInvokingFactoryObject, Spring.Core">
  <property name="TargetType" value="Whatever.MyClassFactory, MyAssembly"/>
  <property name="TargetMethod" value="GetInstance"/>
  
  <!-- the ordering of arguments is significant -->
  <property name="Arguments">
    <list>

      <value>1st</value>
      <value>2nd</value>
      <value>and 3rd arguments</value>
      <!-- automatic Type-conversion will be performed prior to invoking the method -->

    </list>
  </property>
</object>

<object id="myObject" type="Spring.Objects.Factory.Config.MethodInvokingFactoryObject, Spring.Core">
  <property name="TargetObject">
    <object type="Whatever.MyClassFactory, MyAssembly"/>
  </property>
  <property name="TargetMethod" value="Execute"/>
  
  <!-- the ordering of named arguments is not significant -->

  <property name="NamedArguments">
    <dictionary>
      <entry key="argumentName"><value>1st</value></entry>
      <entry key="finalArgumentName"><value>and 3rd arguments</value></entry>

      <entry key="anotherArgumentName"><value>2nd</value></entry>
    </dictionary>
  </property>
</object>

<object id="myMethodObject" type="Whatever.MyClassFactory, MyAssembly" />

<object id="myObject" type="Spring.Objects.Factory.Config.MethodInvokingFactoryObject, Spring.Core">
  <property name="TargetObject" ref="myMethodObject"/>
  <property name="TargetMethod" value="Execute"/>
</object>

[C#]
public class MyClassFactory
{
    public object CreateObject(Type objectType, params string[] arguments)
    {
        return ... // implementation elided for clarity...
    }
}

<object id="myMethodObject" type="Whatever.MyClassFactory, MyAssembly" />
				
<object id="paramsMethodObject" type="Spring.Objects.Factory.Config.MethodInvokingFactoryObject, Spring.Core">
  <property name="TargetObject" ref="myMethodObject"/>
  <property name="TargetMethod" value="CreateObject"/>
  <property name="Arguments">
    <list>

      <value>System.String</value>
      <!-- here is the 'params string[] arguments' -->
      <list>
        <value>1st</value>
        <value>2nd</value>

      </list>
    </list>
</object>

4.3.6.IFactoryObject接口的其它实现类

4.3.6.1. Log4Net

<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 name="daoLogger" type="Spring.Objects.Factory.Config.Log4NetFactoryObject, Spring.Core">
      <property name="logName" value="DAOLogger"/>
    </object>
        
    <object name="productDao" type="PropPlayApp.SimpleProductDao, PropPlayApp ">
      <property name="maxResults" value="100"/>

      <property name="dbConnection" ref="myConnection"/>
      <property name="log" ref="daoLogger"/>
    </object>

    <object name="accountDao" type="PropPlayApp.SimpleAccountDao, PropPlayApp ">
      <property name="maxResults" value="100"/>
      <property name="dbConnection" ref="myConnection"/>

      <property name="log" ref="daoLogger"/>
    </object>
    
    <object name="myConnection" type="System.Data.Odbc.OdbcConnection, System.Data"> 
      <property name="connectionstring" value="dsn=MyDSN;uid=sa;pwd=myPassword;"/> 
    </object> 
    
</objects>

4.3.7.使用depends-on

<object id="objectOne" type="Examples.ExampleObject, ExamplesLibrary" depends-on="manager">
  <property name="manager" ref="manager"/>
</object>

<object id="manager" type="ManagerObject"/>

4.3.8.自动装配协作对象

4.3.9.检查依赖项

4.4. 类型转换

[Serializable, TypeConverter(typeof(FontConverter)), ...]
public sealed class Font : MarshalByRefObject, ICloneable, ISerializable, IDisposable
{
  // Methods
  
  ... etc ..
}

4.4.1.枚举类型的转换

<object id="rod" type="Spring.Objects.TestObject, Spring.Core.Tests">
  <property name="name" value="Rod"/>
  <property name="FileMode" value="Create"/>
</object>

4.4.2.内置的类型转换器

4.4.3.自定义类型转换器

4.4.3.1.使用CustomConverterConfigurer类

public class ExoticType
{
    private string name;
        
    public ExoticType(string name)
    {
        this.name = name;
    }

    public string Name
    {
        get { return this.name; }
    }
}

public class DependsOnExoticType
{
    public DependsOnExoticType() {}
    
    private ExoticType exoticType;
        
    public ExoticType ExoticType
    {
        get { return this.exoticType; }
        set { this.exoticType = value; }
    }
    
    public override string ToString()
    {
        return exoticType.Name;
    }
}

<object name="sample" type="SimpleApp.DependsOnExoticType, SimpleApp">
  <property name="exoticType" value="aNameForExoticType"/>
</object>

public class ExoticTypeConverter : TypeConverter
{
	public ExoticTypeConverter()
	{
	}

	public override bool CanConvertFrom (
		ITypeDescriptorContext context, 
		Type sourceType) 
	{
		if (sourceType == typeof (string)) 
		{
			return true;
		}
		return base.CanConvertFrom (context, sourceType);
	}

	public override object ConvertFrom (
		ITypeDescriptorContext context, 
		CultureInfo culture, object value) 
	{
		if (value is string) 
		{          
			string s = value as string;
			return new ExoticType(s.ToUpper());
		}
		return base.ConvertFrom (context, culture, value);
	}
}

<object id="customConverterConfigurer" 
	type="Spring.Objects.Factory.Config.CustomConverterConfigurer, Spring.Core">
  <property name="CustomConverters">
    <dictionary>
      <entry key="SimpleApp.ExoticType">
        <object type="SimpleApp.ExoticTypeConverter"/>
      </entry>

    </dictionary>
  </property>
</object>

4.5. 自定义对象的行为

4.5.1.生命周期接口

4.5.1.1.IInitializingObject接口和init-method属性

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

<object id="exampleInitObject" type="Examples.ExampleObject" init-method="init"/>
[C#]
public class ExampleObject
{
    public void Init()
    {
        // do some initialization work
    }
}

<object id="exampleInitObject" type="Examples.AnotherExampleObject"/>
[C#]
public class AnotherExampleObject : IInitializingObject
{
    public void AfterPropertiesSet()
    {
        // do some initialization work
    }
}

4.5.1.2.IDisposable接口和destroy-method属性

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

<object id="exampleInitObject" type="Examples.ExampleObject" destroy-method="cleanup"/>
[C#]
public class ExampleObject
{
    public void cleanup()
    {
        // do some destruction work (such as closing any open connection (s))
    }
}

<object id="exampleInitObject" type="Examples.AnotherExampleObject"/>
[C#]
public class AnotherExampleObject : IDisposable
{
    public void Dispose()
    {
        // do some destruction work
    }
}