socket伺服器搭建教程

『壹』 python怎麼建立socket服務端

socket伺服器再細分可分為多種了，tcp,udp,websocket，都是調用socket模塊，但是具體實現起來有一點細微的差別

先給出一個tcp和udp通過socket協議實現的聊天室的例子

python聊天室(python2.7版本)：

都是分別運行server.py和client.py，就可以進行通訊了。

TCP版本：

socket-tcp-server.py（服務端）:

#-*-encoding:utf-8-*-
#socket.getaddrinfo(host,port,family=0,socktype=0,proto=0,flags=0)
#根據給定的參數host/port，相應的轉換成一個包含用於創建socket對象的五元組，
#參數host為域名，以字元串形式給出代表一個IPV4/IPV6地址或者None.
#參數port如果字元串形式就代表一個服務名，比如「http」"ftp""email"等，或者為數字，或者為None
#參數family為地主族，可以為AF_INET，AF_INET6，AF_UNIX.
#參數socktype可以為SOCK_STREAM(TCP)或者SOCK_DGRAM(UDP)
#參數proto通常為0可以直接忽略
#參數flags為AI_*的組合，比如AI_NUMERICHOST，它會影響函數的返回值
#附註：給參數host,port傳遞None時建立在C基礎，通過傳遞NULL。
#該函數返回一個五元組(family,socktype,proto,canonname,sockaddr)，同時第五個參數sockaddr也是一個二元組(address,port)
#更多的方法及鏈接請訪問
#Echoserverprogram
fromsocketimport*
importsys
importthreading
fromtimeimportctime
fromtimeimportlocaltime
importtraceback
importtime
importsubprocess
reload(sys)
sys.setdefaultencoding("utf8")


HOST='127.0.0.1'
PORT=8555#設置偵聽埠
BUFSIZ=1024

classTcpServer():
def__init__(self):
self.ADDR=(HOST,PORT)
try:
self.sock=socket(AF_INET,SOCK_STREAM)
print'%disopen'%PORT

self.sock.bind(self.ADDR)
self.sock.listen(5)
#設置退出條件
self.STOP_CHAT=False

#所有監聽的客戶端
self.clients={}
self.thrs={}
self.stops=[]

exceptException,e:
print"%disdown"%PORT
returnFalse

defIsOpen(ip,port):

s=socket(AF_INET,SOCK_STREAM)
try:
s.connect((ip,int(port)))
#s.shutdown(2)
#利用shutdown()函數使socket雙向數據傳輸變為單向數據傳輸。shutdown()需要一個單獨的參數，
#該參數表示s了如何關閉socket。具體為：0表示禁止將來讀；1表示禁止將來寫；2表示禁止將來讀和寫。
print'%disopen'%port
returnTrue
except:
print'%disdown'%port
returnFalse

deflisten_client(self):
whilenotself.STOP_CHAT:
print(u'等待接入，偵聽埠:%d'%(PORT))
self.tcpClientSock,self.addr=self.sock.accept()
print(u'接受連接，客戶端地址：',self.addr)
address=self.addr
#將建立的clientsocket鏈接放到列表self.clients中
self.clients[address]=self.tcpClientSock
#分別將每個建立的鏈接放入進程中，接收且分發消息
self.thrs[address]=threading.Thread(target=self.readmsg,args=[address])
self.thrs[address].start()
time.sleep(0.5)defreadmsg(self,address):
#如果地址不存在，則返回False
ifaddressnotinself.clients:
returnFalse
#得到發送消息的clientsocket
client=self.clients[address]
whileTrue:
try:
#獲取到消息內容data
data=client.recv(BUFSIZ)
except:
print(e)
self.close_client(address)
break
ifnotdata:
break
#python3使用bytes，所以要進行編碼
#s='%s發送給我的信息是:[%s]%s'%(addr[0],ctime(),data.decode('utf8'))
#對日期進行一下格式化
ISOTIMEFORMAT='%Y-%m-%d%X'
stime=time.strftime(ISOTIMEFORMAT,localtime())
s=u'%s發送給我的信息是:%s'%(str(address),data.decode('utf8'))
#將獲得的消息分發給鏈接中的clientsocket
forkinself.clients:
self.clients[k].send(s.encode('utf8'))
self.clients[k].sendall('sendall:'+s.encode('utf8'))
printstr(k)
print([stime],':',data.decode('utf8'))
#如果輸入quit(忽略大小寫),則程序退出
STOP_CHAT=(data.decode('utf8').upper()=="QUIT")
ifSTOP_CHAT:
print"quit"
self.close_client(address)
print"alreadyquit"
break

