一、前言

这篇文章本来是继续分享IdentityServer4 的相关文章，由于之前有博友问我关于微服务相关的问题，我就先跳过IdentityServer4的分享，进行微服务相关的技术学习和分享。微服务在我的分享目录里面是放到四月份开始系列文章分享的，这里就先穿越下，提前安排微服务应用的开篇文章 电商系统升级之微服务架构的应用。

本博客以及公众号坚持以架构的思维来分享技术，不仅仅是单纯的分享怎么使用的Demo。

二、场景

先来回顾下我上篇文章 Asp.Net Core 中IdentityServer4 授权中心之应用实战 中，电商架构由单体式架构拆分升级到多网关架构

升级之前

升级之后:

然而升级之后问题又来了，由于之前增加了代理商业务并且把授权中心和支付网关单独拆出来了，这使得公司的业务订单量翻了几十倍，这个时候整个电商系统达到了瓶颈，如果再不找解决方案系统又得宕机了。

2.1 问题及解决方案

经过技术的调研及问题分析，导致这个瓶颈的问题主要有以下几个原因，只需要把下面问题解决就可以得到很大的性能提升

  • 每天的订单量暴增，导致订单数据太大，然而整个电商系统数据存储在一个数据库中，并且是单表、单数据库（未进行读写分离），以致于订单数据持续暴增。
  • 相关业务需要依赖订单查询，订单数据查询慢以至于拖垮数据库
  • 整个电商系统连接数达到瓶颈（已经分布式部署，在多加服务器会损耗更多的经费而达不到最佳性价比）

为了一劳永逸的解决以上问题，经过技术的调研，决定对订单业务做如下升级改造：

  • 拆分独立的订单微服务（本章节着重分享）
  • 使用ES进行数据迁移（按年进行划分，并且进行读写分离，这里就不着重讲，下次来跟大家一起学习和分享）
  • 增加分布式缓存 （也不是本次的重点，后续再来跟大家学习和分享）

经过升级后的架构图如下：

架构图说明：

  • 右边同一颜色的代表还是原先电商系统的单体式架构，为拆分的单体架构业务，其中在业务处理上夹杂了一层分布式缓存的处理
  • 左边的是微服务的架构，是这次升级拆分后的架构，其中数据库也已经从原有的数据库拆分并且数据迁移到了ES集群中，并进行了读写分离。
  • 订单服务可以随意扩容成分布式服务，通过一些工具动态扩展服务及服务器的支持。
  • 右边的业务后续也可以进行拆分，拆分成不同的业务服务。
  • 后续升级还可以考虑消息队列等相关方面,架构图中未构思（后续再来分享升级用到的相关技术，这里还是回归到本文的核心微服务）

三、微服务概述

微服务的相关概念我就不多说了，以下就先简单概况下微服务带来的利和弊。

3.1 微服务的优势

  • 使大型的复杂应用程序可以持续交付和持续部署：持续交付和持续部署是DevOps的一部分，DevOps是一套快速、频繁、可靠的软件交付实践。高效的DevOps组织通常将软件部署到生产环境时面临更少的问题和故障。DevOps工具有Docker、Kubernets、Jenkins、Git等。
  • 每个服务相对较小并容易维护：微服务架构相比单体应用要小的多，开发者理解服务中的逻辑代码更容易。代码库小，打包，启动服务速度也快。
  • 服务可以独立部署：每个服务都可以独立于其他服务进行部署
  • 服务可以独立扩展：服务可以独立扩展，不论是采用X轴扩展的实例克隆，还是Z轴的流量分区方式。此外每个服务都可以部署到适合它们需求的硬件之上
  • 微服务架构可以实现团队的自治：可以根据服务来把开发团队拆分。每个团队都有自己负责的微服务，而不用关心不属于他们负责的服务。
  • 更容易实验和采纳新的技术：最后，微服务可以消除对某个技术栈的长期依赖。因为服务更小，使用更换的编程语言和技术来重写一项服务变得有可能，这也意味着，对一项新技术尝试失败后，可以直接丢弃这部分工作而不至于给整个应用带来失败的风险。
  • 更好的容错性：微服务架构也可以实现更换的故障隔离。例如，某个服务引发的致命错误，不会影响其他服务。其他服务仍然正常运行。
  • 服务可以独立扩容：对于整个架构来说，可以随意选择相关业务进行扩容和负载，通过相关技术工具动态进行随意扩容

