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

時間  2019-12-09
標籤 abp 依賴 注入 分析 欄目 設計模式 简体版
原文   原文鏈接
abp依賴注入的原理剖析

請先移步參考 [Abp vNext 源碼分析] - 3. 依賴注入與攔截器 本文此篇文章的補充和完善。html

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==中：ide

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接口定義及實現：code

//定義：
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)。==默認狀況下，實現類自己會注入到服務類型列表中==，從源碼中能夠分析到：htm

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

targetType就是咱們當前注入的類型。在此便注入了類型自己。如此的好處是，能夠獲取到類的實例，減小了直接實例化而帶來依賴。blog

如此便返回了注入類型的定義及實現列表(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屬性注入不會截取接口名與類名比較。

輸出：

img

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程