作者：宿何微服务的稳定性一直是开发者非常关注的话题。随着业务从单体架构向分布式架构演进以及部署方式的变化，服务之间的依赖关系变得越来越复杂，业务系统也面临着巨大的高可用挑战。应用高可用服务 AHAS (Application High Availability Service) 是经阿里巴巴内部多年高可用体系沉淀下来的云产品，以流量与容错为切入点，从流量控制、不稳定调用隔离、熔断降级、热点流量防护、系统自适应保护、集群流控等多个维度来帮助保障服务的稳定性，同时提供秒级的流量监控分析功能。AHAS 不仅在阿里内部淘宝、天猫等电商领域有着广泛的应用，在互联网金融、在线教育、游戏、直播行业和其他大型政央企行业也有着大量的实践。流控是保障微服务稳定性最常用也是最直接的一种控制手段。每个系统、服务都有其能承载的容量上限，流控的思路非常简单，当某个接口的请求 QPS 超出一定的上限后，拒绝多余的请求，防止系统被突发的流量打垮。市面上最常见的方案是单机维度的流控，比如通过 PTS 性能测试预估某个接口的容量上限是 100 QPS，服务有 10 个实例，则配置单机流控 10 QPS。但很多时候，由于流量分布的不确定性，单机维度的流量控制存在一些效果不佳的情况。典型场景 1:精确控制对下游的调用总量场景：服务 A 需要频繁调用服务 B 的查询接口，但服务 A 和 B 的容量存在差异，服务 B 约定最多给服务 A 提供总共 600 QPS 的查询能力，通过流控等手段进行控制。痛点：若按照单机流控的策略配置，由于调用逻辑、负载均衡策略等原因，A 调用 B 到达每个实例的流量分布可能非常不均，部分流量较大的服务 B 实例触发单机流控，但总体限制量尚未达到，导致 SLA 未达标。这种不均的情况经常会发生在调用某个依赖服务或组件（如数据库访问）的时候，这也是集群流控的一个典型场景：精确控制微服务集群对下游服务（或数据库、缓存）的调用总量。典型场景 2：业务链路入口进行请求总量控制场景：在 Nginx/Ingress 网关、API Gateway (Spring Cloud Gateway, Zuul) 进行入口流量控制，希望精确控制某个或某组 API 的流量来起到提前保护作用，多余流量不会打到后端系统。痛点：如果按照单机维度配置，一方面不好感知网关机器数变化，另一方面网关流量不均可能导致限流效果不佳；而且从网关入口角度来讲，配置总体阈值是最自然的手段。AHAS 集群流控AHAS 集群流控可以精确地控制某个服务接口在整个集群的实时调用总量，可以解决单机流控因流量不均匀、机器数频繁变动、均摊阈值太小导致限流效果不佳的问题，结合单机流控兜底，更好地发挥流量防护的效果。对于上面的场景，通过 AHAS 集群流控，无论是 Dubbo 服务调用、Web API 访问，还是自定义的业务逻辑，均支持精确控制调用总量，而无关调用逻辑、流量分布情况、实例分布。既可以支撑数十万 QPS 大流量控制，也支持分钟小时级业务维度小流量精确控制。防护触发后的行为可由用户自定义（如返回自定义的内容、对象）。AHAS 集群防护具有以下几大优势：场景丰富：全面覆盖从网关/Mesh 入口流量精确防护、Web/RPC 服务/SQL 调用精确流控，到分钟小时级业务维度流量控制的场景，支持数十万 QPS 量级；低使用成本：无需特殊接入方式，开箱即用，快速配置；全自动管控与运维：自动化管控与分配 token server 资源，自动化运维能力保障可用性，用户无需关注服务端资源准备与分配，只需关注规则配置与业务流程；低性能损耗：性能模式下对业务链路完全无时延增加，精确模式对业务链路的 RT 损耗控制在 3ms 之内，用户可放心使用；配套的可观测能力，实时了解接口稳定性与规则生效情况。下面我们就来用一个示例来介绍一下，如何快速将应用接入 AHAS 来玩转集群流控能力，保障服务稳定性。快速玩转 AHAS 集群流控第一步，我们将服务或网关接入 AHAS 流量防护。AHAS 提供多种快速便捷的无侵入接入手段：AHAS 流量防护支持 Java/Go/C++/PHP 等多语言原生接入，以及 Nginx/Ingress 网关接入和 Mesh 接入；Java 应用支持全方位的 20+ 种微服务框架/组件：Web 服务端：Spring Web/Spring Boot/Spring Cloud/Tomcat/Jetty/UndertowWeb client：OkHttp/Apache HttpClientRPC：Dubbo/Feign/gRPCDAO/缓存：MyBatis/Spring Data JPA/Memcached/Jedis clientMQ consumer：RocketMQ client/Kafka client/RocketMQ clientAPI Gateway：Spring Cloud Gateway/Zuul 1.xReactor 框架接入 AHAS 成功后，只要触发服务调用/接口访问，即可在 AHAS 控制台看到自己的服务，并可以在监控页面看到自己的接口：第二步，我们在应用左侧菜单的“集群流控-集群配置”页面，开启集群流控功能。测试应用我们可以开启“试用”集群，不同的集群规格可以承载不同的 QPS 量级：第三步，我们在实时监控页面找一个接口，点击右上角的“+”号，新增流控规则。以下示例中，我们对 /doSomething 这个接口配置集群流控规则，这个接口总的访问量每秒钟不超过 200 次。规则状态为“开启”，代表新增后实时生效。点击下一步，我们还可以给选择的 Web/RPC 调用配置防护规则触发后的处理逻辑，如自定义返回值。最终配置完成后，我们点击新增按钮，这条规则就会生效到每个节点。配置完毕后，我们可以向应用集群中不同机器发起一定数量的该接口请求，可以发现每秒钟超过 200 个请求后会自动返回我们在规则中预设好的返回行为；同时控制台实时监控页面也可以看到，多余的流量被拒绝，接口每秒钟通过的总量级平稳在 200 QPS：通过几步简单的配置，我们就可以快速体验 AHAS 集群流控给业务流量带来“如丝般顺滑”的保护能力；同时最近 AHAS 还新上线 Nginx/Ingress 网关入口流量防护、Web 请求参数流控 等核心功能，欢迎大家点击阅读原文，在前往 AHAS 控制台进行快速体验。了解更多相关信息，请扫描下方二维码或搜索微信号（AlibabaCloud888）添加云原生小助手！获取更多相关资讯！

第1 章 ： 事务处理课时1 事务的四大特性（ACID）原子性 Atomicity 操作不可再分割，要么成功，要么失败一致性 Consistency 数据状态与业务规则保持一致隔离性 Isolation 并发事务不会相互干扰持久性 Durability 数据操作必须被持久化到数据库中课时2：MySQL中开启和关闭事务默认情况下，MySQL没执行一条SQL语句，都是单独的事务如果要在一个事务中包含多条SQL语句，那么需要开启事务和结束事务-- 开启事务 start transaction -- 结束事务 commit -- 或者 rollback课时3 JDBC中完成事务处理// 开启事务，设置不自动提交， 默认true conn.setAutoCommit(false); // 提交事务 conn.commit() // 回滚事务 conn.rollback()代码格式try{ conn.setAutoCommit(false); ... conn.commit() }catch(){ conn.rollback() }转账示例import util.JdbcUtils; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException; /** * create table account( * id int primary key auto_increment, * username varchar(50), * balance int * ) * * insert into account(username, balance) values ('张三', 1000), ('王五', 1000) */ class Demo { public static void transferMoney(int fromId, int toId, int money) throws SQLException { Connection conn = JdbcUtils.getConnection(); conn.setAutoCommit(false); try { updateBalance(conn, fromId, -money); if(true){ throw new RuntimeException("断网了"); } updateBalance(conn, toId, money); conn.commit(); } catch (Exception e) { conn.rollback(); throw new RuntimeException(e); } finally { conn.close(); } } public static void updateBalance(Connection conn, int id, int money) throws SQLException { String sql = "update account set balance = balance + ? where id = ?"; PreparedStatement statement = conn.prepareStatement(sql); statement.setInt(1, money); statement.setInt(2, id); statement.executeUpdate(); } public static void main(String[] args) throws SQLException { transferMoney(1, 2, 100); } } 课时4 事务的隔离级别事务并发问题脏读：读取到另一个事务未提交数据不可重复读：两次读取不一致幻读：读到另一个事务已提交数据四大隔离级别串行化 不会出现并发，性能最差（坚决不用）可重复度 防止脏读和不可重复读，不能处理幻读（MySQL默认）读已提交 防止脏读读未提交 性能最好-- 查看隔离级别 select @@tx_isolation -- 设置隔离级别 set transaction isolationlevel [1, 2, 3, 4]第2 章 ： 连接池课时5 dbcp连接池1、池参数初始大小：10个最小空闲连接数：3个增量：一次创建最小单位5个最大空闲连接数：12个最大连接数：20个最大等待时间：1000毫秒2、四大连接参数连接池也是使用4个连接参数来完成创建连接对象3、连接池必须实现接口:javax.sql.DataSource连接池的close() 方法不是关闭，而是归还依赖<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-dbcp2</artifactId> <version>2.7.0</version> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> <version>2.8.0</version> </dependency> ]import org.apache.commons.dbcp2.BasicDataSource; import java.sql.Connection; import java.sql.SQLException; class Demo { public static void main(String[] args) throws SQLException { // 配置4个必要参数 BasicDataSource dataSource = new BasicDataSource(); dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/data"); dataSource.setUsername("root"); dataSource.setPassword("123456"); // 配置连接池参数 dataSource.setMaxWaitMillis(1000); // 获取连接对象 Connection conn = dataSource.getConnection(); System.out.println(conn.getClass().getName()); // 归还连接 conn.close(); } } 课时6 装饰者模式对象增强的手段（1）继承（2）装饰者模式（3）动态代理1、继承：会使得类增多增强的内容是固定的被增强的对象也是固定的2、装饰者模式增强的对象是不能修改的被增强的对象可以是任意的InputStreamFileInputStream 节点流BufferedInputStream 装饰流is ahas ause a// MyConnection is Connection class MyConnection implements Connection{ // MyConnection has Connection private Connection conn; // 底层对象，被增强的对象 // 通过构造器传递底层对象 public MyConnection(Connection conn){ this.conn = conn; } public Statement createStatement(){ return this.conn.createStatement(); } // 增强点 public void close(){ } }3、动态代理被增强的对象可以切换增强的内容也可以切换课时7 c3p0连接池的基本使用方式依赖<dependency> <groupId>com.mchange</groupId> <artifactId>c3p0</artifactId> <version>0.9.5.5</version> </dependency>import com.mchange.v2.c3p0.ComboPooledDataSource; import java.beans.PropertyVetoException; import java.sql.Connection; import java.sql.SQLException; class Demo { public static void main(String[] args) throws PropertyVetoException, SQLException { // 配置4个必要参数 ComboPooledDataSource dataSource = new ComboPooledDataSource(); dataSource.setDriverClass("com.mysql.cj.jdbc.Driver"); dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/data"); dataSource.setUser("root"); dataSource.setPassword("123456"); // 配置连接池参数 dataSource.setAcquireIncrement(5); dataSource.setInitialPoolSize(3); dataSource.setMinPoolSize(3); dataSource.setMaxPoolSize(20); // 获取连接对象 Connection conn = dataSource.getConnection(); System.out.println(conn.getClass().getName()); // 归还连接 conn.close(); } } 课时8 c3p0连接的配置文件使用必须命名为：c3p0-config.xml必须放在src目录下<?xml version="1.0" encoding="utf-8"?> <c3p0-config> <!-- 这是默认配置信息 --> <default-config> <!-- 连接四大参数配置 --> <property name="driverClass">com.mysql.cj.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql://localhost:3306/data</property> <property name="user">root</property> <property name="password">123456</property> <!-- 池参数配置 --> <property name="acquireIncrement">3</property> <property name="initialPoolSize">10</property> <property name="minPoolSize">2</property> <property name="maxPoolSize">10</property> </default-config> </c3p0-config> 连接会报错：java.sql.SQLException: No suitable driverimport com.mchange.v2.c3p0.ComboPooledDataSource; import java.sql.Connection; import java.sql.SQLException; class Demo { public static void main(String[] args) throws SQLException { ComboPooledDataSource dataSource = new ComboPooledDataSource(); // 获取连接对象 Connection conn = dataSource.getConnection(); System.out.println(conn.getClass().getName()); // 归还连接 conn.close(); } } 第3 章 ： JDBC工具类课时9-10 JdbcUtils小工具import com.mchange.v2.c3p0.ComboPooledDataSource; import javax.sql.DataSource; import java.sql.Connection; import java.sql.SQLException; public class JdbcUtil { // 需要配置c3p0-config.xml private static ComboPooledDataSource dataSource = new ComboPooledDataSource(); // 返回连接对象 public static Connection getConnection() throws SQLException { return dataSource.getConnection(); } // 返回连接池对象 public static DataSource getDataSource(){ return dataSource; } } 课时11 JNDI配置JNDI(Java Naming and Directory Interface, Java命名和目录接口)课时12 ThreadLocal解决多线程并发问题的工具类,它为每个线程提供了一个本地的副本变量机制，实现了和其它线程隔离，并且这种变量只在本线程的生命周期内起作用，可以减少同一个线程内多个方法之间的公共变量传递的复杂度import java.sql.SQLException; import java.util.HashMap; import java.util.Map; class Demo { public static void main(String[] args) throws SQLException { ThreadLocal<String> tl = new ThreadLocal<String>(); // 添加 tl.set("Tom"); // 获取 String name = tl.get(); System.out.println(name); // 移除 tl.remove(); } }ThreadLocal的核心代码class TL<T>{ private Map<Thread, T> map = new HashMap<Thread, T>(); public void set(T value){ this.map.put(Thread.currentThread(), value); } public T get(){ return this.map.get(Thread.currentThread()); } public void remove(){ this.map.remove(Thread.currentThread()); } }课时13 dbutils原理依赖<dependency> <groupId>commons-dbutils</groupId> <artifactId>commons-dbutils</artifactId> <version>1.7</version> </dependency>示例Student.classpublic class Student { private int sid; private String sname; public int getSid() { return sid; } public void setSid(int sid) { this.sid = sid; } public String getSname() { return sname; } public void setSname(String sname) { this.sname = sname; } public Student() { } @Override public String toString() { return "Student{" + "sid=" + sid + ", sname='" + sname + '\'' + '}'; } }Demo.class1、查询操作import org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.handlers.BeanHandler; import java.sql.SQLException; class Demo { public static void main(String[] args) throws SQLException { // 提供数据库连接池 QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource()); // 查询操作 // sql模板 String sql = "select * from student where sid = ?"; // 参数 Object[] params = {3}; // 提供结果集处理器 Student student = qr.query(sql, new BeanHandler<Student>(Student.class), params); System.out.println(student); // Student{sid=3, sname='杨不悔'} } } 2、更新操作String sql = "update student set sname=? where sid = ?"; Object[] params = {"杨不悔", 3}; qr.update(sql, params);课时14 dbUtils结果集处理器介绍common-dbutils.jarQueryRunner// update执行增，删，改 int update(String sql, Object... params) int update(Connection conn, String sql, Object... params) // query执行查询 T query(String sql, ResultSetHandler rsh, Object... params) T query(Connection conn, String sql, ResultSetHandler rsh, Object... params) ResultSetHandler接口BeanHandler（单行） 一行转换成指定类型的javaBean对象BeanListHandler(多行) 多行转为list对象MapHandler(单行) 一行结果转为Map对象MapListHandler(多行) 多行结果转为Map对象列表ScalarHandler 单行单列 通常用于select count(*) from table1、BeanListHandlerimport org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.handlers.BeanListHandler; import java.sql.SQLException; import java.util.List; class Demo { public static void main(String[] args) throws SQLException { // 提供数据库连接池 QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource()); String sql = "select * from student"; List<Student> students = qr.query(sql, new BeanListHandler<Student>(Student.class)); System.out.println(students); } } 2、MapListHandlerimport org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.handlers.MapListHandler; import java.sql.SQLException; import java.util.List; import java.util.Map; class Demo { public static void main(String[] args) throws SQLException { QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource()); String sql = "select * from student"; List<Map<String, Object>> students = qr.query(sql, new MapListHandler()); System.out.println(students); } } 3、ScalarHandlerimport org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils.handlers.ScalarHandler; import java.sql.SQLException; class Demo { public static void main(String[] args) throws SQLException { QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource()); String sql = "select count(*) from student"; Number cnt = (Number)qr.query(sql, new ScalarHandler()); long count = cnt.longValue(); System.out.println(count); } } 课时15 编写TxQueryRunner配合JdbcUtils来处理事务class TxQueryRunner extends QueryRunner{ // 重写部分方法 }课时16 JdbcUtils处理多线程并发访问问题使用 ThreadLocal第4 章 ： 分页课时17 分页准备工作分页优点：只查询一页，不用查询所有页class pageBean<T>{ // 当前页码 private int currentPage; // 总页数 private int totalPage; // 总记录数 private int totalRecord; // 页面大小 private int pageSize; // 页面数据 private List<T> beanList; }课时18：处理分页各层分工第n页/共N页 首页 上一页 1 2 3 4 5 6 下一页 尾页课时19 分页处理第一阶段完成课时20 分页之页面页码列表计算计算公式pageSize = 10begin = currentPage - 5end = currentPage + 4如果总页数<=10, 那么bedin=1, end=总页数头溢出：当begin<1, 那么begin=1尾溢出：当end>总页数, 那么end>总页数课时21 分页之查询条件丢失问题超链接中要保留参数课时22 分页之查询条件保存到PageBean的url中

