博客园_Assion Yang

面向领域开发示例

2011-05-10T06:09:00Z

最近面向领域的知识挺火，我也来插一腿。说说我平时做项目时候用到的开发方式，以下代码为伪代码，主要展示一下我现在的开发方式供大家讨论，系统中不考虑持久、UI、AOP和IOC等方面内容。

说到.NET社区的“开发方式”就不得不提一下Petshop了，可以说Petshop真是影响了.NET的一代人。以至于三层成了.NET这边流行的标准的开发方式。但是要说一下Petshop是数据库驱动业务核心的过程式开发，也正是它也毒害了一批人。

下面我们以一个最常见也是大家比较熟的下定单来简单看一下。首先是系统的几个领域类：

应牧章的要求，加上类之间的关系：这里的关系很简单，Order与OrderItem是一对多关系；OrderItem与Product是一对多关系；定单提交业务Order对象是个“根”

我也就不解释了，发下几个类的代码里面有注解。大家看一下就明白了。这里我们要强调的是类关系，还有一个根的概念。每个业务流都会有一个根。而根不是整个系统唯一确定的是而是根据对象在哪个业务范围内而决定的。显然这里面是Order定单对象。

    /// <summary>
    /// 商品
    /// </summary>
    public class Product
    {
        /// <summary>
        /// 键
        /// </summary>
        public int SysNo { get; set; }
        /// <summary>
        /// 商品名称
        /// </summary>
        public string ProductName { get; set; }
        /// <summary>
        /// 商品价格
        /// </summary>
        public decimal ProductPrice { get; set; }
        private Category _category;
        /// <summary>
        /// 所属分类
        /// </summary>
        public Category Category
        {
            get { return _category; }
            set { _category = value; }
        }
    }

    /// <summary>
    /// 定单
    /// </summary>
    public class Order
    {
        #region 属性
        /// <summary>
        /// 键
        /// </summary>
        public int SysNo { get; set; }
        /// <summary>
        /// 定单ID
        /// </summary>
        public string OrderId { get; set; }
        /// <summary>
        /// 定单金额
        /// </summary>
        public decimal OrderAmount { get; set; }
        /// <summary>
        /// 运费金额
        /// </summary>
        public decimal ShipAmount { get; set; }
        /// <summary>
        /// 支付金额
        /// </summary>
        public decimal PayAmount { get; set; }
        /// <summary>
        /// 定单状态
        /// </summary>
        public int OrderStatus { get; set; }
        /// <summary>
        /// 定单时间
        /// </summary>
        public DateTime OrderTime { get; set; }
        private List<OrderItem> _orderItems = new List<OrderItem>();
        /// <summary>
        /// 定单明细
        /// </summary>
        public List<OrderItem> OrderItems
        {
            get { return _orderItems; }
            set { _orderItems = value; }
        }
        #endregion

        #region 方法
        /// <summary>
        /// 计算定单金额
        /// </summary>
        /// <returns></returns>
        public decimal GetOrderAmount()
        {
            decimal amount = 0;
            //计算商品金额
            foreach (var item in OrderItems)
            {
                amount += item.GetAmount();
            }
            //加上运费
            amount += ShipAmount;
            return amount;
        }
        #endregion

    }

/// <summary>
    /// 定单明细
    /// </summary>
    public class OrderItem
    {
        #region 属性
        /// <summary>
        /// 键
        /// </summary>
        public int SysNo { get; set; }
        private Product _product = new Product();
        /// <summary>
        /// 购买商品
        /// </summary>
        public Product Product
        {
            get { return _product; }
            set { _product = value; }
        }
        /// <summary>
        /// 购买价格
        /// </summary>
        public decimal ProductPrice { get; set; }
        /// <summary>
        /// 购买数量
        /// </summary>
        public int ProductQty { get; set; }
        #endregion

        #region 方法
        /// <summary>
        /// 主算小计金额
        /// </summary>
        /// <returns></returns>
        public decimal GetAmount()
        {
            return this.ProductPrice * Convert.ToDecimal(this.ProductQty);
        }
        #endregion
    }

/// <summary>
    /// 商品库存
    /// </summary>
    public class Inventory
    {
        #region 属性
        /// <summary>
        /// 键
        /// </summary>
        public int SysNo { get; set; }
        /// <summary>
        /// 更新键，用来保证更新的数据之前没有别人更新过。对应表的ModKey列,每更新一次更新Guid值
        /// </summary>
        public Guid ModKey { get; set; }
        private Product _product = new Product();
        /// <summary>
        /// 商品
        /// </summary>
        public Product Product
        {
            get { return _product; }
            set { _product = value; }
        }
        /// <summary>
        /// 库存数量
        /// </summary>
        public int Qty { get; set; }
        #endregion

        #region 方法
        /// <summary>
        /// 验证库存是否有库存
        /// </summary>
        /// <returns></returns>
        public bool ValidInventory()
        {
            if (this.Qty > 0)
                return true;
            else
                return false;
        }
        /// <summary>
        /// 减库存
        /// </summary>
        /// <param name="qty"></param>
        public void MinusInventory(int qty)
        {
            if (this.Qty < qty)
                throw new Exception("库存不足！");
            this.Qty -= qty;
        }
        #endregion
    }

接下来看看我这个伪代码的项目结构。做的很简单，简单明快的架构就是好的架构，不要把架构搞的很复杂。

Domain：领域层，里面放的是领域对象。这个层对其它层没有依赖

Repository：持久层，对领域对象进行持久。里面可以有级存和DB等。这个层依赖Domain