3.2 微服务的劣势

  • 服务拆分和定义是一项挑战：采用微服务架构首当其冲的问题，就是根本没有一个具体的、良好定义的算法可以完成服务的拆分工作。与软件开发一样，服务的拆分和定义更像一门艺术。更糟糕的是，如果对系统的服务拆分出现了偏差，很有可能会构建出一个分布式的单体应用；一个包含了一大堆互相之间紧耦合的服务，却又必须部署在一起的所谓分布式系统。这将会把单体架构和微服务架构两者的弊端集于一身。
  • 分布式系统带来的各种复杂性、使开发、测试和部署变得更困难：使用微服务架构的另一个问题是开发人员必须处理创建分布式系统的额外复杂性。服务必须是进程间通信。这比简单的方法调用要复杂的多。
  • 当部署跨越多个服务的功能时需要谨慎地协调更多的开发团队：使用微服务架构的另外一项挑战在于当部署跨越多个服务的功能时需要谨慎地协调更多开发团队。必须制定一个发布计划，把服务按照依赖关系进行排序。这跟单体架构下部署多个组件的方式截然不同。
  • 开发者需要思考到底应该在应用的什么阶段使用微服务架构：使用微服务架构的另一个问题是决定在应用程序生命周期的哪个阶段开始使用这种架构。
  • 跨服务数据的问题：在单体应用中，所有的数据都在一个数据库中，而在微服务架构中，每个服务都有自己的数据库，想要获取，操作其他服务的数据，只能通过该服务提供API进行调用，这样就带来一个问题，进程通信的问题，如果涉及到事务，那么还需要使用Saga来管理事务，增加了开发的难度。

3.3 微服务拆分原则

说到单体架构拆分，那也不是随意拆分，是要有一定的原则，拆分的好是优势，拆分的不好是混乱。以下是我查阅资料以及我的经验总结出来的拆分原则

  • 1、单一职责、高内聚低耦合
  • 2、微服务粒度适中
  • 3、考虑团队结构
  • 4、以业务模型切入
  • 5、演进式拆分
  • 6、避免环形依赖与双向依赖
  • 7、DDD（可以考虑使用领域驱动设计去进行底层服务的设计,后续会单独分析该设计的相关文章）

四、微服务实战

好了，到这里大家已经对微服务有了一定的理解，就不继续详细概述相关理念的东西，下面来直接撸代码，让大家熟悉微服务的应用。这里我使用 莫堇蕈 在github 上开源的微服务框架，框架源代码地址 ：https://github.com/overtly/core-grpc （我这里强烈推荐该框架，目前已经比较成熟的用于公司生产环境）

为了更好的维护开源项目以及技术交流，特意创建了一个交流群，群号：1083147206 有兴趣者开源加入交流

4.1 core-grpc 微服务框架的优势：

  • 集成Consul 实现服务发现和注册以及健康检查等机制
  • 实时监听服务状态
  • 多节点 轮询机制
  • 故障转移，拉入黑名单
  • 支持.Net Core 和Framework 两种框架
  • 实现基于Grpc的微服务
  • 部署支持环境变量

4.2 实战

创建Jlion.NetCore.OrderService 订单微服务

我们用vs2019 创建控制台应用程序 选择框架.Net Core 3.1 命名为Jlion.NetCore.OrderService 后面简称订单服务，创建完后我们通过nuget包引入 core-grpc微服务框架，如下图：



目前core-grpc微服务框架，最新正式发布版本是 1.0.3

引用了core-grpc 后我们还需要安装一个工具VS RPC Menu，这个工具也是大神免费提供的，图片如下：

由于微软官方下载比较慢，我这里共享到 百度网盘，百度网盘下载地址如下：

链接: https://pan.baidu.com/s/1twpmA4_aErrsg-m0ICmOPw 提取码: cshs

如果通过下载后安装不是vs 集成安装方式，下载完成后需要关闭vs 2019相关才能正常安装。

VS RPC Menu 工具说明如下：