场景主要介绍混沌工程的思想及其原理，体验故障演练（AHAS Chaos），阿里云在混沌工程领域的产品。，11 月 9 日至 11 月 23 日期间，，完成体验即可获得“TOMY 多美卡合金车模一辆”。地址：https://developer.aliyun.com/adc/series/activity/1111本场景涉及到以下技术或产品：容器服务ACK：容器服务Kubernetes版（简称ACK）提供高性能可伸缩的容器应用管理能力，支持企业级容器化应用的全生命周期管理；是国内唯一入选2020年Gartner公共云容器报告的产品，并在2019年Forrester容器报告中获国内排名第一；整合了阿里云虚拟化、存储、网络和安全能力，助力企业高效运行云端Kubernetes容器化应用。故障演练Chaos：故障演练（Chaos）是云原生混沌工程平台，提供了大规模、低成本、影响可控、形式多样化的故障演练服务。Chaos提供一站式架构分析、故障巡检、故障注入、系统稳态度量等功能，帮助用户增强分布式系统的容错性和可恢复性，帮助系统平稳上云。原理介绍相信您一定有在新闻联播里看到过解放军某某兵团在某地进行军事实战演练的新闻，对于军队来说，最好的训练方式就是实兵演习。即使平时的训练已经已经非常系统和完善，但到了真正的实战中仍然可能会出现各种各样平时训练预想不到的问题。所以只有真正的实战演练才能发现问题，才能更好的规划下一阶段的训练，提高军队的战斗力。面向失败设计我们的软件系统不也是一样吗？“Everything fails, all the time.” 在平时的开发过程中，即使我们已经预想了各种各样的场景，修复好了所有的bug，但一旦上线总会出现各种各样的情况。我们的软件系统，同样也需要这样的实战演练。您需要在一开始的系统设计阶段就考虑到各种失败场景，把面向失败当成系统设计的一部分，并且准备好从失败中恢复的策略，这有助于更好地提升整个系统的可用性。只有您意识到事情会随着时间的推移而失败，并将这种思想融入到体系结构中，那么在失败发生的时候您才能完全不受影响或者将失败损失降到最低。故障演练混沌工程正是在这种面向失败设计思想下催生的。面对失败设计，要求我们提前为失败做好准备，但是我们准备的这些措施在故障真实发生时是否真的有效？恢复故障的工具是否实现了容灾？处理故障的人员是否熟练？这些问题，很难得到验证，却往往会在真实的故障中暴露出来。而这就是混沌工程的意义所在，混沌工程就像演习一样，通过有目的的制造故障，找出系统可能存在的弱点，从而验证在真实复杂的环境下，系统、人员应对各种突发问题的能力是否符合预期，提升系统的免疫能力。故障演练（Chaos）提供的正是这样的能力。创建实验资源阿里云提供ACK+Chaos云产品资源4小时资源链接：https://developer.aliyun.com/adc/scenario/e9b27357ab9c4785bc7f43fb62f872e3安装探针1回到容器服务控制台页面，单击左侧导航栏上方的< 图标。2在集群列表页面的左侧导航栏中，单击应用目录。3在应用目录页面，单击ack-ahas-pilot。4在ack-ahas-pilot的详情页面，单击创建。返回如下页面，表示探针已经部署完成。通过架构感知查看系统整体架构1复制应用高可用服务控制台地址，在Firefox浏览器打开新页签，粘贴并访问容器服务应用高可用服务控制台。https://chaos.console.aliyun.com/2在概览页面顶部，选择资源所在地域。例如下图中，地域切换为华东1（杭州）。3在左侧导航栏，单击故障演练>架构感知。4在架构地图页面，单击Kubernetes监控视图卡片中的查看视图。5在架构地图页面，打开Kubernetes监控视图下拉列表，选择命令空间为default，然后单击确定即可查看实验资源的Kubernetes监控视图。自动恢复场景演练在分布式系统设计中有一种容错策略是故障恢复（failback），通过健康检查等机制，能在机器或者应用出现问题时自动的进行重新部署。我们利用Chaos进行故障演练，测试我们的系统是否具有这样的能力1.进行稳态假设。定义一个稳态指标，来评估系统的健康状态并且在实施混沌过程当中进行监控和处理。我们将稳态定义为 能访问我们的frontend界面，并正常使用各种购物车、下单等功能。2模拟真实事件。2.1 切换回应用高可用服务控制台。在左侧导航栏中，单击我的空间。2.2 在我的空间页面，在新建演练下拉列表中单击新建空白演练。2.3 在演练配置页面，完成以下操作：（1）设置演练名称。（2）在演练对象配置向导中，演练应用选择frontend，应用分组选择frontend-group，机器列表选择任意一台机器，单击添加演练内容。（3）在选择演练故障对话框中，选择JAVA应用>延迟>容器内Java延迟，单击确定。（4）在演练配置页面，单击容器内Java延迟。（5）在容器内Java延迟面板中，依次输入类的全限定名、方法名、进程关键字和目标容器名称，单击关闭。类的全限定名：输入com.alibabacloud.hipstershop.web.HealthController。方法名：输入health。进程关键字：输入java。目标容器名称：选择frontend。（6）在演练内容区域中，单击保存。（7）单击下一步。（8）在全局配置的监控策略区域，单击新增策略。（9）在新增策略对话框中，选择业务监控>业务状态观察（Http），单击确定。（10）在业务状态观察（Http）面板中，请求类型选择get，URL输入http://<frontend的外部端点>/。说明 ：frontend的外部端点在容器服务ACK控制台frontend服务的访问方式页签中获取。（11）在全局配置配置向导中，单击下一步。（12）在成功对话框中，单击演练详情。2.4 在演练详情页面，单击演练。2.5 在开始执行演练对话框中，单击确认。3检测实验影响。3.1 在演练记录详情页面，查看业务状态观测（Http）时序图。您可以看到health接口的调用在遇到故障之后，先降低，然后马上自动恢复至正常状态，说明我们的设计奏效了。3.2 切换回容器服务ACK控制台，在frontend服务页面，单击事件页签。您可以看到frontend自动的进行了扩容。4终止实验。4.1 切换回应用高可用服务控制台。在演练记录详情页面中，单击终止。4.2 在停止演练对话框中，单击确定。4.3 等待演练场景终止之后，在结果反馈对话框中，单击确定。强弱依赖场景演练在微服务架构中，各个服务之间存在许多依赖关系。但是当一个不重要的弱依赖宕机时，一个健壮的系统应该仍然能够正常的运行。我们利用Chaos进行故障演练，测试我们的系统处理强弱依赖的能力如何。1.进行稳态假设。1.1 切换回容器服务ACK控制台，单击frontend的外部端点。1.2 在Hipster Shop页面，多次刷新页面。您可以看到页面商品的排序每一次都不一样。您可以理解为商品推荐服务会根据个性化进行推荐，使产品存在优先级。因此我们将稳态定义为，每次刷新页面，商品的排序不同。2.模拟真实事件。2.1 切换回应用高可用服务控制台。在左侧导航栏，单击我的空间。2.2 在我的空间页面，在新建演练下拉列表中单击新建空白演练。2.3 在演练配置页面，完成以下操作：（1）设置演练名称。（2）在演练对象配置向导中，演练应用选择recommendationservice，应用分组选择recommendationservice-group，机器列表选择机器，单击添加演练内容。（3）在选择演练故障对话框中，选择JAVA应用>延迟>容器内Java延迟，单击确定。（4）在演练内容区域中，单击容器内Java延迟。（5）在容器内Java延迟面板中，依次输入类的全限定名、方法名、进程关键字和目标容器名称，单击关闭。类的全限定名：输入com.alibabacloud.hipstershop.recomendationservice.service.RecommendationServiceImpl。方法名：输入sortProduct。进程关键字：输入java。目标容器名称：选择recommendationservice。（6）在演练对象中，单击保存。（7）单击下一步。（8）在全局配置中，单击下一步。（9）在成功对话框中，单击演练详情。2.4 在演练详情页面，单击演练。2.5 在开始执行演练对话框中，单击确认。检测实验影响。3.1 切换回容器服务ACK控制台。在无状态页面，单击frontend。3.2 在frontend页面，单击访问方式页签，然后单击frontend的外部端点。3.3 在Hipster Shop页面，多次刷新页面。您可以发现每次刷新，产品顺序不会改变。说明推荐服务宕机，但并没有影响别的服务。终止实验。4.1 切换至应用高可用服务控制台，在演练记录详情页面，单击终止。4.2 在停止演练对话框中，单击确定。4.3 在结果反馈对话框中，单击确定。失败重试场景演练在微服务架构中，一个大系统被拆分成多个小服务，小服务之间存在大量RPC调用，经常可能因为网络抖动等原因导致RPC调用失败，这时候使用重试机制可以提高请求的最终成功率，减少故障影响，让系统运行更稳定。我们通过利用Chaos，给系统注入失败，看看系统失败重试的性能如何。进行稳态假设。1.1 切换回容器服务ACK控制台，在无状态页面，单击cartservice。1.2 在cartservice页面，单击伸缩。1.3 在伸缩对话框中，将所需容器组数量更改为2，单击确定。待状态变为Running，表示容器组扩容成功。1.4 切换至Hispter Shop页面，单击购物车。返回如下页面，表示购物车服务正常。因此我们将稳态定义为，能够正常使用frontend的购物车功能。模拟真实事件。2.1 切换回应用高可用服务控制台，在左侧导航栏，单击我的空间。2.2 在我的空间页面，在新建演练下拉列表中单击新建空白演练。2.3 在演练配置页面，完成以下操作：（1）设置演练名称。（2）在演练对象中，演练应用选择cartservice，应用分组选择cartservice-group，机器列表选择任意一台机器，单击添加演练内容。（3）在选择演练故障对话框中， 选择JAVA应用>抛异常>容器内Java延迟抛出自定义异常，单击确定。（4）在演练内容区域中，单击容器内Java延迟抛出自定义异常。（5）在容器内Java延迟抛出自定义异常面板中，依次输入方法名、类的全限定名、异常、进程关键字和目标容器名称，单击关闭。方法名：输入viewCart。类的全限定名：输入com.alibabacloud.hipstershop.cartserviceprovider.service.CartServiceImpl。异常：输入java.lang.Exception。进程关键字：输入java。目标容器名称：选择cartservice。（6）在演练对象中，单击保存。（7）单击下一步。（8）在全局配置中，单击下一步。（9）在成功对话框中，单击演练详情。2.4 在演练详情页面，单击演练。2.5 在开始执行演练对话框中，单击确认。检测实验影响。3.1 切换至Hispter Shop页面，单击购物车。返回如下页面，您发现无法访问购物车。这是因为流量并没有切换到没有宕机的那台机器，同时 说明我们的系统并没有失败重试的能力，或者是一开始就没有设计，或者是没有生效。通过这次故障注入，我们发现了系统的缺陷。3.2 切换至应用高可用服务控制台，在演练记录详情页面，单击终止。3.3 在停止演练对话框中，单击确定。3.4 在结果反馈对话框中，单击确定。返回如下页面，表示演练结束。微服务演练在体验了上述三个场景演练之后，我们对混沌工程有了初步的了解，也掌握了应用高可用服务的基本功能。但是这样手动部署参数的过程还是比较繁琐的。接下来我们体验一下更为方便快捷的强弱依赖治理。1切换至应用高可用服务控制台。在左侧导航栏中，单击微服务演练。并选择强弱依赖治理页面。2在强弱依赖治理页面中，单击创建治理方案。3在创建治理方案的配置向导页面，完成以下操作。3.1 在应用接入中，自定义方案名称，治理应用选择frontend，单击下一步。3.2 在强弱依赖治理以30天为治理周期对话框中，单击确认。3.3 在依赖分析中，等待分析完成，单击下一步。3.4 在依赖预判中，自行选择依赖对象的强弱依赖预判，例如nacos-standalone和checkoutservice的强弱依赖预判可选择强依赖，其他依赖对象默认弱依赖，然后单击下一步。3.5 在依赖验证中，选择任意用例进行验证。例如选择frontend与nacos-standalone强弱依赖验证用例，单击去验证。3.6 在去验证前的参数确认对话框中，单击确定验证。注意：如果窗口没有跳转，请注意跳转是否被拦截，请手动解除4在演练详情页面中，单击演练。5在开始执行演练对话框中，单击确认。6切换至Hipster Shop页面，单击网页的任意功能。您可以发现Hipster Shop网页和相关功能均可以正常访问，说明frontend服务与nacos-standalone服务是弱依赖关系。7切换至应用高可用服务控制台，在演练记录详情页面，单击终止。8在停止演练对话框中，单击确定。9在结果反馈对话框中，结论选择不符合预期，验证结果选择弱依赖，单击确定，返回强弱依赖治理。10在依赖验证中，您可以验证其他用例，验证完成后，单击方案归档。11在您确定要归档此方案吗对话框中，单击确认归档。返回如下页面，表示归档完毕。相关场景基于EMR离线数据分析容器服务ACK+容器网络文件系统CNFS快速搭建NGINX网站

