ABPvnext源码分析 (二)：Autofac整合及动态代理

写在前面：

上一篇我们讲了Abp的核心模块，这一篇我们把DI 的serviceProvider替换成Autofac，另外添加动态代理拦截器功能。动态代理指从DI容器获取组件实例时组件实例不是原实例，而是代理实例。代理实例是对原实例进行了封装， 在实例方法前后添加逻辑处理，让获取的对象表现基于应有对象但又有自己的逻辑。举个例子，代理对象方法可以在原方法前后记录时间戳，来分析原方法的处理时长。Abp Core默认使用的是微软官方的DI实现， 那个功能较简单没有代理功能，为了添加动态代理功能，我们把DI实现替换为Autofac，并使用Autofac集成的代理实现方式Castle Core。
集成Autofac，我们需要添加Volo.Abp.Autofac包，这个包本身是Abp模块，其依赖AbpCastleCoreModule模块(Volo.Abp.CatleCore)

namespace Volo.Abp.Autofac
{
[DependsOn(typeof(AbpCastleCoreModule))]
public class AbpAutofacModule : AbpModule
{

}
}

 所以我们添加Volo.Abp.Autofac包并让我们的应用模块DependsOn(typeof(AbpAutofacModule))就自动的把AbpAutofacModule，AbpCastleCoreModule加入到我们的Core中进行模块管理，也就是说那些基于约定的服务会自动注册到我们的abpApplication.Services中，非常的方便。我们在使用Abp中发现好多第三方库都有对应的Volo.Abp.Xxx包也是这个道理，通过把包加入我们Abp的模块管理体系，把各自的服务注册放入各自的包当中，这样我们的应用代码就不需要一个一个的注册这些三方库服务，应用模块直接添加DependsOn(typeof(Xxx))即可。

正菜开始：

Abp集成Autofac非常简单 var application = services.AddApplication<TStartupModule>(option=>options.UseAutofac(););
我们看下UseAutofac这个方法

public static void UseAutofac(this AbpApplicationCreationOptions options)
{
var builder = new ContainerBuilder();
options.Services.AddObjectAccessor(builder);
options.Services.AddSingleton((IServiceProviderFactory<ContainerBuilder>) new AbpAutofacServiceProviderFactory(builder));
}