OrderRequest.proto代码如下：

  1. syntax = "proto3";
  2. package Jlion.NetCore.OrderService.Service.Grpc;
  4. //定义订单查找参数实体
  5. message OrderSearchRequest{
  6.     string OrderId = 1; //定义订单ID
  7.     string Name = 2;
  8. }
  10. //定义订单实体
  11. message OrderRepsonse{
  12.     string OrderId = 1;
  13.     string Name = 2;
  14.     double Amount = 3;
  15.     int32 Count = 4;
  16.     string Time = 5;
  17. }
  19. //定义订单查找列表
  20. message OrderSearchResponse{
  21.     bool Success = 1;
  22.     string ErrorMsg = 2;
  23.     repeated OrderRepsonse Data = 3;
  24. }

上面主要是定义了几个消息实体，

我们再创建JlionOrderService.proto，代码如下：

  1. syntax = "proto3";
  2. package Jlion.NetCore.OrderService.Service.Grpc;
  4. import "OrderRequest.proto";
  6. service JlionOrderService{
  7.     rpc Order_Search(OrderSearchRequest) returns (OrderSearchResponse){}
  8. }

上面的代码中都可以看到最上面有 package Jlion.NetCore.OrderService.Service.Grpc 代码，这是声明包名也就是后面生成代码后的命名空间，这个很重要。

同时定义了JlionOrderService服务入口，并且定义了一个订单搜索的方法Order_Search，到这里我们已经完成了一小部分了。

生成客户端代码

再在JlionOrderService.proto文件里面右键 》选择Grpc代码生成》Grpc 代码 会自动生存微服务客户端代码 。

生存工具中具有如下功能：

  • 生存Grpc客户端代码
  • Grpc 编译（不常用）
  • Grpc 打包（常用，用来把客户端dll发布到nuget服务器上）
  • 还可以对Thrift 代码进行生成和打包

创建Jlion.NetCore.OrderService.Grpc 类库

把刚刚通过工具生成的Grpc客户端代码直接copy到 Jlion.NetCore.OrderService.Grpc这个类库中（必须和上面Grpc 的代码声明的package 一致）以下简称订单服务客户端，并且需要通过Nuget包添加Overt.Core.Grpc 的依赖，代码结构如下：



Jlion.NetCore.OrderService.Grpc类库已经构建完成，现在让 Jlion.NetCore.OrderService 服务引用Jlion.NetCore.OrderService.Grpc 类库

订单服务中 实现自己的IHostedService

创建HostService类，继承IHostedService代码如下：

  1. public class HostedService : IHostedService
  2. {
  3.     readonly ILogger _logger;
  4.     readonly JlionOrderServiceBase _grpcServImpl;
  5.     public HostedService(
  6.         ILogger<HostedService> logger,
  7.         JlionOrderServiceBase grpcService)
  8.     {
  9.         _logger = logger;
  10.         _grpcServImpl = grpcService;
  11.     }
  13.     //服务的启动机相关配置
  14.     public Task StartAsync(CancellationToken cancellationToken)
  15.     {
  16.         return Task.Factory.StartNew(() =>
  17.         {
  18.             var channelOptions = new List<ChannelOption>()
  19.             {
  20.                  new ChannelOption(ChannelOptions.MaxReceiveMessageLength, int.MaxValue),
  21.                  new ChannelOption(ChannelOptions.MaxSendMessageLength, int.MaxValue),
  22.             };
  23.             GrpcServiceManager.Start(BindService(_grpcServImpl), channelOptions: channelOptions, whenException: (ex) =>
  24.             {
  25.                 _logger.LogError(ex, $"{typeof(HostedService).Namespace.Replace(".", "")}开启失败");
  26.                 throw ex;
  27.             });
  28.             System.Console.WriteLine("服务已经启动");
  29.             _logger.LogInformation($"{nameof(Jlion.NetCore.OrderService.Service).Replace(".", "")}开启成功");
  30.         }, cancellationToken);
  31.     }
  33.     //服务的停止
  34.     public Task StopAsync(CancellationToken cancellationToken)
  35.     {
  36.         return Task.Factory.StartNew(() =>
  37.         {
  38.             GrpcServiceManager.Stop();
  40.             _logger.LogInformation($"{typeof(HostedService).Namespace.Replace(".", "")}停止成功");
  41.         }, cancellationToken);
  42.     }
  43.  }