一、命名规范1、通用命名方法命名方法举例Camel命名法thisIsAnApplePascal命名法ThisIsAnApple注意：在命名时尽量简洁明了，用英文表达（绝对不能用拼音或者首字母拼写）2、各类型命名规范名称命名方法词汇种类说明举例局部变量名Camel命名法名词fristName全局变量名Camel命名法名词前缀:ggFristName参数名Camel命名法名词fristName方法/属性Camel命名法名词fristName私有（保护）成员Camel命名法名词前缀:__fristName常量名名词下划线+全体大写ADD_METHOD类名Pascal命名法名词AtiveDicBool类型Camel命名法名词前缀:is/hashasChild3、函数与类的命名Ⅰ.函数1）使用Pascal命名法2）前缀为动词，前缀词如下表所示动词含义举例Can判断是否可以执行某个权限CanLoginHas判断是否含有某个值HasTokenIs判断是否为某个值IsShowModelGet获取某个值GetUserIdSet设置某个值SetCookieLoad加载某些数据LoadListUpdate更新某些数据UpdateUserInfoDel删除某些数据DelMenuⅡ、类（Class）命名规范1）使用Pascal命名法2）名字应该明确表达改类的作用二、props与state的使用1、Props定义：大多数组件在定义时就可以通过各种自定义参数来实现组件的定制。编程注意事项：1.在页面中禁止直接修改propsthis.props.name = 'Alen'。2.在调用props时尽量使用扩展符。//goodconst { name } = this.porps;console.log(name);//badconsole.log(this.props.name);3.在传递props时，如无必要，不能传递整个props，只需传递props中所需要的属性（在models中的reducers 同理）。2、State定义：State是一个组件的UI数据模型，是组件渲染时的数据依据。编程注意事项：1.绝对不要 直接改变 this.state,你可以将它看作是一个不可变得变量（如需改变必须调用setState）//goodthis.setState({name:'Lucy'});    //badthis.state.name = 'Lucy';2.setState时异步的，若执行setState后需马上调用，可以使用这些方法转化为同步。（方法）3.和渲染无关的状态尽量不要放在 state 中来管理4.在State更新时，如果更新的值涉及到了state和props，我需要注意在调用setState时不要直接使用this.props和this.state//good this.setState((prevState, props) => ({name: prevState.name + props.increment}));//badthis.setState({name:this.state.name});5.禁止在shouldComponentUpdate或者componentWillUpdate方法中调用setState6.最好在componentDidMount中调用3、何时调用哪个？1.如果数据需要跨组件传输，则放在props中进行传递2.如果数据只在本组件使用，并且涉及到在render中进行渲染，则放在state中进行处理3.其余数据可在组件中直接定义。三、React编码规范1、自我解释尽可能减少代码中的注释。可以通过让变量名更语义化、只注释复杂、潜在逻辑，来减少注释量，同时也提高了可维护性，毕 竟不用总在代码与注释之间同步了。2、JSX编码1.在JSX中禁止使用if语句进行判定//badShowUserInfo{    if(isShowUserInfo){        retrun(            <div>姓名：张三</div>        );    }else{        return(            <div>姓名：未填写</div>        )    }   }//goodShowUserInfo(){    return isShowUserInfo : (<div>姓名：张三</div>) ? (<div>姓名：未填写</div>)}三目运算：条件1?值1或操作1: //如果满足条件1，就返回值1或执行操作12.尽量使用单标签//badrender(){    return(    <div>        ...        <UserInfo></UserInfo>        ...    </div>    );}//goodrender(){    return(    <div>        ...        <UserInfo />        ...    </div>    );}3.在标签中默认的都是true//bad<Foo  hidden={true}/>//good<Foo hidden />4.在map循环时，不要用index作为每个标签的key// bad{todos.map((todo, index) =>  <Todo    {...todo}    key={index}  />)}// good{todos.map(todo => (  <Todo    {...todo}    key={todo.id}  />))}5.使用ref的回调// bad<Foo  ref="myRef"/>// good<Foo  ref={(ref) => { this.myRef = ref; }}/>更多JSX规范参见：更多规范3、渲染与判断逻辑分开在render中只进行页面的渲染，不作对数据或者逻辑的处理4、解构// bad  const splitLocale = locale.split('‑');  const language = splitLocale[0];  const country = splitLocale[1]; // good  const [language, country] = locale.split('‑');5、变量判定1.对所有定义的或者传入的变量，都进行默认设置或者判定是否为undefined，防止数据未定义时程序报错。// Bad  onChange(value => console.log(value.name))  // Dirty  onChange((value) => {       if (!value) {          value = {}    }        console.log(value.name)  })  // Clean  onChange((value = {}) => console.log(value.name))  // Clean  onChange(value => console.log(value?.name))不要信任任何回调函数给你的变量，它们随时可能是 undefined ，使用初始值是个不错的选择，但有的时候初始值没什么意 义，使用 ?. 语法可以安全的访问属性。2.自定义变量//badlet newslist = this.props.newslist;let b = a  // a为数组//good let { newslist = [] } = this.props;let b = a || [];四、React中常用ES6语法1、let与const1.let、const只能定义之后使用console.log(a); // errorlet a = 1;console.log(b); // undefinedvar b = 2;console.log(c);const c = 3;   // error2、let与const不能重复定义let a = 1;const b = 1;var c = 1;let a = 2; // Identifier 'a' has already been declaredconst b = 2; // Identifier 'a' has already been declaredvar c = 2; // 23、const定义后的变量不可修改var a = 1;a = 2;  // 2let b = 1;b = 2; // 2console.log(b);const c = 1;c = 2; //Assignment to constant variable.从上面这些实例我可以大致的知道const、let、var具体应该应用在那些地方，但是我们会发现let与var几乎没有什么区别，那么为什么我们不能全部都用var呢？答案是不能的，有var是在全局中申明一个变量，首先这个变量在使用后依然会存在与内存中，而let在函数调用完成过后就会被立即消除，从下面的例子我们可以看出。for (var j = 0; j < 10; j++) {    // ...}console.log(j);  // 10for (let i = 0; i < 10; i++) {    // ...}console.log(i);  // i is not defined所以慎用var，我们在平常编码过程中，大部分的var都是能被let和const替代的。2、变量解构1.数组与数组合并let a = [1,2];let b = [3,4];//badlet c = a.concat(b); // [1,2,3,4]//ORfor(let i = 0 ;i<b.length;i++){    a.push(b[i]);}//goodlet c = [...a,...b]; // [1,2,3,4]2.对象与对象合并let a = {name:'张三'}let b = {age:32}//badlet c = {    name:a.name,    age:b.age}//good let c = {...a,...b};3.对象并入数组let a = [{name:'张三'}];let b = {name:'Lucy'};//badlet c = a.push(b);//goodlet c = [...a,b];4.更改变量名let a = {name:'Lucy',age:32};//badlet NAME = a.name;//good let {name:NAME} = a;5.数值互换let a = 1;let b = 2;//badlet t;t = a;a = b;b = t;//good[a,b] = [b,a];3、箭头函数请写一个常用的forEach循环let arr = [1,2,3];//bad arr.forEach(function(e){    console.log(e);});//goodarr.forEach((e)=>{    console.log(e);});但是我们会发现，其实funtion去写也并没有什么不对的地方，最多也就是多写一点点而已，那为什么ES6需要新增这个箭头函数呢？最主要的目的就是解决this指针的问题，而this在React的编码过程中会大量的去使用它。我们知道在ES6中，我们可以创建一个class，如果我们默认在其里面加入一个函数的话，其必须在调用的时候，必须绑定this指针，否则不能访问当前类的实例里面的属性。function Person() {  this.age = 0;  setInterval(function growUp() {    this.age++;    console.log(this.age); // NaN  }, 1000);}var p = new Person();在ES3/5我们需要穿过function传递需要怎么做呢？function Person() {  this.age = 0;  let _this = this;  setInterval(function growUp() {    _this.age++;    console.log(_this.age); // 1 2 3...  }, 1000);}var p = new Person();但是这样写会麻烦，而且有点啰嗦和繁杂，所以我们可以使用es6中的箭头函数function Person() {  this.age = 0;  setInterval(()=> {    this.age++;    console.log(this.age); // 1 2 3...  }, 1000);}var p = new Person();在React中需要传递this指针也都是通过箭头函数来实现的，当然以前也可以使用bind函数来绑定this，但是这样也是一种吃力不讨好的做法。4、遍历注意：在遍历过程中禁止删除、新增1.数组遍历let a = [1,2,3,4,5];//badfor(let i = 0;i<a.length;i++){    console.log(a[i]);}//gooda.forEach(e=>{    console.log(e);})//OR 注意，map必须有returna.map(e=>{    console.log(e);    return e;}); 参考文献：for 、 forEach 、 map2.对象遍历let a = {name:'Lucy',age:32,sex:'女'};//badfor(o in a){    console.log(a[o]);}//good for(o in a){    if(a.hasOwnProperty(o)){        console.log(a[o]);    }}参考文献：for...in... for...of... 注意：二者有巨大区别，慎用5、值判断1.判空if([]){    console.log('1');} // 1if({}){    console.log('1');} // 1if(''){    console.log('1');}变量如果不为0，null，undefined，false，都会被处理为true。只要变量有非0的值或是某个对象，数组，非空字符串，都会认为true2.true || falseconsole.log([] == false); // trueconsole.log({} == false); // trueconsole.log('' == false); // falseconsole.log(0 == false); //true3.typeof类型判断类型结果Undefined"undefined"Null"object"Boolean"boolean"Number"number"String"string"Symbol"symbol"宿主对象Implementation-dependent函数对象"function"任何其他对象"object"参考文献：typeof

