细谈Dotnet洋葱架构实践

本文转载自微信公众号「老王Plus」，作者老王Plus的老王 。转载本文请联系老王Plus公众号。

成都创新互联公司凭借专业的设计团队扎实的技术支持、优质高效的服务意识和丰厚的资源优势，提供专业的网站策划、成都网站制作、网站设计、网站优化、软件开发、网站改版等服务，在成都10年的网站建设设计经验，为成都近1000家中小型企业策划设计了网站。

一、洋葱架构简介

洋葱架构出来的其实有一点年头了。大约在2017年下半年，就有相关的说法了。不过，大量的文章在于理论性的讨论，而我们今天会用一个项目来完成这个架构。

洋葱架构，有时候也被叫做整洁架构，它本身是为高质量的软件而存在的。

相对其它架构而言，洋葱架构具有更好的可测试性、实用性和稳定性，并且足够灵活，完全适应项目未来可能的成长和进化。可以这么说，洋葱架构完美解决了三层或N层架构所面临的困难和问题。

牛吹完了，下面来看张图：

这张图，充分解释了它为什么叫洋葱架构。

不过，这不是重点。这个架构最重要的是里面的代码依赖原则：从外向内，并且只有这一个方向。处于内环的代码，不应该知道外环的任何东西。

从上面图也可以看到，洋葱架构，也使用层的概念。不过，它不同于我们习惯的三层或N层。我们来看看每个层的情况：

  • 数据层(Domain Layer)

存在于架构的中心部分，由所有业务数据的实体组成。大多数情况下，就是我们的数据模型。后面的实践代码中，我是用EF(Entity Framework)来操作的数据库。

  • 存储层(Repository Layer)

存储层在架构中充当服务层和数据模型之间的纽带，并且在这一层将保持所有数据库操作和应用数据的上下文。通常的做法是接口，用接口来描述数据访问所涉及的读写操作。

  • 服务层(Services Layer)

服务层用于实现存储层和项目之间的通信，同时，还可以保存实体的业务逻辑。在这一层，服务接口与实现分离，以实现解耦和焦点分离。

  • 用户界面层(UI Layer)

这个不解释了。项目最终对外的一层。注意，这儿可能是网站，也可能是API。不需要纠结有没有实际的界面。咱们的实践代码中，我用的是API。

二、实践

好，现在直接进入代码。

1. 创建工程

这个不解释了，都是套路：

  
 
 
 
    
   
  
  
  
  1. % dotnet new webapi -o demo -f netcoreapp3.1 
    2.

我这个工程用的是Dotnet Core 3.1。框架不重要，基本上哪个版本都可以用。

下面设置Swagger

这个是我的习惯，而且这个项目是个WebApi，装个Swagger方便。

  
 
 
 
    
   
  
  
  
  1. % dotnet add package swashbuckle.aspnetcore 
    2.

Swagger的设置不是本文的重点，略过。需要的同学可以去看源代码。

下面，我们在工程中建三个目录：

  • DomainLayer
  • RepositoryLayer
  • ServicesLayer

这三个目录对应上面的三个层。UI在这个项目里其实就是控制器Controller，已经存在了。

建这三个目录的目的，是为了放置三个层的代码。后面编码的时候，你会看到这三个层之间的关系。另外，这三个层在实际应用时，可以独立为三个类库，这样会更清晰。

前边说了，我会用EF操作数据库。所以，这儿还需要引入三个库：

  
 
 
 
    
   
  
  
  
  1. % dotnet add package Microsoft.EntityFrameworkCore 
    2.    
  
  
  
  2. % dotnet add package Microsoft.EntityFrameworkCore.Relational 
    3.    
  
  
  
  3. % dotnet add package Pomelo.EntityFrameworkCore.MySql 
    4.

注意，微软的EF框架没有提供MySQL的接入，所以引用了一个三方的库。

至此，项目的准备工作完成。

2. 实现数据层

在DomainLayer目录里，建一个Models目录。在Models目录下，建两个类：

BaseEntity.cs

  
 
 
 
    
   
  
  
  
  1. public class BaseEntity 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     public int Id { get; set; } 
    4.    
  
  
  
  4.     public DateTime CreatedDate { get; set; } 
    5.    
  
  
  
  5.     public DateTime ModifiedDate { get; set; } 
    6.    
  
  
  
  6.     public bool IsActive { get; set; } 
    7.    
  
  
  
  7. } 
    8.

