ABP源码分析 - 约定注册(3)

入口

//ConfigureServices
foreach (var module in Modules)
{
    if (module.Instance is AbpModule abpModule)
    {
        if (!abpModule.SkipAutoServiceRegistration)
        {
            // 自动注册服务
            Services.AddAssembly(module.Type.Assembly);
        }
    }

    try
    {
        module.Instance.ConfigureServices(context);
    }
    catch (Exception ex)
    {
        throw new AbpInitializationException($"An error occurred during {nameof(IAbpModule.ConfigureServices)} phase of the module {module.Type.AssemblyQualifiedName}. See the inner exception for details.", ex);
    }
}

public static IServiceCollection AddAssembly(this IServiceCollection services, Assembly assembly)
{
    // 遍历所有的约定注册器，进行服务注册（默认只有一个）
    foreach (var registrar in services.GetConventionalRegistrars())
    {
        registrar.AddAssembly(services, assembly);
    }

    return services;
}

GetConventionalRegistrars

 public static List<IConventionalRegistrar> GetConventionalRegistrars(this IServiceCollection services)
  {
      return GetOrCreateRegistrarList(services);
  }

  private static ConventionalRegistrarList GetOrCreateRegistrarList(IServiceCollection services)
  {
      var conventionalRegistrars = services.GetSingletonInstanceOrNull<IObjectAccessor<ConventionalRegistrarList>>()?.Value;
      if (conventionalRegistrars == null)
      {
          conventionalRegistrars = new ConventionalRegistrarList { new DefaultConventionalRegistrar() }; // 默认约定注册
          services.AddObjectAccessor(conventionalRegistrars);
      }

      return conventionalRegistrars;
  }

registrar.AddAssembly(services, assembly) 相当于 DefaultConventionalRegistrar.AddAssembly。所以直接看DefaultConventionalRegistrar的AddAssembly即可。

DefaultConventionalRegistrar继承于ConventionalRegistrarBase，AddAssembly直接调用ConventionalRegistrarBase.AddAssembly。所以先看ConventionalRegistrarBase

public abstract class ConventionalRegistrarBase : IConventionalRegistrar
{
  public virtual void AddAssembly(IServiceCollection services, Assembly assembly)
  {
      // 查找程序集内所有, 是Class，非抽象，非繁星的所有类型。
      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);

  protected virtual bool IsConventionalRegistrationDisabled(Type type)
  {
      return type.IsDefined(typeof(DisableConventionalRegistrationAttribute), true);
  }

  protected virtual void TriggerServiceExposing(IServiceCollection services, Type implementationType, List<Type> serviceTypes)
  {
      var exposeActions = services.GetExposingActionList();
      if (exposeActions.Any())
      {
          var args = new OnServiceExposingContext(implementationType, serviceTypes);
          foreach (var action in exposeActions)
          {
              action(args);
          }
      }
  }
}

AddType在子类实现，继续看DefaultConventionalRegistrar.AddType

public class DefaultConventionalRegistrar : ConventionalRegistrarBase
    {
    public override void AddType(IServiceCollection services, Type type)
    {
        // 明确禁止的，不注入。即类上加[DisableConventionalRegistration]的
        if (IsConventionalRegistrationDisabled(type))
        {
            return;
        }

        // 获取[Dependency]属性
        var dependencyAttribute = GetDependencyAttributeOrNull(type);
        // 先从Dependency获取，没找到，则从ITransientDependency，ISingletonDependency，IScopedDependency获取
        var lifeTime = GetLifeTimeOrNull(type, dependencyAttribute);

        if (lifeTime == null)
        {
            return;
        }

        // 获取暴露的服务
        var exposedServiceTypes = ExposedServiceExplorer.GetExposedServices(type);

        // 触发服务暴露事件
        TriggerServiceExposing(services, type, exposedServiceTypes);

        // 服务注册
        foreach (var exposedServiceType in exposedServiceTypes)
        {
            var serviceDescriptor = CreateServiceDescriptor(
                type,
                exposedServiceType,
                exposedServiceTypes,
                lifeTime.Value
            );

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

    protected virtual ServiceDescriptor CreateServiceDescriptor(
        Type implementationType,
        Type exposingServiceType,
        List<Type> allExposingServiceTypes,
        ServiceLifetime lifeTime)
    {
        if (lifeTime.IsIn(ServiceLifetime.Singleton, ServiceLifetime.Scoped))
        {
            var redirectedType = GetRedirectedTypeOrNull(
                implementationType,
                exposingServiceType,
                allExposingServiceTypes
            );

            if (redirectedType != null)
            {
                return ServiceDescriptor.Describe(
                    exposingServiceType,
                    provider => provider.GetService(redirectedType),
                    lifeTime
                );
            }
        }

        return ServiceDescriptor.Describe(
            exposingServiceType,
            implementationType,
            lifeTime
        );
    }

    protected virtual Type GetRedirectedTypeOrNull(
        Type implementationType,
        Type exposingServiceType,
        List<Type> allExposingServiceTypes)
    {
        if (allExposingServiceTypes.Count < 2)
        {
            return null;
        }

        if (exposingServiceType == implementationType)
        {
            return null;
        }

        if (allExposingServiceTypes.Contains(implementationType))
        {
            return implementationType;
        }

        return allExposingServiceTypes.FirstOrDefault(
            t => t != exposingServiceType && exposingServiceType.IsAssignableFrom(t)
        );
    }

    protected virtual DependencyAttribute GetDependencyAttributeOrNull(Type type)
    {
        return type.GetCustomAttribute<DependencyAttribute>(true);
    }

    protected virtual ServiceLifetime? GetLifeTimeOrNull(Type type, [CanBeNull] DependencyAttribute dependencyAttribute)
    {
        return dependencyAttribute?.Lifetime ?? GetServiceLifetimeFromClassHierarcy(type);
    }

    protected virtual ServiceLifetime? GetServiceLifetimeFromClassHierarcy(Type type)
    {
        if (typeof(ITransientDependency).GetTypeInfo().IsAssignableFrom(type))
        {
            return ServiceLifetime.Transient;
        }

        if (typeof(ISingletonDependency).GetTypeInfo().IsAssignableFrom(type))
        {
            return ServiceLifetime.Singleton;
        }

        if (typeof(IScopedDependency).GetTypeInfo().IsAssignableFrom(type))
        {
            return ServiceLifetime.Scoped;
        }

        return null;
    }
}

服务暴露

ExposedServiceExplorer

public static class ExposedServiceExplorer
{
    // 默认所有以大写I开头的接口及自身
    private static readonly ExposeServicesAttribute DefaultExposeServicesAttribute =
        new ExposeServicesAttribute
        {
            IncludeDefaults = true,
            IncludeSelf = true
        };

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

ExposeServicesAttribute继承IExposedServiceTypesProvider

public class ExposeServicesAttribute : Attribute, IExposedServiceTypesProvider
{
  public Type[] ServiceTypes { get; }

  public bool IncludeDefaults { get; set; }

  public bool IncludeSelf { get; set; }

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

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

      if (IncludeDefaults) // 默认所有以大写I开头的接口以及自身（如果IncludeSelf=true）
      {
          foreach (var type in GetDefaultServices(targetType))
          {
              serviceList.AddIfNotContains(type);
          }

          if (IncludeSelf)
          {
              serviceList.AddIfNotContains(targetType);
          }
      }
      else if (IncludeSelf)
      {
          serviceList.AddIfNotContains(targetType); // 仅自身
      }

      return serviceList.ToArray();
  }

  // 以大写I开头的接口作为服务
  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;
  }
}