今天，企业数字化转型依然面临很大的挑战，虽然有很多新技术不断涌现，云厂商、ISV 在帮助企业做转型，但是在实际落地过程中，企业仍然需要解决一些痛点，比如：当前，业界技术产品和理念非常繁多，怎么用新技术实现业务快速创新？目前的路径还不是很清晰。 其次，分布式技术复杂度高，运维成本高，业务稳定性挑战大，系统搭建出来之后，存在稳定性不好的问题，在后续运行中也可能出现多种问题。还有就是技术组合集成度不足，缺乏统一的规划和端到端一致的解决方案。 正是因为看到企业在数字化转型中面临的技术难点，阿里云发布业界首款云原生技术中台产品——云原生 Stack（简称 CNStack）。云原生 Stack，是云原生时代的技术中台，可以线下轻量、敏捷的输出。技术中台基于 ACK 敏捷版，在用户的基础设施环境，轻量敏捷地享受到与 ACK一样安全、稳定的容器服务，天生具有多集群管理能力。同时，云原生 Stack 也是业务应用平台，可以满足线下各行各业客户在数字化转型中遇到的所有技术挑战。云原生 Stack 不但可以敏捷输出，也可以规模化输出，更可以在异构 IaaS 上输出。云原生 Stack 补齐了云原生线下能力，提供了四大核心产品形态：第一个是云原生 Stack for Application：它是企业数字化的一站式技术底座，把 ACK 敏捷版、EDAS 应用平台、应用高可用服务 AHAS、可观测 ARMS 集成在一个平台上，具备较高的集成度和一致的体验。云原生 Stack for Application 解决了开发运维一体化，加速业务迭代，内置分布式中间件，一站式满足行业应用云原生的所有诉求，并且提供了大量的解决方案，包括异地多活方案、企业互联网架构方案、业务中台方案、安全生产方案、资源混部方案等。以阿里云资源混部解决方案为例，它可以将 IT 基础设施资源的日平均利用率从 10% 的业界平均水平提升到 45%，帮助企业降低 50% 的 IT 成本。让企业数字化不受技术约束，更轻量、更简单。第二个形态是云原生 Stack for SaaS：以容器为代表的云原生技术带来的核心价值是：向下管理资源，向上支撑应用，水平管理软件生命周期。过去在单机时代，软件的安装管理比较容易。但是到了云计算时代，在分布式软件、分布式环境、分布式算力的背景下，软件想要部署发布，升级维护就会变得很复杂，以前行业中完全没有这个问题的解法。今天，阿里云开创性地提出云原生 Stack for SaaS。让 SaaS 软件的交付更简单，它屏蔽了 IaaS 的差异性，什么环境都可以部署，什么环境都可以适配，每一种硬件、芯片都可以适配。云原生 Stack for SaaS可以让部署提效 5 倍，集群测试提效 5 倍，并且降低依赖组件 90% 运维工作量。现在已经有超过 50 家企业软件在对接、使用、落地这个产品。第三个形态是云原生 Stack for Edge：当下，边缘的场景也非常流行，云原生 Stack 是边缘场景和边缘应用的全生命周期管理平台，可以实现边缘资源 1 分钟自动纳管；具备低时延、安全通信能力，消息到达率 99.9%；组件丰富，内置数十款边缘中间件。 第四个形态是云原生 Stack 社区版：社区版是帮助企业和开发者快速试用云原生 Stack 的技术平台，可以免费下载、一键部署，一站式满足研发测试能力，并且可以无缝迁移到商业版、迁移到生产环境，这个版本会在 12 月在阿里云官网公开提供下载。云原生 Stack 满足了各种典型场景下客户对于线下高集成平台的诉求，让企业数字化转型不受技术约束，专注业务本身，加速企业数字化迭代。 

