WCF版的PetShop之二：模块中的层次划分[提供源代码下载]

上一篇文章主要讨论的是PetShop的模块划分，在这一篇文章中我们来讨论在一个模块中如何进行层次划分。模块划分应该是基于功能的，一个模块可以看成是服务于某项功能的所有资源的集合；层次划分侧重于关注点分离（SoC：Separation of Concern ），让某一层专注于某项单一的操作，以实现重用性、可维护性、可测试性等相应的目的。Source Code从这里下载。

一、基本的层次结构

我们接下来将目光聚焦到模块内部，看看每一个模块具体又有怎样的层次划分。我们将Infrastructures、Products和Orders目标展开，将会呈现出如图1所示的层次结构。

图1 从解决方案的结构看模块的层次结构

以Products模块为例，它由如下的项目组成：

• Products：对于整个应用来说，Products是最终基于该模块功能的提供者；
• Products.Interface: 模块提供给其他模块的服务接口，本项目被Products项目引用；
• Products.Service.Interface：模块客户端和服务端进行服务调用的WCF服务契约，Products项目最为WCF服务的客户端通过该接口进行服务调用；
• Products.Service：实现了上述服务契约的WCF服务，引用了Products.Service.Interface项目；
• Products.BusinessComponent：也可以称为业务逻辑层，实现了真正的业务逻辑；
• Products.DataAccess：数据访问层，在这里主要提供对数据库的访问；
• Products.BusinessEntity：提供的业务实体（BusinessEntity）类型的定义。一般来讲，业务实体和数据契约（DataContract）是不同的，前者主要对本模块，后者则对外，在这里为了简单起见，将两者合二为一。

从部署的角度讲，Products和Products.Interface部署与于Web服务器；Products.Service、Products.BusinessComponent和Products.DataAccess则部署于应用服务器；Products.Service.Interface和Products.BusinessEntity则同时被部署于Web服务器和应用服务器。整个层次结构大体上如图2所示。

图2 逻辑层次和物理部署

二、数据库设计

整个应用主要涉及4个表，其中3个用于存储业务数据（产品表、订单表和订单明细表），另一个用于存储简单的审核信息（审核表）。4个表的结构可以分别参考相应的SQL脚本。

产品表（T_PRODUCT）

CREATE TABLE [T_PRODUCT] (
  [PRODUCT_ID]         [VARCHAR](50)          NOT NULL,
  [PRODUCT_CATEGORY]   [NVARCHAR](128)        NOT NULL,
  [PRODUCT_NAME]       [NVARCHAR](256)        NOT NULL,
  [PRODUCT_PIC]        [NVARCHAR](512),
  [PRODUCT_DESC]       [NVARCHAR](800),
  [PRODUCT_UNIT_PRICE] [DECIMAL](10,2)        NOT NULL,
  [PRODUCT_INVENTORY]  [INT]                  NOT NULL,

  [VERSION_NO]         [TIMESTAMP]            NOT NULL,
  [TRANSACTION_ID]     [VARCHAR](50)          NOT NULL,
  [CREATED_BY]         [NVARCHAR](256)        NOT NULL,
  [CREATED_TIME]       [DATETIME]             NOT NULL,
  [LAST_UPDATED_BY]    [NVARCHAR](256)        NOT NULL,
  [LAST_UPDATED_TIME]  [DATETIME]             NOT NULL

  CONSTRAINT [C_PRODUCT_PK]            PRIMARY KEY CLUSTERED    ( [PRODUCT_ID] ASC ) ON [PRIMARY]) ON [PRIMARY]

订单表（T_ORDER）

