分类 技术教程 下的文章

写了一个 gorm 乐观锁插件

一个很清晰的架构实践,同时刨刨MySQL的坑。

一、洋葱架构简介

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

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

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

牛吹完了,下面来看张图:

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

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

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

  • 数据层(Domain Layer)

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

  • 存储层(Repository Layer)

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

  • 服务层(Services Layer)

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

  • 用户界面层(UI Layer)

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

    为了防止不提供原网址的转载,特在这里加上原文链接:https://www.cnblogs.com/tiger-wang/p/14547702.html

二、实践

好,现在直接进入代码。

1. 创建工程

这个不解释了,都是套路:

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

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

下面设置Swagger

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

% dotnet add package swashbuckle.aspnetcore

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

下面,我们在工程中建三个目录:

  • DomainLayer
  • RepositoryLayer
  • ServicesLayer

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

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

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

% dotnet add package Microsoft.EntityFrameworkCore
% dotnet add package Microsoft.EntityFrameworkCore.Relational
% dotnet add package Pomelo.EntityFrameworkCore.MySql

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

电影AI修复,让重温经典有了新的可能

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

2. 实现数据层

在DomainLayer目录里,建一个Models目录。在Models目录下,建两个类:

BaseEntity.cs

public class BaseEntity
{
    public int Id { get; set; }
    public DateTime CreatedDate { get; set; }
    public DateTime ModifiedDate { get; set; }
    public bool IsActive { get; set; }
}

Customer.cs

public class Customer : BaseEntity
{
    public string CustomerName { get; set; }
    public string PurchasesProduct { get; set; }
    public string PaymentType { get; set; }
}

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

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

CustomerMap.cs

public class CustomerMap : IEntityTypeConfiguration
{
    public void Configure(EntityTypeBuilder builder)
    {
        builder.HasKey(x => x.Id)
            .HasName("pk_customerid");

        builder.Property(x => x.Id).ValueGeneratedOnAdd()
            .HasColumnName("id")
                .HasColumnType("INT");
        builder.Property(x => x.CustomerName)
            .HasColumnName("customer_name")
                .HasColumnType("NVARCHAR(100)");
        builder.Property(x => x.PurchasesProduct)
            .HasColumnName("purchased_product")
                .HasColumnType("NVARCHAR(100)")
                .IsRequired();
        builder.Property(x => x.PaymentType)
            .HasColumnName("payment_type")
                .HasColumnType("NVARCHAR(50)")
                .IsRequired();
        builder.Property(x => x.CreatedDate)
            .HasColumnName("created_date")
                .HasColumnType("datetime");
        builder.Property(x => x.ModifiedDate)
            .HasColumnName("modified_date")
                .HasColumnType("datetime");
        builder.Property(x => x.IsActive)
            .HasColumnName("is_active")
                .HasColumnType("bit");
    }
}

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