Customer.cs

  
 
 
 
    
   
  
  
  
  1. public class Customer : BaseEntity 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     public string CustomerName { get; set; } 
    4.    
  
  
  
  4.     public string PurchasesProduct { get; set; } 
    5.    
  
  
  
  5.     public string PaymentType { get; set; } 
    6.    
  
  
  
  6. } 
    7.

两个类，Customer派生自BaseEntity。没什么特殊的含义，也是一个习惯。而且，后面到存储层写着方便。

后面，我们会用到Customer和BaseEntity实体类创建的数据表。为了让大家看的明白，我在这儿建一个目录EntityMapper，在目录里写个表结构映射。

CustomerMap.cs

  
 
 
 
    
   
  
  
  
  1. public class CustomerMap : IEntityTypeConfiguration 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     public void Configure(EntityTypeBuilder builder) 
    4.    
  
  
  
  4.     { 
    5.    
  
  
  
  5.         builder.HasKey(x => x.Id) 
    6.    
  
  
  
  6.             .HasName("pk_customerid"); 
    7.    
  
  
  
  7.  
    8.    
  
  
  
  8.         builder.Property(x => x.Id).ValueGeneratedOnAdd() 
    9.    
  
  
  
  9.             .HasColumnName("id") 
    10.    
  
  
  
  10.                 .HasColumnType("INT"); 
    11.    
  
  
  
  11.         builder.Property(x => x.CustomerName) 
    12.    
  
  
  
  12.             .HasColumnName("customer_name") 
    13.    
  
  
  
  13.                 .HasColumnType("NVARCHAR(100)"); 
    14.    
  
  
  
  14.         builder.Property(x => x.PurchasesProduct) 
    15.    
  
  
  
  15.             .HasColumnName("purchased_product") 
    16.    
  
  
  
  16.                 .HasColumnType("NVARCHAR(100)") 
    17.    
  
  
  
  17.                 .IsRequired(); 
    18.    
  
  
  
  18.         builder.Property(x => x.PaymentType) 
    19.    
  
  
  
  19.             .HasColumnName("payment_type") 
    20.    
  
  
  
  20.                 .HasColumnType("NVARCHAR(50)") 
    21.    
  
  
  
  21.                 .IsRequired(); 
    22.    
  
  
  
  22.         builder.Property(x => x.CreatedDate) 
    23.    
  
  
  
  23.             .HasColumnName("created_date") 
    24.    
  
  
  
  24.                 .HasColumnType("datetime"); 
    25.    
  
  
  
  25.         builder.Property(x => x.ModifiedDate) 
    26.    
  
  
  
  26.             .HasColumnName("modified_date") 
    27.    
  
  
  
  27.                 .HasColumnType("datetime"); 
    28.    
  
  
  
  28.         builder.Property(x => x.IsActive) 
    29.    
  
  
  
  29.             .HasColumnName("is_active") 
    30.    
  
  
  
  30.                 .HasColumnType("bit"); 
    31.    
  
  
  
  31.     } 
    32.    
  
  
  
  32. } 
    33.

