androidsocket40

① 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如何進行Socket通信

舉一個簡單的例子吧。

伺服器端：

java">importjava.io.IOException;
importjava.io.OutputStream;
importjava.net.ServerSocket;
importjava.net.Socket;

/**
*簡單Socket伺服器類
*/
publicclassSimpleServer{
	publicstaticvoidmain(String[]args)throwsIOException{
		//創建Socket伺服器，監聽客戶端Socket的連接請求
		ServerSocketserver=newServerSocket(30000);
		
		while(true){
			//每當接收到客戶端Socket請求，Socket伺服器端會產生一個對應的Socket
			Socketclient=server.accept();
			OutputStreamos=client.getOutputStream();
			os.write("歡迎您連接伺服器".getBytes("utf-8"));
			os.close();
			client.close();
		}
	}
}

Android客戶端：

packagecom.simpleclient;

importjava.io.BufferedReader;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.net.Socket;
importandroid.app.Activity;
importandroid.os.Bundle;
importandroid.widget.TextView;

{
	TextViewtextView;
	
@Override
publicvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

textView=(TextView)findViewById(R.id.textView1);

MyThreadthread=newMyThread();
thread.start();
}

/**
*線程類
*/
classMyThreadextendsThread{
		publicvoidrun(){
			try{
				Socketsocket=newSocket("192.168.1.51",30000);
				InputStreamis=socket.getInputStream();
				InputStreamReaderisr=newInputStreamReader(is);
				BufferedReaderbr=newBufferedReader(isr);
				textView.setText(br.readLine());
				br.close();
				isr.close();
				is.close();
				socket.close();
			}
			catch(Exceptione){
				System.out.println(e.toString());
			}
		}	
}
}

修改AndroidManifest.xml文件，允許訪問Internet：

<!--添加網路訪問許可權-->
<uses-permissionandroid:name="android.permission.INTERNET"/>

③ android socket崩潰問題

線程中的異常，要處理掉

try{
client = new Socket(site,port);
}catch(Exception e){
e.printStackTrace();

}

④ android如何與手機進行通信（Socket連接）

其實跟電腦差不多了，android里調用socket的方法，拿到socket後就可以發送數據並接收數據。

我最近正在做android方面的通信，真的想把完整的代碼都給你，可是沒辦法，公司機密。。

給你我的socket連接類吧。。。

package sean.socket;

///////////把MyType的一些方法替換成Writer的方法
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

import sean.Sysout;
import sean.business.BusinessCenter;
import sean.business.LoginManager;
import sean.format.MyType;
import sean.io.Reader;
import sean.transfer.BytesBuffer;
import sean.transfer.DataCenter;

