亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

為了賬號安全，請及時綁定郵箱和手機立即綁定

如何進行即時通訊心跳檢查的簡單教程

標簽：
C++ Go
概述

即时通讯心跳检查是保障系统稳定运行的关键机制，通过定期发送心跳包来确认连接状态。心跳包包含时间戳、序列号等信息，用于检测客户端或服务器是否在线。心跳检查有助于保持长连接、实现故障恢复，并帮助系统更好地管理资源。

理解即时通讯心跳检查的基本概念

即时通讯心跳检查是保障即时通信系统稳定运行的一种机制。在即时通讯系统中，心跳检查是一种常见的用于检测客户端或服务器是否在线、是否存活的技术手段。心跳检查通过定期发送心跳包来确认连接的状态，当一段时间内未收到响应时，可以认为该连接已经断开或出现异常。心跳包通常包含一些简单的数据，用于验证连接的活跃状态。

心跳检查的作用可以分为以下几个方面：

  • 检测连接状态：心跳检查可以帮助系统确定连接是否处于活跃状态。通过定期发送心跳包，如果在设定的时间内没有反馈响应，系统可以判断连接已经断开或者连接有问题。
  • 保持长连接：心跳检查有助于保持长连接的活跃状态。在一些应用中，比如WebSockets，长连接是保持实时通信的重要方式。心跳检查可以定期检测连接状态，避免因为长时间无通信而导致连接被网络中间设备（如路由器、防火墙）断开。
  • 故障恢复：心跳检查可以作为故障恢复机制的一部分。如果检测到连接异常，系统可以尝试自动重连或触发其他恢复措施，以保障服务的连续性和可用性。
  • 资源管理：通过心跳检查，系统可以更好地管理资源。例如，在服务器端可以通过心跳检查来确定哪些客户端是活跃的，从而在资源有限的情况下优先为活跃客户端提供服务。

心跳包通常是一个简单的数据包，包含一些基本信息，例如：

  • 时间戳：心跳包的时间戳可以用于计算心跳间隔和判断响应时间。
  • 序列号：心跳包通常会有一个序列号，用于标识心跳包的顺序，帮助系统识别心跳包是否按预期发送或接收。
  • 类型标识：心跳包通常包含一个类型标识，明确表明该数据包是一个心跳包，而不是其他类型的数据包。

心跳包的发送频率通常是一个预设的时间间隔，比如每隔几秒发送一次。心跳包的接收端会记录心跳包的接收时间，并根据设定的超时时间来进行判断。如果在预设的时间内没有收到心跳包，则认为连接已断开或出现异常。

心跳检查具体实现时，可以分为服务器主动发送心跳包或客户端主动发送心跳包，或者两者结合使用。在一些场景中，客户端和服务器可以相互发送心跳包，以确保双方都处于活跃状态。

心跳检查的应用非常广泛，不仅仅局限于即时通讯领域，还可以应用于各种需要长连接的网络场景，例如WebSockets、远程桌面、物联网设备通信等。

为什么需要进行即时通讯心跳检查

即时通讯心跳检查的必要性在于确保即时通讯系统能够稳定可靠地运行。心跳检查机制能有效地检测连接状态、保持长连接、实现故障恢复，并帮助系统更好地管理资源。以下是进行心跳检查的主要原因：

确保连接状态

在即时通讯系统中，网络连接状态的变化是常见的现象。由于网络环境的复杂性，连接可能会因为各种原因而断开或出现异常。例如，设备可能由于电池耗尽而关机，或者网络连接可能因为网络故障而中断。通过心跳检查，系统可以定期检测连接状态，确保连接处于活跃状态。如果在设定的时间间隔内没有收到心跳响应，则可以判断连接已断开或出现异常。

心跳检查的具体实现方式通常是服务器或客户端定期发送心跳包。心跳包是一种非常简单的小数据包，其主要目的是确认另一端是否在线。心跳包的格式通常包括一些基本信息，例如时间戳、序列号和类型标识。在发送心跳包后，发送方会等待一定时间，如果在预设的时间内没有收到响应，则认为连接已断开或出现异常。心跳包的发送频率通常是每几秒发送一次，以确保能够及时发现连接问题。

保持长连接

