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();
}