分类：未分类

wps免费版的下载的地方怎么找

　　鱿鱼币是一种基于热播网剧《鱿鱼游戏》命名的加密货币，借助该剧的热度应运而生。它建立在去中心化区块链平台上，利用智能合约技术保障交易安全，并结合NFT与元宇宙概念。但是鱿鱼币崩盘严重，需谨慎购买。wps官网的下载地方是什么

　　

　　鱿鱼币的命名灵感来源于奈飞（Netflix）热播的全球网剧《鱿鱼游戏》（Squid Game）。该剧以其紧张刺激的剧情和深刻的社会寓意，在全球范围内收获了较高的口碑与热度。正是借助这股文化浪潮，鱿鱼币应运而生，成为wps的官网最新的下载的地方在哪里领域的一次跨界尝试。

　　鱿鱼币是建立在去中心化区块链平台上的加密货币，利用智能合约技术保障交易的透明性、安全性和不可篡改性。其限量发行的策略维持了币种的稀缺性和价值潜力，每一枚鱿鱼币都显得较为珍贵。此外，鱿鱼币还结合了NFT与元宇宙概念，在新一轮投资浪潮中占据先机。

　　1.基于智能合约：鱿鱼币是建立在去中心化区块链平台上的加密货币，利用智能合约技术确保交易的透明性、安全性和不可篡改性。

　　2.限量发行：为了维持其稀缺性和价值潜力，鱿鱼币采取了限量发行的策略，使得每一枚鱿鱼币都显得尤为珍贵。

　　3.高度投机性：受《鱿鱼游戏》热度影响，鱿鱼币自问世以来便伴随着极高的投机性质，价格波动剧烈，吸引了大量寻求短期收益的投资者。

　　鱿鱼币自问世以来，便伴随着较高的投机性质，价格波动剧烈。2021年10月，鱿鱼币一周内最高涨幅达2300倍，币价达到惊人的2861.8美元（约合人民币18309元）。然而，市场热度过后，鱿鱼币价格迅速回落，投资者需谨慎对待。

　　 wps免费版下载的地址是什么 wps office的免费版的下载入口的方法

　　鱿鱼币的市场表现可谓一波三折。初期，凭借其独特的命名和强大的IP效应，鱿鱼币价格迅速攀升，创造了令人瞩目的涨幅。然而，好景不长，随着市场热度的逐渐消散以及监管风险的增加，鱿鱼币价格出现了断崖式下跌，许多投资者因此遭受了巨大损失。

　　此外，鱿鱼币还面临着诸多风险，包括但不限于：

　　- 监管风险：加密货币领域的监管政策日益收紧，鱿鱼币作为新兴项目，更容易受到监管机构的关注和wps官网下载的网站的方法限制。

　　- 技术风险：区块链技术尚不成熟，存在被黑客攻击、智能合约漏洞等安全隐患。

　　- 市场风险：加密货币市场波动性大，投资者需具备较高的风险承受能力。

　　鱿鱼币是一种基于《鱿鱼游戏》文化热度而诞生的加密货币，它结合了区块链技术与热门IP，试图在wps的官网最新的下载的地方在哪里领域开辟一片新天地。然而，其高度投机性和潜在风险也不容忽视。对于投资者而言，在追求高收益的同时，更应理性分析市场形势，谨慎评估自身风险承受能力，避免盲目跟风投资。

　　第一步：登陆P网官网，如果你还没有账号可以注册新账号，进入交易页面wps的电脑版下载的入口

　　

　　第二步：搜索鱿鱼币英文简称SQUID

　　 wps的的官网的下载网站是多少

　　第三步：点击交易，进入购买页面

　　
wps官网最新下载地址怎么找
　　第四步：步填写购买数量，点击买入，若是卖出，填写卖出量，点击卖出即可。

　　

　　鱿鱼币合约地址是:0x87230146E138d3F296a9a77e497A2A83012e9Bc5

　　这款WPS office的电脑版的下载网站怎么找是一款与鱿鱼游戏同名的游戏平台的独家代币。该平台模仿了剧中的六轮比赛，最终赢家获得的奖金将以这款刚刚发布的“鱿鱼币”的形式发放，比赛将在11月启动。

　　与原版不同的是，该平台表示:“我们显然不会提供致命后果!"

　　并且，剧中大奖上限为3850万美元，而这个虚拟模拟的游戏将不限制最终奖金的上限，也不限制参与者的数量但是，玩家必须先支付预设价格的鱿鱼而才能参与每场游戏，有些回合还需要用户购买在平台上出售的定制NFT(非同质化代币，在此游戏中类似于游戏皮肤或道具)。其中一些NFT以剧中的角色为特色，包括穿着红色套装戴着黑色面具的警卫。

　　游戏玩法并不便宜，特别是在当前暴涨的价格下。如果想参加最后一场比赛，玩家必须支付15000魷鱼币(约合33450美元)，并购买一个NFT。每个回合的入会费由开发者(10%)和奖励池(90%)平分。平台还提供弹球池，持有者可以通过质押赚取代币，将他们持有的加密货币作为抵押品来赚取被动收入。

　　1.缺乏官方认可和监管

　　鱿鱼币并非由官方机构或知名金融机构发行，缺乏官方认可和监管，这意味着其存在较高的风险和不确定性。鱿鱼币声称与知名平台Netflix有合作关系，但已被该平台否认，进一步降低了其可信度。

　　2.项目破绽百出

　　鱿鱼币的官网注册时间较短，总使用时间也不长，显示出项目的不成熟和不稳定。项目叙述中存在诸多文法错误，反映出其制作粗糙和缺乏专业性wps office 官方下载网站怎么找。鱿鱼币的创始人身份不明，且在社交媒体上没有个人资料，增加了其神秘性和风险性。

　　3.存在“抽地毯”式骗局风险

　　鱿鱼币在发行后价格暴涨暴跌，是典型的“抽地毯”式骗局特征。开发者在价格高位时突然停止交易并卷走资金，导致投资者损失惨重。这种骗局在加密货币领域屡见不鲜，投资者应高度警惕。

　　4.市场波动性和投机性较强

　　鱿鱼币作为一种加密货币，具有较高的市场波动性和投机性。其价格受到市场情绪、投机行为等多种因素影响，难以预测和稳定。投资者容易在短时间内被“割韭菜”，蒙受较大的经济和财产损失。

　　5.国内监管政策收紧

　　国内对于WPS office的电脑版的下载网站怎么找的监管政策持续收紧，对于WPS office的电脑版的下载网站怎么找交易的打击力度也在不断加大。鱿鱼币作为一种非法定的WPS office的电脑版的下载网站怎么找，在国内进行交易和炒作存在较高的法律风险。

　　

　　鱿鱼币作为wps的官网最新的下载的地方在哪里领域的一次跨界尝试，确实在短时间内吸引了大量关注，并在市场上掀起了一股热潮。然而，投资者在追捧鱿鱼币的同时，也应清醒地认识到其存在的诸多风险。缺乏官方认可和监管、项目破绽百出、存在“抽地毯”式骗局风险以及市场波动性和投机性较强等问题，都使得鱿鱼币成为了一个高风险的投资选择。因此，投资者在做出决策时，应谨慎权衡利弊，避免盲目跟风。

　　以上就是SQUID/鱿鱼币是什么币种，鱿鱼币怎么买？的详细内容，更多关于SQUID币的资料请关注脚本之家其它相关文章！

　　声明：文章内容不代表本站观点及立场，不构成本平台任何投资建议。本文内容仅供参考，风险自担！

　　Tag：squid 鱿鱼币

2025年3月3日
wps官网最新的下载的地方是多少(wps下载电脑版流程图)

　　1、汇总函数：

　　count 含义：求某列的行数

　　sum 含义：对某列数据求和

　　avg 含义：求某列数据的平均值

　　max 含义：求某列数据的最大值

　　min 含义：求某列数据的最小值

　　函数功能：1、功能 2、输入 3、输出

　　2、案例

　　案例1：count 函数教师姓名数汇总案例—备注：count函数里面如果是列名则不包含null值

　　

　　案例2:count 函数教师表所有列汇总

　　

　　案例3：sum函数求成绩汇总

　　

　　案例4：avg 求平均成绩

　　

　　案例5：max，min函数，求成绩最大值和最小值

　　

　　案例6：去除重复行分列 count，distinct

　　

　　3、练习：

　　1)查询课程编号为“0002”的总成绩

　　

　　2) 查询选了课程的学生人数

　　

　　1、SQL分组：group by
wps office的免费版下载网址
　　分析方法：

　　1、数据分组

　　2、应用函数

　　3、组合结果

　　2、案例

　　案例1：对学生性别进行分组

　　

　　案例2：对年龄大于1990-01-01的学生按性别分组

　　

　　SQL运行顺序

　　

　　3、练习：分组

　　1）查询各科成绩最高分和最低的分

　　

　　2）查询每门课程被选修的学生数

　　

　　3）查询男生、女生数

　　

　　1、案例：只取男生组的列数

　　

　　SQL运行顺序

　　

　　2、练习题：分组结果的条件

　　1）查询平均成绩大于60分学生的学号和平均成绩

　　

　　2）查询至少选修两门课程的学生学号

　　

　　3）查询同名同姓学生名单并统计同名人数

　　

　　1、如何使用SQL解决业务问题

　　1、翻译成大白话

　　2、写出分析思路

　　3、写出对应的SQL语句

　　2、案例

　　案例1：如何计算各科的平均成绩

　　翻译：

　　Select查询结果

　　【每门课的课程号：分组，平均成绩：avg（成绩）】

　　From 从哪张表中查找数据【成绩表;score】wps电脑版的下载的网站是什么

　　Where WPS office的电脑版下载的网站查询条件【没有】

　　Group by 分组【每门课程：按课程号分组】

　　Having 对分组结果指定条件【没有】;

　　

　　案例2：如何计算每门课程的平均成绩，并且平均成绩大于等于80分

　　select 查询结果

　　【每门课程的课程号：分组，平均成绩：avg（成绩）】

　　From 从哪张表中查找数据【成绩表：score】

　　Where 查询条件【没有】

　　Group wps官网的下载网址在哪里(wps下载电脑版免费吗) by 分组【每门课程：按课程号分组】

　　Having 对分组结果指定条件【平均成绩>=80】;

　　

　　1、Order by

　　降序（desc）：从大到小

　　升序（asc）：从小到大

　　Select 查询结果

　　【每门课程的课程号：分组，平均成绩：avg（成绩）】

　　From 从哪张表中查找数据【成绩表：score】

　　Where 查询条件【没有】

　　Group by 分组【每门课程：按课程号分组】

　　Having 对分组结果指定条件【平均成绩>=80

　　Order by 对查询结果排序【按成绩降序desc】

　　

　　SQL运行顺序

　　
wps的官网最新下载的网址是多少
　　2、案例

　　案例1：指定多个排序列名

　　

　　案例2：对含有空值null的列进行排序，空值排在最前面

　　

　　3、从查询结果中取出指定行：limit

　　案例：从查询结果中取出前2行数据

　　

　　SQL运行顺序

　　

　　4、练习：理解SQL的运行顺序

　　1）查询小于90分的课程并按课程号从小到大排列

　　

　　2）查询每门课程的平均成绩，结果按平均成绩升序排序。平均成绩相同时，按课程号降序排列

　　

　　常见错误1：在group by中使用了select里的别名

　　

　　常见错误2：在where中使用聚合函数

　　Select 性别,count(*)

　　From student

　　Where count(*)>1 —-错

　　Group by 性别;

　　

　　常见错误3：字符串类型的数字

　　

　　1、select from noble

　　2、sum and count

2025年3月3日
wps免费版下载的网站怎么找

　　官网：官网

　　官方下载地址：下载地址

　　GitHub地址& wps电脑版的下载的地方的方法#xff1a;源码

　　Spring是一个简化java企业级开发的一个轻量级的开源框架。内部包含了很多技术，比如：控制反转&依赖注入，AOP，Spring事务管理，还可以集成其他框架。

　　也叫IoC容器，是具有依赖注入功能的容器。主要负责容器中：对象的初始化，对象的实例化，对象与对象之间依赖关系的配置，对象的销毁，对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。

　　支持xml方式和java注解方式，在配置文件中列出需要让IoC管理的对象，在spring容器启动时会去加载这个配置文件，然后将这些对象组装好供外部访问者使用。

　　由spring管理的对象统称为Bean对象。就是普通的java对象，和使用者new的对象是一样的，只是这些对象由spring来创建和管理。

　　需要先在配置文件中定义好需要创建的Bean对象，这些配置统称为Bean定义配置元数据信息，spring容器通过读取这些配置元数据信息来构建和组装我们需要的对象。

　　1.5.1 BeanFactory 接口

　　spring容器的顶层接口，提供了容器最基本的功能。用BeanFactory加载配置文件时，不会创建容器里的对象，在获取（使用）对象的时候才会创建

　　常用的几个方法：

　　1.5.2 ApplicationContext 接口

　　继承了BeanFactory接口，包含BeanFactory的所有功能，并且进行了扩展，增加了许多企业级功能，如：AOP。国际化，事件支持等。加载xml的时候就会创建对象。

　　1.5.3 ClassPathXmlApplicationContext 类

　　实现了ApplicationContext接口，该实现类可以从classpath中加载beans.xml的配置，然后创建xml中需要的bean对象

　　1.5.4 AnnotationConfigApplicationContext 类

　　实现了ApplicationContext接口，该实现类可以加载用注解方式配置的Bean对象

　　2.1.1 beans.xml配置文件格式

　　(1) beans标签

　　beans是根元素，希迈纳可以包含任意数量的bean，import，alias元素

　　bean标签定义一个bean对象，格式如下：

　　每个bean都有一个名称，叫做bean名称。bean名称在spring中必须唯一，否则会报错，可以通过bean名称从spring容器中获取对应的对象。

　　(2) bean名称和别名定义规则

　　名称和别名可以通过bean元素中的id和name来定义，具体定义规则如下：

　　当id存在时，不管有没有name，取id为bean的名称。当id不存在时，此时看name，name的值可以通过**,;**或者空格分割，最后会按照分隔符得到一个String数组，数组的第一个元素作为bean的名称，其他的作为bean的别名当id和name都存在的时候，id为bean名称，name用来定义多个别名当id和name都不指定的时候，bean名称自动生成；生成规则是：bean名称为完整类名#编号，别名为完整的类名。

　　(3) alias元素

　　alias元素也可以用来给某个bean定义别名，语法：

　　(4) import元素

　　当我们的系统比较大的时候，会分成很多模块，每个模块会对应一个bean xml文件，我们可以在一个总的bean xml中对其他bean xml进行汇总，相当于把多个bean xml的内容合并到一个里面了，可以通过import元素引入其他bean配置文件。

　　2.2.1 scope（作用域）属性

　　singleton：表示这个bean是单例的。当scope为singleton时，spring容器在启动加载spring配置文件的时候，会将bean创建好放在容器中。整个spring容器中只存在一个bean实例，通过容器多次查找bean的时候（调用BeanFactory的getBean方法或者bean之间注入依赖的bean对象的时候），返回的都是同一个bean对象。有个特殊的情况，当bean的lazy被设置为true的时候，表示懒加载，那么使用的时候才会创建。prototype：表示这个bean是多例的，通过容器每次获取的bean都是不同的实例，每次获取时都会重新创建一个bean实例对象request：在spring容器的web环境中，每个http请求都会创建一个bean实例，request结束的时候，这个bean也就结束了session：在spring容器的web环境中，每个会话会对应一个bean实例，不同的session对应不同的bean实例application：一个web应用程序对应一个bean实例。但是，一个应用程序中可以创建多个spring容器，不同的容器中bean的名称不能相同。自定义作用域：自定义scope 3个步骤，实现Scope接口，将实现类注册到spring容器，使用自定义的sope

　　缺点：单例bean是整个应用共享的，所以需要考虑到线程安全问题多例bean每次获取的时候都会重新创建，如果这个bean比较复杂，创建时间比较长，会影响系统的性能

　　2.2.2 通过depend-on干预bean创建和销毁顺序

　　depend-on：设置当前bean依赖的bean名称，可以指定多个，多个之间可以用”,;空格“进行分割。

　　不管bean2,bean2,bean4在任何地方定义，会先将bean2,bean3,bean4在bean1创建之前创建好，表示bean1依赖于这3个bean；销毁的时候也会先销毁当前bean，再去销毁被依赖的bean，即先销毁bean1，再去销毁depend-on指定的bean2,bean3,bean4。

　　2.2.2 通过primary解决根据条件有多个匹配的bean

　　spring中可以通过bean元素的primary属性的primary="true"来解决这个问题，可以通过这个属性来指定当前bean为主要候选者，当容器查询一个bean的时候，如果容器中有多个候选者匹配的时候，此时spring会返回主要的候选者。

　　xml

　　2.2.3 通过autowire-candidate解决根据条件有多个匹配的bean

　　default：这个是默认值，autowire-candidate如果不设置，其值就是defaulttrue：作为候选者false：不作为候选者

　　xml

　　上面两种情形的分析：

　　容器在创建PrimartBean 的时候，发现其autowire为byType，即按类型自动注入，此时会在PrimartBean 类中查找所有setter方法列表，其中就包含了setService方法，setService方法参数类型是IService，然后就会去容器中按照IService类型查找所有符合条件的bean列表，此时容器中会返回满足IService这种类型并且autowire-candidate="true"的bean，刚才有说过bean元素的autowire-candidate的默认值是true，所以容器中符合条件的候选bean有2个：serviceA和serviceB，setService方法只需要一个满足条件的bean，此时会再去看这个列表中是否只有一个主要的bean，即bean元素的primary=“ture”的bean（而bean元素的primary默认值都是false），所以没有primary为true的bean，此时spring不知道选哪个，所以抛出NoUniqueBeanDefinitionException异常。

　　问题解决：

　　从上面过程中可以看出将某个候选bean的primary置为true或者只保留一个bean的autowire-candidate为true，将其余的满足条件的bean的autowire-candidate置为false就可以解决问题了。

　　2.2.4wps的的官网的下载网站是什么(wps下载电脑版链接打不开) bean延迟初始化和实时初始化(lazy-init)

　　在bean定义的时候通过lazy-init属性来配置bean是否是延迟加载，true：延迟初始化，false：实时初始化

　　2.2.4.1 实时初始化

　　在容器启动过程中被创建组装好的bean，称为实时初始化的bean，spring中默认都是实时初始化的bean，这些bean默认都是单例的，在容器启动过程中会被创建好，然后放在spring容器中以供使用

　　优点：

　　(1) 实时初始化的bean如果定义有问题，会在容器启动过程中会抛出异常，让开发者快速发现问题

　　(2) 容器启动完毕之后，实时初始化的bean已经完全创建好了，此时被缓存在spring容器中，当我们需要使用的时候，容器直接返回就可以了，速度是非常快的

　　2.2.4.2 延迟初始化

　　延迟初始化的bean在容器启动过程中不会创建，而是需要使用的时候才会去创建。

　　什么时候bean会被使用：

　　(1)被其他bean作为依赖进行注入的时候，比如通过property元素的ref属性进行引用，通过构造器注入、通过set注入、通过自动注入，这些都会导致被依赖bean的创建。

　　(2)调用容器的getBean方法获取bean

　　2.2.5 使用继承简化bean配置(abstract & parent)

　　当多个类中的属性配置完全一样是，可以进行简化。

　　通过继承优化代码：

　　将公共的代码提取出来，定义一个abstract="true"的属性，没有class，表示这个bean是抽象的，在spring容器中不会被创建，只是会将其当做bean定义的模板。从容器中查找abstract=true的bean的时候，会报错BeanIsAbstractException异常。bean的parent属性可以指定当前bean的父bean，子bean可以继承父bean中配置信息。子bean中也可自定义父bean中已经定义的配置，这样子会覆盖父bean中的配置信息。

　　2.2.6 单例bean中使用多例bean(lookup-method)

　　lookup-method：方法查找，可以对指定的bean的方法进行拦截，然后从容器中查找指定的bean作为被拦截方法的返回值

　　详见博客：Spring创建bean实例的常用四种方式

　　通过无参构造器创建bean实例通过set方法给bean的属性设置值和其他bean的引用将bean时实例传递给bean后置处理器postProcessBeforeInitialization调用配置好的bean的初始化方法将bean时实例传递给bean后置处理器postProcessAfterInitializationbean已创建调用配置好的bean的销毁方法

　　使用Spring前：所有对象的创建和组装都是使用者自己控制的。如果依赖多个对象的话，代码量较大，不方便维护，耦合度较高（依赖有调整时，改动比较大），不利于扩展

　　

　　使用spring后：将对象创建和组装的主动控制权交给spring容器，使用者只需要去容器查找需要的对象就可以了。对象的构建过程被反转了，所以叫做控制反转。

　　IoC优点：IoC是面向对象编程中的一种设计原则，主要是为了降低系统代码的耦合度，让系统有利于扩展和维护。

　　指spring容器在创建对象时给其依赖对象设置值的方式。

　　3.2.1 手动注入(xml方式)

　　3.2.1.1 构造器注入

　　根据构造器参数索引注入

　　注意：通过参数索引注入对参数顺序有很强的依赖性，若构造函数参数位置被调整过，会导致注入出错；可以通过新增构造函数来解决。

　　2. 根据构造器参数类型注入

　　根据构造器参数名称注入

　　注意：关于参数名称可能不稳定的问题，spring提供了解决方案，通过ConstructorProperties注解来定义参数的名称，将这个注解加在构造方法上面，如下：

　　3.2.1.2 set方法注入

　　注意：setter注入相对于构造函数注入要灵活一些，构造函数需要指定对应构造函数中所有参数的值，而setter注入的方式没有这种限制，不需要对所有属性都进行注入，可以按需进行注入

　　3.2.1.3 注入容器中的bean

　　3.2.1.3.1 ref方式

　　3.2.1.3.2 内置bean方式wps官网下载入口在哪里

　　案例：

　　PersonModel

　　UserModel

　　CarModel

　　beans.xml

　　3.2.1.4 其他类型注入

　　注入java.util.List（list元素）

　　注入java.util.Set（set元素）

　　注入java.util.Map（map元素）

　　注入数组（array元素）

　　注入java.util.Properties（props元素）

　　注入null值或者空串

　　3.2.2 自动注入(xml方式和注解方式)

　　3.2.2.1 自动注入之xml方式

　　byName：会自动在容器上下文查找和自己对象里的属性的set方法后面的值相同的bean的id，需要保证IOC容器里bean的id要全局唯一byType：会自动在容器上下文查找和自己对象里的属性的set方法参数类型相同的bean,需要保证IOC容器里bean的类型要全局唯一constructor：判断当前构造器所有参数是否在容器中都可以找到匹配的bean对象，如果可以找到就使用这个构造器进行注入。default：根元素beans下有个default-autowire属性，这个属性可以批量设置当前文件中所有bean的自动注入的方式。

　　3.2.3.2 自动注入之注解方式

　　注意：spring全注解开发只需要在beans.xml中配置包扫描

　　3.2.3.2.1 @Autowired

　　@Autowired为spring的注解，默认通过ByType注入，当通过byType无法唯一确定bean的时候再通过byName查找.

　　当容器中有多个该对象时，通过ByType和byName都无法确定时，需要**@Qualifier**的value属性指定唯一的bean对象注入

　　3.2.3.2.2 @Resource

　　@Resource为java的注解，先通过ByName去容器中找，找不到再通过ByType类型去找;

　　当容器中有多个该对象时，通过ByType和byName都无法确定时，通过@Resource的name属性指定唯一的bean对象注入。

　　3.2.3.2.2 @Value

　　注意：spring4之后使用注解需要先导入aop依赖。

　　4.1.1 @Compent，@Repository，@Service，@Controller

　　@Component 意思是组件，加在类上说明这个类被spring管理了，相当于一个bean.

　　@Component 等价于

　　@Value 等价于，也可以加在set方法上

　　@Component的衍生注解：在web开发中，会按照mvc三层架构分层

　　dao：@Repositoryservice：@Servicecontroller：@Controller

　　注意：这四个注解的功能是一样的，都是将某个类注册到spring容器中，创建并装配bean

　　4.1.2 配置包扫描

　　4.1.2.1在 beans.xml配置注解扫描

　　4.1.2.2 包扫描的两种细节配置方式：

　　4.2.1 @Configuration和@Bean

　　JavaConfig是spring的一个子项目，在spring4之后，它成为了核心功能

　　等价于

　　@Configuration ：代表这是一个配置类，和spring的beans.xml配置文件是等价的，这个注解配置的类会被spring托管，注册到容器中，也是一个@Component@Bean ：注册一个bean，相当于beans.xml里面的,@Bean方法的名字相当于的id属性，方法的返回值相当于的class属性@Import ：当有多个config配置类是。也可以通过@Import(类.class)进行组合@ComponentScan：指定要扫描的包，该包下的注解就会生效通过AnnotationConfigApplicationContext来加载@Configuration注解修饰的类

　　4.2.2 spring中，类上加不加@Configuration注解，有什么区别?

　　@Configuration注解修饰的类，会被spring通过cglib做增强处理，通过cglib会生成一个代理对象，代理会拦截所有被@Bean注解修饰的方法，可以确保创建的bean是单例的，多次调用时时同一个bean。不加该注解则生成的生成的时多例的bean。不管@Bean所在的类上是否有@Configuration注解，都可以将@Bean修饰的方法作为一个bean注册到spring容器中只有当该配置类作为获取容器的方法AnnotationConfigApplicationContext的参数时，配置类上的@Configuration可以不写。如果配置类上都不加@Configuration注解，那么可以把这些配置类作为参数传到AnnotationConfigApplicationContext方法里。

　　案例：bean之间是有依赖关系

　　ServiceA

　　ServiceB

　　MyConfig

　　测试

　　结果：

　　1.有@Configuration

　　

　　2.没有@Configuration

　　

　　4.3.1 @ComponentScan和ComponentScans（bean批量注册）

　　@ComponentScan用于批量注册bean，spring会按照这个注解的配置，递归扫描指定包中的所有类，将满足条件的类批量注册到spring容器中可以通过value、basePackages、basePackageClasses 这几个参数来配置包的扫描范围可以通过useDefaultFilters、includeFilters、excludeFilters这几个参数来配置类的过滤器，被过滤器处理之后剩下的类会被注册到容器中指定包名的方式配置扫描范围存在隐患，包名被重命名之后，会导致扫描实现，所以一般我们在需要扫描的包中可以创建一个标记的接口或者类，作为basePackageClasses的值，通过这个来控制包的扫描范围@CompontScan注解会被ConfigurationClassPostProcessor类递归处理，最终得到所有需要注册的类

　　4.3.1.1 源码定义

　　常用参数：