上面代码主要是创建宿主机并且实现了StartAsync 服务启动及StopAsync 服务停止方法。

我们创建完HostedServicce代码再来创建之前定义的Grpc服务的方法实现类JlionOrderServiceImpl，代码如下：

  1. public partial class JlionOrderServiceImpl : JlionOrderServiceBase
  2. {
  3.     private readonly ILogger _logger;
  4.     private readonly IServiceProvider _serviceProvider;
  6.     public JlionOrderServiceImpl(ILogger<JlionOrderServiceImpl> logger, IServiceProvider provider)
  7.     {
  8.         _logger = logger;
  9.         _serviceProvider = provider;
  10.     }
  12.     public override async Task<OrderSearchResponse> Order_Search(OrderSearchRequest request, ServerCallContext context)
  13.     {
  14.         //TODO 从底层ES中查找订单数据，
  15.         //可以设计成DDD 方式来进行ES的操作，这里我就为了演示直接硬编码了
  17.         var response = new OrderSearchResponse();
  18.         try
  19.         {
  20.             response.Data.Add(new OrderRepsonse()
  21.             {
  22.                 Amount = 100.00,
  23.                 Count = 10,
  24.                 Name = "订单名称测试",
  25.                 OrderId = DateTime.Now.ToString("yyyyMMddHHmmss"),
  26.                 Time = DateTime.Now.ToString()
  27.             });
  29.             response.Data.Add(new OrderRepsonse()
  30.             {
  31.                 Amount = 200.00,
  32.                 Count = 10,
  33.                 Name = "订单名称测试2",
  34.                 OrderId = DateTime.Now.ToString("yyyyMMddHHmmss"),
  35.                 Time = DateTime.Now.ToString()
  36.             });
  38.             response.Data.Add(new OrderRepsonse()
  39.             {
  40.                 Amount = 300.00,
  41.                 Count = 10,
  42.                 Name = "订单名称测试2",
  43.                 OrderId = DateTime.Now.ToString("yyyyMMddHHmmss"),
  44.                 Time = DateTime.Now.ToString()
  45.             });
  46.             response.Success = true;
  47.         }
  48.         catch (Exception ex)
  49.         {
  50.             response.ErrorMsg = ex.Message;
  51.             _logger.LogWarning("异常");
  52.         }
  53.         return response;
  54.     }
  55.  }

再修改Program代码，并把HostedService和JlionOrderServiceImpl 注入到容器中，代码如下：

  1.  class Program
  2.  {
  3.     static void Main(string[] args)
  4.     {
  5.         var host = new HostBuilder()
  6.            .UseConsoleLifetime() //使用控制台生命周期
  7.            .ConfigureAppConfiguration((context, configuration) =>
  8.            {
  9.                configuration
  10.                .AddJsonFile("appsettings.json", optional: true)
  11.                .AddEnvironmentVariables();
  12.            })
  13.            .ConfigureLogging(logger =>
  14.            {
  15.                logger.AddFilter("Microsoft", LogLevel.Critical)
  16.                      .AddFilter("System", LogLevel.Critical);
  17.            })
  18.            .ConfigureServices(ConfigureServices)
  19.            .Build();
  21.         AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
  22.         {
  23.             var logFactory = host.Services.GetService<ILoggerFactory>();
  24.             var logger = logFactory.CreateLogger<Program>();
  25.             logger.LogError(e.ExceptionObject as Exception, $"UnhandledException");
  26.         };
  28.         host.Run();
  29.     }
  31.     /// <summary>
  32.     /// 通用DI注入
  33.     /// </summary>
  34.     /// <param name="context"></param>
  35.     /// <param name="services"></param>
  36.     private static void ConfigureServices(HostBuilderContext context, IServiceCollection services)
  37.     {
  38.         //HostedService 单例注入到DI 中
  39.         services.AddSingleton<IHostedService, HostedService>();
  40.         services.AddTransient<JlionOrderServiceBase, JlionOrderServiceImpl>();
  41.     }
  42.  }

到了这里简单的微服务已经编码完成，但是还缺少两个配置文件，我们创建appsettings.json配置文件和consulsettings.json 服务注册发现的配置文件

