NopCommerce 4.9.3全栈开发实战 - 6.3 服务注册与依赖注入

1. 依赖注入概述

依赖注入（Dependency Injection，DI）是NopCommerce架构的核心设计模式之一，它允许对象通过构造函数、属性或方法接收其依赖项，而不是自己创建或查找依赖项。这种设计模式可以提高代码的可测试性、可维护性和可扩展性能

1.1 核心概念

• *服务（Service：提供特定功能的对象
• **依赖项（Dependency）*：对象所依赖的其他对）- *注入容器（DI Container：负责管理服务的生命周期和依赖关系- *服务注册（Service Registration：将服务类型注册到DI容器- *服务解析（Service Resolution：从DI容器中获取服务实现

1.2 依赖注入的优化

• 松耦合：降低对象之间的直接依赖
• *可测试：便于替换依赖项为模拟对- *可维护：集中管理依赖关系，便于修改和扩展性- *可扩展性：便于添加新的服务和功能
• 生命周期管理：自动管理服务对象的创建和销

2. NopCommerce依赖注入容器

NopCommerce使用ASP.NET Core内置的依赖注入容器，它是一个轻量级的DI容器，支持构造函数注入、属性注入和方法注入）

2.1 核心接口

ASP.NET Core DI容器的核心接口包括：

• IServiceCollection：用于注册服务- IServiceProvider：用于解析服务- IServiceScope：用于管理服务的作用途

2.2 服务生命周期

ASP.NET Core DI容器支持三种服务生命周期）

1. Singleton：单例模式，整个应用程序生命周期内只创建一个实现2. Scoped：作用域模式，每个请求生命周期内创建一个实现3. Transient：瞬态模式，每次请求时创建一个新实例

3. 服务注册

3.1 核心服务注册

NopCommerce的核心服务注册主要在Startup.cs文件中进行：

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // 添加MVC服务
        services.AddControllersWithViews();
        
        // 添加Razor Pages服务
        services.AddRazorPages();
        
        // 添加NopCommerce核心服务
        services.AddNopCore();
        
        // 添加数据访问服务
        services.AddNopDataAccess();
        
        // 添加认证服务
        services.AddNopAuthentication();
        
        // 添加其他核心服务
        services.AddNopServices();
        
        // 注册自定义服务        RegisterCustomServices(services);
    }
    
    private void RegisterCustomServices(IServiceCollection services)
    {
        // 注册自定义服务        services.AddScoped<ICustomService, CustomService>();
        services.AddSingleton<ISingletonService, SingletonService>();
        services.AddTransient<ITransientService, TransientService>();
    }
}

3.2 服务注册方式

3.2.1 基本注册

// 注册接口和实现类
services.AddScoped<IProductService, ProductService>();

// 注册具体类型
services.AddScoped<ProductService>();

// 注册实例
var singletonInstance = new SingletonService();
services.AddSingleton<ISingletonService>(singletonInstance);

// 注册工厂方法
services.AddScoped<IProductService>(provider => 
{
    var repository = provider.GetRequiredService<IRepository<Product>>();
    var mapper = provider.GetRequiredService<IMapper>();
    return new ProductService(repository, mapper);
});

3.2.2 泛型服务注册

// 注册泛型服务
services.AddScoped(typeof(IRepository<>), typeof(Repository<>));

// 注册带约束的泛型服务
services.AddScoped(typeof(IBaseService<>), typeof(BaseService<>));

3.2.3 插件服务注册

NopCommerce的插件系统支持动态注册服务，插件可以通过IDependencyInjection接口注册自己的服务：

public class DependencyInjection : IDependencyInjection
{
    public void Register(IServiceCollection services, IConfiguration configuration)
    {
        // 注册插件服务
        services.AddScoped<IPluginService, PluginService>();
        services.AddScoped<IProductPluginService, ProductPluginService>();
        
        // 注册插件视图组件
        services.AddScoped<ProductPluginViewComponent>();
        
        // 注册插件事件消费）        services.AddScoped<IEventConsumer<ProductCreatedEvent>, ProductPluginEventConsumer>();
    }
}

3.3 服务注册最佳实现

1. **使用构造函数注）*：优先使用构造函数注入，避免属性注）2. 注册抽象类型：优先注册接口或抽象类，而不是具体类型3. 选择合适的生命周期：根据服务的特性选择合适的生命周期
2. *避免服务定位器模式：尽量避免直接使用IServiceProvider解析服务
3. 集中注册服务：将服务注册集中管理，便于维护和修改

4. 服务解析

4.1 构造函数注）

构造函数注入是NopCommerce中最常用的服务解析方式：

public class ProductController : Controller
{
    private readonly IProductService _productService;
    private readonly ICustomerService _customerService;
    
    // 构造函数注）    public ProductController(IProductService productService, ICustomerService customerService)
    {
        _productService = productService;
        _customerService = customerService;
    }
    
    public async Task<IActionResult> Index()
    {
        var products = await _productService.GetAllProductsAsync();
        return View(products);
    }
}

4.2 属性注）

属性注入适用于可选依赖项，使用[FromServices]属性标记：

public class ProductController : Controller
{
    // 属性注）    [FromServices]
    public ILogger<ProductController> Logger { get; set; }
    
    private readonly IProductService _productService;
    
    public ProductController(IProductService productService)
    {
        _productService = productService;
    }
    