​在工作中我们会常用到的一些es6-es10的一些特性还记得多少，今天就让我们重新复习一遍ES6语法 1.Let　　1.let声明的变量具有块级作用域，{ let a = 1}console.log(a); //undefined a变量是在代码块{}中使用 let 定义的，它的作用域是这个代码块内部，外部无法访问。　　2.let声明的全局变量不是全局对象的属性var a = 1console.log(window.a); //1let a = 1console.log(window.a); // undefined　　3.用let重定义变量会抛出一个语法错误var a = 1var a = 2console.log(a) //2如果是 let ，则会报错let a = 1let a = 2// VM131:1 Uncaught SyntaxError: Identifier 'a' has already been declared// at :1:1 2.Constconst除了具有let的块级作用域和不会变量提升外，还有就是它定义的是常量，在用const定义变量后，我们就不能修改它了，对变量的修改会抛出异常。const A= 123;console.log(A);A = 1;console.log(A);// Uncaught TypeError: Assignment to constant variable.在 ES6 中新增了很多实用的原生 API，方便开发者对 Array 的操控性更强，如 for…of、from、of、fill、find、findIndex等。3.for…of　　在es5之前遍历数组for (var i = 0; i < array.length; i++) { console.log(array[i]);}　　在es6之前遍历数组for (let val of [1,2,3]) { console.log(val);}// 1,2,34.Array.prototype.from()数组是开发中经常用到的数据结构，它非常好用。在 JavaScript 的世界里有些对象被理解为数组，然而缺不能使用数组的原生 API，比如函数中的 arguments、DOM中的 NodeList等。当然，还有一些可遍历的对象，看上去都像数组却不能直接使用数组的 API，因为它们是伪数组（Array-Like）。要想对这些对象使用数组的 API 就要想办法把它们转化为数组，传统的做法是这样的：let args = [].slice.call(arguments);let imgs = [].slice.call(document.querySelectorAll('img'));基本原理是使用 call 将数组的 api 应用在新的对象上，换句话说是利用改变函数的上下文来间接使用数组的 api。在 ES6 中提供了新的 api 来解决这个问题，就是 Array.from，代码如下： let args = Array.from(arguments);let imgs = Array.from(document.querySelectorAll('img'));5.Array.prototype.of()Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。Array.of() 和 Array 构造函数之间的区别在于处理整数参数：Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个长度为7的空数组（注意：这是指一个有7个空位(empty)的数组，而不是由7个undefined组成的数组）。Array.of(7); // [7]Array.of(1, 2, 3); // [1, 2, 3]Array(7); // [ , , , , , , ]Array(1, 2, 3); // [1, 2, 3]6.Array.prototype.fill()fill() 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。 let array = [1, 2, 3, 4]array.fill(0, 1, 2)// [1,0,3,4]7.Array.prototype.find()find() 方法返回数组中满足提供的测试函数的第一个元素的值，否则返回 undefined。 let array = [5, 12, 8, 130, 44];let found = array.find(function(element) { return element > 10;});console.log(found);// 128.Array.prototype.findIndex()findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。其实这个和 find() 是成对的，不同的是它返回的是索引而不是值。 let array = [5, 12, 8, 130, 44];let found = array.findIndex(function(element) { return element > 10;});console.log(found);// 19.Class对于面向对象编程而言，更关注类的声明、属性、方法、静态方法、继承、多态、私有属性。首先我们要先来说明在 JavaScript 世界里如何声明一个 “类”。在 ES6 之前大家都是这么做的： let Animal = function (type) { this.type = type this.walk = function () {console.log(`I am walking`)}}let dog = new Animal('dog')let monkey = new Animal('monkey')在 ES6 中把类的声明专业化了，不在用 function 的方式了，请看：class Animal { constructor (type) {this.type = type} walk () {console.log(`I am walking`)}}let dog = new Animal('dog')let monkey = new Animal('monkey')10.Setters & Getters对于类中的属性，可以直接在 constructor 中通过 this 直接定义，还可以直接在类的顶层来定义： class Animal { constructor (type, age) {this.type = type this._age = age} get age () {return this._age} set age (val) {this._age = val}}11.静态方法静态方法是面向对象最常用的功能，在 ES5 中利用 function 实现的类是这样实现一个静态方法的。let Animal = function (type) { this.type = type this.walk = function () {console.log(`I am walking`)}}Animal.eat = function (food) { console.log(I am eating);}在 ES6 中使用 static 的标记是不是静态方法，代码如下： class Animal { constructor (type) {this.type = type} walk () {console.log(`I am walking`)} static eat () {console.log(`I am eating`)}}12.继承面向对象只所以可以应对复杂的项目实现，很大程度上要归功于继承。如果对继承概念不熟悉的同学，可以自行查询。在 ES5 中怎么实现继承呢？// 定义父类let Animal = function (type) { this.type = type}// 定义方法Animal.prototype.walk = function () { console.log(I am walking)}// 定义静态方法Animal.eat = function (food) { console.log(I am eating)}// 定义子类let Dog = function () { // 初始化父类 Animal.call(this, 'dog') this.run = function () {console.log('I can run')}}// 继承Dog.prototype = Animal.prototype从代码上看，是不是很繁琐？而且阅读性也较差。再看看 ES6 是怎么解决这些问题的：class Animal { constructor (type) {this.type = type} walk () {console.log(`I am walking`)} static eat () {console.log(`I am eating`)}}class Dog extends Animal { constructor () {super('dog')} run () {console.log('I can run')}} 13.默认参数对于函数而言，经常会用到参数，关于参数的默认值通常都是写在函数体中，如在 ES5 的时候大家都会这么写：function f (x, y, z) {if (y === undefined) y = 7; if (z === undefined) z = 42; return x + y + z;};f(1) === 50;当一个函数有很多参数涉及初始化的时候，这样写代码极其丑陋，所以在 ES6 中改变了对这种知识的写法：function f (x, y = 7, z = 42) {return x + y + z}f(1) === 50 14.Rest Parameter在写函数的时候，部分情况我们不是很确定参数有多少个，比如求和运算，之前都是这么做的：function sum () { let num = 0 Array.prototype.forEach.call(arguments, function (item) {num += item * 1}) return num}console.log(sum(1, 2, 3))// 6console.log(sum(1, 2, 3, 4))// 10其实在上面说过，这个代码在 ES5 中可以这么写，在 ES6 就不能这么写了，因为 arguments 的问题。现在需要这样写：function sum (...nums) { let num = 0 nums.forEach(function (item) {num += item * 1}) return num}console.log(sum(1, 2, 3))// 6console.log(sum(1, 2, 3, 4))// 10当然，Rest Parameter 也可以和其他参数一起来用，比如：function sum (base, ...nums) { let num = base nums.forEach(function (item) {num += item * 1}) return num}console.log(sum(30, 1, 2, 3))// 36console.log(sum(30, 1, 2, 3, 4))// 40 15.箭头函数箭头函数可以说是 ES6 很大的福利了，不管你是函数式爱好者还是面向对象开发者，函数是必须要用到的东西。之前声明函数需要使用 function，如下：function hello () { console.log('say hello')}// 或let hello = function () { console.log('say hello')}现在可以这样做了：let hello = () => { console.log('say hello')}如果带参数该怎么做呢？let hello = (name) => { console.log('say hello', name)}// 或者let hello = name => { console.log('say hello', name)}16.Enhanced Object Properties(增强对象属性)在 ES6 之前 Object 的属性必须是 key-value 形式，如下：var x = 0, y = 0;obj = { x: x, y: y };在 ES6 之后是可以用简写的形式来表达：var x = 0, y = 0obj = { x, y } 17.Object.assign()Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象，它将返回目标对象。 const target = { a: 1, b: 2 }const source = { b: 4, c: 5 }const returnedTarget = Object.assign(target, source)console.log(target)// expected output: Object { a: 1, b: 4, c: 5 }console.log(returnedTarget)// expected output: Object { a: 1, b: 4, c: 5 }从语法上可以看出源对象的个数是不限制的（零个或多个），如果是零个直接返回目的对象，如果是多个相同属性的会被后边的源对象的属相覆盖。let s = Object.assign({ a: 1 })// {a: 1}18.RegExp　　StickySticky除了u修饰符，ES6还为正则表达式添加了y修饰符，叫做“粘连”（sticky）修饰符。y修饰符的作用与g修饰符类似，也是全局匹配，后一次匹配都从上一次匹配成功的下一个位置开始。不同之处在于，g修饰符只要剩余位置中存在匹配就可，而y修饰符确保匹配必须从剩余的第一个位置开始，这也就是“粘连”的涵义。const s = 'aaa_aa_a'const r1 = /a+/gconst r2 = /a+/yr1.exec(s) // ["aaa"]r2.exec(s) // ["aaa"]r1.exec(s) // ["aa"]r2.exec(s) // null19.UnicodeES6对正则表达式添加了u修饰符，含义为“Unicode模式”，用来正确处理大于 \uFFFF 的Unicode字符。也就是说，会正确处理四个字节的UTF-16编码。/^\uD83D/u.test('\uD83D\uDC2A')// false/^\uD83D/.test('\uD83D\uDC2A')// true上面代码中，\uD83D\uDC2A是一个四个字节的UTF-16编码，代表一个字符 “?”。但是，ES5不支持四个字节的UTF-16编码，会将其识别为两个字符，导致第二行代码结果为true。加了u修饰符以后，ES6就会识别其为一个字符，所以第一行代码结果为false。　　(1)电字符　　　　点（.）字符在正则表达式中，含义是除了换行符以外的任意单个字符。对于码点大于 0xFFFF 的 Unicode 字符，点字符不能识别，必须加上u修饰符。let s = '?'; ///^.$/.test(s) // false/^.$/u.test(s) // true　　（2).Unicode字符表示法　　　　ES6新增了使用大括号表示Unicode字符，这种表示法在正则表达式中必须加上u修饰符，才能识别。/\u{61}/.test('a') // false/\u{61}/u.test('a') // true/\u{20BB7}/u.test('?') // true　　(3)量词　　　　使用u修饰符后，所有量词都会正确识别码点大于0xFFFF的Unicode字符。/a{2}/.test('aa') // true/a{2}/u.test('aa') // true/?{2}/.test('??') // false/?{2}/u.test('??') // true　　(4) 预定义模式　　　　　u修饰符也影响到预定义模式，能否正确识别码点大于0xFFFF的Unicode字符。/^\S$/.test('?') // false/^\S$/u.test('?') // true上面代码的\S是预定义模式，匹配所有不是空格的字符。只有加了u修饰符，它才能正确匹配码点大于0xFFFF的Unicode字符。利用这一点，可以写出一个正确返回字符串长度的函数。function codePointLength(text) { const result = text.match(/[\s\S]/gu); return result ? result.length : 0;}const s = '??';s.length // 4codePointLength(s) // 2　　(5) i修饰符　　　　有些Unicode字符的编码不同，但是字型很相近，比如，\u004B与\u212A都是大写的K。/[a-z]/i.test('\u212A') // false/[a-z]/iu.test('\u212A') // true 20.Template 模板字符串　　　在 ES6 之前对字符串的处理是相当的麻烦，看如下场景：　　1. 字符串很长要换行　　　　字符串很长包括几种情形一个是开发时输入的文本内容，一个是接口数据返回的文本内容。如果对换行符处理不当，就会带来异常。　　2. 字符串中有变量或者表达式　　　　如果字符串不是静态内容，往往是需要加载变量或者表达式，这个也是很常见的需求。之前的做法是字符串拼接：var a = 20var b = 10var c = 'JavaScript'var str = 'My age is ' + (a + b) + ' and I love ' + cconsole.log(str)从 ES6 开始可以这样定义字符串了。string text`string text line 1 string text line 2`string text ${expression} string text在这里你可以任意插入变量或者表达式，只要用 ${} 包起来就好。 21解构赋值在 ES6 中新增了变量赋值的方式：解构赋值。如果对这个概念不了解，我们可以快速展示一个小示例一睹风采：let arr = ['Ilya', 'Kantor']let firstName = arr[0]let surname = arr[1]想从数组中找出有意义的项要单独赋值给变量（一一的写），在 ES6 中就可以这样写了：let [firstName, surname] = ['Ilya', 'Kantor']console.log(firstName) // Ilyaconsole.log(surname) // Kantor22.Promise首先要说明 Promise 就是为了解决“回调地狱”问题的，它可以将异步操作的处理变得很优雅。如果我们使用 Promise 来解决上面那个问题该怎么做呢？function loadScript (src) { return new Promise((resolve, reject) => {let script = document.createElement('script') script.src = src script.onload = () => resolve(script) script.onerror = (err) => reject(err) document.head.append(script)})}loadScript('1.js') .then(loadScript('2.js'), (err) => {console.log(err)}) .then(loadScript('3.js'), (err) => {console.log(err)})   通过创建 Promise 对象开启一个异步操作的过程，一般用几步完成多次异步操作：new Promise(fn) 返回一个Promise 对象在fn 中指定异步等处理处理结果正常的话，调用resolve(处理结果值)处理结果错误的话，调用reject(Error对象)　　1.Promise.prototype.then()var promise = new Promise(function (resolve, reject) { resolve('传递给then的值')})promise.then(function (value) { console.log(value)}, function (error) { console.error(error)})　　　　这段代码创建一个 Promise 对象，定义了处理 onFulfilled 和 onRejected 的函数（handler），然后返回这个 Promise 对象。　　　　这个 Promise 对象会在变为 resolve 或者 reject 的时候分别调用相应注册的回调函数。　　　　　　当 handler 返回一个正常值的时候，这个值会传递给 Promise 对象的 onFulfilled 方法。　　　　　　定义的 handler 中产生异常的时候，这个值则会传递给 Promise 对象的 onRejected 方法　　2.Promise.resolve()　　　　　一般情况下我们都会使用 new Promise() 来创建 Promise 对象，但是除此之外我们也可以使用其他方法。Promise.resolve(42).then(function (value) { console.log(value)})在这段代码中的 resolve(42) 会让这个 Promise 对象立即进入确定（即resolved）状态，并将 42 传递给后面 then 里所指定的 onFulfilled 函数。　　3.Promise.reject()　　　　　　Promise.reject(error) 是和 Promise.resolve(value) 类似的静态方法，是 new Promise() 方法的快捷方式。new Promise(function (resolve, reject) { reject(new Error('出错了'))})　　4.Promise.prototype.catch()　　　　　　捕获异常是程序质量保障最基本的要求，可以使用 Promise 对象的 catch 方法来捕获异步操作过程中出现的任何异常。function test () { return new Promise((resolve, reject) => {reject(new Error('es'))})}test().catch((e) => { console.log(e.message) // es})　　5.Promise.all()var p1 = Promise.resolve(1)var p2 = Promise.resolve(2)var p3 = Promise.resolve(3)Promise.all([p1, p2, p3]).then(function (results) { console.log(results) // [1, 2, 3]})Promise.all 生成并返回一个新的 Promise 对象，所以它可以使用 Promise 实例的所有方法。参数传递promise数组中所有的 Promise 对象都变为resolve的时候，该方法才会返回， 新创建的 Promise 则会使用这些 promise 的值。如果参数中的任何一个promise为reject的话，则整个Promise.all调用会立即终止，并返回一个reject的新的 Promise 对象。由于参数数组中的每个元素都是由 Promise.resolve 包装（wrap）的，所以Paomise.all 可以处理不同类型的 promose对　　6.Promise.race()var p1 = Promise.resolve(1)var p2 = Promise.resolve(2)var p3 = Promise.resolve(3)Promise.race([p1, p2, p3]).then(function (value) { console.log(value) // 1})Promise.race 生成并返回一个新的 Promise 对象。参数 promise 数组中的任何一个 Promise 对象如果变为 resolve 或者 reject 的话， 该函数就会返回，并使用这个 Promise 对象的值进行 resolve 或者 reject。　 23.ReflectReflect 是一个内置的对象，它提供拦截 JavaScript 操作的方法，这些方法与处理器对象的方法相同。Reflect不是一个函数对象，因此它是不可构造的。 　　1.Reflect.apply()　　　　Reflect.apply(Math.floor, undefined, [1.75])// 1;Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111])// "hello"Reflect.apply(RegExp.prototype.exec, /ab/, ['confabulation']).index// 4Reflect.apply(''.charAt, 'ponies', [3])// "i"该方法与ES5中Function.prototype.apply()方法类似：调用一个方法并且显式地指定this变量和参数列表(arguments) ，参数列表可以是数组，或类似数组的对象。Function.prototype.apply.call(Math.floor, undefined, [1.75]);　　2.Reflect.construct()　　　　　Reflect.construct() 方法的行为有点像 new 操作符 构造函数 ， 相当于运行 new target(…args).var d = Reflect.construct(Date, [1776, 6, 4])d instanceof Date // trued.getFullYear() // 1776　　3.Reflect.define​Property()　　　　静态方法 Reflect.defineProperty() 基本等同于 Object.defineProperty() 方法，唯一不同是返回 Boolean 值。const student = {}Reflect.defineProperty(student, 'name', { value: 'Mike' }) // truestudent.name // "Mike"　　4.Deflect.delete​Property()　　　　Reflect.deleteProperty 允许你删除一个对象上的属性。返回一个 Boolean 值表示该属性是否被成功删除。它几乎与非严格的 delete operator 相同。var obj = { x: 1, y: 2 };Reflect.deleteProperty(obj, "x"); // trueobj; // { y: 2 }var arr = [1, 2, 3, 4, 5];Reflect.deleteProperty(arr, "3"); // truearr; // [1, 2, 3, , 5]// 如果属性不存在，返回 trueReflect.deleteProperty({}, "foo"); // true// 如果属性不可配置，返回 falseReflect.deleteProperty(Object.freeze({foo: 1}), "foo"); // false　　5.Reflect.get()　　　　Reflect.get() 方法的工作方式，就像从 object (target[propertyKey]) 中获取属性，但它是作为一个函数执行的。// Objectvar obj = { x: 1, y: 2 }Reflect.get(obj, 'x') // 1// ArrayReflect.get(['zero', 'one'], 1) // "one"// Proxy with a get handlervar x = { p: 1 }var obj = new Proxy(x, { get (t, k, r) { return k + 'bar' }})Reflect.get(obj, 'foo') // "foobar"　　6.Reflect.get​OwnProperty​Descriptor()　　　　　　静态方法 Reflect.getOwnPropertyDescriptor() 与 Object.getOwnPropertyDescriptor() 方法相似。如果在对象中存在，则返回给定的属性的属性描述符，否则返回 undefined。Reflect.getOwnPropertyDescriptor({ x: 'hello' }, 'x')// {value: "hello", writable: true, enumerable: true, configurable: true}Reflect.getOwnPropertyDescriptor({ x: 'hello' }, 'y')// undefinedReflect.getOwnPropertyDescriptor([], 'length')// {value: 0, writable: true, enumerable: false, configurable: false}　　7.Reflect.get​PrototypeOf()　　　　静态方法 Reflect.getPrototypeOf() 与 Object.getPrototypeOf() 方法是一样的。都是返回指定对象的原型（即，内部的 [[Prototype]] 属性的值）。 　　8.Reflect.has()　　　　　Reflect.has 用于检查一个对象是否拥有某个属性， 相当于in 操作符 　　9.Reflect.set()　　　　Reflect.set 方法允许你在对象上设置属性。它的作用是给属性赋值并且就像 property accessor 语法一样，但是它是以函数的方式。// Objectvar obj = {};Reflect.set(obj, "prop", "value"); // trueobj.prop; // "value"// Arrayvar arr = ["duck", "duck", "duck"];Reflect.set(arr, 2, "goose"); // truearr[2]; // "goose"// It can truncate an array.Reflect.set(arr, "length", 1); // truearr; // ["duck"];// With just one argument, propertyKey and value are "undefined".var obj = {};Reflect.set(obj); // trueReflect.getOwnPropertyDescriptor(obj, "undefined");// { value: undefined, writable: true, enumerable: true, configurable: true }　　10.Reflect.set​PrototypeOf()　　　　Reflect.setPrototypeOf 方法改变指定对象的原型 （即，内部的 [[Prototype]] 属性值）Reflect.setPrototypeOf({}, Object.prototype); // true// It can change an object's [[Prototype]] to null.Reflect.setPrototypeOf({}, null); // true// Returns false if target is not extensible.Reflect.setPrototypeOf(Object.freeze({}), null); // false// Returns false if it cause a prototype chain cycle.var target = {};var proto = Object.create(target);Reflect.setPrototypeOf(target, proto); // false 24.Proxy 　　在 ES6 标准中新增的一个非常强大的功能是 Proxy，它可以自定义一些常用行为如查找、赋值、枚举、函数调用等。通过 Proxy 这个名称也可以看出来它包含了“代理”的含义，只要有“代理”的诉求都可以考虑使用 Proxy 来实现。let p = new Proxy(target, handler)　　从服务端获取的数据希望是只读，不允许在任何一个环节被修改。// response.data 是 JSON 格式的数据，来自服务端的响应// 在 ES5 中只能通过遍历把所有的属性设置为只读for (let [key] of Object.entries(response.data)) { Object.defineProperty(response.data, key, {writable: false})}　　如果我们使用 Proxy 就简单很多了：let data = new Proxy(response.data, { set(obj, key, value) {return false}}) 25.Generator什么是 JavaScript Generators 呢？通俗的讲 Generators 是可以用来控制迭代器的函数。它们可以暂停，然后在任何时候恢复。如果这句话不好理解，可以看下接下来的示例。 ES5之前做法　　for (let i = 0; i < 5; i += 1) { console.log(i)}// this will return immediately 0 -> 1 -> 2 -> 3 -> 4用 Generatorfunction * generatorForLoop () { for (let i = 0; i < 5; i += 1) {yield console.log(i)}}const genForLoop = generatorForLoop()console.log(genForLoop.next()) // first console.log - 0console.log(genForLoop.next()) // 1console.log(genForLoop.next()) // 2console.log(genForLoop.next()) // 3对比下代码，常规的循环只能一次遍历完所有值，Generator 可以通过调用 next 方法拿到依次遍历的值，让遍历的执行变得“可控”。　　语法function * gen () { yield 1 yield 2 yield 3}let g = gen()// "Generator { }"　　这个是 Generator 的定义方法，有几个点值得注意：比普通函数多一个 *函数内部用 yield 来控制程序的执行的“暂停”函数的返回值通过调用 next 来“恢复”程序执行　　yield 表达式 　　　　yield 表达式的返回值是 undefined，但是遍历器对象的 next 方法可以修改这个默认值function * gen () { let val val = yield 1 console.log(1:${val}) // 1:undefined val = yield 2 console.log(2:${val}) // 2:undefined val = yield 3 console.log(3:${val}) // 3:undefined}var g = gen()console.log(g.next()) // {value: 1, done: false}console.log(g.next()) // {value: 2, done: false}console.log(g.next()) // {value: 3, done: false}console.log(g.next()) // {value: undefined, done: true}　　yeild * 是委托给另一个遍历器对象或者可遍历对象function * gen () { let val val = yield 1 console.log(1:${val}) // 1:undefined val = yield 2 console.log(2:${val}) // 2:undefined val = yield [3, 4, 5] console.log(3:${val}) // 3:undefined}enerator 对象的 next 方法，遇到 yield 就暂停，并返回一个对象，这个对象包括两个属性：value 和 done。  26.module　　在 ES6 之前，JS 文件之间的导入、导出是需要借助 require.js、sea.js。现在，大家可以使用 import、export 来实现原生 JavaScript 的导入、导出了。　　export　　导出变量或者常量export const name = 'hello'export let addr = 'BeiJing City'export var list = [1, 2 , 3]　　importconst name = 'hello'let addr = 'BeiJing City'var list = [1, 2 , 3]export { name as cname, addr as caddr}export default list ES7语法 1.Array.prototype.includes　　　　Array.prototype.includes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。let array1 = [1, 2, 3]console.log(array1.includes(2))// expected output: truevar pets = ['cat', 'dog', 'bat']console.log(pets.includes('cat'))// expected output: trueconsole.log(pets.includes('at'))// expected output: false在 ES7 之前想判断数组中是否包含一个元素，基本可以这样写： console.log(array1.find(function (item) { return item === 2 }))　2.Math.pow　我们一直都是这样用的：console.log(Math.pow(2, 3)) // 8（2的三次方）　　在 ES7 可以这样写了：console.log(2 ** 3)ES8语法 1.Async/Awaitasync 和 await 是 Promise 的拓展，如果对 Promise 还不了解的话，请移步 Promise 章节进行学习。async function firstAsync () { return 27}firstAsync().then(console.log) // 27也就是说上面的代码等同于：async function firstAsync () { return Promise.resolve(27)}async 的作用我们清楚了，await呢？话不多说：async function firstAsync () { let promise = new Promise((resolve, reject) => {setTimeout(() => resolve("Now it's done!"), 1000)})// wait until the promise returns us a value let result = await promise// "Now it's done!" return result}firstAsync().then(console.log)这段代码使用了 await，从这个字面的意思看就是“等待”，它等什么呢？很简单，它等 Promise 返回结果。上面代码的意思是 async 开启了一个 Promise 对象，这个函数内部嵌套了一个 Promise 操作，这个操作需要等 1 秒才返回 “Now it’s done!” 这个结果。也就是说 await 在拿到这个结果之前不会继续执行，一直等到结果才往后继续执行，也就是 async function 声明的 Promise 才会响应（console.log才执行）。 　　1.await 后面一定是 Promise 对象，如果不是会自动包装成 Promise 对象　　常规async function firstAsync () { let result = await 27 return result}firstAsync().then(console.log) // 27对象async function firstAsync () { let result = await { a: 1 } return result}firstAsync().then(console.log) // { a: 1 }async function firstAsync () { let result = await { a: 1 } return result}firstAsync().then(console.log) // { a: 1 }　非 Promise 对象将用 Promise.resolve 来包装，而 await 后边的值作为 resolve 的参数。 　　2. await 不可以脱离 async 单独使用function firstAsync() { let promise = Promise.resolve(10); let result = await promise; // Syntax error} 2.Object.values() 　　Object.values() 返回一个数组，其元素是在对象上找到的可枚举属性值。属性的顺序与通过手动循环对象的属性值所给出的顺序相同(for…in，但是for…in还会遍历原型上的属性值)。let grade = { 'lilei': 98, 'hanmei': 87}console.log(Object.values(grade)) // [98, 87] 3.Object.entries　　Object.entries()方法返回一个给定对象自身可枚举属性的键值对数组，其排列与使用 for…in 循环遍历该对象时返回的顺序一致。（区别在于 for-in 循环也枚举原型链中的属性）let grade = { 'lilei': 98, 'hanmei': 87}for (let [key, value] of grade) { console.log(key, value) // Uncaught TypeError: grade is not iterable}我们知道 Object 是不可直接遍历的，上述代码足以说明直接遍历触发了错误。如果使用 Object.entries() 则可以完成遍历任务。 let grade = { 'lilei': 98, 'hanmei': 87}for (let [k, v] of Object.entries(grade)) { console.log(k, v) // lilei 98 // hanmei 87}4.String padding在 ES8 中 String 新增了两个实例函数 String.prototype.padStart 和 String.prototype.padEnd，允许将空字符串或其他字符串添加到原始字符串的开头或结尾。这两个方法有什么用武之地呢？回忆下我们处理日期的时候经常要格式化，比如 01、02、10等。for (let i = 1; i < 31; i++) { if (i < 10) {console.log(`0${i}`)} else {console.log(i)}}之前输出1号到31号，需要手动判断是否小于10号，小于的在前面增加 0。现在可以这样做了：for (let i = 1; i < 31; i++) { console.log(i.toString().padStart(2, '0'))}String.prototype.padStart 和 String.prototype.padEnd 用法是相同的，只是一个在开头补白一个在结尾。5.Object.getOwnPropertyDescriptors()想理解 Object.getOwnPropertyDescriptors 这个方法之前，首先要弄懂什么是描述符(descriptor)？ const data = { Portland: '78/50', Dublin: '88/52', Lima: '58/40'}还是上述那个对象，这里有 key 和 value，上边的代码把所有的 key、value 遍历出来，如果我们不想让 Lima 这个属性和值被枚举怎么办？Object.defineProperty(data, 'Lima', { enumerable: false})Object.entries(data).map(([city, temp]) => { console.log(City: ${city.padEnd(16)} Weather: ${temp}) // City: Portland Weather: 78/50 // City: Dublin Weather: 88/52})　　很成功，Lima 没有被遍历出来，那么 defineProperty 的第三个参数就是描述符(descriptor)。这个描述符包括几个属性：value [属性的值]writable [属性的值是否可被改变]enumerable [属性的值是否可被枚举]configurable [描述符本身是否可被修改，属性是否可被删除] ES9语法   1.for await of   我们知道 for…of 是同步运行的，有时候一些任务集合是异步的，那这种遍历怎么办呢？function Gen (time) { return new Promise(function (resolve, reject) {setTimeout(function () { resolve(time) }, time)})}async function test () { let arr = [Gen(2000), Gen(100), Gen(3000)] for (let item of arr) {console.log(Date.now(), item.then(console.log))}}test()// 1560090138232 Promise {}// 1560090138234 Promise {}// 1560090138235 Promise {}// 100// 2000// 3000await 的作用，它可以中断程序的执行直到这个 Promise 对象的状态发生改变，function Gen (time) { return new Promise(function (resolve, reject) {setTimeout(function () { resolve(time) }, time)})}async function test () { let arr = [Gen(2000), Gen(100), Gen(3000)] for (let item of arr) {console.log(Date.now(), await item.then(console.log))}}test()// 2000// 1560091834772 undefined// 100// 1560091836774 undefined// 3000// 1560091836775 undefined从返回值看确实是按照任务的先后顺序进行的，其中原理也有说明是利用了 await 中断程序的功能。不过，在 ES9 中也可以用 for…await…of 的语法来操作： function Gen (time) { return new Promise(function (resolve, reject) {setTimeout(function () { resolve(time) }, time)})}async function test () { let arr = [Gen(2000), Gen(100), Gen(3000)] for await (let item of arr) {console.log(Date.now(), item)}}test()// 1560092345730 2000// 1560092345730 100// 1560092346336 3000  2.Promise.prototype.finally() 　　Promise.prototype.finally() 方法返回一个Promise，在promise执行结束时，无论结果是fulfilled或者是rejected，在执行then()和catch()后，都会执行finally指定的回调函数。这为指定执行完promise后，无论结果是fulfilled还是rejected都需要执行的代码提供了一种方式，避免同样的语句需要在then()和catch()中各写一次的情况。let connection;db.open().then(conn => {connection = conn; return connection.select({ name: 'Jane' });}).then(result => {// Process result // Use `connection` to make more queries})···.catch(error => {// handle errors}).finally(() => {connection.close();});　　 3.Object Rest Spread前面在讲 function 的 Rest & Spread 方法，忘却的同学可以去复习下。在 ES9 新增 Object 的 Rest & Spread 方法，直接看下示例：const input = { a: 1, b: 2}const output = { ...input, c: 3}console.log(output) // {a: 1, b: 2, c: 3}ES10语法  1.JSON.stringify()　　JSON.stringify 在 ES10 修复了对于一些超出范围的 Unicode 展示错误的问题。因为 JSON 都是被编码成 UTF-8，所以遇到 0xD800–0xDFFF 之内的字符会因为无法编码成 UTF-8 进而导致显示错误。在 ES10 它会用转义字符的方式来处理这部分字符而非编码的方式，这样就会正常显示了。JSON.stringify('\u{D800}') === '"\ud800"' // true  2.Array.prototype.flat()　　flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。const newArray = arr.flat(depth) 语法const numbers = [1, 2, [3, 4, [5, 6]]]console.log(numbers.flat())// [1, 2, 3, 4, [5, 6]]此时 flat 的参数没有设置，取默认值 1，也就是说只扁平化向下一级，遇到 [3, 4, [5, 6]] 这个数组会扁平会处理，不会再继续遍历内部的元素是否还有数组const numbers = [1, 2, [3, 4, [5, 6]]]console.log(numbers.flat(2))// [1, 2, 3, 4, 5, 6]3.Array.prototype.flatMap()　　flatMap() 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。从方法的名字上也可以看出来它包含两部分功能一个是 map，一个是 flat（深度为1）。const new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {// 返回新数组的元素}[, thisArg])参数 含义 必选callback 可以生产一个新数组中的元素的函数，可以传三个参数，currentValue,index,array ythisArg 遍历函数this的指向 Nconst numbers = [1, 2, 3]numbers.map(x => [x * 2]) // [[2], [4], [6]]numbers.flatMap(x => [x * 2]) // [2, 4, 6]这个小示例可以简单对比下 map 和 flatMap 的区别。当然还可以看下 MDN 的示例：let arr = ['今天天气不错', '', '早上好']arr.map(s => s.split(''))// [["今", "天", "天", "气", "不", "错"],[""],["早", "上", "好"]]arr.flatMap(s => s.split(''))// ["今", "天", "天", "气", "不", "错", "", "早", "上", "好"]4.String.prototype.trimStart() 　　trimStart() 方法从字符串的开头删除空格，trimLeft()是此方法的别名。let str = ' foo 'console.log(str.length) // 8str = str.trimStart()console.log(str.length) // 55.String.prototype.trimEnd()　　trimEnd() 方法从一个字符串的右端移除空白字符，trimRight 是 trimEnd 的别名。let str = ' foo 'console.log(str.length) // 8str = str.trimEnd()console.log(str.length) // 66.String.prototype.matchAll()matchAll() 方法返回一个包含所有匹配正则表达式及分组捕获结果的迭代器在了解 matchAll 之前，我们回顾下 ES10 之前一共有多少种正则全部遍历的方法。　　1. RegExp.prototype.exec() with /gfunction collectGroup1 (regExp, str) { const matches = [] while (true) {const match = regExp.exec(str) if (match === null) break // Add capture of group 1 to `matches` matches.push(match[1])} return matches}collectGroup1(/"(1*)"/g, "foo" and "bar" and "baz")// [ 'foo', 'bar', 'baz' ]　　2. String.prototype.match() with /g如果用 .match 方法结合 /g 的正则模式，将会把所有的匹配打包成一个数组返回，换句话说所有的捕获被忽略。'abeabd'.match(/(a)b(?=e)/g)// ["ab"]不过如果没有使用 /g 的正则模式，.match 的效果和 RegExp.prototype.exec() 是一致的。　　3. String.prototype.replace()function collectGroup1 (regExp, str) { const matches = [] function replacementFunc (all, first) {matches.push(first)} str.replace(regExp, replacementFunc) return matches}collectGroup1(/"(1*)"/ug, "foo" and "bar" and "baz")// ["foo", "bar", "baz"]现在看下 .matchAll 方法，可以这样做：function collectGroup1 (regExp, str) { let results = [] for (const match of str.matchAll(regExp)) {results.push(match[1])} return results}collectGroup1(/"(1*)"/g, "foo" and "bar" and "baz")// ["foo", "bar", "baz"] 7.Object.fromEntries()方法 Object.fromEntries() 把键值对列表转换为一个对象，这个方法是和 Object.entries() 相对的。Object.fromEntries([['foo', 1], ['bar', 2]])// {foo: 1, bar: 2}示例let obj = { abc: 1, def: 2, ghij: 3 }let res = Object.fromEntries( Object.entries(obj).filter(([ key, val ]) => key.length === 3) .map(([ key, val ]) => [ key, val * 2 ]))console.log(res)// res is { 'abc': 2, 'def': 4 }8.Symbol.prototype.description　　我们知道，Symbol 的描述只被存储在内部的 [[Description]]，没有直接对外暴露，我们只有调用 Symbol 的 toString() 时才可以读取这个属性：const name = Symbol('My name is axuebin')console.log(name.toString()) // Symbol(My name is axuebin)console.log(name) // Symbol(My name is axuebin)console.log(name === 'Symbol(My name is axuebin)') // falseconsole.log(name.toString() === 'Symbol(My name is axuebin)') // true9.Function.prototype.toString()　　toString() 方法返回一个表示当前函数源代码的字符串function hello (msg) { console.log('hello')}console.log(hello.toString())// function hello (msg) {// console.log('hello')// }10.try…catch　　在 ES10 之前我们都是这样捕获异常的：try { // tryCode} catch (err) { // catchCode}在这里 err 是必须的参数，在 ES10 可以省略这个参数：try { console.log('Foobar')} catch { console.error('Bar')}11.BigInt在 ES10 增加了一个数据类型：BigInt，用于处理超过 2^53 的数字。 const aBigInt = 11n;const aNumber = 156;const aBigInt = BigInt(aNumber);aBigInt === 156n // truetypeof aBigInt === bigint // true以上就是在工作中比较常用的es6-es10语法知识点​" ↩