即时通讯系统通常依赖长连接进行实时通信。长连接的保持对于实时通信非常重要，因为它可以避免频繁建立和断开连接带来的开销。然而，长连接也可能因为长时间无通信而被网络中间设备（如路由器、防火墙）断开。心跳检查通过定期发送心跳包，可以有效避免这种情况的发生。当网络中间设备检测到心跳包传输时，会将其视为活跃连接，并不会主动断开连接。

心跳包不仅用于确认另一端的存在，还可以用于维持连接的活跃状态。服务器或客户端通过定期发送心跳包，可以让网络中间设备知道连接是活跃的，从而避免被误认为是空闲连接而被断开。这种机制特别适用于WebSockets等需要长时间维持连接的场景。心跳包的发送频率通常是一个可配置的参数，可以根据实际网络环境进行调整，以确保连接的稳定性和可靠性。

故障恢复

在即时通讯系统中，网络连接可能会因为各种原因而出现故障。例如，客户端设备可能会因为电池耗尽而关机，或者服务器可能会因为硬件故障而宕机。这些故障可能会导致连接中断，从而影响即时通讯的服务。心跳检查可以作为故障恢复机制的一部分，帮助系统在检测到连接异常时快速响应。

当心跳检查发现连接异常时，系统可以采取相应的恢复措施。例如，如果客户端发送的心跳包未能在预设时间内收到响应，则客户端可以尝试重新建立连接。同样，如果服务器未能收到客户端发送的心跳包，则服务器可以尝试主动发送心跳包以确认客户端的状态。在某些情况下，系统还可以通过心跳检查的结果来触发更复杂的恢复流程，例如通知管理员、切换到备用服务器等。

心跳检查的故障恢复机制可以大大提高系统的可用性和稳定性。通过定期发送和接收心跳包，系统可以及时发现并处理连接异常，从而避免服务中断。这种机制不仅适用于客户端和服务器之间的连接，还可以扩展到其他需要高可用性的网络服务中，例如远程桌面、物联网设备通信等。

资源管理

心跳检查也可以帮助系统更好地管理资源。在服务器端，通过心跳检查可以确定哪些客户端是活跃的，从而在资源有限的情况下优先为活跃客户端提供服务。这是因为心跳检查可以提供实时的连接状态信息，使得系统能够根据当前的状态动态调整资源分配。

例如，服务器可以维护一个心跳包接收记录，记录每个客户端发送心跳包的时间。当服务器收到心跳包时，可以更新该客户端的活跃状态。系统可以根据这些状态信息来决定哪些客户端需要优先资源，例如带宽、计算资源等。这样可以确保活跃的客户端得到充分的服务，而那些长时间没有活跃的客户端可以减少资源占用。

心跳检查还可以用于监控系统负载。通过心跳检查，系统可以了解当前连接的总数、活跃连接的数量等信息。这些数据可以帮助系统管理员更好地理解和优化系统性能。例如，管理员可以通过心跳检查的数据来判断是否需要增加服务器容量、调整网络配置等。

综上所述，心跳检查是一种简单而有效的机制，可以确保即时通讯系统的稳定性和可靠性。它不仅可以检测连接状态、保持长连接、实现故障恢复，还可以帮助系统更好地管理和监控资源。通过定期发送和接收心跳包，系统可以及时发现并处理连接异常，从而避免服务中断和资源浪费。

心跳检查的常见方法与实现步骤

即时通讯心跳检查的实现可以通过多种方法来达成，每种方法都有其适用场景和优势。以下是几种常见的心跳检查方法及其实现步骤：

服务器主动发送心跳包

实现步骤：

  1. 设置心跳包结构：心跳包通常包含一些基本信息，如时间戳、序列号和类型标识。
  2. 定时发送心跳包：服务器端设置一个定时器，定期发送心跳包到所有连接的客户端。
  3. 客户端接收并响应：客户端在接收到心跳包后，会进行处理并发送响应包给服务器，以确认客户端状态。
  4. 超时检测：服务器端设置一个超时时间，如果在设定的时间内未收到客户端响应，则认为客户端已断开或出现异常。

示例代码

import time
import threading

