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属性注入不会截取接口名与类名比较。
输出：
