通過(guò)lms.samples熟悉lms微服務(wù)框架的使用詳解

dotnet add package Silky.Lms.NormHost --version 1.0.0

 public class Program
    {
        public static async Task Main(string[] args)
        {
            await CreateHostBuilder(args).Build().RunAsync();
        }

        private static IHostBuilder CreateHostBuilder(string[] args)
        {
            return Host.CreateDefaultBuilder(args)
                    .RegisterLmsServicesNormHostModule>()
                ;
        }
    }

Project Sdk="Microsoft.NET.Sdk">

    PropertyGroup>
        OutputType>Exe/OutputType>
        TargetFramework>net5.0/TargetFramework>
    /PropertyGroup>

    ItemGroup>
      PackageReference Include="Silky.Lms.NormHost" Version="$(LmsVersion)" />
    /ItemGroup>

    ItemGroup>
      None Update="appsettings.yml">
        CopyToOutputDirectory>Always/CopyToOutputDirectory>
      /None>
      None Update="appsettings.Production.yml">
        CopyToOutputDirectory>Always/CopyToOutputDirectory>
      /None>
      None Update="appsettings.Development.yml">
        CopyToOutputDirectory>Always/CopyToOutputDirectory>
      /None>
    /ItemGroup>

    ItemGroup>
      ProjectReference Include="..\Lms.Account.Application\Lms.Account.Application.csproj" />
      ProjectReference Include="..\Lms.Account.EntityFrameworkCore\Lms.Account.EntityFrameworkCore.csproj" />
    /ItemGroup>
/Project>

rpc:
  host: 0.0.0.0
  rpcPort: 2201
  token: ypjdYOzNd4FwENJiEARMLWwK0v7QUHPW
registrycenter:
  connectionStrings: 127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183;127.0.0.1:2184,127.0.0.1:2185,127.0.0.1:2186 # 使用分號(hào);來(lái)區(qū)分不同的服務(wù)注冊(cè)中心
  registryCenterType: Zookeeper
distributedCache:
  redis:
    isEnabled: true 
    configuration: 127.0.0.1:6379,defaultDatabase=0
lock:
  lockRedisConnection: 127.0.0.1:6379,defaultDatabase=1
connectionStrings:
    default: server=127.0.0.1;port=3306;database=account;uid=root;pwd=qwe!P4ss;

/// summary>
    /// 賬號(hào)服務(wù)
    /// /summary>
    [ServiceRoute]
    public interface IAccountAppService
    {
        /// summary>
        /// 新增賬號(hào)
        /// /summary>
        /// param name="input">賬號(hào)信息/param>
        /// returns>/returns>
        TaskGetAccountOutput> Create(CreateAccountInput input);

        /// summary>
        /// 通過(guò)賬號(hào)名稱獲取賬號(hào)
        /// /summary>
        /// param name="name">賬號(hào)名稱/param>
        /// returns>/returns>
        [GetCachingIntercept("Account:Name:{0}")]
        [HttpGet("{name:string}")]
        TaskGetAccountOutput> GetAccountByName([CacheKey(0)] string name);

        /// summary>
        /// 通過(guò)Id獲取賬號(hào)信息
        /// /summary>
        /// param name="id">賬號(hào)Id/param>
        /// returns>/returns>
        [GetCachingIntercept("Account:Id:{0}")]
        [HttpGet("{id:long}")]
        TaskGetAccountOutput> GetAccountById([CacheKey(0)] long id);

        /// summary>
        /// 更新賬號(hào)信息
        /// /summary>
        /// param name="input">/param>
        /// returns>/returns>
        [UpdateCachingIntercept( "Account:Id:{0}")]
        TaskGetAccountOutput> Update(UpdateAccountInput input);

        /// summary>
        /// 刪除賬號(hào)信息
        /// /summary>
        /// param name="id">賬號(hào)Id/param>
        /// returns>/returns>
        [RemoveCachingIntercept("GetAccountOutput","Account:Id:{0}")]
        [HttpDelete("{id:long}")]
        Task Delete([CacheKey(0)]long id);

        /// summary>
        /// 訂單扣款
        /// /summary>
        /// param name="input">/param>
        /// returns>/returns>
        [Governance(ProhibitExtranet = true)]
        [RemoveCachingIntercept("GetAccountOutput","Account:Id:{0}")]
        [Transaction]
        Tasklong?> DeductBalance(DeductBalanceInput input);
    }