class HeartbeatServer:
    def __init__(self, interval=5):
        self.interval = interval
        self.clients = {}  # {client_id: timestamp}
        self.threads = {}

    def start(self):
        for client_id in self.clients:
            self.start_thread(client_id)
        while True:
            for client_id, thread in self.threads.items():
                if not thread.is_alive():
                    print(f"Client {client_id} is considered offline.")
                    del self.clients[client_id]
                    del self.threads[client_id]
            time.sleep(1)

    def start_thread(self, client_id):
        thread = threading.Thread(target=self.send_heartbeats, args=(client_id,))
        thread.start()
        self.threads[client_id] = thread

    def send_heartbeats(self, client_id):
        while True:
            if client_id not in self.clients:
                break
            print(f"Sending heartbeat to client {client_id}")
            self.clients[client_id] = time.time()
            time.sleep(self.interval)

# Example Usage
clients = {
    1: time.time(),
    2: time.time()
}

server = HeartbeatServer()
server.start()
客户端主动发送心跳包

实现步骤：

  1. 设置心跳包结构：心跳包通常包含一些基本信息，如时间戳、序列号和类型标识。
  2. 定时发送心跳包：客户端设置一个定时器，定期发送心跳包到服务器。
  3. 服务器接收并响应：服务器在接收到心跳包后，会进行处理并发送响应包给客户端，以确认服务器状态。
  4. 超时检测：客户端设置一个超时时间，如果在设定的时间内未收到服务器响应，则认为服务器已断开或出现异常。

示例代码

import time
import threading

class HeartbeatClient:
    def __init__(self, server_address, interval=5):
        self.server_address = server_address
        self.interval = interval
        self.last_heartbeat = time.time()

    def start(self):
        thread = threading.Thread(target=self.send_heartbeats)
        thread.start()

    def send_heartbeats(self):
        while True:
            self.send_heartbeat()
            time.sleep(self.interval)

    def send_heartbeat(self):
        print("Sending heartbeat to server")
        self.last_heartbeat = time.time()

# Example Usage
client = HeartbeatClient("127.0.0.1:8080")
client.start()
客户端和服务器双向心跳

实现步骤：

  1. 设置心跳包结构：心跳包通常包含一些基本信息，如时间戳、序列号和类型标识。
  2. 服务器定时发送心跳包：服务器端设置一个定时器，定期发送心跳包到客户端。
  3. 客户端定时发送心跳包：客户端也设置一个定时器，定期发送心跳包到服务器。
  4. 超时检测：在服务器和客户端两端，分别设置超时时间，如果在设定的时间内未收到响应，则认为对方已断开或出现异常。
  5. 响应处理：服务器和客户端在接收到心跳包后，会进行处理并发送响应包，以确认对方状态。

示例代码

import time
import threading

class HeartbeatServer:
    def __init__(self, interval=5):
        self.interval = interval
        self.clients = {}  # {client_id: timestamp}
        self.threads = {}

    def start(self):
        for client_id in self.clients:
            self.start_thread(client_id)
        while True:
            for client_id, thread in self.threads.items():
                if not thread.is_alive():
                    print(f"Client {client_id} is considered offline.")
                    del self.clients[client_id]
                    del self.threads[client_id]
            time.sleep(1)

    def start_thread(self, client_id):
        thread = threading.Thread(target=self.send_heartbeats, args=(client_id,))
        thread.start()
        self.threads[client_id] = thread

    def send_heartbeats(self, client_id):
        while True:
            if client_id not in self.clients:
                break
            print(f"Sending heartbeat to client {client_id}")
            self.clients[client_id] = time.time()
            time.sleep(self.interval)

class HeartbeatClient:
    def __init__(self, server_address, interval=5):
        self.server_address = server_address
        self.interval = interval
        self.last_heartbeat = time.time()

    def start(self):
        thread = threading.Thread(target=self.send_heartbeats)
        thread.start()

    def send_heartbeats(self):
        while True:
            self.send_heartbeat()
            time.sleep(self.interval)

    def send_heartbeat(self):
        print("Sending heartbeat to server")
        self.last_heartbeat = time.time()

# Example Usage
clients = {
    1: time.time(),
    2: time.time()
}

server = HeartbeatServer()
client = HeartbeatClient("127.0.0.1:8080")
client.start()
server.start()

这些方法各有优势，选择哪种方法取决于特定场景的需求。例如，如果需要确保服务器端能够及时发现客户端的问题，可以选择服务器主动发送心跳包的方法。如果需要确保客户端能够及时发现服务器的问题，可以选择客户端主动发送心跳包的方法。在某些情况下，为了确保双方都能及时发现对方的问题，可以选择客户端和服务器双向心跳的方法。

实战演练：使用一个简单的工具进行心跳检查

