python zmq(ZeorMQ)

pip install pyzmq

Three modes:

1. Request-Reply mode

Question and answer, client request, server reply

Which party can be started first, and cut off the middle of the client server reply after the break off does not matter.

server：

Import ZMQ 

context = zmq.Context () 
socket = context.socket (zmq.REP) # Set socket type 
Socket.bind ( ' TCP: // *: 15000 ' ) # port binding 

Message = socket.recv () # The received is byte type 
print (message) 

socket.send_string ( ' copy! ' )

client：

import zmq

context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect('tcp://localhost:15000')
socket.send_string('request')

message = socket.recv()
print(message)

Second, Publisher-Subscriber mode

One-to-many, one publisher, several subscribers. The subscriber side can filter the data by setting filters.

Publisher

import zmq
from random import randrange
 
context = zmq.Context()
socket = context.socket(zmq.PUB)
socket.bind("tcp://*:15000")
 
while True:
    socket.send_string("message")

Subscriber

import sys
import zmq

context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect("tcp://localhost:15000")
 
# 过滤器
zip_filter = sys.argv[1] if len(sys.argv) > 1 else "10002"
socket.setsockopt(zmq.SUBSCRIBE, zip_filter)

for i in range(5):
    msg = socket.recv()
    print msg 
 
print(msg)

Three, Push-Pull mode

The server push, all clients connected to the server pull, the difference is that only one client can pull, there is competition between them, the specific mechanism does not need to understand, this mode is similar to load balancing.

Server

import zmq

context = zmq.Context()
server = context.socket(zmq.PUSH)
server.bind('tcp://*:15000')

while True:
    server.send_string('Push')

Client

import zmq

context = zmq.Context()
client = context.socket(zmq.PULL)
client.connect('tcp://localhost:15000')
 
while True:
    msg = client.recv()

Question 1: If the client needs both pull mode and subscriber mode socket

import zmq
 
context = zmq.Context()
 
receiver = context.socket(zmq.PULL)
receiver.connect("tcp://localhost:5557")
 
subscriber = context.socket(zmq.SUB)
subscriber.connect("tcp://localhost:5556")
subscriber.setsockopt(zmq.SUBSCRIBE, b"10001")
 
poller = zmq.Poller()
poller.register(receiver, zmq.POLLIN)
poller.register(subscriber, zmq.POLLIN)
 
while True:
    try:
        socks = dict(poller.poll())
    except KeyboardInterrupt:
        break
 
    if receiver in socks:
        message = receiver.recv()
 
    if subscriber in socks:
        message = subscriber.recv()

Question 2: In the Request-Reply mode, if the pressure on the server is too high, how to balance the load on the server

The request from the client can be automatically allocated by adding an intermediate proxy.

Server

import zmq
 
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.connect("tcp://localhost:15000")
 
while True:
    message = socket.recv()
    socket.send_string("msg")

Urgent

import zmq
 
# Prepare our context and sockets
context = zmq.Context()
 
frontend = context.socket(zmq.ROUTER)
backend = context.socket(zmq.DEALER)
frontend.bind("tcp://*:15001")
backend.bind("tcp://*:15002")
 
poller = zmq.Poller()
poller.register(frontend, zmq.POLLIN)
poller.register(backend, zmq.POLLIN)
 
while True:
    socks = dict(poller.poll())
    
    if socks.get(frontend) == zmq.POLLIN:
        message = frontend.recv_multipart()
        backend.send_multipart(message)
    
    if socks.get(backend) == zmq.POLLIN:
        message = backend.recv_multipart()
        frontend.send_multipart(message)

Client

import zmq

context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:15001")
 
for request in range(1,11):
    socket.send_string("Hello")
    message = socket.recv()
socket.close()
context.term()

Guess you like