基于.NET平台的分层架构实战（六）——依赖注入机制及IoC的设计与实现

我们设计的分层架构，层与层之间应该是松散耦合的。因为是单向单一调用，所以，这里的“松散耦合”实际是指上层类不能具体依赖于下层类，而应该依赖于下层提供的一个接口。这样，上层类不能直接实例化下层中的类，而只持有接口，至于接口所指变量最终究竟是哪一个类，则由依赖注入机制决定。

      之所以这样做，是为了实现层与层之间的“可替换”式设计，例如，现在需要换一种方式实现数据访问层，只要这个实现遵循了前面定义的数据访问层接口，业务逻辑层和表示层不需要做任何改动，只需要改一下配置文件系统即可正常运行。另外，基于这种结构的系统，还可以实现并行开发。即不同开发人员可以专注于自己的层次，只有接口被定义好了，开发出来的东西就可以无缝连接。

      在J2EE平台上，主要使用Spring框架实现依赖注入。这里，我们将自己做一个依赖注入容器。

      依赖注入的理论基础是Abstract Factory设计模式，这里结合具体实例简单介绍一下。

附件: f4.jpg



      上图以数据访问层为例，展示了Abstract Factory模式的应用。如图，现假设有针对Access和SQLServer两种数据库的数据访问层，它们都实现了数据访问层接口。每个数据访问层有自己的工厂，所有工厂都实现自IDALFactory接口。而客户类（这里就是业务逻辑层类）仅与工厂接口、数据访问层接口耦合，而与具体类无关，这样，只要通过配置文件确定实例化哪个工厂，就可以得到不同的数据访问层。

      然而，这种设计虽然可行，但是代码比较冗余，因为这样需要为数据访问层的每一个实现编写一个工厂，业务逻辑层也一样。在以前，我们毫无办法，但是，.NET平台引入的反射机制，给我们提供了一种解决方案。使用反射，每个层只需要一个工厂，然后通过从配置文件中读出程序集的名称，动态加载相应类。另外，为了提高依赖注入机制的效率，这里引入缓存机制。下面来看具体实现。

      配置
      首先，需要在Web工程的Web.config文件的<appSettings>节点下添加如下两个项：
      <add key="DAL" value=""/>
      <add key="BLL" value=""/>
      这两个配置选项分别存储要应用的数据访问和也业务逻辑层的程序集名称。value目前是空，是因为目前还没有各个层次的具体实现。

      实现缓存操作辅助类
      为实现缓存操作，我们将缓存操作封装成一个辅助类，放在Utility工程下，具体代码如下：

CacheAccess.cs:

CacheAccess

1. 1using System;
2. 2using System.Web;
3. 3using System.Web.Caching;
4. 4
5. 5namespace NGuestBook.Utility
6. 6{
7. 7    /**//// <summary>
8. 8    /// 辅助类，用于缓存操作
9. 9    /// </summary>
10. 10    public sealed class CacheAccess
11. 11    {
12. 12        /**//// <summary>
13. 13        /// 将对象加入到缓存中
14. 14        /// </summary>
15. 15        /// <param name="cacheKey">缓存键</param>
16. 16        /// <param name="cacheObject">缓存对象</param>
17. 17        /// <param name="dependency">缓存依赖项</param>
18. 18        public static void SaveToCache(string cacheKey, object cacheObject, CacheDependency dependency)
19. 19        {
20. 20            Cache cache = HttpRuntime.Cache;
21. 21            cache.Insert(cacheKey, cacheObject, dependency);
22. 22        }
23. 23
24. 24        /**//// <summary>
25. 25        /// 从缓存中取得对象，不存在则返回null
26. 26        /// </summary>
27. 27        /// <param name="cacheKey">缓存键</param>
28. 28        /// <returns>获取的缓存对象</returns>
29. 29        public static object GetFromCache(string cacheKey)
30. 30        {
31. 31            Cache cache = HttpRuntime.Cache;
32. 32
33. 33            return cache[cacheKey];
34. 34        }
35. 35    }
36. 36}

复制代码

封装依赖注入代码
      因为很多依赖注入代码非常相似，为了减少重复性代码，我们将可复用的代码先封装在一个类中。具体代码如下（这个类放在Factory工程下）：

DependencyInjector.cs:

DependencyInjector