开发者学堂课程【SQL进阶及查询练习：概述模型、对象模型、关系模型】学习笔记，与课程紧密联系，让用户快速学习知识。课程地址：https://developer.aliyun.com/learning/course/36   概述模型、对象模型、关系模型  概念模型对象模型:在java中是domain!!!例如:User、StudentIs aHas a (关联)>1对1>1对多>多对多use a关系模型:在数据座中表!!!当我们要完成一个软件系统时,需要把系统中的实体抽取出来,形成概念模型例如部门、员工都是系统中的实体。概念模型中的实体最终会成为Java中的类、数据库中表实体之间还存在着关系,关系有三种:*1对多:例如每个员工都从属一个部门,而一个部门可以有多个员工,其中员工是多方,而部门是一方*1对1:例如老公和老婆就是一对一的关系,一个老公只能有一个老婆,而一个老婆只能有一个老公*多对多:老师与学生的关系就是多对多,一个老师可以有多个学生,一个学生可以有多个老师。概念模型在Java中成为实体类( avabean)举使用成员变景来完成关系,一般都是双向关联!多对一双向中关联,即员工关联部门,部门也关联员工 class Emp1oyee{//多万关联一刀     ...private Department department:)class Department//-方关联多方...private List<Employee> employees;)class Husband{...private wife wife;)class wife {0405private Hu**and}class Student {...Private list<teacher>  teachers}Class teacher {...Private  list <student> students;}