或者也可以自己创建一个表ef.Customer：

  
 
 
 
    
   
  
  
  
  1. CREATE TABLE `Customer` ( 
    2.    
  
  
  
  2.   `id` int NOT NULL AUTO_INCREMENT, 
    3.    
  
  
  
  3.   `created_date` datetime DEFAULT NULL, 
    4.    
  
  
  
  4.   `customer_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL, 
    5.    
  
  
  
  5.   `is_active` bit(1) DEFAULT NULL, 
    6.    
  
  
  
  6.   `modified_date` datetime DEFAULT NULL, 
    7.    
  
  
  
  7.   `payment_type` varchar(50) DEFAULT NULL, 
    8.    
  
  
  
  8.   `purchased_product` varchar(100) DEFAULT NULL, 
    9.    
  
  
  
  9.   PRIMARY KEY (`id`) USING BTREE 
    10.    
  
  
  
  10. ) 
    11.

3. 实现存储层

这个层，主要用来操作数据库。

先在Startup.cs中配置数据库引用：

  
 
 
 
    
   
  
  
  
  1. public class Startup 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     public void ConfigureServices(IServiceCollection services) 
    4.    
  
  
  
  4.     { 
    5.    
  
  
  
  5.         services.AddDbContextPool( 
    6.    
  
  
  
  6.             options => options.UseMySql( 
    7.    
  
  
  
  7.                 "server=192.168.0.241;user=root;password=xxxxxx;database=ef", 
    8.    
  
  
  
  8.                 new MySqlServerVersion(new Version(8, 0, 21)), 
    9.    
  
  
  
  9.                 mysqlOptions => 
    10.    
  
  
  
  10.                 { 
    11.    
  
  
  
  11.                     mysqlOptions.CharSetBehavior(CharSetBehavior.NeverAppend); 
    12.    
  
  
  
  12.                 } 
    13.    
  
  
  
  13.         )); 
    14.    
  
  
  
  14.     } 
    15.    
  
  
  
  15. } 
    16.

这儿偷个懒，连接串就直接写代码里了。正式做项目时，最好写在配置文件中。

在RepositoryLayer目录中建一个DataContext，里面用来放置相关数据库会话，和操作的实例：

ApplicationDbContext.cs

  
 
 
 
    
   
  
  
  
  1. public partial class ApplicationDbContext : DbContext 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     public ApplicationDbContext(DbContextOptions options) : base(options) 
    4.    
  
  
  
  4.     { 
    5.    
  
  
  
  5.     } 
    6.    
  
  
  
  6.  
    7.    
  
  
  
  7.     protected override void OnModelCreating(ModelBuilder modelBuilder) 
    8.    
  
  
  
  8.     { 
    9.    
  
  
  
  9.         modelBuilder.ApplyConfiguration(new CustomerMap()); 
    10.    
  
  
  
  10.  
    11.    
  
  
  
  11.         base.OnModelCreating(modelBuilder); 
    12.    
  
  
  
  12.     } 
    13.    
  
  
  
  13. } 
    14.

再建个目录RespositoryPattern，用来存放数据库操作的类。按照注入的原则，会是两个文件，一个接口定义，一个实现类：

IRepository.cs

  
 
 
 
    
   
  
  
  
  1. public interface IRepository where T : BaseEntity 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     IEnumerable GetAll(); 
    4.    
  
  
  
  4.     T Get(int Id); 
    5.    
  
  
  
  5.     void Insert(T entity); 
    6.    
  
  
  
  6.     void Update(T entity); 
    7.    
  
  
  
  7.     void Delete(T entity); 
    8.    
  
  
  
  8.     void Remove(T entity); 
    9.    
  
  
  
  9.     void SaveChanges(); 
    10.    
  
  
  
  10. } 
    11.

Repository.cs

  
 
 
 
    
   
  
  
  
  1. public class Repository : IRepository where T : BaseEntity 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     private readonly ApplicationDbContext _applicationDbContext; 
    4.    
  
  
  
  4.     private DbSet entities; 
    5.    
  
  
  
  5.  
    6.    
  
  
  
  6.     public Repository(ApplicationDbContext applicationDbContext) 
    7.    
  
  
  
  7.     { 
    8.    
  
  
  
  8.         _applicationDbContext = applicationDbContext; 
    9.    
  
  
  
  9.         entities = _applicationDbContext.Set(); 
    10.    
  
  
  
  10.     } 
    11.    
  
  
  
  11.  
    12.    
  
  
  
  12.     public void Delete(T entity) 
    13.    
  
  
  
  13.     { 
    14.    
  
  
  
  14.         if (entity == null) 
    15.    
  
  
  
  15.         { 
    16.    
  
  
  
  16.             throw new ArgumentNullException("entity"); 
    17.    
  
  
  
  17.         } 
    18.    
  
  
  
  18.         entities.Remove(entity); 
    19.    
  
  
  
  19.         _applicationDbContext.SaveChanges(); 
    20.    
  
  
  
  20.     } 
    21.    
  
  
  
  21.     public T Get(int Id) 
    22.    
  
  
  
  22.     { 
    23.    
  
  
  
  23.         return entities.SingleOrDefault(c => c.Id == Id); 
    24.    
  
  
  
  24.     } 
    25.    
  
  
  
  25.     public IEnumerable GetAll() 
    26.    
  
  
  
  26.     { 
    27.    
  
  
  
  27.         return entities.AsEnumerable(); 
    28.    
  
  
  
  28.     } 
    29.    
  
  
  
  29.     public void Insert(T entity) 
    30.    
  
  
  
  30.     { 
    31.    
  
  
  
  31.         if (entity == null) 
    32.    
  
  
  
  32.         { 
    33.    
  
  
  
  33.             throw new ArgumentNullException("entity"); 
    34.    
  
  
  
  34.         } 
    35.    
  
  
  
  35.         entities.Add(entity); 
    36.    
  
  
  
  36.         _applicationDbContext.SaveChanges(); 
    37.    
  
  
  
  37.     } 
    38.    
  
  
  
  38.     public void Remove(T entity) 
    39.    
  
  
  
  39.     { 
    40.    
  
  
  
  40.         if (entity == null) 
    41.    
  
  
  
  41.         { 
    42.    
  
  
  
  42.             throw new ArgumentNullException("entity"); 
    43.    
  
  
  
  43.         } 
    44.    
  
  
  
  44.         entities.Remove(entity); 
    45.    
  
  
  
  45.     } 
    46.    
  
  
  
  46.     public void SaveChanges() 
    47.    
  
  
  
  47.     { 
    48.    
  
  
  
  48.         _applicationDbContext.SaveChanges(); 
    49.    
  
  
  
  49.     } 
    50.    
  
  
  
  50.     public void Update(T entity) 
    51.    
  
  
  
  51.     { 
    52.    
  
  
  
  52.         if (entity == null) 
    53.    
  
  
  
  53.         { 
    54.    
  
  
  
  54.             throw new ArgumentNullException("entity"); 
    55.    
  
  
  
  55.         } 
    56.    
  
  
  
  56.         entities.Update(entity); 
    57.    
  
  
  
  57.         _applicationDbContext.SaveChanges(); 
    58.    
  
  
  
  58.     } 
    59.    
  
  
  
  59. } 
    60.

4. 实现服务层

服务层用来实现核心的业务逻辑。同样先建一个目录CustomerService，方便注入，也是一个接口一个类：

ICustomerService.cs

  
 
 
 
    
   
  
  
  
  1. public interface ICustomerService 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     IEnumerable GetAllCustomers(); 
    4.    
  
  
  
  4.     Customer GetCustomer(int id); 
    5.    
  
  
  
  5.     void InsertCustomer(Customer customer); 
    6.    
  
  
  
  6.     void UpdateCustomer(Customer customer); 
    7.    
  
  
  
  7.     void DeleteCustomer(int id); 
    8.    
  
  
  
  8. } 
    9.

CustomerService.cs

  
 
 
 
    
   
  
  
  
  1. public class CustomerService : ICustomerService 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     private IRepository _repository; 
    4.    
  
  
  
  4.  
    5.    
  
  
  
  5.     public CustomerService(IRepository repository) 
    6.    
  
  
  
  6.     { 
    7.    
  
  
  
  7.         _repository = repository; 
    8.    
  
  
  
  8.     } 
    9.    
  
  
  
  9.  
    10.    
  
  
  
  10.     public IEnumerable GetAllCustomers() 
    11.    
  
  
  
  11.     { 
    12.    
  
  
  
  12.         return _repository.GetAll(); 
    13.    
  
  
  
  13.     } 
    14.    
  
  
  
  14.     public Customer GetCustomer(int id) 
    15.    
  
  
  
  15.     { 
    16.    
  
  
  
  16.         return _repository.Get(id); 
    17.    
  
  
  
  17.     } 
    18.    
  
  
  
  18.     public void InsertCustomer(Customer customer) 
    19.    
  
  
  
  19.     { 
    20.    
  
  
  
  20.         _repository.Insert(customer); 
    21.    
  
  
  
  21.     } 
    22.    
  
  
  
  22.     public void UpdateCustomer(Customer customer) 
    23.    
  
  
  
  23.     { 
    24.    
  
  
  
  24.         _repository.Update(customer); 
    25.    
  
  
  
  25.     } 
    26.    
  
  
  
  26.     public void DeleteCustomer(int id) 
    27.    
  
  
  
  27.     { 
    28.    
  
  
  
  28.         Customer customer = GetCustomer(id); 
    29.    
  
  
  
  29.         _repository.Remove(customer); 
    30.    
  
  
  
  30.         _repository.SaveChanges(); 
    31.    
  
  
  
  31.     } 
    32.    
  
  
  
  32. } 
    33.

4. 注入

这儿就是套路了，不解释。

  
 
 
 
    
   
  
  
  
  1. public void ConfigureServices(IServiceCollection services) 
    2.    
  
  
  
  2. { 
    3.    
  
  
  
  3.     services.AddScoped(typeof(IRepository<>), typeof(Repository<>)); 
    4.    
  
  
  
  4.     services.AddTransient(); 
    5.    
  
  
  
  5. } 
    6.

5. 实现控制器

重要的三层都已经实现。下面做个演示用的控制器：

CustomerController.cs

  
 
 
 
    
   
  
  
  
  1. [ApiController] 
    2.    
  
  
  
  2. [Route("[controller]")] 
    3.    
  
  
  
  3. public class CustomerController : ControllerBase 
    4.    
  
  
  
  4. { 
    5.    
  
  
  
  5.     private readonly ICustomerService _customerService; 
    6.    
  
  
  
  6.  
    7.    
  
  
  
  7.     public CustomerController(ICustomerService customerService) 
    8.    
  
  
  
  8.     { 
    9.    
  
  
  
  9.         _customerService = customerService; 
    10.    
  
  
  
  10.     } 
    11.    
  
  
  
  11.  
    12.    
  
  
  
  12.     [HttpGet(nameof(GetCustomer))] 
    13.    
  
  
  
  13.     public IActionResult GetCustomer(int id) 
    14.    
  
  
  
  14.     { 
    15.    
  
  
  
  15.         var result = _customerService.GetCustomer(id); 
    16.    
  
  
  
  16.         if (result != null) 
    17.    
  
  
  
  17.         { 
    18.    
  
  
  
  18.             return Ok(result); 
    19.    
  
  
  
  19.         } 
    20.    
  
  
  
  20.         return BadRequest("No records found"); 
    21.    
  
  
  
  21.     } 
    22.    
  
  
  
  22.     [HttpGet(nameof(GetAllCustomer))] 
    23.    
  
  
  
  23.     public IActionResult GetAllCustomer() 
    24.    
  
  
  
  24.     { 
    25.    
  
  
  
  25.         var result = _customerService.GetAllCustomers(); 
    26.    
  
  
  
  26.         if (result != null) 
    27.    
  
  
  
  27.         { 
    28.    
  
  
  
  28.             return Ok(result); 
    29.    
  
  
  
  29.         } 
    30.    
  
  
  
  30.         return BadRequest("No records found"); 
    31.    
  
  
  
  31.     } 
    32.    
  
  
  
  32.     [HttpPost(nameof(InsertCustomer))] 
    33.    
  
  
  
  33.     public IActionResult InsertCustomer(Customer customer) 
    34.    
  
  
  
  34.     { 
    35.    
  
  
  
  35.         _customerService.InsertCustomer(customer); 
    36.    
  
  
  
  36.         return Ok("Data inserted"); 
    37.    
  
  
  
  37.     } 
    38.    
  
  
  
  38.     [HttpPut(nameof(UpdateCustomer))] 
    39.    
  
  
  
  39.     public IActionResult UpdateCustomer(Customer customer) 
    40.    
  
  
  
  40.     { 
    41.    
  
  
  
  41.         _customerService.UpdateCustomer(customer); 
    42.    
  
  
  
  42.         return Ok("Updation done"); 
    43.    
  
  
  
  43.     } 
    44.    
  
  
  
  44.     [HttpDelete(nameof(DeleteCustomer))] 
    45.    
  
  
  
  45.     public IActionResult DeleteCustomer(int Id) 
    46.    
  
  
  
  46.     { 
    47.    
  
  
  
  47.         _customerService.DeleteCustomer(Id); 
    48.    
  
  
  
  48.         return Ok("Data Deleted"); 
    49.    
  
  
  
  49.     } 
    50.    
  
  
  
  50. } 
    51.

代码部分全部完成。编译运行~~~

三、总结

通过上面的代码可以看到：

  • 洋葱架构各层间通过接口互相关联，数据引入是在运行时进行的
  • 应用以区域模型为基础
  • 所有的外部依赖，如数据集准入和管理调，都是在外部处理
  • 适应性强，设计也方便

总之，从应用来说，洋葱架构算是个很优秀的架构。以我的经验，在多个共同开发的项目中，具有比较大的优势。

本文的相关代码，在https://github.com/humornif/Demo-Code/tree/master/0045/demo

新闻名称：细谈Dotnet洋葱架构实践
当前网址：http://www.csdahua.cn/qtweb/news21/31821.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

静态网站知识

分类信息网站

艾名斯线缆　　 　成都网站制作　　 　网站排名　　 　SF双层罐　　 　手机网站版本　　 　腾讯香港免备案空间　　 　梓潼网站建设　　 　重庆外贸网站建设　　 　四川成都网站设计　　 　网站解决方案　　 　卡多尼人工智　　 　葆金莱自动门　　 　四川正泰动物　　 　成都柴油发电机组　　 　宜宾网站建设　　 　抖音短视频拍摄　　 　眉山主机托管　　 　格蓝特设备　　 　服务器托管　　 　成都微信开发