回忆上一篇最后的代码，由于注册了IServiceProviderFactory<ContainerBuilder>，于是使用该实例serviceProviderFactory的工厂方法serviceProviderFactory.CreateServiceProvider(serviceProviderFactory.CreateBuilder(services)完成DI容器IServiceProvider的创建，这就把DI容器具体的创建逻辑交给了AbpAutofacServiceProviderFactory，非常巧妙的设计。

    public ContainerBuilder CreateBuilder(IServiceCollection services)
        {
            _services = services;

            _builder.Populate(services);

            return _builder;
        }

在AbpAutofacServiceProviderFactory中CreateBuilder调用了方法_builder.Populate(services);注意这里的Populate方法是
Autofac.Extensions.DependencyInjection.AutofacRegistration.Populate,
重新实现了Autofac的同名扩展方法 Microsoft.Extensions.DependencyInjection.AutofacRegistration.Populate

，他和原扩展方法类似但加入了新的逻辑，我们不要引用错误包。

跟踪其实现

    public static void Populate(
                this ContainerBuilder builder,
                IServiceCollection services)
        {
            builder.RegisterType<AutofacServiceProvider>().As<IServiceProvider>();
            builder.RegisterType<AutofacServiceScopeFactory>().As<IServiceScopeFactory>(); //注册IServiceProvider，IServiceScopeFactory

            Register(builder, services);
        }

private static void Register(
                ContainerBuilder builder,
                IServiceCollection services)
        {
            var moduleContainer = services.GetSingletonInstance<IModuleContainer>();  //植入的内容
            var registrationActionList = services.GetRegistrationActionList(); //植入的内容

            foreach (var service in services)
            {
                if (service.ImplementationType != null)
                {
                    // Test if the an open generic type is being registered
                    var serviceTypeInfo = service.ServiceType.GetTypeInfo();
                    if (serviceTypeInfo.IsGenericTypeDefinition) //IsGenericTypeDefinition 这个可以泛型类型判断是否参数实例化了
                    {
                        builder
                            .RegisterGeneric(service.ImplementationType) //注册一个无参数实例化的泛型类型
                            .As(service.ServiceType)
                            .ConfigureLifecycle(service.Lifetime)
                            .ConfigureAbpConventions(moduleContainer, registrationActionList); //这一步是新添加的逻辑  包含拦截器
                    }
                    else
                    {
                        builder
                            .RegisterType(service.ImplementationType)
                            .As(service.ServiceType)
                            .ConfigureLifecycle(service.Lifetime)
                            .ConfigureAbpConventions(moduleContainer, registrationActionList);  //这一步是新添加的逻辑  包含拦截器
                    }
                }
                else if (service.ImplementationFactory != null)
                {
                    var registration = RegistrationBuilder.ForDelegate(service.ServiceType, (context, parameters) =>
                    {
                        var serviceProvider = context.Resolve<IServiceProvider>();
                        return service.ImplementationFactory(serviceProvider);
                    })
                    .ConfigureLifecycle(service.Lifetime)
                    .CreateRegistration();
                    //TODO: ConfigureAbpConventions ?

                    builder.RegisterComponent(registration);
                }
                else
                {
                    builder
                        .RegisterInstance(service.ImplementationInstance)
                        .As(service.ServiceType)
                        .ConfigureLifecycle(service.Lifetime);
                }
            }
        }

其主要逻辑是把serives中每一个服务注册在builder中注册。其中对每个服务还调用了ConfigureAbpConventions(moduleContainer, registrationActionList)

        public static IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> ConfigureAbpConventions<TLimit, TActivatorData, TRegistrationStyle>(  //builder.Populate(services)植入的ABP部分
                this IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> registrationBuilder, 
                IModuleContainer moduleContainer, 
                ServiceRegistrationActionList registrationActionList)
            where TActivatorData : ReflectionActivatorData
        {
            var serviceType = registrationBuilder.RegistrationData.Services.OfType<IServiceWithType>().FirstOrDefault()?.ServiceType;
            if (serviceType == null)
            {
                return registrationBuilder; //直接返回
            }

            var implementationType = registrationBuilder.ActivatorData.ImplementationType;
            if (implementationType == null)
            {
                return registrationBuilder; //没有实现类型 直接返回
            }

            registrationBuilder = registrationBuilder.EnablePropertyInjection(moduleContainer, implementationType); //当前type程序集包含Abp模块则开启属性注入
            registrationBuilder = registrationBuilder.InvokeRegistrationActions(registrationActionList, serviceType, implementationType); //调用registration HOOK  如果有拦截器，则添加拦截器

            return registrationBuilder;
        }

上面serviceType是Autofac的registrationBuilder添加的元数据我们不必理会，implementationType是组件（服务实例）类型。重点我们跟踪下InvokeRegistrationActions

        private static IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> InvokeRegistrationActions<TLimit, TActivatorData, TRegistrationStyle>(this IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> registrationBuilder, ServiceRegistrationActionList registrationActionList, Type serviceType, Type implementationType) 
            where TActivatorData : ReflectionActivatorData
        {
            var serviceRegistredArgs = new OnServiceRegistredContext(serviceType, implementationType);

            foreach (var registrationAction in registrationActionList)  //执行每一个registrationAction
            {
                registrationAction.Invoke(serviceRegistredArgs);
            }

            if (serviceRegistredArgs.Interceptors.Any())  //IMPORTANT 如果有拦截器，则添加拦截器
            {
                registrationBuilder = registrationBuilder.AddInterceptors(
                    serviceType,
                    serviceRegistredArgs.Interceptors
                );
            }

            return registrationBuilder;
        }

        private static IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> AddInterceptors<TLimit, TActivatorData, TRegistrationStyle>(
            this IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> registrationBuilder, 
            Type serviceType,
            IEnumerable<Type> interceptors)
            where TActivatorData : ReflectionActivatorData
        {
            if (serviceType.IsInterface)
            {
                registrationBuilder = registrationBuilder.EnableInterfaceInterceptors(); //开启接口拦截器
            }
            else
            {
                (registrationBuilder as IRegistrationBuilder<TLimit, ConcreteReflectionActivatorData, TRegistrationStyle>)?.EnableClassInterceptors(); //开启类拦截器
            }

            foreach (var interceptor in interceptors)
            {
                registrationBuilder.InterceptedBy( //https://www.cnblogs.com/stulzq/p/8547839.html autofac的动态代理  Autofac.Extras.DynamicProxy程序集
                    typeof(CastleAbpInterceptorAdapter<>).MakeGenericType(interceptor) //范型类型实例化  ABP拦截器转CASTLE拦截器 
                );
            }

            return registrationBuilder;
        }

动态代理实现使用的是Castle.Core的api中  

public static IRegistrationBuilder<TLimit, TActivatorData, TStyle> InterceptedBy<TLimit, TActivatorData, TStyle>(
    this IRegistrationBuilder<TLimit, TActivatorData, TStyle> builder,
    params Type[] interceptorServiceTypes)

其中interceptorServiceTypes为IInterceptor的类型的Type。我们Abp使用的是IAbpInterceptor。 CastleAbpInterceptorAdapter类就是实现从IAbpInterceptor到IInterceptor的适配。

       public void Intercept(IInvocation invocation) //拦截器业务逻辑  Castle 的拦截器有一个 Intercept() 方法，该方法将在被拦截方法执行的时候触发。
        {
            var proceedInfo = invocation.CaptureProceedInfo();

            var method = invocation.MethodInvocationTarget ?? invocation.Method;// MethodInvocationTarget目标类方法的methodInfo, Method代理方法的methodInfo 

            if (method.IsAsync())
            {
                InterceptAsyncMethod(invocation, proceedInfo);
            }
            else
            {
                InterceptSyncMethod(invocation, proceedInfo);
            }
        }

     private void InterceptSyncMethod(IInvocation invocation, IInvocationProceedInfo proceedInfo)
        {
            _abpInterceptor.Intercept(new CastleAbpMethodInvocationAdapter(invocation, proceedInfo));
        }

看一下CastleAbpInterceptorAdapter类型的Intercept方法，又调用的是_abpInterceptor.Intercept方法。

由上面可以看出。我们是通过CastleAbpInterceptorAdapter完成从castle core拦截器到abp拦截器的适配。 我们定义好apb拦截器，abp自动为我们生成对应的castle core拦截器进行适配，进行拦截时castle core拦截器调用我们的apb拦截器的拦截接口void Intercept(IAbpMethodInvocation invocation);

以上是abp拦截器的实现机制。通过CastleAbpInterceptorAdapter适配层完成调用castle core拦截器到间接调用 abp拦截器的转换。