概述书接上回： 你来说说什么是限流？ ,限流的整体概述中，描述了 限流是什么，限流方式和限流的实现。在文章尾部的 分布式限流,没有做过多的介绍，选择了放到这篇文章中。给大伙细细讲解一下 Sentinel附带最权威的官方wiki： 《Alibaba-Sentinel,新手指南》本篇文章源码地址： https://github.com/jaycekon/SpringBootSentinel 是啥？分布式系统的流量防卫兵再引用一下之前我画的图：流量防卫兵 它具备了哪些能力？Sentinel 的生态环境随着 Alibaba 的 Java 生态建设，包括 Spring Cloud Alibaba，Rocket，Nacos等多项开源技术的贡献，目前 Sentinel 对分布式的各种应用场景都有了良好的支持和适配，这也是为什么我们选择 Sentinel 学习的原因之一（学习成本低，应用场景多）Sentinel 核心概念1、资源资源 是 Sentinel 中的核心概念之一。最常用的资源是我们代码中的 Java 方法,一段代码，或者一个接口。Java方法:@SentinelResource("HelloWorld") public void helloWorld() { // 资源中的逻辑 System.out.println("hello world"); }一段代码： // 1.5.0 版本开始可以直接利用 try-with-resources 特性，自动 exit entry try (Entry entry = SphU.entry("HelloWorld")) { // 被保护的逻辑 System.out.println("hello world"); } catch (BlockException ex) { // 处理被流控的逻辑 System.out.println("blocked!"); }一个接口：@RestController public class TestController { @GetMapping("/test") public String test(){ return "test"; } }配合控制台使用：2、规则Sentinel 中的规则 提供给用户，针对不同的场景而制定不同的保护动作，规则的类型包括：流量控制规则熔断降级规则系统保护规则来源访问控制规则热点参数规则本文主要会讲解 流量，熔断 和系统保护这三个规则。定义规则： private static void initFlowRules(){ List<FlowRule> rules = new ArrayList<>(); FlowRule rule = new FlowRule(); //绑定资源 rule.setResource("HelloWorld"); //限流阈值类型 rule.setGrade(RuleConstant.FLOW_GRADE_QPS); //数量级别 rule.setCount(20); //添加到本地内存 rules.add(rule); FlowRuleManager.loadRules(rules); }限流规则重要属性说明：Field说明默认值resource资源名，资源名是限流规则的作用对象 count限流阈值 grade限流阈值类型，QPS 模式（1）或并发线程数模式（0）QPS 模式limitApp流控针对的调用来源default，代表不区分调用来源strategy调用关系限流策略：直接、链路、关联根据资源本身（直接）controlBehavior流控效果（直接拒绝/WarmUp/匀速+排队等待），不支持按调用关系限流直接拒绝clusterMode是否集群限流否Sentinel 限流1、单机限流1.1、引入依赖在上一篇文章中，有提到过 RateLimiter 实现的单机限流， 这里介绍一下，使用 Sentinel 实现的单机限流//项目中引入 sentinel-core 依赖 <dependency> <groupId>com.alibaba.csp</groupId> <artifactId>sentinel-core</artifactId> <version>1.8.1</version> </dependency>1.2、定义限流规则定义保护规则: private static void initFlowRules(){ List<FlowRule> rules = new ArrayList<>(); FlowRule rule = new FlowRule(); //绑定资源 rule.setResource("HelloWorld"); //限流阈值类型 rule.setGrade(RuleConstant.FLOW_GRADE_QPS); //数量级别 rule.setCount(20); //添加到本地内存 rules.add(rule); FlowRuleManager.loadRules(rules); }1.3、定义限流资源根据上面描述的 资源划分， 我们这里主要将 代码块 定义为资源。public static void main(String[] args) { // 配置规则. initFlowRules(); while (true) { // 1.5.0 版本开始可以直接利用 try-with-resources 特性，自动 exit entry try (Entry entry = SphU.entry("HelloWorld")) { // 被保护的逻辑 System.out.println("hello world"); } catch (BlockException ex) { // 处理被流控的逻辑 System.out.println("blocked!"); } } }1.4、运行结果Demo 运行之后，我们可以在日志 ~/logs/csp/${appName}-metrics.log.xxx 里看到下面的输出:➜ csp cat com-jaycekon-sentinel-demo-FlowRuleDemo-metrics.log.2021-07-03 |--timestamp-|------date time----|-resource-|p |block|s |e|rt 1625294582000|2021-07-03 14:43:02|HelloWorld|20|1720|20|0|2|0|0|0 1625294583000|2021-07-03 14:43:03|HelloWorld|20|5072|20|0|0|0|0|0 1625294584000|2021-07-03 14:43:04|HelloWorld|20|6925|20|0|0|0|0|0p 代表通过的请求block 代表被阻止的请求s 代表成功执行完成的请求个数e 代表用户自定义的异常rt 代表平均响应时长Sentinel 的单机限流 ，和 RateLimiter 有什么区别呢？Field分布式环境下实现难度空间复杂度时间复杂度限制突发流量平滑限流令牌桶高低O(1)高O(N)是是滑动窗口中高O(N)中O(N)是相对实现附录：《Sentinel - 滑动窗口实现原理》2、控制台限流2.1、客户端接入控制台超详细文档，参考：《Sentinel - 控制台》Sentinel 提供一个轻量级的开源控制台，它提供机器发现以及健康情况管理、监控（单机和集群），规则管理和推送的功能。下载Jar 包(21M)，或者下载源码(4M) 后自行进行编译（不建议，编译花的时间比直接下载jar包还要久）https://github.com/alibaba/Sentinel/releases编译后，启动命令java -Dserver.port=8000 -Dcsp.sentinel.dashboard.server=localhost:8000 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.1.jar进入控制台2.2、引入依赖客户端需要引入 Transport 模块来与 Sentinel 控制台进行通信。您可以通过 pom.xml 引入 JAR 包<dependency> <groupId>com.alibaba.csp</groupId> <artifactId>sentinel-transport-simple-http</artifactId> <version>1.8.1</version> </dependency> //重要的依赖，还是提前先写上吧，避免小伙伴找不到了 <dependency> <groupId>com.alibaba.csp</groupId> <artifactId>sentinel-web-servlet</artifactId> <version>1.8.1</version> </dependency> 然后！！！ 烦了我一下午的地方来了！！ 在官方文档中，指出了需要引入对应的依赖配置 , 好家伙，那么重要的话，你如此轻描淡写，脑壳疼啊！！！对应的适配依赖有云原生微服务体系Web 适配RPC 适配HTTP client 适配Reactive 适配Reactive 适配Apache RocketMQ好家伙，基本上所有业务场景都覆盖到了！ 由于我的 Demo 项目是基于 SpringBoot ，然后想看看 云原生微服务体系下的视频，好家伙，要用 SpringCloud , 想要了解的，可以参考: 《Spring-Cloud-Sentinel》2.3、定义资源@SpringBootApplication @Configuration @RestController public class SpringBootSentinelApplication { public static void main(String[] args) { SpringApplication.run(SpringBootSentinelApplication.class, args); } @Bean public FilterRegistrationBean sentinelFilterRegistration() { FilterRegistrationBean<Filter> registration = new FilterRegistrationBean<>(); registration.setFilter(new CommonFilter()); registration.addUrlPatterns("/*"); registration.setName("sentinelFilter"); registration.setOrder(1); return registration; } @RequestMapping("/index") public String index(){ return "hello index"; } }在概述中，我们有提到过，需要被保护的资源，可以是 一个代码块，一个方法或者一个接口。这里通过 Filter 的 方式，将所有请求都定义为资源 （/*）, 那么我们在请求的过程就会变成这样子：2.4、运行结果添加启动参数-Dserver.port=8088 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=jaycekon-sentinel参数说明:server.port : 服务启动端口csp.sentinel.dashboard.server : 状态上报机器ip:端口project.name : 监控项目名称运行结果：2.5、限流配置流控效果1、快速失败：直接失败2、Warm Up：预热模式，根据codeFactory的值（默认3），从阈值/codeFactory，经过预热时长，才达到设置的QPS阈值。比如设置QPS为90，设置预热为10秒，则最初的阈值为90/3=30，经过10秒后才达到90。3、排队等待：比如设置阈值为10，超时时间为500毫秒，当第11个请求到的时候，不会直接报错，而是等待500毫秒，如果之后阈值还是超过10，则才会被限流。运行结果：3、集群限流讲了那么多，终于要到核心的 集群限流方案了， 在秒杀系统设计中，我们谈到很多场景都是以单机作为具体案例进行分析，如果我们的系统要扩容，那么如何做好限流方案。假设集群中有 10 台机器，我们给每台机器设置单机限流阈值为 10 QPS，理想情况下整个集群的限流阈值就为 100 QPS。不过实际情况下流量到每台机器可能会不均匀，会导致总量没有到的情况下某些机器就开始限流。因此仅靠单机维度去限制的话会无法精确地限制总体流量。而集群流控可以精确地控制整个集群的调用总量，结合单机限流兜底，可以更好地发挥流量控制的效果。介绍一下集群限流的核心角色：Token Client：集群流控客户端，用于向所属 Token Server 通信请求 token。集群限流服务端会返回给客户端结果，决定是否限流。Token Server：即集群流控服务端，处理来自 Token Client 的请求，根据配置的集群规则判断是否应该发放 token（是否允许通过）。在嵌入模式下的结构图：在独立模式下的结构图：内嵌模式，即 发Token 的操作，有其中某一个实例完成，其他 Client 通过向 Server 请求，获取访问许可。独立模式，即作为独立的 token server 进程启动，独立部署，隔离性好，但是需要额外的部署操作。3.1、阿里云AHAS在上述示例代码中，使用了本地模式的 Demo, 在集群限流的场景，这里用一下 阿里云提供的 AHAS 服务。控制台地址： https://ahas.console.aliyun.com/index?ns=default&region=public引入依赖：//sentinel ahas 依赖，包括了sentinel的使用依赖 <dependency> <groupId>com.alibaba.csp</groupId> <artifactId>ahas-sentinel-client</artifactId> <version>1.8.8</version> </dependency> 这里有个要注意的点， AHAS 的依赖，包含了 Sentinel ，所需要使用到的依赖，包括 sentinel-core,sentinel-web-servlet和sentinel-transport-simple-http。否则会出现 Spi 异常 , 如果对 Spi 不太了解，建议加群提问，嘿嘿～com.alibaba.csp.sentinel.spi.SpiLoaderException3.2、开启阿里云AHAS 服务这里有官方的开通文档，我就不赘述了，文档地址在应用防护这里找到 Lincense ,然后添加启动参数：-Dserver.port=8092 -Dproject.name=jaycekon-sentinel -Dahas.license=d1e21b0c8f2e4d87b5ac460b118dc58d -Dcsp.sentinel.log.use.pid=true由于我们要本地启动多实例， 因此需要修改服务的多个端口：java -Dserver.port=8090 -Dproject.name=jaycekon-sentinel -Dahas.license=d1e21b0c8f2e4d87b5ac460b118dc58d -Dcsp.sentinel.log.use.pid=true -jar sentinel-ahas-0.0.1-SNAPSHOT.jar java -Dserver.port=8091 -Dproject.name=jaycekon-sentinel -Dahas.license=d1e21b0c8f2e4d87b5ac460b118dc58d -Dcsp.sentinel.log.use.pid=true -jar sentinel-ahas-0.0.1-SNAPSHOT.jar java -Dserver.port=8092 -Dproject.name=jaycekon-sentinel -Dahas.license=d1e21b0c8f2e4d87b5ac460b118dc58d -Dcsp.sentinel.log.use.pid=true -jar sentinel-ahas-0.0.1-SNAPSHOT.jar产生访问流量后，可以在大盘看到机器的链接状态：http://localhost:8092/index3.3、集群流控规则配置这里有个两个概念：集群阀值：指的是，我们集群总体能通过的访问量，可能存在分配不均的情况（能避免单机误限）。退化单机：当 Token Server 访问超时，即无法从远端获取令牌时，回退到单机限流测试限流, 只访问 http://localhost:8092/index通过手刷（手速过硬～），触碰到限流的临界值，然后整体限流跟我们预期一致。退化单机在集群流控这里，有个 Token 请求超时时间，Client 请求 Server ，然后返回数据结果。整个流程会有网络请求的耗时，在上面的测试流程中，我将超时时间调大了，每次请求都能拿到Token， 通过修改请求超时时间，触发退化 单机限流 。运行结果：3.4、Server 角色转换在内嵌模式下，通过 HTTP API的方式，将角色转换为 Server 或 clienthttp://<ip>:<port>/setClusterMode?mode=<xxx>其中 mode 为 0 代表 client，1 代表 server，-1 代表关闭。注意应用端需要引入集群限流客户端或服务端的相应依赖。在独立模式下，我们可以直接创建对应的 ClusterTokenServer 实例并在 main 函数中通过 start 方法启动 Token Server。Sentinel 熔断在秒杀系统 的案例中，一个完整的链路可能包含了 下订单，支付 和物流对接等多个服务（实际上不止那么少）。在一个完整的链路中，各个系统通过 rpc/http的形式进行交互，在下面的链路图中，如果用户选择的 支付方式，存在延时过高，服务不稳定,或服务异常等情况，会导致整个链路没办法完成。最终的结果就是，用户明明抢到了，但是没办法支付，导致订单丢失。现代微服务架构都是分布式的，由非常多的服务组成。不同服务之间相互调用，组成复杂的调用链路。以上的问题在链路调用中会产生放大的效果。复杂链路上的某一环不稳定，就可能会层层级联，最终导致整个链路都不可用。因此我们需要对不稳定的弱依赖服务调用进行熔断降级，暂时切断不稳定调用，避免局部不稳定因素导致整体的雪崩。熔断降级作为保护自身的手段，通常在客户端（调用端）进行配置。1、熔断降级添加测试代码 @RequestMapping("/myError") public String error(){ if (true){ throw new RuntimeException("sentinel run error"); } return "error"; }在 Sentinel-Dashboard 中配置降级规则降级保护效果：用户通过访问接口 /myError , 出现一次异常后，在接下来的10秒 ，都会走降级策略，直接返回。能够很好的保护服务端避免异常过多，占用机器资源。同时快速响应用户请求。2、熔断策略Sentinel 提供以下几种熔断策略：慢调用比例 (SLOW_REQUEST_RATIO)：选择以慢调用比例作为阈值，需要设置允许的慢调用 RT（即最大的响应时间），请求的响应时间大于该值则统计为慢调用。当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。异常比例 (ERROR_RATIO)：当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。异常比率的阈值范围是 [0.0, 1.0]，代表 0% - 100%。异常数 (ERROR_COUNT)：当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。总结本文主要详细讲解了一下 如何通过 Sentinel 去实际接触 限流和熔断，对于限流的底层实现，后续会有专门的源码分析篇。对于熔断，本文也没有细说个究竟，下一篇文章会给大家带来，熔断是什么，在系统中到底是怎么实际使用，以及常见的熔断策略。项目源码地址： https://github.com/jaycekon/SpringBoot 欢迎 Star 和 Fork