consulsettings.json配置文件如下：

  1. {
  2.   "ConsulServer": {
  3.     "Service": {
  4.       "Address": "127.0.0.1：8500"// 你的Consul 服务注册及发现配置地址
  5.     }
  6.   }
  7. }

上面的地址配置只是简单的例子，我这里假定我的Consul服务地址是 127.0.0.1：8500 等下服务启动是会通过这个地址进行注册。

appsettings.json配置文件如下：

  1. {
  2.   "GrpcServer": {
  3.     "Service": {
  4.       "Name": "JlionOrderService",
  5.       "Port": 10001,
  6.       "HostEnv": "serviceaddress",
  7.       "Consul": {
  8.         "Path": "dllconfigs/consulsettings.json"
  9.       }
  10.     }
  11.   }
  12. }

我这里服务监听了10001 端口，后面注册到Consul中也会看到该端口

官方完整的配置文件如下：

  1. {
  2.   "GrpcServer": {
  3.     "Service": {
  4.       "Name": "OvertGrpcServiceApp",                    // 服务名称使用服务名称去除点：OvertGrpcServiceApp
  5.       "Host": "service.g.lan",                          // 专用注册的域名 （可选）格式：ip[:port=default]
  6.       "HostEnv": "serviceaddress",                      // 获取注册地址的环境变量名字（可选，优先）环境变量值格式：ip[:port=default]
  7.       "Port": 10001,                                    // 端口自定义
  8.       "Consul": {
  9.         "Path": "dllconfigs/consulsettings.json"        // Consul路径
  10.       }
  11.     }
  12.   }
  13. }

好了，订单服务已经全部完成了，订单服务服务整体结构图如下：

好了，我们这里通过命令行启动下JlionOrderService服务，生产环境你们可以搭建在Docker 容器里面

我们可以来看下我之前搭建好的Consul服务 ，打开管理界面，如图：



图片中可以发现刚刚启动的服务已经注册进去了，但是里面有一个健康检查未通过，主要是由于服务端不能访问我本地的订单服务，所有健康检查不能通过。你可以在你本地搭建 Consul服务用于测试。

我本地再来开启一个服务，配置中的的端口号由10001 改成10002，再查看下Consul的管理界面，如下图:



发现已经注册了两个服务，端口号分别是10001 和10002，这样可以通过自定化工具自动添加服务及下架服务，分布式服务也即完成。

到这里订单服务的启动已经完全成功了，我们接下来是需要客户端也就是上面架构图中的电商业务网关或者支付网关等等要跟订单服务进行通讯了。

创建订单网关（跟订单服务进行通信）

创建订单网关之前我先把上面的 订单服务客户端 类库发布到我的nuget包上，这里就不演示了。我发布的测试包名称JlionOrderServiceDemo nuget官方可以搜索找到。你们也可以直接搜索添加到你们的Demo中进行测试。

我通过VS 2019 创建Asp.Net Core 3.1 框架的WebApi 取名为Jlion.NetCore.OrderApiService 下面简称订单网关服务

现在我把前面发布的微服务客户端依赖包 JlionOrderServiceDemo 添加到订单网关服务中，如下图：

现在在订单网关服务中添加OrderController api控制器，代码如下：

  1. namespace Jlion.NetCore.OrderApiService.Controllers
  2. {
  3.     [Route("[controller]")]
  4.     [ApiController]
  5.     public class OrderController : ControllerBase
  6.     {
  7.         private readonly IGrpcClient<OrderService.Service.Grpc.JlionOrderService.JlionOrderServiceClient> _orderService;
  8.         public OrderController (IGrpcClient<OrderService.Service.Grpc.JlionOrderService.JlionOrderServiceClient> orderService)
  9.         {
  10.             _orderService = orderService;
  11.         }
  13.         [HttpGet("getlist")]
  14.         public async Task<List<OrderRepsonse>> GetList()
  15.         {
  16.             var respData =await _orderService.Client.Order_SearchAsync(new OrderService.Service.Grpc.OrderSearchRequest()
  17.             {
  18.                 Name = "test",
  19.                 OrderId = "",
  20.             });
  22.             if ((respData?.Data?.Count ?? 0) <= 0)
  23.             {
  24.                 return new List<OrderRepsonse>();
  25.             }
  27.             return respData.Data.ToList();
  28.         }
  29.     }
  30. }

