搜索[学习]结果-低调大师优秀个人博客

精选列表

搜索[学习]，共10000篇文章

学习ASP.NET Core, 怎能不了解请求处理管道[6]: 管道是如何随着WebHost的开启被构建出来的？

注册的服务器和中间件共同构成了ASP.NET Core用于处理请求的管道，这样一个管道是在我们启动作为应用宿主的WebHost时构建出来的。要深刻了解这个管道是如何被构建出来的，我们就必须对WebHost和它的创建者WebHostBuilder这个重要的对象具有深刻的理解。[本文已经同步到《ASP.NET Core框架揭秘》之中] 目录一、WebHost WebHostOptions 构建管道的三个步骤二、WebHostBuilder WebHost的创建几个常用的扩展方法一、WebHost 顾名思义，WebHost被作为Web应用的宿主，应用的启动和关闭都是通过启动或者关闭对应WebHost的方式来实现的。这里所说的WebHost是对所有实现了IWebHost接口的所有类型及其对应对象的统称。IWebHost接口具有如下三个基本成员，其中Start方法用于启动宿主程序。我们编程中通常会调用它的一个扩展方法Run来启动WebHost，实际上背后调用的其实还是这个Start方法。当WebHost启动之后，注册的服务器变开始了针对请求的监听，所以WebHost需要具有与服务器相关的一些特性，这些特性就保存在通过属性ServerFeatures返回的特性集合中。 1: public interface IWebHost : IDisposable 2: { 3: void Start(); 4: IFeatureCollection ServerFeatures { get; } 5: IServiceProvider Services { get; } 6: } 我们多次提到ASP.NET Core管道在构建和进行请求处理过程中广泛使用到了依赖注入。依赖注入只要体现在：ASP.NET Core框架以及应用程序会根据需要注册一系列的服务，这些服务会在WebHost启动的时候被用来创建一个ServiceProvider对象，管道在进行请求处理过程所需的任何服务对象都可以从这个ServiceProvider对象中获取。IWebHost接口的Services属性返回的就是这么一个ServiceProvider对象。具有如下定义的WebHost类是对IWebHost接口的默认实现，我们默认使用的WebHost就是这么一个对象。一般来说，WebHost是通过对应的WebHostBuilder创建的，当后者通过调用构造函数创建一个WebHost对象的时候，需要提供四个参数，它们分别是直接注册到WebHostBuilder上面的服务（appServices）和由此创建的ServiceProvider（hostingServiceProvider），针对WebHost的选项设置（options）和配置（config）。 1: public class WebHost : IWebHost 2: { 3: public IFeatureCollection ServerFeatures { get; } 4: public IServiceProvider Services { get; } 5: 6: public WebHost( 7: IServiceCollection appServices, 8: IServiceProvider hostingServiceProvider, 9: WebHostOptions options, 10: IConfiguration config); 11: 12: public void Dispose(); 13: public void Start(); 14: } WebHostOptions 顾名思义，一个WebHostOptions对象为构建的WebHost对象提供一些预定义的选项设置。这些选项设置很重要，它们决定由WebHost构建的管道进行内容加载以及异常处理等方面的行为。至于它具体携带着哪些选项设置，我们只需要看看这个类型具有怎样的属性成员。 1: public class WebHostOptions 2: { 3: public string ApplicationName { get; set; } 4: public bool DetailedErrors { get; set; } 5: public bool CaptureStartupErrors { get; set; } 6: public string Environment { get; set; } 7: public string StartupAssembly { get; set; } 8: public string WebRoot { get; set; } 9: public string ContentRootPath { get; set; } 10: 11: public WebHostOptions() 12: public WebHostOptions(IConfiguration configuration) 13: } 如下面的代码片段所示，WebHostOptions具有七个属性成员。这些属性都是可读可写的，我们可以调用默认无参构造函数创建一个空的WebHostOptions对象，通过手工为这些属性赋值的方式来设置对应的选项。除此之外，我们可以将这些选项设置定义在配置中，并利用对应的Configuration对象来创建一个WebHostOptions对象。构建管道的三个步骤一般我们开启了作为应用宿主的WebHost，由注册的服务器和中间件构成的整个管道被构建起来，服务器开始绑定到基地址进行请求的监听。接下来我们就来着重聊聊WebHost在开启过程中都做了些什么。总的来说，WebHost的整个开启过程大体上可以分为如下三个步骤：注册服务：获取Startup对象并利用它完成服务的注册。中间件注册：利用获取的Startup对象完成中间件的注册。设置并开启服务器：获取注册到WebHostBuilder上的服务器并为之设置监听地址，最后启动服务器。接下来我们按照这个步骤定义一个同名的类型来模式真实WebHost的实现逻辑。如下面的代码片段所示，这个模拟的WebHost和真正的WebHost的构造函数具有完全一致的参数列表，我们定义了对应的字段来保存这些参数值。除此之外，我们会创建一个ApplicationLifetime对象并将其注册到提供个ServiceCollection，在WebHost开启和关闭之后我们会利用它发送相应的通知。 1: public class WebHost : IWebHost 2: { 3: private IServiceCollection _appServices; 4: private IServiceProvider _hostingServiceProvider; 5: private WebHostOptions _options; 6: private IConfiguration _config; 7: private ApplicationLifetime _applicationLifetime; 8: 9: public WebHost(IServiceCollection appServices, IServiceProvider hostingServiceProvider, WebHostOptions options, IConfiguration config) 10: { 11: _appServices = appServices; 12: _hostingServiceProvider = hostingServiceProvider; 13: _options = options; 14: _config = config; 15: _applicationLifetime = new ApplicationLifetime(); 16: appServices.AddSingleton<IApplicationLifetime>(_applicationLifetime); 17: } 18: … 19: } 20: 我们接下来看WebHost除Start方法之外的其他成员的定义。只读属性Services返回一个ServiceProvider对象，我们将在完成所有服务注册工作之后利用ServiceCollection对象创建这个对象，所以只要实现具有相关的服务注册，我们就能够利用它得到对应的服务对象。只读属性ServerFeatures返回服务器的特性集合，而服务器本身则直接利用上述这个ServiceProvider获得。当MyWebHost对象因Dispose方法的调用而被回收之后，我们会对ServiceProvider实施回收工作。在实施回收的前后，我们利用ApplicationLifetime发送相应的信号。 1: public class WebHost : IWebHost 2: { 3: private ApplicationLifetime _applicationLifetime; 4: public IServiceProvider Services { get; private set; } 5: public IFeatureCollection ServerFeatures 6: { 7: get { return this.Services.GetRequiredService<IServer>()?.Features; } 8: } 9: public void Dispose() 10: { 11: _applicationLifetime.StopApplication(); 12: (this.Services as IDisposable)?.Dispose(); 13: _applicationLifetime.NotifyStopped(); 14: } 15: } 16: 真正开启WebHost的实现体现在如下所示的代码片段中。我们直接利用WebHostBuilder提供ServiceProvider获取一个Startup对象，并调用其ConfigureServices方法完成服务的注册，作为参数的ServiceCollection对象也是由WebHostBuilder提供的。当所有的服务注册工作完成之后，我们利用最新的ServiceCollection对象创建一个ServiceProvider对象，并利用此对象对Services属性进行赋值。在后续管道构建过程，以及管道在处理请求过程中所使用的服务均是从这个ServiceProvider中提取的。 1: public class WebHost : IWebHost 2: { 3: private IServiceCollection _appServices; 4: private IServiceProvider _hostingServiceProvider; 5: private WebHostOptions _options; 6: private IConfiguration _config; 7: private ApplicationLifetime _applicationLifetime; 8: 9: public void Start() 10: { 11: //注册服务 12: IStartup startup = _hostingServiceProvider.GetRequiredService<IStartup>(); 13: this.Services = startup.ConfigureServices(_appServices); 14: 15: //注册中间件 16: Action<IApplicationBuilder> configure = startup.Configure; 17: configure = this.Services.GetServices<IStartupFilter>().Reverse().Aggregate(configure, (next, current) => current.Configure(next)); 18: IApplicationBuilder appBuilder = this.Services.GetRequiredService<IApplicationBuilder>(); 19: configure(appBuilder); 20: 21: //为服务器设置监听地址 22: IServer server = this.Services.GetRequiredService<IServer>(); 23: IServerAddressesFeature addressesFeature = server.Features.Get<IServerAddressesFeature>(); 24: if (null != addressesFeature && !addressesFeature.Addresses.Any()) 25: { 26: string addresses = _config["urls"] ?? "http://localhost:5000"; 27: foreach (string address in addresses.Split(';')) 28: { 29: addressesFeature.Addresses.Add(address); 30: } 31: } 32: 33: //启动服务器 34: RequestDelegate application = appBuilder.Build(); 35: ILogger logger = this.Services.GetRequiredService <ILogger<MyWebHost>>(); 36: DiagnosticSource diagnosticSource = this.Services.GetRequiredService<DiagnosticSource>(); 37: IHttpContextFactory httpContextFactory = this.Services.GetRequiredService<IHttpContextFactory>(); 38: server.Start(new HostingApplication(application, logger, diagnosticSource, httpContextFactory)); 39: 40: //对外发送通知 41: _applicationLifetime.NotifyStarted(); 42: } 43: } 44: 当服务注册结束并成功创建出ServiceProvider之后，接下来的工作就是注册中间件了。通过上面的介绍我们知道，中间件的注册既可以利用Startup来完成，也可以利用注册的StartupFilter来实现，为此我们利用最新构建的ServiceProvider获取所有注册的StartupFilter，并结合之前提取的Startup对象创建了一个用于注册中间的委托链（最终体现为一个Action<IApplicationBuilder>对象）。我们最终执行这个委托链完成了对所有中间件的注册，执行过程中作为参数的ApplicationBuilder对象同样是通过ServiceProvider提取出来的。再此之后，我们利用ServiceProvider提取出注册在WebHostBuiler上的服务器。如果服务器的监听地址尚未指定，我们在开启服务器之前必须指定。通过前面对服务器的介绍，我们知道监听地址保存在服务器的一个名为ServerAddressesFeature的特性中，而用户设置的监听地址则保存在配置中，对应的Key为“urls”，所以我们将从配置中提取的地址列表添加到ServerAddressesFeature特性中。如果监听地址不曾配置，我们会为之指定一个默认的地址，即“http://localhost:5000”。一切就绪的服务器通过调用Start方法开启，该方法接收一个HttpApplication对象作为参数。通过前面的介绍我们知道这个HttpApplication对象可以视为对所有注册中间件和应用的封装，服务器将接收到的请求传递给它作后续处理。我们默认创建的HttpApplication是一个HostingApplication对象，而构建过程中需要提供四个对象，它们分别是代表中间件链表的RequestDelegate对象，用于日志记录和诊断的Logger和DiagnosticSource，以及用来创建HTTP上下文的HttpContextFactory，除了第一个通过调用ApplicationBuilder的Build方法创建之外，其余的都是通过ServiceProvider提取的。在服务器被成功开启之后，我们利用ApplicationLifetime对外发送应用启动的通知。二、WebHostBuilder 顾名思义,WebHostBuilder就是WebHost的创建者，所谓的WebHostBuilder是对所有实现了IWebHostBuilder接口的类型以及对应对象的统称。如下面的代码片段所示，IWebHostBuilder接口除了用来创建WebHost的核心方法Build之外，还具有其他一些额外的方法。 1: public interface IWebHostBuilder 2: { 3: IWebHost Build(); 4: IWebHostBuilder ConfigureServices(Action<IServiceCollection> configureServices); 5: IWebHostBuilder UseLoggerFactory(ILoggerFactory loggerFactory); 6: IWebHostBuilder ConfigureLogging(Action<ILoggerFactory> configureLogging); 7: string GetSetting(string key); 8: IWebHostBuilder UseSetting(string key, string value); 9: } ConfigureServices方法让我们可以直接将我们所需的服务注册到WebHostBuilder上面。ASP.NET Core具有两种注册服务的途径，一种是将服务注册实现在启动类的ConfigureServices方法中，另一种服务注册的方式就是调用这个方法。对于前者，服务实际上是在开启WebHost的时候调用Startup对象的ConfigureServices进行注册的；至于后者，注册的服务将直接提供给创建的WebHost。UseLoggerFactory 和ConfigureLogging方法与日志记录有关，前者帮助我们设置一个默认的LoggerFactory，后者则对LoggerFactory进行相关设置，最重要的设置就是添加相应的LoggerProvider。GetSetting和UseSetting以键值对的形式获取和设置一些配置。 WebHost的创建 ASP.NET Core定义了一个名为WebHostBuilder的类型作为对IWebHostBuilder接口的默认实现，我们同样采用定义模拟类型的形式来说明WebHostBuilder创建WebHost的实现原理。我们将这个模拟类型命名为，如下的代码片段展示了除Build方法之外的所有成员的定义。 1: public class WebHostBuilder : IWebHostBuilder 2: { 3: private List<Action<ILoggerFactory>> _configureLoggingDelegates = new List<Action<ILoggerFactory>>(); 4: private List<Action<IServiceCollection>> _configureServicesDelegates = new List<Action<IServiceCollection>>(); 5: private ILoggerFactory _loggerFactory = new LoggerFactory(); 6: private IConfiguration _config = new ConfigurationBuilder().AddEnvironmentVariables("ASPNETCORE_").Build(); 7: 8: public IWebHostBuilder ConfigureLogging(Action<ILoggerFactory> configureLogging) 9: { 10: _configureLoggingDelegates.Add(configureLogging); 11: return this; 12: } 13: 14: public IWebHostBuilder ConfigureServices(Action<IServiceCollection> configureServices) 15: { 16: _configureServicesDelegates.Add(configureServices); 17: return this; 18: } 19: 20: public string GetSetting(string key) 21: { 22: return _config[key]; 23: } 24: 25: public IWebHostBuilder UseLoggerFactory(ILoggerFactory loggerFactory) 26: { 27: _loggerFactory = loggerFactory; 28: return this; 29: } 30: 31: public IWebHostBuilder UseSetting(string key, string value) 32: { 33: _config[key] = value; 34: return this; 35: } 36: ... 37: } 38: 如上面的代码片段所示，我们创建了一个Configuration类型的字段（_config）来体现应用默认使用的配置，它默认采用环境变量（用于过滤环境变量的前缀为“ASPNETCORE_”）作为配置源，GetSetting和UseSetting方法操作的均为这个对象。另一个字段_loggerFactory表示默认使用的LoggerFactory，UseLoggerFactory方法指定的LoggerFactory用来对这个字段进行赋值。ConfigureLogging和ConfigureServices方法具有类似的定义，调用它们提供的委托对象都保存在一个集合之中，以待后用。我们实现WebHostBuilder的核心方法Build来创建一个WebHost对象。通过上面的定义我们知道一个WebHostBuilder能够最终运行起来需要从ServiceProvider提供很多必需的服务，而这些服务最初都必需通过WebHostBuilder来注册，所以Build方法除了调用构造函数创建并返回一个WebHost对象之外，余下的工作就是注册这些必需的服务。我们可以简单列一列那些服务是必需的，如下所示的是一个不完全列表。用于注册服务和中间件的Startup对象。用来创建Logger的LoggerFactory对象构建中间件链表的ApplicationBuilder对象创建HTTP上下文的HttpContextFactory对象用户实现诊断功能的DiagnosticSource对象用来保存承载环境的HostingEnvironment对象如下所示的定义在WebHostBuilder中的Build方法的定义。在这个方法中，我们按照上述这些系统服务以及用户服务（通过调用ConfigureServices方法注册的服务）的注册之后，创建并返回了一个WebHost对象。 1: public class WebHostBuilder : IWebHostBuilder 2: { 3: private List<Action<ILoggerFactory>> _configureLoggingDelegates = new List<Action<ILoggerFactory>>(); 4: private List<Action<IServiceCollection>> _configureServicesDelegates = new List<Action<IServiceCollection>>(); 5: private ILoggerFactory _loggerFactory = new LoggerFactory(); 6: private IConfiguration _config = new ConfigurationBuilder().AddInMemoryCollection().Build(); 7: 8: public IWebHost Build() 9: { 10: //根据配置创建WebHostOptions 11: WebHostOptions options = new WebHostOptions(_config); 12: 13: //注册服务IStartup 14: IServiceCollection services = new ServiceCollection(); 15: if (!string.IsNullOrEmpty(options.StartupAssembly)) 16: { 17: Type startupType = StartupLoader.FindStartupType(options.StartupAssembly, options.Environment); 18: if (typeof(IStartup).GetTypeInfo().IsAssignableFrom(startupType)) 19: { 20: services.AddSingleton(typeof(IStartup), startupType); 21: } 22: else 23: { 24: services.AddSingleton<IStartup>(_ => new ConventionBasedStartup(StartupLoader.LoadMethods(_, startupType, options.Environment))); 25: } 26: } 27: 28: //注册ILoggerFactory 29: foreach (var configureLogging in _configureLoggingDelegates) 30: { 31: configureLogging(_loggerFactory); 32: } 33: services.AddSingleton<ILoggerFactory>(_loggerFactory); 34: 35: //注册服务IApplicationBuilder，DiagnosticSource和IHttpContextFactory 36: services 37: .AddSingleton<IApplicationBuilder>(_ => new ApplicationBuilder(_)) 38: .AddSingleton<DiagnosticSource>(new DiagnosticListener("Microsoft.AspNetCore")) 39: .AddSingleton<IHttpContextFactory, HttpContextFactory>() 40: .AddOptions() 41: .AddLogging() 42: .AddSingleton<IHostingEnvironment, HostingEnvironment>() 43: .AddSingleton<ObjectPoolProvider, DefaultObjectPoolProvider>(); 44: 45: //注册用户调用ConfigureServices方法设置的服务 46: foreach (var configureServices in _configureServicesDelegates) 47: { 48: configureServices(services); 49: } 50: 51: //创建MyWebHost 52: return new WebHost(services, services.BuildServiceProvider(), options, _config); 53: } 54: } 55: 虽然上面提供的WebHost和WebHostBuilder仅仅是WebHost和WebHostBuilder的模拟类。为了让读更加易于理解，我们刻意剔除了很多细节的东西，但是两者从实现原理角度来讲是完全一致的。不仅如此，我们自定义的这两个类型甚至可以执行运行的。几个常用的扩展方法 WebHostBuilder在内部使用了配置，环境变量是默认采用的配置源，它的两个方法GetSetting和UseSetting以键值对的形式实现对配置项的获取和设置。除了UseSettings方法之外，我们还可以调用WebHostBuilder如下这个扩展方法UseConfiguration来进行配置项的设置，这个方法会将保存在指定Configuration中的配置原封不动地拷贝过来，它最终调用的依旧是UseSettings方法。 1: public static class HostingAbstractionsWebHostBuilderExtensions 2: { 3: public static IWebHostBuilder UseConfiguration(this IWebHostBuilder hostBuilder, IConfiguration configuration); 4: } WebHostBuilder在创建WebHost的时候需要提供一个WebHostOptions对象，该对象最初是根据当前配置创建的。为了方便设置针对WebHostOptions的配置项，ASP.NET Core为我们定义了如下一系列的扩展方法，这些方法最终调用的也是这个UseSettings方法。 1: public static class HostingAbstractionsWebHostBuilderExtensions 2: { 3: public static IWebHostBuilder CaptureStartupErrors(this IWebHostBuilder hostBuilder, bool captureStartupErrors); 4: public static IWebHostBuilder UseContentRoot(this IWebHostBuilder hostBuilder, string contentRoot); 5: public static IWebHostBuilder UseEnvironment(this IWebHostBuilder hostBuilder, string environment); 6: public static IWebHostBuilder UseStartup(this IWebHostBuilder hostBuilder, string startupAssemblyName); 7: public static IWebHostBuilder UseWebRoot(this IWebHostBuilder hostBuilder, string webRoot); 8: public static IWebHostBuilder UseUrls(this IWebHostBuilder hostBuilder, params string[] urls); 9: } 10: 虽然服务器是必需的，但是WebHostBuilder并没有专门定义一个用于注册服务的方法，这是因为服务器也是作为一项基本的服务进行注册的。但是我们可以调用如下一个扩展方法UseServer实现针对服务器的注册，至于另一个扩展方法UseUrls，我们可以调用它来为注册的服务器设置监听地址。 1: public static class HostingAbstractionsWebHostBuilderExtensions 2: { 3: public static IWebHostBuilder UseServer(this IWebHostBuilder hostBuilder, IServer server); 4: public static IWebHostBuilder UseUrls(this IWebHostBuilder hostBuilder, params string[] urls); 5: } 作者：蒋金楠微信公众账号：大内老A 微博： www.weibo.com/artech 如果你想及时得到个人撰写文章以及著作的消息推送，或者想看看个人推荐的技术资料，可以扫描左边二维码（或者长按识别二维码）关注个人公众号（原来公众帐号蒋金楠的自媒体将会停用）。本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。原文链接

2017-10-23

9月21日云栖精选夜读：专访新浪微博黄波：千人千面，机器学习赋能用户信息流消费

热点热议专访新浪微博黄波：千人千面，机器学习赋能用户信息流消费作者：仁太发表在：云栖大会未来 3~5 年内，哪个方向的机器学习人才最紧缺？

2017-09-20

中国人工智能学会通讯——机器学习在商务智能中的创新应用 1.2 基于人工智能的商业分析应用

无需对机器进行重新编程，机器通过产品学习。产品周转到一个设备之后，机器会告诉设备要对它进行什么操作，所有这些流程都是通过协作来完成的。

2017-08-31

从入门到精通：我与鸿蒙的成长纪实与实战之路——一名全栈开发者的鸿蒙学习、实战与创新之旅

在鸿蒙的官方文档和 CodeLabs 指导下，我开始系统性学习。

2025-12-23

☕【Java技术指南】「Java8技术盲区」在奔向Java13的同时，也让我们仔细研究一下Stream的学习认知！

Java8的功能之最要说到Java8的技术体系中，最让人难以忘怀的功能，那非Lambda和Stream莫属了。两者结合操作，达成天作之合，有点势不可挡。它主要用于补充集合类，它的强大，相信用过它的朋友，能明显的感受到，不用使用for循环就能对集合作出很好的操作。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。元素流在管道中经过中间操作(intermediate operation)的处理，最后由最终操作(terminal operation)得到前面处理的结果。 Stream流 Stream流处理的添加是Java 8中的主要新功能之一，要理解这些需要对Java8（lambda表达式、方法引用）有基本的工作知识。 Stream功能介绍首先，应将Java 8的Stream流与Java原本的 I / O流（例如：FileInputStream等）区分开，两者在本质角度而言是两个东西简而言之，流是数据源周围的包装器，使我们能够使用该数据源进行操作，并使批量处理方便快捷。流不存储数据，从这个意义上说，它不是数据结构，它也永远不会修改基础数据源。此新功能java.util.stream-支持对元素流进行功能样式的操作，例如对集合进行map-reduce转换。 Stream功能定义 Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。采用Stream API可以极大提高 Java 程序员的生产力，让程序员写出高效率、干净、简洁的代码。 Stream的功能分析 Stream的操作符从流程操作是否完结大体上分为两种：中间操作符和终止操作符流程中操作符对于数据流来说，流程中操作符在执行指定处理程序后，数据流依然可以传递给下一级的操作符。 map(mapToInt,mapToLong,mapToDouble) ：转换操作符，把比如A->B，这里默认提供了转int，long，double的操作符。 flatmap(flatmapToInt,flatmapToLong,flatmapToDouble) 拍平操作比如把 int[]{2,3,4} 拍平变成 2，3，4 也就是从原来的一个数据变成了3个数据，默认提供了拍平成int,long,double的操作符。 limit 限流操作，比如数据流中有10个我只要出前3个就可以使用。 distint 去重操作，对重复元素去重，底层使用了equals方法。 filter 过滤操作，把不想要的数据过滤。 peek 挑出操作，如果想对数据进行某些操作，如：读取、编辑修改等。 skip 跳过操作，跳过某些元素。 sorted(unordered) 排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器。流程终止操作符数据经过中间加工操作，就轮到终止操作符上场了，终止操作符就是用来对数据进行收集或者消费的，数据到了终止操作这里就不会向下流动了，终止操作符只能使用一次。 collect 收集操作，将所有数据收集起来，这个操作非常重要，官方的提供的Collectors 提供了非常多收集器，可以说Stream 的核心在于Collectors。 count 统计操作，统计最终的数据个数。 findFirst、findAny 查找操作，查找第一个、查找任何一个返回的类型为Optional。 noneMatch、allMatch、anyMatch 匹配操作，数据流中是否存在符合条件的元素返回值为bool 值。 min、max 最值操作，需要自定义比较器，返回数据流中最大最小的值。 reduce 规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce。 forEach、forEachOrdered 遍历操作，这里就是对最终的数据进行消费了。 toArray 数组操作，将数据流的元素转换成数组。注意：中间操作符包含8种(排除了parallel,sequential，这两个操作并不涉及到对数据流的加工操作) Stream流的API分析 Stream的创建通过java.util.Collection.stream()方法用集合创建流 List<String> list = Arrays.asList("a", "b", "c"); // 创建一个顺序流 Stream<String> stream = list.stream(); // 创建一个并行流 Stream<String> parallelStream = list.parallelStream(); 使用java.util.Arrays.stream(T[] array)方法用数组创建流 int[] array={1,3,5,6,8}; IntStream stream = Arrays.stream(array); 使用Stream的静态方法：of()、iterate()、generate() Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6); Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4); stream2.forEach(System.out::println); // 0 3 6 9 Stream<Double> stream3 = Stream.generate(Math::random).limit(3); stream3.forEach(System.out::println); stream和parallelStream的简单区分：针对于筛选集合中的奇数，两者的处理不同之处： stream是顺序流，由主线程按顺序对流执行操作； parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。遍历/匹配（foreach/find/match） Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。 List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1); // 遍历输出符合条件的元素 list.stream().filter(x -> x > 6).forEach(System.out::println); // 匹配第一个 Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst(); // 匹配任意（适用于并行流） Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny(); // 是否包含符合特定条件的元素 boolean anyMatch = list.stream().anyMatch(x -> x < 6); System.out.println("匹配第一个值：" + findFirst.get()); System.out.println("匹配任意一个值：" + findAny.get()); System.out.println("是否存在大于6的值：" + anyMatch); 筛选（filter）筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。筛选出Integer集合中大于7的元素，并打印出来 public class StreamTest { public static void main(String[] args) { List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9); Stream<Integer> stream = list.stream(); stream.filter(x -> x > 7).forEach(System.out::println); } } 聚合（max/min/count) max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。获取String集合中最长的元素。 public class StreamTest { public static void main(String[] args) { List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd"); Optional<String> max = list.stream().max(Comparator.comparing(String::length)); System.out.println("最长的字符串：" + max.get()); } } 输出结果：最长的字符串：weoujgsd 获取Integer集合中的最大值。 public class StreamTest { public static void main(String[] args) { List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6); // 自然排序 Optional<Integer> max = list.stream().max(Integer::compareTo); // 自定义排序 Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o1.compareTo(o2); } }); System.out.println("自然排序的最大值：" + max.get()); System.out.println("自定义排序的最大值：" + max2.get()); } } 计算Integer集合中大于5的元素的个数。 public class StreamTest { public static void main(String[] args) { List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9); long count = list.stream().filter(x -> x > 5).count(); System.out.println("list中大于6的元素个数：" + count); } } 映射(map/flatMap) 映射可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap： map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。 flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。英文字符串数组的元素全部改为大写。 String[] strArr = { "abcd", "bcdd", "defde", "fTr" }; List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList()); System.out.println("每个元素大写：" + strList); 整数数组每个元素+3 List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11); List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList()); System.out.println("每个元素+3：" + intListNew); 将两个字符数组合并成一个新的字符数组。 List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7"); List<String> listNew = list.stream().flatMap(s -> { // 将每个元素转换成一个stream String[] split = s.split(","); Stream<String> s2 = Arrays.stream(split); return s2; }).collect(Collectors.toList()); 归并操作(reduce) 归并，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。 List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4); // 求和方式1 Optional<Integer> sum = list.stream().reduce(Integer::sum); // 求和方式2 Optional<Integer> sum2 = list.stream().reduce(Integer::sum); // 求和方式3 Integer sum3 = list.stream().reduce(0, Integer::sum); // 求乘积 Optional<Integer> product = list.stream().reduce((x, y) -> x * y); // 求最大值方式1 Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y); // 求最大值写法2 Integer max2 = list.stream().reduce(1, Integer::max); 统计(count/averaging) Collectors提供了一系列用于数据统计的静态方法：计数：count 平均值：averagingInt、averagingLong、averagingDouble 最值：maxBy、minBy 求和：summingInt、summingLong、summingDouble 统计以上所有：summarizingInt、summarizingLong、summarizingDouble 案例：统计员工人数、平均工资、工资总额、最高工资。 List<Person> personList = new ArrayList<Person>(); personList.add(new Person("Tom", 8900, 23, "male", "New York")); personList.add(new Person("Jack", 7000, 25, "male", "Washington")); personList.add(new Person("Lily", 7800, 21, "female", "Washington")); // 求总数 long count = personList.size(); // 求平均工资 Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary)); // 求最高工资 Optional<Integer> max = personList.stream().map(Person::getSalary).max(Integer::compare); // 求工资之和 int sum = personList.stream().mapToInt(Person::getSalary).sum(); // 一次性统计所有信息 DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary)); System.out.println("员工总数：" + count); System.out.println("员工平均工资：" + average); System.out.println("员工最高工资：" + max.get()); System.out.println("员工工资总和：" + sum); System.out.println("员工工资所有统计：" + collect); 分组(partitioningBy/groupingBy) 分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。案例：将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组 List<Person> personList = new ArrayList<Person>(); personList.add(new Person("Tom", 8900, 23, "male", "Washington")); personList.add(new Person("Jack", 7000, 25, "male", "Washington")); personList.add(new Person("Lily", 7800, 21, "female", "New York")); personList.add(new Person("Anni", 8200, 24, "female", "New York")); // 将员工按薪资是否高于8000分组 Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000)); // 将员工按性别分组 Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex)); // 将员工先按性别分组，再按地区分组 Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea))); 接合(joining) joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。 List<Person> personList = new ArrayList<Person>(); personList.add(new Person("Tom", 8900, 23, "male", "New York")); personList.add(new Person("Jack", 7000, 25, "male", "Washington")); personList.add(new Person("Lily", 7800, 21, "female", "Washington")); String names = personList.stream().map(Person::getName).collect(Collectors.joining(",")); System.out.println("所有员工的姓名：" + names); List<String> list = Arrays.asList("A", "B", "C"); String string = list.stream().collect(Collectors.joining("-")); System.out.println("拼接后的字符串：" + string); 排序(sorted) sorted，中间操作。有两种排序： sorted()：自然排序，流中元素需实现Comparable接口 sorted(Comparator com)：Comparator排序器自定义排序案例：将员工按工资由高到低（工资一样则按年龄由大到小）排序 List<Person> personList = new ArrayList<Person>(); personList.add(new Person("Sherry", 9000, 24, "female", "New York")); personList.add(new Person("Tom", 8900, 22, "male", "Washington")); personList.add(new Person("Jack", 9000, 25, "male", "Washington")); personList.add(new Person("Lily", 8800, 26, "male", "New York")); personList.add(new Person("Alisa", 9000, 26, "female", "New York")); // 按工资升序排序（自然排序） List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName) .collect(Collectors.toList()); // 按工资倒序排序 List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()) .map(Person::getName).collect(Collectors.toList()); // 先按工资再按年龄升序排序 List<String> newList3 = personList.stream() .sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName) .collect(Collectors.toList()); // 先按工资再按年龄自定义排序（降序） List<String> newList4 = personList.stream().sorted((p1, p2) -> { if (p1.getSalary() == p2.getSalary()) { return p2.getAge() - p1.getAge(); } else { return p2.getSalary() - p1.getSalary(); } }).map(Person::getName).collect(Collectors.toList()); 提取/组合流也可以进行合并、去重、限制、跳过等操作。 String[] arr1 = { "a", "b", "c", "d" }; String[] arr2 = { "d", "e", "f", "g" }; Stream<String> stream1 = Stream.of(arr1); Stream<String> stream2 = Stream.of(arr2); // concat:合并两个流 distinct：去重 List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList()); // limit：限制从流中获得前n个数据 List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList()); // skip：跳过前n个数据 List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList()); System.out.println("流合并：" + newList); System.out.println("limit：" + collect); System.out.println("skip：" + collect2); 实际案例操作遍历集合日常开发中，我们经常需要需要遍历集合对象中的元素，例如，我们会采用如下方式进行遍历元素，然后过滤出某个字段的集合，当采用 Stream 编程之后，只需要通过一行代码，即可实现： /** * jdk8 从集合对象中获取用户ID集合 * @param userList * @return */ public List<Long> getUserIds(List<User> userList){ List<Long> userIds = userList.stream().map(User::getUserId).collect(Collectors.toList()); return userIds; } 筛选元素筛选元素，是日常开发中经常会碰到，例如在 jdk8，采用 Stream api，我们只需要通过filter方法来筛选出需要的数据，即可过滤出用户ID不为空的数据。 /** * jdk8 从集合对象中筛选出用户ID不为空的数据 * @param userList * @return */ public List<Long> getUserIds8(List<User> userList){ List<Long> userIds = userList.stream().filter(item -> item.getUserId() != null).map(User::getUserId).collect(Collectors.toList()); return userIds; } 删除重复的内容如果你想对返回的集合内容排除重复的数据，操作也很简单，在合并的时候使用Collectors.toSet()即可! /** * jdk8 从集合对象中筛选出用户ID不为空的数据，并进行去重 * @param userList * @return */ public Set<Long> getUserIds(List<User> userList){ Set<Long> userIds = userList.stream().filter(item -> item.getUserId() != null).map(User::getUserId).collect(Collectors.toSet()); return userIds; } 数据类型转换在实际的开发过程中，经常会出现数据类型定义不一致的问题，例如有的系统，使用String接受，有的是用Long，对于这种场景，我们需要将其转换，操作也很简单 /** * jdk8 将Long类型数据转换成String类型 * @param userIds * @return */ public List<String> getUserIds10(List<Long> userIds){ List<String> userIdStrs = userIds.stream().map(x -> x.toString()).collect(Collectors.toList()); return userIdStrs; } 数组转集合我们还会碰到，前端传给我们的是一个数组，但是我们需要转成集合，采用 stream api 操作也很简单! public static void main(String[] args) { //创建一个字符串数组 String[] strArray = new String[]{"a","b","c"}; //转换后的List 属于 java.util.ArrayList 能进行正常的增删查操作 List<String> strList = Stream.of(strArray).collect(Collectors.toList()); } 集合转Map操作在实际的开发过程中，还有一个使用最频繁的操作就是，将集合元素中某个主键字段作为key，元素作为value，来实现集合转map的需求，这种需求在数据组装方面使用的非常多，尤其是在禁止连表 sql 查询操作的公司，视图数据的拼装只能在代码层面来实现。例如，下面这段代码，角色表里面关联角色组ID信息，当查询角色信息的时候，需要把角色组名称也展示处理，采用map方式来匹配，效率会非常高。实际代码案例分享 //角色组ID集合 Set<Long> roleGroupIds = new HashSet<>(); //查询所有的角色信息 List<RoleInfo> dbList = roleInfoMapper.findByPage(request); for (RoleInfo source : dbList) { roleGroupIds.add(source.getRoleGroupId()); RoleInfoDto result = new RoleInfoDto(); BeanUtils.copyProperties(source, result); resultList.add(result); } //查询角色组信息 if (CollectionUtils.isNotEmpty(roleGroupIds)) { List<RoleGroupInfo> roleGroupInfoList = roleGroupInfoMapper.selectByIds(new ArrayList<>(roleGroupIds)); if (CollectionUtils.isNotEmpty(roleGroupInfoList)) { //将List转换成Map，其中id主键作为key，对象作为value Map<Long, RoleGroupInfo> sourceMap = new HashMap<>(); for (RoleGroupInfo roleGroupInfo : roleGroupInfoList) { sourceMap.put(roleGroupInfo.getId(), roleGroupInfo); } //封装角色组名称 for (RoleInfoDto result : resultList) { if (sourceMap.containsKey(result.getRoleGroupId())) { result.setRoleGroupName(sourceMap.get(result.getRoleGroupId()).getName()); } } } } 集合转 map(不分组) 在 jdk8 中，采用 stream api的方式，我们只需要一行代码即可实现，jdk8 将集合转换成Map，其中用户ID作为主键key,如果集合对象有重复的key,以第一个匹配到的为主 public Map<Long, User> getMap(List<User> userList){ Map<Long, User> userMap = userList.stream().collect(Collectors.toMap(User::getUserId, v -> v, (k1,k2) -> k1)); return userMap; } 打开Collectors.toMap方法源码，一起来看看到底是啥。 public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction) { return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new); } 参数表可以看出：第一个参数：表示 key 第二个参数：表示 value 第三个参数：表示某种规则上文中的Collectors.toMap(User::getUserId, v -> v, (k1,k2) -> k1)，表达的意思就是： userId的内容作为key v -> v是表示将元素user作为value。 (k1,k2) -> k1表示如果存在相同的key，将第一个匹配的元素作为内容。集合转map(分组) 实际的操作中，有一些场景需要我们将相同的key，加入到一个集合，而不是覆盖，哪改如何做呢？而在 jdk8 中，采用 stream api的方式，我们只需要一行代码即可实现。 /** * jdk8 将集合转换成Map，将相同的key，加入到一个集合中，实现分组 * @param userList * @return */ public Map<Long, List<User>> getMapGroup(List<User> userList){ Map<Long, List<User>> userMap = userList.stream().collect(Collectors.groupingBy(User::getUserId)); return userMap; } 分页操作 stream api的强大之处还不仅仅是对集合进行各种组合操作，还支持分页操作。例如，将如下的数组从小到大进行排序，排序完成之后，从第1行开始，查询10条数据出来，操作如下： //需要查询的数据 List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5,10, 6, 20, 30, 40, 50, 60, 100); List<Integer> dataList= numbers.stream().sorted((x, y) -> x.compareTo(y)).skip(0).limit(10).collect(Collectors.toList()); System.out.println(dataList.toString()); 其中skip参数表示第几行，limit表示查询的数量，类似页容量! 查找与匹配操作 stream api 还支持对集合进行查找，同时还支持正则匹配模式。 allMatch(检查是否匹配所有元素) 是否全部元素都大于2 List<Integer> list = Arrays.asList(10, 5, 7, 3); boolean allMatch = list.stream() .allMatch(x -> x > 2); System.out.println(allMatch); findFirst(返回第一个元素) 获取第一个元素 List<Integer> list = Arrays.asList(10, 5, 7, 3); Optional<Integer> first = list.stream() .findFirst(); Integer val = first.get(); System.out.println(val);//输出10 (可以将流中元素反复结合起来，得到一个值) List<Integer> list = Arrays.asList(10, 5, 7, 3); Integer result = list.stream() .reduce(2, Integer::sum); System.out.println(result);//输出27，其实相当于2+10+5+7+3，就是一个累加 stream api 支持的操作方法非常多，这里只列举了几种类型，具体在使用的时候，可以参考官网接口文档说明!

2021-10-30

K8s学习进阶月刊第二期阿里云亮相2019云原生产业大会，积极共建云原生生态

欢迎订阅K8s学习进阶月刊视频干货资料尽情下载阿里云应用性能管理(APM)产品-应用实时监控服务(ARMS)技术解密资料下载直播大纲：应用性能管理(APM)背景介绍分布式链路追踪的现状与使用场景

2019-04-25

云盾内容安全8月1日全面升级上线，基于深度学习提供鉴黄、涉政、直播不良场景等10种以上检测服务

spm=5176.8142029.759393.7.23896df一、产品功能与服务：1、图片智能鉴黄服务：通过深度学习算法和实时更新的亿级图像样本库，可对图片进行识别以及色情程度量化。

2017-08-17

苹果机器学习期刊「Siri 三部曲」之一：通过跨带宽和跨语言初始化提升神经网络声学模型

其中第一篇文章讨论了一项利用声学模型数据的迁移学习技术，它可以显著提升新语言版本Siri的精确度。机器之心随后将奉献上第二篇、第三篇博文，敬请读者期待。

2017-08-01

TensorFlow 开发者峰会将于今晚举行；维基百科使用AI机器学习算法来检测恶意评论 | AI开发者头条

TensorFlow 开发者峰会将于今晚举行（美国时间）雷锋网获悉，第一届TensorFlow Dev峰会将于2017年2月15日在加利福尼亚州山景城举行，到时TensorFlow团队将会做相关的技术访谈和演示，整个活动将持续一整天，同时，整个会议还将在Google开发者论坛、YouTube上进行直播，给不能到现场的开发者提供第一手资料。会议时间：2017年2月15日会议地点：加利福尼亚州山景城活动详情：https://events.withgoogle.com/tensorflow-dev-summit/#content 直播地址：https://www.youtube.com/watch?v=LqLyrl-agOw IBM与TensorFlow结合，PowerAI人工智能开发平台支持TensorFlow 0.12架构 2月14日，I

2017-08-01

NAMENODE工作机制，元数据管理(元数据存储机制、元数据手动查看)、元数据的checkpoint、元数据目录说明（来自学习资料）

NAMENODE工作机制学习目标：理解namenode的工作机制尤其是元数据管理机制，以增强对HDFS工作原理的理解，及培养hadoop集群运营中“性能调优”、“namenode”故障问题的分析解决能力

2017-05-29

探秘阿里云Hi购季开发者分会场：海量学习资源0元起！

【点击订阅云栖夜读周刊】开发者分会场致力于帮助开发者学习了解阿里云最新技术，为开发者设计全方位的技术成长与进阶之路。热点热议开发者必看！探秘阿里云Hi购季开发者分会场：海量学习资源0元起！

2019-03-17

学界| UC Berkeley提出新型分布式框架Ray：实时动态学习的开端—— AI 应用的系统需求：支持（a）异质、并行计算，（b）动态任...

学界| UC Berkeley提出新型分布式框架Ray：实时动态学习的开端 from：https://baijia.baidu.com/s?

2017-11-14

CAAI云课堂丨第二期全球高被引科学家王熙照解析监督学习中的不确定性

疫情防控不放松，学习充电不间断。

2020-03-12

上汽集团资深架构师、上汽—安吉人工智能实验室负责人金忠孝：深度学习在智慧供应链中的应用

AlphaGo引发的惨案：深度学习今天首先我讲，AlphaGo引发的惨案，这也是人工智能学习搞出来的。

2018-03-05

大家一起来学习一下面向对象的三层架构吧!今天我来说说Entity有时也叫MODEL实体层!

本文转自博客园张占岭（仓储大叔）的博客，原文链接：大家一起来学习一下面向对象的三层架构吧!今天我来说说Entity有时也叫MODEL实体层!，如需转载请自行联系原博主。

2017-12-06

Hadoop Hive概念学习系列之hive三种方式区别和搭建、HiveServer2环境搭建、HWI环境搭建和beeline环境搭建（五）

参考链接： http://www.aboutyun.com/thread-12278-1-1.html 在之前的学习和实践Hive中，使用的都是CLI或者hive –e的方式，该方式仅允许使用HiveQL

2017-11-11

全球开发者调查报告：IT 人最想学习 Go 和 Python、美国开发者收入最高、培训班出身的程序员也吃香

60％的全栈开发者因工作需要而学习一个全新的框架由于全栈开发者必须熟悉更多的技术栈，因此有 60% 的全栈开发者表示，在过去的一年里，曾因为工作需求而被要求学习全新的框架，有 45% 则表示曾被要求学习新语言

2020-02-11

云计算、大数据、编程语言学习指南下载，100+技术课程免费学！这份诚意满满的新年技术大礼包，你Get了吗？

这个仍处于前沿的技术领域，网上的技术教程五花八门，从何处入手开始学习，成了困扰很多人的问题。对此，我们整理了这套云计算学习指南。

2019-02-20

学习ASP.NET Core, 怎能不了解请求处理管道[5]: 中间件注册可以除了可以使用Startup之外，还可以选择StartupFil...

中间件的注册除了可以借助Startup对象（DelegateStartup或者ConventionBasedStartup）来完成之外，也可以利用另一个叫做StartupFilter的对象来实现。所谓的StartupFilter是对所有实现了IStartupFilter接口的类型及其对象的统称。IStartupFilter接口定义了如下一个唯一的方法Configure，该方法的参数next返回的Action<IApplicationBuilder>对象体现了后续StartupFilter和Startup对中间件的注册，而自身对中间件的注册则实现在返回的Action<IApplicationBuilder>对象中。[本文已经同步到《ASP.NET Core框架揭秘》之中] 1: publicinterface IStartupFilter 2: { 3: Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next); 4: } 我们可以采用服务注册的方式注册多个StartupFilter。具体来说，StartupFilter具有如下两种不同的注册方式，一种是通过调用WebHostBuilder的ConfigureServices方法以服务的形式注册所需的StartupFilter，另一种则是将针对StartupFilter的服务注册实现在启动类的ConfigureServices方法上。 1: //注册方式1 2: new WebHostBuilder() 3: .ConfigureServices(svcs => svcs 4: .AddSingleton<IStartupFilter, Filter1>() 5: .AddSingleton<IStartupFilter, Filter2>()) 6: … 7: 8: //注册方式2 9: publicclass Startup 10: { 11: publicvoid ConfigureServices(IServiceCollection svcs) 12: { 13: svcs.AddSingleton<IStartupFilter,Filter1>() 14: .AddSingleton<IStartupFilter, Filter2>(); 15: } 16: } 既然中间件可以同时通过Startup和StartupFilter进行注册，那么通过这两个种方式注册的中间件有何不同吗？其实它们唯一的区别在于StartupFilter注册的中间件会先执行。话句话说，对于由注册中间件构成的管道来说，通过Startup注册的中间件位于通过StartupFilter注册的中间件之后。我们不妨通过一个简单的实例来证实这一点。我们在一个ASP.NET Core控制台应用中定义如下四个中间件类型（Foo、Bar、Baz和Gux），它们针对请求的处理逻辑很简单，就是将自身的类型名称写入请求的响应中。 1: publicabstractclass MiddlewareBase 2: { 3: private RequestDelegate _next; 4: 5: public MiddlewareBase(RequestDelegate next) 6: { 7: _next = next; 8: } 9: public async Task Invoke(HttpContext context) 10: { 11: await context.Response.WriteAsync($"{this.GetType().Name}=>"); 12: await _next(context); 13: } 14: } 15: 16: publicclass Foo : MiddlewareBase 17: { 18: public Foo(RequestDelegate next) : base(next){} 19: } 20: publicclass Bar : MiddlewareBase 21: { 22: public Bar(RequestDelegate next) : base(next) {} 23: } 24: publicclass Baz : MiddlewareBase 25: { 26: public Baz(RequestDelegate next) : base(next) {} 27: } 28: publicclass Gux : MiddlewareBase 29: { 30: public Gux(RequestDelegate next) : base(next) {} 31: } 接下来我们定义了如下一个泛型的 StartupFilter<TMiddleware>类，这是一个专门用于注册指定类型中间件的StartupFilter，泛型参数代表注册的中间件类型。在实现的Configure方法中，我们将中间件的注册实现在返回的Action<IApplicationBuilder>对象中。 1: publicclass StartupFilter<TMiddleware> : IStartupFilter 2: { 3: public Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next) 4: { 5: return app=> { 6: app.UseMiddleware<TMiddleware>(); 7: next(app); 8: }; 9: } 10: } 我们最终编写如下一段简单的程序来启动承载的应用程序。如下面的额代码片段所示，在利用WebHostBuilder创建并启动WebHost之前，我们调用其ConfigureServices方法注册了两个StartupFilter<TMiddleware>对象，它们对应的中间件类型分别为Foo和Bar。在随后调用的Configure方法中，我们又完成了针对中间Baz和Gux的注册。这段程序实际上注册了五个中间件（调用ApplicationBuilder的Run方法可以视为中间件注册）。 1: publicclass Program 2: { 3: publicstaticvoid Main() 4: { 5: new WebHostBuilder() 6: .UseKestrel() 7: .ConfigureServices(svcs => svcs 8: .AddSingleton<IStartupFilter>(new StartupFilter<Foo>()) 9: .AddSingleton<IStartupFilter>(new StartupFilter<Bar>())) 10: .Configure(app => app 11: .UseMiddleware<Baz>() 12: .UseMiddleware<Gux>() 13: .Run(async context=> await context.Response.WriteAsync("End"))) 14: .Build() 15: .Run(); 16: } 17: } 我们现在需要确定注册的这五个在进行请求处理过程中的执行顺序。为此我们直接启动这个程序，然后开启浏览器访问默认的监听地址（http://localhost:5000），浏览器会按照如下图所示形式显示出请求在这个五个中间件中的“路由”。浏览器显示的结果清晰地表明通过StartupFilter注册的中间件比通过Startup注册的中间件先执行。对于两个采用相同方式注册的中间件，先被注册的中间会先执行。作者：蒋金楠微信公众账号：大内老A 微博： www.weibo.com/artech 如果你想及时得到个人撰写文章以及著作的消息推送，或者想看看个人推荐的技术资料，可以扫描左边二维码（或者长按识别二维码）关注个人公众号（原来公众帐号蒋金楠的自媒体将会停用）。本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。原文链接

2017-10-23

【NIPS2017】深度学习真的不需要理论指导了？图灵奖得主讲座无人问津，贝叶斯之父Judea Pearl落寞身影背后引人深思

NIPS 2017 "Test of Time"论文大奖获得者Ali Rahimi 在长滩现场的演讲中抱怨当前机器学习尤其是深度学习使用的很多方法缺少（理论）理解。

2017-12-10

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。