概述
??套接字（socket）是一個抽象層，應用程序可以通過它發送或接收數據，可對其進行像對文件一樣的打開、讀寫和關閉等操作。套接字允許應用程序將I/O插入到網絡中，并與網絡中的其他應用程序進行通信。網絡套接字是IP地址與端口的組合。
一、Web服務器
??Socket最初是加利福尼亞大學Berkeley分校為Unix系統開發的網絡通信接口。后來隨著TCP/IP網絡的發展，Socket成為最為通用的應用程序接口，也是在Internet上進行應用開發最為通用的API。
下面開始創建一個簡陋的Web服務器
創建Main類監聽端口等待請求：
/**
* 簡陋的Web服務器
*/
public class Main {
// 靜態文件位置
private final String classPath = this.getClass().getClassLoader().getResource("./").getPath();
// 靜態文件類型
public static Set<String> fileType;
static {
fileType = new HashSet<>();
fileType.add("png");
fileType.add("ico");
}
public static void main(String[] args) {
new Main(80);
}
public Main(int port) {
try {
// 開啟服務監聽端口
ServerSocket server = new ServerSocket(port);
while (true) {
// 阻塞，等待請求
Socket client = server.accept();
// TODO 使用線程池
// 創建線程處理請求
new Thread(new Handle(client, classPath)).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
創建請求處理類Handle:
/**
* web請求處理
*/
public class Handle implements Runnable {
private java.net.Socket socket;
private String classPath;
public Handle(java.net.Socket socket, String classPath) {
this.socket = socket;
this.classPath = classPath;
}
@Override
public void run() {
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
PrintWriter out = new PrintWriter(outputStream, true);
// 請求類型
String method = null;
// 請求頭屬性
String[] headers;
// 請求地址
String path = null;
// 接收請求頭屬性
String line;
while ((line = br.readLine()) != null && !"".equals(line)) {
if (method == null) {
headers = line.split(" ");
method = headers[0];
path = headers[1];
}
}
// 處理路徑
if (path != null) {
// 請求地址處理
String[] pathVariable = path.split("/");
if (pathVariable.length == 0) {
out.println("HTTP/1.1 200 OK");
out.println();
out.println("<font style=\"color:red;font-size:50\">Hello world!</font>");
return;
}
// 請求靜態文件處理
String lastRoute = pathVariable[pathVariable.length - 1];
if (lastRoute.contains(".")) {
// 處理靜態文件
if (Main.fileType.contains(lastRoute.split("[.]")[1])) {
File file = new File(classPath + lastRoute);
if (file.exists()) {
try (FileInputStream fis = new FileInputStream(file)) {
this.socket.getOutputStream().write(fis.readAllBytes());
} catch (IOException e) {
e.printStackTrace();
}
return;
}
}
}
// 404
out.println("<font style=\"font-size:50\">404</font>");
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (this.socket != null) {
this.socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
以上一個非常簡陋的Web服務器就完成了，接下來對本地80端口進行測試
localhost
favicon.ico
favicon.png
二、WebSocket
??WebSocket是一種在單個TCP連接上進行全雙工通信的協議。WebSocket通信協議于2011年被IETF定為標準RFC 6455，并由RFC7936補充規范。WebSocket API也被W3C定為標準。
??WebSocket使得客戶端和服務器之間的數據交換變得更加簡單，允許服務端主動向客戶端推送數據。在WebSocket API中，瀏覽器和服務器只需要完成一次握手，兩者之間就直接可以創建持久性的連接，并進行雙向數據傳輸。
下面開始創建WebSocket服務器：
創建后續需要用到的工具類CodingUtil：
public class CodingUtil {
/**
* 字節數組轉長整型
*
* @param bytes 字節數組
* @return Long
*/
public static long bytesToLong(byte[] bytes) {
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
buffer.put(bytes);
buffer.flip();
return buffer.getLong();
}
/**
* 對Sec-WebSocket-Key密鑰進行加密
* 生成Sec-WebSocket-Accept值
*
* @param key 密鑰
* @return String
* @throws NoSuchAlgorithmException
*/
public static String encryption(String key) throws NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("SHA1");
md.update((key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").getBytes());
byte[] bytes = md.digest();
return new String(Base64.getEncoder().encode(bytes));
}
/**
* 取指定位置bit
*
* @param b 字節
* @param index 位置
* @return
*/
public static int getByteBit(byte b, int index) {
return (b & 0x80 >> index) >> (7 - index);
}
/**
* 取指定區間bit
*
* @param b 字節
* @param start 開始位置
* @param end 結束位置
* @return int
*/
public static int getByteBits(byte b, int start, int end) {
return (b << start & 0xff) >> (7 - end + start);
}
}
CodingUtil類中encryption()方法是根據WebSocket協議https://tools.ietf.org/html/rfc6455#section-1.3，對接收到的Sec-WebSocket-Key值與258EAFA5-E914-47DA-95CA-C5AB0DC85B11連接進行SHA1加密后再通過Base64編碼得到Sec-WebSocket-Accept值再返回給客戶端。
創建WebSocketService類作為服務器啟動入口：
public class WebSocketService {
private SocketManager socketManager;
public WebSocketService() {
this.socketManager = new SocketManager();
}
/**
* 監聽指定端口 默認80
* 等待客戶端連接
* 連接后創建一個線程進行處理
*
* @return WebSocketService
*/
public WebSocketService start(int port) {
new Thread(new ManageCore(socketManager)).start();
try {
ServerSocket server = new ServerSocket(port);
while (true) {
Socket client = server.accept();
new Thread(new SocketHandle(client, socketManager)).start();
}
} catch (IOException e) {
e.printStackTrace();
}
return this;
}
}
該類中創建了SocketManager類來管理客戶端連接，實例化ManageCore類作為控制中心交給一個線程進行管理。開啟Socket服務監聽指定端口，使用socket的accept()方法阻塞線程等待請求。當請求到來開啟一個線程進行處理（SocketHandle類）。
創建SocketManager類：
public class ManageCore implements Runnable {
private SocketManager socketManager;
public ManageCore(SocketManager socketManager) {
this.socketManager = socketManager;
}
@Override
public void run() {
Scanner scanner = new Scanner(System.in);
Map<String, String> message = new HashMap<>();
message.put("name", "admin");
// 廣播消息
while (true) {
message.put("content", scanner.nextLine());
socketManager.broadcast(JSON.toJSONString(message));
}
}
}
創建SocketManager類：
public class SocketManager {
private LinkedList<OutputStream> outputStreams;
public SocketManager() {
outputStreams = new LinkedList<>();
}
/**
* 添加緩存
*
* @param outputStream
*/
public void add(OutputStream outputStream) {
outputStreams.add(outputStream);
}
/**
* 刪除緩存
*
* @param outputStream
*/
public void remove(OutputStream outputStream) {
outputStreams.remove(outputStream);
}
/**
* 廣播
*
* @param message 消息
*/
public void broadcast(String message) {
Iterator<OutputStream> iterator = outputStreams.listIterator();
while (iterator.hasNext()) {
try {
OutputStream outputStream = iterator.next();
push(message.getBytes(), outputStream);
} catch (IOException e) {
iterator.remove();
}
}
}
/**
* 通知
*
* @param message 消息
*/
public void notice(String message, OutputStream outputStream) {
try {
push(message.getBytes(), outputStream);
} catch (IOException e) {
remove(outputStream);
}
}
/**
* 推消息
*
* @param bytes
* @param outputStream
* @throws IOException
*/
public void push(byte[] bytes, OutputStream outputStream) throws IOException {
outputStream.write(new byte[]{(byte) 0x81, (byte) bytes.length});
outputStream.write(bytes);
}
/**
* 返回當前緩存的連接數
*
* @return int
*/
public int getCurrentConnNum() {
return outputStreams.size();
}
}
接下來創建SocketHandle類來對請求進行處理：
public class SocketHandle implements Runnable {
private Socket socket;
private SocketManager socketManager;
/**
* @param socket 與客戶端之間的連接
*/
public SocketHandle(Socket socket, SocketManager socketManager) {
this.socket = socket;
this.socketManager = socketManager;
}
@Override
public void run() {
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
// 處理報文,過濾請求
MessageFilter messageFilter = new MessageFilter();
messageFilter.doFilter(inputStream, outputStream);
String path = messageFilter.getPath();
// 緩存與客戶端的消息發送通道
socketManager.add(outputStream);
// 開啟接收消息
Thread receiveThread = new Thread(new WebSocketReceive(inputStream, socketManager));
receiveThread.start();
// 發送心跳包
while (receiveThread.isAlive()) {
Thread.sleep(15000);
socketManager.notice("h", outputStream);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (this.socket != null) {
this.socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
當瀏覽器使用websocket請求時服務端接收到的報文如下：
GET / HTTP/1.1
Host: localhost
Connection: Upgrade
Pragma: no-cache
Cache-Control: no-cache
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
Upgrade: websocket
Origin: file://
Sec-WebSocket-Version: 13
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cookie: _ga=GA1.1.420931640.1569149707
Sec-WebSocket-Key: q+RL7D/fr9/WQHlF2OK/Nw==
Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits
我們可以創建一個過濾器來對報文進行過濾（根據自己的需求進行過濾），判斷是WebSocket請求還是其他請求，若修改請求處理線程類SocketHandle，可根據過濾結果使用對應的處理器，使WebSocket服務器與上面的Web服務器結合使用：
public class MessageFilter {
private String path;
public void doFilter(InputStream inputStream, OutputStream outputStream) throws Exception {
// 讀取請求頭屬性
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
String line;
HashMap<String, String> headers = new HashMap<>();
while ((line = br.readLine()) != null && !"".equals(line)) {
String[] header = line.split(": ");
if (header.length == 2) {
headers.put(header[0], header[1]);
} else {
String[] parame = line.split(" ");
if (parame.length > 2) {
this.path = parame[1];
}
}
}
// 驗證請求
if (whether(headers)) {
throw new Exception("缺少必要的header");
}
// 返回請求頭
PrintWriter out = new PrintWriter(outputStream);
out.println("HTTP/1.1 101 Switching Protocols");
out.println("Connection: Upgrade");
out.println("Sec-WebSocket-Accept: " + CodingUtil.encryption(headers.get("Sec-WebSocket-Key")));
out.println("Upgrade: websocket");
out.println();
out.flush();
}
/**
* 確定是否存在對應屬性
*
* @param headers 請求頭屬性
* @return boolean
*/
public boolean whether(HashMap<String, String> headers) {
if (!"Upgrade".equals(headers.get("Connection"))) {
return false;
}
if (headers.get("Sec-WebSocket-Accept") == null) {
return false;
}
if (!"websocket".equals(headers.get("Upgrade"))) {
return false;
}
return true;
}
public String getPath() {
return path;
}
}
過濾請求，確定服務后緩存與客戶端的消息發送通道，開啟接收客戶端消息的線程并發送心跳。
創建WebSocketReceive類接收客戶端消息：
public class WebSocketReceive implements Runnable {
private InputStream inputStream;
private SocketManager socketManager;
public WebSocketReceive(InputStream inputStream, SocketManager socketManager) {
this.inputStream = inputStream;
this.socketManager = socketManager;
}
@Override
public void run() {
while (true) {
try {
receive();
} catch (Exception e) {
break;
}
](https://upload-images.jianshu.io/upload_images/18713780-9b5d9abfc607e017.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
}
}
public void receive() throws IOException {
byte[] frameReader = inputStream.readNBytes(1);
// FIN表示這是消息中的最后一個片段
// 當FIN為0時表示不是最后一個片段，為1時表示最后一個片段
int fin = getByteBit(frameReader[0], 0);
// RSV 是保留的擴展定義位，沒有擴展的情況下為0
int rsv1 = getByteBit(frameReader[0], 1);
int rsv2 = getByteBit(frameReader[0], 2);
int rsv3 = getByteBit(frameReader[0], 3);
// opcode操作碼
int opcode = getByteBits(frameReader[0], 4, 7);
switch (opcode) {
case 0:
// 連續幀
break;
case 1:
// 文本幀
break;
case 2:
// 二進制幀
break;
case 8:
// 連接關閉
throw new IOException("socket close");
case 9:
// ping
break;
case 10:
// pone
break;
}
// mask掩碼
frameReader = inputStream.readNBytes(1);
int mask = getByteBit(frameReader[0], 0);
// payload len 有效載荷
int payloadLen = getByteBits(frameReader[0], 1, 7);
// extended payload length 有效載荷長度延長
long extendedPayloadLen = payloadLen;
if (payloadLen == 126) {
// 讀2個字節
extendedPayloadLen = CodingUtil.bytesToLong(inputStream.readNBytes(2));
} else if (payloadLen == 127) {
// 讀8個字節
extendedPayloadLen = CodingUtil.bytesToLong(inputStream.readNBytes(8));
}
// 獲得屏蔽鍵
byte[] maskingKey = null;
if (mask == 1) {
maskingKey = inputStream.readNBytes(4);
}
// 解碼
frameReader = inputStream.readNBytes(Long.valueOf(extendedPayloadLen).intValue());
if (maskingKey != null) {
byte[] encodeBytes = new byte[frameReader.length];
for (int i = 0; i < encodeBytes.length; i++) {
encodeBytes[i] = (byte) (frameReader[i] ^ maskingKey[i % 4]);
}
String message = new String(encodeBytes);
socketManager.broadcast(message);
System.out.println(message);
// 自定義的消息格式 JSON解析使用了alibaba的fastjson
// JSONObject messager = JSON.parseObject(message);
// System.out.println(messager.get("name") + " : " + messager.get("content"));
}
}
/**
* 取指定位置bit
*
* @param b 字節
* @param index 位置
* @return
*/
private int getByteBit(byte b, int index) {
return (b & 0x80 >> index) >> (7 - index);
}
/**
* 取指定區間bit
*
* @param b 字節
* @param start 開始位置
* @param end 結束位置
* @return int
*/
private int getByteBits(byte b, int start, int end) {
return (b << start & 0xff) >> (7 - end + start);
}
}
在WebSocket協議中，使用幀傳輸數據，以上類只完成了對幀數據的獲取和解碼，為了簡單性對于其他機制的處理并沒有按照協議（可仔細閱讀協議自行補充），但是足夠完成與客戶端的通信要求。
最后可在WebSocketReceive類中使用SocketManager類進行消息廣播或者自定義一對一的消息通信。
完成以上步驟后就可以創建一個WebSocket類指定端口開啟WebSocket服務了：
public class WebSocket {
public static void main(String[] args) {
new WebSocketService().start(80);
}
}
接下來編寫html頁面來請求WebSocket服務器：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>群聊</title>
<script src="https://cdn.bootcss.com/jquery/3.4.0/jquery.slim.min.js"></script>
</head>
<body>
<div>
<label>請輸入用戶名：</label>
<input type="text" id="name" placeholder="用戶名">
</div>
<div>
<button type="button" id="connect">連接</button>
<button type="button" id="disconnect">斷開連接</button>
</div>
<div id="chat">
</div>
<div>
<input type="text" id="content" placeholder="內容" style="display: inline-block;">
<button type="button" id="send" style="display: inline-block;">發送</button>
</div>
<ul id="info" style="list-style: none">
</ul>
<script>
function connect() {
var ws = new WebSocket("ws://localhost");
ws.onopen = function(){
$('#chat').text('連接成功');
};
ws.onmessage = function (evt){
try{
update(JSON.parse(evt.data));
}catch(err){
}
};
ws.onclose = function(){
$('#chat').text('');
};
$('#send').click(function () {
ws.send(JSON.stringify({'name': $('#name').val(), 'content': $('#content').val()}));
});
$('#disconnect').click(function () {
ws.close();
});
}
function update(message) {
$('#info').append('<li><b>' + message.name + ' : </b>' + message.content + '</li>')
}
$(function () {
$('#connect').click(function () {
connect();
});
})
</script>
</body>
</html>
測試：
連接WebSocket服務器：
connect
服務端接收、發送消息：
service-send
客戶端發送消息：
client-send
