3. abp依赖注入的分析.md

abp依赖注入的原理剖析

请先移步参考 [Abp vNext 源码分析] - 3. 依赖注入与拦截器 本文此篇文章的补充和完善。

abp的依赖注入最后是通过IConventionalRegister接口的AddType方法实现的。先看下该接口:

public interface IConventionalRegistrar
{
    void AddAssembly(IServiceCollection services, Assembly assembly);

    void AddTypes(IServiceCollection services, params Type[] types);

    void AddType(IServiceCollection services, Type type);
}

该接口定义了三个方法,支持传入程序集、类型数组、具体类型,其实现在一个抽象类==ConventionalRegistrarBase==中:

public abstract class ConventionalRegistrarBase : IConventionalRegistrar
{
    public virtual void AddAssembly(IServiceCollection services, Assembly assembly)
    {
        var types = AssemblyHelper
            .GetAllTypes(assembly)
            .Where(
                type => type != null &&
                        type.IsClass &&
                        !type.IsAbstract &&
                        !type.IsGenericType
            ).ToArray();

        AddTypes(services, types);
    }

    public virtual void AddTypes(IServiceCollection services, params Type[] types)
    {
        foreach (var type in types)
        {
            AddType(services, type);
        }
    }

    public abstract void AddType(IServiceCollection services, Type type);
}

不管是程序集,还是类型数组最后都是调用AddType方法,AddType的实现在这个抽象类的派生类中,abp有一个默认的实现类==DefaultConventionalRegistrar==,该类实现了AddType方法,abp的依赖注入就是通过该类的AddType方法注入的。源码:

public class DefaultConventionalRegistrar : ConventionalRegistrarBase
{
    public override void AddType(IServiceCollection services, Type type)
    {
        if (IsConventionalRegistrationDisabled(type))
        {
            return;
        }

        var dependencyAttribute = GetDependencyAttributeOrNull(type);
        var lifeTime = GetLifeTimeOrNull(type, dependencyAttribute);

        if (lifeTime == null)
        {
            return;
        }

        var serviceTypes = ExposedServiceExplorer.GetExposedServices(type);

        TriggerServiceExposing(services, type, serviceTypes);

        foreach (var serviceType in serviceTypes)
        {
            var serviceDescriptor = ServiceDescriptor.Describe(serviceType, type, lifeTime.Value);

            if (dependencyAttribute?.ReplaceServices == true)
            {
                services.Replace(serviceDescriptor);
            }
            else if (dependencyAttribute?.TryRegister == true)
            {
                services.TryAdd(serviceDescriptor);
            }
            else
            {
                services.Add(serviceDescriptor);
            }
        }
    }

    // 其他方法实现
}

从这个类中可以看出abp依赖注入的实现思路:根据GetExposedServices方法返回的服务类型列表去构造服务描述符(服务描述符的第一个参数就是服务类型,第二个参数就是实现类型)。而实现类型就是我们要注入的类型。再将此服务描述符注入到DI容器中。
GetDependencyAttributeOrNull方法和GetLifeTimeOrNull方法是获取使用了Dependency特性注入的类及其生命周期,如果没有则使用默认的生命周期,因此如果Dependency特性的注入优先级更高。GetExposedServices是在静态类ExposedServiceExplorer中,该静态类是用来获取注入类型的定义及实现的。源码实现:

public static List<Type> GetExposedServices(Type type)
{
    return type
        .GetCustomAttributes()
        .OfType<IExposedServiceTypesProvider>()
        .DefaultIfEmpty(DefaultExposeServicesAttribute)
        .SelectMany(p => p.GetExposedServiceTypes(type))
        .ToList();
}

IExposedServicveTypeProvider接口定义及实现:

//定义:
public interface IExposedServiceTypesProvider
{
    Type[] GetExposedServiceTypes(Type targetType);
}

//实现:
public class ExposeServicesAttribute : Attribute, IExposedServiceTypesProvider
{
    public ExposeServicesAttribute(params Type[] serviceTypes)
    {
        ServiceTypes = serviceTypes ?? new Type[0];
    }

