socketserver是基于socket写成的一个更强大的模块。
socketserver简化了网络服务器的编写。它有4个类：TCPServer，UDPServer，UnixStreamServer，UnixDatagramServer。这4个类是同步进行处理的，另外通过ForkingMixIn和ThreadingMixIn类来支持异步。
在python3中该模块是socketserver，在python2中该模块是Socketserver
|
1
2
3
4
5
|
分情况导入导入模块
try
:
import
socketserver
#Python 3
except
ImportError:
import
SocketServer
#Python 2
|
服务器
服务器要使用处理程序，必须将其出入到服务器对象，定义了5个基本的服务器类型(就是“类”)。
BaseServer，TCPServer，UnixStreamServer，UDPServer，UnixDatagramServer。 注意：BaseServer不直接对外服务。关系如下
服务器：
要使用处理程序，必须将其传入到服务器的对象，定义了四个基本的服务器类
（1）TCPServer(address,handler) 支持使用IPv4的TCP协议的服务器，address是一个（host,port）元组。Handler是BaseRequestHandler或StreamRequestHandler类的子类的实例。
（2）UDPServer(address,handler) 支持使用IPv4的UDP协议的服务器，address和handler与TCPServer中类似。
（3）UnixStreamServer(address,handler) 使用UNIX域套接字实现面向数据流协议的服务器，继承自TCPServer。
（4）UnixDatagramServer(address,handler) 使用UNIX域套接字实现数据报协议的服务器，继承自UDPServer。
这四个类的实例都有以下方法。
1、s.socket 用于传入请求的套接字对象。
2、s.sever_address 监听服务器的地址。如元组（"127.0.0.1",80）
3、s.RequestHandlerClass 传递给服务器构造函数并由用户提供的请求处理程序类。
4、s.serve_forever() 处理无限的请求 #无限处理client连接请求
5、s.shutdown() 停止serve_forever()循环
SocketServer模块中主要的有一下几个类
1、BaseServer 包含服务器的核心功能与混合类（mix-in）的钩子功能。这个类主要用于派生，不要直接生成这个类的类对象，可以考虑使用TCPServer和UDPServer类。
2、TCPServer 基本的网络同步TCP服务器
3、UDPServer 基本的网络同步UDP服务器
4、ForkingTCPServer 是ForkingMixIn与TCPServer的组合
5、ForkingUDPServer 是ForkingMixIn与UDPServer的组合
6、ThreadingUDPServer 是ThreadingMixIn和UDPserver的组合
7、ThreadingTCPServer 是ThreadingMixIn和TCPserver的组合
8、BaseRequestHandler 必须创建一个请求处理类，它是BaseRequestHandler的子类并重载其handle()方法。
9、StreamRequestHandler 实现TCP请求处理类的
10、DatagramRequestHandler 实现UDP请求处理类的
11、ThreadingMixIn 实现了核心的线程化功能，用于与服务器类进行混合(mix-in)，以提供一些异步特性。不要直接生成这个类的对象。
12、ForkingMixIn 实现了核心的进程化功能，用于与服务器类进行混合(mix-in)，以提供一些异步特性。不要直接生成这个类的对象。
关系图如下：
创建服务器的步骤
1：首先必须创建一个请求处理类
2：它是BaseRequestHandler的子类
3：该请求处理类是BaseRequestHandler的子类并重新写其handle()方法
实例化 请求处理类传入服务器地址和请求处理程序类
最后实例化调用serve_forever() #无限处理client请求
简单实例tcp方式
服务器server端，多线程方式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
import
socketserver
class
Myserver(socketserver.BaseRequestHandler):
#基本的通信循环
def
handle(
self
):
print
(
"连接：》》"
,
self
.request)
#与client的链接请求信息
print
(
"addr :>>"
,
self
.client_address)
#获取client的地址和端口号
while
True
:
try
:
data
=
self
.request.recv(
1024
)
if
not
data:
break
print
(
"收到client消息是:>>"
,data.decode(
"utf-8"
),
self
.client_address)
back_data
=
input
(
":>>"
)
self
.request.sendall(back_data.encode(
"utf-8"
))
except
Exception:
break
if
__name__
=
=
'__main__'
:
s
=
socketserver.ThreadingTCPServer((
"127.0.0.1"
,
8000
),Myserver)
#开启多线程，绑定地址，和处理通信的类
print
(
"\033[1;33mstart\033[0m"
.center(
50
,
"#"
))
s.serve_forever()
#连接循环
|
client端
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
from
socket
import
*
ip_port
=
(
"127.0.0.1"
,
8000
)
buffersize
=
1024
tcp_client
=
socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while
True
:
msg
=
input
(
":>>>>"
)
if
not
msg:
continue
tcp_client.send(msg.encode(
"utf-8"
))
data
=
tcp_client.recv(buffersize)
print
(
"客户端收到的消息是"
,data.decode(
"utf-8"
))
|
1.开启程序
2.client连接
3.开始通信
简单示例udp方式：
程序server端
|
1
2
3
4
5
6
7
8
9
10
11
|
import
socketserver
class
Myserver(socketserver.BaseRequestHandler):
def
handle(
self
):
print
(
self
.request)
print
(
"收到客户端的消息是:》"
,
self
.request[
0
])
self
.request[
1
].sendto(
self
.request[
0
].upper(),
self
.client_address)
if
__name__
=
=
'__main__'
:
s
=
socketserver.ThreadingUDPServer((
"127.0.0.1"
,
8000
),Myserver)
print
(
"\033[1;33mstart\033[0m"
.center(
50
,
"#"
))
s.serve_forever()
|
client端
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
from
socket
import
*
ip_port
=
(
"127.0.0.1"
,
8000
)
buffersize
=
1024
udp_client
=
socket(AF_INET,SOCK_DGRAM)
udp_client.connect(ip_port)
while
True
:
msg
=
input
(
":>>>>"
)
if
not
msg:
continue
udp_client.sendto(msg.encode(
"utf-8"
),ip_port)
data,addr
=
udp_client.recvfrom(buffersize)
print
(
"客户端收到的消息是"
,data.decode(
"utf-8"
))
|
socketserver是基于socket写成的一个更强大的模块。
socketserver简化了网络服务器的编写。它有4个类：TCPServer，UDPServer，UnixStreamServer，UnixDatagramServer。这4个类是同步进行处理的，另外通过ForkingMixIn和ThreadingMixIn类来支持异步。
在python3中该模块是socketserver，在python2中该模块是Socketserver
|
1
2
3
4
5
|
分情况导入导入模块
try
:
import
socketserver
#Python 3
except
ImportError:
import
SocketServer
#Python 2
|
服务器
服务器要使用处理程序，必须将其出入到服务器对象，定义了5个基本的服务器类型(就是“类”)。
BaseServer，TCPServer，UnixStreamServer，UDPServer，UnixDatagramServer。 注意：BaseServer不直接对外服务。关系如下
服务器：
要使用处理程序，必须将其传入到服务器的对象，定义了四个基本的服务器类
（1）TCPServer(address,handler) 支持使用IPv4的TCP协议的服务器，address是一个（host,port）元组。Handler是BaseRequestHandler或StreamRequestHandler类的子类的实例。
（2）UDPServer(address,handler) 支持使用IPv4的UDP协议的服务器，address和handler与TCPServer中类似。
（3）UnixStreamServer(address,handler) 使用UNIX域套接字实现面向数据流协议的服务器，继承自TCPServer。
（4）UnixDatagramServer(address,handler) 使用UNIX域套接字实现数据报协议的服务器，继承自UDPServer。
这四个类的实例都有以下方法。
1、s.socket 用于传入请求的套接字对象。
2、s.sever_address 监听服务器的地址。如元组（"127.0.0.1",80）
3、s.RequestHandlerClass 传递给服务器构造函数并由用户提供的请求处理程序类。
4、s.serve_forever() 处理无限的请求 #无限处理client连接请求
5、s.shutdown() 停止serve_forever()循环
SocketServer模块中主要的有一下几个类
1、BaseServer 包含服务器的核心功能与混合类（mix-in）的钩子功能。这个类主要用于派生，不要直接生成这个类的类对象，可以考虑使用TCPServer和UDPServer类。
2、TCPServer 基本的网络同步TCP服务器
3、UDPServer 基本的网络同步UDP服务器
4、ForkingTCPServer 是ForkingMixIn与TCPServer的组合
5、ForkingUDPServer 是ForkingMixIn与UDPServer的组合
6、ThreadingUDPServer 是ThreadingMixIn和UDPserver的组合
7、ThreadingTCPServer 是ThreadingMixIn和TCPserver的组合
8、BaseRequestHandler 必须创建一个请求处理类，它是BaseRequestHandler的子类并重载其handle()方法。
9、StreamRequestHandler 实现TCP请求处理类的
10、DatagramRequestHandler 实现UDP请求处理类的
11、ThreadingMixIn 实现了核心的线程化功能，用于与服务器类进行混合(mix-in)，以提供一些异步特性。不要直接生成这个类的对象。
12、ForkingMixIn 实现了核心的进程化功能，用于与服务器类进行混合(mix-in)，以提供一些异步特性。不要直接生成这个类的对象。
关系图如下：
创建服务器的步骤
1：首先必须创建一个请求处理类
2：它是BaseRequestHandler的子类
3：该请求处理类是BaseRequestHandler的子类并重新写其handle()方法
实例化 请求处理类传入服务器地址和请求处理程序类
最后实例化调用serve_forever() #无限处理client请求
简单实例tcp方式
服务器server端，多线程方式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
import
socketserver
class
Myserver(socketserver.BaseRequestHandler):
#基本的通信循环
def
handle(
self
):
print
(
"连接：》》"
,
self
.request)
#与client的链接请求信息
print
(
"addr :>>"
,
self
.client_address)
#获取client的地址和端口号
while
True
:
try
:
data
=
self
.request.recv(
1024
)
if
not
data:
break
print
(
"收到client消息是:>>"
,data.decode(
"utf-8"
),
self
.client_address)
back_data
=
input
(
":>>"
)
self
.request.sendall(back_data.encode(
"utf-8"
))
except
Exception:
break
if
__name__
=
=
'__main__'
:
s
=
socketserver.ThreadingTCPServer((
"127.0.0.1"
,
8000
),Myserver)
#开启多线程，绑定地址，和处理通信的类
print
(
"\033[1;33mstart\033[0m"
.center(
50
,
"#"
))
s.serve_forever()
#连接循环
|
client端
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
from
socket
import
*
ip_port
=
(
"127.0.0.1"
,
8000
)
buffersize
=
1024
tcp_client
=
socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while
True
:
msg
=
input
(
":>>>>"
)
if
not
msg:
continue
tcp_client.send(msg.encode(
"utf-8"
))
data
=
tcp_client.recv(buffersize)
print
(
"客户端收到的消息是"
,data.decode(
"utf-8"
))
|
1.开启程序
2.client连接
3.开始通信
简单示例udp方式：
程序server端
|
1
2
3
4
5
6
7
8
9
10
11
|
import
socketserver
class
Myserver(socketserver.BaseRequestHandler):
def
handle(
self
):
print
(
self
.request)
print
(
"收到客户端的消息是:》"
,
self
.request[
0
])
self
.request[
1
].sendto(
self
.request[
0
].upper(),
self
.client_address)
if
__name__
=
=
'__main__'
:
s
=
socketserver.ThreadingUDPServer((
"127.0.0.1"
,
8000
),Myserver)
print
(
"\033[1;33mstart\033[0m"
.center(
50
,
"#"
))
s.serve_forever()
|
client端
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
from
socket
import
*
ip_port
=
(
"127.0.0.1"
,
8000
)
buffersize
=
1024
udp_client
=
socket(AF_INET,SOCK_DGRAM)
udp_client.connect(ip_port)
while
True
:
msg
=
input
(
":>>>>"
)
if
not
msg:
continue
udp_client.sendto(msg.encode(
"utf-8"
),ip_port)
data,addr
=
udp_client.recvfrom(buffersize)
print
(
"客户端收到的消息是"
,data.decode(
"utf-8"
))
|