CREATE TABLE [T_ORDER] (
  [ORDER_ID]          [VARCHAR](50)         NOT NULL,
  [ORDER_DATE]        [DATETIME]            NOT NULL,
  [ORDER_TOTAL_PRICE] [DECIMAL](38,2)       NOT NULL,
  [ORDERED_BY]        [NVARCHAR](256)       NOT NULL,

  [VERSION_NO]        [TIMESTAMP]           NOT NULL ,
  [TRANSACTION_ID]    [VARCHAR](50)         NOT NULL ,
  [CREATED_BY]        [NVARCHAR](256)       NOT NULL ,
  [CREATED_TIME]      [DATETIME]            NOT NULL ,
  [LAST_UPDATED_BY]   [NVARCHAR](256)       NOT NULL ,
  [LAST_UPDATED_TIME] [DATETIME]            NOT NULL

  CONSTRAINT [C_ORDER_PK]                PRIMARY KEY CLUSTERED ( [ORDER_ID] ASC ) ON [PRIMARY]) ON [PRIMARY]

订单明细表（T_ORDER_DETAIL）

CREATE TABLE [T_ORDER_DETAIL] (
  [ORDER_ID]          [VARCHAR](50)         NOT NULL,
  [PRODUCT_ID]        [VARCHAR](50)         NOT NULL,
  [QUANTITY]          [INT]                 NOT NULL,

  [VERSION_NO]        [TIMESTAMP]           NOT NULL ,
  [TRANSACTION_ID]    [VARCHAR](50)         NOT NULL ,
  [CREATED_BY]        [NVARCHAR](256)       NOT NULL ,
  [CREATED_TIME]      [DATETIME]            NOT NULL ,
  [LAST_UPDATED_BY]   [NVARCHAR](256)       NOT NULL ,
  [LAST_UPDATED_TIME] [DATETIME]            NOT NULL

  CONSTRAINT [C_ORDER_DETAIL_PK]        PRIMARY KEY CLUSTERED ( [PRODUCT_ID]  ASC,[ORDER_ID] ASC ) ON [PRIMARY]) ON [PRIMARY]

审核表（T_AUDIT）

CREATE TABLE [T_AUDIT](
    [TRANSACTION_ID] [varchar](50)    NOT NULL,
    [OPERATION] [nvarchar](256)       NOT NULL,
    [OPERATOR] [varchar](50)          NOT NULL,
    [OPERATION_TIME] [datetime]       NOT NULL,
    CONSTRAINT [C_AUDIT_PK]           PRIMARY KEY CLUSTERED ( [TRANSACTION_ID]  ASC) ON [PRIMARY])    ON [PRIMARY]

注：对于每一个业务表，我都添加了如下6个系统字段：VERSION_NO（TIMESTAMP）用于进行并发验证；TRANSACTION_ID代表最后一次操作该纪录的事务ID；CREATED_BY、CREATED_TIME、LAST_UPDATED_BY和LAST_UPDATED_TIME分别表示创建记录的创建者和创建时间，以及最后一次操作的操作者和操作时间。

在PetShop中，我们将事务作为审核的基本单元，而每一个事务由上述的TRANSACTION_ID作为唯一标识。简单起见，在这里仅仅记录一些数据最基本的信息：操作的名称、操作者和操作时间。

介绍了表的定义，接下来简单介绍相关存储过程的定义。首先是用于筛选产品的两个存储过程：P_PRODUCT_GET_ALL和P_PRODUCT_GET_BY_ID，前者获取所有的产品，后者根据ID获取相应产品信息。

P_PRODUCT_GET_ALL

CREATE Procedure P_PRODUCT_GET_ALL
AS
SELECT [PRODUCT_ID]
      ,[PRODUCT_CATEGORY]
      ,[PRODUCT_NAME]
      ,[PRODUCT_PIC]
      ,[PRODUCT_DESC]
      ,[PRODUCT_UNIT_PRICE]
      ,[PRODUCT_INVENTORY]
      ,[VERSION_NO]
      ,[TRANSACTION_ID]
      ,[CREATED_BY]
      ,[CREATED_TIME]
      ,[LAST_UPDATED_BY]
      ,[LAST_UPDATED_TIME]
  FROM [dbo].[T_PRODUCT]
