hellozhxy
hellozhxy

分布式系统技术点汇总

一个网站就是一个应用，当系统压力较大时，只能横向扩展，增加多个服务器或者多个容器去做负载均衡，避免单点故障而影响到整个系统。

集中式最明显的优点就是开发，测试，运维会比较方便，不用考虑复杂的分布式环境。

弊端也很明显，系统大而复杂、不易扩展、难于维护，每次更新都必须更新所有的应用。

分布式系统技术点汇总_第1张图片

集中式系统拓扑图

鉴于集中式系统的种种弊端，促成了分布式系统的形成，分布式系统背后是由一系列的计算机组成，但用户感知不到背后的逻辑，就像访问单个计算机一样，天然的避免了单机故障的问题。

应用可以按业务类型拆分成多个应用或服务，再按结构分成接口层、服务层。

我们也可以按访问入口分，如移动端、PC 端等定义不同的接口应用。数据库可以按业务类型拆分成多个实例，还可以对单表进行分库分表。同时增加分布式缓存、消息队列、非关系型数据库、搜索等中间件。

分布式系统虽好，但是增加了系统的复杂性，如分布式事务、分布式锁、分布式 Session、数据一致性等都是现在分布式系统中需要解决的难题。

分布式系统也增加了开发测试运维的成本，工作量增加，其管理不好反而会变成一种负担。

分布式系统拓扑图

分布式系统最为核心的要属分布式服务框架，有了分布式服务框架，我们只需关注各自的业务，而无需去关注那些复杂的服务之间调用的过程。

分布式服务框架

目前业界比较流行的分布式服务框架有：阿里的 Dubbo、Spring Cloud。

这里不对这些分布式服务框架做对比，简单的说说他们都做了些什么，能使我们用远程服务就像调用本地服务那么简单高效。

服务

服务是对使用用户有功能输出的模块，以技术框架作为基础，能实现用户的需求。

比如日志记录服务、权限管理服务、后台服务、配置服务、缓存服务、存储服务、消息服务等，这些服务可以灵活的组合在一起，也可以独立运行。

服务需要有接口，与系统进行对接。面向服务的开发，应该是把服务拆分开发，把服务组合运行。

更加直接的例子如：历史详情、留言板、评论、评级服务等。他们之间能独立运行，也要能组合在一起作为一个整体。

注册中心

注册中心对整个分布式系统起着最为核心的整合作用，支持对等集群，需要提供 CRUD 接口，支持订阅发布机制且可靠性要求非常之高，一般拿 Zookeeper 集群来做为注册中心。

分布式环境中服务提供方的服务会在多台服务器上部署，每台服务器会向注册中心提供服务方标识、服务列表、地址、对应端口、序列化协议等信息。

注册中心记录下服务和服务地址的映射关系，一般一个服务会对应多个地址，这个过程我们称之为服务发布或服务注册。

服务调用方会根据服务方标识、服务列表从注册中心获取所需服务的信息(地址端口信息、序列化协议等)，这些信息会缓存至本地。

当服务需要调用其他服务时，直接在这里找到服务的地址，进行调用，这个过程我们称之为服务发现。

分布式系统技术点汇总_第2张图片

注册中心

下面是以 Zookeeper 作为注册中心的简单实现：

 
  1. /** 
  2.      * 创建node节点 
  3.      * @param node 
  4.      * @param data 
  5.      */ 
  6.     public boolean createNode(String node, String data) { 
  7.         try { 
  8.             byte[] bytes = data.getBytes(); 
  9.             //同步创建临时顺序节点 
  10.             String path = zk.create(ZkConstant.ZK_RPC_DATA_PATH+"/"+node+"-", bytes, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); 
  11.             log.info("create zookeeper node ({} => {})", path, data); 
  12.         }catch (KeeperException e) { 
  13.             log.error("", e); 
  14.             return false; 
  15.         }catch (InterruptedException ex){ 
  16.             log.error("", ex); 
  17.             return false; 
  18.         } 
  19.         return true; 
  20.     } 

分布式系统技术点汇总_第3张图片

子节点 1

分布式系统技术点汇总_第4张图片

子节点 2

如下面 Zookeeper 中写入的临时顺序节点信息：

  • com.black.blackrpc.test.HelloWord：发布服务时对外的名称。
  • 00000000010，00000000011：ZK 顺序节点 ID。
  • 127.0.0.1:8888，127.0.0.1:8889：服务地址端口。
  • Protostuff：序列化方式。
  • 1.0：权值，负载均衡策略使用。

这里使用的是 Zookeeper 的临时顺序节点，为什么使用临时顺序节点，主要是考虑以下两点：

  • 当服务提供者异常下线时，与 Zookeeper 的连接会中断，Zookeeper 服务器会主动删除临时节点，同步给服务消费者。

这样就能避免服务消费者去请求异常的服务器。校稿注： 一般消费方也会在实际发起请求前，对当前获取到的服务提供方节点进行心跳，避免请求连接有问题的节点。

  • Zookeeper 下面是不允许创建 2 个名称相同的 ZK 子节点的，通过顺序节点就能避免创建相同的名称。

当然也可以不用顺序节点的方式，直接以 com.black.blackrpc.test.HelloWord 创建节点，在该节点下创建数据节点。

下面是 ZK 的数据同步过程：

 
  1. /** 
  2.      * 同步节点 （通知模式） 
  3.      * syncNodes会通过级联方式，在每次watcher被触发后，就会再挂上新的watcher。完成了类似链式触发的功能 
  4.      */ 
  5.     public boolean syncNodes() { 
  6.         try { 
  7.             List nodeList = zk.getChildren(ZkConstant.ZK_RPC_DATA_PATH, new Watcher() { 
  8.                 @Override 
  9.                 public void process(WatchedEvent event) { 
  10.                     if (event.getType() == Event.EventType.NodeChildrenChanged) { 
  11.                         syncNodes(); 
  12.                     } 
  13.                 } 
  14.             }); 
  15.             Map> map =new HashMap>(); 
  16.             for (String node : nodeList) { 
  17.                 byte[] bytes = zk.getData(ZkConstant.ZK_RPC_DATA_PATH + "/" + node, false, null); 
  18.                 String key =node.substring(0, node.lastIndexOf(ZkConstant.DELIMITED_MARKER)); 
  19.                 String value=new String(bytes); 
  20.                 Object object =map.get(key); 
  21.                 if(object!=null){ 
  22.                     ((List)object).add(value); 
  23.                 }else { 
  24.                     List dataList = new ArrayList(); 
  25.                     dataList.add(value); 
  26.                     map.put(key,dataList); 
  27.                 } 
  28.                 log.info("node: [{}] data: [{}]",node,new String(bytes)); 
  29.             } 
  30.             /**修改连接的地址缓存*/ 
  31.             if(MapUtil.isNotEmpty(map)){ 
  32.                 log.debug("invoking service cache updateing...."); 
  33.                 InvokingServiceCache.updataInvokingServiceMap(map); 
  34.             } 
  35.             return true; 
  36.         } catch (KeeperException | InterruptedException e) { 
  37.             log.error(e.toString()); 
  38.             return false; 
  39.         } 
  40.     } 

当数据同步到本地时，一般会写入到本地文件中，防止因 Zookeeper 集群异常下线而无法获取服务提供者信息。

通讯与协议

服务消费者无论是与注册中心还是与服务提供者，都需要存在网络连接传输数据，而这就涉及到通讯。

笔者之前也做过这方面的工作，当时使用的是 java BIO 简单的写了一个通讯包，使用场景没有多大的并发，阻塞式的 BIO 也未暴露太多问题。

java BIO 因其建立连接之后会阻塞线程等待数据，这种方式必须以一连接一线程的方式，即客户端有连接请求时服务器端就需要启动一个线程进行处理。当连接数过大时，会建立相当多的线程，性能直线下降。

Java NIO：同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 I/O 请求时才启动一个线程进行处理。

Java AIO：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的 I/O 请求都是由 OS 先完成了再通知服务器应用去启动线程进行处理。

BIO、NIO、AIO 适用场景分析:

  • BIO：用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，但程序直观简单易理解。
  • NIO：适用于连接数目多且连接比较短(轻操作)的架构，比如聊天服务器，并发局限于应用中，编程比较复杂。

目前主流的通讯框架 Netty、Apache Mina、Grizzl、NIO Framework 都是基于其实现的。

  • AIO：用于连接数目多且连接比较长(重操作)的架构，比如图片服务器，文件传输等，充分调用 OS 参与并发操作，编程比较复杂。

作为基石的通讯，其实要考虑很多东西。如：丢包粘包的情况，心跳机制，断连重连，消息缓存重发，资源的优雅释放，长连接还是短连接等。

