Ravitn
Ravitn

incubator-gossip框架设计

引言

Gossip protocol 也叫 Epidemic Protocol （流行病协议），实际上它还有很多别名，比如：“流言算法”、“疫情传播算法”等。很多知名的 P2P 网络或区块链项目，比如 IPFS，Ethereum 等，都使用了 Kadmelia 算法，而大名鼎鼎的 Bitcoin 则是使用了 Gossip 协议来传播交易和区块信息。实际上，只要仔细分析一下场景就知道，Ethereum 使用 DHT 算法并不是很合理，因为它使用节点保存整个链数据，不像 IPFS 那样分片保存数据，因此 Ethereum 真正适合的协议应该像 Bitcoin 那样，是 Gossip 协议。

原文地址:https://donaldhan.github.io/blockchain/2020/10/20/Gossip-framework-design.html

目录

  • gossip初探
  • 框架设计
  • 源码分析
    • UDP管理器
    • 消息编解码
    • 消息处理器
    • 节点状态刷新器
    • 数据同步器
    • core组件
    • gossip管理器
  • 总结

gossip初探

关于Gossip 协议介绍，我们不做太多的讲解，因为网上已经有很多的文章，可以参考附录文献。在了解gossip一些的基础之上我们来探索gossip相关的协议实现框架，本文研究的框架为
incubator-retired-gossip。

incubator-retired-gossip框架提供了gossip协议的单机版示例，包括族的管理，基于CRDT的共享数据，PN计数器，数据中心，分布式锁的相关demo；

具体参见使用说明
gossip-examples

把demo跑一篇，我们再来看gossip的框架设计。

框架设计

gossip-framework.png

gossip是基于UDP协议进行通信的，底层是通过UDP管理器进行消息的收发；消息编解码器使用的是JSON序列化方式，节点接收消息后，有解码器进行解码，委托消息处理器处理，消息处理器有节点数据、共享数据、及宕机消息等。集群中的节点的状态同步通过节点状态刷新器进行同步。针对族活跃节点、宕机节点、节点数据，及共享数据的同步通过数据同步器完成。core组件对节点、共享数据进行管理，及消息的收发。gossip管理器持久节点状态、数据及共享数据。

源码分析

UDP管理器

/**
 * This class is constructed by reflection in GossipManager.
 * It manages transport (byte read/write) operations over UDP.
 * 管理基于UDP的数据传输操作
 */
public class UdpTransportManager extends AbstractTransportManager implements Runnable {
  public static final Logger LOGGER = Logger.getLogger(UdpTransportManager.class);
  /**
   *
   * The socket used for the passive thread of the gossip service.
   * gossip socket server
   *  */
  private final DatagramSocket server;
  /**
   * 获取数据超时时间
   */
  private final int soTimeout;
  
  private final Thread me;
  /**
   * 运行状态
   */
  private final AtomicBoolean keepRunning = new AtomicBoolean(true);
  
  /**
   * required for reflection to work!
   * @param gossipManager
   * @param gossipCore*/
  public UdpTransportManager(GossipManager gossipManager, GossipCore gossipCore) {
    super(gossipManager, gossipCore);
    soTimeout = gossipManager.getSettings().getGossipInterval() * 2;
    try {
      SocketAddress socketAddress = new InetSocketAddress(gossipManager.getMyself().getUri().getHost(),
              gossipManager.getMyself().getUri().getPort());
      server = new DatagramSocket(socketAddress);
    } catch (SocketException ex) {
      LOGGER.warn(ex);
      throw new RuntimeException(ex);
    }
    me = new Thread(this);
  }

  @Override
  public void run() {
    while (keepRunning.get()) {
      try {
        byte[] buf = read();
        try {
          //读取数据
          Base message = gossipManager.getProtocolManager().read(buf);
          //处理消息
          gossipCore.receive(message);
          //TODO this is suspect  GossipMemberStateRefresher
          gossipManager.getMemberStateRefresher().run();
        } catch (RuntimeException ex) {//TODO trap json exception
          LOGGER.error("Unable to process message", ex);
        }
      } catch (IOException e) {
        // InterruptedException are completely normal here because of the blocking lifecycle.
        if (!(e.getCause() instanceof InterruptedException)) {
          LOGGER.error(e);
        }
        keepRunning.set(false);
      }
    }
  }
  
  @Override
  public void shutdown() {
    keepRunning.set(false);
    server.close();
    super.shutdown();
    me.interrupt();
  }

  /**
   * blocking read a message.
   * 从缓存区读取消息数据
   * @return buffer of message contents.
   * @throws IOException
   */
  public byte[] read() throws IOException {
    byte[] buf = new byte[server.getReceiveBufferSize()];
    DatagramPacket p = new DatagramPacket(buf, buf.length);
    server.receive(p);
    debug(p.getData());
    return p.getData();
  }

  /**
   * 发送字节数据
   * @param endpoint
   * @param buf
   * @throws IOException
   */
  @Override
  public void send(URI endpoint, byte[] buf) throws IOException {
    // todo: investigate UDP socket reuse. It would save a little setup/teardown time wrt to the local socket.
    try (DatagramSocket socket = new DatagramSocket()){
      socket.setSoTimeout(soTimeout);
      InetAddress dest = InetAddress.getByName(endpoint.getHost());
      DatagramPacket payload = new DatagramPacket(buf, buf.length, dest, endpoint.getPort());
      socket.send(payload);
    }
  }
  

  /**
   * 启动endpoint
   */
  @Override
  public void startEndpoint() {
    me.start();
  }
  
}

从上面可以看出，UDP传输管理UdpTransportManager，主要发送字节数据，接收字节数据，并委托给core组件。在UDP传输管理器启动的过程中，同时启动节点状态刷新器。

我们再来看一下消息编解码器

消息编解码

// this class is constructed by reflection in GossipManager.
public class JacksonProtocolManager implements ProtocolManager {
  
  private final ObjectMapper objectMapper;
  private final PrivateKey privKey;
  private final Meter signed;
  private final Meter unsigned;
  
  /** required for reflection to work!
   * @param settings
   * @param id
   * @param registry*/
  public JacksonProtocolManager(GossipSettings settings, String id, MetricRegistry registry) {
    // set up object mapper.
    objectMapper = buildObjectMapper(settings);
    
    // set up message signing. 如果需要加签消息，则加载节点公私钥
    if (settings.isSignMessages()){
      File privateKey = new File(settings.getPathToKeyStore(), id);
      File publicKey = new File(settings.getPathToKeyStore(), id + ".pub");
      if (!privateKey.exists()){
        throw new IllegalArgumentException("private key not found " + privateKey);
      }
      if (!publicKey.exists()){
        throw new IllegalArgumentException("public key not found " + publicKey);
      }
      try (FileInputStream keyfis = new FileInputStream(privateKey)) {
        byte[] encKey = new byte[keyfis.available()];
        keyfis.read(encKey);
        keyfis.close();
        PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(encKey);
        KeyFactory keyFactory = KeyFactory.getInstance("DSA");
        privKey = keyFactory.generatePrivate(privKeySpec);
      } catch (NoSuchAlgorithmException | InvalidKeySpecException | IOException e) {
        throw new RuntimeException("failed hard", e);
      }
    } else {
      privKey = null;
    }
    
    signed = registry.meter(PassiveGossipConstants.SIGNED_MESSAGE);
    unsigned = registry.meter(PassiveGossipConstants.UNSIGNED_MESSAGE);
  }

  /**
   * 转换消息为字节数组
   * @param message
   * @return
   * @throws IOException
   */
  @Override
  public byte[] write(Base message) throws IOException {
    byte[] json_bytes;
    if (privKey == null){
      json_bytes = objectMapper.writeValueAsBytes(message);
    } else {
      SignedPayload p = new SignedPayload();
      p.setData(objectMapper.writeValueAsString(message).getBytes());
      p.setSignature(sign(p.getData(), privKey));
      json_bytes = objectMapper.writeValueAsBytes(p);
    }
    return json_bytes;
  }