GO

CREATE Procedure P_PRODUCT_GET_BY_ID
(
    @p_product_id VARCHAR(50)
)
AS

SELECT [PRODUCT_ID]
      ,[PRODUCT_CATEGORY]
      ,[PRODUCT_NAME]
      ,[PRODUCT_PIC]
      ,[PRODUCT_DESC]
      ,[PRODUCT_UNIT_PRICE]
      ,[PRODUCT_INVENTORY]
      ,[VERSION_NO]
      ,[TRANSACTION_ID]
      ,[CREATED_BY]
      ,[CREATED_TIME]
      ,[LAST_UPDATED_BY]
      ,[LAST_UPDATED_TIME]
  FROM [dbo].[T_PRODUCT]
  WHERE [PRODUCT_ID] = @p_product_id
GO

而下面的两个存储过程P_ORDER_INSERT和P_ORDER_DETAIL_INSERT则用于添加订单记录。

P_ORDER_INSERT

CREATE Procedure P_ORDER_INSERT
    (
        @p_order_id            VARCHAR(50),
        @p_ordered_by          VARCHAR(50),
        @p_total_price         DECIMAL,
        @p_user_name           NVARCHAR(50),
        @p_transacion_id       VARCHAR(50)
    )

AS
INSERT INTO [PetShop].[dbo].[T_ORDER]
           ([ORDER_ID]
           ,[ORDER_DATE]
           ,[ORDER_TOTAL_PRICE]
           ,[ORDERED_BY]
           ,[TRANSACTION_ID]
           ,[CREATED_BY]
           ,[CREATED_TIME]
           ,[LAST_UPDATED_BY]
           ,[LAST_UPDATED_TIME])
     VALUES
           (@p_order_id
           ,GETDATE()
           ,@p_total_price
           ,@P_ordered_by
           ,@p_transacion_id
           ,@p_user_name
           ,GETDATE()
           ,@p_user_name
           ,GETDATE())
GO

P_ORDER_DETAIL_INSERT

CREATE Procedure P_ORDER_DETAIL_INSERT
    (
        @p_order_id        VARCHAR(50),
        @p_product_id      VARCHAR(50),
        @p_quantity        INT,
        @p_user_name       NVARCHAR(50),
        @p_transacion_id   VARCHAR(50)
    )
AS
INSERT INTO [PetShop].[dbo].[T_ORDER_DETAIL]
           ([ORDER_ID]
           ,[PRODUCT_ID]
           ,[QUANTITY]
           ,[TRANSACTION_ID]
           ,[CREATED_BY]
           ,[CREATED_TIME]
           ,[LAST_UPDATED_BY]
           ,[LAST_UPDATED_TIME])
     VALUES
           (@p_order_id
           ,@p_product_id
           ,@p_quantity
           ,@p_transacion_id
           ,@p_user_name
           ,GETDATE()
           ,@p_user_name
           ,GETDATE())
GO

三、业务实体（数据契约）设计

我们将对内的业务实体（Business Entity）和对外的数据契约合二为一，定义成WCF的数据契约（Data Contract）。所有的业务实体类型定义在相应模块的{Module}.BusinessEntity项目之中。在Products.BusinessEntity定义了Product数据契约表示，产品相关信息；在Orders.BusinessEntity中定义了Order和OrderDetail数据契约，表示提交的订单和订单明细。

注：如果采用领域模型（Domain Model）来设计业务逻辑层，整个模型通过以一个个面向业务逻辑（而不是数据存储）的对象构成。而这些对象是完全基于OO的对象，即数据（或者状态）和行为（或者方法）的封装。如果业务逻辑层对外提供服务，我们需要将数据封装成为数据传输对象（DTO：Data Transfer Object）。在理想的情况下，我们需要一个额外的层次实现领域对象与数据传输对象之间的转换，但是在实际项目开发中，这会带来很多额外的成本。对于本例，我们大体上可以看成是将数据传输对象和领域对象的数据部分合二为一（PetShop并没有完全按照领域模型来设计）。