public class AccountAppService : IAccountAppService
    {
        private readonly IAccountDomainService _accountDomainService;

        public AccountAppService(IAccountDomainService accountDomainService)
        {
            _accountDomainService = accountDomainService;
        }

        public async TaskGetAccountOutput> Create(CreateAccountInput input)
        {
            var account = input.MapToDomain.Accounts.Account>();
            account = await _accountDomainService.Create(account);
            return account.MapToGetAccountOutput>();
        }

        public async TaskGetAccountOutput> GetAccountByName(string name)
        {
            var account = await _accountDomainService.GetAccountByName(name);
            return account.MapToGetAccountOutput>();
        }

        public async TaskGetAccountOutput> GetAccountById(long id)
        {
            var account = await _accountDomainService.GetAccountById(id);
            return account.MapToGetAccountOutput>();
        }

        public async TaskGetAccountOutput> Update(UpdateAccountInput input)
        {
            var account = await _accountDomainService.Update(input);
            return account.MapToGetAccountOutput>();
        }

        public Task Delete(long id)
        {
            return _accountDomainService.Delete(id);
        }

        [TccTransaction(ConfirmMethod = "DeductBalanceConfirm", CancelMethod = "DeductBalanceCancel")]
        public async Tasklong?> DeductBalance(DeductBalanceInput input)
        {
            var account = await _accountDomainService.GetAccountById(input.AccountId);
            if (input.OrderBalance > account.Balance)
            {
                throw new BusinessException("賬號(hào)余額不足");
            }
            return await _accountDomainService.DeductBalance(input, TccMethodType.Try);
        }

        public Task DeductBalanceConfirm(DeductBalanceInput input)
        {
            return _accountDomainService.DeductBalance(input, TccMethodType.Confirm);
        }

        public Task DeductBalanceCancel(DeductBalanceInput input)
        {
            return _accountDomainService.DeductBalance(input, TccMethodType.Cancel);
        }
    }

