最近在整理socket知识，特意做了一个笔记，以供以后查阅。
1.简介
IP协议对应于网络层，TCP协议对应于传输层，而HTTP协议对应于应用层，socket则是对TCP/IP协议的封装和应用(程序员层面上)，它并不是一个协议。
在TCP/IP协议族中主要的Socket类型为流套接字（streamsocket）和数据报套接字(datagramsocket)。流套接字将TCP作为其端对端协议，据报套接字使用UDP协议。
2.通信模型
socket通信模型
3.Android中的源码实现
3.1 TCP模式
Java中基于TCP协议实现网络通信的类：
- 客户端的Socket类
- 服务器端的ServerSocket类
tcp socket模型
3.1.1 TCP通信实现步骤
① 创建ServerSocket和Socket
② 打开连接到Socket的输入/输出流
③ 按照协议对Socket进行读/写操作
④ 关闭输入输出流、关闭Socket
服务器端：
① 创建ServerSocket对象，绑定监听端口
② 通过accept()方法监听客户端请求
③ 连接建立后，通过输入流读取客户端发送的请求信息
④ 通过输出流向客户端发送响应信息
⑤ 关闭相关资源
/**
* 基于TCP协议的Socket通信，实现用户登录，服务端
*/
//1、创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
ServerSocket serverSocket =newServerSocket(10086);//1024-65535的某个端口
//2、调用accept()方法开始监听，等待客户端的连接
Socket socket = serverSocket.accept();
//3、获取输入流，并读取客户端信息
InputStream is = socket.getInputStream();
InputStreamReader isr =newInputStreamReader(is);
BufferedReader br =newBufferedReader(isr);
String info =null;
while((info=br.readLine())!=null){
System.out.println("我是服务器，客户端说："+info)；
}
socket.shutdownInput();//关闭输入流
//4、获取输出流，响应客户端的请求
OutputStream os = socket.getOutputStream();
PrintWriter pw = new PrintWriter(os);
pw.write("欢迎您！");
pw.flush();
//5、关闭资源
pw.close();
os.close();
br.close();
isr.close();
is.close();
socket.close();
serverSocket.close();
客户端：
① 创建Socket对象，指明需要连接的服务器的地址和端口号
② 连接建立后，通过输出流想服务器端发送请求信息
③ 通过输入流获取服务器响应的信息
④ 关闭响应资源
//客户端
//1、创建客户端Socket，指定服务器地址和端口
Socket socket =newSocket("localhost",10086);
//2、获取输出流，向服务器端发送信息
OutputStream os = socket.getOutputStream();//字节输出流
PrintWriter pw =newPrintWriter(os);//将输出流包装成打印流
pw.write("用户名：admin；密码：123");
pw.flush();
socket.shutdownOutput();
//3、获取输入流，并读取服务器端的响应信息
InputStream is = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String info = null;
while((info=br.readLine())!null){
System.out.println("我是客户端，服务器说："+info);
}
//4、关闭资源
br.close();
is.close();
pw.close();
os.close();
socket.close();
应用多线程实现服务器与多客户端之间的通信：
① 服务器端创建ServerSocket，循环调用accept()等待客户端连接
② 客户端创建一个socket并请求和服务器端连接
③ 服务器端接受苦读段请求，创建socket与该客户建立专线连接
④ 建立连接的两个socket在一个单独的线程上对话
⑤ 服务器端继续等待新的连接
//服务器线程处理
//和本线程相关的socket
Socket socket =null;
//
public serverThread(Socket socket){
this.socket = socket;
}
publicvoid run(){
//服务器处理代码
}
//============================================
//服务器代码
ServerSocket serverSocket =newServerSocket(10086);
Socket socket =null;
int count =0;//记录客户端的数量
while(true){
socket = serverScoket.accept();
ServerThread serverThread =newServerThread(socket);
serverThread.start();
count++;
System.out.println("客户端连接的数量："+count);
}
3.2 UDP模式
3.2.1 基本概念
UDP协议（用户数据报协议）是无连接的、不可靠的、无序的,速度快。 进行数据传输时，首先将要传输的数据定义成数据报（Datagram），大小限制在64k，在数据报中指明数据索要达到的Socket（主机地址和端口号），然后再将数据报发送出去
- DatagramPacket类:表示数据报包
- DatagramSocket类：进行端到端通信的类
3.2.2 UDP通信实现步骤
服务器端实现步骤:
① 创建DatagramSocket，指定端口号
② 创建DatagramPacket
③ 接受客户端发送的数据信息
④ 读取数据
//服务器端，实现基于UDP的用户登录
//1、创建服务器端DatagramSocket，指定端口
DatagramSocket socket =new datagramSocket(10010);
//2、创建数据报，用于接受客户端发送的数据
byte[] data =newbyte[1024];//
DatagramPacket packet =newDatagramPacket(data,data.length);
//3、接受客户端发送的数据
socket.receive(packet);//此方法在接受数据报之前会一致阻塞
//4、读取数据
String info =newString(data,o,data.length);
System.out.println("我是服务器，客户端告诉我"+info);
//=========================================================
//向客户端响应数据
//1、定义客户端的地址、端口号、数据
InetAddress address = packet.getAddress();
int port = packet.getPort();
byte[] data2 = "欢迎您！".geyBytes();
//2、创建数据报，包含响应的数据信息
DatagramPacket packet2 = new DatagramPacket(data2,data2.length,address,port);
//3、响应客户端
socket.send(packet2);
//4、关闭资源
socket.close();
客户端实现步骤:
① 定义发送信息
② 创建DatagramPacket，包含将要发送的信息
③ 创建DatagramSocket
④ 发送数据
//客户端
//1、定义服务器的地址、端口号、数据
InetAddress address =InetAddress.getByName("localhost");
int port =10010;
byte[] data ="用户名：admin;密码：123".getBytes();
//2、创建数据报，包含发送的数据信息
DatagramPacket packet = newDatagramPacket(data,data,length,address,port);
//3、创建DatagramSocket对象
DatagramSocket socket =newDatagramSocket();
//4、向服务器发送数据
socket.send(packet);
//接受服务器端响应数据
//======================================
//1、创建数据报，用于接受服务器端响应数据
byte[] data2 = new byte[1024];
DatagramPacket packet2 = new DatagramPacket(data2,data2.length);
//2、接受服务器响应的数据
socket.receive(packet2);
String raply = new String(data2,0,packet2.getLenth());
System.out.println("我是客户端，服务器说："+reply);
//4、关闭资源
socket.close();
4.关于阻塞
先说说一些比较“轻”的避免手段：
1）发送完后调用Socket的shutdownOutput()方法关闭输出流，这样对端的输入流上的read操作就会返回-1。但是这个方法不能用于通信双方需要多次交互的情况。
2）发送数据时，约定数据的首部固定字节数为数据长度。这样读取到这个长度的数据后，就不继续调用read方法。
3）为了防止read操作造成程序永久挂起，还可以给socket设置超时。
如果read()方法在设置时间内没有读取到数据，就会抛出一个java.net.SocketTimeoutException异常。
例如下面的方法设定超时3秒。
socket.setSoTimeout(3000);
接着我们来看看比较“重”的两种解决方案：
4.1 多线程解决堵塞
主要是为了解决多个客户端同时访问引起的阻塞问题，上面已经谈到了多线程的实现，不过可以更进一步，在服务器端加上线程池，使处理更加高效：
服务器源码：
public class Server {
public static void main(String[] args) throws IOException, InterruptedException {
ServerSocket serverSocket = new ServerSocket();
serverSocket.bind(new InetSocketAddress(9527), 10);
final AtomicInteger count = new AtomicInteger(0);
ExecutorService pool = Executors.newCachedThreadPool(new ThreadFactory() {
public Thread newThread(Runnable r) {
return new Thread(r, "ThreadPool-new-" + count.incrementAndGet());
}
});
while(true) {
try {
final Socket clientSocket = serverSocket.accept();
pool.execute(new Runnable() {
public void run() {
String client = clientSocket.getInetAddress().getHostAddress() + ":" + clientSocket.getPort();
System.out.println(client + " received!");
System.out.println(Thread.currentThread().getName() + " handle " + client);
try {
clientSocket.setTcpNoDelay(true);
clientSocket.setReuseAddress(true);
BufferedReader bufReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter writer = new PrintWriter(clientSocket.getOutputStream());
String line = bufReader.readLine();
System.out.println(client + " say:" + line);
writer.println("received '" + line + "'");
writer.flush();
Thread.sleep(10000);
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
4.2 使用NIO非阻塞通信
NIO则具有非阻塞的特性，可以通过对channel的阻塞行为的配置，实现非阻塞式的信道。在非阻塞情况下，线程在等待连接，写数据等（标准IO中的阻塞操作）的同时，也可以做其他事情，这便实现了线程的异步操作。
这里有关于nio的详细说明：
https://www.jianshu.com/p/052035037297
-
非阻塞式网络IO的特点：
1）把整个过程切换成小的任务，通过任务间协作完成。
2）由一个专门的线程来处理所有的 IO 事件，并负责分发。
3）事件驱动机制：事件到的时候触发，而不是同步的去监视事件。
4）线程通讯：线程之间通过 wait,notify 等方式通讯。保证每次上下文切换都是有意义的。减少无谓的进程切换
5）Java NIO引入了选择器的概念，选择器可以监听多个通道的事件（比如：连接打开，数据到达）。因此，单个的线程可以监听多个数据通道，这也是非阻塞IO的核心。而在标准IO的Socket编程中，单个线程则只能在一个端口监听。
参考：
-
NIO模式的基本原理描述如下：
服务端打开一个通道（ServerSocketChannel），并向通道中注册一个选择器（Selector），这个选择器是与一些感兴趣的操作的标识（SelectionKey，即通过这个标识可以定位到具体的操作，从而进行响应的处理）相关联的，然后基于选择器（Selector）轮询通道（ServerSocketChannel）上注册的事件，并进行相应的处理。
客户端在请求与服务端通信时，也可以像服务器端一样注册（比服务端少了一个SelectionKey.OP_ACCEPT操作集合），并通过轮询来处理指定的事件，而不必阻塞。
服务器端源码示例：
public class NIOServer {
private static int BUFF_SIZE=1024;
private static int TIME_OUT = 2000;
public static void main(String[] args) throws IOException {
Selector selector = Selector.open();
ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(10083));
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
TCPProtocol protocol = new EchoSelectorProtocol(BUFF_SIZE);
while (true) {
if(selector.select(TIME_OUT)==0){
//在等待信道准备的同时，也可以异步地执行其他任务， 这里打印*
System.out.print("*");
continue;
}
Iterator keyIter = selector.selectedKeys().iterator();
while (keyIter.hasNext()) {
SelectionKey key = keyIter.next();
//如果服务端信道感兴趣的I/O操作为accept
if (key.isAcceptable()){
protocol.handleAccept(key);
}
//如果客户端信道感兴趣的I/O操作为read
if (key.isReadable()){
protocol.handleRead(key);
}
//如果该键值有效，并且其对应的客户端信道感兴趣的I/O操作为write
if (key.isValid() && key.isWritable()) {
protocol.handleWrite(key);
}
//这里需要手动从键集中移除当前的key
keyIter.remove();
}
}
}
}
public interface TCPProtocol {
void handleAccept(SelectionKey key) throws IOException;
void handleRead(SelectionKey key) throws IOException;
void handleWrite(SelectionKey key) throws IOException;
}
public class EchoSelectorProtocol implements TCPProtocol {
private int bufSize; // 缓冲区的长度
public EchoSelectorProtocol(int bufSize){
this.bufSize = bufSize;
}
@Override
public void handleAccept(SelectionKey key) throws IOException {
System.out.println("Accept");
SocketChannel socketChannel = ((ServerSocketChannel)key.channel()).accept();
socketChannel.configureBlocking(false);
socketChannel.register(key.selector(), SelectionKey.OP_READ, ByteBuffer.allocate(bufSize));
}
@Override
public void handleRead(SelectionKey key) throws IOException {
SocketChannel clntChan = (SocketChannel) key.channel();
//获取该信道所关联的附件，这里为缓冲区
ByteBuffer buf = (ByteBuffer) key.attachment();
buf.clear();
long bytesRead = clntChan.read(buf);
//如果read（）方法返回-1，说明客户端关闭了连接，那么客户端已经接收到了与自己发送字节数相等的数据，可以安全地关闭
if (bytesRead == -1){
clntChan.close();
}else if(bytesRead > 0){
//如果缓冲区总读入了数据，则将该信道感兴趣的操作设置为为可读可写
key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
}
}
@Override
public void handleWrite(SelectionKey key) throws IOException {
// TODO Auto-generated method stub
ByteBuffer buffer=(ByteBuffer) key.attachment();
buffer.flip();
SocketChannel clntChan = (SocketChannel) key.channel();
//将数据写入到信道中
clntChan.write(buffer);
if (!buffer.hasRemaining()){
//如果缓冲区中的数据已经全部写入了信道，则将该信道感兴趣的操作设置为可读
key.interestOps(SelectionKey.OP_READ);
}
//为读入更多的数据腾出空间
buffer.compact();
}
}
客户端：
public class NIOClient {
public static void main(String[] args) throws IOException {
SocketChannel clntChan = SocketChannel.open();
clntChan.configureBlocking(false);
if (!clntChan.connect(new InetSocketAddress("localhost", 10083))){
//不断地轮询连接状态，直到完成连接
while (!clntChan.finishConnect()){
//在等待连接的时间里，可以执行其他任务，以充分发挥非阻塞IO的异步特性
//这里为了演示该方法的使用，只是一直打印"."
System.out.print(".");
}
}
//为了与后面打印的"."区别开来，这里输出换行符
System.out.print("\n");
//分别实例化用来读写的缓冲区
ByteBuffer writeBuf = ByteBuffer.wrap("send send send".getBytes());
ByteBuffer readBuf = ByteBuffer.allocate("send".getBytes().length-1);
while (writeBuf.hasRemaining()) {
//如果用来向通道中写数据的缓冲区中还有剩余的字节，则继续将数据写入信道
clntChan.write(writeBuf);
}
StringBuffer stringBuffer=new StringBuffer();
//如果read（）接收到-1，表明服务端关闭，抛出异常
while ((clntChan.read(readBuf)) >0){
readBuf.flip();
stringBuffer.append(new String(readBuf.array(),0,readBuf.limit()));
readBuf.clear();
}
//打印出接收到的数据
System.out.println("Client Received: " + stringBuffer.toString());
//关闭信道
clntChan.close();
}
}
参考引用：
- http://blog.csdn.net/maoxiao1229/article/details/22886337
- http://www.cnblogs.com/rocomp/p/4790340.html
- http://blog.csdn.net/laliocat/article/details/52758379
- http://blog.csdn.net/xxqi1229/article/details/39315305
- http://www.cnblogs.com/ywind/p/4555625.html