LYWILL设计运营 - 网站运营与推广、开发技术、成功项目展示。

实例学习Spring.NET的控制反转(IoC)

　　今天学习了Spring.NET的控制反转（Inversion of Control，英文缩写为IoC），也叫依赖注入（Dependency Injection）。控制反转的意思是依赖对象(控制权)发生转变，由最初的类本身来管理依赖对象转变为IoC框架来管理这些对象，使得依赖脱离类本身的控制，从而实现松耦合。

        学习新东西，我喜欢从实例入手，我们先来看一段代码：

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

 

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

 

C#代码
  1. namespace DaoFactory   
  2. {   
  3. public static class DataAccess   
  4. {   
  5. public static IPersonDao CreatePersonDao()   
  6. {   
  7. return new PersonDao();   
  8. }   
  9. }   
  10. }   
  11.     
  12.   
  13. FactoryMethod   
  14. namespace SpringNetIoC   
  15. {   
  16. class Program   
  17. { private static void FactoryMethod()   
  18. {   
  19. IPersonDao dao = DataAccess.CreatePersonDao();   
  20. dao.Save();   
  21. Console.WriteLine("我是工厂方法");   
  22. }   
  23. }   
  24. }   

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

 



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

 

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

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

        本文实例来源于刘冬的博客。