CREATE TABLE `Customer` (
  `id` int NOT NULL AUTO_INCREMENT,
  `created_date` datetime DEFAULT NULL,
  `customer_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `is_active` bit(1) DEFAULT NULL,
  `modified_date` datetime DEFAULT NULL,
  `payment_type` varchar(50) DEFAULT NULL,
  `purchased_product` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
)

3. 实现存储层

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

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

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContextPool(
            options => options.UseMySql(
                "server=192.168.0.241;user=root;password=xxxxxx;database=ef",
                new MySqlServerVersion(new Version(8, 0, 21)),
                mysqlOptions =>
                {
                    mysqlOptions.CharSetBehavior(CharSetBehavior.NeverAppend);
                }
        ));
    }
}

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

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

ApplicationDbContext.cs

public partial class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions options) : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.ApplyConfiguration(new CustomerMap());

        base.OnModelCreating(modelBuilder);
    }
}

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

IRepository.cs

public interface IRepository where T : BaseEntity
{
    IEnumerable GetAll();
    T Get(int Id);
    void Insert(T entity);
    void Update(T entity);
    void Delete(T entity);
    void Remove(T entity);
    void SaveChanges();
}

Repository.cs

public class Repository : IRepository where T : BaseEntity
{
    private readonly ApplicationDbContext _applicationDbContext;
    private DbSet entities;

    public Repository(ApplicationDbContext applicationDbContext)
    {
        _applicationDbContext = applicationDbContext;
        entities = _applicationDbContext.Set();
    }

    public void Delete(T entity)
    {
        if (entity == null)
        {
            throw new ArgumentNullException("entity");
        }
        entities.Remove(entity);
        _applicationDbContext.SaveChanges();
    }
    public T Get(int Id)
    {
        return entities.SingleOrDefault(c => c.Id == Id);
    }
    public IEnumerable GetAll()
    {
        return entities.AsEnumerable();
    }
    public void Insert(T entity)
    {
        if (entity == null)
        {
            throw new ArgumentNullException("entity");
        }
        entities.Add(entity);
        _applicationDbContext.SaveChanges();
    }
    public void Remove(T entity)
    {
        if (entity == null)
        {
            throw new ArgumentNullException("entity");
        }
        entities.Remove(entity);
    }
    public void SaveChanges()
    {
        _applicationDbContext.SaveChanges();
    }
    public void Update(T entity)
    {
        if (entity == null)
        {
            throw new ArgumentNullException("entity");
        }
        entities.Update(entity);
        _applicationDbContext.SaveChanges();
    }
}

4. 实现服务层

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

ICustomerService.cs

public interface ICustomerService
{
    IEnumerable GetAllCustomers();
    Customer GetCustomer(int id);
    void InsertCustomer(Customer customer);
    void UpdateCustomer(Customer customer);
    void DeleteCustomer(int id);
}

CustomerService.cs

public class CustomerService : ICustomerService
{
    private IRepository _repository;

    public CustomerService(IRepository repository)
    {
        _repository = repository;
    }

    public IEnumerable GetAllCustomers()
    {
        return _repository.GetAll();
    }
    public Customer GetCustomer(int id)
    {
        return _repository.Get(id);
    }
    public void InsertCustomer(Customer customer)
    {
        _repository.Insert(customer);
    }
    public void UpdateCustomer(Customer customer)
    {
        _repository.Update(customer);
    }
    public void DeleteCustomer(int id)
    {
        Customer customer = GetCustomer(id);
        _repository.Remove(customer);
        _repository.SaveChanges();
    }
}

4. 注入

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

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
    services.AddTransient();
}

5. 实现控制器

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

CustomerController.cs

[ApiController]
[Route("[controller]")]
public class CustomerController : ControllerBase
{
    private readonly ICustomerService _customerService;

    public CustomerController(ICustomerService customerService)
    {
        _customerService = customerService;
    }

    [HttpGet(nameof(GetCustomer))]
    public IActionResult GetCustomer(int id)
    {
        var result = _customerService.GetCustomer(id);
        if (result != null)
        {
            return Ok(result);
        }
        return BadRequest("No records found");
    }
    [HttpGet(nameof(GetAllCustomer))]
    public IActionResult GetAllCustomer()
    {
        var result = _customerService.GetAllCustomers();
        if (result != null)
        {
            return Ok(result);
        }
        return BadRequest("No records found");
    }
    [HttpPost(nameof(InsertCustomer))]
    public IActionResult InsertCustomer(Customer customer)
    {
        _customerService.InsertCustomer(customer);
        return Ok("Data inserted");
    }
    [HttpPut(nameof(UpdateCustomer))]
    public IActionResult UpdateCustomer(Customer customer)
    {
        _customerService.UpdateCustomer(customer);
        return Ok("Updation done");
    }
    [HttpDelete(nameof(DeleteCustomer))]
    public IActionResult DeleteCustomer(int Id)
    {
        _customerService.DeleteCustomer(Id);
        return Ok("Data Deleted");
    }
}

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

三、总结

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

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

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

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

微信公众号:老王Plus

扫描二维码,关注个人公众号,可以第一时间得到最新的个人文章和内容推送

本文版权归作者所有,转载请保留此声明和原文链接

ASP.NET Core与Redis搭建一个简易分布式缓存

电影AI修复,让重温经典有了新的可能

前言

最近在用 Go 写业务的时碰到了并发更新数据的场景,由于该业务并发度不高,只是为了防止出现并发时数据异常。

所以自然就想到了乐观锁的解决方案。

实现

乐观锁的实现比较简单,相信大部分有数据库使用经验的都能想到。

UPDATE `table` SET `amount`=100,`version`=version+1 WHERE `version` = 1 AND `id` = 1

需要在表中新增一个类似于 version 的字段,本质上我们只是执行这段 SQL,在更新时比较当前版本与数据库版本是否一致。

如上图所示:版本一致则更新成功,并且将版本号+1;如果不一致则认为出现并发冲突,更新失败。

这时可以直接返回失败,让业务重试;当然也可以再次获取最新数据进行更新尝试。

我们使用的是 gorm 这个 orm 库,不过我查阅了官方文档却没有发现乐观锁相关的支持,看样子后续也不打算提供实现。

不过借助 gorm 实现也很简单:

type Optimistic struct {
	Id      int64   `gorm:"column:id;primary_key;AUTO_INCREMENT" json:"id"`
	UserId  string  `gorm:"column:user_id;default:0;NOT NULL" json:"user_id"` // 用户ID
	Amount  float32 `gorm:"column:amount;NOT NULL" json:"amount"`             // 金额
	Version int64   `gorm:"column:version;default:0;NOT NULL" json:"version"` // 版本
}

func TestUpdate(t *testing.T) {
	dsn := "root:abc123@/test?charset=utf8&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	var out Optimistic
	db.First(&out, Optimistic{Id: 1})
	out.Amount = out.Amount + 10
	column := db.Model(&out).Where("id", out.Id).Where("version", out.Version).
		UpdateColumn("amount", out.Amount).
		UpdateColumn("version", gorm.Expr("version+1"))
	fmt.Printf("#######update %v line \n", column.RowsAffected)
}

这里我们创建了一张 t_optimistic 表用于测试,生成的 SQL 也满足乐观锁的要求。

不过考虑到这类业务的通用性,每次需要乐观锁更新时都需要这样硬编码并不太合适。对于业务来说其实 version 是多少压根不需要关心,只要能满足并发更新时的准确性即可。

因此我做了一个封装,最终使用如下:


var out Optimistic
db.First(&out, Optimistic{Id: 1})
out.Amount = out.Amount + 10
if err = UpdateWithOptimistic(db, &out, nil, 0, 0); err != nil {
		fmt.Printf("%+v \n", err)
}
  • 这里的使用场景是每次更新时将 amount 金额加上 10

这样只会更新一次,如果更新失败会返回一个异常。

当然也支持更新失败时执行一个回调函数,在该函数中实现对应的业务逻辑,同时会使用该业务逻辑尝试更新 N 次。

func BenchmarkUpdateWithOptimistic(b *testing.B) {
	dsn := "root:abc123@/test?charset=utf8&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err)
		return
	}
	b.RunParallel(func(pb *testing.PB) {
		var out Optimistic
		db.First(&out, Optimistic{Id: 1})
		out.Amount = out.Amount + 10
		err = UpdateWithOptimistic(db, &out, func(model Lock) Lock {
			bizModel := model.(*Optimistic)
			bizModel.Amount = bizModel.Amount + 10
			return bizModel
		}, 3, 0)
		if err != nil {
			fmt.Printf("%+v \n", err)
		}
	})
}

以上代码的目的是:

amount 金额 +10,失败时再次依然将金额+10,尝试更新 3 次;经过上述的并行测试,最终查看数据库确认数据并没有发生错误。

ASP.NET Core与Redis搭建一个简易分布式缓存

面向接口编程

下面来看看具体是如何实现的;其实真正核心的代码也比较少:

func UpdateWithOptimistic(db *gorm.DB, model Lock, callBack func(model Lock) Lock, retryCount, currentRetryCount int32) (err error) {
	if currentRetryCount > retryCount {
		return errors.WithStack(NewOptimisticError("Maximum number of retries exceeded:" + strconv.Itoa(int(retryCount))))
	}
	currentVersion := model.GetVersion()
	model.SetVersion(currentVersion + 1)
	column := db.Model(model).Where("version", currentVersion).UpdateColumns(model)
	affected := column.RowsAffected
	if affected == 0 {
		if callBack == nil && retryCount == 0 {
			return errors.WithStack(NewOptimisticError("Concurrent optimistic update error"))
		}
		time.Sleep(100 * time.Millisecond)
		db.First(model)
		bizModel := callBack(model)
		currentRetryCount++
		err := UpdateWithOptimistic(db, bizModel, callBack, retryCount, currentRetryCount)
		if err != nil {
			return err
		}
	}
	return column.Error

}

具体步骤如下:

  • 判断重试次数是否达到上限。
  • 获取当前更新对象的版本号,将当前版本号 +1。
  • 根据版本号条件执行更新语句。
  • 更新成功直接返回。
  • 更新失败 affected == 0 时,执行重试逻辑。
    • 重新查询该对象的最新数据,目的是获取最新版本号。
    • 执行回调函数。
    • 从回调函数中拿到最新的业务数据。
    • 递归调用自己执行更新,直到重试次数达到上限。

这里有几个地方值得说一下;由于 Go 目前还不支持泛型,所以我们如果想要获取 struct 中的 version 字段只能通过反射。

考虑到反射的性能损耗以及代码的可读性,有没有更”优雅“的实现方式呢?

于是我定义了一个 interface:

type Lock interface {
	SetVersion(version int64)
	GetVersion() int64
}

其中只有两个方法,目的则是获取 struct 中的 version 字段;所以每个需要乐观锁的 struct 都得实现该接口,类似于这样:

func (o *Optimistic) GetVersion() int64 {
	return o.Version
}

func (o *Optimistic) SetVersion(version int64) {
	o.Version = version
}

这样还带来了一个额外的好处:

一旦该结构体没有实现接口,在乐观锁更新时编译器便会提前报错,如果使用反射只能是在运行期间才能进行校验。

所以这里在接收数据库实体的便可以是 Lock 接口,同时获取和重新设置 version 字段也是非常的方便。

currentVersion := model.GetVersion()
model.SetVersion(currentVersion + 1)

类型断言

当并发更新失败时affected == 0,便会回调传入进来的回调函数,在回调函数中我们需要实现自己的业务逻辑。

err = UpdateWithOptimistic(db, &out, func(model Lock) Lock {
			bizModel := model.(*Optimistic)
			bizModel.Amount = bizModel.Amount + 10
			return bizModel
		}, 2, 0)
		if err != nil {
			fmt.Printf("%+v \n", err)
		}

但由于回调函数的入参只能知道是一个 Lock 接口,并不清楚具体是哪个 struct,所以在执行业务逻辑之前需要将这个接口转换为具体的 struct

这其实和 Java 中的父类向子类转型非常类似,必须得是强制类型转换,也就是说运行时可能会出问题。

Go 语言中这样的行为被称为类型断言;虽然叫法不同,但目的类似。其语法如下:

x.(T)
x:表示 interface 
T:表示 向下转型的具体 struct

所以在回调函数中得根据自己的需要将 interface 转换为自己的 struct,这里得确保是自己所使用的 struct ,因为是强制转换,编译器无法帮你做校验,具体能否转换成功得在运行时才知道。

总结

有需要的朋友可以在这里获取到源码及具体使用方式:

https://github.com/crossoverJie/gorm-optimistic

最近工作中使用了几种不同的编程语言,会发现除了语言自身的语法特性外大部分知识点都是相同的;

比如面向对象、数据库、IO操作等;所以掌握了这些基本知识,学习其他语言自然就能触类旁通了。

JVM笔记 -- 来,教你类加载子系统