defclose_client(self,address):
try:
client=self.clients.pop(address)
self.stops.append(address)
client.close()
forkinself.clients:
self.clients[k].send(str(address)+u"已經離開了")
except:
pass
print(str(address)+u'已經退出')


if__name__=='__main__':
tserver=TcpServer()
tserver.listen_client()

——————————華麗的分割線——————————

socket-tcp-client.py（客戶端）：

#-*-encoding:utf-8-*-
fromsocketimport*
importsys
importthreading
importtime
reload(sys)
sys.setdefaultencoding("utf8")


#測試，連接本機
HOST='127.0.0.1'
#設置偵聽埠
PORT=8555
BUFSIZ=1024

classTcpClient:

ADDR=(HOST,PORT)
def__init__(self):
self.HOST=HOST
self.PORT=PORT
self.BUFSIZ=BUFSIZ
#創建socket連接
self.client=socket(AF_INET,SOCK_STREAM)
self.client.connect(self.ADDR)
#起一個線程，監聽接收的信息
self.trecv=threading.Thread(target=self.recvmsg)
self.trecv.start()

defsendmsg(self):
#循環發送聊天消息，如果socket連接存在則一直循環，發送quit時關閉鏈接
whileself.client.connect_ex(self.ADDR):
data=raw_input('>:')
ifnotdata:
break
self.client.send(data.encode('utf8'))
print(u'發送信息到%s：%s'%(self.HOST,data))
ifdata.upper()=="QUIT":
self.client.close()
printu"已關閉"
break
defrecvmsg(self):
#接收消息，如果鏈接一直存在，則持續監聽接收消息
try:
whileself.client.connect_ex(self.ADDR):
data=self.client.recv(self.BUFSIZ)
print(u'從%s收到信息：%s'%(self.HOST,data.decode('utf8')))
exceptException,e:
printstr(e)

if__name__=='__main__':
client=TcpClient()
client.sendmsg()

UDP版本：

socket-udp-server.py

#-*-coding:utf8-*-

importsys
importtime
importtraceback
importthreading
reload(sys)
sys.setdefaultencoding('utf-8')

importsocket
importtraceback

HOST="127.0.0.1"
PORT=9555
CHECK_PERIOD=20
CHECK_TIMEOUT=15

classUdpServer(object):
def__init__(self):
self.clients=[]
self.beats={}
self.ADDR=(HOST,PORT)
try:
self.sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
self.sock.bind(self.ADDR)#綁定同一個域名下的所有機器
self.beattrs=threading.Thread(target=self.checkheartbeat)
self.beattrs.start()
exceptException,e:
traceback.print_exc()
returnFalse

deflisten_client(self):
whileTrue:
time.sleep(0.5)
print"hohohohohoo"
try:
recvData,address=self.sock.recvfrom(2048)
ifnotrecvData:
self.close_client(address)
break
ifaddressinself.clients:
senddata=u"%s發送給我的信息是:%s"%(str(address),recvData.decode('utf8'))
ifrecvData.upper()=="QUIT":
self.close_client(address)
ifrecvData=="HEARTBEAT":
self.heartbeat(address)
continue
else:
self.clients.append(address)
senddata=u"%s發送給我的信息是:%s"%(str(address),u'進入了聊天室')
forcinself.clients:
try:
self.sock.sendto(senddata,c)
exceptException,e:
printstr(e)
self.close_client(c)
exceptException,e:
#traceback.print_exc()
printstr(e)
pass

defheartbeat(self,address):
self.beats[address]=time.time()