public class AccountDomainService : IAccountDomainService
    {
        private readonly IRepository _repository;
        private readonly IDistributedCacheGetAccountOutput, string> _accountCache;

        public AccountDomainService(IRepository repository,
            IDistributedCacheGetAccountOutput, string> accountCache)
        {
            _repository = repository;
            _accountCache = accountCache;
        }

        public async TaskAccount> Create(Account account)
        {
            var exsitAccountCount = await _repository.GetCountAsyncAccount>(p => p.Name == account.Name);
            if (exsitAccountCount > 0)
            {
                throw new BusinessException($"已經(jīng)存在{account.Name}名稱的賬號(hào)");
            }

            exsitAccountCount = await _repository.GetCountAsyncAccount>(p => p.Email == account.Email);
            if (exsitAccountCount > 0)
            {
                throw new BusinessException($"已經(jīng)存在{account.Email}Email的賬號(hào)");
            }

            await _repository.InsertAsyncAccount>(account);
            return account;
        }

        public async TaskAccount> GetAccountByName(string name)
        {
            var accountEntry = _repository.GetQueryableAccount>().FirstOrDefault(p => p.Name == name);
            if (accountEntry == null)
            {
                throw new BusinessException($"不存在名稱為{name}的賬號(hào)");
            }

            return accountEntry;
        }

        public async TaskAccount> GetAccountById(long id)
        {
            var accountEntry = _repository.GetQueryableAccount>().FirstOrDefault(p => p.Id == id);
            if (accountEntry == null)
            {
                throw new BusinessException($"不存在Id為{id}的賬號(hào)");
            }

            return accountEntry;
        }

        public async TaskAccount> Update(UpdateAccountInput input)
        {
            var account = await GetAccountById(input.Id);
            if (!account.Email.Equals(input.Email))
            {
                var exsitAccountCount = await _repository.GetCountAsyncAccount>(p => p.Email == input.Email);
                if (exsitAccountCount > 0)
                {
                    throw new BusinessException($"系統(tǒng)中已經(jīng)存在Email為{input.Email}的賬號(hào)");
                }
            }

            if (!account.Name.Equals(input.Name))
            {
                var exsitAccountCount = await _repository.GetCountAsyncAccount>(p => p.Name == input.Name);
                if (exsitAccountCount > 0)
                {
                    throw new BusinessException($"系統(tǒng)中已經(jīng)存在Name為{input.Name}的賬號(hào)");
                }
            }

            await _accountCache.RemoveAsync($"Account:Name:{account.Name}");
            account = input.MapTo(account);
            await _repository.UpdateAsync(account);
            return account;
        }

        public async Task Delete(long id)
        {
            var account = await GetAccountById(id);
            await _accountCache.RemoveAsync($"Account:Name:{account.Name}");
            await _repository.DeleteAsync(account);
        }

        public async Tasklong?> DeductBalance(DeductBalanceInput input, TccMethodType tccMethodType)
        {
            var account = await GetAccountById(input.AccountId);
            var trans = await _repository.BeginTransactionAsync();
            BalanceRecord balanceRecord = null;
            switch (tccMethodType)
            {
                case TccMethodType.Try:
                    account.Balance -= input.OrderBalance;
                    account.LockBalance += input.OrderBalance;
                    balanceRecord = new BalanceRecord()
                    {
                        OrderBalance = input.OrderBalance,
                        OrderId = input.OrderId,
                        PayStatus = PayStatus.NoPay
                    };
                    await _repository.InsertAsync(balanceRecord);
                    RpcContext.GetContext().SetAttachment("balanceRecordId",balanceRecord.Id);
                    break;
                case TccMethodType.Confirm:
                    account.LockBalance -= input.OrderBalance;
                    var balanceRecordId1 = RpcContext.GetContext().GetAttachment("orderBalanceId")?.Tolong>();
                    if (balanceRecordId1.HasValue)
                    {
                        balanceRecord = await _repository.GetByIdAsyncBalanceRecord>(balanceRecordId1.Value);
                        balanceRecord.PayStatus = PayStatus.Payed;
                        await _repository.UpdateAsync(balanceRecord);
                    }
                    break;
                case TccMethodType.Cancel:
                    account.Balance += input.OrderBalance;
                    account.LockBalance -= input.OrderBalance;
                    var balanceRecordId2 = RpcContext.GetContext().GetAttachment("orderBalanceId")?.Tolong>();
                    if (balanceRecordId2.HasValue)
                    {
                        balanceRecord = await _repository.GetByIdAsyncBalanceRecord>(balanceRecordId2.Value);
                        balanceRecord.PayStatus = PayStatus.Cancel;
                        await _repository.UpdateAsync(balanceRecord);
                    }
                    break;
            }

           
            await _repository.UpdateAsync(account);
            await trans.CommitAsync();
            await _accountCache.RemoveAsync($"Account:Name:{account.Name}");
            return balanceRecord?.Id;
        }
    }

public class EfCoreConfigureService : IConfigureService
    {
        public void ConfigureServices(IServiceCollection services, IConfiguration configuration)
        {
            services.AddDbContextOrderDbContext>(opt =>
                    opt.UseMySql(configuration.GetConnectionString("Default"),
                        ServerVersion.AutoDetect(configuration.GetConnectionString("Default"))))
                .AddGenericRepositoryOrderDbContext>(ServiceLifetime.Transient)
                ;
        }

        public int Order { get; } = 1;
    }

# github
git clone https://github.com/liuhll/lms.git

# gitee
git clone https://gitee.com/liuhll2/lms.git

docker-compose -f .\docker-compose.mysql.yml -f .\docker-compose.redis.yml -f .\docker-compose.zookeeper.yml up -d

dotnet ef database update