关于业务逻辑和对象行为的思考

　　为什么今天写这篇博客呢？
　　主要是因为以前使用三层模式时，经常会出现一种问题，就是BLL业务逻辑层没有什么业务逻辑，经常被用作表现层和DAL数据层的过度，总感觉有跟没有都一样......，Model也只是用数据传输的载体，怎么就觉得跟OOP思想扯不上关系，在我理解的OOP思想里，对象应该是有生命力的才对啊！！

　　后来学习了领域驱动设计，使用EntityFramework CodeFirst重量级ORM，在看资料的过程中，心理可美滋滋的了，应为我觉得这才是我心目中的OOP思想，领域对象有属性，有行为，有事件等等，很具有生命力；随着项目运用，慢慢开始偏离轨道了，如果人生就是一个茶几，我就是上面的杯具，为毛还是和三层时的一样，对象的生命力在哪里，((‵□′)).....

　　作为一个想成为架构师的码农来说，不行，绝对不行，我必须反思，反省，反.......

　　下面是经过左思右想的一点点成果，和大家分享下，希望能得到一些建议。

　　首先先用以前的写法写一个非常简单下单处理，代码如下：

　　对象模型：

　　1.User用户模型

    public class User
        : EntityBase
    {
        public string UserName { get; set; }

        public string Email { get; set; }

        public string Telephone { get; set; }

        public Account Account { get; set; }
    }

　　2.Account账户模型

    public class Account
        : EntityBase
    {
        public Guid UserId { get; set; }

        public double Amount { get; set; }

        public DateTime ActiveLastTime { get; set; }
    }

　　3.Product产品模型

    public class Product
        : EntityBase
    {
        public string Name { get; set; }

        public double Price { get; set; }

        public double Description { get; set; }

        public int Number { get; set; }

        public bool IsPutaway { get; set; }
    }

　　4.Order订单模型

    public class Order
        : EntityBase
    {
        public string OrderNo { get; set; }

        public Guid ProductId { get; set; }

        public string ProductName { get; set; }

        public double Price { get; set; }

        public Guid UserId { get; set; }

        public DateTime CreateTime { get; set; }
    }

　　生成订单的处理逻辑

    public class OrderAppService
    {
        public void Create(Order order)
        {
            if (order == null)
                throw new ArgumentNullException("order");

            order.OrderNo = NewOrderNo();
            order.CreateTime = DateTime.Now;

            //进行创建订单
        }

        private string NewOrderNo()
        {
            return "";
        }
    }

　　表现层进行生成订单

        public JsonResult CreateOrder(Guid productId)
        {
            //这里数据获取就省略了哈...
            Web.Domain.UserModule.User user = null;
            Web.Domain.ProductModule.Product product = null;

            if (product.Number > 0)
                return Json(new { success = false, error = string.Format(""{0}" 该产品库存不足，无法购买。", product.Name) });

            if (!product.IsPutaway)
                return Json(new { success = false, error = string.Format(""{0}" 该产品还没有上架或者暂时下架，如有问题请咨询客服人员。", product.Name) });

            if (user.Account.Amount < product.Price)
                return Json(new { success = false, error = "您的金额不足，请先进行充值，再购买。" });

            Order order = new Order
            {
                ProductId = product.Id,
                ProductName = product.Name,
                Price = product.Price,
                UserId = user.Id
            };

            try
            {
                Web.Application.OrderModule.OrderAppService service = new Web.Application.OrderModule.OrderAppService();
                service.Create(order);
            }
            catch
            {
                return Json(new { success = false, error = "系统出错了，请稍后在进行购买。" });
            }
            return Json(new { success = true });
        }

　　OK，以前的写法就是这样，不知道有没有人和我写的差不多，(●'◡'●)....

　　下面是我根据自己的思路做的一些改进，同时引进前面一篇《提升Boolean和out相结合的用户体验》中的Can状态对象。

　　首先意识到的是表现层的CreateOrder下有很多订单处理的业务逻辑，应该放置在业务逻辑OrderAppService中，代码等下贴出。

　　再观察业务逻辑中的3个if,我觉得应该以拟人的方式进行思考，如下，

　　1.product.Number < 0 : 我们应该问产品："你现在还有库存吗？" 产品做出回答："没有!"；产品做出的回答属于产品的一个行为，那我觉得应该给它定义一个行为：Can HasNumber();

　　2.!product.IsPutaway ： 问："你现在什么状态我能购买吗？" 答："下架中，不能购买！"；虽然这里只有上下架的状态，后期可能会拓展，所有也给他定义一个行为：Can IsEnabled();

　　3.个人觉得这两个if都是询问产品能不能买，可能以后还会有其他限制，所有我觉得应该让产品直接回答我们能不能购买，让它自己一次性检查：Can CanBuying();

　　4.User.Account.Amount < product.Price：这个应该问用户：”我需要这么多的钱你有吗？“，用户说：”没有！“，Can HasMoney(double amount);