Product

using System;
using System.Runtime.Serialization;
namespace Artech.PetShop.Orders.BusinessEntity
{
    [DataContract(Namespace="http://www.artech.com/petshop/")]
    public class Product
    {
        [DataMember]
        public Guid ProductID
        { get; set; }
        [DataMember]
        public string Category
        { get; set; }
        [DataMember]
        public string ProductName
        { get; set; }
        [DataMember]
        public string Description
        { get; set; }
        [DataMember]
        public decimal UnitPrice
        { get; set; }
        [DataMember]
        public string Picture
        { get; set; }
        [DataMember]
        public int Inventory
        { get; set; }
    }
}

OrderDetail

using System;
using System.Runtime.Serialization;
namespace Artech.PetShop.Orders.BusinessEntity
{
    [DataContract(Namespace = "http://www.artech.com/petshop/")]
    public class OrderDetail
    {
       [DataMember]
       public Guid ProductID
       { get; set; }
       public string ProductName
       { get; set; }
       [DataMember]
       public decimal UnitPrice
       { get; set; }
       [DataMember]
        public int Quantity
       { get; set; }
    }
}

Order

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
namespace Artech.PetShop.Orders.BusinessEntity
{
    [DataContract(Namespace = "http://www.artech.com/petshop/")]
    [KnownType(typeof(OrderDetail))]
    public class Order
    {
        public Order()
        {
            this.Details = new List<OrderDetail>();
        }
        [DataMember]
        public Guid OrderNo
        { get; set; }
        [DataMember]
        public DateTime OrderDate
        { get; set; }

        [DataMember]
        public string OrderBy
        { get; set; }

        [DataMember]
        public IList<OrderDetail> Details
        { get; set; }

        public decimal TotalPrice
        {
            get
            {
                return (decimal)this.Details.Sum(detail => detail.Quantity * detail.UnitPrice);
            }
        }
    }
}

四、数据访问层设计

数据访问层定义在{Module}.DataAccess中，它完成单纯的基于数据库操作。为了便于操作，我写了一个简单的帮助类：DbHelper。DbHelper通过ADO.NET完成一些简单的操作，ExecuteReader、ExecuteNonQuery和ExecuteScalar<T>对应DbCommand的同名方法。此外，该DbHelper与具体的数据库无关，同时支持SQL Server和Oracle。

using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.Common;
using System.Data.OracleClient;
using System.Data.SqlClient;
namespace Artech.PetShop.Common
{
    public class DbHelper
    {
        private DbProviderFactory _dbProviderFactory;
        private string _connectionString;
        private DbConnection CreateConnection()
        {
            DbConnection connection = this._dbProviderFactory.CreateConnection();
            connection.ConnectionString = this._connectionString;
            return connection;
        }

        private void DeriveParameters(DbCommand discoveryCommand)
        {
            if (discoveryCommand.CommandType != CommandType.StoredProcedure)
            {
                return;
            }

            if (this._dbProviderFactory is SqlClientFactory)
            {
                SqlCommandBuilder.DeriveParameters
((SqlCommand)discoveryCommand);
            }

            if(this._dbProviderFactory is OracleClientFactory)
            {
                OracleCommandBuilder.DeriveParameters
((OracleCommand)discoveryCommand);
            }
        }

        private void AssignParameters(DbCommand command, IDictionary<string, object> parameters)
        {
            IDictionary<string, object> copiedParams = new Dictionary<string, object>();
            foreach (var item in parameters)
            {
                copiedParams.Add(item.Key.ToLowerInvariant(), item.Value);
            }
            foreach (DbParameter parameter in command.Parameters)
            {
                if (!copiedParams.ContainsKey(parameter.ParameterName.
TrimStart('@').ToLowerInvariant()))
                {
                    continue;
                }

                parameter.Value = copiedParams[parameter.ParameterName.
TrimStart('@').ToLowerInvariant()];
            }
        }