    public Type[] GetExposedServiceTypes(Type targetType)
    {
        var serviceList = ServiceTypes.ToList();

        if (IncludeDefaults == true)
        {
            foreach (var type in GetDefaultServices(targetType))
            {
                serviceList.AddIfNotContains(type);
            }

            if (IncludeSelf != false)
            {
                serviceList.AddIfNotContains(targetType);
            }
        }
        else if (IncludeSelf == true)
        {
            serviceList.AddIfNotContains(targetType);
        }

        return serviceList.ToArray();
    }

    private static List<Type> GetDefaultServices(Type type)
    {
        var serviceTypes = new List<Type>();

        foreach (var interfaceType in type.GetTypeInfo().GetInterfaces())
        {
            var interfaceName = interfaceType.Name;

            if (interfaceName.StartsWith("I"))
            {
                interfaceName = interfaceName.Right(interfaceName.Length - 1);
            }

            if (type.Name.EndsWith(interfaceName))
            {
                serviceTypes.Add(interfaceType);
            }
        }

        return serviceTypes;
    }
}

该接口的实现是在ExposeServices特性的实现类中,这是个特性类,是abp三种注入服务的第一种——ExposeServices特性注入。该类的构造函数会直接保存要注入类型的服务列表。其次就是GetDefaultService方法,该方法会返回默认的服务类型。通过反射获取类继承的接口,并截取接口的名称(除去I之后的接口名),==只有实现类与接口名称相同的条件下才会注入到服务类型列表中==,这点要注意!对于该方法返回的类型会被添加到服务类型列表中(ServiceTypes)。==默认情况下,实现类本身会注入到服务类型列表中==,从源码中可以分析到:

if (IncludeSelf != false)
{
    serviceList.AddIfNotContains(targetType);
}

targetType就是我们当前注入的类型。在此便注入了类型本身。如此的好处是,可以获取到类的实例,减少了直接实例化而带来依赖。

如此便返回了注入类型的定义及实现列表(serviceTypes),而后遍历这个列表,服务描述符(ServiceDescriptor)的参数ServiceType就是这个列表的项。这个服务描述符便注入到了DI容器中。对于Dependency特性注入的方式,如果参数是ReplaceServices,那么将会替换;如果参数是Register,那么将会直接注入。否则的话,直接添加进DI容器中。

三种注入方式的实现:

  • ExposeServices特性的注入分析
// 接口
public interface IMessageWriter
{
    void Write();
}

// 实现 1
[ExposeServices(typeof(IMessageWriter))]
public class TestMessageTwo : IMessageWriter, ITransientDependency
{
    public void Write()
    {
        Console.WriteLine("TestMessageTwo");
    }
}

// 实现 2
[ExposeServices(typeof(IMessageWriter), typeof(TestMessageOne))]
public class TestMessageOne : IMessageWriter, ITransientDependency
{
    public void Write()
    {
        Console.WriteLine("TestMessageOne");
    }
}

// 注入
_services = new ServiceCollection();
_services.AddType<TestMessageOne>();
_services.AddType<TestMessageTwo>();

// 底层调用:
var serviceTypes = ExposedServiceExplorer.GetExposedServices(type);

abp底层通过ExposedServiceExplorer静态类的GetExposedServices方法确定需要注册类型的定义和实现。这个静态类最后实际上是调用了ExposeServicesAttribute类的构造函数和GetExposedServiceTypes方法确定了服务类型列表。

public ExposeServicesAttribute(params Type[] serviceTypes)
{
    ServiceTypes = serviceTypes ?? new Type[0];
}

public Type[] GetExposedServiceTypes(Type targetType)
{
}
  • Dependency特性注入
//接口
public interface IMyService : ITransientDependency
{
}

//实现
[Dependency(TryRegister = true)]
public class TryRegisterImplOfMyService : IMyService
{
}

//注入
_services = new ServiceCollection();
_services.AddTypes(typeof(TryRegisterImplOfMyService));

//底层调用
ExposeServicesAttribute.GetDefaultServices(typeof(TryRegisterImplOfMyService));