public class SocketThread implements Runnable {

String Server = "";
int Port = 0;
static Socket cs = null;
// Thread ioThread=null;
static boolean bool_SocketThread = false;
static OutputStream output = null;

public SocketThread(String server, int port) {
Server = server;
Port = port;
bool_SocketThread = true;
}

@Override
public void run() {
// TODO Auto-generated method stub
while (bool_SocketThread) {
try {
// if (cs == null) {
DataCenter.setBool_Login(false);// 設置登錄失敗
Sysout.println("正在嘗試連接ClientSocket...", Sysout.TempOutDebug);
cs = new Socket(InetAddress.getByName(Server), Port);
if (cs != null) {
Sysout.println("ClientSocket連接成功！__" + cs,
Sysout.TempOutDebug);
cs.setKeepAlive(true);//讓socket保持活動狀態

InputStream input = cs.getInputStream();
output = cs.getOutputStream();
BusinessCenter.sendLoginData();

BytesBuffer bBuffer = new BytesBuffer();
byte[] Buffer = new byte[1024];
int ReadBytes = input.read(Buffer);
while (ReadBytes != -1) {
Sysout.println("已讀取" + ReadBytes + "個位元組到緩沖區",
Sysout.TempOutDebug);
byte[] b = new byte[ReadBytes];
b = MyType.BytesInsertToBytes(Buffer, b, 0);
Reader r = new Reader(b);
Sysout.println(r.toString() + "____ReadBytes=="
+ ReadBytes, Sysout.TempOutDebug);
bBuffer.InsertToBuffer(Buffer, ReadBytes);
ReadBytes = input.read(Buffer);
}
} else {
Sysout.printException("ClientSocket連接失敗！請確認網路正常且伺服器已開啟。");
}
// }
// 執行到這里說明inputstream.read()已中斷，說明socket已斷開連接
// cs=null;
LoginManager.setLoginValue(-1);// 業務中心登錄注銷，即登錄管理器注銷登錄
DataCenter.setBool_Login(false);// 數據中心登錄注銷
Sysout.printException(cs + "已斷開。");
Thread.sleep(2 * 1000);// 睡眠2秒後繼續循環

// try {
// // 判斷ClientSocket是否已斷開
// cs.sendUrgentData(0);
// } catch (IOException e) {
// // TODO Auto-generated catch block
// Sysout.printException("ClientSocket已斷開，重新連接。"+e);
// cs.close();
// cs = null;
// }
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
Sysout.printException("SocketThread.java====解析伺服器名稱發生異常！" + e);
// e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
Sysout.printException("SocketThread發生IO異常，異常消息：" + e);
try {
if (cs != null) {
Sysout.println("准備關閉" + cs, Sysout.TempOutDebug);
cs.shutdownOutput();
cs.shutdownInput();
cs.close();
cs = null;
output = null;
LoginManager.setLoginValue(-1);// 業務中心登錄注銷，即登錄管理器注銷登錄
DataCenter.setBool_Login(false);// 數據中心登錄注銷
Sysout.println(cs + "已關閉。", Sysout.TempOutDebug);
}
try {
Thread.sleep(5000);
} catch (InterruptedException e2) {
// TODO Auto-generated catch block
Sysout.printException("SocketThread.java====線程睡眠異常！！"
+ e2);
// e2.printStackTrace();
}
String ExceptionInfos=e.toString();
if(ExceptionInfos.endsWith("Connection refused")){
stopSocketThread();
}
} catch (IOException e1) {
// TODO Auto-generated catch block
Sysout.printException(cs + "關閉發生異常::" + e1);
// e1.printStackTrace();
try {
Thread.sleep(5000);
} catch (InterruptedException e2) {
// TODO Auto-generated catch block
Sysout.printException("SocketThread.java====線程睡眠異常！！"
+ e2);
// e2.printStackTrace();
}
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}// while(bool_SocketThread)
Sysout.println("SocketThread已停止。", Sysout.TempOutDebug);
}

public static Socket getSocket() {
return cs;
}

// public void setBool(boolean bool0) {
// bool_SocketThread = bool0;
// }

public static OutputStream getOutputStream() {
return output;
}

public static void stopSocketThread() {
try {
// 停止SocketThread線程，必須先把循環的標志bool_SocketThread置為false，否則可能繼續循環，重新建立socket連接
bool_SocketThread = false;
// 關閉socket
if (cs != null) {
cs.shutdownOutput();
cs.shutdownInput();
cs.close();
cs = null;
output = null;

Sysout.println("ClientSocket已被強制關閉。");
// LoginManager.setLoginValue(-1);// 業務中心登錄注銷，即登錄管理器注銷登錄
// DataCenter.setBool_Login(false);// 數據中心登錄注銷
// byte[] lock=LoginActivity.getLock();
// synchronized(lock){
// lock.notify();
// }
}
} catch (IOException e) {
// TODO Auto-generated catch block
Sysout.printException("強制關閉" + cs + "發生異常::" + e);
// e.printStackTrace();
}
}

}

必須先在android里啟動一個服務，由服務去啟動這個socket線程，因為如果是UI去啟動的話，頁面會卡住。。。

⑤ 關於Android的Socket埠的問題

調用SocketServer.close()方法，就可以關閉了.可以在socket代碼的try cath接收字元的塊後面加上一個finnaly塊，設置一個Thread.sleep()等待一定時間後，執行Socket.close()和SocketServer.close()

try {
sp = new SocketPackage(request, type);
OutputStream os = client.getOutputStream();
os.write(sp.request);
} catch (Exception e) {
Log.e(TAG, "Response to server failed", e);
} finally {
try {
Log.i(TAG, "Closing socket....");
Thread.sleep(10000);
flag = false;
socket.close();
client.close();
thread.interrupt();
Log.i(TAG, "Closing socket successed");
} catch (Exception e) {
Log.e(TAG, "Closing socket failed", e);
}
}

server為SocketServer對象，client為Socket對象，通過SocketServer.accept()創建。

這里是向客戶端響應之後的關閉。

⑥ android的Socket問題

這是android嘛？，android socket編程一般會出現許可權的問題，在一個androidmain.xml里配置一下，如果是java的socket編程 最好不要用127.0.0.1 給自己的主機分配一個ip地址，，

⑦ Android Socket了解一下

前段時間做了關於Socket的項目，總結一些在這個過程中學到的東西和需要注意的地方
socket 的使用在Android的開發中還是很常見的，也是非常重要的

先看下思維導圖

首先回一下以前學過的OSI七層網路模型分別是：物理層，數據鏈路層，網路層，傳輸層，會話層，表示層，應用層。

接下來看對我們開發比較重要的對比模型

定義： Transmission Control Protocol，即 傳輸控制協議

特點：

缺點：效率慢

TCP 三次握手和四次揮手

特點：

優點：速度快
缺點：消息容易丟失

特點：

以上是作為今天的主題，需要復習的一些簡單知識點，當然以上知識點裡面的細節遠遠不止這些，這邊知識對知識的一個梳理，打通的過程，接下看說說Socket

看圖理解

一張圖就能看懂

具體步驟

下面是一些簡單的測試方法，當然在實際的應用中，這些測試方法不一定實用，（僅供參考），因為每個企業的業務是不一樣的，比如說可能有的企業會對每個消息進行了組裝，有包頭，包體，報內容，包長度等，那麼你讀取、發送消息的時候都需要去解包、組包的。這一點需要注意

註：因為ICP/IP屬於傳輸層，socket也可以劃分到傳輸層，其實socket和http的對比沒有太大的實際意義，因為他們本身不是處於同一層級

一般在實際的應用中都會採用多線程去處理socket，一個線程負責讀取，一個線程負責發送。注意多線程的使用

⑧ Android4.0 socket通信

你好！把logcat發出來吧！
非UI線程不能修改ui控制項的，可以通過 handler.sendEmptyMessage(1);發送消息根據穿過來的值做相應處理；

⑨ Android Socket通信開發，求詳細過程，附加註釋，謝謝

服務端往Socket的輸出流裡面寫東西，客戶端就可以通過Socket的輸入流讀取對應的內容。Socket與Socket之間是雙向連通的，所以客戶端也可以往對應的Socket輸出流裡面寫東西，然後服務端對應的Socket的輸入流就可以讀出對應的內容。
Socket類型為流套接字（streamsocket）和數據報套接字(datagramsocket)。
Socket基本實現原理
TCP與UDP
1基於TCP協議的Socket
伺服器端首先聲明一個ServerSocket對象並且指定埠號，然後調用Serversocket的accept（）方法接收客戶端的數據。accept（）方法在沒有數據進行接收的處於堵塞狀態。（Socketsocket=serversocket.accept()）,一旦接收到數據，通過inputstream讀取接收的數據。
客戶端創建一個Socket對象，指定伺服器端的ip地址和埠號（Socketsocket=newSocket("172.168.10.108",8080);）,通過inputstream讀取數據，獲取伺服器發出的數據（OutputStreamoutputstream=socket.getOutputStream()），最後將要發送的數據寫入到outputstream即可進行TCP協議的socket數據傳輸。

⑩ android socket有幾種方法

/***第一種：客戶端Socket通過構造方法連接伺服器***/
//客戶端Socket可以通過指定IP地址或域名兩種方式來連接伺服器端,實際最終都是通過IP地址來連接伺服器
//新建一個Socket，指定其IP地址及埠號
Socket socket = new Socket("192.168.0.7",80);
/***Socket 客戶端 一些常用設置***/
//客戶端socket在接收數據時，有兩種超時：1.連接伺服器超時，即連接超時；2.連接伺服器成功後，接收伺服器數據超時，即接收超時
//*設置socket 讀取數據流的超時時間
socket.setSoTimeout(5000);
//發送數據包，默認為false，即客戶端發送數據採用Nagle演算法；
//但是對於實時交互性高的程序，建議其改為true，即關閉Nagle演算法，客戶端每發送一次數據，無論數據包大小都會將這些數據發送出去
socket.setTcpNoDelay(true);
//設置客戶端socket關閉時，close（）方法起作用時延遲1分鍾關閉，如果1分鍾內盡量將未發送的數據包發送出去
socket.setSoLinger(true, 60);
//設置輸出流的發送緩沖區大小，默認是8KB，即8096位元組
socket.setSendBufferSize(8096);
//設置輸入流的接收緩沖區大小，默認是8KB，即8096位元組
socket.setReceiveBufferSize(8096);
//作用：每隔一段時間檢查伺服器是否處於活動狀態，如果伺服器端長時間沒響應，自動關閉客戶端socket
//防止伺服器端無效時，客戶端長時間處於連接狀態
socket.setKeepAlive(true);
/*** Socket客戶端向伺服器端發送數據 ****/
//客戶端向伺服器端發送數據，獲取客戶端向伺服器端輸出流
OutputStream os = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(os);
BufferedWriter bw = new BufferedWriter(osw);
//代表可以立即向伺服器端發送單位元組數據
socket.setOOBInline(true);
//數據不經過輸出緩沖區，立即發送
socket.sendUrgentData(65);//"A"
//向伺服器端寫數據，寫入一個緩沖區
//註：此處字元串最後必須包含「\r\n\r\n」，告訴伺服器HTTP頭已經結束，可以處理數據，否則會造成下面的讀取數據出現阻塞
//在write（）方法中可以定義規則，與後台匹配來識別相應的功能，例如登錄Login（）方法，可以寫為write("Login|test,123 \r\n\r\n"),供後台識別;
bw.write("Login|test,123 \r\n\r\n");
//發送緩沖區中數據，必須有
bw.flush();

/*** Socket客戶端讀取伺服器端響應數據 ****/
//socket.isConnected代表是否連接成功過
if((socket.isConnected() == true) && (socket.isClosed() == false)){//判斷Socket是否處於連接狀態
//客戶端接收伺服器端的響應，讀取伺服器端向客戶端的輸入流
InputStream is = socket.getInputStream();
//緩沖區
byte[] buffer = new byte[is.available()];
//讀取緩沖區
is.read(buffer);
//轉換為字元串
String responseInfo = new String(buffer);
//日誌中輸出
Log.i("TEST", responseInfo);
} //關閉網路
socket.close();
/***第二種：通過connect方法連接伺服器***/
Socket socket_other = new Socket();
//使用默認的連接超時
socket_other.connect(new InetSocketAddress("192.168.0.7",80));
//連接超時2s
socket_other.connect(new InetSocketAddress("192.168.0.7",80),2000);
//關閉socket
socket_other.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}