android非同步socket

① Android 基於UDP的Socket通信

1、連接DatagramSocket的服務端（ip和port）：開啟非同步線程和socket
2、發送數據（DatagramPacket）：非同步
3、接收數據（DatagramPacket）：注意連接狀態，非同步讀取
4、關閉連接：關閉DatagramSocket和對應線程

1、異常：android.os.NetworkOnMainThreadException。 socket需要在線程中使用
2、前後端統一傳輸或者接收協議 [requestcode size d1 d2 d3 ... ]，在解析時候用得到
3、實施監控socket的連接狀態，還是用心跳包發過去，然後返回數據，一段時間沒有的話則代表socket連接失敗。
4、注意receive接收數據後的有效長度（一個是預存的buffer，一個是有效結果buffer）
5、客戶端連上去後不知道為何一定要先發送一次，才能接收？
6、UDP不安全，有長度限制64K

2019 ^{(*￣(oo)￣)} 諸事順利！

② Socket同步和非同步的區別

socket的同步和非同步，主要是指處理服務端處理socket的模式，接收消息和處理消息的同步和非同步。

同步的socket，服務端在接收到一個socket請求之後，必須處理完並返回給客戶端之後，才處理下一個socket請求。
非同步的socket，服務端在收到一個socket請求之後，將該socket請求交給其他線程處理，然後繼續接收下一個socket請求。並不需要等上一個socket請求處理完才接收下一個。
一般現在都是非同步socket，同步socket只用於telnet等單實例的服務端，很少見了。

③ android socket用TCP方式client端怎麼監聽伺服器發送來的數據

伺服器端就是需要一個循環不停的接收，這樣才能保證伺服器能一直監聽客戶端傳過來的數據 你這是同步的，如果用非同步socket的話，BeginReceive裡面注冊了一個回調函數，在回調裡面再次調用BeginReceive就可以一直監聽了

④ Android-Socket

由於二者不屬於同一層面，所以本來是沒有可比性的。但隨著發展，默認的Http里封裝了下面幾層的使用，所以才會出現Socket & HTTP協議的對比：（主要是工作方式的不同）：

Socket可理解為一種特殊的文件，在伺服器和客戶端各自維護一個文件，並使用SocketAPI函數對其進行文件操作。在建立連接打開後，可以向各自文件寫入內容供對方讀取或讀取對方內容，通信結束時關閉文件。在UNIX哲學中「一切皆文件」，文件的操作模式基本為「打開-讀寫-關閉」三大步驟，Socket其實就是這個模式的一個實現。

創建socket的時候，也可以指定不同的參數創建不同的socket描述符，socket函數的三個參數分別為：

當我們調用socket創建一個socket時，返回的socket描述字它存在於協議族（address family，AF_XXX）空間中，但沒有一個具體的地址。如果想要給它賦值一個地址，就必須調用bind()函數，否則就當調用connect()、listen()時系統會自動隨機分配一個埠。

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
函數的三個參數分別為：

如果作為一個伺服器，在調用socket()、bind()之後就會調用listen()來監聽這個socket，如果客戶端這時調用connect()發出連接請求，伺服器端就會接收到這個請求。

TCP伺服器端依次調用socket()、bind()、listen()之後，就會監聽指定的socket地址了。TCP客戶端依次調用socket()、connect()之後就想TCP伺服器發送了一個連接請求。TCP伺服器監聽到這個請求之後，就會調用accept()函數取接收請求，這樣連接就建立好了。之後就可以開始網路I/O操作了，即類同於普通文件的讀寫I/O操作。

注意：accept的第一個參數為伺服器的socket描述字，是伺服器開始調用socket()函數生成的，稱為監聽socket描述字；而accept函數返回的是已連接的socket描述字。一個伺服器通常通常僅僅只創建一個監聽socket描述字，它在該伺服器的生命周期內一直存在。內核為每個由伺服器進程接受的客戶連接創建了一個已連接socket描述字，當伺服器完成了對某個客戶的服務，相應的已連接socket描述字就被關閉。

萬事具備只欠東風，至此伺服器與客戶已經建立好連接了。可以調用網路I/O進行讀寫操作了，即實現了網咯中不同進程之間的通信！網路I/O操作有下面幾組：
read()/write()
recv()/send()
readv()/writev()
recvmsg()/sendmsg()
recvfrom()/sendto()
我推薦使用recvmsg()/sendmsg()函數，這兩個函數是最通用的I/O函數，實際上可以把上面的其它函數都替換成這兩個函數。

從圖中可以看出，當客戶端調用connect時，觸發了連接請求，向伺服器發送了SYN J包，這時connect進入阻塞狀態；伺服器監聽到連接請求，即收到SYN J包，調用accept函數接收請求向客戶端發送SYN K ，ACK J+1，這時accept進入阻塞狀態；客戶端收到伺服器的SYN K ，ACK J+1之後，這時connect返回，並對SYN K進行確認；伺服器收到ACK K+1時，accept返回，至此三次握手完畢，連接建立。