defcheckheartbeat(self):

whileTrue:
print"checkheartbeat"
printself.beats
try:
forcinself.clients:
printtime.time()
printself.beats[c]
ifself.beats[c]+CHECK_TIMEOUT<time.time():
printu"%s心跳超時，連接已經斷開"%str(c)
self.close_client(c)
else:
printu"checkp%s,沒有斷開"%str(c)
exceptException,e:
traceback.print_exc()
printstr(e)
pass
time.sleep(CHECK_PERIOD)

defclose_client(self,address):
try:
ifaddressinself.clients:
self.clients.remove(address)
ifself.beats.has_key(address):
delself.beats[address]
printself.clients
forcinself.clients:
self.sock.sendto(u'%s已經離開了'%str(address),c)
print(str(address)+u'已經退出')
exceptException,e:
printstr(e)
raise

if__name__=="__main__":
udpServer=UdpServer()
udpServer.listen_client()

——————————華麗的分割線——————————
socket-udp-client.py:
#-*-coding:utf8-*-

importsys
importthreading
importtime
reload(sys)
sys.setdefaultencoding('utf-8')

importsocket

HOST="127.0.0.1"
PORT=9555
#BEAT_PORT=43278
BEAT_PERIOD=5


classUdpClient(object):
def__init__(self):
self.clientsock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
self.HOST=HOST
self.ADDR=(HOST,PORT)
self.clientsock.sendto(u'請求建立鏈接',self.ADDR)
self.recvtrs=threading.Thread(target=self.recvmsg)
self.recvtrs.start()
self.hearttrs=threading.Thread(target=self.heartbeat)
self.hearttrs.start()

defsendmsg(self):
whileTrue:
data=raw_input(">:")
ifnotdata:
break
self.clientsock.sendto(data.encode('utf-8'),self.ADDR)
ifdata.upper()=='QUIT':
self.clientsock.close()
break

defheartbeat(self):
whileTrue:
self.clientsock.sendto('HEARTBEAT',self.ADDR)
time.sleep(BEAT_PERIOD)

defrecvmsg(self):
whileTrue:
recvData,addr=self.clientsock.recvfrom(1024)
ifnotrecvData:
break
print(u'從%s收到信息：%s'%(self.HOST,recvData.decode('utf8')))if__name__=="__main__":
udpClient=UdpClient()
udpClient.sendmsg()

『貳』 如何創建一個socket並進行通信

Socket是網路上運行的兩個程序間雙向通訊的一端，它既可以接受請求，也可以發送請求，利用它可以較為方便的編寫網路上的數據的傳遞。在java中，有專門的socket類來處理用戶的請求和響應。利用SOCKET類的方法，就可以實現兩台計算機之間的通訊。這里就介紹一下在JAVA中如何利用socket進行網路編程。 在Java中Socket可以理解為客戶端或者伺服器端的一個特殊的對象，這個對象有兩個關鍵的方法，一個是getInputStream方法，另一個是getOutputStream方法。getInputStream方法可以得到一個輸入流，客戶端的Socket對象上的getInputStream方法得到的輸入流其實就是從伺服器端發回的數據流。GetOutputStream方法得到一個輸出流，客戶端Socket對象上的getOutputStream方法返回的輸出流就是將要發送到伺服器端的數據流，（其實是一個緩沖區，暫時存儲將要發送過去的數據）。 程序可以對這些數據流根據需要進行進一步的封裝。本文的例子就對這些數據流進行了一定的封裝（關於封裝可以參考Java中流的實現部分）。 一、建立伺服器類 Java中有一個專門用來建立Socket伺服器的類，名叫ServerSocket，可以用伺服器需要使用的埠號作為參數來創建伺服器對象。ServerSocket server = new ServerS...
感覺這樣的提問沒有什麼意義
建議看看書，查查資料

『叄』 python怎樣建立socket伺服器

下面的例子是多線程實現的socket伺服器：

import socketimport threadingclass ThreadedServer(object):
def __init__(self, host, port):
self.host = host
self.port = port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((self.host, self.port))