        public DbHelper(string connectionStringName)
        {
            string providerName = ConfigurationManager.ConnectionStrings
[connectionStringName].ProviderName;
            this._connectionString = ConfigurationManager.ConnectionStrings
[connectionStringName].ConnectionString;
            this._dbProviderFactory = DbProviderFactories.GetFactory(providerName);
        }

        public DbDataReader ExecuteReader(string procedureName,  IDictionary<string, object> parameters)
        {
            DbConnection connection = this.CreateConnection();
            using (DbCommand command = connection.CreateCommand())
            {
                command.CommandText = procedureName;
                command.CommandType = CommandType.StoredProcedure;
                connection.Open();
                this.DeriveParameters(command);
                this.AssignParameters(command, parameters);
                return command.ExecuteReader(CommandBehavior.CloseConnection);
            }
        }

        public int ExecuteNonQuery(string procedureName, IDictionary<string, object> parameters)
        {
            using (DbConnection connection = this.CreateConnection())
            {
                using (DbCommand command = connection.CreateCommand())
                {
                    command.CommandText = procedureName;
                    command.CommandType =  CommandType.StoredProcedure;
                    connection.Open();
                    this.DeriveParameters(command);
                    this.AssignParameters(command, parameters);
                    return command.ExecuteNonQuery();
                }
            }
        }

        public T ExecuteScalar<T>(string procedureName, IDictionary<string, object> parameters)
        {
            using (DbConnection connection = this.CreateConnection())
            {
                using (DbCommand command = connection.CreateCommand())
                {
                    command.CommandText = commandText;
                    command.CommandType = CommandType.StoredProcedure;
                    this.DeriveParameters(command);
                    this.AssignParameters(command, parameters);
                    connection.Open();
                    return (T)command.ExecuteScalar();
                }
            }
        }
    }
}

注： 该DbHelper仅仅为演示之用，如果用于真正的开发中，应该进行一些优化，比如利用存储过程的参数缓存提高性能等 。

为了促进重用和扩展，我为每一个层的类型都定义了一个基类，这在真正的项目开发中是比较常见的做法。所有的基类定义在Common项目中，对于数据访问层，对应的基类是DataAccessBase。在DataAccessBase中，将上面定义的DbHelper作为它的只读属性，由于DbHelper是一个单纯的工具（Utility）对象，故将其定义成单例模式。

using System;
namespace Artech.PetShop.Common
{
    public class DataAccessBase:MarshalByRefObject
    {
        private static readonly DbHelper helper = new DbHelper("PetShopDb");

        protected DbHelper Helper
        {
            get
            {
                return helper;
            }
        }
    }
}

在Products.DataAccess和Orders.DataAccess中，分别定义了相应的DataAccessBase类型，用于进行产品的筛选和订单的提交。

ProductDA

using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using Artech.PetShop.Common;
using Artech.PetShop.Orders.BusinessEntity;
namespace Artech.PetShop.Orders.DataAccess
{
    public class ProductDA: DataAccessBase
    {
        public Product[] GetAllProducts()
        {
            List<Product> products = new List<Product>();
            using (DbDataReader reader = this.Helper.ExecuteReader("P_PRODUCT_GET_ALL", new Dictionary<string, object>()))
            {
                while (reader.Read())
                {
                    products.Add(new Product
                    {
                        ProductID   = new Guid((string)reader["PRODUCT_ID"]),
                        ProductName = (string)reader["PRODUCT_NAME"],
                        Description = (string)reader["PRODUCT_DESC"],
                        Picture     = (string)reader["PRODUCT_PIC"],
                        UnitPrice   = (decimal)reader["PRODUCT_UNIT_PRICE"],
                        Category    = (string)reader["PRODUCT_CATEGORY"],
                        Inventory   = (int)reader["PRODUCT_INVENTORY"]
                    });
                }
            }

            return products.ToArray<Product>();
        }