Services：应用程序服务，这个名字喜好着起吧。我们可以把它理解为业务逻辑层，当然这个业务逻辑是对一个功能更粗粒度的API。里面会调用依赖的领域对象进行业务组合达到业务需求。当然对对象的持久也是这里来做的。这个层依赖Domain和Repository

Web：UI层，调用Services进行业务处理，需要ViewModel(VO)我们可以加，我个人比较喜欢按需要创建ViewModel对象，不需要的没必要增加工作量。

基本流程就是

UI调用Serivices创建定单

Services调用Domain对象进行业务组合处理

最后Services调用Repository进行对象的持久

我们从上到下，首先是UI的控制器里面开始。生成定单

public ActionResult About()
        {
            //创建定单，生成定单必要数据收货信息，购物车信息等
            Order order = new Order();
            OrderService service = new OrderService();
            service.OrderBuy(order);//定单提交

            return View();
        }

然后是Services里面的方法

/// <summary>
        /// 定单提交
        /// </summary>
        /// <param name="order"></param>
        public void OrderBuy(Order order)
        {
            //事务开始
            order.OrderAmount = order.GetOrderAmount();//计算订单金额
            //更新库存
            foreach (var item in order.OrderItems)
            {
                Inventory inventory = InventoryRepository.LoadInventory(item.Product);//取得一个库存对象
                inventory.MinusInventory(item.ProductQty);//调用库存调用方法
                InventoryRepository.SaveInventory(inventory);//持久更新完的库存
            }
            OrderRepository.SaveOrder(order);//持久化定单
            //事务结束
        }

Repository里面的是伪代码，就不发了。

工作呢，写的很粗略。最后说一点，其实面向领域开发通过这些代码是看不出本质的。我在这总结一下。

把你的开发关注点提到类（对象）上来，不要把关注点放到数据库（表）上。

PS：我也是存储过程（业务）反对派

本文链接

数据映射工具 AssionMapper

2011-03-30T08:00:00Z

这是一个轻量的映射工具，不可与ORM做比较。它不参与到DB。一般用来配合SqlHelper来使用。目前实现的功能有：DataReader到List的映射、

DataReader到T的映射、List到List的映射、T到T的映射、T到数据库参数的映射。以上这些都是平时操作数据库工作量最大的部分，而且都是重

复的没有含量的工作。其实真正写SQL并不占用多少工作量。

下面来说下如何使用，并写几个各个功能下的使用示例。

首先下载：Assionsoft.AssionMapper 程序集，所有映射功能全部在这个程序集下面。不需要进行XML的配置。

1、我们不采取XML配置的映射形式，而是在实体类上标上特性的方式。通过元数据标识映射。比如下面的学生实体：

[ResultMap("SysNo")]//参与单体DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ResultsMap("SysNo")]//参与集合DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ObjectMap]//参与对象映射
        [ParameterMap]//参与数据库参数映射
        public int SysNo { get; set; }
        [ResultMap("Name")]//参与单体DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ResultsMap("Name")]//参与集合DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ObjectMap]//参与对象映射
        [ParameterMap("Name")]//参与数据库参数映射
        public string Name { get; set; }
        [ResultMap("Gender")]//参与单体DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ResultsMap("Gender")]//参与集合DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ObjectMap]//参与对象映射
        [ParameterMap]//参与数据库参数映射
        public bool Gender { get; set; }
        [ResultMap("Age")]//参与单体DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ResultsMap("Age")]//参与集合DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ObjectMap]//参与对象映射
        [ParameterMap]//参与数据库参数映射
        public int Age { get; set; }
        [ResultMap("Birthday")]//参与单体DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ResultsMap("Birthday")]//参与集合DataReader返回映射，如果[ResultMap]无参则默认已属性名匹配
        [ObjectMap]//参与对象映射
        [ParameterMap]//参与数据库参数映射
        public DateTime Birthday { get; set; }

2、数据库插入增、删、改的参数映射，我们通过委托把Common.Parameter.AddWithValue传给方法进行与student的映射。

Student student = new Student() { Name = "张三", Gender = true, Age = 25, Birthday = DateTime.Now };
            SqlConnection conn = new SqlConnection("server=ASSIONYANG-PCJ\\SQLEXPRESS;uid=sa;pwd=123;database=Testing");
            conn.Open();
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = conn;
            cmd.CommandText = "INSERT INTO ([Name],[Gender],[Age],[Birthday]) VALUES (@Name,@Gender,@Age,@Birthday)";
            ParameterMap.SqlParameterMap<Student>(cmd.Parameters.AddWithValue, student);//生成数据库参数
            cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            conn.Close();

3、DataReader返回集合的映射

IList<Student> studentList = new List<Student>();
            SqlConnection conn = new SqlConnection("server=ASSIONYANG-PCJ\\SQLEXPRESS;uid=sa;pwd=123;database=Testing");
            conn.Open();
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = conn;
            cmd.CommandText = "SELECT [SysNo],[Name],[Gender],[Age],[Birthday] FROM Student ORDER BY [SysNo] DESC";
            SqlDataReader dataReader = cmd.ExecuteReader();
            studentList = ResultMap.GetIList<Student>(dataReader);//从DataReader返回实体集合
            dataReader.Close();
            conn.Close();

4、DataReader 返回实体的映射

            Student student = new Student();
            SqlConnection conn = new SqlConnection("server=ASSIONYANG-PCJ\\SQLEXPRESS;uid=sa;pwd=123;database=Testing");
            conn.Open();
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = conn;
            cmd.CommandText = "SELECT [SysNo],[Name],[Gender],[Age],[Birthday] FROM Student WHERE [SysNo]=@SysNo";
            ParameterMap.SqlParameterMap<Student>(cmd.Parameters.AddWithValue, student);
            SqlDataReader dataReader = cmd.ExecuteReader();
            student = ResultMap.Load<Student>(dataReader);//从DataReader返回单个实体
            dataReader.Close();
            conn.Close();

