网络那些事（1）——认知Socket

相信能够认知到socket层面的大家，至少对网络的分层有一定的了解。这里便简单的呈现一张经典的网络协议的层级图方便对应理解。

OSI网络模型

在Java（Kotlin）/Android中，Socket是对TCP/UDP层协议的封装接口，负责完成三次握手的连接建立，我们使用socket可以轻易的完成在C/S模式（即客户端/服务器端）下数据的简单传输。下面我们首先分析一下服务器端Socket的：1.监听端口；2.获取客户端发来的输入流；3.向客户端发送服务器端的输出流。

object Main {
    @JvmStatic fun main(args: Array<String>) {
        val server = SfServer()//初始化Server，开始监听
        server.startListen()
    }
}

import java.net.ServerSocket
class SfServer {
    var serverSocket: ServerSocket? = null//在服务端要使用ServerSocket而不是Socket
    fun startListen() {
        try {
            serverSocket = ServerSocket(9000)//实例化ServerSocket的过程是一个阻塞的过程，只有绑定成功或者失败才会继续执行
            System.out.println("监听端口9000成功")
            while (true) {
                val socket = serverSocket!!.accept()//accept是监听端口，同样是阻塞的，只有监听到来访者才会继续执行
                val dealThread = Thread(DealClientSocket(socket))//当执行到这一行说明accept已监听到来访者，这时获取来访者的socket，单开一个线程对其进行处理，主线程继续监听阻塞。
                dealThread.start()
            }
        } catch(e: Exception) {
               e.printStackTrace()
            System.out.println("绑定失败")
        }
    }
}

以上就是server端的第一步：监听端口。接下来看在处理这一个客户端的访问时，如何获取输入流和输出流。

import java.io.*
import java.net.Socket
import java.nio.charset.Charset
import java.util.*

class DealClientSocket(val clientSocket: Socket) : Runnable {
    //将建立握手的socket传入构造函数，交给这个类处理。
    @Throws(UnsupportedOperationException::class)
    override fun run() {
        val input = socket.inputStream
        val str = readLine(input)
        System.out.println(str)
        val pw = PrintWriter(socket.outputStream)

        pw.println("来自server的问候")
        pw.flush()
        
        input.close()
        pw.close()
        socket.close()
    }

    @Throws(IOException::class)
    private fun readLine(`is`: InputStream): String {
        val lineByteList = ArrayList<Byte>()
        var readByte: Byte
        do {
            readByte = `is`.read().toByte()
            lineByteList.add(java.lang.Byte.valueOf(readByte))
        } while (readByte.toInt() != 10)
        
        val byteArr = lineByteList.toByteArray()
        return String(byteArr, Charset.defaultCharset())
    }
}

1.这里获取socket中的InputStream，将数据一行一行取出。
2.使用PrintWriter包装OutputStream，将要回复的数据发出。
3.关闭输入输出流和socket连接。

客户端的代码与server端代码也只有一丁点的不同：

import android.util.Log
import java.io.IOException
import java.io.InputStream
import java.io.PrintWriter
import java.net.Socket
import java.nio.charset.Charset

class SimpleSocket : Runnable {
    val HOST = "10.59.47.206"
    val PORT = 9000
    override fun run() {
        var socket = Socket(HOST, PORT)//不同点：需要指定ip地址和端口号
        val pw = PrintWriter(socket.getOutputStream())
        val input = socket.getInputStream()
        pw.println("from app")
        pw.flush()
        
        val back = readLine(input)
        Log.e("sfhttp", "Server:$back")
       
        input.close()
        pw.close()
        socket.close()
    }
    
    @Throws(IOException::class)
    private fun readLine(`is`: InputStream): String {
        val lineByteList = ArrayList<Byte>()
        var readByte: Byte
        do {
            readByte = `is`.read().toByte()
            lineByteList.add(java.lang.Byte.valueOf(readByte))
        } while (readByte.toInt() != 10)
        val byteArr = lineByteList.toByteArray()
        return String(byteArr, Charset.defaultCharset())
    }
}

值得注意的是，上述两端有一个隐形的“坑”：当获取输入流的时候，没有使用BufferedReader(InputStreamReader(socket.getInputStream))进行封装，而是直接操作的inputStream。
虽然java提供了上述封装，但它有个特点，一旦不满足某些条件，就一定会阻塞住，有时候虽然数据都打印出来了，竟然还莫名其妙的阻塞着。这就非常的蛋疼了。于是我们干脆自定义readLine方法，读取一行。这一行的结束标志就是byte.toInt=10(换行符\n).因此我们在PrintWriter调用的时候都是用pringln()方法自带换行符。

这个特点将在上层应用和协议——HTTP协议中得到体现。因此不能小看，需要牢记。

总结：

• Socket是TCP/UDP协议层的封装接口
• Socket、ServerSocket的使用，互相发送和读取信息
• Socket 需要注意换行符的使用
• HTTP的实现是基于Socket.