def listen(self):
self.sock.listen(5)
while True:
client, address = self.sock.accept()
client.settimeout(60)
threading.Thread(target = self.listenToClient,args = (client,address)).start()

def listenToClient(self, client, address):
size = 1024
while True:
try:
data = client.recv(size)
if data:
# Set the response to echo back the recieved data
response = data
client.send(response)
else:
raise error('Client disconnected')
except:
client.close()
return Falseif __name__ == "__main__":
while True:
port_num = input("Port? ")
try:
port_num = int(port_num)
break
except ValueError:
pass

ThreadedServer('',port_num).listen()

『肆』 java簡答題 如何創建socket連接的過程

java socket建立連接的過程如下：
socket

1、 首先調用Socket類的構造函數，以伺服器的指定的IP地址或指定的主機名和指定的埠號為參數，創建一個Socket流，在創建Socket流的過程中包含了向伺服器請求建立通訊連接的過程實現。
2、 建立了客戶端通訊Socket後。就可以使用Socket的方法getInputStream()和getOutputStream()來創建輸入/輸出流。這樣，使用Socket類後，網路輸入輸出也轉化為使用流對象的過程。
3、 使用輸入輸出流對象的相應方法讀寫位元組流數據，因為流連接著通訊所用的Socket，Socket又是和伺服器端建立連接的一個端點，因此數據將通過連接從伺服器得到或發向伺服器。這時我們就可以對位元組流數據按客戶端和伺服器之間的協議進行處理，完成雙方的通訊任務。
4、 待通訊任務完畢後，我們用流對象的close()方法來關閉用於網路通訊的輸入輸出流,在用Socket對象的close()方法來關閉Socket。

『伍』 如何創建一個tls的socket進行連接

：java socket建立連接的過程如下： socket 1、 首先調用Socket類的構造函數，以伺服器的指定的IP地址或指定的主機名和指定的埠號為參數，創建一個Socket流，在創建Socket流的過程中包含了向伺服器請求建立通訊連接的過程實現。

『陸』 如何建立socket5代理伺服器

（1）設置用戶驗證和記賬功能，可按用戶進行記賬，沒有登記的用戶無權通過代理伺服器訪問Internet網。並對用戶的訪問時間、訪問地點、信息流量進行統計。
(2）對用戶進行分級管理，設置不同用戶的訪問許可權，對外界或內部的Internet地址進行過濾，設置不同的訪問許可權。

(3）增加緩沖器（Cache)，提高訪問速度，對經常訪問的地址創建緩沖區，大大提高熱門站點的訪問效率。通常代理伺服器都設置一個較大的硬碟緩沖區（可能高達幾個GB或更大），當有外界的信息通過時，同時也將其保存到緩沖區中，當其他用戶再訪問相同的信息時，則直接由緩沖區中取出信息，傳給用戶，以提高訪問速度。

『柒』 如何在客戶端上建立一個Socket與伺服器端連接,包括連接的函數

【zhuokai】:Socket.RemoteAddress Socket.RemoteHost伺服器端可以給連接上的客戶端發送測試數據，一定時間內回收到客戶端反應的可認為在線.【zhuokai】:請參考： http://www.programfan.com/article/showarticle.asp?id=2289【ylsl917】:我用的API,不是用的控制項,我貼出代碼來,麻煩大家給我修改一下吧procere TForm1.OnWork1Accept(var message: TMessage);Var Client_Addr: TSockAddr; ClientLen: Integer; s:string;begin FillChar(Client_Addr,Sizeof(Client_Addr),0); ClientLen := Sizeof(Client_Addr); Conn_Socket := Accept(Server_Socket,@Client_Addr,@ClientLen);{ 能不能在這里判斷出建立的這個 Comm_Socket 是哪台機器建立的,其IP是多少?} //讀取/關閉 事件 WSAAsyncSelect(Conn_Socket, Form1.Handle, WM_WORK1_READ, FD_READ or FD_CLOSE);end;【ylsl917】:解決了,只要 Client_Addr.sin_addr.S_addr 轉換成字元串IP就行了 function IPIntToStr(I:Integer):String; var sinaddr:in_addr; begin sinaddr.S_addr:=i; result:=String(inet_ntoa(sinaddr)); end;【ylsl917】:還有誰上來說說怎麼做到長連接!!!【wj19781215】:自己定義活動包探測客戶端是否在線，不要用windows的全局活動包檢測，至於長連接就是tcp哦。【ylsl917】:謝謝樓上的 還有一個問題啊 我用API實現socket 能不能讓程序既是伺服器端,又是客戶端 【zhuokai】: 我用API實現socket 能不能讓程序既是伺服器端,又是客戶端 意思是在同一個程序里客戶端連接伺服器？可以的，多個線程【wj19781215】:用getsockname和getpeername【abcdefgdeng】:在socketserver的onAccept事件中用Socket.RemoteAddress讀取【ylsl917】: 我用API實現socket 能不能讓程序既是伺服器端,又是客戶端 意思是在同一個程序里客戶端連接伺服器？可以的，多個線程

『捌』 我想問下如何在手機上建立一個伺服器，用Socket的方法如何實現。

TCP方式:
TCP協議客戶端實現：

//創建一個Socket對象，指定伺服器端的IP地址和埠號
Socketsocket=newSocket("192.168.1.104",4567);
//使用InputStream讀取硬碟上的文件,這里只是用文件當做信息源，可以讀取控制項用戶輸入信息
InputStreaminputStream=new
FileInputStream("f://file/words.txt");

//從Socket當中得到OutputStream

OutputStream outputStream=socket.getOutputStream();
bytebuffer[]=newbyte[4*1024];inttemp=0;

//將InputStream當中的數據取出，並寫入到OutputStream當中
while((temp=inputStream.read(buffer))!=-1)

5
{
outputStream.write(buffer,0,temp);}
outputStream.flush();}