为了更好地了解心跳检查的实际应用，我们将使用一个简单的工具进行心跳检查的实战演练。这里我们将使用Python编写一个简单的服务器和客户端程序，用于演示心跳检查的实现过程。

服务器端实现

实现步骤：

  1. 设置心跳包格式：心跳包通常包含一些基本信息，如时间戳和类型标识。
  2. 定时发送心跳包：服务器端定期发送心跳包到客户端。
  3. 处理客户端响应：服务器端接收到客户端的心跳响应后，更新客户端的心跳时间戳。

示例代码

import time
import threading

class HeartbeatServer:
    def __init__(self, clients):
        self.clients = clients
        self.interval = 5  # 设置心跳间隔时间
        self.threads = {}

    def start(self):
        print("Heartbeat server started.")
        for client_id in self.clients:
            self.start_thread(client_id)
        while True:
            for client_id, thread in self.threads.items():
                if not thread.is_alive():
                    print(f"Client {client_id} is considered offline.")
                    del self.clients[client_id]
                    del self.threads[client_id]
            time.sleep(1)

    def start_thread(self, client_id):
        thread = threading.Thread(target=self.send_heartbeats, args=(client_id,))
        thread.start()
        self.threads[client_id] = thread

    def send_heartbeats(self, client_id):
        while True:
            if client_id not in self.clients:
                break
            print(f"Sending heartbeat to client {client_id}")
            self.clients[client_id]['last_heartbeat'] = time.time()
            time.sleep(self.interval)

# Example Usage
clients = {
    1: {'last_heartbeat': time.time()},
    2: {'last_heartbeat': time.time()}
}

server = HeartbeatServer(clients)
server.start()
客户端实现

实现步骤：

  1. 设置心跳包格式：心跳包通常包含一些基本信息，如时间戳和类型标识。
  2. 定时发送心跳响应：客户端定期发送心跳响应包到服务器。
  3. 处理服务器心跳包：客户端接收到服务器的心跳包后，更新心跳时间戳，并发送心跳响应。

示例代码

import time
import threading

class HeartbeatClient:
    def __init__(self, server_address, interval=5):
        self.server_address = server_address
        self.interval = interval
        self.last_heartbeat = time.time()

    def start(self):
        print("Heartbeat client started.")
        self.send_heartbeats()

    def send_heartbeats(self):
        while True:
            self.send_heartbeat()
            time.sleep(self.interval)

    def send_heartbeat(self):
        print("Sending heartbeat to server")
        self.last_heartbeat = time.time()

# Example Usage
client = HeartbeatClient("127.0.0.1:8080")
client.start()

整合服务器和客户端

为了确保整个系统的完整性，我们需要将服务器和客户端整合在一起。服务器接收心跳响应，并对客户端进行超时检测；客户端接收心跳包，并发送心跳响应。

服务器端整合代码

import time
import threading

class HeartbeatServer:
    def __init__(self, clients):
        self.clients = clients
        self.interval = 5  # 设置心跳间隔时间
        self.threads = {}

    def start(self):
        print("Heartbeat server started.")
        for client_id in self.clients:
            self.start_thread(client_id)
        while True:
            for client_id, thread in self.threads.items():
                if not thread.is_alive():
                    print(f"Client {client_id} is considered offline.")
                    del self.clients[client_id]
                    del self.threads[client_id]
            time.sleep(1)

    def start_thread(self, client_id):
        thread = threading.Thread(target=self.send_heartbeats, args=(client_id,))
        thread.start()
        self.threads[client_id] = thread

    def send_heartbeats(self, client_id):
        while True:
            if client_id not in self.clients:
                break
            print(f"Sending heartbeat to client {client_id}")
            self.clients[client_id]['last_heartbeat'] = time.time()
            time.sleep(self.interval)

# Example Usage
clients = {
    1: {'last_heartbeat': time.time()},
    2: {'last_heartbeat': time.time()}
}

server = HeartbeatServer(clients)
server.start()

客户端整合代码

import time
import threading

class HeartbeatClient:
    def __init__(self, server_address, interval=5):
        self.server_address = server_address
        self.interval = interval
        self.last_heartbeat = time.time()

    def start(self):
        print("Heartbeat client started.")
        self.send_heartbeats()

    def send_heartbeats(self):
        while True:
            self.send_heartbeat()
            time.sleep(self.interval)

    def send_heartbeat(self):
        print("Sending heartbeat to server")
        self.last_heartbeat = time.time()