Dependency特性注入在调用GetDefaultServices方法返回服务类型列表,而后在DefaultConventionalRegistrar类的AddType方法中构造服务描述符,注入到DI中。

var serviceDescriptor = ServiceDescriptor.Describe(serviceType, type, lifeTime.Value);

if (dependencyAttribute?.ReplaceServices == true)
{
    services.Replace(serviceDescriptor);
}
else if (dependencyAttribute?.TryRegister == true)
{
    services.TryAdd(serviceDescriptor);
}

备注:
对于Dependency注入和接口方式注入,实现类的类名必须以接口名结尾,否则将不能注入到DI中。

  • 接口注入
//接口
public interface IMyService : ITransientDependency
{
}

//实现 1
public class FirstImplOfMyService : IMyService
{
}

//实现 2
public class SecondImplOfMyService : IMyService
{
}

// 注入
_services = new ServiceCollection();
_services.AddTypes(typeof(FirstImplOfMyService),typeof(SecondImplOfMyService));

//底层调用
ExposeServicesAttribute.GetDefaultServices(typeof(TryRegisterImplOfMyService));

接口方式的注入,也是调用GetDefaultServices返回一个类型列表,然后遍历,保存到服务类型列表中,最后注入到DI容器中。

  • ReplaceServices替换
    如果接口方式注入与Dependency特性注入同时使用且接口相同那么就是另外一种情况,示例:
// 接口
public interface IMyService : ITransientDependency
{
}

// 接口方式实现
public class FirstImplOfMyService : IMyService
{
}

// Dependency特性注入 -- 替换掉 接口方式注入的实现
[Dependency(ReplaceServices = true)]
public class MyServiceReplacesIMyService : IMyService
{
}

// 注入
_services = new ServiceCollection();
_services.AddTypes(typeof(FirstImplOfMyService),typeof(MyServiceReplacesIMyService));

使用ReplaceServices将会使Dependency特性注入替换接口方式的注入。因此只有Dependency特性的注入会被添加到DI容器中。



代码示例:

#region ExposeServices 属性注入
public interface ICalculator { }

public interface ITaxCalculator { }

[ExposeServices(typeof(IService))]
public class TaxCalculator : ICalculator, ITaxCalculator, ITransientDependency
{
}
#endregion

#region 接口约定 模式注入

public interface IService : ITransientDependency { }

public class MyService : IService
{
}

#endregion

#region Dependency特性注入

public interface IMyDependencyTest { }

[Dependency(lifetime: ServiceLifetime.Transient, TryRegister = true)]
public class MyDependencyTest : IMyDependencyTest { }

#endregion

class Program
{
    static void Main(string[] args)
    {
        var services = new ServiceCollection();
        services.AddType(typeof(MyDependencyTest));
        services.AddType(typeof(MyService));
        services.AddType<TaxCalculator>();

        foreach(var service in services)
        {
            Console.WriteLine($"{service.ServiceType} --- {service.ImplementationType} --- {service.Lifetime}");
        }

        Console.Read();
    }
}

除去ExposeServices属性注入外,其余的两种模式必须接口与类名相对应。否则,就只能注入类本身,但是,ExposeServics属性注入不会截取接口名与类名比较。

输出:

原文地址:https://www.cnblogs.com/zhiyong-ITNote/p/12005772.html

时间: 2024-10-18 04:21:39

3. abp依赖注入的分析.md的相关文章

ABP依赖注入

ABP依赖注入 点这里进入ABP系列文章总目录 基于DDD的现代ASP.NET开发框架--ABP系列之6.ABP依赖注入 ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目)”的简称. ABP的官方网站:http://www.aspnetboilerplate.com ABP在Github上的开源项目:https://github.com/aspnetboilerplate 本文由 上海-半冷 提供翻译 什么是依赖注入 如果你已经知道依赖注入的概念,构造函

基于DDD的现代ASP.NET开发框架--ABP系列之6、ABP依赖注入

