微服务实战(七)：落地微服务架构到直销系统(实现命令与命令处理器)

 public class CreateOrderCommand:BaseEvent
    {
        public OrderDTO orderdto { get; set; }
        public CreateOrderCommand() { }
        public CreateOrderCommand(OrderDTO orderdto)
        {
            this.orderdto = orderdto;
            this.AggregationRootId = Guid.NewGuid();
            this.AssemblyQualifiedAggreateRooType = typeof(Orders).AssemblyQualifiedName;
            this.AssemblyQualifiedCommandAndEventType = this.GetType().AssemblyQualifiedName;
        }
    }

[Produces("application/json")]
    [Route("api/Order")]
    public class OrderController : Controller
    {
        private readonly IEventBus commandbus;
        public OrderController(IEventBus commandbus)
        {
            this.commandbus = commandbus;
        }
        [HttpPost]
        [Route("CreateOrderCmd")]
        public ResultEntity<bool> CreateOrderCmd([FromBody] OrderDTO orderdto)
        {
            var result = new ResultEntity<bool>();
            try
            {
                var createordercommand = new CreateOrderCommand(orderdto);
                //发布命令到命令总线
                commandbus.Publish(createordercommand);
                result.IsSuccess = true;
                result.Msg = "下单处理中!";
            }
            catch(Exception error)
            {
                result.ErrorCode = 200;
                result.Msg = error.Message;
            }
            return result;
        }
    }

public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
            //定义要发布命令的命令总线
            services.AddSingleton<IEventHandlerExecutionContext>(new EventHandlerExecutionContext(services));
            var connectionFactory = new ConnectionFactory { HostName = "localhost" };
            services.AddSingleton<IEventBus>(sp => new RabbitMqEB(connectionFactory,
                sp.GetRequiredService<IEventHandlerExecutionContext>(), "exchange1", "direct", "ordercreatecommandqueue", 1));
        }

            //侦听订单创建命令队列里的消息
            services.AddSingleton<IEventHandlerExecutionContext>(new EventHandlerExecutionContext(services));
            var connectionFactory = new ConnectionFactory { HostName = "localhost" };
            services.AddSingleton<IEventBus>(sp => new RabbitMqEB(connectionFactory,
                sp.GetRequiredService<IEventHandlerExecutionContext>(), "exchange1", "direct", "ordercreatecommandqueue", 2));

            //订阅创建订单命令
            var commandbuss = app.ApplicationServices.GetServices<IEventBus>();
            var commandbus = commandbuss.ToList()[0];
            commandbus.Subscribe<CreateOrderCommand, OrderCreateCommandHandler>();

public class OrderCreateCommandHandler : IEventHandler
    {
        private readonly IServiceProvider iserviceprovider;
        public OrderCreateCommandHandler()
        {
            var iwebhost = FindIWebHost.GetWwebHost("OrderCommandHandler.WebApi");
            iserviceprovider = iwebhost.Services;

        }
        public Task<bool> HandleAsync<TEvent>(TEvent @event) where TEvent : IEvent
        {
            var orderdtocommand = @event as CreateOrderCommand;
            var orderdto = orderdtocommand.orderdto;
            var orderid = orderdtocommand.AggregationRootId;
            Orders order = new Orders();
            var productskus = new List<ProductSKU>();
            for (int i = 0; i < orderdto.ProductSPUNames.Count; i++)
            {
                var productsku = new ProductSKU();
                productsku.ProductSPUName = orderdto.ProductSPUNames[i];
                productsku.DealerPrice = orderdto.ProductDealerPrices[i];
                productsku.PV = orderdto.ProductPVS[i];
                productsku.Id = orderdto.ProductSKUIds[i];
                productsku.Spec = orderdto.ProductSepcs[i];
                productskus.Add(productsku);
            }
            var contact = new Contact();
            contact.ContactName = orderdto.ContactName;
            contact.ContactTel = orderdto.ContactTel;
            contact.Province = orderdto.Privence;
            contact.City = orderdto.City;
            contact.Zero = orderdto.Zero;
            contact.Street = orderdto.Street;
            //完成业务逻辑
            var orders = order.CreateOrders(orderid, orderdto.DealerId, productskus, orderdto.Counts,
                contact);

            var ordercreateevent = new OrderCreateEvent();
            ordercreateevent.AggregationRootId = orders.Id;
            ordercreateevent.AssemblyQualifiedAggreateRooType = orderdtocommand.AssemblyQualifiedAggreateRooType;
            ordercreateevent.AssemblyQualifiedCommandAndEventType = orderdtocommand.AssemblyQualifiedCommandAndEventType;
            ordercreateevent.CreateDate = orders.OrderDateTime;
            ordercreateevent.Id = orders.Id;
            ordercreateevent.OrderDateTime = orders.OrderDateTime;
            ordercreateevent.OrderDealerId = orders.OrderDealerId;
            ordercreateevent.OrderItems = orders.OrderItems;
            ordercreateevent.OrderStreet = orders.OrderStreet;
            ordercreateevent.OrderTotalPrice = orders.OrderTotalPrice;
            ordercreateevent.OrderTotalPV = orders.OrderTotalPV;
            ordercreateevent.Code = orders.Code;
            ordercreateevent.Telephone = orders.Telephone;
            ordercreateevent.Version = 0;
            //对创建订单事件持久化事件存储
            try
            {
                new DomainAndEventStorage().SaveEvent(ordercreateevent);
                var eventbuss = iserviceprovider.GetServices(typeof(IEventBus))
                    as IEnumerable<IEventBus>;
                var eventbusls = eventbuss.ToList();
                var eventbus = eventbusls[1];
                //发布到事件队列，用于未来持久化到业务库中
                eventbus.Publish(ordercreateevent);
            }
            catch(Exception error)
            {
                throw error;
            }
            return Task.FromResult(true);
        }
    }