装饰器模式与领域模型的日志集成难题及解决方法咨询

一、装饰器模式的日志集成：分离职责+DI自动组装 #

核心思路是把日志逻辑和业务过滤逻辑拆分成独立的装饰器，让功能装饰器只专注业务，日志装饰器专门处理日志，再通过依赖注入（DI）容器自动完成嵌套组装，避免手动传递日志对象。

1. 保持功能装饰器的纯净性 #

功能装饰器（如NoZeroDiscount）不需要关心日志，只实现业务过滤逻辑：

public class NoZeroDiscount(IDiscount other) : IDiscount
{
    public IEnumerable<DiscountApplications> GetDiscount(Money money)
    {
        return other.GetDiscount(money).Where(d => d != 0);
    }
}

2. 独立实现通用日志装饰器 #

专门写一个日志装饰器，负责包裹任意IDiscount实例并添加日志逻辑：

public class DiscountLoggingDecorator(IDiscount innerDiscount, ILogger<DiscountLoggingDecorator> logger) : IDiscount
{
    public IEnumerable<DiscountApplications> GetDiscount(Money money)
    {
        logger.LogInformation("开始计算折扣，金额：{Amount}", money.Amount);
        
        var discounts = innerDiscount.GetDiscount(money);
        
        logger.LogInformation("折扣计算完成，返回{Count}条非零折扣", discounts.Count());
        return discounts;
    }
}

3. 通过DI容器自动组装装饰器 #

以ASP.NET Core为例，在DI注册时用Decorate方法依次嵌套装饰器，DI会自动处理日志对象的注入：

// 注册基础折扣实现
services.AddScoped<IDiscount, BaseDiscountImplementation>();
// 用NoZeroDiscount装饰基础实现
services.Decorate<IDiscount, NoZeroDiscount>();
// 用日志装饰器包裹已过滤的折扣实例
services.Decorate<IDiscount, DiscountLoggingDecorator>();

之后业务代码直接注入IDiscount即可，无需手动传递日志或嵌套装饰器，完全保持原有易用性。

二、领域模型（如Book类）的日志集成：避免直接依赖日志对象 #

领域模型通常由业务代码手动实例化，直接注入日志会大幅增加实例化成本，可通过以下三种方案解决：

方案1：静态日志工厂（简单直接） #

在领域层定义一个静态日志工厂，启动时从DI容器注入ILoggerFactory，领域实体通过工厂获取泛型日志对象：

1. 定义静态日志工厂

public static class DomainLoggerFactory
{
    private static ILoggerFactory _loggerFactory;

    public static void Initialize(ILoggerFactory loggerFactory)
    {
        _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
    }

    public static ILogger<T> GetLogger<T>()
    {
        if (_loggerFactory == null)
            throw new InvalidOperationException("DomainLoggerFactory未初始化");
        
        return _loggerFactory.CreateLogger<T>();
    }
}

2. 启动时初始化工厂

在Program.cs中完成初始化：

var builder = WebApplication.CreateBuilder(args);
// 其他服务注册...

// 从DI获取LoggerFactory并初始化领域日志工厂
var loggerFactory = builder.Services.BuildServiceProvider().GetRequiredService<ILoggerFactory>();
DomainLoggerFactory.Initialize(loggerFactory);

3. 领域实体中使用日志

public class Book
{
    private readonly ILogger<Book> _logger = DomainLoggerFactory.GetLogger<Book>();
    public Guid Id { get; init; }

    public void ComplexStuff()
    {
        _logger.LogInformation("执行Book[{BookId}]的ComplexStuff逻辑", Id);
        // 业务逻辑...
    }
}

这样实例化Book时无需传入日志对象，同时能获取到对应类型的泛型日志。

方案2：将日志逻辑移至领域服务 #

把需要日志的业务逻辑从领域实体移到DI管理的领域服务中，服务注入日志对象，实体仅作为数据载体：

1. 领域服务处理日志与业务

public class BookService(ILogger<BookService> logger)
{
    public void ExecuteComplexStuff(Book book)
    {
        logger.LogInformation("处理Book[{BookId}]的复杂逻辑", book.Id);
        // 调用实体内部逻辑或直接处理业务
        book.ExecuteComplexLogic();
    }
}

2. 领域实体保持纯净

public class Book
{
    public Guid Id { get; init; }

    internal void ExecuteComplexLogic()
    {
        // 仅包含核心业务逻辑，无日志依赖
    }
}

业务代码通过注入BookService来处理逻辑，避免了实体实例化时的日志依赖。

方案3：领域事件+后台日志处理 #

领域实体发布业务事件，由独立的事件处理器负责记录日志，实体完全不依赖日志组件：

1. 定义领域事件与实体

// 领域事件基类
public interface IDomainEvent { }

// 具体业务事件
public record BookComplexLogicExecuted(Guid BookId) : IDomainEvent;

public class Book
{
    private readonly List<IDomainEvent> _domainEvents = new();
    public Guid Id { get; init; }

    public void ComplexStuff()
    {
        // 业务逻辑...
        _domainEvents.Add(new BookComplexLogicExecuted(Id));
    }

    public IEnumerable<IDomainEvent> GetDomainEvents() => _domainEvents;
}

2. 实现事件处理器记录日志

public class BookComplexLogicEventHandler(ILogger<BookComplexLogicEventHandler> logger)
{
    public Task Handle(BookComplexLogicExecuted @event)
    {
        logger.LogInformation("Book[{BookId}]的复杂逻辑已执行", @event.BookId);
        return Task.CompletedTask;
    }
}

3. 注册事件处理器并发布事件

在DI中注册处理器，业务代码处理完实体逻辑后，收集并发布事件：

// DI注册事件处理器
services.AddScoped<IEventHandler<BookComplexLogicExecuted>, BookComplexLogicEventHandler>();

// 业务代码中发布事件
var book = new Book { Id = Guid.NewGuid() };
book.ComplexStuff();

var events = book.GetDomainEvents();
foreach (var @event in events)
{
    // 获取对应处理器并执行
    var handler = serviceProvider.GetRequiredService<IEventHandler<@event.GetType()>>();
    await handler.Handle(@event);
}

这种方式完全隔离了领域模型与日志组件，符合领域驱动设计的原则。

内容的提问来源于stack exchange，提问作者Birdalicious