5、集合TO 集合的映射

            IList<Student> studentList = new List<Student>();
            IList<Student> studentResultList = new List<Student>();
            studentResultList = ResultMap.GetIList<Student, Student>(studentList);//从集合返回集合

6、实体TO 实体的映射

            Student student = new Student();
            Student studentResult = new Student();
            studentResult = ResultMap.Load<Student, Student>(student);//从实体返回实体

水文结束!

本文链接

实现简单DTO适配器,解放你的双手

2010-11-10T03:30:00Z

多数人不喜欢用DTO的一个重要原因是嫌麻烦，需要写一堆DTO类不说，还要做DTO到DomainObject,DomainObject到DTO的转换映射，就是这个映射部分，让我感到很不爽，所以写了一个较通用的适配器来完成这部分的Mapping工作。这里有几点觉得有必要提一下：

首先，关于DTO，伟大的“码总”说，DTO应该是扁平的，不应该包含过于复杂的对象。所以我就不考虑DTO里面的过于复杂的子对象，当然DTO只是个数据载体，也不应该有错宗复杂的对象关系了。
其次，关于DomainObject，DomainObject是充血的，对象关系是复杂的。其中包含聚合根等各种复杂关系概念。DomainObject的对象关系，复杂对象的填充应该由业务来做，而不是通过适配器来填充了。

最后，关于上面两点问题弄清楚了，事情就好办多了。D-D之间的关系我们总结一下，大至分为：一对一、一对多、多对一、多对多这么四个对象映射关系。也就是说可能一个DTO对象对应一个DomainObject对象，多个DTO对象对应一个DomainObject对象，一个DTO对象对应多个DomainObject对象，多个DTO对象对应多个DomainObject对象等。这里的映射关系我通过在DTO上标记自定义特性来实现。考虑过通过XML配置，但是想想这种场景一般都是DTO做为匹配对象，去找Do，所以我们只需要标记DTO对象就可以了。必竟DTO是为DO工作的。好接下来我们就说实现，这只是一个晚上实现的初步版本，只是实现了基本的功能。

先上个项目结构图，然后再做分解。项目没什么，因为只是一个功能嘛。Assionsoft.Dtod就是实际的适配器项目，而Assionsoft.Dtod.UnitTest是单元测试。

Dtod里面就是几个类，我们先简要概括一下。

AppEnum 枚举定义类

AttributeManager 自定义特性操作类

DoAdapter DO适配器,用于DTO到DO的转换

DtoAdapter DTO适配器，用于DO到DTO的转换

DtodException 系统自定义异常

DtoMemberMapAttribute 需要转换映射成员的标记特性，限制于属性

IAdapter 适配器接口，规范DTO和DO适配器

接下来我们看看怎么使用，我们做几个例子来说明一下，首先DTO到DO的一对一的适配，我们先做两个对象，一个DTO对象，一个DO对象

/// <summary>
    /// Member DTO对象
    /// </summary>
    public class MemberDto
    {
        public MemberDto()
        {
            SysNo = Guid.NewGuid();
        }
        /// <summary>
        /// 标识
        /// </summary>
        [DtoMemberMap("Member.SysNo")]
        public Guid SysNo { get; set; }
        /// <summary>
        /// 成员名
        /// </summary>
        [DtoMemberMap("Member.MemberName")]
        public string MemberName { get; set; }
        /// <summary>
        /// 成员描述
        /// </summary>
        [DtoMemberMap("MemberDesc.MemberDescs")]
        public string MemberDesc { get; set; }
    }

这个是DTO对象，看字属性上标记了DtoMemberMap代表它要映射到DO上的哪个字段，而 Member.MemberName就是指定哪个类的哪个字段。下面是相应的DO类

/// <summary>
    /// 成员领域对象
    /// </summary>
    public class Member
    {
        public Member()
        {
            SysNo = Guid.NewGuid();
        }
        /// <summary>
        /// 标识
        /// </summary>
        public Guid SysNo { get; set; }
        /// <summary>
        /// 成员名
        /// </summary>
        public string MemberName { get; set; }
        /// <summary>
        /// 成员描述
        /// </summary>
        public MemberDesc MemberDesc { get; set; }

        /// <summary>
        /// 领域逻辑
        /// </summary>
        /// <returns></returns>
        public bool IsOk()
        {
            if (MemberName.Length <= 0)
                return false;
            else
                return true;
        }
    }

/// <summary>
    /// 成员描述领域对象
    /// </summary>
    public class MemberDesc
    {
        public MemberDesc()
        {
            SysNo = Guid.NewGuid();
        }
        /// <summary>
        /// 标识
        /// </summary>
        public Guid SysNo { get; set; }
        /// <summary>
        /// 成员描述
        /// </summary>
        public string MemberDescs { get; set; }
    }

我们看到这里是一个DTO对应两个DO对象的关系，我们做一下一对多的适配例子

/// <summary>
        /// 一对多
        /// </summary>
        [TestMethod()]
        public void DoAdapterOneToAll()
        {
            //创建一个DTO对象
            MemberDto memberDto = new MemberDto();
            memberDto.MemberName = "张三";
            memberDto.MemberDesc = "张三是好淫啊！！！";

            //创建多个领域对象
            Member member = new Member();
            MemberDesc memberDesc = new MemberDesc();

            //实例化DO适配器，并初始化DTO对象
            IAdapter adapter = new DoAdapter(memberDto);
            //填充领域对象
            adapter.Fill(new object[]{member,memberDesc});

            Assert.AreEqual(member.MemberName+memberDesc.MemberDescs, memberDto.MemberName+memberDto.MemberDesc);
        }

