.net MVC, webAPI,webForm集成steeltoe+springcloud实现调用服务中心服务的总结

开始之前，如果没接触过Autofac的，可以移步到Autofac官方示例学习一下怎么使用：https://github.com/autofac/Examples

.net 下集成steeltoe进行微服务客户端的注册与发现均需要使用Autofac依赖注入方式进行，且MVC,WebAPI,webForm三种项目类型所需要依赖扩展库都不一样，经过两周的踩坑，现在做个粗浅的总结吧！

以下是steeltoe官方文档给出的参考：

App Type	Package	Description
Console/ASP.NET 4.x	Steeltoe.Discovery.EurekaBase	Base functionality. No dependency injection.
ASP.NET Core	Steeltoe.Discovery.ClientCore	Includes base. Adds ASP.NET Core dependency injection.
ASP.NET 4.x with Autofac	Steeltoe.Discovery.ClientAutofac	Includes base. Adds Autofac dependency injection.

App Type	Package	Description
Console/ASP.NET 4.x	Pivotal.Discovery.EurekaBase	Base functionality. No dependency injection.
ASP.NET Core	Pivotal.Discovery.ClientCore	Includes base. Adds ASP.NET Core dependency injection.
ASP.NET 4.x with Autofac	Pivotal.Discovery.ClientAutofac	Includes base. Adds Autofac dependency injection.

经过两周的各自尝试，基于Framework4.5.2+的MVC,WebAPI,webForm等项目基本都是用Autofac方式进行服务注册和调用方法的引用，所以所需要引入的扩展库基本都是以Autofac结尾，比如上面的Steeltoe.Discovery.ClientAutofac和Pivotal.Discovery.ClientAutofac。

另外我们还需要用到的类库包括：

Steeltoe.Common.Autofac

这个类库包含了服务发现与调用的方法。

三种类型的项目目录结构是不同的，MVC与WebAPI都是有ApiController接口的，可以自己构建controller集成接口，然后直接用Autofac的依赖注入方式进行微服务调用方法的实现，代码可参考如下：

 public class ValuesController : ApiController
    {
        private readonly DiscoveryHttpClientHandler _handler;
        
        public ValuesController(IDiscoveryClient client, ILoggerFactory logFactory)//这里就是注入依赖了
        {
            _handler = new DiscoveryHttpClientHandler(client);
        }

       
        // GET api/values
        public async Task<string> Get()
        {

            var client = new HttpClient(_handler, false);
           
            return await client.GetStringAsync("http://java-server/hi?name=demo");
        }

        // GET api/values/5
        public string Get(int id)
        {
            String re = id.ToString;
           
            return re;
          
        }

        // POST api/values
        public void Post([FromBody]string value)
        {
        }

        // PUT api/values/5
        public void Put(int id, [FromBody]string value)
        {
        }

        // DELETE api/values/5
        public void Delete(int id)
        {
        }
    }

　　

那么webForm怎么调用微服务的方法呢？这就需要我们自己写一个服务类，在类中实现自定义接口和用依赖注入的方式对steeltoe提供的方法调用，然后在Page里依赖注入自己的这个类了。参考代码：

自定义服务接口类IFetchService.cs：

 public interface IFetchService
    {
        Task<string> RandomFortuneAsync();
    }

自定义服务类并完成steeltoe接口方法的依赖注入与实现FetchService.cs:

public class FetchService : IFetchService
    {
        DiscoveryHttpClientHandler _handler;

        private const string RANDOM_FORTUNE_URL = "http://java-service/hi?name=tian";
        private ILogger<FetchService> _logger;

        public FetchService(IDiscoveryClient client, ILoggerFactory logFactory = null)
        {
            _handler = new DiscoveryHttpClientHandler(client);
            _logger = logFactory?.CreateLogger<FetchServise>();
        }

        public async Task<string> RandomFortuneAsync()
        {
            _logger?.LogInformation("RandomFortuneAsync");
            var client = GetClient();
            return await client.GetStringAsync(RANDOM_FORTUNE_URL);

        }

        private HttpClient GetClient()
        {
            var client = new HttpClient(_handler, false);
            return client;
        }
    }

接下来，最重要的步骤，在程序全局文件Global.asax中进行依赖注入的配置，这里引用到的Autofac扩展库也是有区别：

MVC直接引用Autofac即可

WebAPI引用的是Autofac.WebApi2

webForm引用的是Autofac.Web

这里主要写下 webForm的配置代码：

 public class Global : System.Web.HttpApplication, IContainerProviderAccessor
    {
        // 持有应用程序容器的提供程序
        static IContainerProvider _containerProvider;

        //将被`Autofac HttpModules`用来解析和注入依赖关系的实例属性。
        public IContainerProvider ContainerProvider
        {
            get { return _containerProvider; }
        }

        protected void Application_Start(object sender, EventArgs e)
        {
            ApplicationConfig.RegisterConfig("development");
            //var config = GlobalConfiguration.Configuration;
            var builder = new ContainerBuilder();

            // Add Microsoft Options to container
            builder.RegisterOptions();

            // Add Microsoft Logging to container
            builder.RegisterLogging(ApplicationConfig.Configuration);

            // Add Console logger to container
            builder.RegisterConsoleLogging();

            //// Register all the controllers with Autofac
            builder.RegisterAssemblyModules(Assembly.GetExecutingAssembly());
           

            // Register IDiscoveryClient, etc.
            builder.RegisterDiscoveryClient(ApplicationConfig.Configuration);

            // Register FortuneService
            

            builder.RegisterType<FetchServise>().As<IFetchServise>();//MVC,webAPI也是这么写
          
           

            // Create the Autofac container
            var container = builder.Build();

            _containerProvider = new ContainerProvider(container);

            //config.DependencyResolver = new AutofacWebApiDependencyResolver(container);//WebAPI创建容器
            //DependencyResolver.SetResolver(new AutofacDependencyResolver(container));//MVC创建容器

           
            container.StartDiscoveryClient();

            
        }

        protected void Session_Start(object sender, EventArgs e)
        {

        }

        protected void Application_BeginRequest(object sender, EventArgs e)
        {

        }

        protected void Application_AuthenticateRequest(object sender, EventArgs e)
        {

        }

        protected void Application_Error(object sender, EventArgs e)
        {

        }

        protected void Session_End(object sender, EventArgs e)
        {

        }

        protected void Application_End(object sender, EventArgs e)
        {

        }
    }

　　

　然后在Page代码页中依赖注入实现我们自定义的接口方法：

 public partial class WebForm2 : System.Web.UI.Page
    {
        public IFetchServise fetch { get; set; }
        protected void Page_Load(object sender, EventArgs e)
        {
            this.Page.RegisterAsyncTask(new PageAsyncTask(GetName));
        }

        private async Task GetName()
        {
            Label1.Text = await fetch.RandomFortuneAsync();
        }
    }