TCP協議伺服器端實現：

//聲明一個ServerSocket對象
ServerSocketserverSocket=null;
try{

//創建一個ServerSocket對象，並讓這個Socket在4567埠監聽

serverSocket=newServerSocket(4567);

//調用ServerSocket的accept()方法，接受客戶端所發送的請求，
//如果客戶端沒有發送數據，那麼該線程就停滯不繼續

Socketsocket=serverSocket.accept();
//從Socket當中得到InputStream對象

InputStreaminputStream=socket.getInputStream();
bytebuffer[]=newbyte[1024*4];
inttemp=0;

//從InputStream當中讀取客戶端所發送的數據
while((temp=inputStream.read(buffer))!=-1)
{
System.out.println(newString(buffer,0,temp));}
}
catch(IOExceptione)
{

e.printStackTrace();}

serverSocket.close();
}

UDP方式
UDP的客戶端代碼實現如下：

public static void main(String[]args)
{
try{

//首先創建一個DatagramSocket對象

DatagramSocket socket=new DatagramSocket(4567);
//創建一個InetAddree

6

InetAddress serverAddress=InetAddress.getByName("192.168.1.104");

String str="hello";

//這是要傳輸的數據

byte data[]=str.getBytes();

//把傳輸內容分解成位元組

//創建一個DatagramPacket對象，並指定要講這個數據包發送到網
絡當中的哪個地址，以及埠號

DatagramPacket packet=new
DatagramPacket(data,data.length,serverAddress,4567);
//調用socket對象的send方法，發送數據
socket.send(packet);}
catch(Exceptione)
{

e.printStackTrace();}
}

UDP的服務端代碼實現如下：

//創建一個DatagramSocket對象，並指定監聽的埠號

DatagramSocket socket=new DatagramSocket(4567);
bytedata[]=newbyte[1024];
//創建一個空的DatagramPacket對象

DatagramPacket packet=new DatagramPacket(data,data.length);
//使用receive方法接收客戶端所發送的數據，
//如果客戶端沒有發送數據，該進程就停滯在這里

socket.receive(packet);

Stringresult=newString(packet.getData(),packet.getOffset(),
packet.getLength());

System.out.println("result--->"+result);