先实例一个DTO对象并用来测试用，然后创建两个DO对象。当然，我们是空对象。这时我们实例化DO适配器。因为这里是DTO到DO的转换。我们要填充的是DO，所以实例化DO适配器。通过接口IAdapter实例化DoAdapter对象，关传入memberDto初始对象，接下来调用Fill方法，对两个DO对象member,memberDesc进行适配，最后我们做了个单元测试。对比DTO和DO对象的值。发现已经完成了DTO到DO的转换，其他的关系与此类似，我就不浪费篇幅了。

先前是用泛型做的，但是发现泛型有限制，不能做多关系。所以后来改成object了。

本文链接

三层开发方法洪流下被QJ的MVC

2010-11-05T05:17:00Z

首先大家看到这个标题一定会产生一个想法，这是什么跟什么啊，先且不说大家对“QJ”一词的理解，就说三层和MVC本来最初被大家误认的东西到现在大家都明白的一个东西，他们怎么会被扯到一起？MVC不能代替三层，三层也并不能代替MVC啊！你连三层和MVC的本质都没搞明白，还在这里乱说。其实这里我只是稍标题党一下，由这个标题引发一的场沉思。

1、三层的由来？三层为何像凤姐一样如此之火？

首先，想必大家最熟悉的也是最长用的就是三层“开发方法”了吧，无论懂的与不懂的，大街小巷。以至于一些软件培训机构都把三层做为面试必修课，无论是真懂还是假懂都能说出个“所以然”来。三层形式真是一片大好啊。回头想想三层为何如此之火，这就要说到PetShop来了，微软当初推出PetShop真是个明智之举，这么个东西对推动.NET发展真是起到了非常大的作用，他告诉了大家我.NET是怎么样可以做企业开发，怎么样标准的。同时他最大的功劳就是“标准化了大家的开发模式，对技术流通起到了很正面的作用”。同时也产生了一定的问题，就是大多数人只认三层了（当然这里暂且不说三层的好与坏）。

2、 MVC模式

随着asp.net mvc框架的推出，在.NET社区引发了一场MVC热。一时间大家对webform充满了敌意，唯mvc是从。当然这不是说MVC不好。说到MVC，中文解释就是Model(模型)，View(视图)，Controller(控制器)。View和Controller是用来做View的，实现表现元素与表现逻辑的分离，那M职责是什么呢？问题的点就在这里了，我发现好多人的项目M都是空置的。当然，这里有一点是我们的业务很复杂、我们需要抽离出单独的分层。这是一点，还有一点就是，“我不知道M里面应该放什么”，我之前所熟知的三层，Model都是失血的，显然放在这里不合适。而业务“对象”的呢？我们是事务典型的事务脚本模式，显然放到这里也不合适。所以我认为这个M是多余的，我大多数做是需要Controller调用Biz(业务层)就可以了，至于MVC的M完全没有他的事情了。那我们回过头来看MVC,为何他要做MVC,而不是VC呢？这样不更是符合他做为View模式的身份吗？在我看来MVC出发点不是事务脚本模式的，而是领域模式或是Active Record的，M应该是自包含逻辑的。当然这里DDD太过于庞杂，放到这里显然也不是非常的合适，剩下的最适合的就是活动记录了，MVC配合活动记录模式用来做WEB应用，比如论坛博客再合适不过了。

本来的第3点，写到一半的时候我的思想乱了，完全失去了文章开头的中心思想，突然觉得越写越不知道自己写的是什么，但是又写这么多了。不发可惜了。

如果我看到这样一篇文章，我肯定回复就是：

1、不知楼主所云

2、标题党

3、 #&%）（%）（#）@#（￥&#@）￥

本文链接

AssionShop开源B2C电子商务系统-(二)定单流程活动图状态图

2010-11-01T09:35:00Z

B2C系统的灵魂所在就是定单的流程了，下面展示下定单的最重要的两个动态图，一个是定单流程活动图。还有一个是简单的定单状态图。通过这两张图，基本可以

了解系统定单流的大概情况了啊。图画的只是初步的设想，有些东西没有太细化。后期随着迭代的增加可能的变动会比较大，不过整体的流程不会发生大的变化了。

B2C订单流程大家可能以为很简单，但是不同的公司真是不同的流程，千变万化，想做好了也真是很不容易的，每个公司的各个部门职业配合都不尽相同。客服、

财务、物流、采构等职能相互配合共同完成一个B2C的业务系统，这是个比较复杂的业务系统，有人说运营才是电子商务的核心，那一套能提供良好运营的系统

应该是核心的根基了。话不多说了，下面上图，第一张是流程流动图，第二张是状态图。

我们就捡主要核心的部分画出动态图了，一个人精力有限。其它的各系统就不画图了。尽早的进入开发阶段。