下面是 Netty 建立服务端，客户端的简单实现：

 
  1. import io.netty.bootstrap.ServerBootstrap; 
  2. import io.netty.channel.ChannelInitializer; 
  3. import io.netty.channel.ChannelPipeline; 
  4. import io.netty.channel.EventLoopGroup; 
  5. import io.netty.channel.nio.NioEventLoopGroup; 
  6. import io.netty.channel.socket.SocketChannel; 
  7. import io.netty.channel.socket.nio.NioServerSocketChannel; 
  8. import io.netty.handler.codec.LengthFieldBasedFrameDecoder; 
  9. import io.netty.handler.codec.LengthFieldPrepender; 
  10. import io.netty.handler.codec.bytes.ByteArrayDecoder; 
  11. import io.netty.handler.codec.bytes.ByteArrayEncoder; 
  12. import org.slf4j.Logger; 
  13. import org.slf4j.LoggerFactory; 
  14. /*** 
  15.  * netty tcp 服务端 
  16.  * @author v_wangshiyu 
  17.  * 
  18.  */ 
  19. public class NettyTcpService { 
  20.     private static final Logger log = LoggerFactory.getLogger(NettyTcpService.class); 
  21.     private String host; 
  22.     private int port; 
  23.  
  24.     public NettyTcpService(String address) throws Exception{ 
  25.         String str[] = address.split(":"); 
  26.         this.host=str[0]; 
  27.         this.port=Integer.valueOf(str[1]); 
  28.     } 
  29.  
  30.     public NettyTcpService(String host,int port) throws Exception{ 
  31.         this.host=host; 
  32.         this.port=port; 
  33.     } 
  34.     /**用于分配处理业务线程的线程组个数 */   
  35.     private static final int BIZGROUPSIZE = Runtime.getRuntime().availableProcessors()*2; //默认   
  36.     /** 业务出现线程大小*/   
  37.     private static final int BIZTHREADSIZE = 4;   
  38.     /*  
  39.      * NioEventLoopGroup实际上就是个线程, 
  40.      * NioEventLoopGroup在后台启动了n个NioEventLoop来处理Channel事件,  
  41.      * 每一个NioEventLoop负责处理m个Channel,  
  42.      * NioEventLoopGroup从NioEventLoop数组里挨个取出NioEventLoop来处理Channel 
  43.      */   
  44.     private static final EventLoopGroup bossGroup = new NioEventLoopGroup(BIZGROUPSIZE);   
  45.     private static final EventLoopGroup workerGroup = new NioEventLoopGroup(BIZTHREADSIZE);   
  46.  
  47.     public void start() throws Exception { 
  48.         log.info("Netty Tcp Service Run..."); 
  49.         ServerBootstrap b = new ServerBootstrap();   
  50.         b.group(bossGroup, workerGroup);   
  51.         b.channel(NioServerSocketChannel.class);   
  52.         b.childHandler(new ChannelInitializer() {   
  53.             @Override   
  54.             public void initChannel(SocketChannel ch) throws Exception {   
  55.                 ChannelPipeline pipeline = ch.pipeline();   
  56.                 pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));   
  57.                 pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));   
  58.                 pipeline.addLast("decoder", new ByteArrayDecoder());   
  59.                 pipeline.addLast("encoder", new ByteArrayEncoder());   
  60.               //  pipeline.addLast(new Encoder()); 
  61.               //  pipeline.addLast(new Decoder()); 
  62.                 pipeline.addLast(new TcpServerHandler()); 
  63.             }   
  64.         });   
  65.         b.bind(host, port).sync();   
  66.         log.info("Netty Tcp Service Success!"); 
  67.     }   
  68.     /** 
  69.      * 停止服务并释放资源 
  70.      */ 
  71.     public void shutdown() {   
  72.         workerGroup.shutdownGracefully();   
  73.         bossGroup.shutdownGracefully();   
  74.     } 
  75. }  
  76.  
  77.  
  78. import org.slf4j.Logger; 
  79. import org.slf4j.LoggerFactory; 
  80. import io.netty.channel.ChannelHandlerContext; 
  81. import io.netty.channel.SimpleChannelInboundHandler; 
  82. /** 
  83.  * 服务端处理器 
  84.  */ 
  85. public class TcpServerHandler extends SimpleChannelInboundHandler{ 
  86.     private static final Logger log = LoggerFactory.getLogger(TcpServerHandler.class); 
  87.  
  88.     @Override 
  89.     protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception { 
  90.         byte[] data=(byte[])msg; 
  91.         } 
  92. } 
    93.  
    1. import org.slf4j.Logger; 
    2. import org.slf4j.LoggerFactory; 
    3.  
    4. import io.netty.bootstrap.Bootstrap; 
    5. import io.netty.channel.Channel; 
    6. import io.netty.channel.ChannelInitializer; 
    7. import io.netty.channel.ChannelOption; 
    8. import io.netty.channel.ChannelPipeline; 
    9. import io.netty.channel.EventLoopGroup; 
    10. import io.netty.channel.nio.NioEventLoopGroup; 
    11. import io.netty.channel.socket.nio.NioSocketChannel; 
    12. import io.netty.handler.codec.LengthFieldBasedFrameDecoder; 
    13. import io.netty.handler.codec.LengthFieldPrepender; 
    14. import io.netty.handler.codec.bytes.ByteArrayDecoder; 
    15. import io.netty.handler.codec.bytes.ByteArrayEncoder; 
    16. import io.netty.util.concurrent.Future; 
    17. /** 
    18.  * netty tcp 客户端 
    19.  * @author v_wangshiyu 
    20.  * 
    21.  */ 
    22. public class NettyTcpClient { 
    23.     private static final Logger log = LoggerFactory.getLogger(NettyTcpClient.class); 
    24.     private String host;   
    25.     private int port;   
    26.     private Bootstrap bootstrap;   
    27.     private Channel channel; 
    28.     private EventLoopGroup group; 
    29.  
    30.     public NettyTcpClient(String host,int port){ 
    31.         bootstrap=getBootstrap(); 
    32.         channel= getChannel(host,port); 
    33.         this.host=host; 
    34.         this.port=port; 
    35.     } 
    36.  
    37.     public String getHost() { 
    38.         return host; 
    39.     } 
    40.  
    41.     public int getPort() { 
    42.         return port; 
    43.     } 
    44.  
    45.     /**  
    46.      * 初始化Bootstrap  
    47.      * @return  
    48.      */   
    49.     public final Bootstrap getBootstrap(){   
    50.         group = new NioEventLoopGroup();   
    51.         Bootstrap b = new Bootstrap();   
    52.         b.group(group).channel(NioSocketChannel.class);   
    53.         b.handler(new ChannelInitializer() {   
    54.             @Override   
    55.             protected void initChannel(Channel ch) throws Exception {   
    56.                 ChannelPipeline pipeline = ch.pipeline();   
    57.                  // pipeline.addLast(new Encoder()); 
    58.                  // pipeline.addLast(new Decoder()); 
    59.                 pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));   
    60.                 pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));   
    61.                 pipeline.addLast("decoder", new ByteArrayDecoder());   
    62.                 pipeline.addLast("encoder", new ByteArrayEncoder());   
    63.  
    64.                 pipeline.addLast("handler", new TcpClientHandler()); 
    65.             }   
    66.         });   
    67.         b.option(ChannelOption.SO_KEEPALIVE, true);   
    68.         return b;   
    69.     }   
    70.  
    71.     /** 
    72.      * 连接，获取Channel 
    73.      * @param host 
    74.      * @param port 
    75.      * @return 
    76.      */ 
    77.     public final Channel getChannel(String host,int port){   
    78.         Channel channel = null;   
    79.         try {   
    80.             channel = bootstrap.connect(host, port).sync().channel();   
    81.             return channel; 
    82.         } catch (Exception e) {   
    83.             log.info(String.format("connect Server(IP[%s],PORT[%s]) fail!", host,port));   
    84.             return null;   
    85.         } 
    86.     }   
    87.  
    88.     /** 
    89.      * 发送消息 
    90.      * @param msg 
    91.      * @throws Exception 
    92.      */ 
    93.     public boolean sendMsg(Object msg) throws Exception {   
    94.         if(channel!=null){ 
    95.             channel.writeAndFlush(msg).sync();   
    96.             log.debug("msg flush success"); 
    97.             return true; 
    98.         }else{   
    99.             log.debug("msg flush fail,connect is null"); 
    100.             return false; 
    101.         }   
    102.     } 
    103.  
    104.     /** 
    105.      * 连接断开 
    106.      * 并且释放资源 
    107.      * @return 
    108.      */ 
    109.     public boolean disconnectConnect(){ 
    110.         //channel.close().awaitUninterruptibly(); 
    111.         Future future =group.shutdownGracefully();//shutdownGracefully释放所有资源，并且关闭所有当前正在使用的channel 
    112.         future.syncUninterruptibly(); 
    113.         return true; 
    114.     } 
    115. } 
    116.  
    117. import org.slf4j.Logger; 
    118. import org.slf4j.LoggerFactory; 
    119. import io.netty.channel.ChannelHandlerContext; 
    120. import io.netty.channel.SimpleChannelInboundHandler; 
    121. /** 
    122.  * 客户端处理器 
    123.  */ 
    124. public class TcpClientHandler extends SimpleChannelInboundHandler{ 
    125.     private static final Logger log = LoggerFactory.getLogger(TcpClientHandler.class); 
    126.     @Override 
    127.     protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception { 
    128.         byte[] data=(byte[])msg; 
    129.     } 
    130. } 

      131. 说到通讯就不能不说协议，通信时所遵守的规则，访问什么，传输的格式等都属于协议。

      作为一个开发人员，应该都了解 TCP/IP 协议，它是一个网络通信模型，以及一整套网络传输协议家族，是互联网的基础通信架构。

      也都应该用过 Http(超文本传输协议)，Web 服务器传输超文本到本地浏览器的传送协议，该协议建立在 TCP/IP 协议之上。分布式服务框架服务间的调用也会规定协议。

      为了支持不同场景，分布式服务框架会存在多种协议，如 Dubbo 就支持 7 种协议：Dubbo 协议(默认)，RMI 协议，Hessian协议，HTTP 协议，WebService 协议，Thrift 协议，Memcached 协议，Redis 协议每种协议应对的场景不尽相同，具体场景具体对待。

      服务路由

      分布式服务上线时都是集群组网部署，集群中会存在某个服务的多实例，消费者如何从服务列表中选择合适的服务提供者进行调用，这就涉及到服务路由。分布式服务框架需要能够满足用户灵活的路由需求。

      透明化路由

      很多开源的 RPC 框架调用者需要配置服务提供者的地址信息，尽管可以通过读取数据库的服务地址列表等方式避免硬编码地址信息，但是消费者依然要感知服务提供者的地址信息，这违反了透明化路由原则。

      基于服务注册中心的服务订阅发布，消费者通过主动查询和被动通知的方式获取服务提供者的地址信息，而不再需要通过硬编码方式得到提供者的地址信息。

      只需要知道当前系统发布了那些服务，而不需要知道服务具体存在于什么位置，这就是透明化路由。  

      负载均衡

      负载均衡策略是服务的重要属性，分布式服务框架通常会提供多种负载均衡策略，同时支持用户扩展负载均衡策略。

      随机

      通常在对等集群组网中，采用随机算法进行负载均衡，随机路由算法消息分发还是比较均匀的，采用 JDK 提供的 java.util.Random 或者 java.security.SecureRandom 在指定服务提供者列表中生成随机地址。

      消费者基于随机生成的服务提供者地址进行远程调用：

       
      1. /** 
      2.  * 随机 
      3.  */ 
      4. public class RandomStrategy implements ClusterStrategy { 
      5.     @Override 
      6.     public RemoteServiceBase select(List list) { 
      7.         int MAX_LEN = list.size(); 
      8.         int index = RandomUtil.nextInt(MAX_LEN); 
      9.         return list.get(index); 
      10.     } 
      11. } 

      随机还是存在缺点的，可能出现部分节点的碰撞的概率较高，另外硬件配置差异较大时，会导致各节点负载不均匀。

      为避免这些问题，需要对服务列表加权，性能好的机器接收的请求的概率应该高于一般机器：

       
      1. /** 
      2.  * 加权随机 
      3.  */ 
      4. public class WeightingRandomStrategy implements ClusterStrategy { 
      5.     @Override 
      6.     public RemoteServiceBase select(List list) { 
      7.          //存放加权后的服务提供者列表 
      8.         List weightingList = new ArrayList(); 
      9.         for (RemoteServiceBase remoteServiceBase : list) { 
      10.             //扩大10倍 
      11.             int weight = (int) (remoteServiceBase.getWeight()*10); 
      12.             for (int i = 0; i < weight; i++) { 
      13.                 weightingList.add(remoteServiceBase); 
      14.             } 
      15.         } 
      16.         int MAX_LEN = weightingList.size(); 
      17.         int index = RandomUtil.nextInt(MAX_LEN); 
      18.         return weightingList.get(index); 
      19.     } 
      20. } 

      轮询

      逐个请求服务地址，到达边界之后，继续绕接。主要缺点：慢的提供者会累积请求。

      例如第二台机器很慢，但没挂。当请求第二台机器时被卡在那。久而久之，所有请求都卡在第二台机器上。

      轮询策略实现非常简单，顺序循环遍历服务提供者列表，达到边界之后重新归零开始，继续顺序循环：

       
      1. /** 
      2.  * 轮询 
      3.  */ 
      4. public class PollingStrategy implements ClusterStrategy { 
      5.     //计数器 
      6.     private int index = 0; 
      7.     private Lock lock = new ReentrantLock(); 
      8.     @Override 
      9.     public RemoteServiceBase select(List list) { 
      10.         RemoteServiceBase service = null; 
      11.             try { 
      12.                 lock.tryLock(10, TimeUnit.MILLISECONDS); 
      13.                 //若计数大于服务提供者个数,将计数器归0 
      14.                 if (index >= list.size()) { 
      15.                     index = 0; 
      16.                 } 
      17.                 service = list.get(index); 
      18.                 index++; 
      19.             } catch (InterruptedException e) { 
      20.                 e.printStackTrace(); 
      21.             } finally { 
      22.                 lock.unlock(); 
      23.             } 
      24.           //兜底,保证程序健壮性,若未取到服务,则直接取第一个 
      25.             if (service == null) { 
      26.                 service = list.get(0); 
      27.             }        
      28.         return service; 
      29.     } 
      30. } 

      加权轮询的话，需要给服务地址添加权重：

       
      1. /** 
      2.  * 加权轮询 
      3.  */ 
      4. public class WeightingPollingStrategy implements ClusterStrategy { 
      5.     //计数器 
      6.     private int index = 0; 
      7.     //计数器锁 
      8.     private Lock lock = new ReentrantLock(); 
      9.     @Override 
      10.     public RemoteServiceBase select(List list) { 
      11.         RemoteServiceBase service = null; 
      12.         try { 
      13.             lock.tryLock(10, TimeUnit.MILLISECONDS); 
      14.             //存放加权后的服务提供者列表 
      15.             List weightingList = new ArrayList(); 
      16.             for (RemoteServiceBase remoteServiceBase : list) { 
      17.                 //扩大10倍 
      18.                 int weight = (int) (remoteServiceBase.getWeight()*10); 
      19.                 for (int i = 0; i < weight; i++) { 
      20.                     weightingList.add(remoteServiceBase); 
      21.                 } 
      22.             } 
      23.             //若计数大于服务提供者个数,将计数器归0 
      24.             if (index >= weightingList.size()) { 
      25.                 index = 0; 
      26.             } 
      27.             service = weightingList.get(index); 
      28.             index++; 
      29.             return service; 
      30.  
      31.         } catch (InterruptedException e) { 
      32.             e.printStackTrace(); 
      33.         } finally { 
      34.             lock.unlock(); 
      35.         } 
      36.         //兜底,保证程序健壮性,若未取到服务,则直接取第一个 
      37.         return list.get(0); 
      38.     } 
      39. } 

      服务调用时延

      消费者缓存所有服务提供者的调用时延，周期性的计算服务调用平均时延。

      然后计算每个服务提供者服务调用时延与平均时延的差值，根据差值大小动态调整权重，保证服务时延大的服务提供者接收更少的消息，防止消息堆积。

      该策略的特点：保证处理能力强的服务接受更多的消息，通过动态的权重分配消除服务调用时延的震荡范围，使所有服务的调用时延接近平均值，实现负载均衡。

      一致性哈希

      相同参数的请求总是发送到统一服务提供者，当某一台服务提供者宕机时，原本发往根提供者的请求，基于虚拟节点，平摊到其他提供者，不会引起剧烈变动，平台提供默认的虚拟节点数，可以通过配置文件修改虚拟节点个数。

      一致性 Hash 环工作原理如下图所示：

      分布式系统技术点汇总_第5张图片

      一致性哈希

      路由规则

      负载均衡只能保证服务提供者压力的平衡，但是在一些业务场景中需要设置一些过滤规则，比较常用的是基本表达式的条件路由。

      通过 IP 条件表达式配置黑白名单访问控制：consumerIP != 192.168.1.1。

      只暴露部分服务提供者，防止这个集群服务都被冲垮，导致其他服务也不可用。

       
      1. 例如providerIP = 192.168.3*。  
      2. 读写分离：method=find*,list*,get*,query*=>providerIP=192.168.1.。  
      3. 前后台分离：app=web=>providerIP=192.168.1.,app=java=>providerIP=192.168.2.。  
      4. 灰度升级：将WEB前台应用理由到新的服务版本上：app=web=>provicerIP=192.168.1.*。 

      序列化与反序列化

      把对象转换为字节序列的过程称为序列化，把字节序列恢复为对象的过程称为反序列化。

      运程调用的时候，我们需要先将 Java 对象进行序列化，然后通过网络，IO 进行传输，当到达目的地之后，再进行反序列化获取到我们想要的结果对象。

      分布式系统中，传输的对象会很多，这就要求序列化速度快，产生字节序列小的序列化技术。

      序列化技术：Serializable，XML，Jackson，MessagePack，FastJson，Protocol Buffer，Thrift，Gson，Avro，Hessian 等。

      Serializable 是 Java 自带的序列化技术，无法跨平台，序列化和反序列化的速度相对较慢。

      XML 技术多平台支持好，常用于与银行交互的报文，但是其字节序列产生较大，不太适合用作分布式通讯框架。

      FastJson 是 Java 语言编写的高性能的 JSON 处理器，由阿里巴巴公司开发，字节序列为 json 串，可读性好，序列化也速度非常的快。

      Protocol Buffer 序列化速度非常快，字节序列较小，但是可读性较差。

      一般分布式服务框架会内置多种序列化协议可供选择，如 Dubbo 支持的 7 种协议用到的序列化技术就不完全相同。

      服务调用

      本地环境下，使用某个接口很简单，直接调用就行。分布式环境下就不是那么简单了，消费者方只会存在接口的定义，没有具体的实现。

      想要像本地环境下直接调用远程接口那就得耗费一些功夫了，需要用到远程代理。

      下面是我盗的图：

      分布式系统技术点汇总_第6张图片

      远程代理

      通信时序如下：

      分布式系统技术点汇总_第7张图片

      通信时序

      消费者端没有具体的实现，需要调用接口时动态的去创建一个代理类。与 Spirng 集成的情况，那直接在 Bean 构建的时候注入代理类。

      下面是构建代理类：

       
      1. import java.lang.reflect.Proxy; 
      2. public class JdkProxy { 
      3.     public static Object getInstance(Class cls){        
      4.         JdkMethodProxy invocationHandler = new JdkMethodProxy(); 
      5.         Object newProxyInstance = Proxy.newProxyInstance(   
      6.                 cls.getClassLoader(),   
      7.                 new Class[] { cls },  
      8.                 invocationHandler);  
      9.         return (Object)newProxyInstance; 
      10.     } 
      11. } 
       
      1. import java.lang.reflect.InvocationHandler; 
      2. import java.lang.reflect.Method; 
      3.  
      4. public class JdkMethodProxy implements InvocationHandler { 
      5.  
      6.     @Override 
      7.     public Object invoke(Object proxy, Method method, Object[] parameters)  throws Throwable {         
      8.         //如果传进来是一个已实现的具体类 
      9.         if (Object.class.equals(method.getDeclaringClass())) {   
      10.             try {   
      11.                 return method.invoke(this, parameters);   
      12.             } catch (Throwable t) {   
      13.                 t.printStackTrace();   
      14.             }   
      15.         //如果传进来的是一个接口 
      16.         } else {   
      17.             //实现接口的核心方法  
      18.             //return RemoteInvoking.invoking(serviceName, serializationType, //timeOut,loadBalanceStrategy,method, parameters); 
      19.         }   
      20.         return null; 
      21.     } 
      22. } 

      代理会做很多事情，对请求服务的名称及参数信息的序列化、通过路由选择最为合适服务提供者、建立通讯连接发送请求信息(或者直接发起 Http 请求)、最后返回获取到的结果。

      当然这里面需要考虑很多问题，如调用超时，请求异常，通讯连接的缓存，同步服务调用还是异步服务调用等等。

      同步服务调用：客户端发起远程服务调用请求，用户线程完成消息序列化之后，将消息投递到通信框架，然后同步阻塞，等待通信线程发送请求并接收到应答之后，唤醒同步等待的用户线程，用户线程获取到应答之后返回。

      异步服务调用：基于 Java 的 Future 机制，客户端发起远程服务调用请求，该请求会被标上 RequestId，同时建立一个与 RequestId 对应的 Future，客户端通过 Future 的 Get 方法获取结果时会被阻塞。

      服务端收到请求应达会回传 RequestId，通过 RequestId 去解除对应 Future 的阻塞，同时 Set 对应结果，最后客户端获取到结果。

      构建 Future，以 RequestId 为 Key，Put 到线程安全的 Map 中。Get 结果时需要写入 Time Out 超时时间，防止由于结果的未返回而导致的长时间的阻塞。

       
      1. SyncFuture syncFuture =new SyncFuture(); 
      2. SyncFutureCatch.syncFutureMap.put(rpcRequest.getRequestId(), syncFuture); 
      3. try { 
      4.     RpcResponse rpcResponse= syncFuture.get(timeOut,TimeUnit.MILLISECONDS);     return rpcResponse.getResult(); 
      5. }catch (Exception e){ 
      6.     throw e; 
      7. }finally { 
      8.     SyncFutureCatch.syncFutureMap.remove(rpcRequest.getRequestId()); 
      9. } 

      结果返回时通过回传的 RequestId 获取对应 Future 写入 Response，Future 线程解除阻塞：

       
      1. log.debug("Tcp Client receive head："+headAnalysis+"Tcp Client receive data：" +rpcResponse); 
      2. SyncFuture syncFuture= SyncFutureCatch.syncFutureMap.get(rpcResponse.getRequestId()); 
      3. if(syncFuture!=null){ 
      4.         syncFuture.setResponse(rpcResponse); 
      5. } 
       
      1. import java.util.concurrent.CountDownLatch; 
      2. import java.util.concurrent.Future; 
      3. import java.util.concurrent.TimeUnit; 
      4.  
      5. public class SyncFuture implements Future { 
      6.     // 因为请求和响应是一一对应的，因此初始化CountDownLatch值为1。 
      7.     private CountDownLatch latch = new CountDownLatch(1); 
      8.     // 需要响应线程设置的响应结果 
      9.     private T response; 
      10.     // Futrue的请求时间，用于计算Future是否超时 
      11.     private long beginTime = System.currentTimeMillis(); 
      12.     public SyncFuture() { 
      13.     } 
      14.     @Override 
      15.     public boolean cancel(boolean mayInterruptIfRunning) { 
      16.         return false; 
      17.     } 
      18.     @Override 
      19.     public boolean isCancelled() { 
      20.         return false; 
      21.     } 
      22.     @Override 
      23.     public boolean isDone() { 
      24.         if (response != null) { 
      25.             return true; 
      26.         } 
      27.         return false; 
      28.     } 
      29.     // 获取响应结果，直到有结果才返回。 
      30.     @Override 
      31.     public T get() throws InterruptedException { 
      32.         latch.await(); 
      33.         return this.response; 
      34.     } 
      35.     // 获取响应结果，直到有结果或者超过指定时间就返回。 
      36.     @Override 
      37.     public T get(long timeOut, TimeUnit unit) throws InterruptedException { 
      38.         if (latch.await(timeOut, unit)) { 
      39.             return this.response; 
      40.         } 
      41.         return null; 
      42.     } 
      43.     // 用于设置响应结果，并且做countDown操作，通知请求线程 
      44.     public void setResponse(T response) { 
      45.         this.response = response; 
      46.         latch.countDown(); 
      47.     } 
      48.     public long getBeginTime() { 
      49.         return beginTime; 
      50.     } 
      51. } 
       
      1. SyncFuture syncFuture =new SyncFuture(); 
      2. SyncFutureCatch.syncFutureMap.put(rpcRequest.getRequestId(), syncFuture); 
      3. RpcResponse rpcResponse= syncFuture.get(timeOut,TimeUnit.MILLISECONDS); 
      4. SyncFutureCatch.syncFutureMap.remove(rpcRequest.getRequestId()); 

      除了同步服务调用，异步服务调用，还有并行服务调用，泛化调用等调用形式。

      高可用

      简单的介绍了下分布式服务框架，下面来说下分布式系统的高可用。一个系统设计开发出来，三天两晚就出个大问题，导致无法使用，那这个系统也不是什么好系统。

      业界流传一句话："我们系统支持 X 个 9 的可靠性"。这个 X 是代表一个数字，X 个 9 表示在系统 1 年时间的使用过程中，系统可以正常使用时间与总时间(1 年)之比。

      3 个 9：(1-99.9%)*365*24=8.76 小时，表示该系统在连续运行 1 年时间里最多可能的业务中断时间是 8.76 小时，4 个 9 即 52.6 分钟，5 个 9 即 5.26 分钟。要做到如此高的可靠性，是非常大的挑战。

      一个大型分布式项目可能是由几十上百个项目构成，涉及到的服务成千上万，主链上的一个流程就需要流转多个团队维护的项目。

      拿 4 个 9 的可靠性来说，平摊到每个团队的时间可能不到 10 分钟。这 10 分钟内需要顶住压力，以最快的时间找到并解决问题，恢复系统的可用。

      下面说说为了提高系统的可靠性都有哪些方案：

      服务检测：某台服务器与注册中心的连接中断，其提供的服务也无响应时，系统应该能主动去重启该服务，使其能正常对外提供。

      故障隔离：集群环境下，某台服务器能对外提供服务，但是因为其他原因，请求结果始终异常。

      这时就需要主动将该节点从集群环境中剔除，避免继续对后面的请求造成影响，非高峰时期再尝试修复该问题。至于机房故障的情况，只能去屏蔽整个机房了。

      目前饿了么做的是异地多活，即便单边机房挂了，流量也可以全量切换至另外一边机房，保证系统的可用。

      监控：包含业务监控、服务异常监控、DB 中间件性能的监控等，系统出现异常的时候能及时的通知到开发人员。等到线下报上来的时候，可能影响已经很大了。

      压测：产线主链路的压测是必不可少的，单靠集成测试，有些高并发的场景是无法覆盖到的，压测能暴露平常情况无法出现的问题，也能直观的提现系统的吞吐能力。当业务激增时，可以考虑直接做系统扩容。

      SOP 方案与演练：产线上随时都可能会发生问题，抱着出现问题时再想办法解决的态度是肯定不行的，时间根本来不及。

      提前做好对应问题的 SOP 方案，能节省大量时间，尽快的恢复系统的正常。当然平常的演练也是不可少的，一旦产线故障可以做到从容不迫的去应对和处理。

      除了上述方案外，还可以考虑服务策略的使用：

      降级策略：业务高峰期，为了保证核心服务，需要停掉一些不太重要的业务。

      如双十一期间不允许发起退款、只允许查看 3 个月之内的历史订单等业务的降级，调用服务接口时，直接返回的空结果或异常等服务的降级，都属于分布式系统的降级策略。

      服务降级是可逆操作，当系统压力恢复到一定值不需要降级服务时，需要去除降级，将服务状态恢复正常。

      服务降级主要包括屏蔽降级和容错降级：

      • 屏蔽降级：分布式服务框架直接屏蔽对远程接口的请求，不发起对远程服务的调用，直接返回空结果、抛出指定异常、执行本地模拟接口实现等方式。
      • 容错降级：非核心服务不可调用时，可以对故障服务做业务放通，保证主流程不受影响。如请求超时、消息解码异常、系统拥塞保护异常， 服务提供方系统异常等情况。

      笔者之前就碰到过因双方没有做容错降级导致的系统故障的情况。午高峰时期，对方调用我们的一个非核心查询接口，我们系统因为 Bug 问题一直异常，导致对方调用这个接口的页面异常而无法跳转到主流程页面，影响了产线的生产。当时对方紧急发版才使系统恢复正常。

      限流策略：说到限流，最先想到的就是秒杀活动了，一场秒杀活动的流量可能是正常流量的几百至几千倍，如此高的流量系统根本无法处理，只能通过限流来避免系统的崩溃。

      服务的限流本质和秒杀活动的限流是一样的，都是限制请求的流入，防止服务提供方因大量的请求而崩溃。

      限流算法：令牌桶、漏桶、计数器算法。上述算法适合单机的限流，但涉及到整个集群的限流时，得考虑使用缓存中间件了。

      例如：某个服务 1 分钟内只允许请求 2 次，或者一天只允许使用 1000 次。

      由于负载均衡存在，可能集群内每台机器都会收到请求，这种时候就需要缓存来记录调用方某段时间内的请求次数，再做限流处理。Redis 就很适合做此事。

      熔断策略：熔断本质上是一种过载保护机制，这一概念来源于电子工程中的断路器，当电流过大时，保险丝会熔断，从而保护整个电路。

      同样在分布式系统中，当被调用的远程服务无法使用时，如果没有过载保护，就会导致请求的资源阻塞在远程服务器上耗尽资源。

      很多时候，刚开始可能只是出现了局部小规模的故障，然而由于种种原因，故障影响范围越来越大，最终导致全局性的后果。

      当下游服务因访问压力过大而响应变慢或失败，上游服务为了保护自己以及系统整体的可用性，可以暂时切断对下游服务的调用。

      熔断器的设计思路：

      • Closed：初始状态，熔断器关闭，正常提供服务。
      • Open: 失败次数，失败百分比达到一定的阈值之后，熔断器打开，停止访问服务。
      • Half-Open：熔断一定时间之后，小流量尝试调用服务，如果成功则恢复，熔断器变为 Closed 状态。

      数据一致性

      一个系统设计开发出来，必须保证其运行的数据准确和一致性。拿支付系统来说：用户银行卡已经扣款成功，系统里却显示失败，没有给用户的虚拟帐户充值上，这会引起客诉。

      说的再严重点，用户发起提现，资金已经转到其银行账户，系统却没扣除对应虚拟帐号的余额，直接导致资金损失了。如果这时候用户一直发起提现，那就酸爽了。

      CAP 原则

      说到数据一致性，就不得不说到 CAP 原则。CAP 原则中指出任何一个分布式系统中，Consistency(一致性 C)、 Availability(可用性 A)、Partition tolerance(分区容错性 P)，三者不可兼得。

      传统单机数据库基于 ACID 特性(原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation)、持久性(Durability)) ，放弃了分区容错性，能做到可用性和一致性。

      对于一个分布式系统而言，分区容错性是一个最基本的要求。既然是一个分布式系统，那么分布式系统中的组件必然需要被部署到不同的节点，会出现节点与节点之间的网络通讯。

      而网络问题又是一定会出现的异常情况，分区容错性也就成为了一个分布式系统必然需要面对和解决的问题。

      系统架构师往往需要把精力花在如何根据业务特点在一致性和可用性之间寻求平衡。

      集中式系统，通过数据库事务的控制，能做到数据的强一致性。但是分布式系统中，涉及多服务间的调用，通过分布式事务的方案：

      • 两阶段提交(2PC)
      • 三阶段提交(3PC)
      • 补偿事务(TCC)
      • ...

      虽然能实现数据的强一致，但是都是通过牺牲可用性来实现。

      BASE 理论

      BASE 理论是对 CAP 原则中一致性和可用性权衡的结果：Basically Available(基本可用)、Soft state(软状态)和 Eventually consistent(最终一致性)。

      BASE 理论，其来源于对大规模互联网系统分布式实践的总结，是基于 CAP 原则逐步演化而来的。

      其最核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。

      基本可用：是指分布式系统在出现不可预知故障的时候，允许损失部分可用性，这不等价于系统不可用。

      软状态：指允许系统中的数据存在中间状态，并认为该中间状态的存在不会影响系统的整体可用性，即允许系统在不同节点的数据副本之间进行数据同步的过程存在延时。

      最终一致性：强调的是所有的数据副本，在经过一段时间的同步之后，最终都能够达到一致的状态。

      因此，最终一致性的本质是需要系统保证最终数据能够达到一致，而不需要实时保证系统数据的强一致性。

      总的来说，BASE 理论面向的是大型高可用可扩展的分布式系统，和传统的事物 ACID 特性是相反的。

      它完全不同于 ACID 的强一致性模型，而是通过牺牲强一致性来获得可用性，并允许数据在一段时间内是不一致的，但最终达到一致状态。

      同时，在实际的分布式场景中，不同业务单元和组件对数据一致性的要求是不同的，因此在具体的分布式系统架构设计过程中，ACID 特性和 BASE 理论往往又会结合在一起。

      结语

      分布式系统涉及到的东西还有很多，如：分布式锁、定时调度、数据分片、性能问题、各种中间件的使用等，笔者分享只是了解到的那一小部分的知识而已。

      之前本着学习的目的也写过一个非常简单的分布式服务框架 blackRpc，通过它了解了分布式服务框架内部的一些活动。

      本文中所有代码都能在该项目中找到，有兴趣读者可以看看：

       
      1. https://github.com/wangshiyu/blackRpc 

      你可能感兴趣的:(架构设计)

      • 系统架构设计师 需求分析篇二 AmHardy 软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML
        面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
      • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
        一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
      • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
        一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
      • 信息系统安全相关概念(上) YuanDaima2048 课程笔记基础概念安全信息安全笔记
        文章总览：YuanDaiMa2048博客文章总览下篇:信息系统安全相关概念(下)信息系统安全相关概念[上]信息系统概述信息系统信息系统架构信息系统发展趋势：信息系统日趋大型化、复杂化信息系统面临的安全威胁信息系统安全架构设计--以云计算为例信息系统安全需求及安全策略自主访问控制策略DAC强制访问控制策略MAC信息系统概述信息系统用于收集、存储和处理数据以及传递信息、知识和数字产品的一组集成组件。几
      • Kafka 基础与架构理解 StaticKing KAFKAkafka
        目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
      • 以太坊DApp开发指南 Kirn
        DApp架构设计DApp架构.png如上图，DApp的架构我们可以简单分为以上三种类型：轻钱包模式、重钱包模式和兼容模式。轻钱包模式轻钱包模式下我们需要有一个开放HttpRPC协议的节点与钱包通信，这个节点可以是任意链上的节点。轻钱包通常会作为一个浏览器插件存在，插件在运行时会自动注入Web3框架，DApp可以通过Web3与区块链节点通信。当DApp只是单纯的获取数据时是不需要钱包介入的，但是当D
      • 系统架构设计师教程 第5章 5.3 系统分析与设计 笔记 z2014z 系统架构设计师系统架构笔记
        5.3系统分析与设计系统分析阶段把复杂的对象分解为简单的组成部分，其基本任务是在充分了解用户需求的基础上，书写系统需求规格说明书。系统设计是根据系统分析的结果，完成系统的构建过程。其主要目的是绘制系统的蓝图，权衡和比较各种技术和实施方法的利弊，合理分配各种资源，构建新系统的详细设计方案和相关模型，指导系统实施工作的顺利开展。系统设计的主要内容包括概要设计和详细设计。5.3.1结构化方法★★★★★针
      • 新零售SaaS架构：客户管理系统的应用架构设计 公众号-架构师汤师爷 SaaS架构零售架构系统架构后端java
        客户管理系统的应用架构设计应用层定义了软件系统的应用功能，负责接收用户的请求，协调领域层能力来执行任务，并将结果返回给用户，功能模块包括：客户管理：核心功能模块，负责收集和更新客户信息，包括个人资料、联系方式、消费习惯、会员卡、归属信息（比如销售或顾问）和备注。这个模块是CRM系统的基础，支撑其他模块的运作，提供详细的客户信息，帮助企业更好的理解和服务客户。客户标签：通过对客户进行标签化管理，实现
      • 一文搞懂应用架构的3个核心概念 公众号-架构师汤师爷 后端架构设计JavaSaaS
        如果你是一名业务开发，你可能要说，我整天就是做CRUD（增删改查），哪里需要了解什么应用架构设计？经常有人说，程序员35岁之后很容易陷入瓶颈，被行业淘汰，我觉得原因其实就在此。有些朋友在写代码的时候，可能没有太多考虑非功能性的需求、扩展性，只是完成功能，觉得能用就好。做事情的时候，也没有长远的规划，只是把眼前的事情做好就满足了。我面试过很多大龄候选人，他们的简历长达十几页，项目经历有几十个。然而，
      • 当前最流行的架构设计模式 turingbooks
        《微服务设计（第2版）》最可贵的地方在于，不光具备理论性与系统性，更为注重实践性与可操作性。全书勾勒出一幅从宏观到细节，再到组织落地的微服务架构整体实施蓝图。无论是对关注微服务领域的工程师与架构师，还是对寻求架构升级的管理者与决策者来说，本书都可以作为指导手册。——沈剑，快狗打车CTO《微服务设计（第2版）》萨姆·纽曼|著钟健鑫张沙沙智伟|译软件开发大神MartinFowler如此推荐本书：“微服
      • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
        文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
      • 2024上半年软考系统架构设计师-综合知识选择题及答案 不对法 系统架构
        1.操作系统先来先服务调度算法2.操作系统多道程序设计，利用率3.操作系统状态流转错误的，执行态到运行态4.数据库2NF每一个非主属性完全依赖主键5.数据库笛卡尔积m*n6.数据库不属于事务的特点，并发性7.数据库交集表达式R-(R-S)8.数据库反规范化属于逻辑设计9.网络没有加密功能，物理层10.网络二层交换机数据，数据链路层11.知识产权专利法是否属于民法12.知识产权商标不属于，其他几个是
      • 【60天备战软考高级系统架构设计师——第十天：软件设计与架构综合练习】 冷风扇666 备战-软考系统架构架构
        经过前十天的学习，我们已经了解了软件工程生命周期模型、需求分析与管理方法，以及软件设计与架构的核心内容。为了巩固这些知识点，今天我们将进行一个综合练习。前十天学习内容回顾第1-3天：软件工程概述学习了软件生命周期模型（如瀑布模型、迭代模型、敏捷模型等）、软件工程原则（如开闭原则、单一职责原则等），以及常用的工程方法。第4-6天：需求分析与管理需求分析与管理是软件开发的关键环节之一。我们掌握了需求获
      • 【系统架构设计】系统的可靠性分析与设计 傻傻虎虎 系统架构设计系统架构系统安全
        【系统架构设计】系统的可靠性分析与设计可靠性概述系统故障模型系统配置方法组成结构‌‌功能与应用场景‌‌技术含量与成本‌系统可靠性可靠性概述这里有几个名词要做好区分，可靠度是某一个时间区间内能正常运行的概率；可用度是某一时刻可运行的概率；可维度是指系统失效后，在时间间隔内被修复的概率；平均无故障时间是从0时开始到故障发生时，系统的持续运行时间的期望值；平均故障修复时间就是字面意思；平均故障间隔时间是
      • 系统架构师软考历年论文题目（2009-2024年）及分析 pccai-vip 系统架构师系统架构
        时间题目20091.论基于DSSA的软件架构设计与应用；2.论信息系统建模方法；3.论基于REST服务的Web应用系统设计；4.论软件可靠性设计与应用20101.论软件的静态演化和动态演化及其应用；2.论数据挖掘技术的应用；3.论大规模分布式系统缓存设计策略；4.论软件可靠性评价20111.论模型驱动架构在系统开发中的应用；2.论企业集成平台的架构设计；3.论企业架构管理与应用；4.论软件需求获取
      • Nacos 与 Eureka 的区别 litGrey 微服务eureka
        随着微服务架构的流行，服务发现成为了构建分布式系统的关键技术之一。在众多服务发现工具中，Nacos和Eureka是两个非常受欢迎的选择。本文将深入探讨这两者的区别，帮助你在选择适合自己的服务发现解决方案时做出明智的决策。如果你不懂得怎么选择，请记得看最后一点小建议！1.基础对比1.1.架构设计：集中式vs分布式Eureka采用的是客户端-服务器（Client-Server,CS）架构。Eureka
      • 论文分享系列（三）——论软件架构风格 马斯洛金字塔下的小灵猴儿 #软考高项架构师论软件架构风格论文
        论软件架构风格摘要2023年5月，我司启动了精彩购电商系统的开发工作，该项目组中我担任系统架构师岗位，主要负责整体架构设计与中间件选型。本文以该电商平台为例，主要讨论了软件架构风格在该项目中的具体应用。整个系统采用具有三层的层次式软件架构的设计思想，分别是应用层，服务层，数据层。在应用层中的业务逻辑层的设计中，将整个业务系统划分为十余个子系统。服务层以springcloud服务框架为核心，数据采用
      • 论文分享系列（二）——论微服务架构及其应用 马斯洛金字塔下的小灵猴儿 #软考高项架构师论微服务架构及其应用论文
        论微服务架构及其应用摘要2023年5月，我司启动了精彩购电商系统的开发工作，该项目组中我担任系统架构师岗位，主要负责整体架构设计与中间件选型。本文以该电商平台为例，将介绍微服务架构的特点、应用场景以及实现方法。系统以SpringCloud微服务框架开发，分为前端Web服务、平台保障服务、业务服务三部分。前端Web服务由负载均衡与服务器集群结合，实现高并发的前台界面；平台保障服务以Eureka为中心
      • 248、Python开发秘籍：技术选型与架构设计技巧解析 多多的编程笔记 python开发语言
        Python开发：掌握如何处理技术债务和遗留系统作为软件开发者，我们经常会遇到两种问题：技术债务和遗留系统。技术债务是指在软件开发过程中，为了尽快完成项目而采用的短期解决方案，这会导致代码质量下降，维护成本增加。而遗留系统则是指那些已经存在很长时间，但不再适应现代技术需求的系统。在这篇文章中，我们将介绍如何使用Python来处理这两种问题。理解技术债务技术债务可以理解为一种“借债”。想象一下，你正
      • 多级缓存架构设计 白鸽呀 架构缓存redis数据库
        缓存是提升性能最直接的方法多级缓存分为：客户端，应用层，业务层，数据层1、客户端缓存：主要对浏览器的静态资源进行缓存通过在响应头设置Expires，cache-control，将文件保存在本地，减少多次请求静态资源带来的带宽损耗（解决并发手段）2、应用层缓存：浏览器只负责读取Expires，Expires在CDN内容分发网络和Nginx进行设置CDN内容分发网络是静态资源分发的主要技术手段，有效解
      • 一种E2E的架构设计流程 weixin_33796205
        本文不是介绍架构设计方法，只是给出一种E2E的架构设计流程的实现，具体的架构设计方法需要参考相关的资料。架构设计流程分析：具体步骤说明：1、需求收集，包括从用户收集到的原始需求和项目通过友商的竞争分析得到的需求，需求分为功能需求和非功能需求两大类。2、需求分析，针对1中搜集到的需求，首先按类划分整理，再对原始需求进行分解，生成子业务需求，在根据业务需求做用例分析。用例分析中，需要对每个用例业务模型
      • 【HDFS】角色的架构设计 流辉fglow #HDFS大数据hdfshadoop大数据学习分布式
        HDFS角色的架构设计前置知识：Windows与Linux文件系统的差异HDFS中的角色及功能HDFS的架构NameNodeDataNodeNameNode元数据的持久化说明：/表示两个词是同一语义，方便你理解的前置知识：Windows与Linux文件系统的差异Windows&LInux虽然都有硬盘/分区、目录，但感受很不同的是：Windows：有很强的分区概念，要先通过不同的“盘符”去找文件在命
      • Flutter电商项目实践-架构设计 Zhouztashin Flutterflutter电子商务项目架构
        1、框架设计图框架设计总体说明整个框架划分成业务层、组件层、基础层与外部层。其中外部层对应着第三方或者自己封装的提供单独功能的依赖库，基础层主要对应着非UI的基础性功能，组件层对应着UI功能的基础性功能，可以向业务层提供完整可以使用的UI组件功能。业务层则是应用的核心，除了外部层之外，组件层、基础层以库的形式提供给业务层使用，这样的好处是提高了这两层的复用性。框架设计原则层级职责划分需要单一且清晰
      • 学习之性能的理论知识一 蓝瑟柳絮 学习
        一、性能的测试的概念1、什么是性能性能：就是软件质量属性中的效率效率特性：时间特性：表示系统处理用户请求的响应时间资源特性：表示系统运行过程中，系统资源的消耗情况：CPU，内存、磁盘2、什么是性能测试性能测试概念：使用自动化工具，模拟不同的场景，对软件各项性能指标进行测试和评估的过程测试的是：1、后台处理程序的性能（代码性能）2、应用服务、数据库、架构设计等是否存在瓶颈3、服务器资源消耗（cpu、
      • 【架构篇】软件架构的指南针之架构原则 林木森^~^ 架构架构数据库
        软件架构的设计原则是一组指导思想，帮助我们在设计系统时做出有效的决策，以确保软件的可维护性、可扩展性和可靠性。以下是一些关键的软件架构设计原则：模块化（Modularity）：将系统分解为功能独立的模块，每个模块负责系统中的一个特定的功能区域。这种分解有助于降低系统的复杂性，便于理解和维护。抽象（Abstraction）：提供系统组件的简化表示，隐藏其内部复杂性，只暴露必要的接口。这有助于理解系统
      • 【系统架构设计师】解释器模式 Evaporator Core 解释器模式python开发语言
        解释器模式（InterpreterPattern）是一种行为型设计模式，它定义了文法的表示，并定义了一个解释器，该解释器使用该表示来解释语言中的句子。在解释器模式中，通常包括一个抽象语法树（AbstractSyntaxTree,AST），用于表示输入的语言文法，以及一系列的解释器类，每个类对应文法中的一个符号或符号的组合。解释器模式主要适用于那些需要将一个语言中的句子解释成程序可以理解的另一种形式
      • 软考架构-架构风格 zyhJhon 架构
        一、概念：风格就是架构的模式，比如C/S、B/S架构，比如现实生活中的中式风格、欧式风格描述某一特定应用领域中系统组织的方式软件架构风格反映了领域中众多系统所共有的结构和语义特性，并指导如何将各个模块和子系统有效地组织成一个完整的系统。架构设计的核心问题是能否达到架构级的软件复用架构风格定义了用于描述系统的术语表和一组指导构架系统的规则二、风格分类架构风格考点说明数据流-批处理传统编译器，每个阶段
      • 【深入剖析】Kylin架构全景及其组件详解 2401_85763639 kylin架构大数据
        标题：【深入剖析】Kylin架构全景及其组件详解ApacheKylin是一个开源的分布式分析引擎，提供大数据集上的即时分析能力。它通过预计算技术，将数据以多维立方体的形式存储，从而加快查询速度。本文将详细探讨Kylin的架构及其组件，包括数据源、元数据存储、Cube构建、协调节点、查询引擎等关键部分。1.Kylin架构概述Kylin的架构设计为分层结构，每一层负责不同的功能和任务。2.数据源层Ky
      • 探索高效开发之道：N-Tier架构开源项目深度剖析 钟洁祺
        探索高效开发之道：N-Tier架构开源项目深度剖析N-Tier-ArchitectureThisisan-layerarchitecturebasedonCommonwebapplicationarchitectures.项目地址:https://gitcode.com/gh_mirrors/nt/N-Tier-Architecture在追求卓越的软件开发旅程中，一个清晰、高效的架构设计是基石。今
      • 即时通讯技术文集（第16期）：IM架构设计技术精选(第一部分) [共17篇] jackjiang20212
        为了更好地分类阅读52im.net总计1000多篇精编文章，我将在每周三推送新的一期技术文集，本次是第16期。[-1-]浅谈IM系统的架构设计[链接]http://www.52im.net/thread-307-1-1.html[摘要]下面把我近年来从技术上我对IM系统（即时消息的传输，不包括语音，视频，文件的传输）的理解和设计分享出来，浅薄之见，望大家别见笑，欢迎给出批评意见。[-2-]简述移动
      • 解读Servlet原理篇二---GenericServlet与HttpServlet 周凡杨 javaHttpServlet源理GenericService源码
        在上一篇《解读Servlet原理篇一》中提到，要实现javax.servlet.Servlet接口（即写自己的Servlet应用），你可以写一个继承自javax.servlet.GenericServletr的generic Servlet ，也可以写一个继承自java.servlet.http.HttpServlet的HTTP Servlet（这就是为什么我们自定义的Servlet通常是exte
      • MySQL性能优化 bijian1013 数据库mysql
                性能优化是通过某些有效的方法来提高MySQL的运行速度，减少占用的磁盘空间。性能优化包含很多方面，例如优化查询速度，优化更新速度和优化MySQL服务器等。本文介绍方法的主要有：         a.优化查询         b.优化数据库结构  
      • ThreadPool定时重试 dai_lm javaThreadPoolthreadtimertimertask
        项目需要当某事件触发时，执行http请求任务，失败时需要有重试机制，并根据失败次数的增加，重试间隔也相应增加，任务可能并发。 由于是耗时任务，首先考虑的就是用线程来实现，并且为了节约资源，因而选择线程池。 为了解决不定间隔的重试，选择Timer和TimerTask来完成 package threadpool; public class ThreadPoolTest {
      • Oracle 查看数据库的连接情况 周凡杨 sqloracle 连接
        首先要说的是，不同版本数据库提供的系统表会有不同，你可以根据数据字典查看该版本数据库所提供的表。 select * from dict where table_name like '%SESSION%'; 就可以查出一些表，然后根据这些表就可以获得会话信息 select sid,serial#,status,username,schemaname,osuser,terminal,ma
      • 类的继承 朱辉辉33 java
        类的继承可以提高代码的重用行，减少冗余代码；还能提高代码的扩展性。Java继承的关键字是extends 格式:public class 类名（子类）extends 类名（父类）{ } 子类可以继承到父类所有的属性和普通方法，但不能继承构造方法。且子类可以直接使用父类的public和 protected属性，但要使用private属性仍需通过调用。 子类的方法可以重写，但必须和父类的返回值类
      • android 悬浮窗特效 肆无忌惮_ android
        最近在开发项目的时候需要做一个悬浮层的动画，类似于支付宝掉钱动画。但是区别在于，需求是浮出一个窗口，之后边缩放边位移至屏幕右下角标签处。效果图如下：   一开始考虑用自定义View来做。后来发现开线程让其移动很卡，ListView+动画也没法精确定位到目标点。   后来想利用Dialog的dismiss动画来完成。   自定义一个Dialog后，在styl
      • hadoop伪分布式搭建 林鹤霄 hadoop
        要修改4个文件    1: vim hadoop-env.sh  第九行    2: vim core-site.xml            <configuration>     &n
      • gdb调试命令 aigo gdb
        原文：http://blog.csdn.net/hanchaoman/article/details/5517362   一、GDB常用命令简介   r run 运行.程序还没有运行前使用 c             cuntinue 
      • Socket编程的HelloWorld实例 alleni123 socket
        public class Client { public static void main(String[] args) { Client c=new Client(); c.receiveMessage(); } public void receiveMessage(){ Socket s=null; BufferedRea
      • 线程同步和异步 百合不是茶 线程同步异步
        多线程和同步 : 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。 所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法   多线程和异步:多线程可以做不同的事情,涉及到线程通知     &
      • JSP中文乱码分析 bijian1013 javajsp中文乱码
                在JSP的开发过程中，经常出现中文乱码的问题。         首先了解一下Java中文问题的由来：         Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，
      • js实现页面跳转重定向的几种方式 bijian1013 JavaScript重定向
                js实现页面跳转重定向有如下几种方式： 一.window.location.href <script language="javascript"type="text/javascript"> window.location.href="http://www.baidu.c
      • 【Struts2三】Struts2 Action转发类型 bit1129 struts2
         在【Struts2一】 Struts Hello World http://bit1129.iteye.com/blog/2109365中配置了一个简单的Action，配置如下   <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configurat
      • 【HBase十一】Java API操作HBase bit1129 hbase
        Admin类的主要方法注释：   1. 创建表 /** * Creates a new table. Synchronous operation. * * @param desc table descriptor for table * @throws IllegalArgumentException if the table name is res
      • nginx gzip ronin47 nginx gzip
        Nginx GZip 压缩 Nginx GZip 模块文档详见：http://wiki.nginx.org/HttpGzipModule 常用配置片段如下： gzip on; gzip_comp_level 2; # 压缩比例，比例越大，压缩时间越长。默认是1 gzip_types text/css text/javascript; # 哪些文件可以被压缩 gzip_disable &q
      • java-7.微软亚院之编程判断俩个链表是否相交 给出俩个单向链表的头指针，比如 h1 ， h2 ，判断这俩个链表是否相交 bylijinnan java
        public class LinkListTest { /** * we deal with two main missions: * * A. * 1.we create two joined-List(both have no loop) * 2.whether list1 and list2 join * 3.print the join
      • Spring源码学习-JdbcTemplate batchUpdate批量操作 bylijinnan javaspring
        Spring JdbcTemplate的batch操作最后还是利用了JDBC提供的方法，Spring只是做了一下改造和封装 JDBC的batch操作： String sql = "INSERT INTO CUSTOMER " + "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
      • [JWFD开源工作流]大规模拓扑矩阵存储结构最新进展 comsci 工作流
            生成和创建类已经完成,构造一个100万个元素的矩阵模型,存储空间只有11M大,请大家参考我在博客园上面的文档"构造下一代工作流存储结构的尝试",更加相信的设计和代码将陆续推出.........     竞争对手的能力也很强.......,我相信..你们一定能够先于我们推出大规模拓扑扫描和分析系统的....
      • base64编码和url编码 cuityang base64url
        import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.io.StringWriter; import java.io.UnsupportedEncodingException;
      • web应用集群Session保持 dalan_123 session
        关于使用 memcached 或redis 存储 session ，以及使用 terracotta 服务器共享。建议使用 redis，不仅仅因为它可以将缓存的内容持久化，还因为它支持的单个对象比较大，而且数据类型丰富，不只是缓存 session，还可以做其他用途，一举几得啊。1、使用 filter 方法存储这种方法比较推荐，因为它的服务器使用范围比较多，不仅限于tomcat ，而且实现的原理比较简
      • Yii 框架里数据库操作详解-[增加、查询、更新、删除的方法 'AR模式'] dcj3sjt126com 数据库
            public function getMinLimit () {        $sql = "...";        $result = yii::app()->db->createCo
      • solr StatsComponent（聚合统计） eksliang solr聚合查询solr stats
        StatsComponent 转载请出自出处：http://eksliang.iteye.com/blog/2169134 http://eksliang.iteye.com/ 一、概述        Solr可以利用StatsComponent 实现数据库的聚合统计查询，也就是min、max、avg、count、sum的功能   二、参数
      • 百度一道面试题 greemranqq 位运算百度面试寻找奇数算法bitmap 算法
        那天看朋友提了一个百度面试的题目：怎么找出{1,1,2,3,3,4,4,4,5,5,5,5}  找出出现次数为奇数的数字.   我这里复制的是原话，当然顺序是不一定的，很多拿到题目第一反应就是用map,当然可以解决，但是效率不高。   还有人觉得应该用算法xxx,我是没想到用啥算法好...！   还有觉得应该先排序...   还有觉
      • Spring之在开发中使用SpringJDBC ihuning spring
          在实际开发中使用SpringJDBC有两种方式：   1. 在Dao中添加属性JdbcTemplate并用Spring注入；     JdbcTemplate类被设计成为线程安全的，所以可以在IOC 容器中声明它的单个实例，并将这个实例注入到所有的 DAO 实例中。JdbcTemplate也利用了Java 1.5 的特定(自动装箱，泛型，可变长度
      • JSON API 1.0 核心开发者自述 | 你所不知道的那些技术细节 justjavac json
        2013年5月，Yehuda Katz 完成了JSON API(英文，中文) 技术规范的初稿。事情就发生在 RailsConf 之后，在那次会议上他和 Steve Klabnik 就 JSON 雏形的技术细节相聊甚欢。在沟通单一 Rails 服务器库—— ActiveModel::Serializers 和单一 JavaScript 客户端库——&
      • 网站项目建设流程概述 macroli 工作
        一.概念 网站项目管理就是根据特定的规范、在预算范围内、按时完成的网站开发任务。 二.需求分析 项目立项 　　我们接到客户的业务咨询，经过双方不断的接洽和了解，并通过基本的可行性讨论够，初步达成制作协议，这时就需要将项目立项。较好的做法是成立一个专门的项目小组，小组成员包括：项目经理，网页设计，程序员，测试员，编辑/文档等必须人员。项目实行项目经理制。 客户的需求说明书 　　第一步是需
      • AngularJs 三目运算 表达式判断 qiaolevip 每天进步一点点学习永无止境众观千象AngularJS
        事件回顾：由于需要修改同一个模板，里面包含2个不同的内容，第一个里面使用的时间差和第二个里面名称不一样，其他过滤器，内容都大同小异。希望杜绝If这样比较傻的来判断if-show or not，继续追究其源码。 var b = "{{", a = "}}"; this.startSymbol = function(a) {
      • Spark算子：统计RDD分区中的元素及数量 superlxw1234 sparkspark算子Spark RDD分区元素
        关键字：Spark算子、Spark RDD分区、Spark RDD分区元素数量     Spark RDD是被分区的，在生成RDD时候，一般可以指定分区的数量，如果不指定分区数量，当RDD从集合创建时候，则默认为该程序所分配到的资源的CPU核数，如果是从HDFS文件创建，默认为文件的Block数。   可以利用RDD的mapPartitionsWithInd
      • Spring 3.2.x将于2016年12月31日停止支持 wiselyman Spring 3
                      Spring 团队公布在2016年12月31日停止对Spring Framework 3.2.x（包含tomcat 6.x）的支持。在此之前spring团队将持续发布3.2.x的维护版本。          请大家及时准备及时升级到Spring
      • fis纯前端解决方案fis-pure zccst JavaScript
        作者：zccst FIS通过插件扩展可以完美的支持模块化的前端开发方案，我们通过FIS的二次封装能力，封装了一个功能完备的纯前端模块化方案pure。 1，fis-pure的安装 $ fis install -g fis-pure $ pure -v 0.1.4 2，下载demo到本地 git clone https://github.com/hefangshi/f