# Example Usage
client = HeartbeatClient("127.0.0.1:8080")
client.start()
运行结果

运行上述代码后，可以看到服务器和客户端之间的心跳包交互情况。服务器端会定时发送心跳包到客户端，客户端接收到心跳包后会更新心跳时间戳，并发送心跳响应给服务器。服务器端会记录每个客户端的最后一次心跳时间，并在超时时间到达时认为客户端已断开。

运行示例

# 启动服务器端
python heartbeat_server.py

# 启动客户端
python heartbeat_client.py

运行上述命令后，你会在终端中看到类似以下输出：

Heartbeat server started.
Sending heartbeat to client 1
Sending heartbeat to client 2
Sending heartbeat to server
Sending heartbeat to server
Sending heartbeat to client 1
Sending heartbeat to client 2
Sending heartbeat to server
Sending heartbeat to server

通过上述示例，你可以看到心跳检查的完整过程，包括心跳包的发送和接收，以及超时检测。这种实现方式可以保证服务器和客户端之间的连接状态得到有效监控和维护。

常见问题与解决方案

在实现即时通讯心跳检查的过程中，可能会遇到一些常见问题。这些问题可能导致心跳检查机制无法正常工作或出现其他意外情况。以下是几个常见问题及其解决方案：

问题：心跳包被丢弃或延迟

心跳包被丢弃或延迟的原因可能是因为网络条件不稳定或中间设备（如路由器、防火墙）的问题。例如，如果网络中间设备在一定时间内没有接收到数据包，则可能会将连接视为空闲并中断连接。心跳包可能在传输过程中被丢弃或延迟，导致心跳检查机制无法正常工作。

解决方案

  • 增加心跳包频率：增加心跳包的发送频率可以减少心跳包被丢弃的概率。例如，可以将心跳包的发送时间间隔设置得更短，以确保更快地检测到连接问题。
  • 使用心跳探测功能：一些网络设备（如路由器、防火墙）提供了心跳探测功能，可以通过配置这些设备来避免误断连接。例如，可以通过配置路由器的“保持活跃连接”功能来确保心跳包能够顺利通过。
  • 心跳包重试机制：在心跳包发送失败或超时的情况下，客户端可以尝试重新发送心跳包，以确保心跳包能够被成功发送。此外，还可以设置重试次数和重试间隔时间，以增加心跳包发送的成功率。
问题：心跳包被误判为正常响应

心跳包被误判为正常响应可能是由于心跳包与正常通信数据包混淆或中间设备的过滤机制导致的。例如，某些中间设备可能会将心跳包误认为是正常数据包，从而导致心跳检查机制无法正确识别连接状态。

解决方案

  • 使用专门的心跳包类型：为心跳包设置一个专门的类型标识，例如在数据包中添加一个特殊的字段，用于标识该数据包是一个心跳包。这样，服务器端可以通过检查类型标识来区分心跳包和正常数据包，从而避免误判。
  • 时间戳验证：心跳包通常包含一个时间戳，服务器端可以通过检查心跳包的时间戳来验证心跳包的合法性。例如，心跳包的时间戳应该在合理的范围内，如果时间戳相差太大，则可能表示心跳包被延迟或篡改。
  • 序列号机制：心跳包通常包含一个序列号，服务器端可以通过检查序列号来验证心跳包的合法性。例如，心跳包的序列号应该按顺序递增，如果序列号不连续或跳过，则可能表示心跳包被丢弃或延迟。
问题：心跳包被篡改或伪造

心跳包被篡改或伪造可能是由于网络攻击或中间设备的篡改导致的。例如，恶意攻击者可能会篡改心跳包的内容，以干扰心跳检查机制的正常工作。

解决方案

  • 数据包校验：心跳包可以通过添加校验和（如CRC校验）来验证数据包的完整性。校验和可以确保数据包在传输过程中没有被篡改。例如，在心跳包中添加一个校验和字段，服务器端在接收到心跳包后，可以通过校验和来验证心跳包的完整性。
  • 加密传输：心跳包可以通过加密传输来防止被篡改或伪造。例如，心跳包可以通过TLS（传输层安全性）协议进行加密传输，这样即使心跳包被第三方截获，也无法篡改其内容。
  • 认证机制：心跳包可以通过认证机制来验证发送方的身份。例如，心跳包可以通过数字签名来验证发送方的身份。服务器端在接收到心跳包后，可以通过验证数字签名来确认心跳包的合法性。