代码中通过构造函数注入 OrderService 并且提供了一个GetList的接口方法。接下来我们还需要把OrderService.Service.Grpc.JlionOrderService注入到容器中，代码如下：

  1. public void ConfigureServices(IServiceCollection services)
  2. {
  3.      services.AddControllers();
  5.      //注册Grpc 客户端，具体可以查看源代码
  6.      services.AddGrpcClient();
  7. }

现在整个订单网关服务项目结构如下图：

项目中有两个最重要的配置dllconfig//Jlion.NetCore.OrderService.Grpc.dll.json 和consulsettings.json 他们分别是干什么的呢？我们先分别来看我本地这两个配置的内容

Jlion.NetCore.OrderService.Grpc.dll.json 配置如下：

  1. {
  2.    "GrpcClient": {
  3.        "Service": {
  4. 		"Name": "JlionOrderService",  // 服务名称与服务端保持一致
  5. 		"MaxRetry": 0,                // 最大可重试次数，默认不重试
  6. 		"Discovery": {
  7. 		    "Consul": {              // Consul集群,集群优先原则
  8. 		        "Path": "dllconfigs/consulsettings.json"
  9. 		    }，
  10. 		    "EndPoints": [           // 单点模式
  11. 	        	{
  12. 		        	"Host": "127.0.0.1",
  13. 			        "Port": 10001
  14. 		     }]
  15. 	        }
  16.         }
  17.     }
  18. }

Jlion.NetCore.OrderService.Grpc.dll.json 配置主要是告诉订单网关服务和订单服务应该怎样进行通信，以及通信当中的一些参数配置。我为了测试，本地使用单点模式，不使用Consul模式

consulsettings.json 配置如下：

  1. {
  2.   "ConsulServer": {
  3.     "Service": {
  4.       "Address": "127.0.0.1:8500"
  5.     }
  6.   }
  7. }

有没有发现这个配置和之前服务端的配置一样，主要是告诉订单网关服务（客户端调用者）和订单服务服务端服务发现的集群地址，如果上面的配置是单点模式则这个配置不会起作用。

到这里订单网关服务 （客户调用端）编码完成，我们开始启动它：



我这里固定5003端口，现在完美的启动了，我们访问下订单接口，看下是否成功。访问结果如下图：

微服务完美的运行成功。

上面的构建微服务还是比较麻烦，官方提供了比较快速构建你需要的微服务方式，不需要写上面的那些代码，那些代码全部通过模板的方式进行构建你的微服务，有需要学习的可以到点击

微服务项目构建模板使用教程

教程地址：https://www.cnblogs.com/jlion/p/12494525.html

文章中的Demo 代码已经提交到github 上，代码地址：https://github.com/a312586670/NetCoreDemo

微服务框架开源项目地址：https://github.com/overtly/core-grpc