        public Product GetProductByID(Guid productID)
        {
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            parameters.Add("p_product_id", productID.ToString());
            using (DbDataReader reader = this.Helper.ExecuteReader("P_PRODUCT_GET_BY_ID", parameters))
            {
                while (reader.Read())
                {
                    return new Product
                    {
                        ProductID   = new Guid((string)reader["PRODUCT_ID"]),
                        ProductName = (string)reader["PRODUCT_NAME"],
                        Description = (string)reader["PRODUCT_DESC"],
                        Picture     = (string)reader["PRODUCT_PIC"],
                        UnitPrice   = (decimal)reader["PRODUCT_UNIT_PRICE"],
                        Category    = (string)reader["PRODUCT_CATEGORY"],
                        Inventory   = (int)reader["PRODUCT_INVENTORY"]
                    };
                }
            }

            return null;
        }
    }
}

OrderDA

using System;
using System.Collections.Generic;
using System.Transactions;
using Artech.PetShop.Common;
using Artech.PetShop.Orders.BusinessEntity;
namespace Artech.PetShop.Orders.DataAccess
{
  public  class OrderDA: DataAccessBase
    {
      public void Submit(Order order)
      {
          order.OrderNo = Guid.NewGuid();
          string procedureName = "P_ORDER_INSERT";
          Dictionary<string, object> parameters = new Dictionary<string, object>();
          parameters.Add("p_order_id",      order.OrderNo.ToString());
          parameters.Add("p_ordered_by",    ApplicationContext.Current.UserName);
          parameters.Add("p_total_price",   order.TotalPrice);
          parameters.Add("p_user_name",     ApplicationContext.Current.UserName);
          parameters.Add("p_transacion_id", Transaction.Current.TransactionInformation.LocalIdentifier);
          this.Helper.ExecuteNonQuery(procedureName, parameters);

          procedureName = "P_ORDER_DETAIL_INSERT";
          foreach (OrderDetail detail in order.Details)
          {
              parameters.Clear();
              parameters.Add("p_order_id",      order.OrderNo.ToString());
              parameters.Add("p_product_id",    detail.ProductID.ToString());
              parameters.Add("p_quantity",      detail.Quantity);
              parameters.Add("p_user_name",     ApplicationContext.Current.UserName);
              parameters.Add("p_transacion_id", Transaction.Current.TransactionInformation.LocalIdentifier);
              this.Helper.ExecuteNonQuery(procedureName, parameters);
          }
      }
    }
}

在PetShop中，对事务的控制放在服务层。事务在服务操作开始的时候被开启，在事务被提交之前，我们通过当前事务（Transaction.Current）的TransactionInformation属性得到事务ID（LocalIdentifier）。而CREATED_BY和LAST_UPDATED_BY代表当前登录系统的用户，对于采用分布式构架的PetShop来说，登录用户的获取仅限于Web服务器，对于应用服务器是不可得的。不仅仅是用户名，在基于分布式部署的情况下，可能会需要其他一些从客户端向服务端传递的上下文信息。为此我定义了一个特殊的组件：ApplicationContext，用于保存基于当前线程或者会话的上下文信息。关于ApplicationContext的实现，你可以参考《 通过WCF Extension实现Context信息的传递》，在这里只需要知道可以通过它获取登录PetShop系统的用户名。

五、业务逻辑层设计

业务逻辑层建立在数据访问层之上，在PetShop中模块业务逻辑层对应的项目为{Module}. BusinessComponent，所以业务对象类型也具有自己的基类：BusinessComponentBase。由于案例的逻辑相对简单，并没有太复杂的业务逻辑，所以主要集中在对数据访问层的调用上面。下面是定义在Products.BusinessComponent和Orders.BusinessComponent中业务类型的定义：

ProductBC