總結：客戶端的connect在三次握手的第二個次返回，而伺服器端的accept在三次握手的第三次返回。

某個應用進程首先調用close主動關閉連接，這時TCP發送一個FIN M；
另一端接收到FIN M之後，執行被動關閉，對這個FIN進行確認。它的接收也作為文件結束符傳遞給應用進程，因為FIN的接收意味著應用進程在相應的連接上再也接收不到額外數據；
一段時間之後，接收到文件結束符的應用進程調用close關閉它的socket。這導致它的TCP也發送一個FIN N；
接收到這個FIN的源發送端TCP對它進行確認。
這樣每個方向上都有一個FIN和ACK。

所謂短連接，即連接只保持在數據傳輸過程，請求發起，連接建立，數據返回，連接關閉。它適用於一些實時數據請求，配合輪詢來進行新舊數據的更替。

https://github.com/nuisanceless/MySocketDemo
https://github.com/xuuhaoo/OkSocket

⑤ 如何干凈的實現Android/java Socket 長連接通信

JavaSocket通信有很多的時候需要我們不斷的學習。方面效率雖然不及C與C++但它以靈活語言優勢，為大家廣為使用。本文就對在使用java做通信方面程序時候應改注意問題做以說明。

1.長連接、短鏈接只是針對客戶端而言，伺服器無所謂長、短；

2.無論同步或者非同步通信，發送之後務必要又響應回復，確認收到，負責進行一定范圍內重發，例如重發三次；

3.長連接伺服器與客戶端之間務必需要心跳探測，由客戶端主動發起；

4.短連接伺服器通用代碼：

