六、工厂模式Factory
Factory是常用到软件开发模式，在网上像简单工厂、工厂方法、抽象工厂等开发模式的资料都到处可寻，可这并不是领域驱动设计的主题。在这一节里，我主要想介绍Factory的适用时机。
并非生成所有对象的时候，都需要用到工厂模式。在生成简单对象的时候，可以直接利用构造函数来代替工厂，也可以添加工厂方法来生成对象。但如果在生成对象时，内部属性之间存在一系统复杂的业务规则的时候，就可以把生成方法独立到一个Factory类里面。这时候客户端无需理会潜在逻辑关系，而直接通过这个Factory来生成相应的对象。
举个例子，在新建Order的时候，业务上规定运费是总体金额的1%，折扣规定是7.5折...... 。如果由客户端新建一个对象Order，然后为这些属性负值，那相关的业务逻辑就会暴露在外。这时候就可以使用Factory模式，把属性之间的关系封装到Factory之内，客户端通过Factory就能轻松地生成Order对象而无需要理会复杂的内部关系。
至于较复杂的Factory模式，在此不多作介绍，各位可以在网上查找相关资料。
七、细说应用层
1. SOA系统中应用层的特点
在开发SOA分布式系统的时候，应用层是一个重点，它主要有两个作用。
第一，应用层主要作用是协调领域层工作，指挥领域对象解决业务问题，但应用层本身不会牵扯到业务状态。
第二，在SOA系统当中应用层是数据运输中心和信息发放的端口，担负着数据转换与数据收发的责任。
它有以下的特点：
1、粗粒度
分布式系统与普通网站和应用程序不同，因为它假定外界对系统内部是毫无了解的，用户只想输入相关数据，最后得到一系列计算结果。所以我们应该把计算结果封装在一个数据传输对象（DTO）内，实现粗粒度的传递，这是一般项目与SOA系统在服务层的一个最明显的差别。 想想如果一个页面需要同时显示一个顾客的个人资料、某张订单的详细资料，那将要同时获取Person、Order、OrderItem三张表的信息。在普通系统的开发过程中，这并不会造成太大问题，但在使用远程服务的时候，如果用三个方法分别获取，那将会造成不少的性能损耗。特别是在分布式开发系统中，应用层与表现层之间是实现分离的，更多时候两者是由不同部门所开发的模块，表现层不会了解应用层中的逻辑关系，Person，Order，OrderItem三样东西在表现层看来，也就是同一样东西，那就是返回值。所以在系统内，应该把多张表的信息封装在一个DTO对象内，通过应用层一个远程方法一次性返还。使用粗粒度的数据元素是分布式系统的一个特点。
2、 传输性
如果你熟悉SOA系统，对DTO（Data Transfer Object 数据传输对象）这个词一定并不陌生。DTO属于一个数据传输的载体，内部并不存在任何业务逻辑，通过DTO可以把内部的领域对象与外界隔离。DTO所封装的是客户端的数据，所以它的设计更多地是针对客户端的需求，而不是业务逻辑。比如说本来Person与Order是一对多的关系，但当一个页面只要显示的是一个客户的单张订单信息，那我们就可以根据需要把DTO中的Person和Order设计为一对一的关系。如果你是使用MVC开发一般的网站，更多时候会把返回对象直接转化为Model。如果你开发是一个分布式系统，那更多时候会从系统性能与隐藏业务逻辑出发着想。而且考虑到把内部对象转化为DTO，将是一件麻烦的事，建议应该考虑DTO的兼容性，使DTO可以作为多个方法的返还载体。（注意：在SOA系统内，应该从性能出发优先考虑粗粒度元素的传输性问题）
3、 封装性
在SOA系统当中应用层服务的发布并不需要复杂的模型，只需使用外观模式（Facade）把一些功能封装在少数的几个服务类里面，使用Web Service、TCP/IP套接字、MSMQ等服务方式向外界发布。
说到这里，我真的十分感激Martin先生带给我的帮助，在开发过程中，这些复杂的问题带给我不少的困扰，Martin先生一纸富有经验的独特见解，真的带给在下很大的启发。
2. 应用层的协调性
应用层服务会利用Repository，完成实体基本的插入、更新、获取等等操作，并调用领域层的服务管理的业务逻辑。注意观察，一切的业务逻辑都只会隐藏于领域层，应用层服务只起着协调作用，本身不应该包含有任何业务逻辑。
可以看到OrderService就是通过调用AccountManager、PaymentManager等领域层服务来完成结账、付款等一系列复杂业务逻辑的。
namespace Business.Service.ApplicationService
{
public class PersonService
{
private IPersonRepository personRepository = DataAccess.CreatePersonRepository();
public int AddPerson(Person person)
{
return personRepository.AddPerson(person);
}
public int UpdatePerson(Person person)
{
return personRepository.UpdatePerson(person);
}
public Person GetPerson(int personID)
{
return personRepository.GetPerson(personID);
}
public IListGetList()
{
return personRepository.GetList();
}
}
public class OrderService
{
private IOrderRepository orderRepository = DataAccess.CreateOrderRepository();
public int AddOrder(Order order)
{
//计算Order总体费用
Account(order);
//加入修改后的Order
return orderRepository.AddOrder(order);
}
//调用领域层服务AccountManager，计算Order总体费用
private void Account(Order order)
{
//获取对应Person对象
IPersonRepository personRepository = DataAccess.CreatePersonRepository();
Person person = personRepository.GetPerson(order.PersonID);
//调用服务层的AccountManager对象，计算费用，修改Order
AccountManager accountManager = new AccountManager(person, order);
accountManager.Account();
}
//调用领域层服务PaymentManager，确认订单
public Order Payment(int orderID)
{
var order=orderRepository.GetOrder(orderID);
if (order != null)
{
PersonRepository personRepository = new PersonRepository();
var person=personRepository.GetPerson(order.PersonID);
PaymentManager paymentManager = new PaymentManager();
paymentManager.Payment(order, person);
orderRepository.UpdateOrder(order);
personRepository.UpdatePerson(person);
return order;
}
else
throw new Exception("Can not find order!");
}
public int DeleteOrder(Order order)
{
return orderRepository.DeleteOrder(order.ID);
}
public Order GetOrder(int orderID)
{
return orderRepository.GetOrder(orderID);
}
public IListGetList()
{
return orderRepository.GetList();
}
public IListGetListByPerson(int personID)
{
return orderRepository.GetListByPerson(personID);
}
public int UpdateOrder(Order order)
{
Account(order);
return orderRepository.UpdateOrder(order);
}
public int AddOrderItem(OrderItem orderItem)
{
int index = orderRepository.AddOrderItem(orderItem);
Order order = orderRepository.GetOrder(orderItem.OrderID);
UpdateOrder(order);
return index;
}
public int DeleteOrderItem(OrderItem orderItem)
{
int index = orderRepository.DeleteOrderItem(orderItem.ID);
Order order = orderRepository.GetOrder(orderItem.OrderID);
UpdateOrder(order);
return index;
}
.......................
.......................
}
} |
3. 数据转换过程
前面已经解释了DTO的作用，但实现领域对象与DTO之间的转换是一件复杂的事件，因此可以建立一个数据转换器实现此功能。
在平常的工作里，不太多会把“订单管理系统”做成SOA的模式，因为在分布式系统中，数据的格式与定义大多数由部门之间协定，其中包含明确的规则。但由于条件的局限，在这里还是想以订单管理为例子，希望可以带给你一定的帮助。例子如下：在购物车结账，页面会包含用户基本信息，当前订单信息，订单明细信息等多个部分。
>
要完成数据转换，首先可以根据页面建立DTO对象，在分布式系统中，通常会把DTO对象放在一个独立的命名空间里，在这个实例里面称之为Business.TransferObject。DTO对象更多时候是面向表现层的需求而建立，这里由于表现层页面所需要的只是单个用户，单张订单的数据，所以在OrderDTO对象里会包含了用户信息和订单资料，也存在订单详细列List<OrderItemDTO>。当然，DTO的设计可以随着需求而修改。
在SOA系统里，DTO是远程服务数据的载体，所以会把DTO附上可序列化特性，这此例子中会使用WCF的数据契约实现OrderDTO和OrderItemDTO。
如图，要实现数据转换，就应该建立数据转换器。在这里OperationAssembler就是一个数据转换器，它是数据转换的核心，它是领域对象与DTO之间实现转换的工具。要在多个对象之间实现数据转换实在是一件非常麻烦的事，所以我一直提倡注意DTO对象的兼容性，使单个DTO对象可以适用于多个外观层，以减少数据转换所带来的麻烦。
namespace Business.Service.ApplicationService
{
public class OperationAssembler
{
//把领域对象转换成DTO
public static OrderDTO GetOrderDTO(Order order,Person person)
{
OrderDTO orderDTO = new OrderDTO();
if (person != null)
{
orderDTO.EMail = person.EMail.GetString();
orderDTO.Address = person.Address.GetString();
orderDTO.Name = person.Name.GetString();
orderDTO.PersonID = person.ID;
orderDTO.Point = person.Point.GetInt();
orderDTO.Telephone = person.Telephone.GetString();
}
if (order != null)
{
orderDTO.PersonID = order.PersonID;
orderDTO.Count = order.Count.GetInt();
orderDTO.Delivery = order.Delivery.GetDateTime();
orderDTO.Favorable = order.Favorable.GetDouble();
orderDTO.Freightage = order.Freightage.GetDouble();
orderDTO.OrderID = order.ID;
orderDTO.OrderNumber = order.OrderNumber.GetString();
orderDTO.Price = order.Price.GetDouble();
orderDTO.TotalPrice = order.TotalPrice.GetDouble();
var orderItemList = order.OrderItem.ToList();
if (orderItemList.Count != 0)
{
var orderItemDTO = new List();
foreach (var orderItem in orderItemList)
orderItemDTO.Add(GetOrderItemDTO(orderItem));
orderDTO.OrderItemList = orderItemDTO;
}
}
return orderDTO;
}
public static OrderItemDTO GetOrderItemDTO(OrderItem orderItem)
{
OrderItemDTO orderItemDTO = new OrderItemDTO();
orderItemDTO.Count = orderItem.Count.GetInt();
orderItemDTO.Goods = orderItem.Goods.GetString();
orderItemDTO.OrderID = orderItem.OrderID;
orderItemDTO.OrderItemID = orderItem.ID;
orderItemDTO.Price = orderItem.Price.GetDouble();
return orderItemDTO;
}
//把DTO转换成多个对象
public static void SetOrder(OrderDTO orderDTO, out Person person, out Order order)
{
person = new Person();
person.EntityKey=new System.Data.EntityKey("BusinessContext.Person","ID",orderDTO.PersonID);
person.Address = orderDTO.Address;
person.EMail = orderDTO.EMail;
person.ID = orderDTO.PersonID;
person.Name = orderDTO.Name;
person.Point = orderDTO.Point;
person.Telephone = orderDTO.Telephone;
order = new Order();
order.EntityKey=new System.Data.EntityKey("BusinessContext.Order","ID",orderDTO.OrderID);
order.Count = orderDTO.Count;
if (orderDTO.Delivery.Year!=0001&&orderDTO.Delivery.Year!=9999)
order.Delivery = orderDTO.Delivery;
order.Favorable = orderDTO.Favorable;
order.Freightage = orderDTO.Freightage;
order.ID = orderDTO.OrderID;
order.OrderNumber = orderDTO.OrderNumber;
order.PersonID = orderDTO.PersonID;
order.Price = orderDTO.Price;
order.TotalPrice = orderDTO.TotalPrice;
var orderItemDTOList = orderDTO.OrderItemList;
if (orderItemDTOList.Count() != 0)
foreach (var orderItemDTO in orderItemDTOList)
order.OrderItem.Add(GetOrderItem(orderItemDTO));
}
public static OrderItem GetOrderItem(OrderItemDTO orderItemDTO)
{
OrderItem orderItem = new OrderItem();
orderItem.EntityKey = new System.Data.EntityKey("BusinessContext.OrderItem", "ID", orderItemDTO.OrderItemID);
orderItem.Count = orderItemDTO.Count;
orderItem.Goods = orderItemDTO.Goods;
orderItem.ID = orderItemDTO.OrderItemID;
orderItem.OrderID = orderItemDTO.OrderID;
orderItem.Price = orderItemDTO.Price;
return orderItem;
}
}
}
//数据传输对象 DTO
namespace Business.TransferObject
{
[DataContract]
public class OrderItemDTO
{
private int _orderItemID;
private int _orderID;
private string _goods;
private double _price;
private int _count;
[DataMember]
public int OrderItemID
{
get { return _orderItemID; }
set { _orderItemID = value; }
}
............
............
}
[DataContract]
public class OrderDTO
{
private int _personID;
private string _name;
private string _address;
private string _telephone;
private int _point;
private string _email;
private int _orderID;
private string _orderNumber;
private int _count;
private double _freightage;
private double _favorable;
private DateTime _delivery;
private double _price;
private double _totalPrice;
private IList_orderItemDTOList;
[DataMember]
public int PersonID
{
get{return this._personID;}
set{this._personID=value;}
}
..........
..........
}
} |
通过数据转换器，可以顺利实现领域模型与DTO之间的转换，协调应用层服务的运行。
4. 应用层的发布
在开发SOA系统的时候，应用层的服务需要使用远程方法对外开放，在接收到请求的时候，它可以调用领域层服务获取运算结果，然后通过数据转换器OperationAssembler把运算结果转换成DTO，最后返还到表现层。在起初，我曾尝试对应每个应用层的对象建立一个远程接口，但经过多次重构以后，我觉得行程对象就是一个简单的对外接口，对象之间不存在什么逻辑关系。所以更简单的方法是使用外观模式，建立少数的几个远程服务类，把所有的应用层对象的方法都包含在内。
可以留意代码，OperationService包括了对Person模型和Order模型的所有操作。而且每个操作都只是简单地调用应用层服务 (ApplicationService) 获得计算结果，然后使用数据转换器 （OperationAssembler）转换数据，当中并不存在任何的业务逻辑。
namespace Business.Service.ApplicationService
{
[ServiceContract]
public interface IOperationService
{
[OperationContract]
int AddOrder(ref OrderDTO orderDTO);
[OperationContract]
int DeleteOrder(OrderDTO orderDTO);
[OperationContract]
int UpdateOrder(ref OrderDTO orderDTO);
[OperationContract]
IListGetOrderByPerson(int personID);
[OperationContract]
OrderDTO GetOrder(int orderID);
[OperationContract]
int AddPerson(ref OrderDTO orderDTO);
[OperationContract]
int UpdatePerson(ref OrderDTO orderDTO);
[OperationContract]
OrderDTO GetPerson(int personID);
[OperationContract]
IListGetPersonList();
[OperationContract]
OrderDTO Payment(int orderID);
}
public class OperationService:IOperationService
{
[OperationBehavior(TransactionScopeRequired = true, TransactionAutoComplete = true)]
public int AddOrder(ref OrderDTO orderDTO)
{
OrderService orderService = new OrderService();
Order order = GetOrder(orderDTO);
int n = orderService.AddOrder(order);
orderDTO = OperationAssembler.GetOrderDTO(order, null);
return n;
}
[OperationBehavior(TransactionScopeRequired = true, TransactionAutoComplete = true)]
public int DeleteOrder(OrderDTO orderDTO)
{
OrderService orderService = new OrderService();
return orderService.DeleteOrder(GetOrder(orderDTO));
}
[OperationBehavior(TransactionScopeRequired = true, TransactionAutoComplete = true)]
public int UpdateOrder(ref OrderDTO orderDTO)
{
OrderService orderService = new OrderService();
Order order = GetOrder(orderDTO);
int n = orderService.UpdateOrder(order);
orderDTO = OperationAssembler.GetOrderDTO(order, null);
return n;
}
..............
..............
}
} |
八、系统总体架构
1. 体现领域驱动设计的架构
到此总结一下领域驱动设计DDD的总体结构，Repository层使用ORM映射或SQL命令等方式把持久化数据转化为领域对象，然后根据业务逻辑设计对应领域层服务Domain Service 。接着应用层进行操作上的协调，利用Repository、领域模型、领域层服务Domain Service 完成业务需要，再通过数据转换器把领域对象Domain Object转化为数据传输对象DTO。最后，利用远程通讯技术把应用层的服务（Application Service）对外开放。
注意留意的是SOA系统中，UI表现层与Application Service应用层服务是实现分离的，表现层可以同时调用多方的远程服务来完成工作。
2. 体现面向服务开发的架构
面向服务开发SOA的架构主要体现在表现层与应用层之间通过远程通讯实现分离，表现层可以引用多方的应用服务作为基础。由此系统实现业务上的分离，不同的功能模块可以独立开发，最后通过服务在表现层共同体现。长期的发展，使不少的企业针对单个功能模块开发出一套独立的系统，再通过强大的虚拟化技术为第三方提供服务，这就是云计算的前身。
就像一个通讯购物的平台，其实就是综合了内部业务管理、银行转帐服务、呼叫中心、第三方接口等多方服务的综合性平台。如果你有过这方面的经验，就会知道其实银行转帐、呼叫中心不过就是银行、电信、移动等公司提供的几个简单的接口。开发人员根本无需理会其实内部的结构，只要通过几个简单的远程方法就能调用。这正是应用层服务 Application Service 的最好体现。
3. 结束语
写这篇文章目的只是想与各位分享一下我在开发过程中的一些体会，欢迎各位点评，指出其中的不足。
其实架构是死物，人才是有脑子的生物。每一个架构必然会有其优点，也会有不足之处，我们应该从开发之中一齐起来体验，而不是盲目地跟从，希望在下的拙见能够给大家带来帮助。可别忘了支持一下，挺一挺。
出处：http://www.uml.org.cn/zjjs/201504301.asp
223
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