点这里进入ABP系列文章总目录 基于DDD的现代ASP.NET开发框架--ABP系列之6.ABP依赖注入 ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目)”的简称. ABP的官方网站:http://www.aspnetboilerplate.com ABP在Github上的开源项目:https://github.com/aspnetboilerplate 本文由 上海-半冷 提供翻译 什么是依赖注入 如果你已经知道依赖注入的概念,构造函数和属性注入模式

基于DDD的.NET开发框架 - ABP依赖注入

返回ABP系列 ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目)”的简称. ASP.NET Boilerplate是一个用最佳实践和流行技术开发现代WEB应用程序的新起点,它旨在成为一个通用的WEB应用程序框架和项目模板. ABP的官方网站:http://www.aspnetboilerplate.com ABP官方文档:http://www.aspnetboilerplate.com/Pages/Documents Github上的开源项目:http

Spring学习笔记——Spring依赖注入原理分析

我们知道Spring的依赖注入有四种方式,分别是get/set方法注入.构造器注入.静态工厂方法注入.实例工厂方法注入 下面我们先分析下这几种注入方式 1.get/set方法注入 public class SpringAction { //注入对象springDao private SpringDao springDao; //一定要写被注入对象的set方法 public void setSpringDao(SpringDao springDao) { this.springDao = spri

依赖注入优缺点分析

背景 项目开发要求: 1.增加程序重用 2.模块功能单一 3.方便测试 4.需求变更,减少程序开发 实际应用场景 以两种日志记录和数据库使用两种场景来分析 1.日志记录:有时需要调试分析,需要记录日志信息,这时可以采用输出到控制台.文件.数据库.远程服务器等:假设最初采用输出到控制台,直接在程序中实例化ILogger logger = new ConsoleLogger(),但有时又需要输出到别的文件中,也许关闭日志输出,就需要更改程序,把ConsoleLogger改成FileLogger或者N

[Architect] ABP(现代ASP.NET样板开发框架)(7) 依赖注入

本节目录: 什么是依赖 传统方式的问题 解决方案 构造函数注入 属性注入 注入框架 Abp依赖注入框架 注册 通常注册 帮助接口 自定义注册 解析 构造函数 & 属性注入 IIocResolver & IIocManager 扩展 IShouldInitialize ASP.NET MVC & ASP.NET Web API注入 什么是依赖 如果你已经知道依赖注入思想,构造函数和属性注入模式,你可以跳到下节. 维基:"依赖注入是1种软件设计模式,在这种模式下,1个或多个依

&lt;&lt;ABP框架&gt;&gt; 依赖注入

文档目录 本节内容: 什么时依赖注入 传统方式的问题 解决方案 构造器注入模式 属性注入模式 依赖注入框架 ABP 依赖注入基础 注册依赖 约定注入 辅助接口 自定义/直接 注册 使用IocManager 使用Castle Windsor API 解析 构造器和属性注入 IIocResolver 和 IIocManager 另外 IShouldInitialize 接口 Asp.net Mvc 和 Asp.net Web Api 集成 Asp.net Core 集成 最后提醒 什么是依赖注入 如

2.1 依赖注入

依赖注入 什么是依赖注入 传统方式的问题 解决方案 构造函数注入模式 属性注入模式 依赖注入框架 ABP依赖注入基础设施 注册依赖注入 传统注册 帮助接口 自定义/直接注册 使用IocManager 分析 构造函数和属性注入 IIocResolver,IIocManager和IScopedIocResolver 附加的 IShouldInitialize接口 ASP.NET MVC和ASP.NET Web API集成 ASP.NET Core 集成 最后建议 什么是依赖注入? 如果你已经知道依赖

【架构篇】OCP和依赖注入

描述 本篇文章主要讲解 : (1)OO设计OCP原则: (2)依赖注入引入 (3)依赖注入分析 (4)依赖注入种类 1   内容区 1.1   IOC背景 (1)Ralph E. Johnson & Brian Foote 论文 <Designing Reusable Classes> 早在1988年,Ralph E. Johnson & Brian Foote在论文Designing Reusable Classes中写到: One important characteris