python">packagecom.biesan.sms.gate.unioncom.communication;
importcom.biesan.commons.Constants;
importcom.biesan.commons.util.CodeUtil;
importcom.biesan.sms.gate.unioncom.data.*;
importcom.biesan.sms.gate.unioncom.util.GateInfo;
importjava.net.*;
importjava.io.*;
importjava.util.*;
importorg.apache.log4j.*;
importspApi.*;
{
//stopflag
privatebooleanunInterrupt=true;
privatebooleanunErr=true;
//privatebooleancloseSocketFlag=false;
//serversocket
privateServerSocketserverSo=null;
//currentsocket
privateSocketso=null
privateOutputStreamoutput=null;
privateInputStreaminput=null;
//gatecommand
privateSGIP_CommandtmpCmd=null;
privateSGIP_Commandcmd=null;
privateBindbind=null;
privateBindRespbindResp=null;
//privateUnbinnBind=null;
privateUnbindRespunBindResp=null;
=true;
LoggerunioncomLog=Logger.getLogger(Unioncom
Deliver.class.getName());
publicUnioncomDeliver(){
}
publicvoidrun(){
unioncomLog.info("Start...");
while(unInterrupt){
this.initServer();
this.startServices();
while(this.unAcceptErrorFlag){
try{
//接受連接請求
unioncomLog.info("beforeacceptconnection!.......
FreeMemroy:"+Runtime.getRuntime().freeMemory());
this.acceptConnection();
unioncomLog.info("afteracceptconnection!.......
FreeMemroy:"+Runtime.getRuntime().freeMemory());
while(unErr){
cmd=newCommand();
unioncomLog.info("beforereadcommandfromstream
...........FreeMemroy:"+Runtime.getRuntime().
freeMemory());
tmpCmd=cmd.read(input);
unioncomLog.info("afterreadcommandfromstream"+
getCommandString(cmd.getCommandID())+"FreeMemroy:"+
Runtime.getRuntime().freeMemory());
if(tmpCmd==null){
unErr=false;
break;
}
switch(cmd.getCommandID()){
//biadreadycommunication
caseSGIP_Command.ID_SGIP_BIND:{
this.dealBind();
break;
}//exitbind
caseSGIP_Command.ID_SGIP_UNBIND:{
this.dealUnBind();
unioncomLog.info("afterunbindconnection!.......
FreeMemroy:"+Runtime.getRuntime().freeMemory());
break;
}//deliver
....
default://錯誤的命令字
break;
}//switch
}//while(unErr)
}catch(Exceptione){
unioncomLog.error("UnioncomRecvServiceError"
+e.getMessage());
}finally{
if(this.so!=null){
this.closeSocket();
}
this.unErr=true;
}
}//while(this.unAcceptErrorFlag)
try{
this.closeServerSocket();
sleep(200);//sleep
}catch(InterruptedExceptionie){
}
}//while(unInterrupt)
}
privateStringgetCommandString(intcmd){
switch(cmd){
//biadreadycommunication
caseSGIP_Command.ID_SGIP_BIND:{
return"BINDCOMMAND";
}//exitbind
caseSGIP_Command.ID_SGIP_UNBIND:{
return"UNBINDCOMMAND";
}//deliver
case...
default:
return"UNKNOWNCOMMAND";
}
}
privatevoiddealBind(){
try{
bind=newBind(tmpCmd);
if(bind.readbody()!=0){
unioncomLog.warn("ReadBinderror");
this.unErr=false;
}
bindResp=newBindResp(tmpCmd.getMsgHead());
bindResp.SetResult(0);
bindResp.write(output);
unioncomLog.debug("Bindsuccess!");
}catch(Exceptione){
unioncomLog.error("DelaUnionRecvBindError!"+
e.getMessage());
this.unErr=false;
}
}
privatevoiddealUnBind(){
try{
//unBind=(Unbind)tmpCmd;
unBindResp=newUnbindResp(tmpCmd.getMsgHead());
unBindResp.write(output);
unioncomLog.debug("UnBindsuccess!");
}catch(Exceptione){
unioncomLog.warn("Unbinderror!"+e.getMessage());
}
this.unErr=false;
}
privatevoidstartServices(){
booleanunStartServices=true;
while(unStartServices){
try{
serverSo=newServerSocket(ugInfo.getLocalServerPort(),5,
InetAddress.getByName(ugInfo.getLocalIpAdd()));
//serverSo.setSoTimeout(60000);
unStartServices=false;
unioncomLog.info("CreateunionrecvsocketOk!");
}catch(IOExceptione){
unioncomLog.warn("Createunionrecvsocketerror!"
+e.getMessage());
unStartServices=true;
UnioncomSubmit.thrSlp(3000);
}
}
}
privatevoidacceptConnection(){
//Accept失敗
try{
so=serverSo.accept();
so.setSoTimeout(10000);
}catch(Exceptione){
unioncomLog.warn("AcceptError!"+e.getMessage());
this.closeServerSocket();
this.unAcceptErrorFlag=false;
this.unErr=false;
}
//Accept成功
try{
input=so.getInputStream();
output=so.getOutputStream();
}catch(IOExceptione){
unioncomLog.warn("GetI/OstreamError!"+e.getMessage());
this.closeService();
this.unAcceptErrorFlag=false;
this.unErr=false;
}
}
privatevoidcloseSocket(){
try{
so.close();
unioncomLog.info("SocketCloseSuccess!!!");
}catch(Exceptione){
unioncomLog.error("SocketCloseFailure!!!"+e.getMessage());
}
}
privatevoidcloseServerSocket(){
try{
serverSo.close();
unioncomLog.info("ServerSocketCloseSuccess!!!");
}catch(Exceptione){
unioncomLog
.error("ServerSocketCloseFailure!!!"+e.getMessage());
}
}
privatevoidcloseService(){
this.closeSocket();
this.closeServerSocket();
}
privatevoidinitServer(){
this.bind=null;
this.bindResp=null;
//this.unBind=null;
this.unBindResp=null;
this.tmpCmd=null;
this.cmd=null;
this.serverSo=null;
this.so=null;
this.output=null;
this.input=null;
this.unErr=true;
//this.closeSocketFlag=false;
unioncomLog.info("Memory***==="
+java.lang.Runtime.getRuntime().freeMemory());
}
(){
this.unInterrupt=false;
unioncomLog.info("Requreinterrupt!!!");
}

(intmsgCoding,byte[]msgContent){
StringdeliverContent=null;
try{
if(msgContent!=null){
if(msgCoding==8){//處理ucs32編碼
deliverContent=newString(msgContent,
"UnicodeBigUnmarked");
}elseif(msgCoding==0){//處理ASCII編碼
deliverContent=newString(msgContent,"ASCII");
}elseif(msgCoding==4){//處理binary編碼
deliverContent=newString(msgContent);
}elseif(msgCoding==15){//處理GBK編碼
deliverContent=newString(msgContent,"GBK");
//處理DELIVER數據包的簡訊息ID
}else{
unioncomLog.error("編碼格式錯誤!");
return"";
}
}else
return"";
returndeliverContent;
}catch(){
unioncomLog.error("dealcontenterror!"+
ex.getMessage());
return"";
}
}
}

⑥ android studio連接io.socket:sokect.io-client伺服器的條件

條件是socket協議。
WebSocket是跟隨HTML5一同提出的，所以在兼容性上存在問題，這時一個非常好用的庫就登場了——Socket.io。
socket.io封裝了websocket，同時包含了其它的連接方式，你在任何瀏覽器里都可以使用socket.io來建立非同步的連接。socket.io包含了服務端和客戶端的庫，如果在瀏覽器中使用了socket.io的js，服務端也必須同樣適用。
socket.io是基於Websocket的Client-Server實時通信庫。
socket.io底層是基於engine.io這個庫。engine.io為socket.io提供跨瀏覽器/跨設備的雙向通信的底層庫。engine.io使用了Websocket和XHR方式封裝了一套socket協議。在低版本的瀏覽器中，不支持Websocket，為了兼容使用長輪詢(polling)替代。

⑦ android localserversocket 創建的文件在哪個目錄

Socket最初用在基於TCP/IP網路間進程通信中，以客戶端/伺服器模式進行通信。
實現非同步操作，共享資源集中處理，提高客戶端響應能力。

⑧ WebSocket SSL 加密淺析

WebSocket 是基於Http 協議的改進，Http 為無狀態協議，基於短連接，需要頻繁的發起請求，第二 Http 只能客戶端發起請求，服務端無法主動請求。

都是基於TCP的應用層協議。
都使用Request/Response模型進行連接的建立。
在連接的建立過程中對錯誤的處理方式相同，在這個階段WS可能返回和HTTP相同的返回碼。
都可以在網路中傳輸數據。

WS使用HTTP來建立連接，但是定義了一系列新的header域，這些域在HTTP中並不會使用。
WS的連接不能通過中間人來轉發，它必須是一個直接連接。
WS連接建立之後，通信雙方都可以在任何時刻向另一方發送數據。
WS連接建立之後，數據的傳輸使用幀來傳遞，不再需要Request消息。
WS的數據幀有序。

WebSocket 分為握手和數據傳輸

WebSocket 的握手基於http GET方法進行，

通過Http握手之後，如果是http 協議的話，tcp 連接會斷開，這里在http 頭部指明了升級為 websocket， 所以tcp 連接不斷開。 WebSocket在握手後發送數據並象下層TCP協議那樣由用戶自定義,還是需要遵循對應的應用協議規范。 WebSocket 數據傳輸以數據幀的形式傳輸。

數據幀的結構如下圖：

AndroidAsync 是一個基於nio的非同步socket ，http（客戶端伺服器端），websocket，socket.io庫，AndroidAsync 是一個底層的網路協議庫。AndroidAsync 適合用於一個未被封裝的Android的raw Socket， HTTP client/server, WebSocket, and Socket.IO。

特性

wss 建立在HTTPS 的基礎上，在握手的時候使用HTTS 建立連接。HTTPS是HTTP over SSL/TLS，HTTP是應用層協議，TCP是傳輸層協議，在應用層和傳輸層之間，增加了一個安全套接層SSL/TLS。
HTTPS 連接過程如下圖：

AndroidSync API
AndroidSync 對ssl 的支持如下：

ssl 連接需要證書，通常證書是CA機構發布，保證權威性。但是也可以使用自簽名證書。如12306.根據我們車機的特點，可以採用自簽名證書。

HTTPS ，是一種網路安全傳輸協議，利用 SSL/TLS 來對數據包進行加密,以提供對網路伺服器的身份認證，保護交換數據的隱私與完整性。 中間人攻擊， Man-in-the-middle attack ，縮寫： MITM ，是指攻擊者與通訊的兩端分別創建獨立的聯系，並交換其所收到的數據，使通訊的兩端認為他們正在通過一個私密的連接與對方直接對話，但事實上整個會話都被攻擊者完全控制。
https 在理論上是可以抵禦 MITM ，但是由於開發過程中的編碼不規范，導致 https 可能存在 MITM 攻擊風險，攻擊者可以解密、篡改 https 數據。 0X02 https 漏洞 Android https 的開發過程中常見的安全缺陷:

Android安全開發之安全使用HTTPS

竊聽風暴：Android平台https嗅探劫持漏洞

淺析HTTPS中間人攻擊與證書校驗

⑨ Android - Socket簡單使用

ServerSocket類提供如下構造器：

當ServerSocket使用完畢，應使用 close() 方法來關閉此ServerSocket。通常情況下，伺服器不應該只接收一個客戶端請求，而應該不斷接收來自客戶端的請求，所以程序可以通過循環，不斷調用ServerSocket的accept方法：

Socket 常用構造器

註：上面兩個構造器指定遠程主機時既可以使用InetAddress來指定，也可以直接使用String對象來指定遠程IP。本地主機只有一個IP地址時，使用第一個方法更簡單。

在與伺服器進行通訊的時候，無法判斷遠程的伺服器是否斷開連接。如果使用 OutputStream 發送數據則會影響正常的數據發送（無法區分）。所以就引入了一個心跳機制。

心跳機制實現，使用 Socket.sendUrgentData() 方法發送一個位元組流數據（緊急數據）。可以通過判斷服務端的 OOBINLINE 屬性是否打開，來確定是否斷開連接；

setSoTimeout()理解 ：設置超時時間；例如：設置為2s，如果阻塞的時間>2s ，那麼就會報錯。