  /**
   * 转换字节数组为消息对象
   * @param buf
   * @return
   * @throws IOException
   */
  @Override
  public Base read(byte[] buf) throws IOException {
    Base activeGossipMessage = objectMapper.readValue(buf, Base.class);
    if (activeGossipMessage instanceof SignedPayload){
      SignedPayload s = (SignedPayload) activeGossipMessage;
      signed.mark();
      return objectMapper.readValue(s.getData(), Base.class);
    } else {
      unsigned.mark();
      return activeGossipMessage;
    }
  }

  public static ObjectMapper buildObjectMapper(GossipSettings settings) {
    ObjectMapper om = new ObjectMapper();
    om.enableDefaultTyping();
    // todo: should be specified in the configuration.
    om.registerModule(new CrdtModule());
    om.configure(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS, false);
    return om;
  }
  
  private static byte[] sign(byte [] bytes, PrivateKey pk){
    Signature dsa;
    try {
      dsa = Signature.getInstance("SHA1withDSA", "SUN");
      dsa.initSign(pk);
      dsa.update(bytes);
      return dsa.sign();
    } catch (NoSuchAlgorithmException | NoSuchProviderException | InvalidKeyException | SignatureException e) {
      throw new RuntimeException(e);
    } 
  }
}

从上面可以看出，消息编解码器JacksonProtocolManager是基于JSON的消息编解码，如果是RSA加签方式，则在收发消息，做响应的加解密。

消息处理器

消息处理这块，我们来看一下节点数据、共享数据、节点宕机消息的处理。

  • 共享数据消息处理器
public class SharedDataMessageHandler implements MessageHandler{
  
  /**
   * @param gossipCore context.
   * @param gossipManager context.
   * @param base message reference.
   * @return boolean indicating success.
   */
  @Override
  public boolean invoke(GossipCore gossipCore, GossipManager gossipManager, Base base) {
    UdpSharedDataMessage message = (UdpSharedDataMessage) base;
    //添加共享数据
    gossipCore.addSharedData(message);
    return true;
  }
}
  • 节点数据消息处理器
public class PerNodeDataMessageHandler implements MessageHandler {

  /**
   * @param gossipCore context.
   * @param gossipManager context.
   * @param base message reference.
   * @return boolean indicating success.
   */
  @Override
  public boolean invoke(GossipCore gossipCore, GossipManager gossipManager, Base base) {
    UdpPerNodeDataMessage message = (UdpPerNodeDataMessage) base;
    //添加节点数据消息
    gossipCore.addPerNodeData(message);
    return true;
  }
}
  • 节点宕机消息处理器
public class ShutdownMessageHandler implements MessageHandler {
  
  /**
   * @param gossipCore context.
   * @param gossipManager context.
   * @param base message reference.
   * @return boolean indicating success.
   */
  @Override
  public boolean invoke(GossipCore gossipCore, GossipManager gossipManager, Base base) {
    ShutdownMessage s = (ShutdownMessage) base;
    //转换宕机下消息，为节点数据消息
    PerNodeDataMessage m = new PerNodeDataMessage();
    m.setKey(ShutdownMessage.PER_NODE_KEY);
    m.setNodeId(s.getNodeId());
    m.setPayload(base);
    m.setTimestamp(System.currentTimeMillis());
    m.setExpireAt(System.currentTimeMillis() + 30L * 1000L);
    //添加节点数据消息
    gossipCore.addPerNodeData(m);
    return true;
  }
}

从上面可以共享数据和节点数据处理实际是委托给core组件，这个我们后面再来看，宕机消息转换为节点消息进行处理。

节点状态刷新器

/**
 * 成员状态刷新线程
 */
public class GossipMemberStateRefresher {
  public static final Logger LOGGER = Logger.getLogger(GossipMemberStateRefresher.class);

  /**
   * gossip成员
   */
  private final Map members;
  /**
   * gossip配置
   */
  private final GossipSettings settings;
  /**
   * gossip监听器
   */
  private final List listeners = new CopyOnWriteArrayList<>();
  /**
   * 系统时钟
   */
  private final Clock clock;
  private final BiFunction findPerNodeGossipData;
  /**
   * 监听器执行线程
   */
  private final ExecutorService listenerExecutor;
  /**
   * 条赌气
   */
  private final ScheduledExecutorService scheduledExecutor;
  /**
   * 任务队列
   */
  private final BlockingQueue workQueue;

  public GossipMemberStateRefresher(Map members, GossipSettings settings,
                                    GossipListener listener,
                                    BiFunction findPerNodeGossipData) {
    this.members = members;
    this.settings = settings;
    listeners.add(listener);
    this.findPerNodeGossipData = findPerNodeGossipData;
    clock = new SystemClock();
    workQueue = new ArrayBlockingQueue<>(1024);
    listenerExecutor = new ThreadPoolExecutor(1, 20, 1, TimeUnit.SECONDS, workQueue,
            new ThreadPoolExecutor.DiscardOldestPolicy());
    scheduledExecutor = Executors.newScheduledThreadPool(1);
  }

  /**
   * 调度成员状态刷新器
   */
  public void init() {
    scheduledExecutor.scheduleAtFixedRate(() -> run(), 0, 100, TimeUnit.MILLISECONDS);
  }

  /**
   *
   */
  public void run() {
    try {
      runOnce();
    } catch (RuntimeException ex) {
      LOGGER.warn("scheduled state had exception", ex);
    }
  }

  /**
   * gossip成员状态探测
   */
  public void runOnce() {
    for (Entry entry : members.entrySet()) {
      boolean userDown = processOptimisticShutdown(entry);
      if (userDown)
        continue;

      Double phiMeasure = entry.getKey().detect(clock.nanoTime());
      GossipState requiredState;
      //根据探测结果，判断节点状态
      if (phiMeasure != null) {
        requiredState = calcRequiredState(phiMeasure);
      } else {
        requiredState = calcRequiredStateCleanupInterval(entry.getKey(), entry.getValue());
      }

      if (entry.getValue() != requiredState) {
        members.put(entry.getKey(), requiredState);
        /* Call listeners asynchronously 异步触发节点状态监听器*/
        for (GossipListener listener: listeners)
          listenerExecutor.execute(() -> listener.gossipEvent(entry.getKey(), requiredState));
      }
    }
  }

  /**
   *
   * @param phiMeasure
   * @return
   */
  public GossipState calcRequiredState(Double phiMeasure) {
    //如果探测节点存活的时间间隔大于阈值，则节点down
    if (phiMeasure > settings.getConvictThreshold())
      return GossipState.DOWN;
    else
      return GossipState.UP;
  }

  /**
   * 首次探活状态
   * @param member
   * @param state
   * @return
   */
  public GossipState calcRequiredStateCleanupInterval(LocalMember member, GossipState state) {
    long now = clock.nanoTime();
    long nowInMillis = TimeUnit.MILLISECONDS.convert(now, TimeUnit.NANOSECONDS);
    //如果当前时间减去清理时间间隔，大于成员的心跳时间，则DOWN
    if (nowInMillis - settings.getCleanupInterval() > member.getHeartbeat()) {
      return GossipState.DOWN;
    } else {
      return state;
    }
  }