　　下面来看看改造后的模型：

    public class Product
        : EntityBase
    {
        public string Name { get; set; }

        public double Price { get; set; }

        public double Description { get; set; }

        public int Number { get; set; }

        public bool IsPutaway { get; set; }

        /// <summary>
        /// 有没有库存
        /// </summary>
        /// <returns></returns>
        public Can HasNumber()
        {
            if (this.Number < 0)
                return string.Format(""{0}" 该产品库存不足，无法购买。", this.Name);

            return true;
        }

        /// <summary>
        /// 当前状态是否支持购买
        /// </summary>
        /// <returns></returns>
        public Can IsEnabled()
        {
            if (!this.IsPutaway)
                return string.Format(""{0}" 该产品还没有上架或者暂时下架，如有问题请咨询客服人员。", this.Name);

            return true;
        }

        /// <summary>
        /// 当前产品是否可以购买
        /// </summary>
        /// <returns></returns>
        public Can CanBuying()
        {
            var hasNumber = this.HasNumber();
            if (!hasNumber)
                return hasNumber;

            var isEnabled = this.IsEnabled();
            if (!isEnabled)
                return isEnabled;

            return true;
        }
    }


    public class User
        : EntityBase
    {
        public string UserName { get; set; }

        public string Email { get; set; }

        public string Telephone { get; set; }

        public Account Account { get; set; }

        /// <summary>
        /// 是否有指定额度的钱
        /// </summary>
        /// <param name="amount">指定额度的钱</param>
        public Can HasMoney(double amount)
        {
            if (this.Account == null)
                throw new MemberAccessException("账户未被实例化");

            return this.Account.HasMoney(amount);
        }
    }


    public class Account
        : EntityBase
    {
        public Guid UserId { get; set; }

        public double Amount { get; set; }

        public DateTime ActiveLastTime { get; set; }

        /// <summary>
        /// 是否有指定额度的钱
        /// </summary>
        /// <param name="amount">指定额度的钱</param>
        public Can HasMoney(double amount)
        {
            if (this.Amount < amount)
                return "您的金额不足，请先进行充值，再购买。";
            return true;
        }
    }

    public class Order
        : EntityBase
    {
        public Order(Guid productId, string productName, double price, Guid userId)
        {
            this.ProductId = productId;
            this.ProductName = productName;
            this.Price = price;
            this.UserId = userId;

            this.CopyToNewOrder();
        }

        public string OrderNo { get; private set; }

        public Guid ProductId { get; set; }

        public string ProductName { get; set; }

        public double Price { get; set; }

        public Guid UserId { get; set; }

        public DateTime CreateTime { get; private set; }

        /// <summary>
        /// 拷贝为新创建的订单
        /// </summary>
        public void CopyToNewOrder()
        {
            this.OrderNo = this.NewOrderNo();
            this.CreateTime = DateTime.Now;
        }

        private string NewOrderNo()
        {
            return "";
        }
    }

　　然后我觉得应该学习下CQRS查询与命令分离的思路，为业务逻辑创建判断逻辑的统一存储如下：

    public static class OrderAppLogic
    {
        /// <summary>
        /// 是否可以创建订单
        /// </summary>
        /// <param name="user">用户</param>
        /// <param name="product">产品</param>
        /// <returns></returns>
        public static Can CanCreateOrder(User user, Product product)
        {
            Can canCreateOrder = true;

            if(!(canCreateOrder = product.CanBuying()))
                return canCreateOrder;

            if(!(canCreateOrder = user.HasMoney(product.Price)))
                return canCreateOrder;

            return canCreateOrder;
        }
    }

　　OrderAppService 就挺简单的了

        public Can Create(User user, Product product)
        {
            if (user == null)
                throw new ArgumentNullException("user");

            if (product == null)
                throw new ArgumentNullException("product");

            Can flag = true;

            if (!(flag = OrderAppLogic.CanCreateOrder(user, product)))
                return flag;

            Order order = new Order(product.Id, product.Name, product.Price, user.Id);

            //进行创建

            return flag;
        }

　　表现层代码就更简单了

        public JsonResult CreateOrder(Guid productId)
        {
            //这里数据获取就省略了哈...
            Web.Domain.UserModule.User user = null;
            Web.Domain.ProductModule.Product product = null;

            try
            {
                Web.Application.OrderModule.OrderAppService service = new Web.Application.OrderModule.OrderAppService();
                var result = service.Create(user, product);
                return Json(new { success = (bool)result, error = result.Error });
            }
            catch
            {
                return Json(new { success = false, error = "系统出错了，请稍后在进行购买。" });
            }
        }

　　目录结构：

　　

　　好了，终于写完了，大家要是如果有什么建议和意见，欢迎积极评论！如果您觉得还不错，帮忙点击下推荐呗！！