using System;
using Artech.PetShop.Common;
using Artech.PetShop.Orders.BusinessEntity;
using Artech.PetShop.Orders.DataAccess;
using Microsoft.Practices.Unity;
namespace Artech.PetShop.Products.BusinessComponent
{
   public class ProductBC: BusinessComponentBase
    {
       [Dependency]
       public ProductDA DataAccess
       { get; set; }

        public Product[] GetAllProducts()
        {
            return this.DataAccess.GetAllProducts();
        }

        public Product GetProductByID(Guid productID)
        {
            return this.DataAccess.GetProductByID(productID);
        }

        public int GetInventory(Guid productID)
        {
            return this.DataAccess.GetProductByID(productID).Inventory;
        }
    }
}

OrderBC

using Artech.PetShop.Common;
using Artech.PetShop.Orders.BusinessEntity;
using Artech.PetShop.Orders.DataAccess;
using Artech.PetShop.Products.Service.Interface;
using Microsoft.Practices.Unity;
namespace Artech.PetShop.Orders.BusinessComponent
{
    public class OrderBC:BusinessComponentBase
    {
        [Dependency]
        public OrderDA DataAccess
        { get; set; }

        [Dependency]
        public IProductService ProductService
        { get; set; }

        private void ValidateInventory(Order order)
        {
            foreach (var detail in order.Details)
            {

                if(this.ProductService.GetInventory(detail.ProductID) < detail.Quantity)
                {
                    throw new BusinessException("Lack of stock!");
                }
            }
        }

        public void Submit(Order order)
        {
            this.ValidateInventory(order);
            this.DataAccess.Submit(order);
        }
    }
}

PetShop采用典型的N层（N-Tier和N-Layer）应用架构和模块化设计，我们通过依赖注入模式实现模块之间，以及同一个模块各个层次之间的松耦合。在实现上，充分利用了Unity这样一个依赖注入容器。这两点都可以从业务逻辑层的实现看出来：

• 通过依赖注入容器创建底层对象：在业务逻辑层，对于数据访问层对象的创建是通过属性注入的方式实现的。比如，在ProductBC中，并没有手工创建ProductDA对象，而是将其定义成属性，并在上面应用了DependencyAttribute特性。那么当Unity创建ProductBC对象的时候，会初始化这个属性。

注： 虽然ProductBC对ProductDA并没有采用基于接口的调用（我们认为模块是应用最基本的逻辑单元，接口是模块对外的代理，模块之间的调用才通过接口；无须为同一个模块内各个层次之间的调用定义接口，当然，同一个模块调用WCF服务又另当别论。如果硬要为被调用层的类型定义接口，我认为这是一种设计过度），谈不上层次之间的松耦合，但是Unity是一种可扩展的依赖注入框架，我们可以同一些扩展去控制对象的创建行为，我认为这也是一种松耦合的表现。在PetShop中，正是因为采用这样的设计，我们可以在每一个层上应用PIAB的CallHandler实现AOP，此是后话。

• 通过依赖注入创建被依赖服务对象：一个模块的业务逻辑需要调用另一个模块的服务，需要采用基于接口的方式创建该服务。在OrderBC中，需要调用ProductService提供的服务获取相关产品的库存量。和上面一样，依然采用基于依赖属性的实现方式，所不同的是，这里属性的类型为接口。

六、服务层与服务接口（服务契约）

业务场景的简单性，决定了服务接口会很复杂。对于Products模块来说，其业务功能主要集中于产品列表的获取，以及基于某一个产品的相关信息和库存的查询；而Orders模块，则主要体现在提交订单上。下面是分别定义在Products.Service.Interface和Orders.Service.Interface的服务契约。

IProductService

using System;
using System.ServiceModel;
using Artech.PetShop.Common;
using Artech.PetShop.Orders.BusinessEntity;
namespace Artech.PetShop.Products.Service.Interface
{
    [ServiceContract(Namespace="http://www.artech.com/petshop/")]
    public interface IProductService
    {
        [OperationContract]
        [FaultContract(typeof(ServiceExceptionDetail))]
        Product[] GetAllProducts();