2020年初，新冠肺炎疫情爆发。春节后，企业要复产，百姓要复工，政府需尽快保障各项工作有序开展。如何精准防控，统筹疫情期间的各项工作，有序稳健恢复经济社会秩序，成为当务之急。对此，阿里巴巴快速反应，除各种物资支持、政策响应外，还配合多地政府开发健康码，充分运用大数据手段助力疫情防控和复工复产，实现数字化防疫，让政府相关人员更快速、更清晰、更精准地进行防控管理决策。健康码开发期间，SRE团队发挥团队优势，紧急召开专题会议，成立专项应急小组，协调各方资源，并在第一时间赶往各省市，配合相关团队完成资源准备、业务压测、业务优化等工作，保证了多地健康码的顺利上线。健康码上线后，SRE团队持续对各项关键指标数据进行监控，确保健康码应用可以承受业务高峰压力并顺利运作。1 河南健康码——一“码”当先河南省疫情防控指挥部依据《国务院应对新型冠状病毒肺炎疫情联防联控机制关于依法科学精准做好新冠肺炎疫情防控工作的通知》等相关法律法规，结合河南省实际情况，制定“健康码”管理办法。项目3月5日正式启动，按照局方要求3月9日上线投入使用，团队接到通知提前一天3月4日第一个到达现场。团队到现场后，首先梳理资源需求与系统部署架构，提前完成资源开通准备及远程环境准备，以保障其它团队可远程交付。其次评估系统压测目标，并对系统进行多轮多场景压测，压测过程中发现并处置1处业务逻辑问题、3处产品优化、1处APIServer资源瓶颈扩容问题，最终达到压测目标并设置AHAS限流控制保障系统稳定运行。安全方面全部使用https域名证书并接入WAF，对系统安全访问进行加固。运维监控方面接入ARMS、TAC、封神、铜雀等运维监控巡检平台保障系统运行稳定。系统顺利于3月9日18:00正式上线，截至3月15日健康码累计申领人数380W。接下来政府将对全省各市级推广，阿里云SRE团队将继续支持客户保障健康码业务稳定。2 海南健康码——一心战“疫”面对新型冠状病毒肺炎疫情的迅猛爆发，针对海南省精准防控、疫情统筹与经济社会秩序恢复的指导方针，海口市政府与市科工信局等单位立即展开多方协同，要求第一时间上线疫情申报相关应用，即海南省健康一码通应用。这是首个全省健康码应用，政府采取多种方式推广，需要在上线第一周内完成全省900多万市民的注册和使用。由于海口城市大脑云平台资源已经接近饱和，阿里云SRE-TAM团队紧急召开专题会议，迅速成立专项应急小组，与AM团队一起争分夺秒协调海南其他项目组，完成紧急资源释放、扩容及相关并网，并通过全链路压测、资源的提前储备（ECS、SLB）、应用同步改异步（MQ）、数据库读写分离（RDS）以及业务限流（AHAS）等优化手段，为海南健康码保驾护航。健康码准时上线并向全省推广，在此期间阿里云SRE-TAM团队、应用团队以及AM团队联合进行每日的护航保障，通过个性化运维监控方案实现关键资源、核心实例、业务指标等监控，并进行网络相关保障，确保健康码应用可以承受业务高峰压力并顺利运作。截止3月24日，健康码应用注册使用量达到300万+，预计在4月底注册使用量将超过1000万。该系统将有助于更加科学高效地防范疫情，更好地服务广大人民群众安全，为打赢这场全民战役贡献一份力量！图2：海南健康码成果图3 苏州健康码——阿里速度为解决大量外来人口返苏复工的管理难题，提升人员流动效率，苏州市政府、苏州市疫情防控指挥部决定上线苏城码（苏州健康码）。阿里云数字政府华东大区江苏团队和集团GR团队、蚂蚁团队、GTS团队和数据智能团队，从接到需求、立项、进场部署仅仅耗时40小时就完成了“苏城码”上线，这是除浙江省外第一个运用阿里数据引擎短时间完成上线的城市，我们充分运用数字化防疫，为中国最强地级市打造便捷、高效的管理模式！【与时间赛跑，火速拉齐，投入战斗】客户根据本地情况提出了很多定制化开发的需求，面对客户需求，团队快速分析、展开调研、拿出最终方案，客户最终同意将整个系统部署在苏州城市大脑平台上，充分发挥城市大脑在算力、数据融合方面的强大能力。图3：客户现场讨论方案【不眠不休展开部署】确定方案之后，项目团队不眠不休，火速在现场展开各项部署，与时间赛跑。数字政府和支付宝团队项目经理在现场合理组织交付节奏和方案实施。数据智能的精兵强将，现场与客户的各个专班展开对接，确定客户各项需求的实施方案。GTS的交付同学精准实施，从硬件到软件的全维度保证了项目上线。客户对于苏州团队的努力和付出非常感动和认可，苏州市副市长江海同志亲自到现场慰问项目团队，感谢团队成员争分夺秒为苏州全市人民平稳复工复产所做出的努力。图4：市领导慰问现场项目团队【践行客户第一的价值观，组织重保团队力保稳定运行】2020年2月22日晚9:30分，苏州市疫情防控指挥部正式下发第9、10号公告，在全市正式推广“苏城码”。在公告下发之后的2小时之内完成了40万的健康码发码，平台瞬间流量激增，业务平台受到了极大考验，现场GTS同学密切监控、随时排障，苏州城市大脑平台经受住了考验。图5：项目顺利上线为保证项目能够长期稳定可靠地运行，GTS同学快速拉通GOC团队建立项目重保机制，得到客户首肯。江海副市长和李晶处长现场说，只有把业务放在阿里云上才放心！并且表示要把苏城码在城市通行场景方面做有力探索，让苏城码成为苏州市民通行的电子码。与此同时，也有其他政府部门开始思考苏城码与各自业务的结合，比如园林局考虑是否可以把苏城码和园林的进出和电子票进行结合，加强园林的管理和通行效率。“一心战一疫”，“客户第一”！借助苏州健康码项目的火速上线，再次刷新了健康码快速上线的速度，既服务了客户，也激发了团队强大的战斗力，同时为数字政府在苏州乃至江苏的破局打下了坚实的基础！4 上海健康码——健康出行上海“一网通办”依托移动端“随申办”打造的“随申码”于2月17日试点上线。依托上海市大数据资源平台汇聚的国家及本市公共管理机构数据，经过数据建模、分析评估后，测算出红色、黄色、绿色三种风险状态供参考，赋予“随申码”健康出行、防控管理的相关信息。结合新冠肺炎疫情防控的需求，随申码的发码与查码量不断攀升，系统负载不断加大，阿里云GTS团队迅速介入，帮助随申码搭建高可用高可靠系统平台。GTS团队用一个晚上的时间快速确定高并发方案，在确认方案后SRE团队基于阿里云中国政务云平台快速为随申码搭建可扩展的高可用云平台，TM和产品研发团队基于云平台部署定制化的数据智能码引擎，并通过全链路压测、应用弹性扩容、基础架构优化、应用逻辑优化、业务限流（AHAS）等优化手段将随申码的并发承载能力提升百倍以上。2月28日8:00阿里云-随申码平台正式上线，承载的用户并发突破万次每分钟，累计查码量突破一千万次，覆盖上海全部的两千四百万人口，并保持不断的产品迭代，在后续的企业码、亲情码业务中持续给与技术和资源支持。图6：项目人员加班加点保障上海随申码上线我们是阿里云智能全球技术服务-SRE团队，我们致力成为一个以技术为基础、面向服务、保障业务系统高可用的工程师团队；提供专业、体系化的SRE服务，帮助广大客户更好地使用云、基于云构建更加稳定可靠的业务系统，提升业务稳定性。我们期望能够分享更多帮助企业客户上云、用好云，让客户云上业务运行更加稳定可靠的技术，您可用钉钉扫描下方二维码，加入阿里云SRE技术学院钉钉圈子，和更多云上人交流关于云平台的那些事。

直达最佳实践：【容器场景下云原生可观测性最佳实践】最佳实践频道：【最佳实践频道】这里有丰富的企业上云最佳实践，从典型场景入门，提供一系列项目实践方案，降低企业上云门槛的同时满足您的需求！场景描述针对部署在阿里云容器服务Kubernetes的微服务应用，一键式接入覆盖用户体验层、应用层、基础组件层的云原生可观测方案，构建全面的可观测技术体系，帮助客户更好的梳理系统架构，更深入的掌握系统运行状态。在故障以及系统瓶颈场景下，对于客户排查问题效率的提升。方案优势集链路明细、性能统计、拓扑发现于一体，端到端诊断分析；基于开源和业界标准，支持各类开发语言，应用广泛；自定义大盘，快速分析和定位错误，实时报警；阿里云专业技术输出，成本低于自建，与阿里云ECS、容器服务等无缝集成。产品列表容器服务Kubernetes版(ACK)云数据库服务RDS微服务引擎MSE应用高可用服务AHAS应用实时监控服务ARMS业务架构直达最佳实践 》》