  /**
   * If we have a special key the per-node data that means that the node has sent us
   * a pre-emptive shutdown message. We process this so node is seen down sooner
   * 预处理节点状态
   * @param l member to consider
   * @return true if node forced down
   */
  public boolean processOptimisticShutdown(Entry l) {
    //获取节点宕机消息
    PerNodeDataMessage m = findPerNodeGossipData.apply(l.getKey().getId(), ShutdownMessage.PER_NODE_KEY);
    if (m == null) {
      return false;
    }
    ShutdownMessage s = (ShutdownMessage) m.getPayload();
    //如果节点宕机时间大于当前心跳时间
    if (s.getShutdownAtNanos() > l.getKey().getHeartbeat()) {
      members.put(l.getKey(), GossipState.DOWN);
      if (l.getValue() == GossipState.UP) {
        //如果状态变化，则通知监听器
        for (GossipListener listener: listeners)
          listenerExecutor.execute(() -> listener.gossipEvent(l.getKey(), GossipState.DOWN));
      }
      return true;
    }
    return false;
  }

  /**
   * 注解监听器
   * @param listener
   */
  public void register(GossipListener listener) {
    listeners.add(listener);
  }

  /**
   * 关闭gossip成员刷新器
   */
  public void shutdown() {
    scheduledExecutor.shutdown();
    try {
      scheduledExecutor.awaitTermination(5, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
      LOGGER.debug("Issue during shutdown", e);
    }
    listenerExecutor.shutdown();
    try {
      listenerExecutor.awaitTermination(5, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
      LOGGER.debug("Issue during shutdown", e);
    }
    listenerExecutor.shutdownNow();
  }
}

节点状态刷新器GossipMemberStateRefresher，通过宕机探测器FailureDetector，探测节点的存活状态，并更新节点状态，针对状态变更的，要通知响应的监听器。

数据同步器

/**
 * Base implementation gossips randomly to live nodes periodically gossips to dead ones
 *
 */
public class SimpleActiveGossiper extends AbstractActiveGossiper {

  /**
   * 调度器
   */
  private ScheduledExecutorService scheduledExecutorService;
  /**
   * 任务队列
   */
  private final BlockingQueue workQueue;
  /**
   * 线程池执行器
   */
  private ThreadPoolExecutor threadService;

  /**
   * @param gossipManager
   * @param gossipCore
   * @param registry
   */
  public SimpleActiveGossiper(GossipManager gossipManager, GossipCore gossipCore,
                              MetricRegistry registry) {
    super(gossipManager, gossipCore, registry);
    scheduledExecutorService = Executors.newScheduledThreadPool(2);
    workQueue = new ArrayBlockingQueue(1024);
    threadService = new ThreadPoolExecutor(1, 30, 1, TimeUnit.SECONDS, workQueue,
            new ThreadPoolExecutor.DiscardOldestPolicy());
  }

  @Override
  public void init() {
    super.init();
    scheduledExecutorService.scheduleAtFixedRate(() -> {
      threadService.execute(() -> {
        //发送Live成员
        sendToALiveMember();
      });
    }, 0, gossipManager.getSettings().getGossipInterval(), TimeUnit.MILLISECONDS);
    scheduledExecutorService.scheduleAtFixedRate(() -> {
      //发送Dead成员
      sendToDeadMember();
    }, 0, gossipManager.getSettings().getGossipInterval(), TimeUnit.MILLISECONDS);
    scheduledExecutorService.scheduleAtFixedRate(
            //发送节点数据
            () -> sendPerNodeData(gossipManager.getMyself(),
                    selectPartner(gossipManager.getLiveMembers())),
            0, gossipManager.getSettings().getGossipInterval(), TimeUnit.MILLISECONDS);
    scheduledExecutorService.scheduleAtFixedRate(
            //发送共享数据
            () -> sendSharedData(gossipManager.getMyself(),
                    selectPartner(gossipManager.getLiveMembers())),
            0, gossipManager.getSettings().getGossipInterval(), TimeUnit.MILLISECONDS);
  }
  
  @Override
  public void shutdown() {
    super.shutdown();
    scheduledExecutorService.shutdown();
    try {
      scheduledExecutorService.awaitTermination(5, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
      LOGGER.debug("Issue during shutdown", e);
    }
    //发送关闭消息
    sendShutdownMessage();
    threadService.shutdown();
    try {
      threadService.awaitTermination(5, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
      LOGGER.debug("Issue during shutdown", e);
    }
  }

  /**
   *从当前节点的gossip成员列表中选择一个成员，发送Live节点信息
   */
  protected void sendToALiveMember(){
    LocalMember member = selectPartner(gossipManager.getLiveMembers());
    sendMembershipList(gossipManager.getMyself(), member);
  }

  /**
   * 从当前节点的gossip成员列表中选择一个成员，发送Dead节点信息
   */
  protected void sendToDeadMember(){
    LocalMember member = selectPartner(gossipManager.getDeadMembers());
    sendMembershipList(gossipManager.getMyself(), member);
  }
  
  /**
   * sends an optimistic shutdown message to several clusters nodes
   * 通知族节点，当前节点已关闭
   */
  protected void sendShutdownMessage(){
    List l = gossipManager.getLiveMembers();
    int sendTo = l.size() < 3 ? 1 : l.size() / 2;
    for (int i = 0; i < sendTo; i++) {
      threadService.execute(() -> sendShutdownMessage(gossipManager.getMyself(), selectPartner(l)));
    }
  }
}

数据同步器，同步活跃、宕机成员，节点数据、共享数据。

我们再来看同步活跃节点

//SimpleActiveGossiper

 /**
   *从当前节点的gossip成员列表中选择一个成员，发送Live节点信息
   */
  protected void sendToALiveMember(){
    LocalMember member = selectPartner(gossipManager.getLiveMembers());
    sendMembershipList(gossipManager.getMyself(), member);
  }

//AbstractActiveGossiper

 /**
   * 返回本地的随机gossip成员
   * @param memberList
   *          An immutable list
   * @return The chosen LocalGossipMember to gossip with.
   */
  protected LocalMember selectPartner(List memberList) {
    LocalMember member = null;
    if (memberList.size() > 0) {
      int randomNeighborIndex = random.nextInt(memberList.size());
      member = memberList.get(randomNeighborIndex);
    }
    return member;
  }
 /**
   * Performs the sending of the membership list, after we have incremented our own heartbeat.
   * 在自增心跳之后，发送成员列表
   */
  protected void sendMembershipList(LocalMember me, LocalMember member) {
    if (member == null){
      return;
    }
    long startTime = System.currentTimeMillis();
    me.setHeartbeat(System.nanoTime());
    //保活gossip消息
    UdpActiveGossipMessage message = new UdpActiveGossipMessage();
    message.setUriFrom(gossipManager.getMyself().getUri().toASCIIString());
    message.setUuid(UUID.randomUUID().toString());
    message.getMembers().add(convert(me));
    for (LocalMember other : gossipManager.getMembers().keySet()) {
      message.getMembers().add(convert(other));
    }
    Response r = gossipCore.send(message, member.getUri());
    if (r instanceof ActiveGossipOk){
      //maybe count metrics here
    } else {
      LOGGER.debug("Message " + message + " generated response " + r);
    }
    sendMembershipHistogram.update(System.currentTimeMillis() - startTime);
  }

发送活跃节点消息，实际随机从活跃节点的信息，将当前节点的活跃节点信息包装保活gossip消息发送给筛选出的节点。发送宕机节点的原理一致。发送消息委托给core组件。

再来看发送共享数据

//SimpleActiveGossiper

 @Override
  public void init() {
    super.init();
    scheduledExecutorService.scheduleAtFixedRate(() -> {
      threadService.execute(() -> {
        //发送Live成员
        sendToALiveMember();
      });
    }, 0, gossipManager.getSettings().getGossipInterval(), TimeUnit.MILLISECONDS);
    scheduledExecutorService.scheduleAtFixedRate(() -> {
      //发送Dead成员
      sendToDeadMember();
    }, 0, gossipManager.getSettings().getGossipInterval(), TimeUnit.MILLISECONDS);
    scheduledExecutorService.scheduleAtFixedRate(
            //发送节点数据
            () -> sendPerNodeData(gossipManager.getMyself(),
                    selectPartner(gossipManager.getLiveMembers())),
            0, gossipManager.getSettings().getGossipInterval(), TimeUnit.MILLISECONDS);
    scheduledExecutorService.scheduleAtFixedRate(
            //发送共享数据
            () -> sendSharedData(gossipManager.getMyself(),
                    selectPartner(gossipManager.getLiveMembers())),
            0, gossipManager.getSettings().getGossipInterval(), TimeUnit.MILLISECONDS);
  }

//AbstractActiveGossiper

 /**
   * 发送共享该数据
   * @param me
   * @param member
   */
  public final void sendSharedData(LocalMember me, LocalMember member) {
    if (member == null) {
      return;
    }
    long startTime = System.currentTimeMillis();
    if (gossipSettings.isBulkTransfer()) {
      sendSharedDataInBulkInternal(me, member);
    } else {
      sendSharedDataInternal(me, member);
    }
    sharedDataHistogram.update(System.currentTimeMillis() - startTime);
  }

 /**
   * Send shared data one entry at a time.
   * 发送共享数据
   * @param me
   * @param member
   */
  private void sendSharedDataInternal(LocalMember me, LocalMember member) {
    for (Entry innerEntry : gossipCore.getSharedData().entrySet()){
      if (innerEntry.getValue().getReplicable() != null && !innerEntry.getValue().getReplicable()
              .shouldReplicate(me, member, innerEntry.getValue())) {
        //不可复制，则直接do nothing
        continue;
      }
      //拷贝共享数据
      UdpSharedDataMessage message = new UdpSharedDataMessage();
      message.setUuid(UUID.randomUUID().toString());
      message.setUriFrom(me.getId());
      copySharedDataMessage(innerEntry.getValue(), message);
      gossipCore.sendOneWay(message, member.getUri());
    }
  }

发送共享数据实际为通过core组件将共享数据保证成UdpSharedDataMessage并发送给peer节点。节点数据原理一致，只不过发送的是节点数据。

core组件

public class GossipCore implements GossipCoreConstants {

  class LatchAndBase {
    /**
     * 请求锁
     */
    private final CountDownLatch latch;
    /**
     * 消息
     */
    private volatile Base base;
    
    LatchAndBase(){
      latch = new CountDownLatch(1);
    }
    
  }
  public static final Logger LOGGER = Logger.getLogger(GossipCore.class);
  private final GossipManager gossipManager;
  /**
   * 可追溯的请求
   */
  private ConcurrentHashMap requests;
  /**
   * 每个节点的数据
   */
  private final ConcurrentHashMap> perNodeData;
  /**
   * 共享数据集
   */
  private final ConcurrentHashMap sharedData;
  private final Meter messageSerdeException;
  /**
   * 传输异常度量器
   */
  private final Meter transmissionException;
  /**
   * 传输成功度量器
   */
  private final Meter transmissionSuccess;
  private final DataEventManager eventManager;
  
  public GossipCore(GossipManager manager, MetricRegistry metrics){
    this.gossipManager = manager;
    requests = new ConcurrentHashMap<>();
    perNodeData = new ConcurrentHashMap<>();
    sharedData = new ConcurrentHashMap<>();
    eventManager = new DataEventManager(metrics);
    metrics.register(PER_NODE_DATA_SIZE, (Gauge)() -> perNodeData.size());
    metrics.register(SHARED_DATA_SIZE, (Gauge)() ->  sharedData.size());
    metrics.register(REQUEST_SIZE, (Gauge)() ->  requests.size());
    messageSerdeException = metrics.meter(MESSAGE_SERDE_EXCEPTION);
    transmissionException = metrics.meter(MESSAGE_TRANSMISSION_EXCEPTION);
    transmissionSuccess = metrics.meter(MESSAGE_TRANSMISSION_SUCCESS);
  }
  ...
}

//GossipCore

 /**
   * 接受消息
   * @param base
   */
  public void receive(Base base) {
    if (!gossipManager.getMessageHandler().invoke(this, gossipManager, base)) {
      LOGGER.warn("received message can not be handled");
    }
  }

//SharedDataMessageHandler

public class SharedDataMessageHandler implements MessageHandler{
  
  /**
   * @param gossipCore context.
   * @param gossipManager context.
   * @param base message reference.
   * @return boolean indicating success.
   */
  @Override
  public boolean invoke(GossipCore gossipCore, GossipManager gossipManager, Base base) {
    UdpSharedDataMessage message = (UdpSharedDataMessage) base;
    //添加共享数据
    gossipCore.addSharedData(message);
    return true;
  }
}

//GossipCore

 /**
   * 添加共享数据
   * @param message
   */
  @SuppressWarnings({ "unchecked", "rawtypes" })
  public void addSharedData(SharedDataMessage message) {
    while (true){
      SharedDataMessage previous = sharedData.putIfAbsent(message.getKey(), message);
      if (previous == null){
        eventManager.notifySharedData(message.getKey(), message.getPayload(), null);
        return;
      }
      if (message.getPayload() instanceof Crdt){
        //合并共享数据
        SharedDataMessage merged = new SharedDataMessage();
        merged.setExpireAt(message.getExpireAt());
        merged.setKey(message.getKey());
        merged.setNodeId(message.getNodeId());
        merged.setTimestamp(message.getTimestamp());
        Crdt mergedCrdt = ((Crdt) previous.getPayload()).merge((Crdt) message.getPayload());
        merged.setPayload(mergedCrdt);
        boolean replaced = sharedData.replace(message.getKey(), previous, merged);
        if (replaced){
          if(!merged.getPayload().equals(previous.getPayload())) {
            eventManager
                    .notifySharedData(message.getKey(), merged.getPayload(), previous.getPayload());
          }
          return;
        }
      } else {
        //非CRDT数据，已最新数据为准
        if (previous.getTimestamp() < message.getTimestamp()){
          boolean result = sharedData.replace(message.getKey(), previous, message);
          if (result){
            eventManager.notifySharedData(message.getKey(), message.getPayload(), previous.getPayload());
            return;
          }
        } else {
          return;
        }
      }
    }
  }

peer节点接收消息后，调用消息处理器，处理消息，针对共享数据，如果基于CRDT的数据则合并，否则更新，通知事件处理器；针对节点数据基本相同。

再来看发送数据

//GossipCore

/**
   * @param message
   * @param uri
   * @return
   */
  public Response send(Base message, URI uri){
    if (LOGGER.isDebugEnabled()){
      LOGGER.debug("Sending " + message);
      LOGGER.debug("Current request queue " + requests);
    }

    final Trackable t;
    LatchAndBase latchAndBase = null;
    if (message instanceof Trackable){
      t = (Trackable) message;
      latchAndBase = new LatchAndBase();
      //放入请求集
      requests.put(t.getUuid() + "/" + t.getUriFrom(), latchAndBase);
    } else {
      t = null;
    }
    sendInternal(message, uri);
    if (latchAndBase == null){
      return null;
    }
    
    try {

      boolean complete = latchAndBase.latch.await(1, TimeUnit.SECONDS);
      if (complete){
        //等待结果
        return (Response) latchAndBase.base;
      } else{
        return null;
      }
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    } finally {
      if (latchAndBase != null){
        //移除高清球
        requests.remove(t.getUuid() + "/" + t.getUriFrom());
      }
    }
  }

  /**
   * Sends a message across the network while blocking. Catches and ignores IOException in transmission. Used
   * when the protocol for the message is not to wait for a response
   * 发送网络消息。忽略，并捕捉传输的io异常。一般用于不需要回复的协议消息
   * @param message the message to send
   * @param u the uri to send it to
   */
  public void sendOneWay(Base message, URI u) {
    try {
      sendInternal(message, u);
    } catch (RuntimeException ex) {
      LOGGER.debug("Send one way failed", ex);
    }
  }
   /**
   * Sends a blocking message.
   * todo: move functionality to TransportManager layer.
   * @param message
   * @param uri
   * @throws RuntimeException if data can not be serialized or in transmission error
   */
  private void sendInternal(Base message, URI uri) {
    byte[] json_bytes;
    try {
      json_bytes = gossipManager.getProtocolManager().write(message);
    } catch (IOException e) {
      messageSerdeException.mark();
      throw new RuntimeException(e);
    }
    try {
      gossipManager.getTransportManager().send(uri, json_bytes);
      transmissionSuccess.mark();
    } catch (IOException e) {
      transmissionException.mark();
      throw new RuntimeException(e);
    }
  }

core组件发送消息实际是委托底层的UDP传输管理器进行传输。

gossip管理器

public abstract class GossipManager {

  public static final Logger LOGGER = Logger.getLogger(GossipManager.class);
  
  // this mapper is used for ring and user-data persistence only. NOT messages.
  public static final ObjectMapper metdataObjectMapper = new ObjectMapper() {
    private static final long serialVersionUID = 1L;
  {
    enableDefaultTyping();
    configure(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS, false);
  }};

  /**
   * gossip 成员
   */
  private final ConcurrentSkipListMap members;
  /**
   * 当前节点信息
   */
  private final LocalMember me;
  /**
   * gossip协议配置
   */
  private final GossipSettings settings;
  /**
   * gossip服务运行状态
   */
  private final AtomicBoolean gossipServiceRunning;

  /**
   * gossip 节点管理
   */
  private TransportManager transportManager;
  /**
   * 协议管理器
   */
  private ProtocolManager protocolManager;
  
  private final GossipCore gossipCore;
  private final DataReaper dataReaper;
  /**
   * 时钟
   */
  private final Clock clock;
  /**
   * 调度器
   */
  private final ScheduledExecutorService scheduledServiced;
  private final MetricRegistry registry;
  /**
   * 节点gossip成员持久器
   */
  private final RingStatePersister ringState;
  /**
   * 用户数据持久器
   */
  private final UserDataPersister userDataState;
  /**
   * 成员状态刷新器
   */
  private final GossipMemberStateRefresher memberStateRefresher;

  /**
   * 消息处理器
   */
  private final MessageHandler messageHandler;
  private final LockManager lockManager;

  /**
   * @param cluster
   * @param uri
   * @param id
   * @param properties  成员属性
   * @param settings
   * @param gossipMembers
   * @param listener
   * @param registry
   * @param messageHandler
   */
  public GossipManager(String cluster,
                       URI uri, String id, Map properties, GossipSettings settings,
                       List gossipMembers, GossipListener listener, MetricRegistry registry,
                       MessageHandler messageHandler) {
    this.settings = settings;
    this.messageHandler = messageHandler;
    //创建系统时钟
    clock = new SystemClock();
    //本地gossip成员
    me = new LocalMember(cluster, uri, id, clock.nanoTime(), properties,
            settings.getWindowSize(), settings.getMinimumSamples(), settings.getDistribution());
    gossipCore = new GossipCore(this, registry);
    this.lockManager = new LockManager(this, settings.getLockManagerSettings(), registry);
    dataReaper = new DataReaper(gossipCore, clock);
    members = new ConcurrentSkipListMap<>();
    for (Member startupMember : gossipMembers) {
      if (!startupMember.equals(me)) {
        LocalMember member = new LocalMember(startupMember.getClusterName(),
                startupMember.getUri(), startupMember.getId(),
                clock.nanoTime(), startupMember.getProperties(), settings.getWindowSize(),
                settings.getMinimumSamples(), settings.getDistribution());
        //TODO should members start in down state?
        members.put(member, GossipState.DOWN);
      }
    }
    gossipServiceRunning = new AtomicBoolean(true);
    this.scheduledServiced = Executors.newScheduledThreadPool(1);
    this.registry = registry;
    //gossip成员持久器
    this.ringState = new RingStatePersister(GossipManager.buildRingStatePath(this), this);
    //用户数据持久器
    this.userDataState = new UserDataPersister(
        gossipCore,
        GossipManager.buildPerNodeDataPath(this),
        GossipManager.buildSharedDataPath(this));
    //gossip成员状态刷新器
    this.memberStateRefresher = new GossipMemberStateRefresher(members, settings, listener, this::findPerNodeGossipData);
    //加载节点gossip成员
    readSavedRingState();
    //加载节点及共享数据
    readSavedDataState();
  }
...
}

gossip管理器，对集群的成员、消息处理、全局配置、节点状态持久器、用户数据持久器，协议管理器，udp传输管理器进行集成。我们来
简单看一下共享数据持久器；

public class UserDataPersister implements Runnable {
  
  private static final Logger LOGGER = Logger.getLogger(UserDataPersister.class);
  private final GossipCore gossipCore;

  /**
   * 节点数据文件
   */
  private final File perNodePath;
  /**
   * 节点共享数据文件
   */
  private final File sharedPath;
  private final ObjectMapper objectMapper;
  
  UserDataPersister(GossipCore gossipCore, File perNodePath, File sharedPath) {
    this.gossipCore = gossipCore;
    this.objectMapper = GossipManager.metdataObjectMapper;
    this.perNodePath = perNodePath;
    this.sharedPath = sharedPath;
  }

  /**
   * 从磁盘加载节点数据
   * @return
   */
  @SuppressWarnings("unchecked")
  ConcurrentHashMap> readPerNodeFromDisk(){
    if (!perNodePath.exists()) {
      return new ConcurrentHashMap>();
    }
    try (FileInputStream fos = new FileInputStream(perNodePath)){
      return objectMapper.readValue(fos, ConcurrentHashMap.class);
    } catch (IOException e) {
      LOGGER.debug(e);
    }
    return new ConcurrentHashMap>();
  }

  /**
   *
   */
  void writePerNodeToDisk(){
    try (FileOutputStream fos = new FileOutputStream(perNodePath)){
      objectMapper.writeValue(fos, gossipCore.getPerNodeData());
    } catch (IOException e) {
      LOGGER.warn(e);
    }
  }
  
  void writeSharedToDisk(){
    try (FileOutputStream fos = new FileOutputStream(sharedPath)){
      objectMapper.writeValue(fos, gossipCore.getSharedData());
    } catch (IOException e) {
      LOGGER.warn(e);
    }
  }

  /**
   * 从磁盘加载共享数据
   * @return
   */
  @SuppressWarnings("unchecked")
  ConcurrentHashMap readSharedDataFromDisk(){
    if (!sharedPath.exists()) {
      return new ConcurrentHashMap<>();
    }
    try (FileInputStream fos = new FileInputStream(sharedPath)){
      return objectMapper.readValue(fos, ConcurrentHashMap.class);
    } catch (IOException e) {
      LOGGER.debug(e);
    }
    return new ConcurrentHashMap();
  }
  
  /**
   * Writes all pernode and shared data to disk 
   */
  @Override
  public void run() {
    writePerNodeToDisk();
    writeSharedToDisk();
  }
}

用户数据持久UserDataPersister，主要是在节点宕机将用户数据持久化的磁盘，启动时，在从磁盘加载。节点状态持久化器原理相似。

总结

gossip是基于UDP协议进行通信的，底层是通过UDP管理器进行消息的收发；消息编解码器使用的是JSON序列化方式，节点接收消息后，有解码器进行解码，委托消息处理器处理，消息处理器有节点数据、共享数据、及宕机消息等。集群中的节点的状态同步通过节点状态刷新器进行同步。针对族活跃节点、宕机节点、节点数据，及共享数据的同步通过数据同步器完成。core组件对节点、共享数据进行管理，及消息的收发。gossip管理器持久节点状态、数据及共享数据。

UDP传输管理UdpTransportManager，主要发送字节数据，接收字节数据，并委托给core组件。在UDP传输管理器启动的过程中，同时启动节点状态刷新器。

消息编解码器JacksonProtocolManager是基于JSON的消息编解码，如果是RSA加签方式，则在收发消息，做响应的加解密。

共享数据和节点数据处理实际是委托给core组件，宕机消息转换为节点消息进行处理。

节点状态刷新器GossipMemberStateRefresher，通过宕机探测器FailureDetector，探测节点的存活状态，并更新节点状态，针对状态变更的，要通知响应的监听器。

数据同步器，同步活跃、宕机成员，节点数据、共享数据。发送活跃节点消息，实际随机从活跃节点的信息，将当前节点的活跃节点信息包装保活gossip消息发送给筛选出的节点。发送宕机节点的原理一致。发送消息委托给core组件。发送共享数据实际为通过core组件将共享数据保证成UdpSharedDataMessage并发送给peer节点。节点数据原理一致，只不过发送的是节点数据。

peer节点接收消息后，调用消息处理器，处理消息，针对共享数据，如果基于CRDT的数据则合并，否则更新，通知事件处理器；针对节点数据基本相同。core组件发送消息实际是委托底层的UDP传输管理器进行传输。

gossip管理器，对集群的成员、消息处理、全局配置、节点状态持久器、节点数据持久器、共享数据持久器，协议管理器，udp传输管理器进行集成。

附

Gossip

P2P 网络核心技术：Gossip 协议
漫谈 Gossip 协议
浅谈集群版Redis和Gossip协议

incubator-retired-gossip
apache gossip

分布式一致性算法-CRDT一
分布式一致性算法-CRDT二
分布式CRDT模型
如何选择地理分布式双活策略：合并复制和CRDT之对比
何时使用基于CRDT的数据库
基于TLA+的CRDT协议验证框架

单实例比redis吞吐大12倍，Anna用了什么黑科技？

Kademlia

P2P 网络核心技术：Kademlia 协议
Kademlia协议
Kademlia
OpenKAD github
openkad google

你可能感兴趣的:(incubator-gossip框架设计)

  • 自己实现一个简易RPC调用框架 殷俊杰
    最近在看dubbo，去创始人之一梁飞大神的博客搂了几眼，找到这个demo自己实现了一下，关于dubbo就不再介绍了，快速开始、框架设计、设计原则官网都有，有兴趣可以自己看Dubbo官网1.服务接口packagecom.yjj.my.api;/***@Description:*@Author:yinjunjie*@CreateDate:2018/8/713:16*@Version:1.0*/publ
  • Flutter电商项目实践-架构设计 Zhouztashin Flutterflutter电子商务项目架构
    1、框架设计图框架设计总体说明整个框架划分成业务层、组件层、基础层与外部层。其中外部层对应着第三方或者自己封装的提供单独功能的依赖库，基础层主要对应着非UI的基础性功能，组件层对应着UI功能的基础性功能，可以向业务层提供完整可以使用的UI组件功能。业务层则是应用的核心，除了外部层之外，组件层、基础层以库的形式提供给业务层使用，这样的好处是提高了这两层的复用性。框架设计原则层级职责划分需要单一且清晰
  • Livewire Flash 教程 巫文钧Jill
    LivewireFlash教程livewire-flashALaravelLivewire-basedFlashmessagecomponent项目地址:https://gitcode.com/gh_mirrors/li/livewire-flash项目介绍LivewireFlash是一个专为Laravel框架设计的Livewire组件，它提供了简单易用的方式来添加和显示flashed（闪烁）消息
  • Laravel Prometheus Exporter 教程 郁俪晟Gertrude
    LaravelPrometheusExporter教程laravel-prometheus-exporterAprometheusexporterforLaravel项目地址:https://gitcode.com/gh_mirrors/la/laravel-prometheus-exporter项目介绍LaravelPrometheusExporter是一个专为Laravel框架设计的开源工具，
  • 基于ThinkPHP5的旧衣回收小程序——二手交换废物系统的设计与实现 IT实战课堂—x小凡同学 Java毕业设计项目小程序
    摘要：随着社会的快速发展和人们生活水平的提高，旧衣物数量迅速增加，传统的旧衣处理方式已难以满足现代社会的需求。为了有效减少资源浪费，提高旧衣物的利用率，本文基于ThinkPHP5框架设计并实现了一款旧衣回收小程序——二手交换废物系统。该系统通过线上平台，实现旧衣物的回收、分类、展示、交换等功能，为用户提供了一种便捷、环保的旧衣处理方式。本文将从系统需求分析、系统设计、系统实现、系统测试与评估等方面
  • 目标检测-YOLOv4 wydxry 深度学习目标检测YOLO目标跟踪
    YOLOv4介绍YOLOv4是YOLO系列的第四个版本，继承了YOLOv3的高效性，并通过大量优化和改进，在目标检测任务中实现了更高的精度和速度。相比YOLOv3，YOLOv4在框架设计、特征提取、训练策略等方面进行了全面升级。它在保持实时检测的同时，显著提升了检测性能，尤其在复杂场景中的表现尤为出色。相比YOLOv3的改进与优势改进的Backbone(CSPDarknet-53)YOLOv4使用
  • SLG服务器框架设计说明 我叫向左转 服务器网络游戏golang
    一、SLG服务器业务特点同屏数据量大一次同屏请求可能需要传输上千单位的数据同屏人数多同屏的某个单位变动,需要同步近千人同屏频率高玩家可以随意拖动屏幕切换不同的位置,每次需要同步大量数据玩家交互频繁玩家间交互频繁,因为游戏主要以GVG为主,频繁的与其他玩家交换数据复杂计算多由于是大地图自由行军,超大地图的寻路带来较高压力计算,地图越复杂,计算压力越大计时任务多SLG中存在大量计时任务,行军计时,建造
  • 开源战棋 SLG 游戏框架设计思考（二）规则系统要考虑的因素 weixin_30367169
    游戏对象1.地块方格地形：山脉、丘陵、乔木林、灌木林、平原、河流、湖泊、海洋、雪原、沼泽、沙漠、暗礁、滩涂、岛屿等等（需完善）设施：铁路、公路、桥梁、机场、城市、村庄、岸防炮、要塞、废墟等等（需完善）移动力需求工事等级（影响防御效率）隐匿性（影响防御效率）天气（如果地图比例尺太大可能不同区域的天气不一样，因此天气与每个地块方格相关联）海拔、气温、风向、风速（影响细菌武器、化学武器、核武器破坏力）各
  • 前端MVVM框架设计及实现（一） baoaoba9317 前端设计模式数据结构与算法ViewUI
    最近抽出点时间想弄个dom模块化的模板引擎，不过现在这种都是MVVM自带的，索性就想自己造轮子写一个简单的MVVM框架了借鉴的自然还是从正美的avalon开始了，我记得还是去年6月写过一个系列的avalon源码分析的，不过那时候0.7版本，不够健全，现在已经好太多了框架是面向一个领域，提供一套解决方案，那么我们用前端的MVVM能为我们带来什么便利？关注点分离操作数据即操作DOM动态模板关注点分离是
  • JavaScript常用前端框架和库浅谈_前端框架设计-js 2401_84435885 javascript前端框架开发语言
    Vue.js：Vue.js是一个轻量级的JavaScript框架，用于构建用户界面。它采用了组件化的开发模式，类似于React。Vue.js的核心概念包括组件、指令和响应式数据等。Vue.js还提供了一种称为VueRouter的路由管理工具和Vuex状态管理库。Vue.js的最佳实践包括组件化开发、单文件组件、响应式数据和虚拟DOM等。使用方法：安装Vue.js：使用npm或yarn进行安装。创建
  • 【项目日记】高并发内存池---实现线程缓存 叫我龙翔 我的项目从零开始的C++生活缓存c++哈希
    比起那些用大嗓门企图压制世界的人，让全世界都安静下来听你小声说话的人更可畏。---韩寒《告白与告别》---高并发内存池项目---实现线程缓存1框架设计2自由链表类和哈希规则2.1自由链表类2.2映射规则3实现线程缓存3.1申请内存3.2释放内存4多线程优化5运行测试1框架设计我们需要实现的是一个这样的效果：线程缓存（256KB）中每个空间位置映射到在哈希表上，对应一个自由链表，申请空间时从自由链表
  • 推荐使用：react-qr-code - 灵活高效的React和React Native二维码组件 纪亚钧
    推荐使用：react-qr-code-灵活高效的React和ReactNative二维码组件react-qr-codeAQRcodegeneratorforReactandReactNative.项目地址:https://gitcode.com/gh_mirrors/re/react-qr-code1、项目介绍react-qr-code是一个专为React框架设计的二维码组件库，同时也支持Reac
  • Rider for Mac v2024.1.0 跨平台.NET IDE集成开发 狂风和暴雨 macos.netide
    RiderforMac是JetBrains公司推出的一款跨平台开发工具，特别针对.NET和.NETCore框架设计。它为.NET开发人员提供了一个强大的编程环境和工具集，使他们能够更高效地进行.NET应用程序的开发、调试、测试和部署。前往Mac粉笔下载RiderforMacv2024.1.0跨平台.NETIDE集成开发激活版-Mac粉笔网(macfb.com)RiderforMac具备多项优秀功能
  • 微信小程序-wxml语法 卡卡舅舅 微信小程序
    介绍WXML（WeiXinMarkupLanguage）是框架设计的一套标签语言，可以进行页面布局，声明事件，数据绑定，条件判断。语法数据绑定{{message}}//page.jsPage({data:{//状态message:'HelloMINA!'}})列表渲染{{item}}//page.jsPage({data:{//状态array:['cat','dog']}})条件渲染WEBVIEW
  • QT 中 Graphics View 程序例子-Diagram Scene Example 火柴盒zhang 数据库qt开发语言1024程序员节
    一、概况本例演示如何使用图形视图框架。“图表场景”示例是一个应用程序，您可以在其中创建流程图。可以添加流程图形状和文本，并通过箭头连接形状，如上图所示。形状、箭头和文本可以赋予不同的颜色，并且可以更改文本的字体、样式和下划线。Qt图形视图框架设计用于管理和显示自定义2D图形项目。该框架的主要类是QGraphicsItem、QGraphicsScene和QGraphicsView。图形场景管理项目并
  • 嵌入式Qt 计算器界面设计代码重构 嵌入式_笔记 Qt重构
    一.计算器界面设计代码重构计算器界面设计：嵌入式Qt计算器界面设计-CSDN博客重构的概念：代码实现与代码重构的不同：软件开发过程：什么样的代码需要重构：计算器界面代码重构的框架设计：实验：计算器界面设计代码重构目录：QCalculatorUI.h：#ifndef_QCALCULATORUI_H_#define_QCALCULATORUI_H_#include#include#includecla
  • 【1105】备课备什么 杜香开花2008
    听干老师备课第一讲有感教了22年的书，最近四五年也特别重视学习，在我们这个十八线的小县城，自认为比较爱学习的人，可是今天听了干老师的文本分析、解读，以及对教学框架设计。我只有一个感受，我简直怀疑自己的教学能力了，自己的教学可能连合格也算不上吧。关于备课有几点感触：1.备课要备大概念2022版新课标颁布后，在加上当前双减背景下，教育必将会新来一场新的变革。真正好的教育，我们要带给孩子什么，不仅是知识
  • 跟着pink老师前端入门教程-day25 axiu呀 移动端HTML5+CSS3前端开发语言html5css3vscode
    4、阿里百秀首页案例4.1技术选型方案：我们采取响应式页面开发方案技术：bootstrap框架设计图：本设计图采用1280px设计尺寸4.2屏幕划分分析①屏幕缩放发现中屏幕和大屏幕布局是一致的。因此我们列定义为col-md-就可以了，md是大于等于970以上的②屏幕缩放发现小屏幕布局发生变化，因此我们需要为小屏幕根据需求改变布局③屏幕缩放发现超小屏幕布局又发生变化，因此我们需要为超小屏幕根据需求改
  • 【项目】高并发内存池 那个楠人 缓存c++c语言visualstudio散列表后端sql
    高并发内存池【项目】高并发内存池项目介绍这个项目做的是什么？内存池相关知识池化技术内存池malloc定长内存池的实现高并发内存池整体框架设计ThreadCache对齐规则封装FreeList类封装threadcache类TLS无锁访问CenctralCache整体设计页号规定span结构SpanList结构封装centralcache类PageCache整体设计封装pagecache类Thread
  • 浅谈 Angular 和 UI5 这两种前端框架里控件 ID 的设计思路差异
    最近笔者在工作中，修复了一些我团队负责的Angular应用里关于控件id的issue，正好我在从事Angular开发之前，使用UI5这个前端开发框架也工作了很多年。虽然二者都是优秀的企业级前端应用的开发框架，但二者无论是从设计理念还是开发思路上来说都有着很大的差异。所谓『管中窥豹，可见一斑』。本文从UI控件元素ID的生成逻辑这个切入点出发，向大家分享我对这两个前端框架设计理念差异的一些理解。我们先
  • SpringCloud微服务实战——搭建企业级开发框架（三十六）：使用Spring Cloud Stream实现消息中间件功能
      在以往消息队列的使用中，我们通常使用集成消息中间件开源包来实现对应功能，而消息中间件的实现又有多种，比如目前比较主流的ActiveMQ、RocketMQ、RabbitMQ、Kafka，Stream等，这些消息中间件的实现都各有优劣。  在进行框架设计的时候，我们考虑是否能够和之前实现的短信发送、分布式存储等功能一样，抽象统一消息接口，屏蔽底层实现，在用到消息队列时，使用统一的接口代码，然后在根
  • Vue组件（Component） Mr Robot 前端vue.js前端javascript
    Vue组件（Component）什么是组件组件的基本使用全局注册局部注册DOM模板解析说明组件（Component）是Vue最核心的功能部分，也是整个框架设计最精彩的地方，当然也是比较难掌握的。每个开发者都想在软件开发过程中使用之前写好的代码，但又担心引入这段代码会对现有的程序产生影响。WebComponents的出现提供了一种新的思路，可以自定义tag标签，并拥有自身的模板、样式和交互。什么是组
  • Disruptor介绍及原理讲解 作妖大鹅鹅
    简介Disruptor是一个无锁有界内存队列开源框架，最大的特点就是性能非常高高高。很多知名项目都有用到它比如我们熟悉的Log4j2.本文主要介绍它如何做到高性能，以及具体的框架设计。为什么性能这么强大？主要是因为有这三个法宝：RingBuffer，无锁设计和缓存行填充。RingBufferDisruptor底层采用RingBuffer的结构，RingBuffer大家都知道，就是一个循环使用下标的
  • UI自动化之python+pytest+allure+selenium Gia_ouyang pythonpythonui自动化
    一、基础搭建1.下载pycharm，配置环境变量2.安装对应版本的webdriver，将webdriver放在项目根目录3.pipinstallpytest4.pipinstallallure二、框架设计三、目录详解1.common读取yaml文件yaml_handle.py2.config路径及环境配置1)config.yaml2)path.py3.pages页面方法封装包括url打开，页面元素
  • python_pytest-软件测试UI自动化全集【2】之代码运行方式、入口 测试1枚 测试管理测试技术分析python出错处理pythonpytestuipycharm
    python_pytest-软件测试UI自动化全集【2】之代码运行方式、入口开头的不啦不啦就省去了，直接续上上篇。上篇讲到关于UI自动化项目的选取、UI用例的设计原则及UI代码的整个框架设计，文章链接如：UI自动化全集【1】今天我们讲一下写完page页面的对象层、操作层、业务层写完之后如果去运行这些代码（则开启自动操作UI界面），则以下截图的scriptscript文件-脚本入口（以模块为维度）脚
  • 我的语文教学框架 洛城忆呢
    【新网师·中学语文理想课堂课程·第三次作业】我的语文教学框架--让计划融入现实提交人：212272陈晨[email protected]河南省驻马店市实验中学【框架图示】【设计说明】框架图示中有两张图，第一张是我的语文教学框架，第二张是围绕这个教学框架设计的课程表。一、教学框架我把教学框架分为了四大类：不停实践，不停阅读，不停写作，不停思考。这四句话相信大家都不陌生，李镇西老师提出后我们一直在赞赏，
  • 2019-05-03 孙志新
    练书客复盘：本周完成事物清单完成通城的建群和话术设置完成通城的7天刻意练习《先发影响力》这本书完成莆田的建群和话术设置跟麦子团队打成实操项目引入合作完成实操的发售设计和话术完成实操的框架设计实操的组织架构和激励机制的60%完成学员摸底表单完成滴滴清单全员布置邀请三好爸爸加入团队
  • DataX详解和架构介绍 shandongwill 大数据DataX大数据详解
    系列文章目录一、DataX详解和架构介绍二、DataX源码分析JobContainer三、DataX源码分析TaskGroupContainer四、DataX源码分析TaskExecutor五、DataX源码分析reader六、DataX源码分析writer七、DataX源码分析Channel文章目录系列文章目录DataX是什么？DataX支持的数据源DataX的框架设计DataX核心架构核心模块
  • Java和Scala的区别 moose_killer javascala
    1、什么是ScalaScala是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台（Java虚拟机），并兼容现有的Java程序。2、为什么要学Scala1.优雅：这是框架设计师第一个要考虑的问题，框架的用户是应用开发程序员，API是否优雅直接影响用户体验。2.速度快：Scala语言表达能力强，一行代码抵得上Java多行，开发速度快；Scala
  • Spring MVC 随心者随心行
    SpringMVC与Struts2区别对比项目SpringMvcStruts2优势框架入口基于servlet基于filter两者有没有太大区别，只是配置方式不同框架设计思想控制器基于方法级别的拦截，处理器设计为单例处理设计为多例Struts2会比SpringMVC更加消耗内存参数传递参数通过方法入参传递参数通过类的成语变量传递Struts2通过成语变量传递参数，导致了参数线程不安全，有可能引发并发
  • mysql主从数据同步 林鹤霄 mysql主从数据同步
    配置mysql5.5主从服务器(转) 教程开始：一、安装MySQL 说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22  二、配置MySQL主服务器（192.168.21.169）mysql  -uroot  -p   &nb
  • oracle学习笔记 caoyong oracle
    1、ORACLE的安装    a>、ORACLE的版本    8i,9i :   i是internet    10g,11g : grid (网格)    12c : cloud (云计算)       b>、10g不支持win7 &
  • 数据库，SQL零基础入门 天子之骄 sql数据库入门基本术语
    数据库，SQL零基础入门        做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。          数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
  • pom.xml 一炮送你回车库 pom.xml
    1、一级元素dependencies是可以被子项目继承的 2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 3、父项目里的一级元素<modules> <module>lcas-admin-war</module> <
  • sql查地区省市县 3213213333332132 sqlmysql
    -- db_yhm_city SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35 SELECT * FROM db_yhm_city WHERE class_parent_id =169 SELECT d1.cla
  • 关于监听器那些让人头疼的事 宝剑锋梅花香 画图板监听器鼠标监听器
           本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。       
  • JAVA的遍历MAP darkranger map
    Java Map遍历方式的选择 1. 阐述 　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？ 　　为了解遍历性能的真实差距，包括在遍历ke
  • POJ 2312 Battle City 优先多列+bfs aijuans 搜索
    来源：http://poj.org/problem?id=2312 题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。 思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
  • Hibernate与Jpa的关系，终于弄懂 avords javaHibernate数据库jpa
    我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。 在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
  • 酸爽的console.log bee1314 console
    在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 /** * log.js hufeng * The safe wrapper for `console.xxx` functions *
  • 哈佛教授：穷人和过于忙碌的人有一个共同思维特质 bijian1013 时间管理励志人生穷人过于忙碌
            一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。 　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
  • other operate 征客丶 OSosx
    一、Mac Finder 设置排序方式，预览栏 在显示－》查看显示选项中 二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出， 我好及时改正，同时也让我们一
  • 【Scala五】分析Spark源代码总结的Scala语法三 bit1129 scala
    1. If语句作为表达式 val properties = if (jobIdToActiveJob.contains(jobId)) { jobIdToActiveJob(stage.jobId).properties } else { // this stage will be assigned to "default" po
  • ZooKeeper 入门 BlueSkator 中间件zk
    ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。 值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
  • MySQL取得当前时间的函数是什么 格式化日期的函数是什么 BreakingBad mysqlDate
    取得当前时间用 now() 就行。 在数据库中格式化时间 用DATE_FORMA T(date, format) . 根据格式串format 格式化日期或日期和时间值date，返回结果串。 可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值: %S, %s 两位数字形式的秒（ 00,01,
  • 读《研磨设计模式》-代码笔记-组合模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
  • 4_JAVA+Oracle面试题(有答案) chenke oracle
    基础测试题 卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。 选择题 1、 What will happen when you attempt to compile and run the following code? （3） public class Static { static { int x = 5; // 在static内有效 } st
  • 新一代工作流系统设计目标 comsci 工作算法脚本
      用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。 在这个设计中，最难的地方是系统根据什么来生成流
  • oracle 行链接与行迁移 daizj oracle行迁移
    表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 第一种情况: INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
  • [JShop]开源电子商务系统jshop的系统缓存实现 dinguangx jshop电子商务
    前言 jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
  • 初三全学年难记忆单词 dcj3sjt126com englishword
    several 儿子；若干 shelf 架子 knowledge 知识；学问 librarian 图书管理员 abroad 到国外，在国外 surf 冲浪 wave 浪；波浪 twice 两次；两倍 describe 描写；叙述 especially 特别；尤其 attract 吸引 prize 奖品；奖赏 competition 比赛；竞争 event 大事；事件 O
  • sphinx实践 dcj3sjt126com sphinx
      安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server   yum install sphinx 如果失败的话使用下面的方式安装 wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm yum loca
  • JPA之JPQL（三） frank1234 ormjpaJPQL
    1 什么是JPQL JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 2 检索单个对象 @Test public  void querySingleObject1() {     Query query = em.createQuery("sele
  • Remove Duplicates from Sorted Array II hcx2013 remove
    Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? For example,Given sorted array nums = [1,1,1,2,2,3], Your function should return length
  • Spring4新特性——Groovy Bean定义DSL jinnianshilongnian spring 4
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • CentOS安装Mysql5.5 liuxingguome centos
    CentOS下以RPM方式安装MySQL5.5 首先卸载系统自带Mysql： yum remove mysql mysql-server mysql-libs compat-mysql51 rm -rf /var/lib/mysql rm /etc/my.cnf 查看是否还有mysql软件： rpm -qa|grep mysql 去http://dev.mysql.c
  • 第14章 工具函数（下） onestopweb 函数
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • POJ 1050 SaraWon 二维数组子矩阵最大和
    POJ ACM第1050题的详细描述，请参照 http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 题目意思： 给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。 如二维数组 0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 中和最大的子矩阵是 9 2 -4 1 -1 8 且最大和是15
  • [5]设计模式——单例模式 tsface java单例设计模式虚拟机
    单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点   安全的单例模式：     /* * @(#)Singleton.java 2014-8-1 * * Copyright 2014 XXXX, Inc. All rights reserved. */ package com.fiberhome.singleton;
  • Java8全新打造，英语学习supertool yangshangchuan javasuperword闭包java8函数式编程
    superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。   升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他