下一篇：系统类图的设计(业务模型，系统模型）

本文链接

AssionShop开源B2C电子商务系统-(一)用例图

2010-10-26T07:12:00Z

这篇文章，将有实质的进展。先把大体的需求整理了一份用例图，自认为粒度做的已经很细了，再细就没法搞了。我还是坚信一个原则：自己业余搞的东西千万不要

想一口吃个胖子，这样很容易项目就搞流产了~，废话不多说上图。

1. 系统总用例图，分为web商城和erp系统用例图包。

2. web商城系统用例图包

3. web个人用户中心用例图

4. 商品浏览用例图

5. 商品购买用例图

6.erp系统用例图包

7. 用户管理用例图

8. 权限角色管理用例图

9. 商品管理用例图

10. 销售单管理用例图

11. 仓库管理用例图

12. 采购管理用例图

13. 财务管理用例图

14.物流管理用例图

15. 售后管理用例图(售后未细化）

16. 网站管理用例图

17. 报表管理用例图

结语：大体上暂时就这么多需求，也不用多说了大家都看的明白。下一章做一些动态图，序列图、活动图、状态图等还说明业务活动。

最后，为了方便大家查看，我提供个用例的html文档下载:AssionshopUseCaseModel。

本文链接

AssionShop开源B2C电子商务系统-概述

2010-10-22T02:15:00Z

今天是个特殊的日子，我在北京房租价格又上了一个新的台阶。在这个日子我准备开始建立一个开源项目，一个B2C行业的EC系统。

一、关于定位

我要做的不只是一个商城，应该说是一个能满足中小型企业建立电子商务的一套完善的系统。其中的一些模块包括（但不限于）如下：

1. 前台商城

1.1. 前台网站商品的展架模块，包括整个商品的推销策略，包括分类、检索、各类活动形式等。

1.2. 前台的购物流程，包括购物车、定单、支付等。共中的客户可能包括：一般零售客户、大客户、团购客户等。

1.3. 前台用户中心，包括个人信息及商业行为信息等的维护。

2. 后台ECERP系统

1.1. 对前台各展架信息等的维护模块，也就是网站管理模块。对应的操作角色：网站的运维人员

1.2. 商品管理模块，对商品的分类、商品等基元信息进行管理等。对应的操作角色：网站运维人员、采购人员等。

1.3. 活动管理模块，包括优惠券系统等。对应的操作角色为：网站运维人员

1.4. 采购模块，对商品的库存进行管理，一系统的缺断货控制等。对应操作的角色为：采购人员

1.4. 销售定单处理模块，对定单进行处理。对应的操作角色为：客户服务人员、财务人员、主管人员等概据不同角色进行处理。

1.4. 财务模块，财务人员进行销售的收款单处理，采购的付款单处理等。对应的操作角色为：财务人员

1.5. 售后模块，对售后进行管理，商品的退货换货等。对应的操作角色为：客服人员、售后工作人员、物流人员

1.6. 物流模块，对定单的出货、换货、退货等业务进行处理。对应的操作角色为：物流人员

1.7. 仓库管理模块，对仓库进行管理。对应的操作角色为系统管理人员

3. 其他

当然系统还需要权限的支撑。其他的还有很多东西通过增量的方式迭代出来吧。

二、关于开发模式

最好的开发模式就是无模式了，适合自己就好，不过也要有个基本的思路，本系统将采用2个DDD，第一个就是Domain driven design(领域区动设计),

第二个就是Domain driven development(领域区动开发），当然DDD只是个思想，我们不必拘泥于形，每个人都有每个人的想法，还是那句话：适合自

己就好。

这里说一下敏捷开发，我对这个概念理解不深。个人感觉真的没必要理解的“过于深”，个人感觉现在一般的小公司的开发模式“不正规，很敏捷”，由于

没有正规的开发方法论，一直是个迭代的过程。没有文档、口头交流、增量、迭代好像出现了不少这样的名词了。

三、关于架构

架构方面现在只是个初步想法，先贴出来大家参考下。

以上Solution图我一个一个的简要描述一下：

AssionShop.AdminWeb 这个是个WebForm项目，是我们前面提到的ECERP系统的UI层，做这样的信息系统WebForm还是有一定优势的，具体再定。

AssionShop.Caching 系统的缓存层，之所以把缓存独立出来，因为它在项目中的份量挺重要的，对对象的生命进行支持，可以抽象出支持多种缓存架构，

比如asp.net的进程缓存，基于key-value的分布式缓存产品等。

AssionShop.Common 系统的一些公共框架级模块，可能包括字符处理、AOP、IOC、ORM、Log等一系列支撑对象。

AssionShop.DBMap 数据库映射层，可以采用NHibernate框架来解决o-r的阴抗问题。为什么不直接在Repositories里？不为什么。

AssionShop.Domain 领域层，系统的核心业务逻辑对象，不依懒其它任务层，半充血模式。不自身完成持久化，持久化由仓储来负责。

AssionShop.Dto 数据传统对象，里面包括数据传统对象和相应的适配器，注：有可能DTO直接跨越UI和Repositories/DBMap 比如系统的报表等。

AssionShop.Repositories 仓储，负责Domain的工厂生产及生命周期控制，内部调用缓存和数据库完成领域对象的持久化。

AssionServices 这个Services应该是ApplicationService而非DomainService，它调用Domain与Repositories进行轻量的组装，为UI或是SOA提供API，

我把事务控制放在这层，采用MSDTC分布式事务，Services为事务边界我认为是比较合理的。

AssionShop.Web 前台商城WEB项目，初步计划采用asp.net mvc 这层同AdminWeb一样，调用Services以及对DTO对象的引用。

以上就是项目的初步设想与规划定位，有很多不足将通过一步步的深入进行处理。下一章将从需求的《用例模型》开始。

本文链接

Android+WebServer的GPS监控系统（设想）

2010-08-12T22:53:00Z

突然有个idea，建立一套系统。可以用来监控执有移动设备的人（设备有GPS功能）的当前位置。有点类似于电影里面监控“正义的坏人”的逃往位置一样。在

大屏幕的地图上用小红点显示被监控人的当前位置。由于车开的很快小红点的移动速度也很快（当然我们没有这么实时的，我们也不需要这么实时的监控，可以

设置个时间更新，比如半小时一更新就可以了）。

设想的平台基于Android(用它，而不是Windows mobile或是ios等，纯綷是为了争夺眼球。哈哈。因为Android在园子里很火嘛）。

首先是个网页系统，系统基于用户机制。用户也就是要监控的对象。数据字段定义如下：

ID 系统自增ID

UserGUID GUID字段，每注册一个帐号都生成一个新的全宇宙唯一的编码，我们就是通过这个编码与被监控手机进行匹配（别问我为何不用用户ID。很简单。别人容易猜得到）

UserName 被监控人姓名

PassWord 登录密码

以上是用户表，然后就是有个表用来记录被监控人的坐标位置，字段结构如下

ID 系统自增ID

UserID 被临控人ID

Coordinate 记录用户当前坐标，例如： 213,822 等（乱写的，对世界坐标体系还不太熟）

然后Server 端就可以利用Google Map Api 加上获得的坐标值在地图上定位。也就知道当前手机持久人的具体位置了。怎么样？很SY吧？

最后在说说Android 端。就是一个可以后台运行的程序，输入注册的Guid。然后利用手机的GPS系统获得当前的坐标。设个时间。定时把这个作标通信到Web Server端。具体采

用什么方式通信都可以（比如POST,WebServices,tcp等等)。

怎么样？这样理论上就可以实现一个监控服务提供系统了，很好的Idea吧？

本文链接

ASP.NET中在不同的子域中共享Session

2010-07-29T07:43:00Z

今天遇到了这个问题，于是研究了一下。要解决这个问题，首先就要明白一些Session的机理。Session在服务器是以散列表形式存在的，我们都知道Session是会话级的，每个用户访问都会生成一个Session。那么服务器是怎么区分不同用户的Session？又是怎么将不同用户的Session与不同的用户绑定的呢？下面我们来研究一下，以下纯属我个人的理解，如有错误请指证。

Session在服务器端是以散列表的形式存在的，区分每一个Session是通过SessionID来实现的，所以可以说这个SessionID是一个Key是一个全局唯一的值。我们可以通过ASP.NET来打印出SessionID，如下代码：

protected void Page_Load(object sender, EventArgs e)
        {
            Response.Write(Session.SessionID.ToString());
        }

这样我们就得到了这样的值：0julmoedn0kz3gyfnr1vksv0,有点像是GUID，就算不是算法也都是类似的，主要就是为了保证全局唯一性。这样就达到了区分不同用户的Session的目的。接下来还有第二个问题，那就是SessionID有了，但是它又是怎么和相应的访问者（用户）绑定的呢？比如说用户A访问维护了自己的SessionID,用户B访问也维护了自己的SessionID。我们都知道web是基于http无链接的，他们又是怎么做到的呢？没错，答案就是在客户端存储了自己的SessionID。浏览器存储SessionID有两种方式，一种就是利用Cookies;还有一种就是利用url参数(这种我们不常用,很不友好)。

话题说到Cookies上来了，怎么的？没想到Session和Cookies还有这样的关系吧？(很多人知道，别BS我)没错，当我们请求一个URL时候，服务器会生成一个全局的SessionID，并且把这个值以Cookies的形式保存在客户端也就是浏览器（这里暂不讨论url方式）。这样当用户再去请求的时候，在http头把这个SessionID的Cookie发到服务器端，服务器就去找这个SessionID，如果找到了。就证明这个用户的状态是存在的。

知道了这个原理，我们的问题也就有眉头了，即然是用Cookies来保存SessionID，那么我们就可以在Cooikes上做手脚了。我们都知道Cooikes记录方式是以域(例如：http://www.local.com/)为区分的，这也是各种浏览器规定的。如果不这么做，安全性就会有问题。我们要做的就是让指定Cookies的父域方式，不指定具体指域，这样Cookies就可以跨子域了。Cookies可以像这样指定域：

protected void Page_Load(object sender, EventArgs e)
        {
            Response.Cookies["MyCook"].Domain = ".local.com";
        }

这样，我们所有的二级域全部是认这一个主域的，比如a.local.com;b.local.com;user.local.com等等。有了这个认识，我想大家心里也有数了，该怎么怎么做，但是现在问题是用来生成SessionID的方法是ASP.NET自动实现的，我们又怎么去干涉它呢？这是这样做的，不主动干涉它，但是我可以操作它的Cookies啊。接下来我们就研究ASP.NET存SessionID的Cooike的名字是什么。经过网上很容易就查找到了，名字是：ASP.NET_SessionId，这个就是SessionId的Cookies名字。我们可以在Session_Start中这样写：

protected void Session_Start(object sender, EventArgs e)
        {
            Response.Cookies["ASP.NET_SessionId"].Value = Session.SessionID.ToString();
            Response.Cookies["ASP.NET_SessionId"].Domain = ".local.com";
        }

代码的意思是每次会话开始的时候，我都把ASP.NET_SessionId这个Cookie重写成我们已有的SessionID,并且把这个Cookie的domain指定为父域，比如:.local.com,这样就可以实现跨子域的Session共享了。怎么样很简单吧？

我们还有一个外题问题，就是客户端保存的问题解决了，但是服务器端的Session怎么办？一般情况下我们不同的子域做的是指向不同的服务器的，比如user.local.com 专门一台服务器，yellow.local.com专门一台服务器。这时它们别说是进程了，连物理上都不是一个了。Session怎么共享？这时就用到另一个方法了，我们默认的Session是存储在asp.net进程中的，这样没法互相访问，如下面所示：

我们可以修改为State Server方式，这是一个单独的服务可以用来存储ASP.NET Session的，它支持分布式远程主机的，这样我们可以用一台服务器来提供Session服务，如下所示：

这样，就完全实现了不同子域的Session共享了。

前面说到Url保存SessionId的方式，由于不常用，给大家演示一下，如下配置就可以了：

cookieless属性指定是否用cookie来保存SessionId,我们运行一下得到下面的样子：

http://localhost:3380/(S(dqxcs455n4u2vg55ia51fvqg))/default.aspx

本文链接

ASP.NET Mvc + NHibernate + Unity Application Block 示例程序

2010-07-16T15:27:00Z

今天无意间看到了Unity Application Block (以下简称Unity)，感觉很不错，用起来挺方便的说。于是一时兴起写了这个留言本的小示例。数据库操作采用的NHibernate，UI直接用的

ASP.NET Mvc了。项目基于VS2010 + SQLServer 2005 ，就一个表的增删改查操作很简单。目的是为了体验下Unity的Ioc功能。

国际惯例，先上个项目结构图

项目只是演示使用，未建立公共类和配置项抽象出来等工作，各个项目如下：

Guestbook.Biz 业务层，具体业务实现。这里只实现了增删改查

Guestbook.Dal 持久层，基于NHibernate的ORM映射。实现增删改查

Guestbook.IBiz 业务层接口，给UI引用实现解藕。UI层不直接引用具体业务类，实现面向接口

Guestbook.IDal 持久层接口，给Biz引用实现解藕。方便更换不同数据库持久类（PS；虽然NHibernate 已经可以支持多库,这里纯为了娱乐)

Guestbook.Model 持久实体，NHibernate的映射文件也放到这个类库里面了

Guestbook.Unity 简单封装了一下Unity，传入相应接口即可New相应的在Web.Config中配置的具体业务类

Guestbook.Web UI层，ASP.NET Mvc项目。控制器直接引用的业务接口IBiz和Model还有Unity其它全部不引用

采取从下往上依次说各层的东西。首先从数据库。。。。（略）---从持久层说起吧。持久层采用了NHibernate基本配置和映射配置就不说了（hkgoogle)，首先在Guestbook.Dal中写了一个NHibernateHelper帮助类，代码如下:

    /// <summary>
    /// NHibernate操作辅助类
    /// </summary>
    public class NHibernateHelper
    {
        private ISessionFactory _sessionFactory;
        public NHibernateHelper()
        {
            _sessionFactory = GetSessionFactory();
        }
        private ISessionFactory GetSessionFactory()
        {
            Configuration cfg = new Configuration();
            ISessionFactory sf =
                cfg.Configure().BuildSessionFactory();
            return sf;
        }
        public ISession GetSession()
        {
            ISession session = _sessionFactory.OpenSession();
            return session;
        }
    }

以上就是创建个NHibernate的Session。

接下来是在Guestbook.IDal定义持久层相关的接口，首先是一个通用的增删改查接口，如下：

    /// <summary>
    /// 数据执行类接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IDbObject<T>
    {
        void Save(T entity);
        void Delete(T entity);
        void Update(T entity);
        T Load(int sysNo);
        IList<T> GetList();
    }

定义基本的增删改查，是个泛型接口，这样实现它的类可以接收所有实本类，实现通用的方法。

接下来在Guestbook.Dal 定义一个 DbObject<T>基类，实现IDbObject<T>的增删改查方法，并做具体的实现，像下面这样：

/// <summary>
    /// 数据执行基础泛型类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class DbObject<T>:IDbObject<T> where T:class
    {
        private ISession _session;
        public DbObject()
        {
            NHibernateHelper nhbHelper = new NHibernateHelper();
            _session = nhbHelper.GetSession();
        }
        #region IDbObject<T> 成员

        public void Save(T entity)
        {
            _session.Save(entity);
            _session.Flush();
        }

        public void Delete(T entity)
        {
            _session.Delete(entity);
            _session.Flush();
        }

        public void Update(T entity)
        {
            _session.Update(entity);
            _session.Flush();
        }

        public T Load(int sysNo)
        {
            return _session.Load<T>(sysNo);
        }

        public IList<T> GetList()
        {
            return _session.CreateCriteria<T>().AddOrder(NHibernate.Criterion.Order.Asc("SysNo")).List<T>();
        }

        #endregion

比如 Save(T entity) 方法，实现具体的_session.Save(entity);_session.Flush();方法。通过NHibernate操作数据库。接下来就可以具体的持久业务类继承这个操作基类了。下面以Guestbook 为原型做相关讲解。为了数据层解藕，先建接口IGuestbookDal如下：

/// <summary>
    /// 留言本数据操作接口
    /// </summary>
    public interface IGuestbookDal
    {
        void Save(GuestbookInfo entity);
        void Delete(GuestbookInfo entity);
        void Update(GuestbookInfo entity);
        GuestbookInfo Load(int sysNo);
        IList<GuestbookInfo> GetList();
    }

然后在Guestbook.Dal中建一个具体持久类，这个类继承DbObject<GuestbookInfo>基类并实现IGuestbookDal接口，代码如下：

    /// <summary>
    /// 留言本数据处理类
    /// </summary>
    public class GuestbookDal:DbObject<GuestbookInfo>,IGuestbookDal
    {

    }

具体操作已经在泛型基类DbObject中实现了，所以这个类不用再实现什么操作即可。再加比如UserDal;ProductDal都可以直接继承不用实现就可以了。大大减少了很多工作量（之前园子里有觉得应该取消泛型，这么好的东西给我留着吧。阿们)。这样持久层基本就完成了。接下来说说业务类。

首先，一切为了解藕，一切为了面向接口。主阿，饶恕我吧。先在Guestbook.IBiz中定义个业务接口IGuestbookBiz吧：

  /// <summary>
    /// 留言本业务接口
    /// </summary>
    public interface IGuestbookBiz
    {
        void Save(GuestbookInfo entity);
        void Delete(GuestbookInfo entity);
        void Update(GuestbookInfo entity);
        GuestbookInfo Load(int sysNo);
        IList<GuestbookInfo> GetList();
    }

这没啥说的了，再说大家都烦了。再紧跟着在Guestbook.Biz中建一个业务类GuestbookBiz 实现以上接口：

/// <summary>
    /// 留言本业务类
    /// </summary>
    public class GuestbookBiz:IGuestbookBiz
    {
        private IGuestbookDal _guestbookDal = UnityHelper.UnityToT<IGuestbookDal>("DalType");

        #region IGuestbookBiz 成员
        public void Save(GuestbookInfo entity)
        {
            _guestbookDal.Save(entity);
        }

        public void Delete(GuestbookInfo entity)
        {
            _guestbookDal.Delete(entity);
        }

        public void Update(GuestbookInfo entity)
        {
            _guestbookDal.Update(entity);
        }

        public GuestbookInfo Load(int sysNo)
        {
            return _guestbookDal.Load(sysNo);
        }

        public IList<GuestbookInfo> GetList()
        {
            return _guestbookDal.GetList();
        }

        #endregion
    }

注意这句 private IGuestbookDal _guestbookDal = UnityHelper.UnityToT<IGuestbookDal>("DalType");，这里是业务层引用持久层，并不是直接New的，而是通过持久接口IGuestbookDal定义的，通过Unity加载进来的。这样就实现了相当成份的解藕了，不是由使用者去引用并实例被引用者，这个操作是由Ioc容器来做(这里是Unity)。这里用到了UnityHelper类了，它的写法如下（没有深入学习，只是基本操作)：

public static class UnityHelper
    {
        /// <summary>
        /// 通过Unity实组装对象泛型方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <returns></returns>
        public static T UnityToT<T>(string name)
        {
            IUnityContainer container = CreateContainer();
            T model = container.Resolve<T>(name);
            return model;
        }
        /// <summary>
        /// 通过Unity实组装对象泛型方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <returns></returns>
        public static T UnityToT<T>()
        {
            IUnityContainer container = CreateContainer();
            T model = container.Resolve<T>();
            return model;
        }
        /// <summary>
        /// 通过配置创建UnityContainer
        /// </summary>
        /// <returns></returns>
        public static IUnityContainer CreateContainer()
        {
            IUnityContainer container = new UnityContainer();
            UnityConfigurationSection section = (UnityConfigurationSection)
                System.Configuration.ConfigurationManager.GetSection("unity");
            section.Containers["Guestbook"].Configure(container);
            return container;
        }
    }

CreateContainer就是创建UnityContainer,它是Unity的核心所在。通过它就可以进行动态组装了。这里可以用代码创建也可以通过配置文件。我选择配置文件。因为直接写代码里面侵入太强了，失去了很多灵活装配的意义。配置我直接写在了Web.config里面，也可以单独写配置文件。我们在后面讲一下配置文件。UnityToT(string name)是我写的一个泛型方法，通过name查找相应的配置项去组装并反回接口的对象，T是我们的接口。使用就如上面：private IGuestbookDal _guestbookDal = UnityHelper.UnityToT<IGuestbookDal>("DalType");，<IGuestbookDal>就是接口，我们在配置里面有指定。"DalType"就是配置的名称。下面我们看一下相关的配置项：

type节就是我们的对应配置项，name是我们前面泛型方法要传入的name,type为接口,mapTo为具体的业务类。比如上面的IGuestbookDal持久层接口对应的相应的GuestbookDal持久类，这样配置后Unity就会帮我们根据接口装配(实例化)实现类，并反回相应的实例对象，我们就可以通过这个对象实现具体业务了，比如：_dao.Save(entity);。

这样我们的业务层也完成了，接下来就是UI层调用业务层就可以了。UI层我们一样通过Unity进行装配，UI层只引用实体类Guestbook.Model和Guestbook.IBiz业务层接口(当然用Unity要引用相应的UnityHelper类了)。这样UI层对业务层向下层次全部是弱依赖。UI我们基于的ASP.NET Mvc，所以我们在Controllers的里面进行业务层的装配并使用。我们以GuestbookInfo的列表显示为例，说一下。相应的Action叫说GuestbookList，代码如下：

private static IGuestbookBiz _biz = UnityHelper.UnityToT<IGuestbookBiz>("BizType");
        public ActionResult GuestbookList()
        {
            IList<GuestbookInfo> guestbookList = _biz.GetList();
            return View(guestbookList);
        }

private static IGuestbookBiz _biz = UnityHelper.UnityToT<IGuestbookBiz>("BizType");就是业务层装配了，我们通过业务接口IGuestbookBiz进行引用。通过_biz.GetList()就取得了相应的IList<GuestbookInfo>了。最后在相对应的View里面，指定Page Model ，像这样：Inherits="System.Web.Mvc.ViewPage<IList<Guestbook.Model.GuestbookInfo>>";然后在View中循环显示一下集合数据就可以了，大概像下面这样：

<%foreach(var item in Model){ %>
      <table width="500" border="0" cellpadding="0" cellspacing="0">
      <tr>
      <th>姓名</th>
      <th style="background-color:White"><%=item.GuestName %></th>
      <th>性别</th>
      <th style="background-color:White"><%=item.Sex==1?"男":"女" %></th>
      </tr>
      <tr>
      <td colspan="4" height="50" valign="top">
      <%=item.GuestMessage %>
      </td>
      </tr>
      <tr>
      <td colspan="4"><%=Html.ActionLink("删除","Delete",new{sysno=item.SysNo}) %></td>
      </tr>
      </table>
    <%} %>

最后放一张运行的图片，其它的Save,Delete方式其本相同，这里就不多讲了。大家可以在这里下载源码(已上传)。

本文链接