【.net core】电商平台升级之微服务架构应用实战的更多相关文章

  1. Java生鲜电商平台-秒杀系统微服务架构设计与源码解析实战

    Java生鲜电商平台-秒杀系统微服务架构设计与源码解析实战 Java生鲜电商平台-  什么是秒杀 通俗一点讲就是网络商家为促销等目的组织的网上限时抢购活动 比如说京东秒杀,就是一种定时定量秒杀,在规定 ...

  2. Java生鲜电商平台-如何使用微服务来架构生鲜电商B2B2C平台？

    Java生鲜电商平台-如何使用微服务来架构生鲜电商B2B2C平台? 说明:随着互联网的日益普及,人们通过手机下单买菜的人越来越多,生鲜这个行业有两个显著的特点,一个是刚需.(你每天都要吃饭,都要吃菜) ...

  3. Java生鲜电商平台-深入理解微服务SpringCloud各个组件的关联与架构

    Java生鲜电商平台-深入理解微服务SpringCloud各个组件的关联与架构 概述 毫无疑问,Spring Cloud是目前微服务架构领域的翘楚,无数的书籍博客都在讲解这个技术.不过大多数讲解还停留 ...

  4. Java生鲜电商平台-高可用微服务系统如何设计？

    Java生鲜电商平台-高可用微服务系统如何设计? 说明:Java生鲜电商平台高可用架构往往有以下的要求: 高可用.这类的系统往往需要保持一定的 SLA,7*24 时不间断运行不代表完全不挂,而是有一定 ...

  5. Java生鲜电商平台-深入订单拆单架构与实战

    Java生鲜电商平台-深入订单拆单架构与实战 Java生鲜电商中在做拆单的需求,细思极恐,思考越深入,就会发现里面涉及的东西越来越多,要想做好订单拆单的功能,还是相当有难度, 因此总结了一下拆单功能细 ...

  6. Java生鲜电商平台-Spring Cloud微服务架构图

  7. Java生鲜电商平台-服务化后的互联网架构实战(针对生鲜电商小程序或者APP)

    Java生鲜电商平台-服务化后的互联网架构实战(针对生鲜电商小程序或者APP) “微服务架构”的话题非常之火,很多朋友都在小窗我,说怎么做服务化?解答“怎么做”之前,先得了解“为什么做”. 画外音:做 ...

  8. Java生鲜电商平台-Java后端生成Token架构与设计详解

    Java生鲜电商平台-Java后端生成Token架构与设计详解 目的:Java开源生鲜电商平台-Java后端生成Token目的是为了用于校验客户端,防止重复提交. 技术选型:用开源的JWT架构. 1. ...

  9. Java开源生鲜电商平台-监控模块的设计与架构(源码可下载）

    Java开源生鲜电商平台-监控模块的设计与架构(源码可下载) 说明:Java开源生鲜电商平台-监控模块的设计与架构,我们谈到监控,一般设计到两个方面的内容: 1. 服务器本身的监控.(比如:linux ...

随机推荐

  1. python语法基础-函数-内置函数和匿名函数-长期维护

    ##################     内置函数        #######################  """ 一共是 68个内置函数: 反射相关的内置函 ...

  2. Java基础 带你深刻理解自动装箱，拆箱含义

    1.什么是装箱,什么是拆箱装箱:把基本数据类型转换为包装类.拆箱:把包装类转换为基本数据类型.基本数据类型所对应的包装类:int(几个字节4)- Integerbyte(1)- Byteshort(2 ...

  3. 如何用Nginx解决跨域问题

    一. 产生跨域的原因 1.浏览器限制 2.跨域 3.XHR(XMLHttpRequest)请求 二. 解决思路 解决跨域有多重,在这里主要讲用nginx解决跨域 1.JSONP 2.nginx代理 3 ...

  4. VisionPro连接Dalsa线扫相机

    1 环境配置 硬件:编码器(提供编码信号的PLC) 线扫相机 镜头 相机线缆 图像采集卡(Dalsa_Xcelera-CL_PX4 Dual) 软件:VisionPro 8.2 VisionPro软件 ...

  5. python可变类型和不可变类型，深拷贝vs浅拷贝

    转载:https://www.cnblogs.com/huamingao/p/5809936.html 核心提示: 可变类型 Vs 不可变类型 可变类型(mutable):列表,字典 不可变类型(un ...

  6. tfjs-node初体验：训练模型的存储

    JS,一门从浏览器兴起,却不止于浏览器的脚本,个人一直认为其是最有潜力的脚本语言.不只是因为ES6优雅的语法,更重要的是其易上手,跨平台的优点. Node将JS从browser带去了client是革命 ...

  7. http，tcp，udp的报文格式

    http请求报文与响应报文:https://blog.csdn.net/qq_26565861/article/details/80969960 tcp与udp报文:https://www.cnblo ...

  8. 吴裕雄--天生自然python编程：pycharm常用快捷键问题

    最近在使用pycharm的时候发现不能正常使用ctrl+c/v进行复制粘贴,也无法使用tab键对大段代码进行整体缩进.后来发现是因为安装了vim插件的问题,在setting里找到vim插件,取消勾选即 ...

  9. MyBatis之ResultMap的association和collection标签(一)

    1.先说resultMap比较容易混淆的点, 2. Map结尾是映射,Type是类型  resultType 和restltMap restulyType: 1.对应的是java对象中的属性,大小写不 ...

  10. 数据库事务(Transaction)

    事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit). 事务四大特性(ACID): 原子性(Atomicity):个事务是一个不可分割的工作单位,事务中包括的 ...