        [OperationContract]
        [FaultContract(typeof(ServiceExceptionDetail))]
        Product GetProductByID(Guid productID);

        [OperationContract]
        [FaultContract(typeof(ServiceExceptionDetail))]
        int GetInventory(Guid productID);
    }
}

IOrderService

using System.ServiceModel;
using Artech.PetShop.Common;
using Artech.PetShop.Orders.BusinessEntity;
namespace Artech.PetShop.Orders.Service.Interface
{
    [ServiceContract(Namespace = "http://www.artech.com/petshop/")]
    public interface IOrderService
    {
        [OperationContract]
        [FaultContract(typeof(ServiceExceptionDetail))]
       void Submit(Order order);
    }
}

在服务契约的每一个服务操作中，通过FaultContractAttribute定义了基于错误契约（Fault Contract），关于错误的契约，这是为了与EnterLib的Exception Handling Application Block集成的需要，具体的实现原理，可以参考《WCF与Exception Handling AppBlock集成[上篇][下篇]》。

服务接口定义完毕后，接下来的任务就是实现该接口，定义相应的服务。WCF服务定义在{Module}.Service项目中，服务操作通过调用对应的BusinessComonent实现。

ProductService

using System;
using Artech.PetShop.Common;
using Artech.PetShop.Orders.BusinessComponent;
using Artech.PetShop.Orders.BusinessEntity;
using Artech.PetShop.Products.Service.Interface;
using Microsoft.Practices.Unity;
namespace Artech.PetShop.Products.Service
{
    public class ProductService : ServiceBase, IProductService
    {
        [Dependency]
        public ProductBC BusinessComponent
        { get; set; }

        #region IProductService Members

        public Product[] GetAllProducts()
        {
           return this.BusinessComponent.GetAllProducts();
        }

        public Product GetProductByID(Guid productID)
        {
            return this.BusinessComponent.GetProductByID(productID);
        }

        public int GetInventory(Guid productID)
        {
            return this.BusinessComponent.GetInventory(productID);
        }

        #endregion
    }
}

OrderService：

using System.ServiceModel;
using Artech.PetShop.Common;
using Artech.PetShop.Orders.BusinessComponent;
using Artech.PetShop.Orders.BusinessEntity;
using Artech.PetShop.Orders.Service.Interface;
using Microsoft.Practices.Unity;
namespace Artech.PetShop.Orders.Service
{
    public class OrderService :ServiceBase, IOrderService
    {
        [Dependency]
        public OrderBC BusinessComponent
        { get; set; }

        #region IOrderService Members

        [OperationBehavior(TransactionScopeRequired= true)]
        [AuditCallHandler("提交订单")]
        public void Submit(Order order)
        {
            this.BusinessComponent.Submit(order);
        }

        #endregion
    }
}

关于服务的定义，有以下3点值得注意：

• 同BC（BusinssComponent）调用DA（DataAccess）一样，Service同样不需要通过new操作符创建BC对象，而是通过Unity提供的声明式（应用DependencyAttribute特性）对象创建方式降低统一模块中各个层级的依赖；
• 对于涉及操作数据（添加、修改和删除）的操作，需要将其纳入事务中保证数据的完整性。PetShop中采用WCF自有的事务管理方式，我们只需要在相应的操作中通过OperationBehavior设置TransactionScopeRequired属性即可；
• 由于在PetShop中，服务操作和事务具有相同的粒度，所以基于事务的审核也就是基于操作的审核。PetShop采用声明式的审核方式，我们只需要在相应的操作上添加AuditCallHandlerAttribute并设置操作审核名称即可。这是一种AOP的编程方式，在这里使用到的是微软提供的一个开源的AOP框架：PIAB。

作者：Artech
出处：http://artech.cnblogs.com
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。