def main():
host = "0.0.0.0"
port = 80
addr = (host, port)
newTCPServer = TCP(addr, LaserQtRequestHandler)
print("等待客户端的连接...")
newTCPServer.serve_forever()
def __init__(self):
super(Receiver, self).__init__()
self.host = ''
self.port = 5678
self.addr = (self.host, self.port)
Receiver.tcp_server = TCP(self.addr, MyRequestHandler)
def main():
tcpServ = TCP(ADDR, MyRequestHandler)
print("-----waiting for connect-----")
tcpServ.serve_forever()
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
Host = ''
Port = 21567
Addr = (Host, Port)
class MyRequesHandler(SRH):
def handle(self):
print('... connected from:', self.client_address)
self.wfile.write(
('[%s] %s' % (ctime(), self.rfile.readline().decode())).encode())
tcpServ = TCP(Addr, MyRequesHandler)
print('waiting for connect')
tcpServ.serve_forever()
# x13socketserver1.py的服务器
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
host = '127.0.0.1'
port = 1311
addr = (host, port)
#创建请求处理类 继承BaseRequestandler并重写它的handle()方法
class MyRequestHandler(SRH):
def handle(self):
print('.......connected from:', self.client_address[0])
self.data = self.request.recv(1024).strip() #接收客户端的消息
print('---self.data---', self.data)
self.wfile.write(
('%s $$ %s' % ('socketserver', self.data.decode('utf-8'))
).encode('utf-8')) #向客户端发送消息
time = ctime().encode('utf-8')
self.wfile.write(('\nconnection %s: %s at %s succeed!' %
(host, port, ctime())).encode('utf-8'))
tcpServ = TCP(addr, MyRequestHandler) #实例化一个服务器类对象
print('waiting forconnection...')
tcpServ.serve_forever() #调用服务类对象的 handle_request() 或 serve_forever()方法来开始处理请求
#tcpServ.handle_request()客户端连接后关闭后 关闭tcpServ
如果QQ群已满，请访问https://geekori.com，在右侧查看最新的QQ群，同时可以扫码关注公众号
“欧瑞学院”是欧瑞科技旗下在线IT教育学院，包含大量IT前沿视频课程，
请访问http://geekori.com/edu或关注前面提到的订阅号和服务号，进入移动版的欧瑞学院
“极客题库”是欧瑞科技旗下在线题库，请扫描源代码根目录中的小程序码安装“极客题库”小程序
关于更多信息，请访问下面的页面
https://geekori.com/help/videocourse/readme.html
'''
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
host = ''
port = 9876
addr = (host, port)
class MyRequestHandler(SRH):
def handle(self):
print('客户端已经连接，地址：', self.client_address)
self.wfile.write(ctime().encode(encoding='utf-8') + b' ' +
self.rfile.readline())
print('正在等待客户端的连接')
tcpServer = TCP(addr, MyRequestHandler)
tcpServer.serve_forever()
#! /usr/bin/python
from socketserver import (StreamRequestHandler as SRH, TCPServer as TCP)
from time import ctime
HOST = ''
PORT = 8099
ADDR = (HOST, PORT)
class MyMsgHandler(SRH):
def handle(self):
print("....connecting from:", self.client_address)
strResponse = '%s : %s' % (ctime(), self.rfile.readline())
self.wfile.write(bytes(strResponse, 'utf-8'))
tcpServ = TCP(ADDR, MyMsgHandler)
print("waiting for connection....")
tcpServ.serve_forever()
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from MagnetFinder import sel
import urllib.parse
class MyTCPHandler(SRH):
def handle(self):
while True:
data = self.request.recv(1024) #把接收的数据实例化
if str(data).find('\\') > 0: jg = sel(data.decode('gbk'))
else: jg = sel(urllib.parse.unquote(data.decode('utf_8')))
self.request.sendall(jg.encode('utf_8'))
break
if __name__ == "__main__":
HOST, PORT = "127.0.0.1", 2333
# 把刚才写的类当作一个参数传给ThreadingTCPServer这个类，下面的代码就创建了一个多线程socket server
server = TCP((HOST, PORT), MyTCPHandler)
# 启动这个server,这个server会一直运行，除非按ctrl-C停止
server.serve_forever()
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
# 定义StreamRequestHandler子类，处理客户端连接
class MyRequestHanlder(SRH):
def handle(self):
print('...contected from:', self.client_address)
self.wfile.write(
('[%s] %s' % (ctime(), self.rfile.readline().decode())).encode())
tcpServ = TCP(ADDR, MyRequestHanlder)
print('waiting for connection...')
tcpServ.serve_forever()
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ""
PORT = 21567
ADDR = (HOST, PORT)
class MyRequeatHandler(SRH): #继承与实例化请求处理器类
def handle(self): #重写handle方法
print("...Connecting from: ", self.client_address)
temp = self.rfile.readline()
print(type(temp))
self.wfile.write(b"[%s]%s" % (bytes(ctime(), "utf-8"), temp))
tcpServ = TCP(ADDR, MyRequeatHandler) #设置地址与事件处理器
print("waiting for connection...")
tcpServ.serve_forever() #开启服务器无限循环
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from socketserver import TCPServer as TCP, StreamRequestHandler as SRH
from time import ctime
HOST = '' #表示本机下所有地址，相当于c语言中的INADDR_ANY
PORT = 50001
ADDR = (HOST, PORT)
class MyRequstHandler(SRH):
#覆写StreamRequestHandler中的handle,缺省是空函数
def handle(self):
print("...connected from :", self.client_address)
self.wfile.write(
(("[%s] %s") %
(ctime(),
self.rfile.readline().strip().decode('utf-8'))).encode('utf-8'))
tcp_serv = TCP(ADDR, MyRequstHandler)
print("Waiting for connection ...")
tcp_serv.serve_forever()
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 10002
ADDRESS = (HOST, PORT)
class MyRequestHandler(SRH):
def handle(self):
print('连接来自于: ', self.client_address)
data = self.rfile.readline().strip().decode()
print(data)
self.wfile.write(('[%s] %s' % (ctime(), data)).encode())
tcpServer = TCP(ADDRESS, MyRequestHandler)
print('等待连接')
tcpServer.serve_forever()
#!/usr/bin/python3
from socketserver import TCPServer as TCP, StreamRequestHandler as SRH
from time import ctime
import threading
ADDR = 'localhost', 21568
class MyRequestHandler(SRH):
'''创建请求类，处理客户请求'''
def handle(self):
# 请求处理
print(f'...connected from:{self.client_address}')
print(self.request)
print(threading.current_thread()) # 一直使用主线程，即没有开启新的线程
self.wfile.write(f'[{ctime()}] {self.rfile.readline()}'.encode('utf8'))
with TCP(ADDR, MyRequestHandler) as tcpServ:
tcpServ.fileno()
print('waiting for connection')
tcpServ.serve_forever() # 运行服务器，直到shutdown()
else:
request_html_name = STATIC_PATH + request_html_name
# 根据文件情况来返回相应的信息
try:
html_file = open(request_html_name, 'rb')
except FileNotFoundError:
# 文件不存在，则返回文件不存在，并返回状态码404
resp_headers = 'HTTP/1.1 404 not found\r\n'
resp_headers += "Server: PWB" + str(VERSION) + '\r\n'
resp_headers += '\r\n'
resp_body = '==== 404 file not found===='.encode('utf-8')
else:
# 文件存在，则读取文件内容，并返回状态码200
resp_headers = "HTTP/1.1 200 OK\r\n" # 200代表响应成功并找到资源
resp_headers += "Server: PWB" + str(VERSION) + '\r\n' # 告诉浏览器服务器
resp_headers += '\r\n' # 空行隔开body
resp_body = html_file.read() # 显示内容为读取的文件内容
html_file.close()
finally:
resp_data = resp_headers.encode('utf-8') + resp_body # 结合响应头和响应体
# 发送相应数据至浏览器
self.request.send(resp_data)
self.request.close() # HTTP短连接，请求完即关闭TCP连接
if __name__ == '__main__':
tcpServ = TCP(ADDR, MyRequestHandler) # 创建TCP服务器实例对象，并调用自定义请求处理子类
print('web server:PWB %s on port %d...\n' % (VERSION, PORT))
tcpServ.serve_forever() # 调用TCPServer的serve_forever来永久运行TCP服务器
finally:
if intCount != 0 and intCount in tboxDic:#.keys():
appMsgDic[intCount] = "^^^^^^^^^^^^^^^one cmd be called 2 this client $$$$$$$$$$$$$$$$$$$"
self.request.send(index_content.encode())
else:
self.request.send(notfind_content.encode())
#appCount -= 1
def startAppServer(server):
server.serve_forever()
if __name__ == '__main__':
TCP.allow_reuse_address = True
tcpServ = TCP((HOST, redFlagPORT), MyEchoHandler)
_thread.start_new_thread(startEchoServer, (tcpServ, ))
httpServ = TCP((HOST, appPORT), MyCmdHandler)
_thread.start_new_thread(startAppServer, (httpServ, ))
while True:
pass
# time.sleep(5)
#
# if tboxDic[0] != None:
# flag = 1
#! /usr/bin/env python
# -*- coding: UTF-8 -*-
#!/usr/bin/python3
from socketserver import (TCPServer as TCP , StreamRequestHandler as SRH )
from time import ctime
HOST = '127.0.0.1'
PORT = 10086
BUFSIZE = 1024
ADDR = (HOST , PORT)
class MyRequestHandle(SRH):
def handle(self):
print('...connect from:' , self.client_address)
#print(self.rfile.readline().decode())
# self.wfile.write(self.rfile.readline())
#print(ctime())
self.wfile.write( ('[%s] %s' % (ctime() , self.rfile.readline()) ).decode())
tcp_server = TCP(ADDR , MyRequestHandle)
print('waiting for connection...')
tcp_server.serve_forever()
#!/bin/env python3
#-*- coding:utf-8 -*-
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
import time
host = ''
port = 8989
addr = (host, port)
class mySocketSer(SRH):
def handle(self):
print('...connect from ', self.client_address)
time.sleep(10)
data = self.rfile.readline()
self.wfile.write(('[%s] %s' % (ctime(), data.decode())).encode())
tcp = TCP(addr, mySocketSer)
print('waiting for connetion...')
tcp.serve_forever()
from socketserver import StreamRequestHandler as SRH # 选择 TCP的处理器类
from socketserver import TCPServer as TCP
from time import ctime
HOST = ''
PORT = 8888
BUFSIZE = 1024
ADDR = (HOST, PORT)
'''处理器类部分'''
class myTcp(SRH): # 第二步：自定义处理器类的功能(这也是一个请求--request)
def handle(self):
print('client\'s address:', self.client_address), # 打印连接上的客户端的 ip地址
while True:
data = self.request.recv(BUFSIZE) # 从客户端接收信息
if not data:
break
print(data.decode('utf-8'))
reply = '[%s] %s' % (ctime(), data.decode('utf-8'))
self.request.sendall(reply.encode('utf-8')) # 向客户端发送信息
if __name__ == '__main__':
'''服务器类部分'''
tcpServ = TCP(ADDR, myTcp) # 第一步：.选择一个服务器类，并创建其对象
print("waiting for connecting...")
tcpServ.serve_forever() # 第三步：开启服务器
# encoding=utf-8
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 12345
ADDR = (HOST, PORT)
# 继承的用法
# readline()之后需要decode()方法。还是跟普通的tcp一样。接收到的信息需要解码，发送的信息需要编码
class MyRequestHandler(SRH):
def handle(self):
print('connect from ', self.client_address)
self.wfile.write(
('[%s] %s' % (ctime(), self.rfile.readline().decode())).encode())
tcp = TCP(ADDR, MyRequestHandler)
print('waiting for connection...')
tcp.serve_forever()
# перекрытие метода подкласса SRH. При получении сообщений от
# клиента происходит вызов данного метода. В классе SRH сокеты
# ввода и вывода расматриваются как объекты, подобные файлам,
# поэтому в сценарии используются функции readline() для
# получения сообщения от клиента и функции write() для отправки
# строки обратно клиенту
def handle(self):
self.data = self.rfile.readline().strip()
print('...conected from:', self.client_address[0])
# self.wfile.write(self.data)
data = bytes('[{}] {}'.format(ctime(), self.data), 'utf-8')
self.wfile.write(data)
if __name__ == "__main__":
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
server = TCP(ADDR, MyTCPHandler)
# # создаётся сервер TCP на основе заданной информации о хосте и
# класса обработчика запросов
try:
print('Waiting for connection...')
server.serve_forever()
# переход в бесконечный цикл
except KeyboardInterrupt:
print('\nServer stoped.')
server.server_close()
# -*- coding: utf-8 -*-
"""
socketserver高级模块
"""
__author__ = 'katherinelove'
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
class MyRequsetHandler(SRH):
'''
发送wirte()/接收readline()信息类似文件系统
处理程序用重写handler
'''
def handle(self):
print('...connected from :', self.client_address)
self.wfile.write(
('[%s] %s' %
(ctime(), self.rfile.readline().decode('utf-8'))).encode('utf-8'))
tcp = TCP(ADDR, MyRequsetHandler)
print('wattting for connection')
tcp.serve_forever()
#!/urs/bin/env python
'''
SocketServer 时间戳TCP服务器
'''
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
class MyRequestHandler(SRH):
def handle(self):
print('connected from: ', self.client_address)
data = '[%s] %s' % (ctime(), self.rfile.readline().decode('utf-8'))
self.wfile.write(bytes(data, 'utf-8'))
tcpServ = TCP(ADDR, MyRequestHandler)
print('waiting for connection...')
tcpServ.serve_forever()
def main():
tcpServ = TCP(ADDR, MyRequestHandler)
print('waiting for connection...')
tcpServ.serve_forever()