    public async Task<IActionResult> Index()
    {
        Logger.LogInformation("Product index page requested");
        var products = await _productService.GetAllProductsAsync();
        return View(products);
    }
}

4.3 方法注入

方法注入适用于在方法执行时获取依赖项）

public class ProductController : Controller
{
    public async Task<IActionResult> Index([FromServices] IProductService productService)
    {
        var products = await productService.GetAllProductsAsync();
        return View(products);
    }
}

4.4 直接解析服务

在某些特殊情况下，可以直接使用IServiceProvider解析服务）

public class CustomMiddleware
{
    private readonly RequestDelegate _next;
    
    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // 直接解析服务
        var logger = context.RequestServices.GetRequiredService<ILogger<CustomMiddleware>>();
        var productService = context.RequestServices.GetRequiredService<IProductService>();
        
        logger.LogInformation("Custom middleware invoked");
        
        // 处理请求
        await _next(context);
    }
}

4.5 作用域服务解）

对于Scoped服务，需要在作用域内解析）

public class SingletonService : ISingletonService
{
    private readonly IServiceProvider _serviceProvider;
    
    public SingletonService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public async Task DoWorkAsync()
    {
        // 创建作用途        using (var scope = _serviceProvider.CreateScope())
        {
            // 在作用域内解析Scoped服务
            var scopedService = scope.ServiceProvider.GetRequiredService<IScopedService>();
            await scopedService.DoWorkAsync();
        }
    }
}

5. 服务生命周期管理

5.1 生命周期选择原则

5.2 生命周期注意事项

1. 避免在Singleton服务中依赖Scoped服务：这会导致Scoped服务的生命周期延长，可能引发线程安全问题
2. 正确管理资源：对于实现了IDisposable接口的服务，DI容器会自动调用Dispose方法
3. **避免长生命周期服务持有短生命周期服务的引）：这会导致内存泄）4. **使用作用域管理临时资）：对于需要在多个服务之间共享的临时资源，使用作用域管理

6. 依赖注入最佳实现

6.1 设计原则

1. 依赖倒置原则：依赖于抽象，而不是具体实现2. 接口隔离原则：服务接口应小而专业性3. 单一职责原则：每个服务只负责一个特定的功能
2. *最少知识原理：服务应只依赖于直接需要的其他服务

6.2 实现最佳实现

1. **优先使用构造函数注）*：构造函数注入使依赖关系明确，便于测试2. 避免过多依赖：一个服务的依赖项不应超）个，否则应考虑拆分服务
2. 使用接口注册服务：便于替换实现和测试
3. 选择合适的生命周期：根据服务的特性选择合适的生命周期
4. *避免服务定位器模式：尽量避免直接使用IServiceProvider解析服务
5. 集中注册服务：将服务注册集中管理，便于维护和修改
6. *使用依赖注入容器的功能：充分利用DI容器的生命周期管理、自动注入等功能
7. **测试时使用模拟对）*：在单元测试中，使用模拟对象替换真实依赖）

6.3 常见问题与解决方案

1. 循环依赖） - 问题：两个或多个服务相互依赖，导致DI容器无法解析

   • 解决方案：重构代码，打破循环依赖，或使用属性注入（不推荐）

2. **服务未注）*） - 问题：尝试解析未注册的服务，导致InvalidOperationException

   • 解决方案：确保所有依赖项都已正确注册

3. *生命周期不匹配） - 问题：在Singleton服务中依赖Scoped服务，导致线程安全问） - 解决方案：重构代码，或使用IServiceScopeFactory创建作用途

4. 过度依赖） - 问题：一个服务依赖过多的其他服务，导致代码难以维护 - 解决方案：拆分服务，减少依赖项数）

7. 自定义依赖注入容）

虽然NopCommerce默认使用ASP.NET Core内置的DI容器，但也支持替换为其他DI容器，如Autofac、Unity、StructureMap等）

7.1 使用Autofac替换默认DI容器

public class Startup
{
    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        // 注册服务
        services.AddControllersWithViews();
        services.AddNopCore();
        // 其他服务注册
        
        // 创建Autofac容器构建）        var builder = new ContainerBuilder();
        
        // 将已注册的服务导入到Autofac
        builder.Populate(services);
        
        // 注册Autofac特定的服务        builder.RegisterType<CustomService>().As<ICustomService>().InstancePerLifetimeScope();
        
        // 构建Autofac容器
        var container = builder.Build();
        
        // 返回Autofac服务提供程序
        return new AutofacServiceProvider(container);
    }
}

8. 总结

依赖注入是NopCommerce架构的核心设计模式之一，它允许对象通过构造函数、属性或方法接收其依赖项，而不是自己创建或查找依赖项。良好的依赖注入设计可以提高代码的可测试性、可维护性和可扩展性能
在NopCommerce开发中，应遵循以下原则：

1. 优先使用构造函数注入，避免属性注入和方法注入
2. 根据服务的特性选择合适的生命周期
3. 注册抽象类型，便于替换实现和测试
4. 集中管理服务注册，便于维护和修改
5. 避免服务定位器模式，尽量使用构造函数注）6. 注意服务生命周期的匹配，避免在Singleton服务中依赖Scoped服务
6. 充分利用DI容器的功能，如自动生命周期管理、自动注入等

通过遵循这些原则和最佳实践，可以设计出高质量、高可维护性的NopCommerce应用程序