　　value：指定需要扫描的包，如：com.javacode2018basePackages：作用同value；value和basePackages不能同时存在设置，可二选一basePackageClasses：指定一些类，spring容器会扫描这些类所在的包及其子包中的类nameGenerator：自定义bean名称生成器resourcePattern：需要扫描包中的那些资源，默认是：**/*.class，即会扫描指定包中所有的class文件useDefaultFilters：对扫描的类是否启用默认过滤器，默认为trueincludeFilters：过滤器：用来配置被扫描出来的那些类会被作为组件注册到容器中excludeFilters：过滤器，和includeFilters作用刚好相反，用来对扫描的类进行排除的，被排除的类不会被注册到容器中lazyInit：是否延迟初始化被注册的bean@Repeatable(ComponentScans.class)，这个注解可以同时使用多个

　　4.3.1.2 工作过程：

　　Spring会扫描指定的包，且会递归下面子包，得到一批类的数组然后这些类会经过上面的各种过滤器，最后剩下的类会被注册到容器中

　　4.3.1.3 关键问题：

　　需要扫描哪些包？

　　通过value、backPackages、basePackageClasses这3个参数来控制过滤器有哪些？

　　通过useDefaultFilters、includeFilters、excludeFilters这3个参数来控制过滤器

　　4.3.1.4 扫描规则：

　　默认情况下，任何参数都不设置的情况下会将@ComponentScan修饰的类所在的包作为扫描包。

　　默认情况下，useDefaultFilters=true，spring容器内部会使用默认过滤器，规则是：凡是类上有@Repository、@Service、@Controller、@Component这几个注解中的任何一个的，那么这个类就会被作为bean注册到spring容器中，所以默认情况下，只需在类上加上这几个注解中的任何一个，这些类就会自动交给spring容器来管理了。

　　4.3.1.5 案例1：任何参数未设置

　　分别在dao，controller，service包下创建类，用@Service,@Controller,@Repository注解标注

　　UserService

　　UserController

　　UserDao

　　UserModel

　　ScanBean

　　测试

　　使用AnnotationConfigApplicationContext作为ioc容器，将ScanBean.class作为参数传入，默认会扫描ScanBean类所在的包中的所有类，类上有@Component、@Repository、@Service、@Controller任何一个注解的都会被注册到容器中

　　

　　4.3.1.6 案例2：指定需要扫描的包

　　指定需要扫毛哪些包，可以通过value或者basePackage来配置，二者选其一，都配置运行会报错，下面我们通过value来配置

　　测试结果

　　

　　4.3.1.7 案例：basePackageClasses指定扫描范围

　　指定包名的方式扫描存在的一个隐患，若包被重名了，会导致扫描会失效，我们可以在需要扫描的包中定义一个标记的接口或者类，他们的唯一的作用是作为basePackageClasses的值，其他没有任何用途。

　　定义一个类或者接口

　　4.3.1.8 includeFilters和excludeFilters的使用

　　是一个Filter类型的数组，多个Filter之间为或者关系，即满足任意一个就可以了，看一下Filter的代码：

　　主要参数：

　　type：过滤器的类型，是个枚举类型，5种类型

　　ANNOTATION：通过注解的方式来筛选候选者，即判断候选者是否有指定的注解

　　ASSIGNABLE_TYPE：通过指定的类型来筛选候选者，即判断候选者是否是指定的类型

　　ASPECTJ：ASPECTJ表达式方式，即判断候选者是否匹配ASPECTJ表达式

　　REGEX：正则表达式方式，即判断候选者的完整名称是否和正则表达式匹配

　　CUSTOM：用户自定义过滤器来筛选候选者，对候选者的筛选交给用户自己来判断

　　value：和参数classes效果一样，二选一

　　classes：3种情况如下

　　当type=FilterType.ANNOTATION时，通过classes参数可以指定一些注解，用来判断被扫描的类上是否有classes参数指定的注解

　　当type=FilterType.ASSIGNABLE_TYPE时，通过classes参数可以指定一些类型，用来判断被扫描的类是否是classes参数指定的类型

　　当type=FilterType.CUSTOM时，表示这个过滤器是用户自定义的，classes参数就是用来指定用户自定义的过滤器，自定义的过滤器需要实现org.springframework.core.type.filter.TypeFilter接口

　　pattern：2种情况如下

　　当type=FilterType.ASPECTJ时，通过pattern来指定需要匹配的ASPECTJ表达式的值

　　当type=FilterType.REGEX时，通过pattern来自正则表达式的值

　　4.3.1.8.1 扫描包含注解的类

　　我们自定义一个注解，让标注有这些注解的类自动注册到容器中

　　创建一个类，使用这个注解标注

　　再来一个类，使用spring中的标注

　　再来一个类，使用@CompontentScan标注

　　测试用例

　　结果

　　

　　问题：Service1上标注了@MyBean注解，被注册到容器了，但是没有标注@MyBean啊，怎么也被注册到容器了？

　　回答：@CompontentScan注解中的useDefaultFilters默认是true，表示会启用默认的过滤器，默认的过滤器会将标注有@Component、@Repository、@Service、@Controller这几个注解的类也注册到容器中。

　　修改扫描代码：

　　如果我们只想将标注有@MyBean注解的bean注册到容器，需要将默认过滤器关闭，即：useDefaultFilters=false

　　再输出：

　　

　　4.3.1.8.2 包含指定类型的类

　　被扫描的类满足IService.class.isAssignableFrom(被扫描的类)条件的都会被注册到spring容器中

　　@ComponentScan(

　　useDefaultFilters = false,

　　includeFilters = {

　　@ComponentScan.Filter(type= FilterType.ASSIGNABLE_TYPE,classes = IService.class)}

　　)

　　接口

　　实现类

　　@CompontentScan标注的类

　　测试：

　　

　　4.3.1.8.3 自定义Filter

　　步骤：

　　1.设置@Filter中type的类型为：FilterType.CUSTOM

　　2.自定义过滤器类，需要实现接口：org.springframework.core.type.filter.TypeFilter

　　3.设置@Filter中的classses为自定义的过滤器类型

　　TypeFilter这个接口的定义：

　　是一个函数式接口，包含一个match方法，方法返回boolean类型，有2个参数，都是接口类型的，下面介绍一下这2个接口

　　MetadataReader接口：

　　类元数据读取器，可以读取一个类上的任意信息，如类上面的注解信息、类的磁盘路径信息、类的class对象的各种信息，spring进行了封装，提供了各种方便使用的方法。

　　MetadataReader接口的定义：

　　MetadataReaderFactory接口：

　　类元数据读取器工厂，可以通过这个类获取任意一个类的MetadataReader对象

　　MetadataReaderFactory接口定义：

　　案例：

　　需求：我们来个自定义的Filter，判断被扫描的类如果是IService接口类型的，就让其注册到容器中。

　　接口

　　实现类

　　自定义的TypeFilter类：

　　@CompontentScan标注的类

　　4.3.1.9 @ComponentScan重复使用

　　4.3.2 @Import使用：bean的批量注册

　　@Import可以用来批量导入需要注册的各种类，如普通的类、配置类，然后完成普通类和配置类中所有bean的注册。

　　@Import可以使用在任何类型上，通常情况下，类和注解上用的比较多。

　　value：一个Class数组，设置需要导入的类，可以是@Configuration标注的列，可以是ImportSelector接口或者ImportBeanDefinitionRegistrar接口类型的，或者需要导入的普通组件类。

　　当使用AnnotationConfigApplicationContext(MyConfig.class)加载配置类创建容器时，方法参数为某个主配置类的字节码文件,此时主配置类上可以不用加@Configuration注解。当有多个创建bean的配置类时，通过**@Import**注解在主配置类上进行导入其他配置类，此时其他配置类上也可以不加@Configuration注解。

　　源码：

　　@Import的value常见的有5种用法：

　　value为普通的类

　　通过@Import导入的2个类，bean名称为完整的类名,可以使用@Compontent注解指定被导入类的bean名称

　　value为@Configuration标注的类

　　value为@CompontentScan标注的类

　　项目中分多个模块，每个模块有各自独立的包，我们在每个模块所在的包中配置一个@CompontentScan类，然后通过@Import来导入需要启用的模块

　　第一个组件的包及里面的类：

　　第二个组件的包及里面的类：

　　总配置类：通过@Import导入每个模块中的组件扫描类

　　value为ImportBeanDefinitionRegistrar接口类型

　　这个接口提供了通过spring容器api的方式直接向容器中注册bean

　　importingClassMetadata：AnnotationMetadata类型的，通过这个可以获取被@Import注解标注的类所有注解的信息。

　　registry：BeanDefinitionRegistry类型，是一个接口，内部提供了注册bean的各种方法。

　　importBeanNameGenerator：BeanNameGenerator类型，是一个接口，内部有一个方法，用来生成bean的名称。

　　BeanDefinitionRegistry接口：bean定义注册器，提供了bean注册的各种方法，基本上所有bean工厂都实现了这个接口，让bean工厂拥有bean注册的各种能力，AnnotationConfigApplicationContext类也实现了这个接口

　　BeanNameGenerator接口：bean名称生成器

　　这个接口spring有三个内置的实现：

　　DefaultBeanNameGenerator：默认bean名称生成器，xml中bean未指定名称的时候，默认就会使用这个生成器，默认为：完整的类名#bean编号

　　AnnotationBeanNameGenerator：注解方式的bean名称生成器，比如通过@Component(bean名称)的方式指定bean名称，如果没有通过注解方式指定名称，默认会将完整的类名作为bean名称。

　　FullyQualifiedAnnotationBeanNameGenerator：将完整的类名作为bean的名称

　　BeanDefinition接口：bean定义信息，用来表示bean定义信息的接口，我们向容器中注册bean之前，会通过xml或者其他方式定义bean的各种配置信息，bean的所有配置信息都会被转换为一个BeanDefinition对象，然后通过容器中BeanDefinitionRegistry接口中的方法，将BeanDefinition注册到spring容器中，完成bean的注册操作。

　　案例：

　　Service1：

　　Service2：需要注入Service1

　　定义一个类实现ImportBeanDefinitionRegistrar接口，然后在里面实现上面2个类的注册

　　定义配置类导入实现类

　　测试：

　　value为ImportSelector接口类型

　　ImportSelector接口：

　　案例：

　　普通类：Service1

　　@Configuration标注的配置类：Module1Config

　　自定义一个ImportSelector，然后返回上面2个类的名称

　　@Import标注的类，导入MyImportSelector

　　测试

　　value为DeferredImportSelector接口类型

　　DeferredImportSelector是ImportSelector的子接口，既然是ImportSelector的子接口，所以也可以通过@Import进行导入。和ImportSelector不同地方有两点：延迟导入和指定导入的类的处理顺序。

　　延迟导入：

　　@Import的value包含了多个普通类、多个@Configuration标注的配置类、多个ImportSelector接口的实现类，多个ImportBeanDefinitionRegistrar接口的实现类，还有DeferredImportSelector接口实现类，此时spring处理这些被导入的类的时候，会将DeferredImportSelector类型的放在最后处理，会先处理其他被导入的类，其他类会按照value所在的前后顺序进行处理

　　案例：

　　来3个配置类，每个配置类中都通过@Bean定一个string类型的bean，内部输出一句文字。

　　Configuration1：

　　Configuration2：

　　Configuration3：

　　一个ImportSelector实现类，导入Configuration1

　　一个DeferredImportSelector实现类，导入Configuration2

　　一个总的配置类

　　测试及输出：

　　输出的结果结合一下@Import中被导入的3个类的顺序，可以看出DeferredImportSelector1是被最后处理的，其他2个是按照value中所在的先后顺序处理的。

　　指定导入的类的处理顺序：

　　@Import中有多个DeferredImportSelector接口的实现类时候，可以指定他们的顺序，指定顺序常见2种方式：

　　实现Ordered接口的方式：

　　实现Order注解的方式：

　　案例：

　　2个配置类，内部都有一个@Bean标注的方法，用来注册一个bean

　　Configuration1：

　　Configuration2：

　　来2个DeferredImportSelector实现类，分别来导入上面2个配置文件，顺便通过Ordered接口指定一下顺序，DeferredImportSelector1的order为2，DeferredImportSelector2的order为1，order值越小优先级越高

　　DeferredImportSelector1：

　　DeferredImportSelector2：

　　来个总的配置类，引入上面两个ImportSelector

　　MainConfig8：

　　测试输出：

　　4.3.2.1 案列

　　需求：

　　凡是类名中包含service的，调用他们内部任何方法，我们希望调用之后能够输出这些方法的耗时

　　实现分析：

　　我们可以通过代理来实现，bean实例创建的过程中，我们可以给这些bean生成一个代理，在代理中统计方法的耗时，这里面有2点：wps office免费版下载的网址怎么找(金山wps官网电话)

　　创建一个代理类，通过代理来间接访问需要统计耗时的bean对象拦截bean的创建，给bean实例生成代理生成代理

　　具体实现：

　　Service1

　　Service2

　　创建统计耗时的代理类：用cglib来实现一个代理类

　　拦截bean实例的创建，返回代理对象

　　需要将MethodCostTimeProxyBeanPostProcessor注册到容器中才会起作用，下面我们通过@Import结合ImportSelector的方式来导入这个类，将其注册到容器中

　　来一个@Import来导入MethodCostTimeImportSelector，下面我们使用注解的方式，在注解上使用@Import

　　来一个总的配置类

　　上面使用了@CompontentScan注解，此时会将Servce1和Service2这两个类注册到容器中wps官网下载的网址怎么找。

　　@1：此处使用了@EnableMethodCostTime注解，而@EnableMethodCostTime注解上使用了@Import(MethodCostTimeImportSelector.class)，此时MethodCostTimeImportSelector类中的MethodCostTimeProxyBeanPostProcessor会被注册到容器，会拦截bean的创建，创建耗时代理对象。

　　测试：

　　结果：

　　如果我们不想开启方法耗时统计，只需要将MainConfig6上的@EnableMethodCostTime去掉就可以了

　　spring中有很多类似的注解，以@EnableXXX开头的注解，基本上都是通过上面这种方式实现的，如：

　　4.3.3 @Conditional 通过条件控制Bean的注册

　　请浏览另一篇博客：@Conditional注解的详解和应用

　　4.3.3 @Import使用：bean的批量注册

　　关于注解定义的详解，浏览博客：Java注解的定义和使用以及spring对注解的增强

　　5.1.1 什么是代理模式？

　　

　　为其它对象提供一个代理以控制对这个对象的访问，在某些情况下，一个对象不适合或不能直接访问另一个对象，而代理可以在客户类与目标对象之间起到中介的作用。具有这种访问关系呈现出来的模式称之为代理模式

　　5.1.2 代理的作用

　　功能增强：在原有功能的基础上增加了额外的功能控制访问：代理类不让客户能直接访问目标对象

　　5.2.1 静态代理

　　(1) 含义：

　　静态代理类是手工创建的一个java类，所要代理的目标是确定的。代理类包含了目标对象，在对目标对象的方法进行调用时可以进行功能增强。

　　(2)图示

　　

　　代理类B、C和目标类D、E均实现了接口F中抽象方法出售U盘的功能。但厂家D、E不向个人客户A直接出售，只向代理商家B、C出售。某一天，F新增了U盘的某功能，类B、C、D、E均要修改

　　(3)角色分析

　　抽象角色（租房）：一般是接口或者抽象类真实角色（房东）：被代理的角色代理角色（中介）：代理真实角色，可以做扩展操作,比如看房子，收中介费等客户：访问代理对象的人

　　(4)优缺点

　　静态代理模式好处：

　　可以使真实角色的操作更加纯粹，不用去关注一些公共的业务公共业务交给代理角色,实现业务的分工公共业务发生扩展的时候，方便集中管理静态代理模式缺点：

　　为了个性化增强，每一个真实的角色就会产生一个代理角色，代码量会翻倍，开发效率会变低当接口变化时，代理类和被代理类都要相应变化。

　　(5)demo展示

　　接口类

　　真实角色类实现接口

　　代理角色类代理真实角色类

　　如果UserServiceITwompl也实现了UserService，那么也要编写UserServiceTwoImplProxy

　　客户类

　　5.2.2 动态代理

　　(1)含义

　　在程序执行过程中，JDK利用反射机制创建对象的能力创建代理对象，不用创建代理类。代理目标不是确定的，而是可活动的，变化的。

　　动态代理支持在系统运行期给类动态添加代理，然后通过操控代理类完成对目标类的调用

　　(2)分类

　　动态代理分为两大类：基于接口的动态代理：JDK动态代理：

　　使用java反射包java.lang.reflect中的类和接口实现动态代理的功能类：Proxy，Method接口：InvocationHandler 基于类的动态代理：cglib动态代理：

　　第三方的开源项目，高效的code生成类库，可以在运行期间扩展java类，实现java接口，被广泛的AOP框架使用

　　使用JDK动态代理，要求目标类与代理类实现相同接口。若目标类没实现接口，则不能使用该方法实现。此时可以考虑使用cgLib。cgLib代理的生成原理是生成目标类的子类，子类对象即代理对象。因此目标类不能是final的。

　　(3)优缺点

　　动态代理模式好处：

　　可以使真实角色的操作更加纯粹，不用去关注一些公共的业务公共业务交给代理角色,实现业务的分工公共业务发生扩展的时候，方便集中管理一个动态代理类，可以代理实现了同一个接口的多个类当在接口中修改方法时，不用修改代理类JDK动态代理要求代理目标必须实现接口

　　在实际开发中，将日志、事务等与业务方法无关、但很多业务方法都要执行的代码放在InvocationHandler类invoke方法的功能增强中，这样一来：

　　解耦合，使业务代码与非业务代码分离，业务类专注于业务的实现减少代码复用

　　(5)demo

　　接口类

　　目标接口,定义目标类实现的功能

　　目标类

　　JDK动态代理要求代理目标必须实现接口

　　动态代理类

　　创建InvocationHandler的实现类，在invoke方法中实现代理功能

　　主要步骤：

　　创建动态代理的目标对象通过构造方法或者set方法注入目标对象，首选构造方法注入生成动态代理类对象,并将返回值转为接口类型调用应用处理程序的invoke方法处理代理实例，如有返回值，接收返回结果，可进行强制类型转换；在invoke实现功能增强（日志、事务等）

　　注意：

　　invoke方法是java.lang.reflect.InvocationHandler中的方法，此方法实现了对原有目标对象的业务方法的调用，即目标类的方法的调用，并在此基础上可以选择进行一定的功能增强。此方法的参数均为JDK管理，不需要人工传入：

　　Object proxy：目标类的代理对象Method method：目标类的业务方法对象Object[] args：目标类的业务方法所需的参数（例如本例业务方法没有参数，args为空）

　　创建动态代理类Proxy对象的参数：

　　第一个参数是目标类的类加载器，可看作固定写法第二个参数是目标类的接口对象，可看作固定写法，正是因为这个参数决定了JDK动态代理必须实现接口第三个参数是包含目标类的MyInvocationHandle 对象

　　客户类调用步骤：

　　创建目标对象创建InvocationHandle对象,构造器参数决定了代理目标,传谁代理谁创建代理对象,并将返回值强转为接口类型，强转成功的原因是目标对象target实现了 UserService接口实现代理的业务功能

　　5.3.1 概述

　　在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能：

　　所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务所谓的周边功能，比如性能统计，日志，事务管理等等

　　周边功能在 Spring 的面向切面编程AOP思想里，即被定义为切面

　　定义：AOP（Aspect Oriented Programming 面向切面编程），通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

　　目的：是将交叉业务逻辑封装成切面，利用 AOP 容器的功能将切面织入到主业务逻辑中，从而减少系统的重复代码量，并且能够降低模块间的耦合度，有利于程序代码的扩展和维护，降低了维护成本，提高了开发的效率。

　　交叉业务逻辑：是指通用的、与主业务逻辑无关，却被各个业务模块大量调用代码，如安全检查、事务、日志、缓存等。

　　

　　

　　

　　5.3.2 AOP的相关术语

　　横切关注点：跨越应用程序多个模块的方法或者功能。如：日志记录、缓存、安全检查、事务处理等。切面(Aspect)：横切关注点被模块化的对象，指封装好的用于插入业务逻辑功能的类，是对业务逻辑的一种增强连接点(Joinpoint)：指被切面织入的具体方法。通常业务接口中所有可以增强的方法均为连接点。Spring中一个连接点表示一个方法的调用切入点(Pointcut)：一个或者多个连接点的集合，定义了切面在何处执行，切点也是一个连接点，也指满足匹配规则的一组类或者方法通知/增强(Advice)：在切面类中定义的方法，也是在切点处要执行的代码，通知定义了通知代码切入到目标代码的时间点，是在目标代码之前执行还是之后执行，通知类型不同切入时间不同目标(Target)：将要被增强的对象。即包含主业务逻辑的类的对象代理(Proxy)：目标对象增强后创建的代理对象；织入(Wearving)：把切面应用到目标对象并创建新的代理对象的过程，切面在指

　　定的连接点被织入到目标对象中。

　　编译期：切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的类加载期：切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ 5的加载时织入（load-timeweaving，LTW）就支持以这种方式织入切面运行期：切面在应用运行的某个时刻被织入。一般情况下，在织

　　入切面时，AOP容器会为目标对象动态地创建一个代理对象。

　　Spring AOP就是以这种方式织入切面的引入(Introduction)：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段

　　

　　5.3.3 AOP实现方式

　　5.3.3.1 AOP的技术实现框架：

　　Spring：Spring的API实现较为笨重，一般用在事务处理aspectJ: 一个开源，专门做AOP的框架，隶属于Eclipse基金会

　　5.3.3.2 AspectJ 对 AOP 的实现

　　aspectJ框架实现AOP有两种方式:

　　使用xml配置文件，一般用于配置全局事务使用注解，一般在项目开发中使用这种方式

　　(1) AspectJ 的通知类型

　　AspectJ 中常用的通知有五种类型，体现在五个不同的添加在切面的注解：

　　前置通知：@Before后置通知：@AfterReturning、环绕通知：@Around、异常通知：@AfterThrowing、最终通知：@After

　　(2) AspectJ 的切入点表达式

　　① execution (* com.sample.service.impl…*. *(…))

　　execution(): 表达式主体。第一个星号：表示返回类型，星号表示所有的类型。包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包。第二个*号：表示类名，*号表示所有的类。*(…):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数② 通过方法签名定义切点

　　execution(public * *(…)) 匹配所有目标类的public方法

　　③ 通过类定义切点

　　execution(* com.baobaotao.Waiter.(…)) 匹配Waiter包下所有类的所有方法,参数不限

　　execution( com.baobaotao.Waiter+.(…)) 匹配Waiter接口及其所有实现类的方法

　　④ 通过类包定义切点

　　在类名模式串中，“.”表示包下的所有类，而“…”表示包、子孙包下的所有类

　　execution( com.baobaotao.(…)) 匹配com.baobaotao包下所有类的所有方法

　　execution( com.baobaotao…(…)) 匹配com.baobaotao包、子孙包下所有类的所有方法，如com.baobaotao.dao，com.baobaotao.servier以及 com.baobaotao.dao.user包下的所有类的所有方法都匹配。“…”出现在类名中时，后面必须跟“”，表示包、子孙包下的所有类

　　切入点表达式要匹配的对象就是目标方法的方法名。所以，execution 表达式中明显就是方法的签名。注意，表达式中加[ ]的部分表示可省略部分，各部分间用空格分开。

　　在其中可以使用以下符号：

　　*：0至多个任意字符

　　… ：用在方法参数中，表示任意多个参数；用在包名后，表示当前包及其子包

　　+：用在类名后，表示当前类及其子类；用在接口名后，表示当前接口及其实现类

　　(3) AspectJ 的开发环境

　　(4) beans.xml加入aop的约束

　　(5) AspectJ 的开启注解支持

　　注解支持的参数：

　　proxy-target-class=“false” JDK动态代理proxy-target-class=“true” cglib动态代理

　　(6) AspectJ 的通知注解

　　切面类：@Aspect 注解的类叫做切面类

　　通知注解：在切面类中修饰方法的注解，这些注解体现了通知类型。通知注解修饰的方法称之为通知方法，所有的通知方法都可包含JoinPoint类型参数

　　@Before前置通知

　　在目标方法执行之前执行。被注解为前置通知的方法，JoinPoint类型的参数的对象本身就是切入点表达式。通过该参数，可获取切入点表达式、方法签名、目标对象等

　　@AfterReturning后置通知-注解有 returning 参数

　　在目标方法执行之后执行，可以获取到目标方法的返回值。该注解的 returning 属性就是用于指定接收方法返回值的变量名的。被注解为后置通知的方法，除了可以包含 JoinPoint 参数外，还可以包含用于接收返回值的变量。该变量最好为 Object 类型，因为目标方法的返回值可能是任何类型。

　　@Around 环绕通知-增强方法有 ProceedingJoinPoint 参数

　　在目标方法执行之前之后执行。被注解为环绕增强的方法要有返回，Object 类型。并且方法可以包含一个 ProceedingJoinPoint 类型的参数。接口 ProceedingJoinPoint 继承于JoinPoint，因此可以根据它获取方法的信息。其有一个 proceed()方法，用于执行目标方法。若目标方法有返回值，则该方法的返回值就是目标方法的返回值。最后，环绕增强方法将其返回值返回。该增强方法实际是拦截了目标方法的执行；

　　ProceedingJoinPoint能获取连接点方法的定义，参数等信息

　　@AfterThrowing 异常通知-注解中有 throwing 属性

　　在目标方法抛出异常后执行。该注解的 throwing 属性用于指定所发生的异常类对象。当然，被注解为异常通知的方法可以包含一个参数 Throwable，参数名称为 throwing 指定的名称，表示发生的异常对象；在效果上相当于一个try…catch语句。目标方法的方法体在try语句块中，而切面方法的方法体放在了catch子句中@After最终通知

　　无论目标方法是否抛出异常，该增强均会被执行。在执行效果上，相当于将切面方法的方法体放在了try…catch…finally…语句发finally子句中。@Pointcut 定义切入点

　　当较多的通知增强方法使用相同的 execution 切入点表达式时，编写、维护均较为麻烦。 AspectJ 提供了@Pointcut 注解，用于定义 execution 切入点表达式。

　　其用法是，将@Pointcut 注解在一个方法之上，以后所有的 execution 的 value 属性值均可使用该方法名作为切入点。代表的就是@Pointcut 定义的切入点。这个使用@Pointcut 注解的方法一般使用 private 的标识方法，即没有实际作用的方法。方法体内部也无需添加代码。

　　有多个增强类对同一个方法进行增强时，设置增强类优先级@Order(数值类型)，数值越小优先级越高。

　　5.3.4 AOP具体实现方式

　　5.3.4.1 使用spring的API接口实现【主要是Spring API】

　　接口

　　创建目标类

　　通过spring API 创建要切入的通知

　　创建beans.xml

　　测试

　　测试结果

　　

　　5.3.4.2 使用自定义方式实现AOP【主要是切面】

　　接口

　　被切入的目标类

　　自定义切面

　　beans.xml

　　测试

　　测试结果

　　

　　5.3.4.3 使用注解的AOP实现

　　接口

　　目标类

　　切面

　　beans.xml

　　测试

　　测试结果

　　

　　Spring事务相关：Spring事务的实现和面试常问情形

　　事务是数据库操作的最基本单元，逻辑上的一组操作，要么都成功，如果有一个失败，所有操作都失败。

　　事务的四个特性：

　　原子性：事务是一个不可再分割的工作单位，事务中的操作要么都发生，要么都不发生

　　一致性：事务开始之前和事务结束以后，数据库的完整性约束没有被破坏

　　持久性：一个事务一旦提交，它对数据库中的数据的改变就是永久性的

　　隔离性：数据库存在多个事务同时操作时，保证各事务之间互不干扰，操作互不影响

　　7.1.1 事务管理器接口

　　事务管理器是 PlatformTransactionManager 接口对象。其主要用于完成事务的提交、回滚，及获取事务的状态信息。PlatformTransactionManager 接口有两个常用的实现类：

　　➢ DataSourceTransactionManager：JdbcTemplate 或 MyBatis 进行数据库操作时使用。

　　➢ HibernateTransactionManager： Hibernate 进行持久化数据时使用。

　　7.1.2 Spring 的回滚方式

　　Spring 事务的默认回滚方式是：发生运行时异常和 error 时回滚，发生编译时异常时提交.

　　运行时异常：是 RuntimeException 类或其子类，即只有在运行时才出现的异常。如， NullPointerException、ArrayIndexOutOfBoundsException、IllegalArgumentException 等均属于运行时异常。这些异常由 JVM 抛出，在编译时不要求必须处理。只要代码编写足够仔细，程序足够健壮，运行时异常是可以避免的。

　　编译时异常：即在代码编写时要求必须捕获或抛出的异常，若不处理，则无法通过编译。如 SQLException，ClassNotFoundException，IOException 等都属于编译时异常。 RuntimeException 及其子类以外的异常，均属于编译时异常。

　　7.1.3 事务定义接口

　　事务定义接口TransactionDefinition中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限，及对它们的操作。

　　1.定义了五个事务隔离级别常量

　　事务的隔离级别：定义一个事务可能受其他并发事务活动影响的程度，事务的隔离级别可以想象为这个事务处理数据的自私程度。

　　如果不考虑事务的隔离性，在事务的并发操作中可能会出现脏读，不可重复读，幻读：

　　脏读（Dirty read）：一个事务读取了被另一个事务修改但未提交的数据时。如果这些数据稍后被回滚了，那么第一个事务读取的数据就会是无效的

　　不可重复读（Nonrepeatable read）：一个事务多次执行相同的查询，但每次查询结果都不相同。这通常是因为另一个并发事务在两次查询之间更新了该条数据并提交。不可重复读重点在修改

　　幻读（Phantom reads）：当一个事务读取几行记录后，另一个并发事务插入或者删除了一些记录。在后来的查询中，第一个事务看到原来没有的记录。幻读重点在新增或删除

　　区别：

　　脏读和不可重复读的区别：脏读是某一事务读取了另一个事务未提交的脏数据；而不可重复读则是在同一个事务范围内多次查询同一条数据却返回了不同的数据，这是由于在查询间隔期间，该条数据被另一个事务修改并提交了。

　　幻读和不可重复读区别：幻读和不可重复读都是读取了另一个事务中已经提交的数据，不同的是不可重复读多次查询的都是同一个数据项，针对的是对同一行数据的修改；而幻读针对的是一个数据整体（如：数据条数），主要是新增或者删除

　　在理想状态下，事务之间将完全隔离，从而可以防止这些问题发生。然而，完全隔离会影响性能，因为隔离经常涉及到锁定在数据库中的记录（甚至有时是锁表）。完全隔离要求事务相互等待来完成工作，会阻碍并发。因此，可以根据业务场景选择不同的隔离级别：

　　隔离级别含义ISOLATION_DEFAULT采用 DB 默认的事务隔离级别ISOLATION_READ_UNCOMMITTED允许读取尚未提交的更改。可能导致脏读、幻读或不可重复读ISOLATION_READ_COMMITTED（Oracle 默认级别）允许从已经提交的并发事务读取，保证了一个事务不会读到另一个并行事务已修改但未提交的数据。可防止脏读，但幻读和不可重复读仍可能会发生。ISOLATION_REPEATABLE_READ（MYSQL默认级别）可重复读，保证一个事务不能读取另一个事务已修改但未提交的数据并且在开始读取数据时，不再允许其他事务进行修改操作。可防止脏读和不可重复读，但幻读仍可能发生ISOLATION_SERIALIZABLE完全服从ACID的隔离级别，确保不发生脏读、不可重复读和幻影读。这在所有隔离级别中也是性能最慢的，因为它通常是通过完全锁定当前事务所涉及的数据表来完成的。

　　并发性能：Read Uncommitted > Read Committed > Repeatable Read > Serializable

　　隔离级别：Read Uncommitted < Read Committed < Repeatable Read < Serializable

　　隔离级别越低，并发性能越高

　　2.定义了七个事务传播行为常量

　　所谓事务传播特性就是多个事务方法相互调用时，事务如何在这些方法间传播。一般用在事务嵌套的场景。

　　如：A类中的事务方法 add()调用B类中的事务方法update()，在调用执行期间事务的维护情况，就称为事务传播行为。

　　传播特性含义PROPAGATION_REQUIRED如果外层有事务，则当前事务加入到外层事务，内外部方法均属于同一个事务，一块提交，一块回滚。如果外层没有事务，内部方法为自己新开启一个事务，且内部方法的事务之间互不干扰。出现异常时只回滚自己，外层方法不会回滚PROPAGATION_REQUIRES_NEW如果外层有事务，内部方法每次都会单独新开启一个事务，同时把外层事务挂起，当内部事务执行完毕，恢复外围事务的执行，内部事务抛出异常会被外部事务感知，自己捕获后只回滚自己则不会被外围事务感知。内外部事务之间，内部事务和方法之间互相独立互不干扰。如果外层没有开启事务，执行当前内部方法新开启的事务，且内部的事物之间互不干扰，出现异常时只回滚自己PROPAGATION_SUPPORTS如果外层有事务，则加入外层事务，如果外层没有事务，则直接使用非事务方式执行。完全依赖外层的事务PROPAGATION_NOT_SUPPORTED该传播机制不支持事务，如果外层存在事务则挂起，执行完当前代码，则恢复外层事务，无论是否异常都不会回滚当前的代码PROPAGATION_NEVER该传播机制不支持外层事务，即如果外层有事务就抛出异常PROPAGATION_MANDATORY如果外层没有事务，则抛出异常PROPAGATION_NESTED外围事务未开启时，作用与REQUIRED相同，内部方法都会新开启自己的事务，并且互不干扰。外围开启事务时，内部事务是外部事务的子事务，外围事务回滚，子事务一定回滚；同时内部方法抛出异常回滚，外围事务感知异常导致整体事务回滚。还有一点，内部方法事务是外围的一个子事务，有单独的保存点，所以方法抛出异常捕获后可以单独回滚，不影响外围主事务和其他子事务

　　注意：什么是事务挂起操作？

　　可以这样理解，对当前存在事务的现场生成一个快照，然后将事务现场清理干净，然后重新开启一个新事物，新事物执行完毕之后，将事务现场清理干净，在根据前面快照恢复旧事务

　　1.开启注解驱动

　　2.声明事务管理器

　　3.业务层 public 方法加入事务属性的注解

　　@Transactional 的所有可选属性如下所示：

　　➢ propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为 Propagation.REQUIRED。

　　➢ isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认值为 Isolation.DEFAULT。

　　➢ readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值为 false。

　　➢ timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为 -1，即没有时限。在实际业务开发中一般不设置。

　　➢ rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。若只有一个异常类时，可以不使用数组。

　　➢ rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

　　➢ noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

　　➢ noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，默认值为空数组。若只有一个异常类时，可以不使用数组。

　　需要注意的是，@Transactional 若用在方法上，只能用于 public 方法上。对于其他非 public 方法，如果加上了注解@Transactional，虽然 Spring 不会报错，但不会将指定事务织入到该方法中。因为 Spring 会忽略掉所有非 public 方法上的@Transaction 注解。若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时织入事务

　　1.添加Maven依赖

　　2.声明事务管理器

　　3.配置事务通知

　　4.配置增强器

2025年3月2日
wps office免费版下载的网址的方法

　　

　　Sentinel-dashboard官方下载地址：https://github.com/alibaba/Sentinel/releases

　　下载jar包

　　

　　SpringCloud Alibaba 官方版本说明：https://github.com/alibaba/spring-cloud-alibaba/wiki/%E7%89%88%E6%9C%AC%E8%AF%B4%E6%98%8E

　　Spring Cloud Alibaba Sentinel官网文档:https://github.com/alibaba/spring-cloud-alibaba/wiki/Sentinel

　　Sentinel-dashboard需要在JDK1.8及以上的版本登录

　　由于Sentinel-dashboard使用Springboot写的一个项目，所以默认是集成了Tomcat，所以启动的时候需要修改端口号。

　　2.1.1 Sentinel-dashboard启动命令

　　这里使用端口作为访问Snetinel-dashboard的管理页面的端口号

　　【不指定输出日志的命令示例】

　　

　　【指定输出日志的命令】

　　访问地址http://localhost:8070/

　　

　　Sentinel-dashboard的登录密码和账户：

　　账户： sentinel

　　密码： sentinel

　　2.1.2 Sentinel dashboard控制台启动配置项

　　Dserver.port=8080：用于指定 Sentinel 控制台端口为 8080，如若8080端口冲突，可使用 -Dserver.port=新端口进行设置。。Dcsp.sentinel.dashboard.server=localhost:8080：指定控制台地址和端口，会自动向该地址发送心跳包。地址格式为：hostIp:port，l配置成ocalhost:8080即监控自己Dproject.name&wps office 官方下载地方#61;sentinel-dashboard：wps 的官网最新的下载入口是多少指定Sentinel控制台程序显示的名称

　　-Dcsp.sentinel.log.dir：指定Sentinel 日志文件目录，默认是：${user.home}/logs/csp/Dcsp.sentinel.api.port=xxxx：本地的 Sentinel 客户端端口（可选，默认是 8719，有冲突会尝试向后探测）。若启动多个应用，则需要通过 -Dcsp.sentinel.api.port=xxxx 指定客户端监控 API 的端口（默认是 8719）。Dcsp.sentinel.app.type=1：从 1.6.3 版本开始，控制台支持网关流控规则管理。启动参数以将您的服务标记为 API Gateway，在接入控制台时您的服务会自动注册为网关类型，然后您即可在控制台配置网关规则和 API 分组。

　　用户可以通过如下参数进行鉴权配置：

　　Dsentinel.dashboard.auth.username=sentinel 用于指定控制台的登录用户名为 sentinel；Dsentinel.dashboard.auth.password=123456 用于指定控制台的登录密码为 123456；如果省略这两个参数，默认用户和密码均为 sentinel；Dserver.servlet.session.timeout=7200 用于指定 Spring Boot 服务端 session 的过期时间，如 7200 表示 7200 秒；60m 表示 60 分钟，默认为 30 分钟；

　　同样也可以直接在 Spring properties 文件中进行配置。

　　注意：部署多台控制台时，session 默认不会在各实例之间共享，这一块需要自行改造。

　　这里说明一下：我们如果想要自定义一个Sentinel-dashboard的项目，则可以通过启动时配置一定的启动参数来完成，具体如下：

　　这里是指定一个名称为sentinel-helloworld的项目，

　　然后在eclispe里面通过配置JVM启动参数来实现将服务的流量监控数据同步到sentinel-dashboard的控制面板上

　　

　　

　　启动完成后，多刷新几次，保证数据同步过来，也可以测试几次失效流量控制的情况

　　

　　出现问题：但是这样子有的情况下我也不清楚具体原因是什么，就是出不来，然后我就重新引入了另外的Sentinel的依赖

　　解决问题：

　　通过配置文件的方式来完成dashBoard的搭建

　　这时候我们再次重启Sentinel-dashboard和HelloWorld的这个项目

　　访问localhost:8080

　　登录，多次刷新应用程序

　　

　　然后后来我有用Idea去使用我第一次的写法尝试后，是没有问题的，可能是我的Eclispe配置的问题，总之，是成功搭建完成了Sentinel-dashboard的环境

　　上一篇的末尾写了一个使用代码的方式编程完成流量控制的方式。

　　这里我们把编程式的流量控制规则代码注释掉以后，再次访问http://localhost:8090/hello，去到Sentinel-dashboard，我们发现此时无论我们怎么刷新，此时都不会出现流量控制的现象。

　　
wps office 官方下载网址在哪里

　　首先在管理页面新建一个流控规则

　　

　　这里的资源名是我们通过来设置的资源名，必须哟啊保证一致，否则无法生效

　　这是我们保存后，再次刷新，可以发现就有了流量控制的监控。

　　

　　资源是Sentinel的关键概念。它可以是Java引用程序中的任何内容，例如：有应用程序提供的服务，或者是引用程序调用的其他应用程序，甚至可以是一段代码，在接下来的文档中，我们都会使用资源来描述迭代代码。

　　只要通过Sentinel API定义的代码，就是资源。能够被Sentinel保护起来，大部分情况下，可以使用方法签名，URL，甚至是服务名作为资源的标识来唯一的定位某一个资源。

　　使用Sentinel来进行资源保护，主要分为以下几个步骤：

　　定义资源定义规则检验规则是否生效

　　在编码的时候，我们只需要考虑是否需要对其进行流控。如果需要则先把这个定义为一个资源。

　　4.1.1 方式一：主流框架的默认适配定义资源

　　为了减少开发过称中的复杂度，Sentinel对大多数的主流框架都有默认的适配，例如：Dubbo，SpringCloud，Web Servlet等等。，我们只需要引入对应的依赖即可方便的整合Sentinel。

　　4.1.2 方式二：抛出异常的方式定义资源

　　就是包含了try-catch风格的API，用这种方式，当资源发生了限流以后会抛出BlockException，这时候，我们就可以进行限流之后的逻辑操作

　　4.1.3 方式三：返回布尔类型的定义资源

　　提供if-else风格的API，这种方式，当资源发生了限流之后会返回false，这个时候可以通过返回值，进行限流之后的逻辑操作，示例代码：

　　注意：否则会导致调用链记录异常。抛出ErrorEntryFreeExecption异常

　　4.1.4 方式四：注解方式定义资源🔥🔥🔥

　　1️⃣ 引入@SentinelResource注解依赖支持

　　使用注解来定义资源。

　　Sentinel支持通过SentinelResource注解来定义资源，并提供了AspectJ的扩展用来自定义资源，处理BlockException等，使用Sentinel Annotation Aspect Extension 的时候需要引入一下依赖：

　　2️⃣ 创建AspectJ配置类

　　Spring Cloud Aibaba

　　若您的应用是通过接入的，

　　Spring Boot

　　如你的应用使用的是，我们都；

　　3️⃣流控保护

　　@SentinelResource注解里提供了两个违规处理的方法blockHandler和fallback

　　fallback管理的是java运行异常WPS office电脑版的下载的地方是什么。blockHandler管sentinel的控制台违规配置。

　　若blockHandler和fallback都进行了配置，则被限流降级而抛出BlockException时只会进入blockHandler处理逻辑。

　　4.1.5 方式五：异步调用支持

　　Sentinel支持异步调用链路的统计。在异步调用中，通过SphU.asyncEntry(xxx)的方式定义资源，并通过需要在异步的回调函数中调用exit方法。

　　1️⃣ 第一步：启动类上加注解@EnableAsync，让项目支持异步调用

　　2️⃣ 第二步：创建AsyncService的异步调用类及其方法

　　Service层代码逻辑

　　Controller层调用

　　

　　

　　总结：

　　在工作中，我们常常使用的是注解的方式进行流控配置，这样更加优雅使用纯代码的配置已经很少有人使用，十分笨重当然，在日常的工作中，我们经常也是用抛出异常的方式定义资源结合控制台进行流控配置

　　Sentinel的所有的规则都可以用在内存态中动态的查询及修改，修改之后立即生效，不好会有延迟。同时Sentinel也提供相关API，供我们来定制自己的规则策略。Sentinel支持以下几种规则：

　　流量控制规则熔断降级规则系统保护规则来源访问控制规则热点参数规则

　　4.2.1 流量控制规则

　　流量控制（Flow Control）：其原理是监控应用流量的QPS或者并发线程等指数，当达到指定的阈值时候，对流量进行控制，以避免瞬时的高峰访问流量冲垮服务，从而保障高可用性。

　　重要属性：

　　Field说明默认值resource资源名，资源名是限流规则的作用对象–count限流阈值–grade限流阈值的类型，QPS模式(1)后者开发线程的模式(0)QPS模式limitApp流控针对的调用来源defalut，代表不区分调用来源strategy调用关系限流策略：直接，链路，关联根据资源本身(直接)controlBehavior流控效果(直接拒绝/WarmUp/匀速+排队等待) ，不支持调用关系限流直接拒绝clusterMode是否集群限流否

　　与Sentinel的控制台对应的可以对比观察。

　　 wps office 的官方下载的入口怎么找

　　限流类型分为：

　　QPS：每秒请求限制线程数：资源使用线程限制

　　流控模式：

　　直接资源直接限流，这个就是简单的限流关联关联模式需要填写相关联资源的路径，意为如果关联资源的流量超额之后，限流自己(自己为资源名填写的路径)

　　

　　当helloworld3的QPS超过2的时候，helloworld失效

　　链路如果是链路模式需要填写入口资源，限制入口资源对自己的调用

　　流控效果：

　　快速失败（RuleConstant.CONTROL_BEHAVIOR_DEFALUT）方式是默认的流控方式，当QPS超过任意的规则的阈值之后，新的请求就会被立即被拒绝，拒绝方式为抛出FlowEception。这种方式使用与对系统处理能力确切已知的情况之下，比如通过压力测试确定的准确水准时。Warm Up（RuleConstant.control_behavior_warm_up）方式，即预热/冷启动的方式，当系统长期处于低水位的情况之下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮，通过”冷启动“，。给冷却系统一个预约的时间，避免冷却系统压垮。排队等待（RuleConstarnt_CONTROL_BEHAVIOR_OR_RATE_LIMITER）方式会严格控制情求通过的间隔时间，，对应的是漏桶算法。同一个资源可以同时有多个限流规则，检查规则是会依次检查。
wps电脑版下载地方是什么
　　总结流量控制效果：

　　快速失败适用于那种流量比较平均的情况之下Warm Up适用于那种流量高，且速度快的，比如大型的电商项目。平时一般不用，用的话很多的那种情况排队等待适用于秒杀系比 Warm Up更加完善的一种模式

　　4.3.1 概述

　　一个服务常常会调用别的模块,可能是另外的一个远程服务、数据库，或者第三方API等。例如，支付的时候,可能需要远程调用银联提供的API ;查询某个商品的价格，可能需要进行数据库查询。

　　然而，这个被依赖服务的稳定性是不能保证的。如果依赖的服务出现了不稳定的情况，请求的响应时间变长，那么调用服务的方法的响应时间也会变长，线程会产生堆积，最终可能耗尽业务自身的线程池，服务本身也变得不可用。

　　在大型的分布式应用中，我们可能会存在多个服务之间存在着比较复杂的调用关系，但是，我们无法保证在某一时刻某一个服务不会崩掉，

　　，所以，我们最好是使用Sentinel1.8.0及以上的版本，这样学习成本会比较低。

　　4.3.2 熔断策略

　　慢调用比例(SLOW_ REQUEST_ RATIO) :选择以慢调用比例作为阈值, 需要设置允许的慢调用RT (即最大的响应时间) ,经过熔断时长后熔断器会进入探测恢复状态( HALF-OPEN状态) , 若接下来的一个请求响应时间小于设置的慢调用RT则结束熔断,若大于设置的慢调用RT则会再次被熔断。异常比例(ERROR RATIO) :当单位统计时长( statIntervalMs ) 内请求数目大于设置的最小请求数目, 并且异常的比例大于阈值, 则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态(HALF-OPEN状态) , 若接下来的一个请求成功完成(没有错误)则结束熔断,否则会再次被熔断。异常比率的阈值范围是[0.0, 1.0] ,代表0%- 100%。异常数(ERROR COUNT):当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态( HALF-OPEN状态) ,若接下来的一个请求成功完成(没有错误)则结束熔断,否则会再次被熔断。

　　

　　注意异常降级仅针对业务异常,对Sentinel限流降级本身的异常( BlockException )不生效。为了统计异常比例或异常数，需要通过 Tracer. trace(ex)记录业务异常。示例:

　　

　　4.3.2.1 熔断降级规则属性

　　

　　同一个资源可以有多个降级规则，了解了上面的规则之后，我们可以通过DegradeRuleManager.loadRules(rule)的方式来规定降价规则

　　熔断器事件监听

　　Sentinel支持注册自定义的时间监听器监听熔断器状态变化事件（State Change event）：实例：

　　

　　4.4.1 概述

　　Sentinel 系统自适应限流瓜整体维度对应用入口流量进行控制,结合应用的Load、CPU 使用率、总体平均 RT、入口QPS和并发线程数等几个维度的监控指标,通过自适应的流控策略,让系统的入口流量和系统的负载达到一个平衡,让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。

　　系统规则包含下面几个重要的属性:

　　

　　了解了上面的规则定义以后，我们就可以通过调用SystemRuleManager.loadRules()方法来硬编码的方式定义流控规则

　　

　　在开始之前,我们先了解一下系统保护的目的:

　　保证系统不被拖垮在系统稳定的前提下,保持系统的吞吐量

　　长期以来,系统保护的思路是根据硬指标,即系统的负载(load1)来做系统过载保护。当系统负载高于某个阈值,就禁止或者减少流量的进入;当load开始好转,则恢复流量的进入。这个思路给我们

　　带来了不可避免的两个问题:

　　load是一个结果，如果根据load的情况来调节流量的通过率，那么就始终有延迟性。也就意味着通过率的任何调整，都会过一段时间才能看到效果。当前通过率是使load恶化的一个动作,那么也至少要过1秒之后才能观测到；同理，如果当前通过率调整是让load好转的一个动作，也需要1秒之后才能继续调整，这样就浪费了系统的处理能力。所以我们看到的曲线,总是会有抖动WPS office的官网下载的地方的方法。恢复慢wps的的官网最新下载的网站在哪(wps官网最新首页电脑版下载)。想象一下这样的一个场景(真实) , 出现了这样一个问题，下游应用不可靠，导致应用RT很高,从而load到了一个很高的点。过了一段时间之后下游应用恢复了,应用RT也相应减少。这个时候,其实应该大幅度增大流量的通过率;但是由于这个时候load仍然很高,通过率的恢复仍然不高。

　　的思想给了我们一个很大的启发。我们应该根据系统能够处理的请求,和允许进来的请求。来做平衡,而不是根据一个间接的指标(系统load )来做限流。最终我们追求的目标是在系统不被拖垮的情况下,提高系统的吞吐率,而不是load一定要到低于某个阈值。如果我们还是按照固有的思维，超过特定的load就禁止流量进入，系统load恢复就放开流量,这样做的结果是无论我们

　　怎么调参数，调比例,都是按照果来调节因,都无法取得良好的效果。

　　Sentinel在系统自适应保护的做法是，用load1作为启动自适应保护的因子,而允许通过的流量由处理请求的能力,即请求的响应时间以及当前系统正在处理的请求速率来决定。wps的电脑版的下载的网址是什么

　　4.5.1 概述

　　很多时候，我们需要根据调用来源来判断该次请求是否允许放行，这时候可以使用Sentinel的来源访问控制( 黑白名单控制)的功能。来源访问控制根据资源的请求来源( origin )限制资源是否通过，

　　调用方信息通过方法中的origin参数传入。

　　规则配置

　　来源访问控制规则( AuthorityRule )非常简单,要有以下配置项:

　　资源名，即限流规则的作用对象。对应的黑名单/白名单，不同origin用，分隔,如appA, appB。限制模式。

　　AUTHORITY _WHITE 为白名单模式，AUTHORITY BLACK 为黑名单模式，

　　实例：

　　比如我们希望控制对资源test的访问配置白名单，只有来源为appA 和appB的请求才可以通过，则可以配置如下的白名单

　　

　　4.6.1 概述

　　❓何为热点? 很多时候我们希望统计某个热点数据中访问频次最高的Top K数据,并对其访问进行限制。比如:

　　商品ID为参数,统计一段时间内最常购买的商品ID并进行限制用户ID为参数,针对一段时间内频繁访问的用户ID进行限制

　　热点参数限流可以看做是一种特殊的流量控制,仅对包含热点参数的资源调用生效。

　　

　　Snetinel通过LRU策略统计最近最常访问的热点参数，结合令牌桶算法来进行参数级别的流控，热点参数限流支持集群模式

　　基本使用

　　要使用热点参数限流功能，需要引入以下的依赖文件

　　参数描述

　　

　　Spring Cloud Alibaba默认为Sentinel整合了Servlet、RestTemplate、FeignClient和Spring WebFlux。它不仅补全了Hystrix在Servlet和RestTemplate这一块的空白，且还完全兼容了Hystrix在FeignClient中限流降级的用法，并支持灵活配置和调整流控规则。

　　我们发现，使用Sentinel的时候，一旦我们重启过后Sentinel之前的配置就会全部没有，这是十分可怕的一件事，

　　**🔥注意：**要使用Nacos做持久化配置，就必须要修改Naocs的Application>properties里的配置信息，将其数据源修改为Spring.mysql，并将Nacos默认提供的数据文件导入Mysql数据库中

　　1️⃣添加Sentinel的Nacos支持

　　2️⃣在Nacos中定义策略

　　

　　Data Id：和配置文件中的data_id相对应

　　Group：和配置文件中的group_id相对应

　　配置内容：

　　resource：接口名，即限流规则的资源对象，limitApp：流控针对的调用来源，若为default则不区分调用来源grade：西安流阈值类型（QPS或者并发线程数）：1代表 QPS，0代表并发线程数来限制流量count：限流阈值strategy：调用关系限流策略（直接，链路，关联）

　　0：代表直接（默认就是这种）1：代表链路2：代表关联 controlBehavior：流量控制效果（直接拒绝，WarmUp，匀速排队等待）clusterMode：是否为集群模式

　　3️⃣声明一个资源，用于流控

　　4️⃣ 配置Nacos和Sentinel

　　5️⃣启动应用，查看是否配置成功

　　这里我们可以观察发现其实Nacos做的持久化操作与之提供的数据库发现，我们一旦修改过Naocs的配置，就会在his_config_info里有记录，而config_info则是我们的使用的配置数据。

　　wps office免费版下载地址在哪

　　至此，我们对Sentinel的初步了解的差不多了，接下来就需要我平时多练习，来熟悉这个Sentinel使用

2025年3月2日
wps电脑版下载的入口是什么

　　原文：

　　译者：飞龙

　　协议：CC BY-NC-SA 4.0

　　Apache Spark 是一个基于内存的集群数据处理系统，提供广泛的功能，如大数据处理、分析、机器学习等。通过这个学习路径，您可以将 Apache Spark 的知识提升到一个新的水平，学习如何扩展 Spark 的功能，并在此平台上构建自己的数据流和机器学习程序。您将使用 Apache Spark 的不同模块，如使用 Spark SQL 进行交互式查询、使用 DataFrames 和数据集、使用 Spark Streaming 实现流分析，以及使用 MLlib 和各种外部工具在 Spark 上应用机器学习和深度学习技术。通过这个精心设计的学习…

　　如果您是一名中级 Spark 开发者，希望掌握 Apache Spark 2.x 的高级功能和用例，这个学习路径非常适合您。希望学习如何集成和使用 Apache Spark 功能并构建强大大数据管道的大数据专业人士也会发现这个学习路径很有用。要理解本学习路径中解释的概念，您必须了解 Apache Spark 和 Scala 的基础知识。

　　第一章，Apache Spark V2 初体验及新特性，概述了 Apache Spark，介绍了其模块内的功能，以及如何进行扩展。它涵盖了 Apache Spark 标准模块之外的生态系统中可用的处理和存储工具。还提供了性能调优的技巧。

　　第二章，Apache Spark 流处理，讲述了使用 Apache Spark Streaming 的连续应用程序。您将学习如何增量处理数据并创建可行的见解。wps官网下载入口在哪

　　第三章，结构化流处理，讲述了使用 DataFrame 和 Dataset API 定义连续应用程序的新方式——结构化流处理。

　　第四章，Apache Spark MLlib，介绍了…

　　操作系统：首选 Linux 发行版（包括 Debian、Ubuntu、Fedora、RHEL 和 CentOS），具体来说&#xffWPS office官网最新的下载的地方的方法0c;推荐使用完整的 Ubuntu 14.04（LTS）64 位（或更高版本）安装，VMware player 12 或 VirtualBox。您也可以在 Windows（XP/7/8/10）或 Mac OS X（10.4.7+）上运行 Spark 作业。

　　硬件配置：处理器建议使用 Core i3、Core i5（推荐）或 Core i7（以获得最佳效果）。然而，多核处理将提供更快的数据处理和可扩展性。对于独立模式，您至少需要 8-16 GB RAM（推荐），对于单个虚拟机至少需要 32 GB RAM——集群模式则需要更多。您还需要足够的存储空间来运行繁重的作业（取决于您将处理的数据集大小），并且最好至少有 50 GB 的可用磁盘存储空间（对于独立模式和 SQL 仓库）。

　　此外，您还需要以下内容：

　　VirtualBox 5.1.22 或更高版本

　　Hortonworks HDP Sandbox V2.6 或更高版本

　　Eclipse Neon 或更高版本

　　Eclipse Scala 插件

　　Eclipse Git 插件

　　Spark 2.0.0（或更高版本）

　　Hadoop 2.7（或更高版本）

　　Java（JDK 和 JRE）1.7+/1.8+

　　Scala 2.11.x（或更高版本）

　　Python 2.7+/3.4+

　　R 3.1+ 和 RStudio 1.0.143（或更高版本）
wps的的官网的下载的地方怎么找
　　Maven Eclipse 插件（2.9 或更高版本）

　　Maven 编译器插件 for Eclipse（2.3.2 或更高版本）

　　Maven 装配插件 for Eclipse（2.4.1 或更高版本）

　　Oracle JDK SE 1.8.x

　　JetBrain IntelliJ 社区版 2016.2.X 或更高版本

　　IntelliJ 的 Scala 插件 2016.2.x

　　Jfreechart 1.0.19

　　breeze-core 0.12

　　Cloud9 1.5.0 JAR

　　Bliki-core 3.0.19

　　hadoop-streaming 2.2.0

　　Jcommon 1.0.23

　　Lucene-analyzers-common 6.0.0

　　Lucene-core-6.0.0

　　Spark-streaming-flume-assembly 2.0.0

　　Spark-streaming-kafka-assembly 2.0.0

　　您可以从www.packt.com的账户下载本书的示例代码文件。如果您在其他地方购买了本书，可以访问www.packt.com/support并注册，以便将文件直接发送到您的邮箱。

　　您可以按照以下步骤下载代码文件：

　　登录或注册于www.packt.com。

　　选择支持选项卡。

　　点击代码下载与勘误。

　　在搜索框中输入书名，并按照屏幕上的指示操作。

　　下载文件后，请确保使用最新版本的以下软件解压缩或提取文件夹：

　　WinRAR/7-Zip for Windows

　　Zipeg/iZip/UnRarX for Mac

　　7-Zip/PeaZip for Linux

　　本书代码包也托管在 GitHub 上。

　　本书中，您会发现多种文本样式用于区分不同类型的信息。以下是这些样式的示例及其含义的解释。

　　文本中的代码词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 句柄显示如下：“接下来的代码行读取链接并将其分配给函数。”

　　代码块设置如下：

　　任何命令行输入或输出如下所示：

　　粗体：新术语和重要词汇以粗体显示。屏幕上看到的词汇，例如在菜单或对话框中，在文本中这样显示：“配置全局库。选择 Scala SDK 作为您的全局库。”

　　警告或重要提示以这种方式出现。

　　提示和技巧以这种方式出现。

　　Apache Spark是一个分布式且高度可扩展的内存数据分析系统，为你提供了使用 Java、Scala、Python 以及 R 等语言开发应用程序的能力。它是当前 Apache 顶级项目中贡献/参与度最高的项目之一。Apache 系统，如 Mahout，现在将其作为处理引擎，而非 MapReduce。还可以使用 Hive 上下文让 Spark 应用程序直接处理 Apache Hive 中的数据。

　　最初，Apache Spark 提供了四个主要子模块——SQL、MLlib、GraphX 和 Streaming。它们将在各自的章节中进行解释，但在此之前，一个简单的概述将是有益的。…

　　机器学习是 Apache Spark 的真正原因，因为归根结底，你不仅仅希望将数据从 A 地运送到 B 地（这一过程称为ETL（提取、转换、加载））。你希望在你的数据上运行高级数据分析算法，并且希望这些算法能够扩展。这正是 Apache Spark 发挥作用的地方。

　　Apache Spark 的核心提供了大规模并行数据处理的运行时环境，不同的并行机器学习库在其上运行。这是因为流行的编程语言如 R 和 Python 有大量机器学习算法，但它们不具备可扩展性。一旦你向系统可用主内存加载更多数据，它们就会崩溃。

　　相比之下，Apache Spark 可以利用多个计算机节点形成集群，并且即使在单个节点上，也能透明地将数据溢出到磁盘，从而避免主内存瓶颈。Apache Spark 自带了两个有趣的机器学习库，但本工作还将涵盖第三方机器学习库。

　　Spark MLlib 模块，即经典 MLlib，提供了一个不断增长但尚不完整的机器学习算法列表。自从基于DataFrame的机器学习 API——SparkML推出以来，MLlib 的命运已定。它仅因向后兼容的原因而被保留。

　　在 SparkML 中，我们已有一个机器学习库，该库开箱即用，可利用这些改进作为底层架构。

　　SparkML 最终将取代 MLlib。Apache SystemML 推出了首个运行在 Apache Spark 之上的库，该库并非随 Apache Spark 发行版一同提供。SystemML 为你提供了一个具有内置成本优化器的 R 风格语法执行环境。大规模并行机器学习是一个不断变化的高频领域。很难预测这一旅程将走向何方，但这是首次，使用开源和云计算的每个人都能获得大规模的高级机器学习。

　　Apache Spark 上的深度学习使用H2O、Deeplearning4j和Apache SystemML，这些都是非常有趣的第三方机器学习库的例子，它们并未随 Apache Spark 分发。

　　尽管 H2O 在某种程度上与 MLlib 互补，但 Deeplearning4j 仅专注于深度学习算法。两者都使用 Apache Spark 作为数据处理并行化的手段。您可能会好奇为什么我们要研究不同的机器学习库。

　　实际上，每个库在实现不同算法时都有其优缺点。因此，通常取决于您的数据和数据集大小，您会选择哪种实现以获得最佳性能。

　　然而，令人高兴的是，使用 Apache Spark 时有如此多的选择，您不会被锁定在一个单一的库中。开源意味着开放性，这只是我们如何从与单一供应商、单一产品锁定相反的方法中受益的一个例子。尽管最近 Apache Spark 将另一个库 GraphX 集成到其分发中，但我们不期望这种情况会很快发生。因此，最有可能的是，Apache Spark 作为一个中央数据处理平台和额外的第三方库将共存，就像 Apache Spark 是大数据操作系统，而第三方库是您在其上安装和运行的软件一样。

　　流处理是 Apache Spark 的另一个重大且流行的话题。它涉及在 Spark 中以流的形式处理数据，并涵盖了输入和输出操作、转换、持久性和检查点等主题。

　　Apache Spark Streaming 将涵盖处理领域，我们还将看到不同类型流处理的实际示例。这讨论了批处理和窗口流配置，并提供了一个检查点设置的实际示例。它还涵盖了包括 Kafka 和 Flume 在内的不同流处理示例。

　　流数据有许多用途。其他 Spark 模块功能（例如，SQL、MLlib 和 GraphX）可用于处理流。您…

　　从 Spark 版本 1.3 开始，Apache Spark 引入了数据帧，使得 Spark 数据可以以表格形式处理，并可以使用表格函数（如、和）来处理数据。Spark SQL 模块与 Parquet 和 JSON 格式集成，允许数据以更好地表示数据的格式存储。这也提供了更多与外部系统集成的选项。

　　将 Apache Spark 集成到 Hadoop Hive 大数据数据库的想法也可以引入。基于 Hive 上下文的 Spark 应用程序可用于操作基于 Hive 的表数据。这使得 Hive 能够利用 Spark 的快速内存分布式处理能力，有效地让 Hive 使用 Spark 作为处理引擎。

　　此外，还有大量额外的连接器，可以直接从 Apache Spark 访问 Hadoop 生态系统之外的 NoSQL 数据库。

　　图处理是数据分析中另一个非常重要的主题。事实上，大多数问题都可以表示为图。

　　图基本上是一个项目及其相互关系的网络。项目称为节点，关系称为边。关系可以是定向的或非定向的。关系以及项目可以具有属性。因此，例如，地图也可以表示为图。每个城市是一个节点，城市之间的街道是边。城市之间的距离可以作为边上的属性分配。

　　Apache Spark GraphX模块使 Apache Spark 能够提供快速的大数据内存图处理。这使您能够运行图算法…

　　在审视大数据处理系统时，我们认为不仅要关注系统本身，还要关注它如何扩展以及如何与外部系统集成，以便提供更高级别的功能。在这本书的篇幅中，我们无法涵盖每一种选择，但通过引入一个主题，我们希望能够激发读者的兴趣，使他们能够进一步研究。

　　自 Apache Spark V2 以来，许多事情都发生了变化。这并不意味着 API 已被破坏。相反，大多数 V1.6 的 Apache Spark 应用程序将在 Apache Spark V2 上运行，无论是否需要很少的更改，但在幕后，已经发生了很多变化。

　　尽管Java 虚拟机（JVM）本身是一件杰作，但它是一个通用的字节码执行引擎。因此，存在大量的 JVM 对象管理和垃圾回收（GC）开销。例如，存储一个 4 字节的字符串，在 JVM 上需要 48 字节。GC 基于对象生命周期估计进行优化，但 Apache Spark 通常比 JVM 更了解这一点。因此，Tungsten 对私有子集禁用了 JVM GC…

　　正如我们已经提到的，Apache Spark 是一个分布式、内存内并行处理系统，需要一个关联的存储系统。因此，当您构建大数据集群时，您可能会使用分布式存储系统，如 Hadoop，以及用于移动数据的工具，如 Sqoop、Flume 和 Kafka。

　　我们希望在大数据集群中引入边缘节点的概念。这些集群中的节点将面向客户端，上面驻留着如 Hadoop NameNode 或可能是 Spark master 等客户端面向组件。大多数大数据集群可能位于防火墙后面。边缘节点将减少由防火墙引起的复杂性，因为它们将是外部可访问的唯一接触点。下图展示了一个简化的大数据集群：

　　

　　它展示了五个简化的集群节点，每个 CPU 核心有一个执行器 JVM，以及位于集群外部的 Spark 驱动程序 JVM。此外，您可以看到直接连接到节点的磁盘。这被称为JBOD（只是一堆磁盘）方法。非常大的文件在磁盘上分区，虚拟文件系统（如 HDFS）将这些块作为一个大虚拟文件提供。当然，这是风格化和简化的，但您可以理解这个概念。

　　下面的简化组件模型展示了驱动程序 JVM 位于集群外部。它与集群管理器通信，以获得在 worker 节点上调度任务的许可，因为集群管理器负责跟踪集群上运行的所有进程的资源分配。

　　正如我们稍后将看到的，存在多种不同的集群管理器，其中一些还能够管理其他 Hadoop 工作负载，甚至与 Spark 执行器并行运行的非 Hadoop 应用程序。请注意，执行器和驱动程序之间始终保持双向通信，因此从网络角度来看，它们也应该彼此靠近：

　　

　　图源：https://spark.apache.org/docs/2.0.2/cluster-overview.html

　　通常，虽然防火墙为集群增加了安全性，但也增加了复杂性。系统组件之间的端口需要打开，以便它们可以相互通信。例如，Zookeeper 被许多组件用于配置。Apache Kafka，发布/订阅消息系统，使用 Zookeeper 来配置其主题、组、消费者和生产者。因此，需要打开到 Zookeeper 的客户端端口，可能跨越防火墙。

　　最后，需要考虑将系统分配给集群节点的方案。例如，如果 Apache Spark 使用 Flume 或 Kafka，则会使用内存通道。这些通道的大小以及数据流导致的内存使用量需要考虑。Apache Spark 不应与其他 Apache 组件竞争内存使用。根据您的数据流和内存使用情况，可能需要在不同的集群节点上部署 Spark、Hadoop、Zookeeper、Flume 和其他工具。或者，可以使用 YARN、Mesos 或 Docker 等资源管理器来解决此问题。在标准的 Hadoop 环境中，YARN 最有可能被采用。

　　通常，作为集群 NameNode 服务器或 Spark 主服务器的边缘节点将需要比防火墙内的集群处理节点更多的资源。当许多 Hadoop 生态系统组件部署在集群上时，它们都需要在主服务器上额外内存。您应该监控边缘节点的资源使用情况，并根据需要调整资源和/或应用程序位置。例如，YARN 正在处理这个问题。

　　本节简要介绍了大数据集群中的 Apache Spark、Hadoop 及其他工具。但是，大数据集群内部，Apache Spark 集群本身可能如何配置呢？例如，可以有多种类型的 Spark 集群管理器。下一节将探讨这一点，并描述每种 Apache Spark 集群管理器的类型。

　　Spark 上下文，正如你在本书的许多示例中看到的，可以通过 Spark 配置对象和 Spark URL 来定义。Spark 上下文连接到 Spark 集群管理器，后者随后在集群的工作节点之间分配资源给应用程序。集群管理器在集群的工作节点上分配执行器。它将应用程序 JAR 文件复制到工作节点，并最终分配任务。

　　以下小节描述了目前可用的 Apache Spark 集群管理器的各种选项。

　　通过指定一个本地 Spark 配置 URL，可以使应用程序在本地运行。通过指定，可以使 Spark 使用 n 个线程在本地运行应用程序。这是一个有用的开发和测试选项，因为你还可以测试某种并行化场景，但将所有日志文件保留在单个机器上。

　　Standalone 模式使用 Apache Spark 自带的基本集群管理器。Spark 主节点的 URL 将如下所示：

　　在此，表示运行 Spark 主节点的宿主机的名称。我们已将端口指定为，这是默认值，但可配置。当前这种简单的集群管理器仅支持 FIFO（先进先出）调度策略。你可以通过为每个应用程序设置资源配置选项来设法实现并发应用调度；例如，使用在应用程序之间共享核心。

　　在更大规模上，当与 Hadoop YARN 集成时，Apache Spark 集群管理器可以是 YARN，应用程序可以运行在两种模式之一。如果将 Spark 主节点值设置为，则可以将应用程序提交到集群并随后终止。集群将负责分配资源和运行任务。然而，如果应用程序主节点以方式提交，则应用程序在处理周期内保持活动状态，并向 YARN 请求资源。

　　Apache Mesos 是一个开源系统，用于集群间的资源共享。它允许多个框架通过管理和调度资源来共享集群。作为一个集群管理器，它利用 Linux 容器提供隔离，并允许 Hadoop、Spark、Kafka、Storm 等多种系统安全地共享集群。它高度可扩展至数千个节点。它是一个基于主/从的系统，并具有故障容忍性，使用 Zookeeper 进行配置管理。

　　对于单个主节点的 Mesos 集群，Spark 主 URL 将采用以下形式：

　　.

　　在此，是 Mesos 主服务器的 hostname；端口定义为，这是默认的 Mesos 主端口（…）

　　云系统有三种不同的抽象层次——基础设施即服务（IaaS）、平台即服务（PaaS）和软件即服务（SaaS）。我们将探讨如何在所有这些层面上使用和安装 Apache Spark。

　　新的 IaaS 方式是 Docker 和 Kubernetes，与虚拟机相对，基本上提供了一种在几分钟内自动设置 Apache Spark 集群的方法。Kubernetes 的优势在于，由于它是开放标准且基于开源，因此可以在多个不同的云提供商之间使用。

　　你甚至可以使用 Kubernetes，在本地数据中心内透明且动态地移动工作负载，跨越本地、专用和公共云数据中心。相比之下，PaaS 为你减轻了安装和操作 Apache Spark 集群的负担，因为这作为一项服务提供。

　　关于 Docker 是 IaaS 还是 PaaS 的讨论仍在进行中，但在我们看来，它只是一种轻量级预装虚拟机形式。这一点特别有趣，因为其完全基于开源技术，使得你能够在任何其他数据中心复制该系统。

　　我们将介绍的开源组件之一是 Jupyter 笔记本；一种在基于云的协作环境中进行数据科学的现代方式。

　　在进入涵盖 Apache Spark 功能区域和扩展的其余章节之前，我们将审视性能领域。需要考虑哪些问题和领域？从集群级别到实际 Scala 代码，哪些因素可能影响 Spark 应用程序性能？我们不想仅仅重复 Spark 网站上的内容，因此请查看此 URL：。

　　在此，对应于你正在使用的 Spark 版本；即，最新版本或类似的特定版本。因此，浏览此页面后，我们将简要提及一些主题领域。本节中，我们将列出一些一般性要点，但不暗示…

　　大数据集群的规模和结构将影响性能。如果你拥有一个基于云的集群，相比非共享硬件集群，你的 IO 和延迟将会受到影响。你将与多个客户共享底层硬件，且集群硬件可能位于远程。当然，也有例外。例如，IBM 云提供按小时租赁的专用裸金属高性能集群节点，配备 InfiniBand 网络连接。

　　此外，集群组件在服务器上的位置可能导致资源争用。例如，在大规模集群中仔细考虑 Hadoop NameNodes、Spark 服务器、Zookeeper、Flume 和 Kafka 服务器的布局。在高负载情况下，您可能需要将服务器隔离到单独的系统中。您还可以考虑使用 Apache Mesos 等系统，它为各个进程提供更好的资源分配和分配。

　　同时考虑潜在的并行性。对于大型数据集，您的 Spark 集群中的工作者数量越多，实现并行处理的机会就越大。一个经验法则是每个超线程或虚拟核心分别对应一个工作者。

　　根据您的集群需求，您可能考虑使用 HDFS 的替代方案。例如，IBM 提供了GPFS（通用目的文件系统）以提高性能。

　　GPFS 可能是更好选择的原因在于，它源自高性能计算背景，这种文件系统具有完整的读写能力，而 HDFS 设计为一次写入、多次读取的文件系统。它在性能上优于 HDFS& wps office的免费版下载地方#xff0c;因为它在核心级别运行，而 HDFS 在Java 虚拟机（JVM）中运行，后者又作为操作系统进程运行。它还与 Hadoop 和 Spark 集群工具集成。IBM 使用 GPFS 配置了数百 PB 的系统。…

　　良好数据处理性能的关键是避免网络传输。这在几年前是非常正确的，但对于 CPU 需求高、I/O 需求低的任务来说，这不太相关，但对于 CPU 需求低、I/O 需求高的数据处理算法，这仍然适用。

　　由此我们可以得出结论，HDFS 是实现数据局部性的最佳方式之一，因为文件块分布在集群节点上，在大多数情况下，使用直接连接到服务器系统的硬盘。这意味着可以在包含个别数据块的机器上使用 CPU 并行处理这些块，以避免网络传输。

　　另一种实现数据局部性的方法是使用。根据连接器实现的不同，SparkSQL 可以利用源引擎的数据处理能力。例如，当结合使用 MongoDB 和 SparkSQL 时，SQL 语句的部分内容在数据发送到 Apache Spark 之前由 MongoDB 预处理。

　　为了避免 Apache Spark 集群上的任务出现内存不足（OOM）消息，请考虑以下调优问题：

　　考虑您的 Spark 工作节点上可用的物理内存级别。是否可以增加？在高负载期间检查操作系统进程的内存消耗，以了解可用内存的情况。确保工作者有足够的内存。

　　考虑数据分区。你能增加分区数量吗？一般而言，分区的数量应至少与集群中可用的 CPU 核心数相等。可使用 RDD API 中的函数。

　　你能调整用于存储和缓存 RDD 的 JVM 内存比例吗？…

　　尝试优化你的代码，以提升 Spark 应用程序的性能。例如，在你的 ETL 周期早期基于应用程序数据进行过滤。一个例子是，当使用原始 HTML 文件时，在早期阶段去除标签并裁剪掉不需要的部分。调整并行度，尝试找出代码中资源消耗大的部分，并寻找替代方案。

　　ETL是分析项目中首先要做的事情之一。因此，你正在从第三方系统抓取数据，要么直接访问关系型或 NoSQL 数据库，要么通过读取各种文件格式的导出，如 CSV、TSV、JSON，甚至是来自本地或远程文件系统或 HDFS 中暂存区的更奇特的格式：在对文件进行一些检查和合理性检查后，Apache Spark 中的 ETL 过程基本上读取这些文件并从中创建 RDD 或 DataFrames/Datasets。

　　它们被转换以适应下游的分析应用程序，这些应用程序运行在 Apache Spark 或其他应用程序之上，然后存储回文件系统，格式可以是 JSON、CSV 或 PARQUET 文件，甚至返回到关系型或 NoSQL 数据库。

　　最后，对于任何与 Apache Spark 性能相关的问题，我推荐以下资源：。

　　尽管本书的部分内容将专注于 Apache Spark 在物理服务器集群上安装的示例，但我们想强调，市面上存在多种基于云的选项，它们带来了许多好处。有些云系统将 Apache Spark 作为集成组件，而有些则提供 Spark 作为服务。

　　通常，对于你的应用程序，需要问的问题是：是否必须接收并处理所有数据？如果不是，那么在失败时，你可能只需重启应用程序并丢弃缺失或丢失的数据。如果情况并非如此，那么你需要使用将在下一节中描述的检查点机制。

　　同样值得注意的是，你的应用程序的错误管理应该是健壮且自给自足的。我们的意思是，如果异常不是关键性的，那么管理该异常，可能记录它，并继续处理。例如，当任务达到最大失败次数（由指定）时，它将终止处理。

　　这一属性及其他属性，可以在创建对象时设置，或者在调用或时作为额外的命令行参数。

　　在结束本章之际，我们邀请你逐步学习后续章节中基于 Scala 代码的示例。Apache Spark 的发展速度令人印象深刻，值得注意的是其发布的频繁程度。因此，尽管在撰写本文时 Spark 已达到 2.2 版本，但我们确信你将使用更新的版本。

　　如果你遇到问题，请在www.stackoverflow.com上报并相应地标记它们；你将在几分钟内收到反馈——用户社区非常活跃。获取信息和帮助的另一种方式是订阅 Apache Spark 邮件列表：。

　　本章结束时，你应该对本书中等待你的内容有了一个清晰的认识。我们专门…

　　Apache 流处理模块是 Apache Spark 中的一个基于流处理的模块。它使用 Spark 集群，提供高度扩展的能力。基于 Spark，它也具有高度容错性，能够通过检查点正在处理的数据流来重新运行失败的任务。在本章的介绍部分之后，将涵盖以下主题，该部分将提供 Apache Spark 如何处理基于流的数据的实际概述：

　　错误恢复与检查点

　　TCP 基础的流处理

　　文件流

　　Kafka 流源

　　对于每个主题，我们将提供一个在 Scala 中实现的工作示例，并展示如何设置和测试基于流的架构。

　　以下图表展示了 Apache 流处理的潜在数据源，如 Kafka、Flume 和 HDFS：

　　

　　这些输入被送入 Spark 流处理模块，并作为离散流进行处理。该图还显示了其他 Spark 模块功能，如机器学习，也可以用于处理基于流的数。

　　完全处理后的数据可以作为输出到 HDFS、数据库或仪表板。此图基于 Spark 流处理网站上的图，但我们希望扩展它以表达 Spark 模块功能：

　　

　　在批处理中，我们习惯于具备容错性。这意味着，如果某个节点崩溃，作业不会丢失其状态，丢失的任务会在其他工作节点上重新调度。中间结果被写入持久存储（当然，这种存储也必须具备容错性，如 HDFS、GPFS 或云对象存储）。现在我们希望在流处理中也实现同样的保证，因为确保我们正在处理的数据流不丢失可能至关重要。

　　可以设置一个基于 HDFS 的检查点目录来存储基于 Apache Spark 的流处理信息。在这个 Scala 示例中，数据将存储在 HDFS 下的。以下 HDFS 文件系统命令显示，在开始之前，该目录不存在：

　　为了复制以下示例，我们使用 Twitter API 凭证来连接到 Twitter API 并获取推文流。以下链接解释了如何在 Twitter UI 中创建此类凭证：。

　　以下 Scala 代码示例首先导入 Spark 流处理上下文和基于 Twitter 的功能。然后定义了一个名为的应用程序对象：

　　接下来，定义了一个名为的方法，该方法将用于创建 Spark 和 Streaming 上下文。它还将使用流上下文检查点方法将流检查点到基于 HDFS 的目录，该方法接受目录路径作为参数。目录路径是传递给方法的值：

　　现在，定义了主方法以及 HDFS 目录、Twitter 访问权限和参数。Spark Streaming 上下文通过方法的使用 HDFS 检查点目录检索或创建。如果目录不存在，则调用之前的方法，该方法将创建上下文和。显然，出于安全原因，我们在这个例子中截断了自己的 Twitter ：

　　运行此代码后，由于没有实际处理，可以再次检查 HDFS 目录。这次，很明显目录已被创建，数据已被存储：

　　本例取自 Apache Spark 官网，展示了如何设置和使用检查点存储。检查点执行的频率是多少？元数据在每个流批次期间存储。实际数据存储在一个周期内，该周期是批次间隔或十秒的最大值。这可能不适合您，因此您可以使用以下方法重置该值：

　　这里，是您需要的新检查点间隔值；通常，您应该瞄准一个值，该值是您的批次间隔的五到十倍。检查点保存了流批次和元数据（关于数据的数据）。

　　如果应用程序失败，那么当它重新启动时，在处理开始时使用检查点数据。在失败时正在处理的数据批次与自失败以来的批处理数据一起重新处理。请记住监控用于检查点的 HDFS 磁盘空间。

　　在下一节中，我们将检查流源并提供每种类型的示例。

　　在本节中，我们无法涵盖所有流类型的实际示例，但当本章太小而无法包含代码时，我们将至少提供描述。在本章中，我们将介绍 TCP 和文件流以及 Flume、Kafka 和 Twitter 流。Apache Spark 通常只支持这个有限的集合开箱即用，但这不是问题，因为第三方开发者也提供了连接到其他源的连接器。我们将从一个基于 TCP 的实际示例开始。本章检查流处理架构。

　　例如，在流数据交付速率超过潜在数据处理速率的情况下会发生什么？像 Kafka 这样的系统提供了可能解决这个问题的可能性…

　　有可能使用 Spark Streaming Contextwps电脑版的下载的地方在哪的方法通过 TCP/IP 流式传输数据，只需指定主机名和端口号。本节中的基于 Scala 的代码示例将在端口接收数据，这些数据是通过Linux 命令提供的。

　　命令是一个 Linux/Unix 命令，它允许你使用 TCP 或 UDP 向本地或远程 IP 目的地发送和接收数据。这样，每个 shell 脚本都可以充当完整的网络客户端或服务器。以下是一个关于如何使用的良好教程：。

　　代码示例首先导入了 Spark、上下文以及流处理类。定义了一个名为的对象类，它是带有参数的主方法。

　　检查传递给类的参数数量，以确保它是主机名和端口号。创建了一个带有定义的应用程序名称的 Spark 配置对象。然后创建了 Spark 和流处理上下文。接着，设置了秒的流处理批次时间：

　　通过使用和端口名参数调用流处理上下文的方法，创建了一个名为的 DStream：

　　通过用空格分割单词，从原始流数据中创建了一个前十单词计数。然后，创建了一个(key, value)对，即(word,1)，它按键值，即单词进行缩减。现在，有一个单词列表及其关联的计数。键和值被交换，使得列表变为(计数和单词)。然后，对键（现在是计数）进行排序。最后，从 DStream 中的 RDD 中取出前 10 项并打印出来：

　　代码以调用 Spark Streaming 的和方法结束，以启动流处理并等待进程终止：

　　正如我们之前所述，此应用程序的数据由 Linux Netcat ()命令提供。Linux 命令转储日志文件的内容，该内容被管道传输到。选项强制 Netcat 监听连接，并在连接丢失时保持监听。此示例显示正在使用的端口是：

　　这里展示了基于 TCP 的流处理的输出。实际输出不如所展示的方法重要。然而，数据显示，正如预期的那样，是一份按降序计数的 10 个日志文件单词列表。请注意，顶部单词为空，因为流未被过滤以排除空单词：

　　如果你想基于 TCP/IP 从主机和端口使用 Apache Spark Streaming 进行数据流处理，这会很有趣。但是，更奇特的方法呢？如果你想从消息系统或通过基于内存的通道流式传输数据怎么办？如果你想使用当今可用的一些大数据工具，如 Flume 和 Kafka，该怎么办？接下来的部分将探讨这些选项，但首先，我们将展示如何基于文件构建流。

　　我们已修改上一节中的基于 Scala 的代码示例，通过调用 Spark Streaming 上下文的方法来监控基于 HDFS 的目录。鉴于这一小改动，我们将不展示所有代码。应用程序类现在称为，它接受一个参数——HDFS 目录。目录路径也可以位于另一个存储系统上（所有代码示例都将随本书提供）：

　　流处理与之前相同。流被分割成单词，并打印出前十个单词列表。这次唯一的区别是，数据必须在应用程序运行时放入 HDFS 目录。这是通过…实现的

　　Flume 是一个 Apache 开源项目及产品，旨在以大数据规模移动大量数据。它具有高度可扩展性、分布式和可靠性，基于数据源、数据接收器和数据通道运作，如下图所示，取自：

　　

　　Flume 使用代理处理数据流。如前图所示，一个代理具有数据源、数据处理通道和数据接收器。更清晰地描述此流程的方法是通过我们刚才看到的图。通道充当源数据的队列，接收器将数据传递到链中的下一个环节。

　　Flume 代理可以构成 Flume 架构；一个代理的接收器输出可以作为第二个代理的输入。Apache Spark 支持两种使用 Apache Flume 的方法。第一种是基于 Avro 的内存推送方法，而第二种方法，同样基于 Avro，是使用自定义 Spark 接收器库的拉取系统。本例中我们使用 Flume 版本 1.5：

　　我们在此初步实现的基于 Flume 的 Spark 示例是基于 Flume 的推送方法，其中 Spark 充当接收器，Flume 将数据推送到 Spark。下图表示我们将在单个节点上实现的结构：

　　

　　消息数据将被发送到名为的主机的端口，使用 Linux 的（）命令。这将作为 Flume 代理（）的一个源（），该代理将有一个名为的内存通道。使用的接收器将是基于 Apache Avro 的，同样在名为的主机上，但这次端口号将是。Apache Spark Flume 应用程序（我们稍后将描述）将监听此端口上的 Flume 流数据。

　　我们通过向端口执行命令来启动流处理。现在，当我们在该窗口中输入文本时，它将作为 Flume 源，数据将被发送到 Spark 应用程序：

　　为了运行 Flume 代理，我们创建了一个名为的 Flume 配置文件，该文件描述了代理的源、通道和接收器。文件内容如下。第一部分定义了的源、通道和接收器名称。

　　下一部分定义为基于 netcat，运行在名为的主机上和端口：

　　通道被定义为具有最大事件容量事件的内存通道：

　　最后，接收器被定义为在名为的主机上和端口的 Apache Avro 接收器：

　　我们创建了一个名为的 Bash 脚本来运行 Flume 代理。它如下所示：

　　该脚本调用 Flume 可执行文件，传递配置文件。调用指定了名为的代理。它还指定了 Flume 配置目录为，这是默认值。最初，我们将使用一个基于 Scala 的示例，该示例使用 Flume 源来展示如何将数据发送到 Apache Spark 应用程序。然后，我们将展示如何以类似方式处理基于 RSS 的数据源。因此，最初接收数据的 Scala 代码看起来是这样的。应用程序类名被定义。导入 Spark 和 Flume 所需的类。最后，定义了主方法：

　　Spark 和 Streaming 上下文被创建。然后，使用流上下文主机和端口号创建基于 Flume 的数据流。为此，使用了基于 Flume 的类，通过调用其方法来实现：

　　最终，会打印出流事件计数，并且在测试流时（出于调试目的）会转储流内容。之后，流上下文被启动并配置为运行，直到通过应用程序终止：

　　编译完成后，我们将使用运行此应用程序。在本书的其他一些章节中，我们将使用一个名为的基于 Bash 的脚本来执行任务。该脚本如下所示：

　　因此，此脚本设置了一些基于 Spark 的变量和一个 JAR 库路径用于此作业。它将 Spark 类作为第一个参数运行。它将所有其他变量作为参数传递给 Spark 应用程序类作业。因此，应用程序的执行如下所示：

　　这意味着 Spark 应用程序已准备好，并在端口上作为 Flume 接收器运行。Flume 输入已准备好，作为端口上的任务运行。现在，Flume 代理可以使用名为的 Flume 脚本启动，以将基于源的数据发送到 Apache Spark 基于 Flume 的接收器：

　　现在，当文本传递给会话时，它应该通过 Flume 流动，并由 Spark 作为流处理。让我们试试：

　　已向会话添加了三个简单的文本片段，并使用进行了确认，以便它们可以传递给 Flume。Flume 会话中的调试输出显示已收到并处理了事件（每行一个）：

　　最后，在 Spark 应用程序会话中，已收到并处理了三个事件；在这种情况下，它们已被转储到会话中，以证明数据已到达。当然，这不是您通常会做的，但我们想证明数据通过此配置传输：

　　这很有趣，但它并不是真正值得生产的 Spark Flume 数据处理示例。因此，为了演示一种可能的实际数据处理方法，我们将更改 Flume 配置文件源详细信息，使其使用一个 Perl 脚本，该脚本可执行如下：

　　先前引用的 Perl 脚本仅作为路透社科学新闻的来源。它接收 XML 格式的消息并将其转换为 JSON 格式。它还清理了数据中的不必要噪音。首先，它导入 LWP 和等包以启用 XML 处理。然后，它指定基于科学的 Reuters 新闻数据源，并创建一个新的 LWP 代理来处理数据，如下所示：

　　如果请求成功，则返回的 XML 数据定义为请求的解码内容。通过使用路径的 XPath 调用从 XML 中提取标题信息：

　　对于提取的标题数据字符串中的每个节点，都会提取数据。它清除了不需要的标签，并添加到名为 titles 的基于 Perl 的数组中：

　　对于请求响应 XML 中的基于描述的数据，执行相同的处理。这次使用的 XPath 值是。描述数据中有许多更多的标签需要清理，因此有许多更多的 Perl 搜索和行替换作用于该数据（）：

　　最后，基于 XML 的标题和描述数据使用命令以 RSS JSON 格式输出。然后脚本休眠 30 秒，并请求更多 RSS 新闻信息进行处理：

　　我们创建了第二个基于 Scala 的流处理代码示例，名为。它类似于示例，但现在它处理来自流中的项数据。接下来，定义以处理来自 XML RSS 信息的类别、标题和摘要。定义了一个 HTML 位置来存储从 Flume 通道传来的结果数据。

　　来自基于 Flume 事件的 RSS 流数据被转换为字符串，然后使用名为的 case 类进行格式化。如果有事件数据，则使用之前的路径将其写入 HDFS 目录。

　　运行此代码示例，可以观察到 Perl RSS 脚本正在生成数据，因为 Flume 脚本的输出表明已接受并接收了 80 个事件。

　　事件已存储在 HDFS 下的预期目录中，正如 Hadoop 文件系统命令所示：

　　此外，使用 Hadoop 文件系统命令，可以证明 HDFS 上的文件包含基于订阅源的新闻数据，如下所示：

　　此基于 Spark 流的示例使用了 Apache Flume 将数据从源传输，经过 Flume，通过 Spark 消费者到达 HDFS。这是一个很好的示例，但如果你想向一组消费者发布数据呢？在下一节中，我们将探讨 Apache Kafka——一个发布/订阅消息系统——并确定如何将其与 Spark 结合使用。

　　Apache Kafka () 是 Apache 基金会下的一个顶级开源项目。它是一个快速且高度可扩展的大数据发布/订阅消息系统，利用消息代理进行数据管理，并通过 ZooKeeper 进行配置，以便数据可以组织成消费者组和主题。

　　Kafka 中的数据被分割成多个分区。在本例中，我们将展示一个基于 Spark 的无接收器 Kafka 消费者，这样我们就不需要在比较 Kafka 数据时担心配置 Spark 数据分区。为了演示基于 Kafka 的消息生产和消费，我们将使用上一节中的 Perl RSS 脚本作为数据源。传递到 Kafka 并到 Spark 的数据将是路透社 RSS 新闻…

　　我们本可以为其他系统提供流式示例，但本章没有空间。Twitter 流式传输已在检查点部分通过示例进行了探讨。本章提供了通过 Spark Streaming 中的检查点进行数据恢复的实用示例。它还触及了检查点的性能限制，并表明检查点间隔应设置为 Spark 流批处理间隔的五到十倍。

　　检查点提供了一种基于流的恢复机制，用于在 Spark 应用程序失败时进行恢复。本章提供了一些基于 TCP、文件、Flume 和 Kafka 的 Spark 流编码的流式工作示例。这里所有的示例都是基于 Scala 并用编译的。如果你更熟悉Maven，以下教程将解释如何设置基于 Maven 的 Scala 项目：。

　　正如你可能已经从前几章理解的那样，Apache Spark 目前正从基于 RDD 的数据处理过渡到更结构化的处理，背后有 DataFrames 和 Datasets 支持，以便让 Catalyst 和 Tungsten 发挥作用，进行性能优化。这意味着社区目前采用双轨制。虽然非结构化 API 仍然得到支持——它们甚至还没有被标记为已弃用，而且它们是否会这样做也值得怀疑——但在 Apache Spark V 2.0 中为各种组件引入了一套新的结构化 API，这也适用于 Spark Streaming。Structured Steaming 在 Apache Spark V 2.2 中被标记为稳定。请注意，截至 Apache Spark V 2.1 时…

　　流应用程序往往变得复杂。流计算不是孤立运行的；它们与存储系统、批处理应用程序和机器学习库交互。因此，与批处理相对的连续应用的概念应运而生，基本上意味着批处理和实时流处理的组合，其中流处理部分是应用程序的主要驱动力，并且仅访问由批处理过程创建或处理的数据以进行进一步增强。连续应用程序永不停止，并且随着新数据的到达而持续产生数据。

　　因此，一个连续的应用程序也可以基于 RDD 和 DStreams 实现，但需要使用两种不同的 API。在 Apache Spark Structured Streaming 中，API 得到了统一。这种统一是通过将结构化流视为一张无边界的关系表来实现的，其中新数据不断追加到表的底部。在批处理中使用关系 API 或 SQL 处理 DataFrames 时，会创建中间 DataFrames。由于流和批处理在 Apache SparkSQL 引擎上得到了统一，当处理结构化流时，会创建无边界的中间关系表。

　　重要的是要注意，可以混合（连接）静态和增量…

　　开源和商业流处理引擎，如 IBM Streams、Apache Storm 或 Apache Flink，都在使用窗口的概念。

　　Windows 指定了粒度或后续记录的数量，这些记录在执行流上的聚合函数时会被考虑。

　　存在五个不同的属性，分为两个维度，这就是窗口如何被定义的方式，其中每个窗口定义都需要使用每个维度的一个属性。

　　第一个属性是连续流中元组的后续窗口可以创建的模式：滑动和翻滚。

　　第二个是必须指定落入窗口的元组数量：基于计数、基于时间或基于会话。

　　让我们来看看它们的含义：

　　滑动窗口：每当有新元组符合条件被纳入时，滑动窗口就会移除一个元组。

　　翻滚窗口：每当有足够多的元组到达以创建新窗口时，翻滚窗口就会移除所有元组。

　　基于计数的…

　　Apache Spark 结构化流在窗口处理模型中展现出显著的灵活性。由于流被视为持续追加的表，且表中每行都带有时间戳，窗口操作可以在查询中直接指定，每个查询可以定义不同的窗口。此外，如果静态数据中存在时间戳，窗口操作也可以定义，从而形成一个非常灵活的流处理模型。

　　换言之，Apache Spark 的窗口操作本质上是对时间戳列的一种特殊分组。这使得处理迟到数据变得非常简单，因为 Apache Spark 可以将迟到数据纳入适当的窗口，并在特定数据项迟到时重新计算该窗口。此功能高度可配置。

　　事件时间与处理时间对比：在时间序列分析中，尤其是在流计算中，每个记录都会被分配一个特定的时戳。一种创建这种时戳的方法是记录到达流处理引擎的时间。然而，这往往并非所需。通常，我们希望为每个记录分配一个事件时间，即该记录创建时的特定时间点，例如，当物联网设备进行测量时。这有助于处理事件创建与处理之间的延迟，例如，当物联网传感器离线一段时间，或网络拥堵导致数据交付延迟时。

　　在使用事件时间而非处理时间为每个元组分配唯一时戳时，迟到数据的概念颇具趣味。事件时间是指特定测量发生的时间戳。Apache Spark 结构化流能够自动透明地处理在稍后时间点到达的数据子集。

　　迟到数据：无论记录何时到达任何流引擎，都会立即处理。在此方面，Apache Spark 流处理与其他引擎并无二致。然而，Apache Spark 具备在任何时间确定特定元组所属窗口的能力。如果由于任何原因元组迟到，所有受影响的窗口将被更新，基于这些更新窗口的所有受影响聚合操作将重新运行。这意味着，如果迟到数据到达，结果允许随时间变化，而无需程序员为此担忧。最后，自 Apache Spark V2.1 起，可以使用方法指定系统接受迟到数据的时间量。

　　水印基本上是阈值，用于定义延迟到达的数据点允许有多旧，以便仍能被包含在相应的窗口中。再次考虑 HTTP 服务器日志文件在超过一分钟长度的窗口上工作。如果，由于任何原因，一个数据元组到达，它超过 4 小时旧，如果这个应用程序用于创建基于小时的时间序列预测模型来为集群提供或取消提供额外的 HTTP 服务器，那么它可能没有意义将其包含在窗口中。一个四小时前的数据点就没有意义处理，即使它可能改变决策，因为决策已经做出。

　　正如在 Apache SparkSQL 中用于批处理，以及作为 Apache Spark 结构化流的一部分，Catalyst Planner 也为微批创建增量执行计划。这意味着整个流模型基于批处理。这也是为什么能够实现流处理和批处理的统一 API 的原因。我们付出的代价是，Apache Spark 流处理在面对极低延迟要求（亚秒级，在几十毫秒范围内）时有时会有缺点。正如结构化流和使用 DataFrame 及 Dataset 所暗示的，我们也因 Tungsten 项目带来的性能提升而受益，该项目在之前的…

　　Apache Spark 结构化流支持完全崩溃容错和精确一次投递保证，而无需用户处理任何特定的错误处理例程。这不是很神奇吗？那么这是如何实现的呢？

　　完全崩溃容错和精确一次投递保证是系统理论中的术语。完全崩溃容错意味着你可以在任何时间点拔掉整个数据中心的电源，而不会丢失任何数据或留下不一致的状态。精确一次投递保证意味着，即使拔掉同一个电源插头，也能确保每个元组——从数据源到数据汇——仅且仅一次被投递。既不是零次，也不会超过一次。当然，这些概念也必须在一个节点失败或行为异常（例如开始限流）的情况下成立。

　　首先，各个批次和偏移量范围（源流中的位置）之间的状态保持在内存中，但由预写日志（WAL）在如 HDFS 这样的容错文件系统中支持。WAL 基本上是一个日志文件，以主动的方式反映整个流处理状态。这意味着在数据通过操作符转换之前，它首先以一种可以在崩溃后恢复的方式持久存储在 WAL 中。因此，换句话说，在处理单个迷你批次期间，工作者内存的区域以及流源的偏移位置都被持久化到磁盘。如果系统失败并需要恢复，它可以重新请求源中的数据块。当然，这只在源支持这种语义的情况下才可能。

　　端到端的一次性交付保证要求流源支持在请求位置进行某种流重放。这对于文件源和 Apache Kafka 等是正确的，例如，以及本章中示例将基于的 IBM Watson 物联网平台。

　　端到端一次性交付保证的另一个关键是幂等接收器。这基本上意味着接收器知道过去哪些特定的写操作已经成功。这意味着这样的智能接收器可以在失败时重新请求数据，并在相同数据被发送多次时丢弃数据。

　　那么状态呢？设想一个机器学习算法在所有工作者上维护一个计数变量。如果你将完全相同的数据重放两次，你最终会多次计数这些数据。因此，查询计划器也在工作者内部维护一个版本化的键值映射，这些工作者依次将其状态持久化到 HDFS——这是设计上的容错机制。

　　因此，在发生故障时，如果数据需要被替换，计划器确保工作者使用正确的键值映射版本。

　　那么，让我们从一个示例用例开始。让我们连接到一个物联网（IoT）传感器数据流。由于我们到目前为止还没有涉及机器学习，我们不分析数据，我们只是展示概念。

　　我们使用 IBM Watson 物联网平台作为流数据源。在其核心，Watson 物联网平台由MQTT（消息队列遥测传输）消息代理支持。MQTT 是 IBM 于 1999 年发明的一种轻量级遥测协议，并于 2013 年成为OASIS（结构化信息标准促进组织，一个全球非营利性联盟，致力于安全、物联网、能源、内容技术、应急管理等领域的标准开发、融合和采纳）的标准——物联网数据集成的实际标准。

　　应用程序间的消息传递可以由消息队列支持，这是一种支持各种交付模式的异步点对点通道的中间件系统，如先进先出（FIFO）、后进先出（LIFO）或优先级队列（其中每条消息可以根据特定标准重新排序）。

　　这已经是一个非常棒的功能，但仍然以某种方式耦合了应用程序，因为一旦消息被读取，它就对其他应用程序不可用了。

　　这种 N 对 N 通信实现起来较为困难（但并非不可能）。在发布/订阅模型中，应用程序完全解耦。不再存在任何队列，而是引入了主题的概念。数据提供者在特定主题上发布消息，而数据消费者则订阅这些主题。这样一来，N 对 N 通信的实现就变得非常直接，因为它反映了底层的消息传递模型。这种中间件被称为消息代理，与消息队列相对。

　　由于云服务不断变化，且本书稍后才会介绍云，以下教程解释了如何在云中设置测试数据生成器并连接到远程 MQTT 消息代理。在本例中，我们将使用 IBM Watson IoT 平台，这是一个在云中可用的 MQTT 消息代理。或者，也可以安装开源消息代理如 MOSQUITTO，它还提供了一个公开可用的测试安装，网址如下：。

　　为了复现示例，以下步骤（1）和（2）是必要的，如以下教程所述：。请确保在执行教程时记下、、和。这些信息稍后用于通过 Apache Spark 结构化流订阅数据。

　　由于 IBM Watson 物联网平台采用开放的 MQTT 标准，因此无需特殊的 IBM 组件即可连接到该平台。相反，我们使用 MQTT 和 Apache Bahir 作为 MQTT 与 Apache Spark 结构化流之间的连接器。

　　Apache Bahir 项目的目标是为包括 Apache Spark 和 Apache Flink 在内的各种数据处理引擎提供一组源和汇连接器，因为它们缺乏这些连接器。在这种情况下，我们将使用 Apache Bahir MQTT 数据源进行 MQTT 通信。

　　为了使用 Apache Bahir，我们需要向本地 maven 仓库添加两个依赖项。本章下载部分提供了一个完整的文件。让我们看一下的依赖部分：

　　

　　我们基本上是在获取 Apache Bahir 的 MQTT Apache 结构化流适配器以及一个用于低级 MQTT 处理的依赖包。在文件所在的目录中执行简单的命令，会将所需的依赖项拉取到我们的本地 maven 仓库，在那里它们可以被 Apache Spark 驱动程序访问并自动传输到 Apache Spark 工作节点。

　　另一种解决依赖关系的方法是在启动 spark-shell（spark-submit 同样适用）时使用以下命令；必要的依赖项会自动分发给工作节点：

　　

　　现在我们需要之前获取的 MQTT 凭证。让我们在这里设置值：

　　现在我们可以开始创建一个连接到 MQTT 消息代理的流。我们告诉 Apache Spark 使用 Apache Bahir MQTT 流源：

　　为了从 MQTT 消息代理拉取数据，我们需要指定凭证，如、和；前面提到的教程链接解释了如何获取这些凭证：

　　由于我们使用的是发布/订阅消息模型，我们必须提供我们正在订阅的主题——这个主题由您之前部署到云端的测试数据生成器使用：

　　一旦配置方面一切就绪，我们就必须提供端点主机和端口以创建流：

　　有趣的是，正如以下截图所示，这导致了 DataFrame 的创建：

　　

　　请注意，模式固定为，并且在流创建过程中无法更改——这是 Apache Bahir 库的一个限制。然而，使用丰富的 DataFrame API，您可以解析值（例如，JSON 字符串）并创建新列。

　　如前所述，这是 Apache Spark 结构化流的一个强大功能，因为相同的 DataFrame（和 Dataset）API 现在可以用于处理历史和实时数据。因此，让我们通过将其写入控制台来查看此流的

　　作为输出模式，我们选择以强制增量显示，并避免历史流的内容被反复写入控制台。作为，我们指定，因为我们只想调试流上发生的情况：

　　

　　最后，方法启动查询处理，如这里所示：

　　

　　一旦连续应用程序（即使是简单的，不考虑历史数据）启动并运行，它就必须以某种方式进行控制，因为调用方法立即开始处理，但也不会阻塞返回。如果您希望程序在此阶段阻塞，直到应用程序完成，可以使用方法，如下所示：

　　这在预编译代码并使用命令时尤为重要。当使用时，应用程序无论如何都不会终止。

　　流式传输通常用于创建连续应用程序。这意味着该过程在后台运行，与批处理不同，它没有明确的停止时间；因此，由流式源支持的 DataFrames 和 Datasets 支持各种流生命周期管理方法，如下所述：

　　：这启动了连续应用程序。此方法不会阻塞。如果这不是您想要的，请使用。

　　：这终止了连续应用程序。

　　：如前所述，使用方法启动流立即返回，这意味着调用不会阻塞。有时您希望等待直到流被终止，无论是由其他人调用还是由于错误。

　　：如果流因错误而停止，可以使用此方法读取原因。

　　：这是为了获取流式源的实时元信息。

　　：这是为了获取流式接收器的实时元信息。

　　Apache Spark 流式传输中的接收器很智能，因为它们支持故障恢复和端到端的一次性交付保证，如前所述。此外，Apache Spark 需要它们支持不同的输出方法。目前，以下三种输出方法、和显著改变了底层语义。以下段落包含有关不同输出方法的更多详细信息。

　　不同的输出模式在接收器上：接收器可以指定以不同方式处理输出。这称为。最简单的选择是使用增量方法，因为我们无论如何都在处理增量数据流。此模式称为。然而，存在一些需求，其中已经由接收器处理的数据必须更改。一个例子是特定时间窗口中缺失数据的延迟到达问题，一旦为该特定时间窗口重新计算，就可能导致结果改变。此模式称为。

　　自 Apache Spark 2.1 版本起，引入了模式，其行为类似于模式，但仅更改已修改的行，从而节省处理资源并提高速度。某些模式不支持所有查询类型。由于这不断变化，最好参考上的最新文档。

　　那么为什么在同一个数据处理框架内会有两种不同的流处理引擎呢？我们希望在阅读本章后，您会认同经典 DStream 引擎的主要痛点已得到解决。以前，基于事件时间的处理是不可能的，只考虑了数据的到达时间。随后，延迟数据仅以错误的时戳进行处理，因为只能使用处理时间。此外，批处理和流处理需要使用两种不同的 API：RDD 和 DStreams。尽管 API 相似，但并不完全相同；因此，在两种范式之间来回切换时重写代码是必要的。最后，端到端的交付保证难以实现…

　　MLlib 是 Apache Spark 附带的原始机器学习库，Apache Spark 是一个基于内存的集群式开源数据处理系统。该库仍然基于 RDD API。在本章中，我们将从回归、分类和神经网络处理等领域来探讨 MLlib 库提供的功能。在提供解决实际问题的示例之前，我们将先探讨每种算法的理论基础。网络上的示例代码和文档可能稀少且令人困惑。

　　我们将采取逐步的方式来描述以下算法的使用方法及其功能：

　　架构

　　使用朴素贝叶斯进行分类

　　K-Means 聚类

　　使用人工神经网络进行图像分类

　　请记住，尽管 Spark 因其内存中的分布式处理速度而被使用，但它并不提供存储。您可以使用主机（本地）文件系统来读写数据，但如果您的数据量足够大，可以称之为大数据，那么使用基于云的分布式存储系统（如 OpenStack Swift 对象存储）是有意义的，该系统可以在许多云环境中找到，也可以安装在私有数据中心中。

　　如果需要极高的 I/O 性能，HDFS 也是一个选项。更多关于 HDFS 的信息可以在这里找到：。

　　本书中的代码示例将使用 Scala 语言编写。这是因为作为一种脚本语言，它产生的代码比 Java 少。它也可以在 Spark shell 中使用，以及与 Apache Spark 应用程序一起编译。我们将使用sbt 工具来编译 Scala 代码，我们已经按照以下方式将其安装到 Hortonworks HDP 2.6 Sandbox 中：

　　以下 URL 提供了在包括 Windows、Linux 和 macOS 在内的其他操作系统上安装 sbt 的说明：。

　　我们使用了一个名为Hadoop的通用 Linux 账户。如前述命令所示，我们需要以 root 账户安装，我们通过（切换用户）访问了该账户。然后，我们使用从名为的基于网络的服务器下载了文件到目录。最后，我们使用带有（安装）、（验证）和（打印哈希标记）选项的命令安装了文件。

　　本章中，我们在 Linux 服务器上使用 Linux Hadoop 账户开发了 Apache Spark 的所有 Scala 代码。我们将每组代码放置在下的一个子目录中。例如，以下结构图显示 MLlib 朴素贝叶斯代码存储在 Spark 目录下的名为的子目录中wps 的官网最新的下载的网址是多少。该图还显示，Scala 代码是在目录下的子目录结构中开发的。名为和的文件包含将在下一节中使用的朴素贝叶斯代码：

　　

　　文件是工具使用的配置文件，描述了如何编译 Scala 目录内的 Scala 文件。（注意，如果你使用 Java 开发，你将使用这样的路径。）接下来展示文件的内容。和Linux 命令提醒你文件位置，并提示你查看文件内容。

　　、和选项设置项目详细信息及使用的 Scala 版本。选项定义 Hadoop 和 Spark 库的位置。

　　可以使用以下命令从子目录编译 Scala 项目代码：

　　命令用于将代码编译成类。这些类随后被放置在目录下。使用此命令可将编译后的类打包成 JAR 文件：

　　命令将在目录下创建一个 JAR 文件。如sbt 结构图所示例中，编译打包成功后，名为的 JAR 文件已被创建。此 JAR 文件及其包含的类可通过命令使用。随着对 Apache Spark MLlib 模块功能的探索，这将在后面描述。

　　本节将提供一个 Apache Spark MLlib 朴素贝叶斯算法的实际示例。它将阐述该算法的理论基础，并提供一个逐步的 Scala 示例，展示如何使用该算法。

　　要使用朴素贝叶斯算法对数据集进行分类，数据必须是线性可分的；即数据中的类别必须能通过类别边界线性分割。下图通过三条数据集和两条虚线表示的类别边界直观解释了这一点：

　　

　　朴素贝叶斯假设数据集内的特征（或维度）彼此独立；即它们互不影响。以下示例考虑将电子邮件分类为垃圾邮件。如果你有 100 封电子邮件，则执行以下操作：

　　让我们将此示例转换为条件概率，以便朴素贝叶斯分类器可以识别：

　　包含单词“buy”的电子邮件是垃圾邮件的概率是多少？这可以写为P(Spam|Buy)。朴素贝叶斯表示，它由以下等式描述：

　　

　　因此，使用之前的百分比数据，我们得到以下结果：

　　P(Spam|Buy) = ( 0.8 * 0.6 ) / (( 0.8 * 0.6 ) + ( 0.1 * 0.4 ) ) = ( .48 ) / ( .48 + .04 )

　　= .48 / .52 = .923

　　这意味着包含单词“buy”的电子邮件是垃圾邮件的可能性*92%*更高。以上是理论部分；现在是时候尝试一个使用 Apache Spark MLlib 朴素贝叶斯算法的真实示例了。

　　第一步是选择一些用于分类的数据。我们选择了英国政府数据网站上的一些数据，网址为。

　　数据集名为道路安全 – 数字呼吸测试数据 2013，下载一个名为的压缩文本文件。该文件包含大约五十万行。数据如下所示：

　　为了对数据进行分类，我们对列进行了修改…

　　本例将使用与前例相同的测试数据，但我们尝试使用 MLlib 的 K-Means 算法在数据中寻找簇。

　　K-Means 算法通过迭代尝试，通过最小化簇中心向量的均值与新候选簇成员向量之间的距离，来确定测试数据中的簇。以下等式假设数据集成员范围从X1到Xn；同时也假设K个簇集合，范围从S1到Sk，其中K <= n。

　　

　　MLlib 的 K-Means 功能使用结构处理数据，因此需要数值输入数据。由于正在重复使用上一节的数据，我们将不再解释数据转换。本节中数据方面的唯一变化是，处理将在 HDFS 下的目录进行。此外，K-Means 示例的转换 Scala 脚本生成的记录全部以逗号分隔。

　　为了将工作与其他开发分开，K-Means 示例的开发和处理已在目录下进行。配置文件现在称为，与上一个示例相同，只是项目名称不同：

　　本节代码可在软件包的目录下找到。因此，查看存储在下的代码，会发现一些类似的操作。导入语句引用了 Spark 上下文和配置。然而，这一次，K-Means 功能是从 MLlib 导入的。此外，为了这个例子，应用程序类名已更改为：

　　与上例相同，正在采取行动定义数据文件——定义 Spark 配置并创建 Spark 上下文：

　　接下来，从数据文件加载 CSV 数据，并通过逗号字符分割到变量中：

　　对象被初始化，并设置参数以定义簇的数量和确定它们的最大迭代次数：

　　为初始化模式、运行次数和 Epsilon 定义了一些默认值，这些值是我们进行 K-Means 调用所需的，但在处理过程中并未改变。最后，这些参数被设置到对象上：

　　我们缓存了训练向量数据以提高性能，并使用向量数据训练了对象，创建了一个经过训练的 K-Means 模型：

　　我们计算了 K-Means 成本和输入数据行数，并通过语句输出了结果。成本值表示簇的紧密程度以及簇之间的分离程度：

　　接下来，我们使用 K-Means 模型打印出计算出的三个簇中每个簇的中心作为向量：

　　最后，我们使用 K-Means 模型的预测函数来创建一个簇成员资格预测列表。然后，我们按值计数这些预测，以给出每个簇中数据点的计数。这显示了哪些簇更大，以及是否真的存在三个簇：

　　因此，为了运行此应用程序，必须从子目录进行编译和打包，正如 Linux 的命令所示：

　　一旦打包成功，我们检查 HDFS 以确保测试数据已就绪。如前例所示，我们使用软件包中提供的文件将数据转换为数值形式。我们将处理 HDFS 目录中的数据文件，如下所示：

　　使用工具运行 K-Means 应用程序。此命令中唯一的更改是类名现在是：

　　来自 Spark 集群运行的输出显示如下：

　　先前的输出显示了输入数据量，看起来是正确的；它还显示了值。该成本基于内部总和平方误差（WSSSE），基本上给出了找到的簇质心与数据点分布匹配程度的度量。匹配得越好，成本越低。以下链接更详细地解释了 WSSSE 以及如何找到一个好的k值。

　　接下来是三个向量，它们描述了具有正确维数的数据簇中心。请记住，这些簇质心向量将具有与原始向量数据相同的列数：

　　最后，给出了 1 至 3 簇的簇成员资格，其中簇 1（索引 0）拥有最大的成员资格，有个成员向量：

　　因此，这两个示例展示了如何使用朴素贝叶斯和 K-Means 对数据进行分类和聚类。如果我想对图像或更复杂的模式进行分类，并使用黑盒方法进行分类呢？下一节将探讨基于 Spark 的分类，使用ANNs，即人工神经网络。

　　下图左侧展示了一个简单的生物神经元。该神经元具有接收其他神经元信号的树突。细胞体控制激活，轴突将电脉冲传递到其他神经元的树突。右侧的人工神经元有一系列加权输入：一个汇总函数，将输入分组，以及一个触发机制（F(Net)），该机制决定输入是否达到阈值，如果是，则神经元将触发：

　　

　　神经网络对噪声图像和失真具有容忍度，因此在需要潜在的…黑盒分类方法时非常有用。

　　为了开始 ANN 训练，需要测试数据。鉴于这种分类方法应该擅长分类扭曲或噪声图像，我们决定在这里尝试对图像进行分类：

　　

　　它们是手工制作的文本文件，包含由 1 和 0 组成的形状块。当存储在 HDFS 上时，回车符会被移除，使得图像呈现为单行向量。因此，ANN 将对一系列形状图像进行分类，然后与添加了噪声的相同图像进行测试，以确定分类是否仍然有效wps的的官网的下载入口怎么找。有六张训练图像，每张图像将被赋予一个从 0.1 到 0.6 的任意训练标签。因此，如果 ANN 呈现一个闭合的正方形，它应该返回标签 0.1。下图展示了一个带有噪声的测试图像示例。

　　通过在图像内添加额外的零（0）字符创建的噪声已被突出显示：

　　

　　与之前一样，ANN 代码是在 Linux Hadoop 账户下的子目录中开发的。文件位于目录中：

　　文件的内容已更改，以使用 Spark 依赖项 JAR 库文件的完整路径：

　　如前例所示，实际要编译的 Scala 代码存放在名为的子目录中。我们创建了两个 Scala 程序。第一个程序使用输入数据进行训练，然后用同一输入数据测试 ANN 模型。第二个程序则用噪声数据测试已训练模型的扭曲数据分类能力：

　　我们将检查第一个 Scala 文件，然后仅展示第二个文件的额外特性，因为两个示例在训练 ANN 之前非常相似。此处展示的代码示例可在本书提供的软件包中的路径下找到。因此，要检查第一个 Scala 示例，导入语句与前例类似。正在导入 Spark 上下文、配置、向量和。这次还导入了用于 RDD 处理的类以及新的 ANN 类。请注意，MLlib/分类例程广泛使用结构作为输入数据，该结构将包含要训练的特征和标签：

　　本例中的应用程序类名为。要处理的 HDFS 文件已根据 HDFS 的、和文件名定义：

　　Spark 上下文已使用 Spark 实例的 URL 创建，现在端口号不同——。应用程序名称为。当应用程序运行时，这将在 Spark Web UI 上显示：

　　基于 HDFS 的输入训练和测试数据文件被加载。每行上的值通过空格字符分割，数值已转换为双精度数。包含此数据的变量随后存储在一个名为inputs的数组中。同时，创建了一个名为 outputs 的数组，包含从到的标签。这些值将用于对输入模式进行分类：

　　代表输入数据特征和标签的输入和输出数据随后被合并并转换为结构。最后，数据被并行化，以便为最佳并行处理进行分区：

　　变量用于定义人工神经网络（ANN）的隐藏层拓扑结构。在此例中，我们选择了两个隐藏层，每层各有 100 个神经元。同时定义了最大迭代次数、批次大小（六个模式）以及收敛容差。容差指的是训练误差达到多大时，我们可以认为训练已经成功。接着，根据这些配置参数和输入数据创建了一个 ANN 模型：

　　为了测试已训练的 ANN 模型，使用相同的输入训练数据作为测试数据以获取预测标签。首先，创建一个名为的输入数据变量。然后，数据被分区，并最终使用已训练的 ANN 模型获取预测结果。为了使该模型工作，它必须输出标签，即到：

　　打印标签预测结果，脚本以闭合括号结束：

　　因此，要运行此代码示例，首先必须对其进行编译和打包。至此，您应该已经熟悉了从子目录执行的命令：

　　然后，在新路径内使用新的基于 Spark 的 URL（端口）运行应用程序，使用命令：

　　通过访问 Apache Spark 网页 URL ，现在可以看到应用程序正在运行。下图显示了应用程序的运行情况以及先前完成的执行：

　　

　　通过选择其中一个集群主机工作实例，可以看到实际执行集群处理的工作实例的执行程序列表：

　　

　　最后，通过选择其中一个执行程序，可以看到其历史和配置，以及到日志文件和错误信息的链接。在这一级别，借助提供的日志信息，可以进行调试。可以检查这些日志文件以处理错误消息：

　　

　　应用程序提供了以下输出，以显示它已正确地对相同输入数据进行了重新分类。重新分类成功，因为每个输入模式都被赋予了与其训练时相同的标签：

　　这表明 ANN 训练和测试预测将适用于相同的数据。现在，我们将使用相同的数据进行训练，但测试时使用扭曲或含噪声的数据，我们已展示了一个示例。该示例可在软件包中的文件中找到。它与第一个示例非常相似，因此我们将仅展示更改的代码。该应用程序现在称为：

　　在 ANN 模型使用训练数据创建后，会生成一组额外的测试数据。此测试数据包含噪声：

　　此数据被处理成输入数组并分区以供集群处理：

　　它随后以与第一个示例相同的方式生成标签预测。如果模型正确分类数据，则应从到打印相同的标签值：

　　代码已经编译完成，因此可以使用命令运行：

　　本脚本的集群输出显示了使用训练好的 ANN 模型对一些噪声测试数据进行成功分类的情况。噪声数据已被正确分类。例如，如果训练模型出现混淆，它可能会对位置一的噪声测试图像给出 0.15 的值，而不是像实际那样返回：

　　本章试图为你概述 Apache Spark MLlib 模块中可用的一些功能。它还展示了即将在 ANNs 或人工神经网络方面可用的功能。你可能会对 ANNs 的工作效果印象深刻。由于时间和篇幅限制，本章无法涵盖 MLlib 的所有领域。此外，我们现在希望在下一章中更多地关注 SparkML 库，该库通过支持 DataFrames 以及底层 Catalyst 和 Tungsten 优化来加速机器学习。

　　我们学习了如何开发基于 Scala 的示例，用于朴素贝叶斯分类、K-Means 聚类和 ANNs。你了解了如何准备测试…

　　既然你已经学了很多关于 MLlib 的知识，为什么还需要另一个 ML API 呢？首先，在数据科学中，与多个框架和 ML 库合作是一项常见任务，因为它们各有优劣；大多数情况下，这是性能和功能之间的权衡。例如，R 在功能方面是王者——存在超过 6000 个 R 附加包。然而，R 也是数据科学执行环境中最慢的之一。另一方面，SparkML 目前功能相对有限，但却是速度最快的库之一。为什么会这样呢？这引出了 SparkML 存在的第二个原因。

　　RDD 与 DataFrames 和 Datasets 之间的二元性就像本书中的一条红线，并且不断影响着机器学习章节。由于 MLlib 设计为在 RDD 之上工作，SparkML 在 DataFrames 和 Datasets 之上工作，因此利用了 Catalyst 和 Tungsten 带来的所有新性能优势。

　　本章我们将涵盖以下主题：

　　SparkML API 简介

　　管道概念

　　转换器和估计器

　　一个工作示例

　　在 Apache Spark 上进行机器学习时，我们习惯于在将数据实际输入算法之前将其转换为适当的格式和数据类型。全球的机器学习实践者发现，机器学习项目中的预处理任务通常遵循相同的模式：

　　数据准备

　　训练

　　评估

　　超参数调整

　　因此，新的 ApacheSparkML API 原生支持这一过程。它被称为管道，灵感来源于 scikit-learn ，一个非常流行的 Python 编程语言机器学习库。中央数据结构是 DataFrame，所有操作都在其上运行。

　　ApacheSparkML 管道包含以下组件：

　　DataFrame：这是中央数据存储，所有原始数据和中间结果都存储于此。

　　转换器：顾名思义，转换器通过在大wps的官网的下载的网站在哪里多数情况下添加额外的（特征）列将一个 DataFrame 转换为另一个。转换器是无状态的，这意味着它们没有任何内部内存，每次使用时行为完全相同；这个概念在使用 RDD 的 map 函数时你可能已经熟悉。

　　估计器：在大多数情况下，估计器是一种机器学习模型。与转换器不同，估计器包含内部状态表示，并且高度依赖于它已经见过的数据历史。

　　管道：这是将前面提到的组件——DataFrame、Transformer 和 Estimator——粘合在一起的胶水。

　　参数：机器学习算法有许多可调整的旋钮。这些被称为超参数，而机器学习算法为了拟合数据所学习的值被称为参数。通过标准化超参数的表达方式，ApacheSparkML 为任务自动化打开了大门，正如我们稍后将看到的。

　　让我们从简单的事情开始。机器学习数据准备中最常见的任务之一是对分类值进行字符串索引和独热编码。让我们看看这是如何完成的。

　　假设我们有一个名为的 DataFrame，其中包含一个名为 color 的分类标签列——红色、绿色和蓝色。我们希望将它们编码为整数或浮点值。这时就派上用场了。它会自动确定类别集的基数，并为每个类别分配一个唯一值。所以在我们的例子中，一个类别列表，如红色、红色、绿色、红色、蓝色、绿色，应该被转换为 1、1、2、1、3、2：

　　此转换的结果是一个名为 indexed 的 DataFrame，除了字符串类型的颜色列外，现在还包含一个名为的 double 类型列。

　　我们仅进行了一半。尽管机器学习算法能够利用列，但如果我们对其进行独热编码，它们的表现会更好。这意味着，与其拥有一个包含 1 到 3 之间标签索引的列，不如我们拥有三个列——每种颜色一个——并规定每行只允许将其中一个列设置为 1，其余为 0。让我们这样做：

　　直观上，我们期望在编码后的 DataFrame 中得到三个额外的列，例如，、和…

　　在我们开始实际的机器学习算法之前，我们需要应用最后一个转换。我们必须创建一个额外的列，其中包含我们希望机器学习算法考虑的所有列的信息。这是通过如下完成的：

　　这个转换器只为结果 DataFrame 添加了一个名为features的列，该列的类型为。换句话说，这个由创建的新列 features 包含了我们定义的所有列（在这种情况下，、、和），每行编码在一个向量对象中。这是 Apache SparkML 算法所喜欢的格式。

　　在我们深入了解估计器之前——我们已经在中使用过一个——让我们首先理解管道的概念。你可能已经注意到，转换器只向 DataFrame 添加一个单一列，并且基本上省略了所有未明确指定为输入列的其他列；它们只能与一起使用，后者将单个转换器（和估计器）粘合在一起，形成一个完整的数据分析过程。因此，让我们为我们的两个阶段执行此操作：

　　现在得到的 DataFrame 称为transformed，包含所有…

　　我们在中已经使用过估计器。我们已经说过，估计器在查看数据时会改变其状态，而转换器则不会。那么为什么是估计器呢？这是因为它需要记住所有先前见过的字符串，并维护字符串和标签索引之间的映射表。

　　在机器学习中，通常至少使用可用的训练数据的一个训练和测试子集。在管道中的估计器（如）在查看训练数据集时可能没有看到所有的字符串标签。因此，当你使用测试数据集评估模型时，现在遇到了它以前未见过的标签，你会得到一个异常。实际上，这是一个非常罕见的情况，基本上可能意味着你用来分离训练和测试数据集的样本函数不起作用；然而，有一个名为的选项，你的问题就解决了。

　　区分估计器和转换器的另一种简单方法是查看估计器上是否有额外的方法。实际上，fit 方法会根据给定数据集填充估计器的内部数据管理结构，在的情况下，这是标签字符串和标签索引之间的映射表。现在让我们来看另一个估计器，一个实际的机器学习算法。

　　假设我们处于二分类问题设置中，并希望使用。所有 SparkML 算法都有一个兼容的 API，因此它们可以互换使用。所以使用哪个并不重要，但比更简单的模型如逻辑回归有更多的（超）参数。在稍后的阶段，我们将使用（超）参数调整，这也是 Apache SparkML 内置的。因此，使用一个可以调整更多参数的算法是有意义的。将这种二分类器添加到我们的中非常简单：

　　如前所述，模型评估是 ApacheSparkML 内置的，你会在包中找到所需的一切。让我们继续进行二分类。这意味着我们将不得不使用：

　　为了编码，之前初始化了一个函数，并告诉它计算，这是评估机器学习算法预测性能的众多可能指标之一。

　　由于我们在名为的数据框中同时拥有实际标签和预测，因此计算此分数很简单，使用以下代码行完成：

　　我们将分别看一个和超参数调整的例子。让我们来看看。

　　如前所述，我们使用了机器学习算法的默认参数，我们不知道它们是否是好的选择。此外，与其简单地将数据分为训练集和测试集，或训练集、测试集和验证集，可能是一个更好的选择，因为它确保最终所有数据都被机器学习算法看到。

　　基本上将你全部可用的训练数据分成若干个k折。这个参数k可以指定。然后，整个对每一折运行一次，并为每一折训练一个机器学习模型。最后，通过分类器的投票方案或回归的平均方法将得到的各种机器学习模型合并。

　　下图说明了十折：

　　

　　通常与所谓的（超）参数调整结合使用。什么是超参数？这些是你可以在你的机器学习算法上调整的各种旋钮。例如，以下是随机森林分类器的一些参数：

　　树的数量

　　特征子集策略

　　不纯度

　　最大箱数

　　最大树深度

　　设置这些参数可能会对训练出的分类器的性能产生重大影响。通常，没有明确的方案来选择它们——当然，经验有帮助——但超参数调整被视为黑魔法。我们不能只选择许多不同的参数并测试预测性能吗？当然可以。这个功能…

　　赢得 Kaggle 竞赛本身就是一门艺术，但我们只是想展示如何有效地使用 Apache SparkML 工具来做到这一点。

　　我们将使用博世公司提供的一个存档竞赛来进行这个操作，博世是一家德国跨国工程和电子公司，关于生产线性能数据。竞赛数据的详细信息可以在找到。

　　挑战数据以三个 ZIP 包的形式提供，但我们只使用其中两个。一个包含分类数据，一个包含连续数据，最后一个包含测量时间戳，我们暂时忽略它。

　　如果你提取数据，你会得到三个大型 CSV 文件。因此，我们首先要做的是将它们重新编码为 parquet，以便更节省空间：

　　首先，我们定义一个函数…

　　现在，是时候运行第一个转换器（实际上是估计器）了。它是，需要跟踪字符串和索引之间的内部映射表。因此，它不是转换器，而是估计器：

　　如图所示，已创建一个名为的附加列：

　　

　　最后，让我们检查新创建列的一些内容，并与源列进行比较。

　　我们可以清楚地看到类别字符串是如何转换为浮点索引的：

　　

　　现在，我们想要应用，这是一个转换器，以便为我们的机器学习模型生成更好的特征：

　　如图所示，新创建的列包含对象，这是一种稀疏向量的压缩表示：

　　稀疏向量表示：与其他许多算法一样，返回一个类型的稀疏向量，根据定义，向量中只有一个元素可以为 1，其余必须保持为 0。这为压缩提供了大量机会，因为只需知道非零元素的位置即可。Apache Spark 使用以下格式的稀疏向量表示：(l,[p],[v])，其中l代表向量长度，p代表位置（这也可以是位置数组），v代表实际值（这可以是值数组）。因此，如果我们得到(13,[10],[1.0])，如我们之前的例子所示，实际的稀疏向量看起来是这样的：(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0)。

　　现在，我们的特征工程已完成，我们想要创建一个包含机器学习器所需所有必要列的总体稀疏向量。这是通过使用完成的：

　　我们基本上只需定义列名列表和目标列，其余工作将自动完成：

　　

　　由于列的视图有些压缩，让我们更详细地检查特征字段的一个实例：

　　

　　我们可以清楚地看到，我们处理的是一个长度为 16 的稀疏向量，其中位置 0、13、14 和 15 是非零的，并包含以下值：、、和。完成！让我们用这些组件创建一个。

　　让我们用我们的转换器和估计器创建一个：

　　请注意，的方法仅期望一个由和组成的数组，这些我们之前已经创建。由于的部分包含估计器，我们必须先对我们的运行。得到的对象在方法中接受一个，并返回转换的结果：

　　正如预期的，…

　　现在是时候向添加另一个组件了：实际的机器学习算法——随机森林：

　　这段代码非常直接。首先，我们必须实例化我们的算法，并将其作为引用获取到中。我们可以为模型设置额外的参数，但我们将稍后在步骤中以自动化方式进行。然后，我们只需将阶段添加到我们的，拟合它，并最终转换。方法，除了运行所有上游阶段外，还调用上的拟合以训练它。训练好的模型现在包含在中，方法实际上创建了我们的预测列：

　　

　　正如我们所见，我们现在获得了一个名为 prediction 的额外列，其中包含模型的输出。当然，我们仅使用了可用特征/列的一个非常有限的子集，并且尚未调整模型，因此我们不期望表现很好；但是，让我们看看如何使用 Apache SparkML 轻松评估我们的模型。

　　没有评估，模型一文不值，因为我们不知道它的准确性如何。因此，我们现在将使用内置的来评估预测性能，并使用一个广泛使用的度量标准，称为（深入探讨这一点超出了本书的范围）：

　　正如我们所见，有一个内置类名为，还有其他一些…

　　如前所述，机器学习中的一个常见步骤是使用测试数据对训练数据进行交叉验证，并调整机器学习算法的旋钮。让我们使用 Apache SparkML 来自动完成这一过程！

　　首先，我们必须配置参数映射和：

　　用于定义需要在其中搜索的超参数空间，而则接收我们的、随机森林分类器的超参数空间以及的折数作为参数。现在，按照惯例，我们只需对调用 fit 和 transform 方法，它就会基本运行我们的多次，并返回一个表现最佳的模型。你知道训练了多少个不同的模型吗？我们有 5 折的和 5 维超参数空间基数在 2 到 8 之间，所以让我们计算一下：5 * 8 * 5 * 2 * 7 * 7 = 19600 次！

　　既然我们已经以全自动方式优化了，接下来让我们看看如何获得最佳模型：

　　代码基本上返回了最佳。现在我们使用来获取各个阶段，并获得经过调优的

　　你已经了解到，正如在许多其他领域一样，引入促进了互补框架的发展，这些框架不再直接使用 RDDs。机器学习领域亦是如此，但还有更多内容。实际上将 Apache Spark 中的机器学习提升到了一个新的水平，极大地提高了数据科学家的生产力。

　　所有中间对象之间的兼容性以及精心设计的概念简直令人惊叹。太棒了！最后，我们将讨论的概念应用于来自 Kaggle 竞赛的真实数据集，这对于你自己的 Apache SparkML 机器学习项目来说是一个非常好的起点。下一章将介绍 Apache SystemML，这是一个第三方机器学习库，用于 Apache Spark。让我们看看它为何有用以及与 SparkML 的区别。

　　到目前为止，我们只涵盖了 Apache Spark 标准发行版附带的组件（当然，除了 HDFS、Kafka 和 Flume）。然而，Apache Spark 也可以作为第三方组件的运行时，使其成为某种大数据应用的操作系统。在本章中，我们将介绍最初由IBM Almaden Research Lab在加利福尼亚开发的 Apache SystemML，这是一项令人惊叹的技术。Apache SystemML 经历了许多转变阶段，现在已成为 Apache 顶级项目。

　　在本章中，我们将探讨以下主题，以深入了解该主题：

　　在 Apache Spark 之上使用 SystemML 开发您自己的机器学习应用

　　学习…

　　为了回答这个问题，我们需要了解 SystemML 的历史，该历史始于 2007 年，作为IBM Almaden Research Lab在加利福尼亚的一个研究项目。该项目旨在改善数据科学家的工作流程，特别是那些希望改进和增强现有机器学习算法功能的人。

　　因此，SystemML是一种声明性标记语言，能够透明地在 Apache Spark 上分发工作。它支持通过多线程和 CPU 上的 SIMD 指令以及 GPU 进行 Scale-up，以及通过集群进行 Scale-out，当然，两者可以同时进行。

　　最后，有一个基于成本的优化器，它生成考虑数据集大小统计信息的低级执行计划。换句话说，Apache SystemML之于机器学习，正如 Catalyst 和 Tungsten 之于 DataFrames。
wps官网下载地方怎么找
　　Apache Spark 解决了数据处理和机器学习中的许多常见问题，因此 Apache SystemML 可以利用这些功能。例如，Apache Spark 支持在通用 RDD 结构之上统一 SQL、图形、流和机器学习数据处理。

　　换言之，它是一个支持惰性求值和分布式内存缓存的通用DAG（有向无环图）执行引擎。

　　Apache SystemML 已有十年历史。当然，它经历了多次重构，现已成为世界上最先进、最快的机器学习库之一。

　　

　　如前图所示，针对 Apache SystemML 进行了大量研究。它比 Apache Spark 早两年，并在 2017 年成为 Apache 顶级项目，脱离孵化器状态。甚至在 SystemML 启动之初，IBM Research Almaden的研究人员就意识到，通常情况下，开箱即用的机器学习算法在大数据集上表现非常糟糕。

　　因此，数据分析管道在经过小规模原型调整后必须进行优化。下图说明了这一点：

　　

　　这意味着数据科学家将在他选择的编程语言中设计他的应用程序，最可能是 Matlab、R 或 Python，最终，系统程序员将接手这个工作，并将其重新实现为 JVM 语言，如 Java 或 Scala，这通常会提供更好的性能，并且也能在数据并行框架如 Apache Spark 上进行线性扩展。

　　原型的缩放版本将在整个数据集上返回结果，数据科学家再次负责修改原型，整个循环再次开始。不仅 IBM Almaden 研究中心的员工经历过这种情况，我们的团队也见证了这一点。因此，让我们使系统程序员变得多余（或者至少只需要他来处理我们的 Apache Spark 作业），使用 Apache SystemML。

　　让我们从一个例子开始，来说明 Apache SystemML 内部是如何工作的。考虑一个推荐系统。

　　推荐系统试图根据其他用户的历史记录预测用户可能感兴趣的潜在商品。

　　因此，让我们考虑一个所谓的商品-用户或产品-客户矩阵，如图所示：

　　

　　这是一个所谓的稀疏矩阵，因为只有少数单元格填充了非零值，表示客户i和产品j之间的匹配。要么在单元格中放置一个一，要么放置任何其他数值，例如，表示购买的产品数量或客户i对特定产品j的评分。我们称这个矩阵为r[ui]，其中u代表用户，i代表商品。

　　熟悉线性代数的你可能知道，任何矩阵都可以通过两个较小的矩阵进行因式分解。这意味着你需要找到两个矩阵p[u]和q[i]，当它们相乘时，能够重构原始矩阵r[ui]；我们称这个重构为r[ui]'。目标是找到p[u]和q[i]以重构r[ui]'，使其与*r[ui]*的差异不过大。这通过求和平方误差目标函数来实现。

　　下图说明了这一点以及矩阵的稀疏性特性：

　　

　　一旦我们找到了良好的因子p[u]和q[i]，我们就能构建r[ui]'，最终，新的非零单元格将出现，这些将成为新的预测产品推荐。如果你还没有完全理解所有细节，不用担心，因为理解本章其余部分并不需要太多这个例子。

　　寻找p[u]和q[i]的常用算法称为交替最小二乘法（ALS）——交替是因为在每次迭代中，优化目标从p[u]切换到q[i]，反之亦然。对此不必过于纠结，但实际运作即是如此，而在 Apache Spark MLlib 中，这仅是一行 Scala 代码：

　　

　　那么问题何在？在我们解释之前，先来看看 ALS 如何在统计编程语言如 R 中实现：

　　

　　同样，若你未能理解每一行代码也不必担心，此图旨在展示在 R 中，该算法仅需 27 行代码即可表达。若我们再查看 MLlib 中的 ALS 实现，会发现它有超过 800 行代码。你可在找到此实现。

　　那么为何在 Spark 上需要超过 800 行的 Scala 代码，而在 R 中仅需 27 行呢？这是因为性能优化。MLlib 中的 ALS 实现包含了超过 50%的性能优化代码。如果我们能做到以下这些呢？

　　去除我们算法实现中的所有性能优化

　　将我们的 R 代码 1:1 移植到某个并行框架

　　如有变动，只需修改我们的 R 实现

　　这正是 Apache SystemML 发挥作用的地方，它支持这一切。Apache SystemML 的DSL（特定领域语言）是 R 语法的一个子集，因此你可以直接将之前的示例原封不动地运行在 Apache SystemML 之上，无需任何修改。此外，基于成本的性能优化器会在 Apache Spark 之上生成物理执行计划，以根据数据规模属性最小化执行时间。那么，让我们探究其工作原理。

　　在 Apache SystemML 中，关键在于优化器。该组件将算法的高级描述在特定领域语言中转化为 Apache Spark 上高度优化的物理执行，如图所示：

　　

　　让我们稍稍揭开 Apache SystemML 优化器的神秘面纱，以便理解其中究竟发生了什么。引擎首先进行的是 DSL 的编译步骤。首先是语法检查，然后进行活跃变量分析以确定哪些中间结果仍需保留，最后进行语义检查。

　　一旦通过前述步骤，便生成使用所谓高级操作符（HOPs）的执行计划。这些操作符构建自 DSL 的抽象语法树（AST）。在此阶段，以下重要优化步骤正在进行：

　　静态重写：DSL 提供了一套丰富的语法和语义特性，使得实现易于理解，但可能导致非最优执行。Apache SystemML 检测到这些 AST 分支，并静态地将其重写为更好的版本，保持语义等价。

　　动态重写：动态重写与静态重写非常相似，但它们是由基于成本的统计数据驱动的，考虑了数据集的大小…

　　让我们看看，低级操作符是如何被选择和优化的。我们将坚持使用加权除法矩阵乘法的例子——一个在 HOP 优化过程之前被选中的 HOP，而不是一系列普通的矩阵乘法。现在问题来了，例如，是否应该使用在 Apache Spark 工作节点上并行运行的 LOP 的并行版本，或者是否应该优先考虑本地执行。在这个例子中，Apache SystemML 确定所有中间结果都适合驱动节点的主内存，并选择本地操作符WDivMM，而不是并行操作符MapWDivMM。下图说明了这一过程：

　　

　　所有这些努力值得吗？让我们来看一些本地 R 脚本、MLlib 和 Apache SystemML 之间的性能比较：

　　

　　在不同大小的数据集（1.2GB、12GB 和 120GB）上运行 ALS 算法，使用 R、MLlib 和 ApacheSystemML。我们可以清楚地看到，即使在最小的数据集上，R 也不是一个可行的解决方案，因为它花费了超过 24 小时，我们不确定它是否能完成。在 12GB 的数据集上，我们注意到 ApacheSystemML 比 MLlib 运行得快得多，最后，在 120GB 的数据集上，MLlib 的 ALS 实现一天内没有完成，我们…

　　让我们来看一个非常简单的例子。让我们在 Apache SystemML DSL 中创建一个脚本——一种类似 R 的语法——以便乘以两个矩阵：

　　然后，我们生成一些测试数据：

　　为了使用 Apache SystemML，我们必须创建一个对象：

　　现在我们需要将数据转换成 Apache SystemML 能理解的格式：

　　现在，我们将数据和传递给 Apache SystemML 运行时，并预先注册一个名为的变量，以便从运行时获取结果：

　　最后，我们实际执行了存储在中的脚本，并使用方法从运行时获取结果：

　　现在包含了一个带有矩阵乘法结果的。完成！

　　你已了解到，在 Apache Spark 之上还有额外的机器学习框架和库的空间，并且，一个类似于我们在 Catalyst 中已使用的基于成本的优化器可以极大地加速处理。此外，将性能优化代码与算法代码分离，有助于在不考虑性能的情况下进一步改进算法方面。

　　另外，这些执行计划高度适应数据量的大小，并根据主内存大小和可能的加速器（如 GPU）等可用硬件配置进行调整。Apache SystemML 显著提升了机器学习应用的生命周期，尤其是在机器学习方面…

2025年3月2日
wps office免费版的下载的网站在哪

　　

　　1943年亚伯拉罕·马斯洛提出了著名的马斯洛需求层次理论，其基本内容是将人的需求分为五种，由高到低依次分为：自我实现需求、尊重需求、社交需求、安全需求和生理需求。

　　我们了解到社交是每个人的基本需求，且重要程度大于安全需求和生理需求。进入互联网时代之后，信息高效率传输优势拓展了交友的方式，QQ就是国内最早最大的陌生人社交产物，然后到了移动互联网时代，微信作为社交工具成了人们新的生活方式，在这过程中不断涌现挑战者想从社交红利中分一杯羹，皆以失败告终，微信的地位暂定为无法被撼动。

　　近几年，各家纷纷开始往社交细分领域布局寻找突破口，从以话题、兴趣为主题的社区社交类产品到直接“看脸翻牌”匹配的颜值类社交产品数不胜数。（据统计，在2019年国内市面上出现过的社交产品就达150多款）

　　那么，如果说社交是人类的基本需求，线上的陌生人社交产品就一定是必需品吗？陌生人社交产品有直接改变人们生活的方式，或者说有提高人们交友的效率吗？还是说，仅仅是依据互联网思维一厢情愿创造出来的需求？

　　图片由 @pattlexue 独家提供，未经授权不可使用

　　本文主要分析三款产品，概括为两个派别：

　　以为首，主张“灵魂社交”，其核心业务是用户可以通过UGC社区表达真实的自己，产品以降低人们的孤独感为价值主张，创新点则是将人格分析结合AI人工智能算法，是一种“心灵匹配”的方式为用户推荐感兴趣的人和事的社交产品。

　　以和积目为首，主张“颜值社交”，其核心业务是基于LBS地理位置服务的方式，向平台上的用户主动推送其他用户的资料（以卡牌形式展现用户照片和其他基本信息），用户可以选择向右滑动表示“喜欢”，或向左滑动表示“不喜欢”，当用户双方同时做出“喜欢”的选择时，双方“匹配成功”，可直接开启对话，是一种“看脸匹配”方式的社交产品。

　　下面将通过拆解这三款产品主要功能的业务逻辑、差异化以及商业模式等方面，希望能让你对目前市面上比较流行的三款陌生人社交App有更好地了解。

　　本段将基于注册后的正常流程，拆解三款App是以什么方式获取到用户最底层的画像：

　　第一步：收集基本的用户画像，用于匹配算法的底层逻辑依据，以提供更精准的匹配体验，内容包括：

　　注册时必填的信息

　　生日、性别、地区

　　初级人格测试题（6题）

　　（※图①为“灵魂测试”页，图②为初级人格测试题，图③为与其他用户匹配度结果，图④/⑤为匹配结果中合拍与不合拍情况分析）

　　注册完成后选填的信息

　　中级人格测试题（26题）、高级人格测试题（32题）以及其他趣味测试题（若干种）；

　　选择自己的“引力签”：引力签指用户可以给自己打标签，从而吸引到与自己标签相同的人，有助于提高匹配算法准确度；

　　引力签类型：包括职业、在做的事情，喜欢听的音乐类型，喜欢看或者正在看的剧，在玩的游戏，在读什么类型的书、喜爱的作者；

　　最新版对引力签进行了集中收纳管理，便于更精准定位引力签类型。引力签中的内容也有亮点，其中“在做”会有一些比较“新”的词，例如唱见、舞见，有一些比较“好玩”的词，例如银行数钱师，有一些比较“流行”的词，例如直男、直女、程序猿、产品狗，可以更好地接近用户，与用户产生共鸣。标签集中管理的好处十分明显，坏处也是，标签颗粒度有些过粗有些又过细，只能适用于部分用户，后期要通过不断完善标签库来满足更大范围的用户；

　　优化点：增加引力签搜索功能，或优化标签分类来满足快wps的官网最新下载网址是多少速查找和筛选。“在做”类型下的引力签就达50个之多，通过“换一批”来切换列表需要点击5次才能浏览完全部，且内容无序不是按照首字母规律排序。由于标签内容更新频率低，用户设置和更新的频次也不算高，所以考虑通过最简单的交互方式实现，但是也会影响到用户使用时的体验。

　　（※图①-图⑥分别为“在做”、“在热爱”、“在听”、“在看”、“在玩”和“在读”引力签类型的内容）

　　第二步：基于用户信息和系统分析生成的用户画像数据进行内容推荐，推荐内容的主要形式有两种维度：

　　内容的维度：用户可以在“广场”中拉取到由系统根据用户喜好推荐其他用户的动态信息（见下图①）

　　人的维度：用户可以主动触发“灵魂匹配”功能，系统会即时推送在线且匹配度高的用户，无需添加好友直接开启对话（见下图②,③,④,⑤）

　　注：

　　图①为“广场”：soul应用中承载UGC信息流位置的名称；

　　图②为“星球”：soul App的第一个tab，提供了多种触点路径；

　　图③为“灵魂匹配”界面，正在匹配用户中；

　　图④为用户聊天界面，通过“灵魂匹配”匹配到的用户会直接弹出聊天窗口，界面主要内容有与该用户的匹配度，对方的引力签，双方相同的引力签，共同之处，例如年龄或城市，还有提供破冰参考话题，例如“跟ta聊聊最喜欢吃的食物吧”，“有什么喜欢的运动吗，跟ta讲讲是因为什么喜欢上的吧”，但实际用处不明显，在陌生人第一次对话中稍显突兀；

　　图⑤为个人主页，主要显示用户注册天数及所发布的动态数量及引力签项和动态内容。

　　第三步：在后续的用户行为中也会进行挖掘、筛选、分类、分析和校准，以完善更全面的用户个人画像。

　　第一步：与soul相比，探探的做法相对原始，依赖用户主动输入，在注册完成后会引导用户完善个人资料便于优化匹配（大部分为选填信息，跳过也不影响用户使用主干功能）。

　　（ ※图①,②,③为探探个人资料编辑界面）

　　（ ※上图为探探个人资料信息结构图）

　　第二步：基于底层的用户画像信息数据进行个性化推荐。

　　（ ※图①为探探首页，显示用户卡牌概要信息；图②③④展开显示显示用户更多信息，其中会明确标出双方共同点；图⑤为用户个人主页）

　　第一步：与上述两款相比，积目的做法可以称得上简单粗暴，在注册时要求必选一个兴趣（且只能有一个），作为后续系统推荐时的依据。

　　（ ※上图为积目兴趣信息结构图）

　　第二步：发现筛选：选择筛选的距离范围，以及兴趣范围（全部兴趣或与你相同的兴趣）。

　　（ ※图①②为积目发现筛选页面；图③为首页，展示用户卡牌信息；图④为用户个人主页）

　　综合可得，以上三款应用如果按核心功能的业务逻辑复杂程度进行排序，为soul>探探>积目，而交友目的性的直接程度则与其核心功能业务逻辑复杂程度成反比，为积目>探探>soul，这其中的部分原因与产品本身定位的目标用户群相关：

　　soul

　　soul主要针对一二线城市的年轻用户，25岁及以下占比高达84%，四成用户为在校生，更喜欢进行线上交流和分享，且男女比例比较均衡（在交友应用中不多见），早期soul还瞄准了海外留学生用户的市场，能理解他们的痛点——需要一个能远在异国他乡排解孤独寂寞、且能与国内网友分享和交流的社区，在产品上线不到一年的时间内就支持海外用户的注册登录，并在YouTube和instagram上投放广告吸引海外用户，而国内则是通过豆瓣和知乎渠道引流，吸引年轻有活力的社区爱好者。

　　另外值得一提的是，soul用户对探探的安装比例（重合度）仅为25.5%，说明soul准确得找到了这一细分用户群——更愿意表达、分享和交流而不急于通过快速手段找对象。

　　探探

　　探探则是一开始模仿Tinder出道，用简单的交互方式提升用户浏览其他用户资料的效率为特色，早期取得极大的优势抢占了市场份额，在被陌陌收购前探探官方提供的数据中，（2018年6月）探探手机注册用户达9000万，其中90后用户占比75%以上，日活跃量600万，次日留存率高达75%，完成超过30亿次用户匹配，用户男女比例为6:4。到了2019年底，注册用户数量超3亿，18-25岁年轻用户占比最高，App Store社交和生活类别中，下载排行和收入排行均位于第一名。

　　探探用户年龄分布在25-34岁的占比接近42%，多为白领，高收入人群较多，更看重直接匹配的效率。WPS office的官网最新的下载网站的方法

　　积目

　　积目主打“潮”“酷”风格专属年轻人的社交平台，倡导以兴趣为基础拓宽社交圈子，其主要用户集中在一二线城市，95后占比近80%，是对音乐、艺术、潮流文化有追求的Z世代群体，可以通过产品内以下几个方面印证：

　　1）提供的兴趣项更为年轻个性、另类和小众化，例如LiveHouse、改装车、音乐制作、释放、怪癖、字母等；

　　2）App UI呈现黑白色系为主的风格和官网品牌传达出的年轻时尚的视觉理念一致。

　　（※上图为探探官网，应该好几年没更新了，整体风格和设计比较“复古”）

　　（※上图为积目官网，点击图片可新开页访问，官网以全视频的形式为背景，视频内容中的不同场景突出了产品核心价值“兴趣”、“交友”以及“约会”）

　　3）用户头像平均质量较优，趋近于“网图”，翻快一点的话会有一种“都长得差不多、相wps office免费版的下载网址的方法似”的感觉，这里的网图并非贬义，而是指紧跟潮流、擅长打扮和自拍的一类人。

　　如果同时体验探探和积目两款产品，这种差异会十分明显，甚至你会怀疑是不是真的有“托”，主要原因还是面向的用户群体属性不同，其次平台用户体量小也是一个因素，不过这也引发了另外一个值得关注的问题——关于用户头像的真实性问题，存在过多的“网图”该怎么办？

　　对于真实用户的重视程度，由高到低依次排序：探探>积目>soul

　　由于soul主打的心灵社交，用户头像采用类似早期腾讯QQ时的卡通头像模式，不支持自定义上传图片，表面上算是基本屏蔽了颜值因素，所以在产品逻辑上并没有强调实名认证的问题，只能通过用户自主判断。

　　而探探和积目主打的是颜值社交，头像或者说照片的真实性有助于推进匹配的效率。

　　探探采用的方案是“人脸识别技术比对”，认证的前提需要先上传一张主头像（最多能上传6张头像），主头像必须是清晰露脸照便于认证。

　　测试功能过程中发现即使是认证不成功，探探也会保留认证时的人脸面部数据，如果在后续添加新头像时，系统会自动发起比对，减少用户操作。（由于只比对主头像的照片，所以其余五个位置的头像不影响）

　　积目则是通过让用户手动填写真实姓名和身份证号码，然后再进行“面部特征生物识别”完成实名认证，其主要目的是完成“实名认证”，而非探探的“真实头像认证”即能证明该用户所上传的头像是其本人的照片。

　　对比之下，积目“实名认证”功能定位不清晰，更像是为加而加的功能，并不能起多大作用，如果说是为了约束用户行为，但也不是强制性的要求。

　　而探探“真实头像”的功能更符合产品定位，是为了提升用户曝光度和匹配效率。在认证通过后，用户身上会有明显的认证标识，可为其他用户做判断时提供有效佐证。

　　更准确的说法则是探探“真实头像”认证只能说明大概率或99%概率是本人，因为盗用网图在陌生人交友App很常见，常被应用于诈骗和引流等黑产行业。

　　探探百度贴吧中就有大量相关的广告贴，例如出售账号（主要是伪装成女性的账号，越多人“喜欢”价格越贵）、提供朋友圈素材（日常真实生活照、同一个人的语音包和视频，更具真实性），还有市面上泛滥的真实头像“代认证”服务，他们会通过对照片上的人脸进行关键点标注，再生成正面活体实人认证所需的眨眼、张嘴巴，摇头等动作信息，甚至可以针对更高要求的面容识别进行脸部3D建模，所以对于探探这类App而言，“真人”就显示格外重要，要通过不断优化认证准确度或增大认证难度以提高“代认证”门槛，持续打击相关恶意用户、排查异常账号，保持平台“健康度”。

　　对于社区建设的重视程度，由高到低依次排序：soul>积目>探探

　　社区对于soul而言，是最核心的功能业务，通过什么方式能营造出属于soul用户的树洞和精神园地，这是soul一直在追求和强调的，来看下他们是怎么做的：

　　1）找准目标用户群

　　在早期投放广告时，集中在知乎、豆瓣这两大相对文艺范儿、年轻的社区，所制作的广告文案因地制宜，符合对应社区的文化，也符合产品冠以始终的调性——“跟随灵魂找到你”，以情感化方式向用户传达，与之共情，吸引到的用户也是认可这个价值，期望能在此尽情分享喜怒哀乐，分享那些在朋友圈不敢发的内容，甚至是能找到自己的soulmate。

　　（※上图为soul投放至豆瓣的广告）

　　2）精细化运营

　　通过合理的运营手段促使用户生产出高质量的UGC内容和活跃用户氛围，提高社区用户活跃度和黏性：

　　通过运营后台监测和筛选短时间内传播热度高的优质帖子进行人工手动置顶；

　　如果是更大面积传播的内容，在人工筛查后，会对其所属用户发出“优质内容推荐”的邀请，用户通过官方授权邀请后即可获得更多流量的曝光和资源扶持；

　　周期性发布官方话题活动（大部分用户都深谙流量之道，通过蹭热度的方式能最快获得，快速响应官方话题的活动以及日常发布带热门tag标签的动态争取曝光量，背后都是长期教育后的成果）

　　（ ※图①为soul官方助手发布的活动页；图②,③,④为对应tag标签的话题详情页）

　　3）AI大数据匹配算法分发内容

　　有别于微博以推荐头部KOL为主，soul则是彻底贯彻了“个人内容分享社区”的定位，通过合理的数据分发模式让用户的内容分发更加平等和有效，就像品牌slogan“跟随灵魂找到你”说的那样，soul也是这么做的，用户在“广场”中可以很容易找到自己感兴趣的内容和人，这就是soul打造的“人格分析+AI”匹配算法的魅力之处。

　　4）推行官方孵化计划，鼓励用户持续创作优质内容

　　2019年11月25日启动了“SSR”孵化计划（Super Soul Real），旨在鼓励用户创造更多优质内容，对在某一类垂直领域有持续创作的用户进行扶持，打造用户分层中的头部KOL，扶持奖励包括流量、资源扶持、专人运营和数据分析支持以及现金奖励等。

　　其主要目的是为丰富社区内容形态，布局六大垂直领域的内容生产，以更大化、更全面满足不同兴趣分层的用户。

　　（ ※上图为“SSR”计划中六大垂直领域及包含的内容）

　　5）营造良好的社区环境，以符合并稳定产品整体调性

　　通过组建内容审核团队严格把控内容质量，将机审无法判定的内容（异常）进行24小时人工审核，保证内容合规性。

　　但同时也带来了一个问题，在机器识别度不是特别精准的情况下，用户的帖子没有能够及时发出，对于重UGC内容社区的产品而言导致的坏体验是致命的，用户发布的内容在短时间之内如果没有得到有效曝光获得点击量（阅读）和反馈（点赞和评论），错过了内容曝光点，很快会沉没在海底，极大打击用户创作的欲望和信心。

　　特别是在春节疫情高峰期间，实际体验下来，涉及图片、音视频类的帖子审核速度明显过慢（即使是发布普通的风光照），让人不禁怀疑系统到底有没有针对内容中的图像、视频和音频语音进行机器判别，亦或是高峰期发帖量大，机器处理速度慢，判断准确率低，内容积压在审核队列中导致人工审核不及时、周期长，且产品本身没有提供帖子发布状态，即使是审核不通过用户也不能及时获悉状态和原因。

　　不过对于内容如此严格把控的程度有迹可循：wps电脑版的下载地方是多少

　　2019年4月到6月期间，国家网信办启动了对即时通信工具内容的专项整治，因传wps office免费版的下载网站的方法播历史虚无主义、淫秽色情内容被分别采取了约谈、下架、关停等不同程度的惩罚，涉及陌生人社交玩法的许多平台也遭到了不同程度的打击。

　　soul也不例外，在下架后的两个月时间内部开始排查所有可能的风险，并制定了严格的内容审核和监控方案，在增大了对内容的把控力度同时，也影响了部分用户体验。

　　在去年八九月份重新上架后，进行大范围推广拉新，由于注册用户量激增，内容平均质量下降，随之而来导致一些老用户流失，普遍觉得“不像以前的soul了”，这无疑是给社区的内容运营提出了更大的要求：

　　1）减少明显网图倾向、无意义内容（主要表现为虚荣心作祟，博关注之类的内容）、“莫名其妙”的热门内容；（例如腿照，女生在soul发布此类内容是很受男生喜欢的，点赞量会莫名的多，其他用户会效仿，从而导致恶性循环，认真创作内容的用户会失望）

　　（特别说明：以下案例中用户所发布的图片为该用户发布时所呈现的原始效果，本人并无做二次打码处理。但为了保护相关人员，在头像、名称及部分文案上做了特殊处理，以保证在该平台上无法通过搜索方式找到，避免对其造成骚扰或伤害。

　　*以下图片仅作为产品案例分析使用，如果给您带来不便，请联系我删除，感谢您的理解。）

　　图①：

　　属于“莫名其妙”的热门内容中的一种，分析发布的图片和文案都很难明白其中点赞的数量为何能达到300+，照片原图无露脸，与该用户沟通后确认也并非是墙上所展出的画引发了观众共鸣，最后猜测可能是该用户的关注人数多导致。

　　图②：

　　属于“无意义内容”范畴，热门主要原因分析：JK元素及露腿。

　　在体验App的前期，能经常看到“露腿”、“展示身材”相关的热门内容，其主要特点是用户不需要露出面部信息就可以吸引到很多点击量（可排除是用户偏好的原因，体验过程中并无对相关类型的标签话题、动态进行关注或点赞评论的行为数据）

　　图③以及下图②③④：

　　也属于“无意义内容”范畴，通过明显带有引诱性质的图片或文案在短时间之间就能获取大量的关注和点击，即使是下图④中的自拍图片被原用户“马”的面目全非。（2分钟之内就能达到23个赞）

　　上图①：

　　则是一种典型代表，一句简单“撩”人的话和一张能表明自己是女性用户的图片，就能吸引接近900个用户点赞，伴随而来的基本是“私信”轰炸，聊天icon上徽标99+的情况是大多数soul的女性用户或多或少都能遇到的，无论是有意或无意为之。

　　为什么强调只要是能表明自己是女性用户的图片就能吸引到关注呢？

　　有一位男性用户分享过一次经历，在发布了一张小概率会被误认为是女生的照片后，他收到了一些男性用户的私聊消息，截图如下，关于这个问题我们留到最后来分析。

　　（※前提：该男性用户动态中有明确能证明性别的照片；而以上聊天记录中可以很明显了解到，部分男性主动并不能证明是对你了解后产生了兴趣，而仅仅是因为你是稀缺的“女性”）

　　2）加强推荐算法准确和精细度，需要对用户进行更多更细维度的分层，目的是减少不同层级之间用户的交流，互存但不互斥，这也是为什么有些用户觉得“soul好像变了”的主要原因；

　　3）加强“不感兴趣”功能的体验，分析用户不感兴趣的主要原因，对用户不感兴趣的原因进行本质溯源，主要是图片的内容、文字、风格、标签、话题还是作者本身的原因，如果仅仅根据系统给内容打的标签为准，很容易存在和用户主观感受大不一致的情况发生，可通过减少和控制相关标签的样本量，再对用户后续的行为进行偏好判断以及校准；

　　引导用户对机器进行训练，使其更懂用户，加强推荐或“不感兴趣”功能的普及，普及则要求该功能在交互上具有易用、清晰明了和准确等性质。

　　由于探探近期社区模块有大更新，下面会简单列出前后版本进行对比分析：

　　改版前：

　　探探在改版前除了匹配及聊天功能，还有个“朋友圈”功能，功能范围如名，与微信朋友圈大致相同，支持评论和点赞匹配成功的好友动态。

　　比较小的区别就是特意强调了动态“私密评论”功能，这一做法是为了降低用户的戒备心，意指“只有对方可见”，评论后顺带会将评论内容及概要或图片转发到对方聊天窗口，这点与微信不同，探探则更希望最终的流程还是回到即时聊天这个闭环上，提高双方交流意愿。

　　（※图①②为改版前的探探“朋友圈”；图③为聊天窗口界面）

　　改版后：

　　改版后的更新点如下：

　　新增“附近”模块：可以查看附近的人推荐的动态（也可以理解为“附近的朋友圈”）

　　新增“个人主页”模块：可以通过用户的个人主页了解该用户发布过的动态，粉丝、关注和获赞数量等信息

　　新增“ 关注”模块：除了可以查看匹配成功的好友动态之外，单向关注其他用户也可以跟踪其动态消息，如果双方互关也可以达成匹配关系进行对话

　　（※图①为改版后探探的“关注”页；图②为用户个人主页；图③为“附近”页）

　　改版后增强了社区属性，新增的“附近”模块和“关注”功能也增加了用户间触点的路径和细分场景，能促进用户生产内容的欲望，增大个人动态曝光量和延长了用户使用时间。不过前期内容质量参次不齐，通过观察可以得出推荐机制比较随机，匹配算法有待加强和优化，向用户偏好的匹配度方向进行推荐。另外更新后有一个比较奇葩的问题，原本版本中强调的“私密评论”变成了公开评论内容，且不支持删除，迭代功能前后逻辑互相违背。

　　积目社区主要分为四个小模块，分别有：

　　关注：展示已“关注”用户的动态内容（包含自己）

　　推荐：展示“系统推荐”的用户动态内容

　　好友：展示“双向匹配成功”好友的动态内容

　　地区：可任意切换地区，展示不同地区推荐的用户动态内容

　　积目社区推荐的内容尺度包容性明显更大、更“开放”，会有许多擦边球倾向的内容上热门推荐（比如露骨的文案、过于暴露的图片和带有暗示可能的拍照姿势），可能会吸引大胆前卫、思想开放、敢秀的年轻用户群体，但也更容易面临监管可能，且不是一个可持续、良性循环的内容社区。

　　在分析积目是怎么形成如今产品调性之前，我们先了解下积目创始人蔡狄的创业历程：

　　2015年5月，于深圳发起第一个创业项目涩色，该项目主要解决夜店陌生人社交的闭塞问题，通过在夜店桌与桌之间植入LBS强定位设备的方式，让用户通过扫描二维码获取附近座位陌生人的社交信息，提升桌与桌之间破冰匹配效率，建立有效的互动关系，后来项目因资金链的问题没有继续；

　　在第一个项目失败后，蔡狄参加和调研了大量的线下音乐节、LiveHouse等青年文化活动，通过与用户深度接触之后，将第二次创业项目的核心目标人群指向最年轻最潮流的这一群体；

　　2016年8月，积目iOS正式版上线，设定的目标是想打造一个青年文化领域的社交App，建立O2O社交服务体系，早期是让用户基于共同的兴趣从线上匹配，匹配成功后由系统推荐相关活动，再到线下完成共同目的为闭环，以加固社交关系来沉淀用户。线下环节则是通过与品牌合作、主办潮流派对或青年活动，例如与国内知名音乐厂牌方（如草莓音乐节）建立合作关系，进而拓展其他活动主办方。最多的时候一年要做2000到3000场活动，从线下抓取了很多精准用户。

　　所以不难理解积目为何会形成与其他产品完全不同的气质，从将各类小众兴趣列为兴趣项就可见一斑。早期通过非常垂直媒体宣传、举办潮流文化和街头活动吸引相同价值观的用户，将产业资源和兴趣圈层打通，再到用户之间自传播沉淀为中、头部优质的种子用户。

　　（※图①为社区“推荐”页；图②③为社区“地区”页；图③为动态详情页；图④为个人主页）

　　但是探探和积目的社区都会有个明显的问题，社区互动性差，（特别是积目）社区中推荐靠前的内容多以获得他人的认同感以及满足个人虚荣心、展示欲、博关注为重点的内容，单向评论居多缺少互动性，另外推荐内容基本与用户兴趣不相关，推荐机制更多存在随机成分。

　　从去年10月份被映客收购至今，并未明显看到相关匹配或推荐功能、策略和算法有比较大的提升。

　　社区如果仅仅只是用于多一个用户曝光的途径，而缺少关键的互动，就不足以建立有效的闭环，形成一个在平台上独立的功能产品。陌生人之间破冰如果单靠个人的“找话题/尬聊”能力很难维持长久的关系，从而产生很多“一次性”浪费，好的社区应该更像是一个能承载用户的兴趣、生活动态以及个人名片（多维度展示）的场所，为用户之间破冰提供更有指导性方向的话题。（比如我通过soul的“灵魂匹配”匹配到一个用户，点进去她的主页后发现她最近看了调音师这部电影，刚好我也看过这部电影，我们之间就有了共同话题，可以就此展开交流）

　　陌生人社交难逃低俗怪圈，流量和商业利益诱惑下，容易打擦边球，特别是在2019年，因为社区管理的敏感问题被下架或约谈的App有很多。

　　近期行业内也揭露了一起恶性事件，soul运营合伙人李某为打击竞品uki，故意设局制造违规内容，以此举报来打压同行，导致uki被下架近四个多月，产品注册用户量出现断崖下降，造成公司运营停顿。

　　由此可见，陌生人社交行业竞争激烈，都在为了抢占市场，想尽办法争夺市场份额。据相关报道，soul前员工爆料其实恶意举报对手的想法，在2018年就有了，而此次恶性事件发生的时间则是2019年6月soul被下架之后，担心竞争对手趁机赶上，抢去流量，才真正实施的。也突显了陌生人社交赛道上各家的焦虑，只有“活命”才是首要的目标，有时候牺牲一些商业价值，产品坚持合规化才能持续为用户创造价值，为公司创造利益。

　　三款产品在现阶段主要通过会员订阅制和售卖虚拟币等增值服务的方案进行变现。

　　探探在今年3月份传出正在内测直播功能，于近期（4月15日）大面积开放测试，距离全量上线不会太远。另外积目四月初也传出涉及直播相关的消息，这不仅仅是探探和积目的竞争，背后还是陌陌和映客之间的较量。

　　下面将对三款产品中付费功能及价格进行简单对比：

　　【超级星人】主要特权可查看谁访问过你的主页、聊天等级加速、发布5分钟的音视频动态等。

　　（※soul-超级星人价格表）

　　【WPS office的电脑版的下载网站怎么找】可用于购买一些功能的特权和虚拟商品，有对标QQ的“礼物”，可用于赠送好友，有对标QQ秀的“超萌捏脸”，未来要拓展应该也会往QQ的“厘米秀”方向走。

　　目前暂未明显看到soul出现其他类型的变现模式，正在探索的只有在当前模式上的一些延伸尝试，例如主打的“灵魂匹配”功能在进行收费的可行性测试，通过逐渐减少每日匹配次数上限、提高匹配精确度和匹配效率，再慢慢过渡到付费，这种方式比较适合一个长期主打免费的功能过渡至付费的过程，最终的替换速度还是要根据用户的反应数据决定，与免费阶段时的体验形成明显差别用户才会买单。

　　（※免费向付费过渡的流程）

　　【VIP】主要用于滑错反悔、任意更改定位、无限“喜欢”次数（普通用户每日120次）

　　（※探探-VIP会员价格表）

　　【查看谁喜欢我】开通后可以查看哪些用户“喜欢”了你

　　（※探探-“查看谁喜欢我”特权功能价格表）

　　【闪聊配对】每日3个蒙脸在线配对实时聊天的机会，对话达20个回合可解锁对方头像，或者通过购买“偷看特权”直接解锁。

　　在线实时配对聊天弥补了“卡牌配对”低时效、高延迟的问题，闪聊的也只能是已开通了该功能的用户，虽然用户范围被缩窄，但双方“配对”的意愿程度是高度接近的。

　　闪聊开始后的前20个回合还设置了蒙脸机制（指用户看不到对方真实头像），意指先“灵魂社交”，通过聊三观、聊兴趣完成匹配的首轮考验，可惜现实很骨感，很容易通过互相刷屏解锁，最终都是奔着“和你聊天的人到底长什么样”去的，闪聊的功能虽然在滑牌中显得更具有价值，但是硬要套一层“面具”，在产品内的功能矩阵中显得格格不入，有点像开倒车。

　　我不禁在想，是先有蒙脸的收费点，还是先有蒙脸的需求点。

　　（※探探-“闪聊配对”功能价格表）

　　【超级曝光】该功能可以在30分钟内增加曝光度（10倍的人优先看到）【闪聊偷看】可在闪聊配对时直接解锁对方头像

　　【探探币】探探的虚拟币，可用于购买超级曝光和闪聊偷看

　　【VIP】主要用于滑错反悔、任意更改定位、无限“喜欢”次数、优先推荐（增加曝光量）、高级筛选（筛选项包括用户照片数量、标签和星座）。

　　（※积目-VIP价格表）

　　【查看谁喜欢我】开通后可以查看哪些用户“喜欢”了你。

　　（※积目-“查看谁喜欢我”特权功能价格表）

　　积目从去年底被映客收购后，十二月份开始进行变现方案尝试，先开通的是VIP增值服务，“查看谁喜欢我”服务依然是免费，到了今年一月开始逐渐加大测试范围，“查看谁喜欢我”需要付费才能查看，从贴吧的反馈来看，对没有付费习惯，一开始就享受“白嫖”的部分普通用户来说会是比较大的打击，对他们来说无疑是失去了原本的重要优势，用户价值骤减，而且付费功能价格相对较高。

　　soul倾向于打包功能付费模式，会员在购买其他虚拟道具时有额外折扣，而探探和积目采用多点付费模式，便于后续拓展新的变现功能。

　　三款均有“查看谁喜欢我”的功能，对于soul的用户而言，访问主页1次2次不值一提，而反复查看多次，甚至每天“关心”到一定程度，就足以刺激用户付费揭谜底，当然，更多是取决于用户的好奇心与是否在意。

　　（※上图为soul-“谁看过我”列表页面）

　　而对于探探和积目用户而言，“查看谁喜欢我”是一个“外挂”般的功能，相当于掌握了“主动权”（可以从喜欢你的列表里面挑选你喜欢的完成匹配），自然价格也比偏贵，探探的“查看谁喜欢我”为60元/月，积目则为58元/月。

　　2019年6月数据：

　　【探探】

　　41.7%的用户年龄在25-34岁之间，41.2%的用户为企业白领，40%的用户收入在5-10k之间，9.2%的用户收入在10-20k之间。

　　【积目】

　　65.8%的用户年龄在18-24岁之间，43.9%为在读学生，43.3%的用户收入小于3k，10.5%的用户收入在3-5k之间。

　　积目对标价格的参考目标没考虑仔细，自己的用户属性也没了解清楚，探探五成以上的用户多为白领、上班族和高收入人群，有足够的付费能力。

　　而积目主要用户群体为在校学生或刚刚踏入社会工作不久的职场新人，对他们而言，包季的腾讯视频会员再加上一个麦当劳巨无霸可能会“更香”。

　　近两年来直播行业进入成熟期并呈现下滑的趋势，走势低迷有疲惫期的态势，为了刺激商业生态，陌陌和映客开始布局陌生人匹配效率相对较高的兴趣交友领域，并也有将直播带入陌生人交友领域的意向。

　　2018年2月，陌陌以7.6亿美元的价格全资对探探完成收购。 2019年7月，映客以8500万美元的价格对积目完成收购。

　　如果单看直播业务，探探有陌陌背书会更具优势，另有消息称探探如今的直播团队就是陌陌原本的直播团队，陌陌这些年走得非常稳，始终位于直播行业最头部，先来看一组数据：

　　2019年Q4陌陌的运营利润为14.585亿元，2018年同期为10.926亿元。 2019年Q4探探的运营亏损为2.027亿元，2018年同期运营亏损2.199亿元。

　　被收购后的探探并未给陌陌带来很可观的收益，而且在2019年4月份探探卷入“涉黄”风波，产品被全平台下架整改，两个月后才得以重新上线，至今仍未恢复至下架前的规模。

　　2018年，陌陌的月活用户从Q1的1.03亿到Q4的1.13亿，仅增长了10%左右。

　　2019年，陌陌在前三个季度的月活用户数分别为1.144亿、1.135亿、1.14亿，12月为1.145亿，较2018年同期的1.133亿仅增长200万，二季度甚至还略有下滑。

　　此时的陌陌商业模式见顶，用户增长停滞，急需寻找下一个大规模变现场景，希望可能就寄托在2018年以7.6亿美元收购的探探身上。

　　有迹象表明，探探的用户是具有可观的付费用户规模的，根据官方发布的2019年财报显示，2019年Q4探探付费用户有450万，且探探与陌陌用户的重合度低（当然也是能被收购的其中一个原因），这时候上线直播业务，目标则是完成对探探直播存量用户的挖掘，从而拉动陌陌的营收增长，而探探在产品和业务层面也需要新的元素刺激，加快商业化进程。

　　通过引入直播和“附近的人”丰富探探产品的形态及商业模式，在未来直播运营的策略上，探探应该会更偏向尾部的直播用户倾斜，主打附近的主播页面，强调陌生人直播交友的属性，这样会更符合用户对原本产品的诉求和期待。

　　（※图①为直播-推荐页；图②为直播-附近页；图③为发现-附近页，发布-动态/直播功能；图④为发现-附近页-最近直播推荐）

　　直播和“滑牌交友”这两个旧元素是否会碰撞出新火花，探探的新模式是否能引领下一个风向呢，还未知，可以预期的是：

　　近期迭代的功能会延长探探用户平均的使用时间和增加活跃量

　　扩大用户付费渠道（直播打赏）

　　激活直播的存量用户（观众/主播）

　　带动中部优质用户成为主播

　　在今年3月27日晚，我在soul上面发起了针对“是否会打开soul应用通知”的投票，115人参与投票，结果显示关闭应用通知的占比达76.5%，接近八成的用户会选择屏蔽应用通知。

　　这还仅是抽样统计soul用户的选择，要知道soul对于应用通知提供给用户的权限是比较开放的，消息接收模式如下：

　　通知显示消息详情

　　接收所有消息提醒（运营类通知包括定期的官方话题和热门推荐话题等）

　　只接收广场及聊天消息提醒（相当于选择关闭App运营类通知）

　　只接收聊天消息提醒

　　*且在不打开App时，将不再接收未打开的类型的消息

　　（※上图为soul-通知设置界面）

　　探探

　　显示消息预览

　　朋友圈得到“赞”用私信通知

　　积目

　　消息详情

　　新增关注通知

　　评论通知

　　谁喜欢我通知

　　（※上图为探探和积目推送的“运营激活类”通知）

　　小结

　　应用PUSH通知作为App中很重要且最常见的激活和挽留用户的运营策略，用得好那将是纯收益零成本的买卖，用不好反会提醒用户卸载App。

　　soul在这方面相对比较克制，选择把主动权交给用户，提供了定制化的通知消息组合，由用户根据自己的实际需要设定，既保证良好的用户体验，也与其他App形成了明显的体验差，从而提升好感和忠诚度。
WPS office的官网的下载方法是什么wps免费版下载的地址在哪里
　　而探探则根据用户使用频率进行分层，然后采取不同频率的推送方案：当天打开频率较多，则不会推送任何运营类通知；一到两天及以上不打开App，则会在早8点至晚10点之间每隔两个小时推送一条激活唤醒通知（一天最多会有8条），通知的主要类型为推荐附近的用户，打开后所推荐的用户会排在卡牌列表的首位。

　　积目采用的推送策略时间会比较随机，内容主要属于诱导点击类，点击文案打开后也不会有对应的落地页。

　　各家都采取了不同的通知运营策略，是基于对平台下用户的理解，soul更像是一个朋友，走情感化路线，探探则是置之死地而后生，自杀式的策略，最坏也不过是卸载，最好的情况是唤醒成功，再不济也只是关闭应用通知继续保持沉默，有需要时你肯定会打开。

　　在陌生人社交App中你很经常能遇见这种情况，很多人上来聊不到两句就会开口要微信，我们可以简单分析下这种做法其中可能的原因：

　　排除诈骗和引流等其他特殊情况，索要者并非平台忠实用户，只是将平台作为拓展好友的渠道或工具，这类人更重视社交效率，其目的是完成自己“搭讪”的闭环，即索要微信成功作为结果，是一种惯性动作，这种做法在多数情况会被拒绝，在少数情况即使交换微信后，也只是沦为微信通讯录中的沉寂“好友”。

　　除此之外，就是好友关系已经进展到双方愿意达成现实或接近现实关系的共识，才会互加微信，微信在部分用户心智中是作为熟人社交工具，存在一定的门槛，而这种情况普遍是陌生人社交最担心又不得不接受的事实。

　　平台能做的只有是努力增加自己被替换的成本，提升产品本身的用户体验、提高用户价值及有别于微信的差异化体验，下面对比下三款App针对此类情况作出的反应和策略：

　　soul主要通过独特的社区氛围和好友共同的聊天等级等组合手段吸引用户留存。

　　聊天等级：随着在双方聊天回合数增加，聊天界面右上角的爱心会一点点累积。每满3颗爱心可以点亮1个字母，以此类推，点亮soulmate则达到满级，越往后的字母所需的聊天回合数就会越多。（同性之间会显示蓝色，异性之间会显示粉色）

　　soulmate空间：在点亮soulmate之后，可以选择建立soulmate关系，同时可以拥有二人专属的soulmate空间，发布属于双方的动态。

　　（※图①,②为soul聊天界面；图③为个人主页，提供soulmate空间入口；图④为soulmate空间；图⑤为“广场”推荐的soulmate空间动态）

　　探探和积目则不同，大部分用户的目的是想通过该App找到对象或拓宽交际圈认识多一些人，如果双方关系寻求进一步发展，在探探或积目App内进行交流肯定不是最佳选择，而是会选择微信更像是能承载熟人关系的App，而如果双方发展为恋人关系，大概率都会成为流失用户。

　　此外，探探和积目能留住用户的最主要原因是提供了接近无限多的关系撮合可能，用户会抱有与之匹配的关系出现，而如何保持用户的热情，减少挫败感，是特别需要考虑的问题。

　　在这个问题上探探和积目天生自带高门槛，只有双方完成匹配才可进行对话，而soul的情况在上面也介绍了，女性用户在私信基本无门槛的App中极其容易受到骚扰，soul采取的做法是提供“防过度打扰”机制，用户当天的私聊人数达到上限时（预估为99人），其他新的私聊用户则需要通过送礼才能开启聊天通道。

　　不仅“贴心”为用户提高了防骚扰门槛，还自然地促成虚拟商品的交易，送的礼物用户会收到通知，以及在个人主页的“礼物墙”上可以公开展示。

　　但“被骚扰”本人对这一“贴心”的机制基本无感知（除非他人告知或自己了解得知），这多少存在一些不透明，如果是在“防过度打扰”机制被触发时，当事人端有提醒标识，甚至可以自主选择关闭“防过度打扰”，在用户体验和商业价值上会更平衡。

　　当然，这完全取决于决策倾向，在某一情境下，某些机制默默运行以不打扰用户为出发点，也是一种好的用户体验。

　　（※上图为soul-聊天界面-“防过度打扰”弹窗）

　　在防骚扰的问题上，“堵”只能是暂时性的方案，且只是该问题组合方案中其中的一个子方案而已，如果从长期可持续的角度看，建立起用户信用体系，严格精准实行奖惩措施，能极大约束用户行为，更好对用户进行分层管理，也响应了之前soul在推广文案中提到的：

　　你的灵魂不能太无趣，否则我们建议你不要来。如果你三观不正，我们不欢迎你来。如果你的目的不单纯，我们禁止你来。

　　虽然举报功能是App最基本、常规的功能，但在探探这边，执行力度的层面会更具说服力，一旦发现并证实用户存在骚扰字眼等行为，都会面临直接封号的结果。

　　这也从侧面印证了，女性用户在陌生人社交App中是处于被保护和追捧的角色，是处于社区食物链顶端，一个好看的女生一天可以收获近万个喜欢，普通一点的几百上千都有可能。前几天从一个用户那里了解到，注册了两年，但玩的特别少，就已经有26万人点赞，男性用户主动积极，女性用户相对被动，一个长相平庸的男性用户数月可能也收获不到几个喜欢。

　　探探创始人王宇曾经分享过一个数据：

　　在探探中男性用户会喜欢60%的女性用户，而女性用户只会喜欢6%的男性用户，还有女性用户匹配成功率超高，有60%的成功率，我们的数据中，最不受欢迎的女生也要比最受欢迎的男生受欢迎。

　　当然不排除有部分男性用户是没有筛选条件的，而女性用户更多会先仔细查看资料中的照片和其他信息，例如职业、爱好、对某些事情看法（价值观），思考后才会下决定。而大量“不走心”的“喜欢”也会使女性用户逐渐减少对可能会出现匹配关系的期待值，从而导致女性用户只能贡献出极少量的“喜欢”。

　　即使在今年二月份国内疫情高峰这种最特殊的情况下，探探人均使用时长增幅超30%，App内每天配对数、聊天消息条数均上涨20%，女性用户右滑“喜欢”男性的比例也仅仅从6%上涨到9.8%而已。（破了探探创立6年以来最高纪录）

　　（※图①为积目用户表示“没怎么管这个软件，突然就破万了”；图②为探探注册两年但非活跃女性用户，收获了26W+“喜欢”；图③为探探女性普通用户，一天收获近500“喜欢”）

　　所以在关于男女性社交主动性差异的问题上，即使是举全社会之力在短时间内都很难扭转平衡，我想，这也就是为何陌生人社交需求会一直存在的原因吧。

　　感谢阅读，希望对你有所帮助或启发。意犹未尽，希望在下一篇能针对某一个App展开讲，如果有什么想法、建议、意见欢迎留言或联系，再见。

　　

　　作者：半岁PM

　　来源：半岁PM

　　扫一扫微信咨询

　　

　　

　　商务合作联系我们

2025年3月2日
wps电脑版的下载的网站在哪

　wps官网最新的下载的地址是什么　SOL币是Solana区块链平台的原生加密货币，是该平台的数字资产之一。Solana是一个具有高性能和低成本的区块链平台，旨在为去中心化应用程序（DApps）和加密货币交易提供更快速和更经济的解决方案。尽管SOL币在区块链领域备受关注，但投资者仍应认识到其中存在的风险。

　　首先，SOL币的价格波动性较大。像其他加密货币一样，SOL币价格受市场供求关系和wps office的免费版下载的方法在哪里整体市场情绪影响WPS office官网最新下载的网站是什么。由于加密货币市场的波动性较大，SOL币价格可能会出现剧烈波动，导致投资者面临较大的风险。wps 的官网下载网站在哪(wps office免费版破解版电脑版)

　　其次，Solana平台可能面临技术风险。尽管Solana拥有高性能和低成本的优势，但任何区块链平台都可能面临技术问题，并可能导致网络中断或其他问题。这种技术风险可能会对SOL币的价格产生负面影响。

　　另外，政策风险也是投资SOL币的一个考虑因素。加密货币市场受监管政策和法律法规的影响，政府可能出台新的政策来限制或监管加密货币交易。如果相关政策对SOL币的使用或交易产生负面影响，可能会影响其价格表现。

　　最后，市场风险也是投资SOL币需要注意的问题。加密货币市场是一个高度波动的市场wps的官网最新的下载的网址是什么，投资者应该做好市场波动带来的风险准备。在投资SOL币之前，投资者应该对市场进行充分的研究和分析，做好风险管理和资产分散。WPS office官网最新的下载地址在哪里
wps office免费版下载地址是什么
　　总的来说，投资SOL币具有一定的风险，投资者应该根据自己的风险承受能力和投资目标来评估是否适合投资SOL币。在投资加密货币之前，投资者应该做好充分的准备wps的官网最新的下载的方法是什么工作，了解相关风险，并采取适当的风险管理措施wps 的官网最新的下载的地址是什么。愿投资者能够在投资SOL币中取得成功。

2025年3月2日
wps电脑版下载地址的方法

　　Solana由前高通，英特尔和Dropbox工程师于2017年底创立，是一种WPS office官网的下载地方是什么单链委托权益证明协议，其重点是在不降低分散性或安全性的前提下提供可扩展性。Solana扩展解决方案的核心是名为“历史证明（PoH）”的分散式时钟，旨在解决分布式网络中没有单个可信赖时间源的时间问题。通过使用可验证的延迟功能，PoH允许每个节点使用SHA256计算在wps的官网最新的下载的地址的方法本地生成时间戳。这样就无需在整个网络上广播时间戳，从而提高了整体网络效率。SOL是Solana区块链的本地令牌。Solana使用委托权益证明共识算法来激励令牌持有者验证交易。作为Solana安全设计的一部分，所有费用都将在SOL中支付并被烧掉，从而减少总供应量。这种通货紧缩的SOL机制激励了更多的代币持有者参股，从而提高了网络安全性。

　　项目特征为了创建一个带有编码、无信任时间的分布式wps office 的官方的下载的入口怎么找账本，SOLANA设计了历史证明（ProofofHistory），这是验证订单和特定事件之间时间流逝的证据。历史证明将与工作证明（比特币等使用的共识性算法）或者权益证明（以太坊的Casper所使用的共识性算法）一起工作。这可以减少导致终止时间达到亚秒的消息传递开销。除此之外，Solana正在致力于在1GB网络基础上每秒产生高达710K的事务，而无需数据分区。你想知道他们计划如何实现这个伟大的胜利吗？在开发高吞吐量(Tps)和高度安全的区块链的竞赛中，团队正在设计新的方法来创建高度可扩展性的解决方案，从而允许现有区块链中每秒钟可进行高事务数量。“时间问题?”。在计算和信息时代，有一个基本的需求正在等待解决。事件之间的公平协调。这意味着：例如，当计算机向另一台计算机发送消息时，他们需要同步事务之间的时间。因此，这意味着，如果他们每个人都有自己的内在时钟，他们可能会或不可能正确协调。用时间戳来协调事件不仅是系统的需要，而且在金钱、人员和努力方面都是巨大的成本。开发人员已经开始使用一种技术来提高链的总体吞吐量。分片是一种技术，用于改善总链的TPS（系统吞吐量），并被证明是成功的，但它本身并不是一个完整的解决方案，因为这可能会引入漏洞。最大的漏洞是交易的分割，如果处理不好，就会打开链，导致欺诈交易、双重支出或同一交易的碎片缺乏共享知识。

　　为了提供一些普遍的看法，GoogleSpanner（谷歌的可扩展、多版本、全球分布式和同步复制的数据库支持读写事务、只读事务和快照读取）花费了大量资源来同步其数据数据中心之间的原子钟。他们需要得到精确的维护，并且有大量工程师正在为此工作。看起来协调时间是一件容易的事wps的官网最新下载地方是什么情，但事实并非如此，这就是Solana提出的历史证明解决方案。通过实现可信的时间协调，Solana不仅能够在速度和可靠性方面提高区块链吞吐量，还能降低平均成本。成功解决这个问题的团队可能会有一个高度采用的区块链。

　　技术概况深入研究Solana提出的解决方案会发现一些问题，例如，如何在区块链上实现历史证明，以及Solana到底是如何工作的，它们使用的是什么工具？首先，我们需要了解网络是如何设计的，以及它所包含的内容。历史证明是一种高频率可验证延迟函数。这意味着它将需要确定数量的相关步骤进行评估。但另一方面，这些步骤最终会产生一个唯一的输出，便于验证。在解决方案部分中，我们讨论了Solana如何增加TXN/s的数量，以及如何减少用于运行它们的所需资源。对这种可能性的解释与哈希函数的解释是一致的。哈希函数作为压缩数据的一种方式，这样更大数量的数据最终可以被压缩成小量位，这就鼓励了减少tx权重，从而提高了效率和更快速的序列。如上所述，历史证明序列被设计为与加密哈希函数一起工作。与加密哈希函数特别相关的是，使用原始输入，不用从头执行整个函数就可以预测最终的结果（输出）。因此，如果有输入并试图预测输出是不可能的，那么您将需要运行该函数来获得结果。考虑到这一点，假设这个哈希函数从某个随机起点（初始输入）运行，一旦这个过程完成，就获得第一个输出（哈希）wps免费版的下载地方怎么找。以下是它变得有趣的地方，将输入与从运行函数中获得的输出一起输入到下一个哈希的输入中。如果我们要重复这个过程，例如300次。您可以开始看到，我们已经创建了一个单线程进程，其中最后的输出(哈希300)除了执行整个线程的人之外是完全不可猜测的。这个向下一个函数的输入和生成的数据提供输出的循环，表示为时间的流逝和历史的创建，用Solana的话来说就是滴答声。每一个输出都携带详细信息，如果不运行该函数，则无法预测。就像上述例子中的漫威的电影一样，每一部作品都代表了一段时间，恰好在连续时间的线程中位于它的位置。因此，Solana建议不要使用不可靠的时间，而是使用这些顺序有序和不可预测的输出来确定特定时刻，即线程进程中的特定时刻wps电脑版的下载网站。我们可以称之为历史。

　　项目权益证明Solana使用权益证明（POS）来达成共识，并且它具有许多其他基于POS代币的相同特征。作为一个复习这里是是POS代币的一些主要特征：POS代币的证明使用验证器POS可通过证明1.把代币锁在钱包里2.将代币锁在主节点上，有助于链的稳定性支付顺序由POS代币或主节点奖励计划的“年龄”决定。每个POS钱包或主节点奖励计划都会收到铸币或新伪造的代币。离线时间太长的钱包或主节点奖励计划不再“支付”，可能会从网络中删除。POS的作用是防止不良行为的参与者通过破坏网络的安全性而引入无效的事务。对“坏角色”的惩罚可能是损失了POS代币和奖励。只要证明利益的回报大于通过欺诈获得收益的机会，信任就能得到保证。Solana有非常相似的结构，但他们以一种稍微不同的方式实现了他们的POS。Solana从那些已被连接的节点中选择了一个验证器(即，把一个代币投进去)。然后，验证器的投票和选择将由一直处于最长或最多绑定节点的节点来确定。Solana依赖于快速确认；如果一个节点在指定的时间内没有响应，它被标记为失效并从投票中移除，如果该节点当时是验证器，则举行新的选举以选择新的验证器。如果一个超级多数节点(三分之二节点)在该超时内投票，则该分支被认为是有效的。裁剪是使权益无效的行为，它防止验证器进行欺诈或试图验证多个节点，因为保税代币将丢失。一个主要的区别是次级选举节点的概念。一旦被选中，辅WPS office的官网最新的下载入口是什么助节点就可以在网络中断或其他故障的情况下接管主要角色。

2025年3月2日
wps office免费版下载的地址

　　Solana由前高通，英特尔和Dropbox工程师于2017年底创立，是一种单链委托权益证明协议，其重点是在不降低分散性或安全性的前提下提供可扩展性。Solana扩展解决方案的核心是名为“历史证明（PoH）”的分散式时钟，旨在解决分布式网络中没有单个可信赖时间源的时间问题。通过使用可验证的延迟功能，PoH允许每个节点使用SHA256计算在本地生成时间戳。这样就无需在整个网络上广播时间戳，从而提高了整体网络效率。SOL是Solana区块链的本地令牌。Solana使用委托权益证明共识算法来激励令牌持有者验证交易。作为Solana安全设计的一部分，所有费用都将在SOL中支付并被烧掉，从而减少总供应量。这种通货紧缩的SOL机制激励了更多的代币持有者参股，从而提高了网络安全性。

　　项目特征为了创建一个带有编码、无信任时间的分布式账本，SOLANAwps的官网最新下载的网站在哪设计了历史证明（ProofofHistory），这是验证订单和特定事件之间时间流逝的证据。历史证明将与工作证明（比特币等使用的共识性算法）或者权益证明（以太坊的Casper所使用的共识性算法）一起工作。这可以减少导致终止时间达到亚秒的消息传递开销。除此之外，Solana正在致力于在1GB网络基础上每秒产生高达710K的事务，而无需数据分区。你想知道他们计划如何实现这个伟大的胜利吗？在开发高吞吐量(Tps)和高度安全的区块链的竞赛中，团队正在设计新的方法来创建高度可扩展性的解决方案，从而允许现有区块链中每秒钟可进行高事务数量。“时间问题?”。在计算和信息时代，有一个基本的需求正在等待解决wps office 官方下载地址。事件之间的公平协调。这wps官网下载网址怎么找(wps office下载手机版下载)意味着：例如，当计算机向另一台计算机发送消息时，他们需要同步事务之间的时间。因此，这意味着，如果他们每个人都有自己的内在时钟，他们可能会或不可能正确协调。用时间戳来协调事件不仅是系统的需要，而且在金钱、人员和努力方面都是巨大的成本。开发人员已经开始使用一种技术来提高链的总体吞吐量。分片是一种技术，用于改善总链的TPS（系统吞吐量），并被证明是成功的，但它本身并不是一个完整的解决方案，因为这可能会引入漏洞。最大的漏洞是交易的分割，如果处理不好，就会打开链，导致欺诈交易、双重支出或同一交易的碎片缺乏共享知识。

　　为了提供一些普遍的看法，GoogleSpanner（谷歌的可扩展、多版本、全球分布式和同步复制的数据库支持读写事务、只读事务和快照读取）花费了大量资源来同步其数据数据中心之间的原子钟。他们需要得到精确的维护，并且有大量工程师正在为此工作。看起来协调时间是一件容易的事情，但事实并非如此，这就是Solana提出的历史证明解决方案。通过实现可信的时间协调，Solana不仅能够在速度和可靠性方面提高区块链吞吐量，还能降低平均成本。成功解决这个问题的团队可能会有一个高度采用的区块链wps免费版下载地址的方法。

　　技术概况深入研究Solana提出的解决方案会发现一些问题，例如，如何在区块链上实现历史证明，以及Solana到底是如何工作的，它们使用的是什么工具？首先，我们需要了解网络是如何设计的，以及它所包含的内容。历史证明是一种高频率可验证延迟函数。这意味着它将需要确定数量的相关步骤进行评估。但另一方面，这些步骤最终会产生一个唯一的输出，便于验证。在解决方案部分中，我们讨论了Solana如何增加TXN/s的数量，以及如何减少用于运行它们的所需资源wps的电脑版下载的入口。对这种可能性的解释与哈希函数的解释是一致的。哈希函数作为压缩数据的一种方式，这样更大数量的数据最终可以被压缩成小量位，这就鼓励了减少tx权重，从而提高了效率和更快速的序列。如上所述，历史证明序列被设计为与加密哈希函数一起工作。与加密哈希函数特别相关的是，使用原始输入，不用从头执行整个函数就可以预测最终的结果（输出）。因此，如果有输入并试图预测输出是不可能的，那么您将需要运行该函数来获得结果。考虑到这一点，假设wps的电脑版的下载地址在哪里这个哈希函数从某个随机起点（初始输入）运行，一旦这个过程完成，就获得第一个输出（哈希）。以下是它变得有趣的地方，将输入与从运行函数中获得的输出一起输入到下一个哈希的输入中。WPS office的电脑版下载的入口是什么如果我们要重复这个过程，例如300次。您可以开始看到，我们已经创建了一个单线程进程，其中最后的输出(哈希300)除了执行整个线程的人之外是完全不可猜测的。这个向下一个函数的输入和生成的数据提供输出的循环，表示为时间的流逝和历史的创建，用Solana的话来说就是滴答声。每一个输出都携带详细信息，如果不运行该函数，则无法预测。就像上述例子中的漫威的电影一样，每一部作品都代表了一段时间，恰好在连续时间的线程中位于它的位置。因此，Solana建议不要使用不可靠的时间，而是使用这些顺序有序和不可预测的输出来确定特定时刻，即线程进程中的特定时刻。我们可以称之为历史。

　　项目权益证明Solana使用权益证明（POS）来达成共识，并且它具有许多其他基于POS代币的相同特征。作为一个复习这里是是POS代币的一些主要特征：POS代币的证明使用验证器POS可通过证明1.把代币锁在钱包里2.将代币锁在主节点上，有助于链的稳定性支付顺序由POS代币或主节点奖励计划的“年龄”决定。每个POS钱包或主节点奖励计划都会收到铸币或wps的的官网最新下载的网站是什么新伪造的代币。离线时间太长的钱包或主节点奖励计划不再“支付”，可能会从网络中删除。POS的作用是防止不良行为的参与者通过破坏网络的安全性而引入无效的事务。对“坏角色”的惩罚可能是损失了POS代币和奖励。只要证明利益的回报大于通过欺诈获得收益的机会，信任就能得到保证。Solana有非常相似的结构，但他们以一种稍微不同的方式实现了他们的POS。Solana从那些已被连接的节点中选择了一个验证器(即，把一个代币投进去)wps官网的下载地方是多少。然后，验证器的投票和选择将由一直处于最长或最多绑定节点的节点来确定。Solana依赖于快速确认；如果一个节点在指定的时间内没有响应，它被标记为失效并从投票中移除，如果该节点当时是验证器，则举行新的选举以选择新的验证器。如果一个超级多数节点(三分之二节点)在该超时内投票，则该分支被认为是有效的。裁剪是使权益无效的行为，它防止验证器进行欺诈或试图验证多个节点，因为保税代币将丢失。一个主要的区别是次级选举节点的概念。一旦被选中，辅助节点就可以在网络中断或其他故障的情况下接管主要角色。

2025年3月2日
WPS office的电脑版的下载的地址

　wps的官网最新的下载的入口怎么找(wps官网最新在线编辑)　Solana由前高通，英特尔和Dropbox工程师于2017年底创立，是一种单链委托权益证明协议wps官网的下载网址的方法，其重点是在不降低分散性或安全性的前提下提供可扩展性。Solana扩展解决方案的核心是名为“历史证明（PoH）”的分散式时钟，旨在解决分布式网络中没有单个可信赖时间源的时间问题。通过使用可验证的延迟功能，PoH允许每个节点使用SHA256计算在本地生成时间戳。这样就无需在整个网络上广播时间戳，从而提高了整体网络效率。SOL是Solana区块链的本地令牌。Solana使用委托权益证明共识算法来激励令牌持有者验证交易。作为Solana安全设计的一部分，所有费用都将在SOL中支付并被烧掉，从而减少总供应量。这种通货紧缩的SOL机制激励了更多的代币持有者参股，从而提高了网络安全性。

　　项目特征为了创建一个带有编码、无信任时间的分布式账本，SOLANA设计了历史证明（ProofofHistory），这是验证订单和特定事件之间时间流逝的证据。历史证明将与工作证明（比特币等使用的共识性算法）或者权益证明（以太坊的Casper所使用的共识性算法）一起工作。这可以减少导致终止时间达到亚秒的消息传递开销。除此之外，Solana正在致力于在1GB网络基础上每秒产生高达710K的事务，而无需数据分区wps的官网的下载网址在哪。你想知道他们计划如何实现这个伟大的胜利吗？在开发高吞吐量(Tps)和高度安全的区块链的竞赛中，团队正在设计新的方法来创建高度可扩展性的解决方案，从而允许现有区块链中每秒钟可进行高事务数量。“时间问题?”。在计算和信息时代，有一个基本的需求正在等待解决。事件之间的公平协调。这意味着：例如，当计算机向另一台计算机发送消息时，他们需要同步事务之间的时间。因此，这意味着，如果他们每个人都有自己的内在时钟，他们可能会或不可能正确协调。用时间戳来协调事件不仅是系统的需要，而且在金钱、人员和努力方面都是巨大的成本。开发人员已经开始使用一种技术来提高链的总体吞吐量。分片是一种技术，用于改善总链的TPS（系统吞吐量），并被证明是成功的，但它本身并不是一个完整的解决方案，因为这可能会引入漏洞。最大的漏洞是交易的分割，如果处理不好，就会打开链，导致欺诈交易、双重支出或同一交易的碎片缺乏共享知识。wps office免费版的下载网站是多少

　　为了提供一些普遍的看法，GoogleSpanner（谷歌的可扩展、多版本、全球分布式和同步复制的数据库支持读写事务、只读事务和快照读取）花费了大量资源来同步其数据数据中心之间的原子钟。他们需要得到精确的维护，并且有大量工程师正在为此工作。看起来协调时间是一件容易的事情，但事实并非如此，这就是Solana提出的历史证明解决方案wps 的官网的下载地方是多少。通过实现可信的时间协调，Solana不仅wps官网最新的下载的入口在哪里能够在速度和可靠性方面提高区块链吞吐量，还能降低平均成本。成功解决这个问题的团队可能会有一个高度采用的区块链。

　　技术概况深入研究Solana提出的解决方案会发现一些问题，例如，如何在区块链上实现历史证明，以及Solana到底是如何工作的，它们使用的是什么工具？首先，我们需要了解网络是如何设计的，以及它所包含的内容。历史证明是一种高频率可验证延迟函数。这意味着它将需要确定数量的相关步骤进行评估。但另一方面，这些步骤最终会产生一个唯一的输出，便于验证。在解决方案部分中，我们讨论了Solana如何增加TXN/s的数量，以及如何减少用于运行它们的所需资源。对这种可能性的解释与哈希函数的解释是一致的。哈希函数作为压缩数据的一种方式，这样更大数量的数据最终可以被压缩成小量位，这就鼓励了减少tx权重，从而提高了效率和更快速的序列。如上所述，历史证明序列被设计为与加密哈希函数一起工作。与加密哈希函数特别相关的是，使用原始输入，不用从头执行整个函数就可以预测最终的结果（输出）。因此，如果有输入并试图预测输出是不可能的，那么您将需要运行该函数来获得结果。考虑到这一点，假设这个哈希函数从某个随机起点（初始输入）运行，一旦这个过程完成，就获得第一个输出（哈希）。以下是它变得有趣的地方，将输入与从运行函数中获得的输出一起输入到下一个哈希的输入中。如果我们要重复这个过程，例如300次。您可以开始看到，我们已经创建了一个单线程进程，其中最后的输出(哈希300)除了执行整个线程的人之外是完全不可猜测的。这个向下一个函数的输入和生成的数据提供输出的循环，表示为时间的流逝和历史的创建，用Solana的话来说就是滴答声。每一个输出都携带详细信息，如果不运行该函数，则无法预测。就像上述例子中的漫威的电影一样，每一部作品都代表了一段时间，恰好在连续时间的线程中位于它的位置。因此，Solana建议不要使用不可靠的时间，而是使用这些顺序有序和不可预测的输出来确定特定时刻，即线程进程中的特定时刻。我们可以称之为历史wps的电脑版的下载的地方。

　　项目权益证明Solana使用权益证明（POS）来达成共识，并且它具有许多其他基于POS代币的相同特征。作为一个复习这里是是POS代币的一些主要特征：POS代币的证明使用验证器POS可通过证明1.把代币锁在钱包里2.将代币锁在主节点上，有助于链的稳定性支付顺序由POS代币或主节点奖励计划的“年龄”决定。每个POS钱包或主节点奖励计划都会收到铸币或新伪造的代币。离线时间太长的钱包或主节点奖励计划不再“支付”，可能会从网络中删除。POS的作用是防止不良行为的参与者通过破坏网络的安全性而引入无效的事务。对“坏角色”的惩罚可能是损失了POS代币和奖励。只要证明利益的回报大于通过欺诈获得收益的机会，信任就能得到保证。Solana有非常相似的结构，但他们以一种稍微不同的方式实现了他们的POS。Solana从那些已被连接的节点中选择了一个验证器(即，把一个代币投进去)。然后，验证器的投票和选择将由一直处于最长或最多绑定节点的节点来确定。Solana依赖于快速确认；如果一个节点在指定的时间内没有响应，它被标记为失效并从投票中移除，如果该节点当时是验证器，则举行新的选举以选择新的验证器。如果一个超级多数节点(三分之二节点)在该超时内投票，则该分支被认为是有效的。裁剪是使权益无效的行为，它防止验证器进行欺诈或试图验证多个节点，因为保税代币将丢失。一个主要的区别是次级选举节点的概念。一旦被选中，辅助节点就可以在网络中断或其他故障的情况下接管主要角色。

2025年3月2日

分类： 未分类

分类：未分类