问题：心跳包和正常数据包的冲突

心跳包和正常数据包的冲突可能是因为心跳包和正常数据包在传输过程中发生重叠导致的。例如，心跳包和正常数据包可能被同时发送，导致网络设备无法正确区分两者，从而影响心跳检查机制的正常工作。

解决方案

  • 心跳包优先级：心跳包可以通过设置优先级来确保心跳包优先传输。例如，心跳包可以设置为高优先级，正常数据包可以设置为低优先级。这样，心跳包可以在正常数据包之前传输，避免发生冲突。
  • 心跳包发送间隔：心跳包可以通过设置发送间隔来避免心跳包和正常数据包的冲突。例如，心跳包可以设置为每隔一段时间发送一次，这样可以确保心跳包不会与正常数据包同时发送。
  • 心跳包通道隔离：心跳包可以通过设置专用通道来避免心跳包和正常数据包的冲突。例如，心跳包可以通过专用的网络通道进行传输，这样可以避免心跳包与正常数据包在同一通道上传输，从而避免冲突。

通过以上解决方案，可以有效地解决心跳包在传输过程中可能遇到的各种问题，从而确保心跳检查机制的正常工作。

总结与后续学习建议

在本文中，我们详细介绍了即时通讯心跳检查的基本概念、实现步骤、常见方法及其实战演练。心跳检查是保证即时通讯系统稳定运行的重要机制，通过定期发送心跳包，可以确保连接的活跃状态，并实现故障恢复。

回顾心跳检查的关键点

  1. 心跳检查的基本功能：心跳检查通过定期发送心跳包来确认连接状态。心跳包通常包含时间戳、序列号等信息。
  2. 心跳检查的方法：心跳检查可以通过服务器主动发送心跳包、客户端主动发送心跳包，或者两者结合使用。每种方法都有其适用场景和优势。
  3. 心跳检查的实现步骤：心跳检查的具体实现包括设置心跳包结构、定时发送心跳包、接收并响应心跳包、超时检测等步骤。
  4. 实战演练：通过使用Python编写简单示例，演示了心跳检查的实现过程。服务器端定时发送心跳包，客户端接收并响应心跳包，确保连接状态的正常维护。
  5. 常见问题与解决方案：心跳包可能被丢弃、延迟、误判、篡改或伪造。通过增加心跳包频率、使用心跳包类型标识、设置优先级等方法，可以解决这些问题。

后续学习建议

  1. 深入学习网络编程：心跳检查机制依赖于网络编程技术，建议进一步学习TCP/IP协议、网络通信原理等知识。可以参考《TCP/IP详解》等经典书籍或慕课网上的相关课程。
  2. 实践更多的应用场景：尝试将心跳检查应用到不同的网络场景中，如WebSockets、远程桌面等。通过实践，可以更好地理解心跳检查在不同场景下的应用和优化。
  3. 网络设备配置：了解网络设备（如路由器、防火墙）的配置方法，确保心跳包能够顺利通过中间设备，避免被丢弃或延迟。
  4. 心跳包加密与认证：学习心跳包加密和认证技术，确保心跳包的安全性。了解TLS（传输层安全性）协议和数字签名等技术，提升心跳检查机制的安全性。
  5. 故障恢复机制：深入研究故障恢复机制的设计和实现，了解心跳检查如何与故障恢复机制结合，提高系统的稳定性和可用性。
  6. 性能优化：优化心跳检查机制的性能，减少心跳包的发送频率和网络开销。通过合理的设置心跳包的发送间隔，确保心跳检查机制的有效性和高效性。

通过这些学习和实践，可以更全面地掌握即时通讯心跳检查机制，进一步提升系统的设计和实现能力。

點擊查看更多內容
為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

作者其他優質文章

正在加載中
  • 推薦
  • 評論
  • 收藏
  • 共同學習，寫下你的評論
感謝您的支持，我會繼續努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進行掃碼打賞哦
今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與 放棄機會
微信客服

購課補貼
聯系客服咨詢優惠詳情

 幫助反饋 APP下載

慕課網APP
您的移動學習伙伴

 公眾號

掃描二維碼
關注慕課網微信公眾號

舉報

0/150
提交
取消