python学习之【16】网络编程
主题
- 客户端/服务器架构
- 套接字:通信终点
- 套接字地址
- 面向连接与无连接套接字
- Python中的网络编程
- SOCKET模块
- 套接字对象方法
- TCP/IP客户端和服务器
- UDP/IP客户端和服务器
- SocketServer模块
- Twisted框架介绍
- 相关模块
1.客户端服务器架构
客户<---->INTERNET<------->服务器。客户连上一个预先已知的服务器，提出自己的请求，发送必要的数据，然后就等待服务器返回的数据。
2.套接字:通信终点
套接字是一种具有"通信端点"概念的计算机网络数据结构。网络化的应用程序在开始任何通讯之前都需要创建套接字、就像电话插口一样，没有它就会完全没办法通信。Python只支持AF_UNIX,AF_NETLINK,AF_INET家族，由于我们只关心网络编程所以我们都只用AF_INET。
3.套接字地址
如果把套接字比作电话接口----------即通信的最底层结构，那主机与端口就像区号与电话号码的一对组合。有了电话还不够，你还要知道你要打电话给谁，往哪打。一个因特网地址由网络通信所必须的主机和端口组成，而且另一端一定要有人听才可以。
合法的端口号范围为0~65535，其中，小于1024的端口号为系统保留端口。
4.面向连接与无连接套接字
(1)面向连接
无论使用哪个地址家族，套接字的类型只有两种，面向连接和无连接。面向连接即是在通信前必须建立一条连接，就像跟朋友打电话一样。实现这种连接的主要协议就是传输控制协议(TCP)，要创建TCP套接字就得在创建的时候指定套接字类型为SOCK_STREAM。TCP套接字采用SOCK_STREAM这个名字体现了它最为流套接字的特点，由于这些套接字使用网际协议(ip)来查找网络中的主机，所以这样形成的整个系统，一般会有两个协议(TCP和IP)名的组合来描述，即TCP/IP。
(2)无连接
即无需连接就可以进行通信。但这时，数据到达的顺序、可靠性及不重复性就无法保证了。数据是整个发送的，不会像面向连接的协议那样先被拆分成小块。
实现这种连接的主要协议就是用户数据报协议(UDP)。要创建UDP套接字就得在创建的时候指定套接字类型为SOCK_DGRAM。"datagram"是"数据报"。
5.Python中的网络编程
我们将使用Python中的socket模块，模块中的socket()函数用来创建套接字。要使用socket.socket()函数来创建套接字，语法如下:
socket.socket(socket_family,socket_type,protocol=0)
如前所述,Socket_family 不是 AF_VNIX 就是 AF_INET ,socket_type可以是SOCK_STREAM或是SOCK_DGRAM,protocol一般不填，默认为0。
6.SOCKET模块
例如创建一个TCP/IP的套接字，你要这样调用socket.socket()函数:
tcpSock = socket.socket(socket.AF_INET,socket.SOCKET_STREAM)
UDP/IP的套接字
udpSock = socket.socket(socket.AF_INET,socket.SOCKET_DGRAM)
由于socket模块中有太多的属性，我们在这里可以使用 “from module import *”的语句,我们就把socket模块里所有属性都带到我们的命名空间里了。
tcpSock = socket(AF_INET,SOCKET_STREAM)
7.套接字对象(内建)方法
函数 描述
服务器端套接字函数
- s.bind( ) 绑定地址(主机名，端口号对)到套接字
- s.listen( ) 开始TCP监听
- s.accept( ) 被动接受TCP客户端连接，（阻塞式）等待连接的到来。
客户端套接字函数
- s.connect( ) 主动初始化TCP服务器连接。
- s.connect_ex( ) connect( )扩展版本，出错时返回错误码，而不是抛出异常。
公共用途的套接字函数
- s,recv( ) 接受TCP数据。
- s.send( ) 发送TCP数据。
- s.sendall( ) 完整发送TCP数据。
- s.recvfrom( ) 接受UDP数据。
- s.sendto( ) 发送UDP数据。
- s.getpeername( ) 连接到当前套接字的远程的地址(TCP连接)
- s.getsockname( ) 当前套接字的地址。
- s.getsockopt( ) 返回当前套接字的参数。
- s.setsockopt( ) 设置指定套接字的参数。
- s.close( ) 关闭套接字。
面向模块的套接字函数
- s.setblocking( ) 设置套接字的阻塞与非阻塞模式。
- s.settimeout( ) 设置阻塞套接字操作的超时时间。
- s.gettimeout( ) 得到阻塞套接字操作的超时时间。
面向文件套接字函数
- s.fileno( ) 套接字文件描述符。
- s.makefile( ) 创建一个与该套接字关联的文件对象。
8.TCP/IP客户端和服务器
TCP服务器设计伪代码:
ss = socket() #创建服务器套接字
ss.bind() #把地址绑定到套接字上
ss.listen() #监听连接
inf_loop: #服务器无线循环
cs = ss.accept() #接受客户端连接
comm_loop: #通信循环
cs.recv()/cs.send() #对话（接收与发送）
cs.close() #关闭客户端套接字
ss.close() #关闭服务器套接字(可选)
所有套接字都用socket.socket( )函数来创建。服务器需要"坐在某个端口上"等待请求。所以它们必须要"绑定"到一个本地的地址上。一个简单的(单线程)服务器会调用accept( )函数等待连接的到来。默认情况下，accept( )函数是阻塞式的，即程序在连接到来之前会处于挂起状态。套接字也支持非阻塞状态。
TCP时间戳服务器(tsTserv.py)
创建一个能接受客户端的消息，在消息前加一个时间戳后返回TCP服务器
from socket import *
from time import ctime
HOST = ''
PORT = 21567
BUFSIZE = 1024
ADDR = (HOST,PORT) tcpSerSock = socket(AF_INET,SOCK_STREAM)
tcpSerSock.bind( ADDR)
tcpSerSock.listen(5) while True:
print 'waiting for connection......'
tcpCliSock,addr = tcpSerSock.accept( )
print '......connected from:',addr while True:
data = tcpCliSock.recv(BUFSIZ)
if not data:
break
tcpCliSock.send('[%s]%s' %(ctime(),data))
tcpCliSock.close( )
tcpSerSock.close()
创建TCP客户端
伪代码:
cs = socket( ) #创建客户端套接字
cs.connect( ) #尝试连接服务器
comm_loop:
cs.send( )/cs.recv( ) #对话(发送/接收)
cs.close( ) #关闭客户端套接字
TCP时间戳客户端(tsTclnt.py)
from socket import *
HOST = 'localhost'
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST,PORT)
tcpCliSock = socket(AF_INET,SOCK_STREAM)
tcpCliSock.connect(ADDR)
while True:
data = raw_input('>')
if not data:
break
tcpCliSock.send(data)
data = tcpCliSock.recv(BUFSIZ)
if not data:
break
print data
tcpCliSock.close()
9.UDP/IP客户端和服务器
UDP时间戳服务器(tsUserv.py)
from socket import *
from time import ctime HOST = ''
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST,PORT) udpSerSock = socket(AF_INET,SOCK_DGRAM)
udpSerSock.bind(ADDR) while True:
print 'waiting for message......'
data,addr = udpSerSock.recvfrom(BUFSIZ)
udpSerSock.sendto('[%s] %s' % (ctime,data) ,addr)
print '......received from and returned to:',addr udpSerSock.close()
创建一个UDP客户端
from socket import *
HOST = 'localhost'
PORT = ""
BUFSIZ = 1024
ADDR = (HOST,PORT)
udpCliSock = socket(AF_INET,SOCK_DGRAM)
while Trus:
data = raw_input('>')
if not data:
break
udpCliSock.sendto(data,ADDR)
data,ADDR = udpCliSock.recvfrom(BUFSIZ)
if not data:
break
print data
udpCliSock.close()
10.SocketServer模块
SocketServer 是标准库中一个高级别的模块。用于简化实现网络客户端与服务器所需的大量样板代码。该模块中，已经实现了一些可供使用的类。
SocketServer模块的类
| 类 | 描述 |
| BaseServer | 包含服务器核心功能与混合(mix-in)类挂钩;这个类只用于派生，所以不会生成这个类的实例;可以考虑使用TCPServer和UDPServer |
| TCPServer/UDPServer | 基本的网络同步TCP/UDP服务器 |
| UnixStreamServer/UnixDatagramServer | 基本的基于文件同步TCP/UDP服务器 |
| ForkingMixIn/ThreadingMixIn | 实现了核心的进程化或线程化的功能;作为混合类，与服务器类一并使用以提供一些异步特性;这个类不会直接实例化。 |
| ThreadingTCPServer/ThreadingUDPServer | ThreadingMixIn和TCPServer/UDPServer的组合 |
| BaseRequestHandler | 包含处理服务器请求的核心功能，这个类只用于派生，所以不会生成这个类的实例可以考虑使用StreamRequestHandler 或 DatagramRequestHandler |
| StreamRequestHandler/DatagramRequestHandler | 用于TCP/UDP服务器处理工具 |
创建一个SocketServerTCP服务器
在代码中，先导入我们的服务器类，然后像之前一样定义主机常量。主机常量后就是我们的请求处理器类，然后是启动代码。
例 SocketServer 时间戳TCP服务器（TsTservss.py）
from SocketServer import (TCPServer as TCP,StreamRequsetHandler as SRH)
from time import ctime HOST = ''
PORT = 21567
ADDR = (HOST,PORT) class MyRequestHandler(SRH):
def handle(self):
print '......connected from:',self.client_address
self.wfile.write('[%s]%s' % (ctime(),self.rfile.readline())) tcpServ = TCP(ADDR,MyRequestHandler)
print 'waiting for connection...'
tcpServ.serve_forever( )
创建SocketServerTCP客户端
from socket import *
HOST = 'localhost'
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST,PORT)
while True:
tcpCliSock = socket(AF_INET,SOCK_STREAM)
tcpCliSock.connect(ADDR)
data = raw_input('>')
if not data:
break
tcpCliSock.send('%s\r\n' %data)
data = tcpCliSock.recv(BUFSIZ)
if not data:
break
print data.strip()
tcpCliSock.close()
11.Twisted框架介绍
Twsited是一个完全事件驱动的网络框架。它允许你使用和开发完全异步的网络应用程序和协议。需要安装它，系统中可以有:网络协议、线程、安全和认证、聊天/即时通讯、数据库管理、关系数据库集成、Web/internet、电子邮件、命令行参数、图形界面集成等。
创建一个Twisted Reactor TCP服务器
Twsited Reactor事件戳服务器(tsTservTW.py)
from twisted.internet import protocol,reactor
from time import ctime
PORT = 21567
class TSServProtocol(protocol.Protocol)
-----------------------
课后题
16-1. 套接字,面向连接与无连接有何区别?
答:socket第二个参数不同。面向连接即tcp通信函数为socket.socket(socket.AF_INET,socket.SOCK_STREAM),UDP通信函数第二个参数为SOCK_DGRAM。
16-2. 客户端/服务器架构。用你自己的语言描述这个架构。并给出几个例子?
答:服务器在某端口等待客户端的连接。怎么说呢 client<------------>internet<------------->server
16-3. 套接字。TCP和UDP中，哪一种服务器在接受连接后，把连接交给不同的套接字处理与客户端的通讯。
答:TCP。
16-4. 修改TCP(tsTclnt.py)和UDP（tsUclnt.py）客户端，让服务器的名字不要在代码里写死，要允许用户指定一个主机名和端口，只有在两个值都没有输入的时候才使用默认值。
答:修改后的tsTclnt.py
from socket import *
from time import ctime HOST = ''
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST,PORT) tcpSerSock = socket(AF_INET,SOCK_STREAM)
tcpSerSock.bind(ADDR)
tcpSerSock.listen(5) while True:
print 'waitiing for connection...'
tcpCliSock,addr = tcpSerSock.accept()
print '...connected from:',addr while True:
data = tcpCliSock.recv(BUFSIZ)
if not data:
break
tcpCliSock.send('[%s] %s' % (ctime(),data)) tcpSerSock.close()
16-5. 网络互联和套接字。找到《python library reference》 示例tcp客户端/服务器程序，实现它并让它运行起来。先运行服务器，然后是客户端。http://www.python.org/doc/current/lib/Socket_Example.html
你认为这个服务器太无聊，决定要修改服务器，让它能识别以下命令:
data 服务器将返回它的当前时间，即time.ctime(time.time())
os 得到操作系统的信息（os.name）
ls 得到当前目录的文件列表
做这个作业的时候，你不一定要有网络------你的机器可以自己通讯。注：在服务器退出后，要清除绑定后才能再次运行，否则有可能得碰到‘端口已经被使用’的错误信息，操作系统一般会在5分钟内清除绑定。所以请耐心等待。
服务器端
from socket import *
import time,os HOST = ''
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST,PORT) tcpSerSock = socket(AF_INET,SOCK_STREAM)
tcpSerSock.bind(ADDR)
tcpSerSock.listen(5) while True:
print 'waitiing for connection...'
tcpCliSock,addr = tcpSerSock.accept()
print '...connected from:',addr while True:
data = tcpCliSock.recv(BUFSIZ)
data = data.strip()
if not data:
break
if data == "date":
tcpCliSock.send('%s' % (time.ctime(time.time())))
elif data == "os":
tcpCliSock.send('%s' % (os.name))
elif data == "ls":
tcpCliSock.send('%s' % (os.listdir(os.curdir)))
else:
tcpCliSock.send('[%s] %s' % (time.ctime(),data)) tcpSerSock.close()
16-6日期时间服务。使用socket.getservbyname()函数得到UDP协议中"daytime"服务所对应的端口。请参考getservbyname()函数的文档，查阅如何使用的详细语法。现在，写一个程序发送一个随便什么数据过去，等待回答。一旦你收到了服务器的信息，显示到屏幕上去。
答：服务端
from socket import *
from time import ctime HOST = "localhost" PORT = getservbyname("daytime","udp") BUFSIZ = 1024 ADDR = (HOST,PORT) udpSerSock = socket(AF_INET,SOCK_DGRAM) udpSerSock.bind(ADDR) while True:
print "waiting for message..."
data,addr = udpSerSock.recvfrom(BUFSIZ)
udpSerSock.sendto("[%s]%s" % (ctime(), data),addr)
print "...received from and returned to:",addr udpSerSock.close
客户端
from socket import *
from time import ctime HOST = "localhost"
PORT = getservbyname("daytime","udp") BUFSIZ = 1024 ADDR = (HOST,PORT) udpCliSock = socket(AF_INET,SOCK_DGRAM) while True:
data = raw_input(">")
if not data:
break
udpCliSock.sendto(data,ADDR)
data,ADDR = udpCliSock.recvfrom(BUFSIZ)
if not data:
break
print data tcpCliSock.close()
16-7.半双工聊天。创建一个简单的半双工聊天程序。“半双工”的意思是当创建一个连接，服务启动的时候，只有一个人可以打字，另一个人只有在等到消息通知他输入消息时才能说话。一旦消息发送出去后，要等到有回复了才能发送下一条消息。一个人是服务端，另一个人是客户端。
客户端
from socket import * HOST = "localhost"
PORT = 23346
BUFSIZ = 1024
ADDR = (HOST,PORT) tcpCliSock = socket(AF_INET,SOCK_STREAM)
tcpCliSock.connect(ADDR) while True:
data = raw_input("client>")
if not data:
continue
tcpCliSock.send(data)
while True:
data = tcpCliSock.recv(BUFSIZ)
if not data:
continue
else:
print "server>",data
break tcpCliSock.close()
服务端
from socket import * HOST = "localhost"
PORT = 23346
BUFSIZ = 1024
ADDR = (HOST,PORT) tcpServSock = socket(AF_INET,SOCK_STREAM)
tcpServSock.bind(ADDR)
tcpServSock.listen(5) while True:
print "waiting for connection..."
tcpCliSock,addr = tcpServSock.accept()
print "connected from:",addr while True:
data = tcpCliSock.recv(BUFSIZ)
if not data:
continue
print "client>",data
data = raw_input("server>")
tcpCliSock.send(data) tcpServSock.close()
---------------------------------------------------------------------
16-8 全双工聊天。修改你刚才的程序，改成全双工，即两个人可以独立地发送和接收消息。
答：
服务端
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import socket,traceback,os
from threading import * host = 'localhost'
port = 51423 #监听所有的接口 #接受消息的线程
def handlerecv(clientsock):
print "New child",currentThread().getName()
print "Got connection from",clientsock.getpeername()
while True:
data = clientsock.recv(4096)
if not len(data):
break
print data
clientsock.close() #发送消息的线程
def handlesend(clientsock):
while True:
data = raw_input(">")
data = data + "\n"; #加上换行，好看一点。
clientsock.sendall(data)
#关闭连接
clientsock.close() #建立套接字
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((host,port))
s.listen(1) while True:
try:
clientsock,clientaddr = s.accept()
except KeyboardInterrupt:
raise
except:
traceback.print_exc()
continue t = Thread(target = handlerecv,args=[clientsock])
t.setDaemon(1)
t.start() r = Thread(target = handlesend,args=[clientsock])
r.setDaemon(1)
r.start()
客户端
#!/usr/bin/env python
#-*-coding:utf-8-*- from socket import *
import sys
from threading import * if(len(sys.argv) < 3):
HOST = 'localhost'
PORT = 51423
else:
HOST = sys.argv[1]
PORT = int(sys.argv[2]) BUFSIZ = 1024
ADDR = (HOST,PORT) def handlesend(tcpCliSock):
while True:
sdata = raw_input('> ')
if not sdata:
break
tcpCliSock.send(sdata) tcpCliSock.close() tcpCliSock = socket(AF_INET,SOCK_STREAM)
tcpCliSock.connect(ADDR) #建立发送消息的线程
s = Thread(target = handlesend,args=[tcpCliSock])
s.setDaemon(1)
s.start() while True:
rdata = tcpCliSock.recv(BUFSIZ)
if not rdata:
break
print rdata
tcpCliSock.close()
------------------------------------------------------------------
16-9----10 多用户全双工聊天。再次修改你的程序，把聊天服务改成支持多用户版本。(扩展功能多人，多房间，多线程，全双工)
服务端 cs.py
#!/usr/bin/env python
# _*_ coding: utf8 _*_ from socket import *
from time import ctime
import threading
from string import split HOST = ''
PORT = 21567
BUFSIZE = 1024
ADDR = (HOST, PORT) def Deal(sck, username, room):
while True:
data = sck.recv(BUFSIZE)
for i in clients[room].iterkeys():
if i <> username:
if data <> "quit":
clients[room][i].send("[%s] %s: %s" %(ctime(), username, data))
else:
clients[room][i].send("用户%s在%s退出房间%s" %(username, ctime(), room ))
if data == "quit":
del clients[room][username]
sck.send(data)
sck.close()
break chatSerSock = socket(AF_INET, SOCK_STREAM)
chatSerSock.bind(ADDR)
chatSerSock.listen(5) clients = {"":{},} while True:
print 'waiting for connection...'
chatCliSock, addr = chatSerSock.accept()
print "...connected romt: ", addr
data = chatCliSock.recv(BUFSIZE)
username, room = split(data)
print username
if not clients.has_key(room):
clients[room] = {}
if clients[room].has_key(username):
chatCliSock.send("reuse")
chatCliSock.close()
else:
chatCliSock.send("success")
clients[room][username] = chatCliSock
t = threading.Thread(target=Deal, args=(chatCliSock, username, room))
t.start() chatSerSock.close()
客户端 cc.py
#!/usr/bin/env python
# _*_ coding: utf8 _*_ from socket import *
from time import ctime
import threading
import random
from sys import argv, exit, stdout
from getopt import gnu_getopt, GetoptError help_info = ["cs.py [ -h | --help | -u | --username] username",
"\t-h or --help\t显示帮助信息",
"\t-u or --username\指定用户名",
"\t-r or --room\t指定房间"]
def help():
for i in help_info:
print i def Send(sck, test):
while True:
data = raw_input('>')
sck.send(data)
if data == "quit":
break
def Recieve(sck, test):
while True:
data = sck.recv(BUFSIZ)
if data == "quit":
sck.close()
break
str = "\n" + data + "\n>"
stdout.write(str) HOST = 'localhost'
PORT= 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)
threads = [] if __name__ == "__main__":
# 解析命令行参数
try:
opts, args = gnu_getopt(argv[1:], "hu:r:", ["help", "username=", "room="])
except GetoptError, err:
print str(err)
help()
exit(2)
username = ""
room = ""
for o, a in opts:
if o in ("-h", "--help"):
help()
exit(0)
elif o in ("-u", "--username"):
username = a
elif o in ("-r", "--room"):
room = a
else:
print "未知选项"
help()
exit(2)
if not username or not room:
help()
exit(2)
chatCliSock = socket(AF_INET, SOCK_STREAM)
chatCliSock.connect(ADDR)
chatCliSock.send("%s %s" %(username, room))
data = chatCliSock.recv(BUFSIZ)
if data == "reuse":
print "用户%s已登录房间%s" %(username, room)
raw_input()
exit(1)
elif data == "success":
print "用户%s成功登录房间%s" %(username, room)
t = threading.Thread(target=Send, args = (chatCliSock, None))
threads.append(t)
t = threading.Thread(target=Recieve, args = (chatCliSock, None))
threads.append(t)
for i in range(len(threads)):
threads[i].start()
threads[0].join()
python学习之【16】网络编程的更多相关文章
- python学习之路网络编程篇（第四篇）
python学习之路网络编程篇(第四篇) 内容待补充
- python学习笔记11 ----网络编程
网络编程 网络编程需要知道的概念 网络体系结构就是使用这些用不同媒介连接起来的不同设备和网络系统在不同的应用环境下实现互操作性,并满足各种业务需求的一种粘合剂.网络体系结构解决互质性问题彩是分层方法. ...
- python学习之路网络编程篇（第二篇）
新课程知识的引入:python作用域 #python中无块级别作用域 if 1 == 1 : name = 'alex' print(name) for i in range(10): name = ...
- python学习笔记10 ----网络编程
网络编程 网络编程需要知道的概念 网络体系结构就是使用这些用不同媒介连接起来的不同设备和网络系统在不同的应用环境下实现互操作性,并满足各种业务需求的一种粘合剂.网络体系结构解决互质性问题彩是分层方法. ...
- Python学习之==>Socket网络编程
一.计算机网络 多台独立的计算机通过网络通信设备连接起来的网络.实现资源共享和数据传递.在同一台电脑上可以将D盘上的一个文件传到C盘,但如果想从一台电脑传一个文件到另外一台电脑上就要通过计算机网络 二 ...
- python学习之路网络编程篇（第五篇）
paramiko简介 paramiko 是基于Python实现的SSH2远程安装连接,支持认证及秘钥方式.可以实现远程命令执行.文件传输.中间SSH代理等功能. paramiko安装 #!/bin/b ...
- python学习之路网络编程篇（第一篇）socket初识
什么是socket 网络上的两个程序通过一个双向的通信连接实现数据的交换,这个连接的一端称为socket.socket通常也称为“套接字”,是一个通信链的句柄,可以用来实现不同虚拟机或不同计算机之间的 ...
- python学习之路网络编程篇（第五篇）-续篇
Python堡垒机实现之基础知识 一般的堡垒机必须要具备以下5个基本功能: 1.权限控制 2.执行命令 3.上传下载文件 4.远程登录 5.记录操作 权限控制 说明:根据不同的登录用户分配不同的可管理 ...
- python学习之路网络编程篇（第四篇）- 续
Memcache简介 Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速 ...
- python学习之路网络编程篇（第三篇）
python线程 Threading用于提供线程相关的操作,线程是应用程序中工作的最小单元. #!/usr/bin/env python # -*- coding:utf-8 -*- import t ...
随机推荐
- laravel 5.3 多用户认证
不知道对不对,乱来一下!!!! 1)laravel自带了一个用户认证系统,要使用的话,直接运行一下命令就可以用了 php artisan make:auth 会生成相应的控制器.路由和模版文件 2)数 ...
- nginx 重复提交 重复请求问题
我遇到的奇葩问题. 后台使用的是nginx + tomcat 前端页面确实只发送了一个ajax请求到后台. 后台却接收到了两条请求! 百度了一下,说是因为nginx负载均衡,一个请求超时后会重复发送一 ...
- Golang文件名命名规则
在golang源代码中,经常看到各种文件名,比如: bolt_windows.go. 下面对文件名命令规则的说明: 1.平台区分 文件名_平台. 例: file_windows.go, file_un ...
- DOS cmd - how to ping a remote host with specified port
You can use ping to test whether you can connect to a remote host: ping baidu.com ping 125.6.45.88 ( ...
- Delphi Live Bindings 初探
Delphi Live Bindings 初探 Live Bindings,顾名思义,动态绑定. 1.绑定前: 2.点击数据源: 3.绑定连线:点击 蓝色区域, 按住 鼠标左键,一直移动到绿色区域,然 ...
- MyBatis官方文档——入门
入门 安装 要使用 MyBatis, 只需将 mybatis-x.x.x.jar 文件置于 classpath 中即可. 如果使用 Maven 来构建项目,则需将下面的 dependency 代码置于 ...
- type 、instanceof、in 和 hasOwnproperty
typeof可以检测的类型有:string.number.boolean.undefined.不可以用typeof检测null typeof也可以用来检测function,但是在IE8及跟早的浏览器中 ...
- 用ajax实现用户名的检测（JavaScript方法）
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding= ...
- 【BZOJ1630/2023】[Usaco2007 Demo]Ant Counting DP
[BZOJ1630/2023][Usaco2007 Demo]Ant Counting 题意:T中蚂蚁,一共A只,同种蚂蚁认为是相同的,有一群蚂蚁要出行,个数不少于S,不大于B,求总方案数 题解:DP ...
- MariaDB登陆
设置root密码 “mariabd”是新密码 [root@master /]# mysqladmin -u root password mariadb [root@master /]# mysql - ...