Spring.NET学习笔记1——控制反转(基础篇)

在学习Spring.NET这个控制反转(IoC)和面向切面(AOP)的容器框架之前，我们先来看一下什么是控制反转(IoC)。

　　控制反转（Inversion of Control，英文缩写为IoC），也叫依赖注入（Dependency Injection）。我个人认为控制反转的意思是依赖对象发生改变，由最初的类本身来管理依赖对象改变为IoC框架来管理这些对象，使得依赖脱离类本身的控制，从而实现松耦合。

我们先来看一段代码

1. namespace Dao
2. {
3.     public interface IPersonDao
4.     {
5.         void Save();
6.     }
7.     public class PersonDao : IPersonDao
8.     {
9.         public void Save()
10.         {
11.             Console.WriteLine("保存 Person");
12.         }
13.     }
14. }
15. namespace SpringNetIoC
16. {
17.     class Program
18.     {
19.         private static void NormalMethod()
20.         {
21.             IPersonDao dao = new PersonDao();
22.             dao.Save();
23.             Console.WriteLine("我是一般方法");
24.         }
25.     }
26. }

复制代码

Program必然需要知道IPersonDao接口和PersonDao类。为了不暴露具体实现，我可以运用设计模式中的抽象工厂模式（Abstract Factory）来解决。

1. namespace DaoFactory
2. {
3.     public static class DataAccess
4.     {
5.         public static IPersonDao CreatePersonDao()
6.         {
7.             return new PersonDao();
8.         }
9.     }
10. }

复制代码

FactoryMethod

1. namespace SpringNetIoC
2. {
3.     class Program
4.     {        private static void FactoryMethod()
5.         {
6.             IPersonDao dao = DataAccess.CreatePersonDao();
7.             dao.Save();
8.             Console.WriteLine("我是工厂方法");
9.         }
10.     }
11. }

复制代码

这时，Program只需要知道IPersonDao接口和工厂，而不需要知道PersonDao类。然后我们试图想象，要是有这样的工厂框架帮我们管理依赖的对象就好了，于是控制反转出来了。

App.config

1. <?xml version="1.0" encoding="utf-8" ?>
2. <configuration>
3.   <configSections>
4.     <sectionGroup name="spring">
5.       <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core" />
6.       <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core" />
7.     </sectionGroup>
8.   </configSections>
9.   <spring>
10.     <context>
11.       <resource uri="config://spring/objects" />
12.     </context>
13.     <objects xmlns="http://www.springframework.net">
14.       <description>一个简单的控制反转例子</description>
15.       <object id="PersonDao" type="Dao.PersonDao, Dao" />
16.     </objects>
17.   </spring>
18. </configuration>

复制代码

Program

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using Dao;
6. using DaoFactory;
7. using Spring.Context;
8. using Spring.Context.Support;
9. namespace SpringNetIoC
10. {
11.     class Program
12.     {
13.         static void Main(string[] args)
14.         {
15.             //NormalMethod();  // 一般方法
16.             //FactoryMethod();  // 工厂方法
17.             IoCMethod();  // IoC方法"
18.             Console.ReadLine();
19.         }
20.         private static void NormalMethod()
21.         {
22.             IPersonDao dao = new PersonDao();
23.             dao.Save();
24.             Console.WriteLine("我是一般方法");
25.         }
26.         private static void FactoryMethod()
27.         {
28.             IPersonDao dao = DataAccess.CreatePersonDao();
29.             dao.Save();
30.             Console.WriteLine("我是工厂方法");
31.         }
32.         private static void IoCMethod()
33.         {
34.             IApplicationContext ctx = ContextRegistry.GetContext();
35.             IPersonDao dao = ctx.GetObject("PersonDao") as IPersonDao;
36.             if (dao != null)
37.             {
38.                 dao.Save();
39.                 Console.WriteLine("我是IoC方法");
40.             }
41.         }
42.     }
43. }

复制代码

一个简单的控制反转程序例子就实现了。

这样从一定程度上解决了Program与PersonDao耦合的问题，但是实际上并没有完全解决耦合，只是把耦合放到了XML 文件中，通过一个容器在需要的时候把这个依赖关系形成，即把需要的接口实现注入到需要它的类中。我个人认为可以把IoC模式看做是工厂模式的升华，可以把 IoC看作是一个大工厂，只不过这个大工厂里要生成的对象都是在XML文件中给出定义的。