一.通過Socket實現TCP編程
1.1 TCP編程
TCP協議是面向連接，可靠的，有序的，以字節流的方式發送數據。基於TCP協議實現網絡通信的類有客戶端的Socket類和服務器端的ServerSocket類。
1.2 服務器端套路
1.創建ServerSocket對象，綁定監聽端口。
2.通過accept（）方法監聽客戶端請求。
3.連接建立後，通過輸入流讀取客戶端發送的請求信息。
4.通過輸出流向客戶端發送響應信息。
5.關閉響應的資源。
1.3 客戶端套路
1.創建Socket對象，指明需要連接的服務器的地址和端口號。
2.連接建立後，通過輸出流向服務器發送請求信息。
3.通過輸入流獲取服務器響應的信息。
4.關閉相應資源。
1.4 多線程實現服務器與多客戶端之間通信步驟
1.服務器端創建ServerSocket，循環調用accept（）等待客戶端連接。
2. 客戶端創建一個socket並請求和服務器端連接。
3.服務器端接受客戶端請求，創建socket與該客戶建立專線連接。
4.建立連接的兩個socket在一個單獨的線程上對話。
5.服務器端繼續等待新的連接。
1.5 創建處理線程類ServerThread
這裡選擇實現runnable接口而不是繼承Thread是因為一個類只能繼承一個父類，當我需要繼承其他類的時，父類就就不好處理了。
package com.tzzh;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
public class ServerThread implements Runnable{
Socket socket = null;//和本線程相關的Socket
public ServerThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
InputStream is = null;
InputStreamReader isr = null;
BufferedReader br = null;
OutputStream os = null;
PrintWriter pw = null;
try {
//與客戶端建立通信，獲取輸入流，讀取取客戶端提供的信息
is = socket.getInputStream();
isr = new InputStreamReader(is,"GBK");
br = new BufferedReader(isr);
String data = null;
while((data=br.readLine()) != null){//循環讀取客戶端的信息
System.out.println("我是服務器，客戶端提交信息為："+data);
}
socket.shutdownInput();//關閉輸入流
//獲取輸出流，響應客戶端的請求
os = socket.getOutputStream();
pw = new PrintWriter(os);
pw.write("服務器端響應成功！");
pw.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
//關閉資源即相關socket
try {
if(pw!=null)
pw.close();
if(os!=null)
os.close();
if(br!=null)
br.close();
if(isr!=null)
isr.close();
if(is!=null)
is.close();
if(socket!=null)
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
1.6 創建服務器端類
使用while以達到可以循環偵聽不同客戶端的連接請求。因為這是一個死循環，所以不用關閉也沒有機會去關閉serverSocket。設置count值，用於記錄服務器端被連接過的次數並顯示客戶端所在ip值。如果線程處理類是繼承Thread類，那麼創建新線程代碼可以改為ServerThread serverThread = new ServerThread(socket);serverThread.start();
package com.tzzh;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) {
try {
//創建一個服務器端的Socket，即ServerSocket,綁定需要監聽的端口
ServerSocket serverSocket = new ServerSocket(8888);
Socket socket = null;
//記錄連接過服務器的客戶端數量
int count = 0;
System.out.println("***服務器即將啟動，等待客戶端的連接***");
while(true){//循環偵聽新的客戶端的連接
//調用accept（）方法偵聽，等待客戶端的連接以獲取Socket實例
socket = serverSocket.accept();
//創建新線程
Thread thread = new Thread(new ServerThread(socket));
thread.start();
count++;
System.out.println("服務器端被連接過的次數："+count);
InetAddress address = socket.getInetAddress();
System.out.println("當前客戶端的IP為："+address.getHostAddress());
}
//serverSocket.close();一直循環監聽，不用關閉連接
} catch (IOException e) {
e.printStackTrace();
}
}
}
1.7 創建客戶端類
在後面的關閉資源中，我把輸入輸出相關的流關閉注釋了，是因為對於同一個Socket，關閉socket的時候也會把輸入輸出流關閉，直接關閉socket就行，當然保留也是可以的。
package com.tzzh;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
public static void main(String[] args) {
try {
//創建客戶端Socket，指定服務器地址和端口
Socket socket = new Socket("localhost", 8888);
//建立連接後，獲取輸出流，向服務器端發送信息
OutputStream os = socket.getOutputStream();
//輸出流包裝為打印流
PrintWriter pw = new PrintWriter(os);
//向服務器端發送信息
pw.write("用戶名：zzh;密碼：123");//寫入內存緩沖區
pw.flush();//刷新緩存，向服務器端輸出信息
socket.shutdownOutput();//關閉輸出流
//獲取輸入流，接收服務器端響應信息
InputStream is = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is, "GBK"));
String data = null;
while((data=br.readLine())!= null){
System.out.println("我是客戶端，服務器端提交信息為："+data);
}
//關閉其他資源
// br.close();
// is.close();
// pw.close();
// os.close();
socket.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
1.8 先運行服務器端，在運行客戶端
此時在看服務器控制台：服務器端一直在循環偵聽客戶端的連接
1.9 進行第二個客戶端的連接
修改相應信息將用戶名zzh改為admin。運行客戶端，打開服務端控制台
輸出客戶端的ip都為127.0.0.1，是因為服務器和客戶端都是本機，在真實的環境中會顯示客戶端的ip地址信息。
二. 通過Socket實現UDP編程
2.1 UDP編程
UDP協議又叫用戶數據報協議，是無連接，不可靠的，無序的。特點是傳輸速度相對要快，UDP協議以數據報作為數據傳輸的載體。當進行數據傳輸時，首先需要將要傳輸的數據定義成數據報（Datagram），在數據報中指明數據所要達到的Socket（主機地址和端口號），然後再將數據報發送出去。相關操作類有：DatagramPacket數據報包，DatagramSocket進行端到端通信的類。
2.2 服務器端實現套路
1.創建DatagramSocket，指定端口號。2.創建DatagramPacket。3.接收客戶端發送的數據信息。4.讀取數據。
2.3 客戶端實現套路
1.定義發送信息，比如發送地址，端口號和內容。2. 創建DatagramPacket，包含將要發送的信息。3.創建DatagramSocket。4.發送數據。
2.4 多線程實現服務器與多客戶端之間通信步驟
1.服務器端創建DatagramSocket的實例socket，循環調用receive（）方法，此方法在接收到數據報之前會一直阻塞。
2.客戶端創建DatagramSocket，將含有地址，端口號和內容的數據報包發送出去。
3. 服務器端收到數據報包packet，通過DatagramSocket和packet與客戶端建立一個線程
4. 服務器端繼續等待新的數據報包。
5. 發送方的DatagramPacket構造方法傳遞四個參數包含數據內容，數據大小，地址和端口號。接收方的DatagramPacket構造方法有兩個參數接收數據和數據大小。
2.5 創建服務器線程處理類UDPThread
注意，DatagramSocket的實例socket不能關閉，會出現SocketException。讀取數據用到的new String(packet.getData(), 0, packet.getLength())，參數表示數據報中的字節數組，位置和長度。
package com.uzzh;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPThread implements Runnable{
DatagramSocket socket = null;
DatagramPacket packet = null;
public UDPThread(DatagramSocket socket,DatagramPacket packet) {
this.socket = socket;
this.packet = packet;
}
@Override
public void run() {
String info = null;
InetAddress address = null;
int port = 8800;
byte[] data2 = null;
DatagramPacket packet2 = null;
try {
info = new String(packet.getData(), 0, packet.getLength());
System.out.println("我是服務器，客戶端說："+info);
address = packet.getAddress();
port = packet.getPort();
data2 = "我在響應你！".getBytes();
packet2 = new DatagramPacket(data2, data2.length, address, port);
socket.send(packet2);
} catch (IOException e) {
e.printStackTrace();
}
//socket.close();不能關閉
}
}
2.6 創建服務器端類
package com.uzzh;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPServer {
public static void main(String[] args) throws IOException {
DatagramSocket socket = new DatagramSocket(8800);
DatagramPacket packet = null;
byte[] data = null;
int count = 0;
System.out.println("***服務器端啟動，等待發送數據***");
while(true){
data = new byte[1024];//創建字節數組，指定接收的數據包的大小
packet = new DatagramPacket(data, data.length);
socket.receive(packet);//此方法在接收到數據報之前會一直阻塞
Thread thread = new Thread(new UDPThread(socket, packet));
thread.start();
count++;
System.out.println("服務器端被連接過的次數："+count);
InetAddress address = packet.getAddress();
System.out.println("當前客戶端的IP為："+address.getHostAddress());
}
}
}
之前我將new DatagramSocket放入了while循環中，報了java.net.BindException: Address already in use: Cannot bind，才知道不能在while中連續創建新的DatagramSocket對象。
2.7 創建客戶端類
package com.uzzh;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPClient {
public static void main(String[] args) throws IOException {
//定義服務器的地址，端口號，數據
InetAddress address = InetAddress.getByName("localhost");
int port = 8800;
byte[] data = "用戶名：admin;密碼：123".getBytes();//將字符串轉換為字節數組
//創建數據報
DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
//創建DatagramSocket，實現數據發送和接收
DatagramSocket socket = new DatagramSocket();
//向服務器端發送數據報
socket.send(packet);
//接收服務器響應數據
byte[] data2 = new byte[1024];
DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
socket.receive(packet2);
String info = new String(data2, 0, packet2.getLength());
System.out.println("我是客戶端，服務器說："+info);
socket.close();
}
}
2.8 先運行服務器端，在運行客戶端
2.9 修改客戶端信息，再次運行客戶端
服務器控制台：服務器端一直在循環等待接收客戶端的數據。
三. 總結
這兩個例子只是簡單的實現了基於TCP和UDP的socket編程，其中像多線程的優先級等都暫且沒做考慮，不過依然要強調一下，服務器與多個客戶端進行通信，因為是死循環，不設置多線程優先級，可能會導致運行時速度非常慢，優先級的范圍1-10，默認為5，我們可以適當降低線程的優先級，比如thread.setPriority(4);
對於同一個socket，如果關閉了輸出流比如（pw.close()），則與該輸出流關聯的socket也會關閉，所以一般不需要關閉輸出流，當關閉socket的時候，輸出流也會關閉，直接關閉socket就行。
在使用TCP通信傳輸信息時，更多是使用對象的形式來傳輸，可以使用ObjectOutputStream對象序列化流來傳遞對象，比如ObjectOutputStream os = new ObjectOutputStream（socket.getOutputStream()）;User user = new User("admin","123"); os.writeObject(user);
希望這篇文章能讓你有所獲，麻煩點贊或關注我，謝謝觀看！