1. 1using System;
2. 2using System.Configuration;
3. 3using System.Reflection;
4. 4using System.Web;
5. 5using System.Web.Caching;
6. 6using NGuestBook.Utility;
7. 7
8. 8namespace NGuestBook.Factory
9. 9{
10. 10    /**//// <summary>
11. 11    /// 依赖注入提供者
12. 12    /// 使用反射机制实现
13. 13    /// </summary>
14. 14    public sealed class DependencyInjector
15. 15    {
16. 16        /**//// <summary>
17. 17        /// 取得数据访问层对象
18. 18        /// 首先检查缓存中是否存在，如果不存在，则利用反射机制返回对象
19. 19        /// </summary>
20. 20        /// <param name="className">数据访问类名称</param>
21. 21        /// <returns>数据访问层对象</returns>
22. 22        public static object GetDALObject(string className)
23. 23        {
24. 24            /**//// <summary>
25. 25            /// 取得数据访问层名称，首先检查缓存，不存在则到配置文件中读取
26. 26            /// 缓存依赖项为Web.Config文件
27. 27            /// </summary>
28. 28            object dal = CacheAccess.GetFromCache("DAL");
29. 29            if (dal == null)
30. 30            {
31. 31                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath("Web.Config"));
32. 32                dal = ConfigurationManager.AppSettings["DAL"];
33. 33                CacheAccess.SaveToCache("DAL", dal, fileDependency);
34. 34            }
35. 35
36. 36            /**//// <summary>
37. 37            /// 取得数据访问层对象
38. 38            /// </summary>
39. 39            string dalName = (string)dal;
40. 40            string fullClassName = dalName + "." + className;
41. 41            object dalObject = CacheAccess.GetFromCache(className);
42. 42            if (dalObject == null)
43. 43            {
44. 44                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath("Web.Config"));
45. 45                dalObject = Assembly.Load(dalName).CreateInstance(fullClassName);
46. 46                CacheAccess.SaveToCache(className, dalObject, fileDependency);
47. 47            }
48. 48
49. 49            return dalObject;
50. 50        }
51. 51
52. 52        /**//// <summary>
53. 53        /// 取得业务逻辑层对象
54. 54        /// 首先检查缓存中是否存在，如果不存在，则利用反射机制返回对象
55. 55        /// </summary>
56. 56        /// <param name="className">业务逻辑类名称</param>
57. 57        /// <returns>业务逻辑层对象</returns>
58. 58        public static object GetBLLObject(string className)
59. 59        {
60. 60            /**//// <summary>
61. 61            /// 取得业务逻辑层名称，首先检查缓存，不存在则到配置文件中读取
62. 62            /// 缓存依赖项为Web.Config文件
63. 63            /// </summary>
64. 64            object bll = CacheAccess.GetFromCache("BLL");
65. 65            if (bll == null)
66. 66            {
67. 67                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath("Web.Config"));
68. 68                bll = ConfigurationManager.AppSettings["BLL"];
69. 69                CacheAccess.SaveToCache("BLL", bll, fileDependency);
70. 70            }
71. 71
72. 72            /**//// <summary>
73. 73            /// 取得业务逻辑层对象
74. 74            /// </summary>
75. 75            string bllName = (string)bll;
76. 76            string fullClassName = bllName + "." + className;
77. 77            object bllObject = CacheAccess.GetFromCache(className);
78. 78            if (bllObject == null)
79. 79            {
80. 80                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath("Web.Config"));
81. 81                bllObject = Assembly.Load(bllName).CreateInstance(fullClassName);
82. 82                CacheAccess.SaveToCache(className, bllObject, fileDependency);
83. 83            }
84. 84
85. 85            return bllObject;
86. 86        }
87. 87    }
88. 88}

复制代码

实现工厂
      下面使用两个辅助类，实现数据访问层工厂和业务逻辑层工厂。

DALFactory.cs

DALFactory

1. 1using System;
2. 2using NGuestBook.IDAL;
3. 3
4. 4namespace NGuestBook.Factory
5. 5{
6. 6    /**//// <summary>
7. 7    /// 数据访问层工厂，用于获取相应的数据访问层对象
8. 8    /// 使用Abstract Factory设计模式+Facace设计模式+反射机制+缓存机制设计
9. 9    /// </summary>
10. 10    public sealed class DALFactory
11. 11    {
12. 12        /**//// <summary>
13. 13        /// 获取管理员数据访问层对象
14. 14        /// </summary>
15. 15        /// <returns>管理员数据访问层对象</returns>
16. 16        public static IAdminDAL CreateAdminDAL()
17. 17        {
18. 18            return (IAdminDAL)DependencyInjector.GetDALObject("AdminDAL");
19. 19        }
20. 20
21. 21        /**//// <summary>
22. 22        /// 获取留言数据访问层对象
23. 23        /// </summary>
24. 24        /// <returns>留言数据访问层对象</returns>
25. 25        public static IMessageDAL CreateMessageDAL()
26. 26        {
27. 27            return (IMessageDAL)DependencyInjector.GetDALObject("MessageDAL");
28. 28        }
29. 29
30. 30        /**//// <summary>
31. 31        /// 获取评论数据访问层对象
32. 32        /// </summary>
33. 33        /// <returns>评论数据访问层对象</returns>
34. 34        public static ICommentDAL CreateCommentDAL()
35. 35        {
36. 36            return (ICommentDAL)DependencyInjector.GetDALObject("CommentDAL");
37. 37        }
38. 38    }
39. 39}

复制代码

BLLFactory.cs

BLLFactory

1. 1using System;
2. 2using NGuestBook.IBLL;
3. 3
4. 4namespace NGuestBook.Factory
5. 5{
6. 6    /**//// <summary>
7. 7    /// 业务逻辑层工厂，用于获取相应的业务逻辑层对象
8. 8    /// 使用Abstract Factory设计模式+Facace设计模式+反射机制+缓存机制设计
9. 9    /// </summary>
10. 10    public sealed class BLLFactory
11. 11    {
12. 12        /**//// <summary>
13. 13        /// 获取管理员业务逻辑层对象
14. 14        /// </summary>
15. 15        /// <returns>管理员业务逻辑层对象</returns>
16. 16        public static IAdminBLL CreateAdminBLL()
17. 17        {
18. 18            return (IAdminBLL)DependencyInjector.GetBLLObject("AdminBLL");
19. 19        }
20. 20
21. 21        /**//// <summary>
22. 22        /// 获取留言业务逻辑层对象
23. 23        /// </summary>
24. 24        /// <returns>留言业务逻辑层对象</returns>
25. 25        public static IMessageBLL CreateMessageBLL()
26. 26        {
27. 27            return (IMessageBLL)DependencyInjector.GetBLLObject("MessageBLL");
28. 28        }
29. 29
30. 30        /**//// <summary>
31. 31        /// 获取评论业务逻辑层对象
32. 32        /// </summary>
33. 33        /// <returns>评论业务逻辑层对象</returns>
34. 34        public static ICommentBLL CreateCommentBLL()
35. 35        {
36. 36            return (ICommentBLL)DependencyInjector.GetBLLObject("CommentBLL");
37. 37        }
38. 38    }
39. 39}

复制代码