java实现套接字网络编程_Java网络编程（一）Socket套接字
一、基礎知識
1.TCP：傳輸控制協議。
2.UDP：用戶數據報協議。
二、IP地址封裝
1.InetAddress類的常用方法
getLocalHost() 返回本地主機的InetAddress對象 InetAddress類型
getByName(String host) 獲取指定主機名稱的IP地址 InetAddress類型
getHostName() 獲取此主機名 String
getHostAddress() 獲取主機IP地址 String
isReachable(int timeout) 在timeout指定的毫秒時間內，測試IP地址是否可達 Boolean
2.示例1：測試IP地址從“192.168.131.1”到“192.168.131.150”范圍內所有可以訪問的主機的名稱，如果對方沒有安裝防火墻，并且網絡連接正常的話，都可以訪問的。從輸出可以看出，192.168.131.1是本地主機的IP，其他地址都不能聯通，可能是因為1000毫秒太短或者對方主機裝有防火墻的原因。
packagebigjunoba.bjtu.iptoname;importjava.io.IOException;importjava.net.InetAddress;importjava.net.UnknownHostException;public classIPToName {public static voidmain(String[] args) {
String IP= null;for (int i = 1; i <= 150; i++) {
IP= "192.168.131." + i; //生成IP字符串
try{
InetAddress host;
host= InetAddress.getByName(IP); //獲取IP封裝對象
if (host.isReachable(1000)) { //用1秒的時間測試IP地址是否可達
String hostName =host.getHostName();
System.out.println("IP地址" + IP + "的主機名稱是：" +hostName);
}
}catch (UnknownHostException e) { //捕獲未知主機異常
e.printStackTrace();
}catch (IOException e) { //捕獲輸入輸出異常
e.printStackTrace();
}
}
System.out.println("搜索完畢！");
}
}
IP地址192.168.131.1的主機名稱是：BigjunOba
搜索完畢！
三、套接字
套接字(Socket)是代表計算機之間網絡連接的對象，用于建立計算機之間的TCP連接，使計算機之間可以建立連接并實現網絡通信。
1.服務器端套接字
服務器端套接字是SercerSocket類的實例對象，用于實現服務器緩存。ServerSocket類將監視指定的端口，并建立客戶端到服務器端套接字的連接，也就是客戶負責呼叫任務。
(1)創建服務器端套接字
創建服務器端套接字可以使用4種構造方法。
①ServerScoket()
默認構造方法，可以創建未綁定端口號的服務器套接字。服務器套接字的所有構造方法都需要處理IOException異常。
一般格式為：
try{
ServerSocket server= newServerSocket();
}catch(IOException e) {
e.printStackTrace();
}
②ServerScoket(int port)
該構造方法將創建綁定到port參數指定端口的服務器套接字對象，默認的最大連接隊列長度為50，也就是說哦如果連接數量超過50個，將不會再接收新的連接請求。
一般格式為：
try{
ServerSocket server= new ServerSocket(9527);
}catch(IOException e) {
e.printStackTrace();
}
}
③ServerScoket(int port， int backlog)
使用port參數指定的端口號和backlog參數指定的最大連接長度創建服務器端套接字對象，這個構造方法可以指定超出50的連接數量，如300。
一般格式為：
try{
ServerSocket server= new ServerSocket(9527, 300);
}catch(IOException e) {
e.printStackTrace();
}
}
④public ServerSocket(int port, int backlog, InerAddress bindAddr)
使用port參數指定的端口號和backlog參數指定的最大連接隊列長度創建服務器端套接字對象。如果服務器有多個IP地址，可以使用bindAddr參數指定創建服務器套接字的地址；如果服務器只有一個IP地址，那么沒有必要使用該構造方法。
try{
InetAddress address = InetAddress.getByName("192.168.1.128");
ServerSocket server= new ServerSocket(9527, 300, address);
}catch(IOException e) {
e.printStackTrace();
}
}
(2)接收客戶端套接字連接
當服務器建立ServerSocket套接字對象以后，就可以使用該對象的accept()方法接收客戶端請求的套接字連接。
語法格式為：
serverSocket.accept();
該方法被調用之后，將等待客戶端的連接請求，在接收客戶端的套接字連接請求以后，該方法將返回Socket對象，這個Socket對象是已經和客戶端建立好連接的套接字，通過這個Socket對象獲取客戶端的輸入輸出流來實現數據發送與接收。
該方法可能會產生IOException異常，所以在調用accept()方法時必須捕獲并處理該異常。
一般形式為：
try{
server,accept();
}catch(IOException e) {
e.printStackTrace();
}
}
accept()方法將阻塞當前線程，直到接收到客戶端的連接請求為止，該方法之后的任何語句都不會執行，必須有客戶端發送連接請求；accpet()方法返回Socket套接字以后，當前線程才會繼續運行，accpet()方法之后的代碼才會被執行。
示例1：System.out.println("已經建立連接！");在server對象接收到客戶端的連接請求之前永遠都不會執行，這樣會導致程序的main主線程阻塞。
packagebigjunoba.bjtu.serverSocketTest;importjava.io.IOException;importjava.net.ServerSocket;public classServerSocketTest {public static voidmain(String[] args) {try{
ServerSocket serverSocket= new ServerSocket(9527);
serverSocket.accept();
System.out.println("已經建立連接！");
}catch(IOException e) {
e.printStackTrace();
}
}
}
示例2：將上述語句放在一個新的線程中，作為main主線程的子線程，在新的線程中完成等待客戶端連接請求并獲取客戶端Socket對象的任務，這樣就不會阻塞main主線程。
packagebigjunoba.bjtu.serverSocketTest;importjava.io.IOException;importjava.net.ServerSocket;public classServerSocketTest {public static voidmain(String[] args) {
Runnable runnable= newRunnable() {
@Overridepublic voidrun() {try{
ServerSocket serverSocket= new ServerSocket(9527);
serverSocket.accept();
System.out.println("已經建立連接！");
}catch(IOException e) {
e.printStackTrace();
}
}
};
Thread thread= newThread(runnable);
thread.start();
}
}
2.客戶端套接字
Socket類是實現客戶端套接字的基礎。它采用TCP建立計算機之間的連接，并包含了Java語言所有對TCP有關的操作方法，如建立連接、傳輸數據、斷開連接等。
(1)創建客戶端套接字
Socket類定義了多個構造方法，它們可以根據InetAddress對象或者字符串指定的IP地址和端口號創建示例。
①Socket(InetAddress address, int port);
使用address參數傳遞的IP封裝對象和port參數指定的端口號創建套接字實例對象。Socket類的構造方法可能會產生UnknownHostException和IOException異常，在使用該構造方法創建Socket對象時必須捕獲和處理這兩個異常。
一般形式為：
try{
InetAddress address= InetAddress.getByName("BigjunOba");int port = 33;
Socket socket= newSocket(address, port);
}catch(UnknownHostException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
②Socket(String host, int port);
使用host參數指定的IP地址字符串和port參數指定的整數類型端口號創建套接字實例對象。
一般形式為：
try{int port = 33;
Socket socket= new Socket("192.168.131.1", port);
}catch(UnknownHostException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
③Socket(InetAddress address, int port, InetAddress localAddr, int localPort)
創建一個套接字并將其連接到指定遠程地址上的指定遠程端口。
一般格式為：
try{
InetAddress localHost=InetAddress.getLocalHost();
InetAddress address= InetAddress.getByName("192.168.131.1");int port1 = 33;int port2 = 44;
Socket socket= newSocket(address, port1, localHost, port2) ;
}catch(UnknownHostException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
④Socket(String host, int port, InetAddress localAddr, int localPort)
創建一個套接字并將其連接到指定遠程主機上的指定端口。
一般形式為：
try{
InetAddress localHost=InetAddress.getLocalHost();int port1 = 33;int port2 = 44;
Socket socket= new Socket("192.168.131.1", port1, localHost, port2) ;
}catch(UnknownHostException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
示例1：檢測本地計算機中被使用的端口，端口的檢測范圍是1~256
packagebigjunoba.bjtu.clientSocketTest;importjava.io.IOException;importjava.net.InetAddress;importjava.net.Socket;importjava.net.UnknownHostException;public classCheckPort {public static voidmain(String[] args) {for (int i = 1; i <= 256; i++) {try{
InetAddress localHost=InetAddress.getLocalHost();
Socket socket= newSocket(localHost, i);//如果不產生異常，輸出該端口被使用
System.out.println("本機已經使用了端口：" +i);
}catch(UnknownHostException e) {
e.printStackTrace();
}catch(IOException e) {//e.printStackTrace();
}
}
System.out.println("執行完畢！");
}
本機已經使用了端口：135執行完畢！
(2)發送和接收數據
Socket對象創建成功以后，代表和對方的主機已經建立了連接，可以接受與發送數據了。Socket提供了兩個方法分別獲取套接字的輸入流和輸出流，可以將要發送的數據寫入輸出流，實現發送功能，或者從輸入流讀取對方發送的數據，實現接受功能。
①接受數據
Socket對象從數據輸入流中獲取數據，該輸入流包含對方發送的數據，這些數據可能是文件、圖片、音頻或視頻。所以，在實現接受數據之前，必須使用getInputStream()方法獲取輸入流。
語法格式為：
socket.getInputStream()
②發送數據
Socket對象使用輸出流，向對方發送數據，所以，在實現數據發送以前，必須使用getOutputStream()方法獲取套接字的輸出流。
語法格式為：
socket.getOutputStream()
3.創建一些Socket套接字小程序。
示例1：創建服務器Server程序和客戶端Client程序，并實現簡單的Socket通信程序。
創建Server服務器類：
packagebigjunoba.bjtu.CSTest;importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStream;importjava.io.InputStreamReader;importjava.net.ServerSocket;importjava.net.Socket;public classServer {public static voidmain(String[] args) {try{//創建服務器套接字
ServerSocket server = new ServerSocket(9527);
System.out.println("服務器啟動完畢！");//等待客戶端連接，返回的是已經連接到服務器的客戶端socket對象
Socket socket =server.accept();
System.out.println("客戶端已經連接上服務器啦！");//獲取客戶端socket對象的輸入流
InputStream inputStream =socket.getInputStream();
InputStreamReader reader= newInputStreamReader(inputStream);
BufferedReader bufferedReader= newBufferedReader(reader);while (true) {
String string=bufferedReader.readLine();//如果接收到exit就退出服務器
if (string.equals("exit")) {break;
}//如果接收到的不是exit，就輸出接收到的內容
System.out.println("接受內容為：" +string);
}
System.out.println("連接斷開！");
bufferedReader.close();
reader.close();
inputStream.close();
socket.close();
server.close();
}catch(IOException e) {
e.printStackTrace();
}
}
}
創建client客戶端類：
packagebigjunoba.bjtu.CSTest;importjava.io.IOException;importjava.io.OutputStream;importjava.net.Socket;importjava.net.UnknownHostException;public classClient {public static voidmain(String[] args) {try{//創建連接服務器的Socket
Socket socket = new Socket("localhost", 9527);//獲取Socket輸出
OutputStream outputStream =socket.getOutputStream();//向服務器發送數據(將字符串轉化成字節數組)
outputStream.write("這是客戶端發送給服務器的文字\n".getBytes());//發送退出信息
outputStream.write("exit\n".getBytes());
}catch(UnknownHostException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
}
}
先啟動服務器：
服務器啟動完畢！
再啟動客戶端：
服務器啟動完畢！
客戶端已經連接上服務器啦！
接受內容為：這是客戶端發送給服務器的文字
連接斷開！
示例2：示例1中的程序在運行完一次后，程序就會自動結束，因為Socket socket = server.accept();會阻塞當前的main線程，而且客戶端連接一次后，程序執行完之后就直接退出了，這樣的效果很不好。為了實現客戶端能夠實時多次發送數據的功能，考慮將Socket socket = server.accept();這行代碼更換到一個更適當的位置，并考慮使用多線程技術來實現多次發送的功能，使得程序更加完善。
(1)首先需要解釋一下DataInputStream與InputStream的區別：
DataInputStream類繼承了InputStream類，比普通的InputStream多了一些方法，DataInputStream、DataOutputStream并沒有改變InputStream或OutputStream的行為，讀入或寫出時的動作還是InputStream、OutputStream負責。DataInputStream、DataOutputStream只是在實現對應的方法時，動態地為它們加上類型判斷功能。readUTF()的作用，是從輸入流中讀取UTF-8編碼的數據，并以String字符串的形式返回。writeUTF(value:String)的作用是 ：將String字符串轉換成UTF-8編碼的字節流并寫入輸出流。
(2)內部類：如果內部類和main方法在同一個類中，那么因為靜態方法不能調用動態方法，所以可以將內部類定義成靜態static，然后在創建類時就已經new出了實例，因此不需要new語句，調用的時候直接調用即可。
(3)明確服務器端和客戶端的發送和接收
客戶端：從輸入流中接收數據，使用輸出流發送數據。即dataOutputStream.writeUTF(line);是客戶端發送給服務器的數據，dataInputStream.readUTF()是客戶端接收服務器發來的數據。
服務器端：從輸入流中接收數據，使用輸出流發送數據。即dataOutputStream.writeUTF(replyMessage);是服務器發送給客戶端的數據，dataInputStream.readUTF()服務器接收客戶端發來的數據。
(3)server服務器端程序修改為：
packagebigjunoba.bjtu.CSTest2;importjava.io.DataInputStream;importjava.io.DataOutputStream;importjava.io.IOException;importjava.net.ServerSocket;importjava.net.Socket;public classServer {public static voidmain(String[] args) {try{//創建服務器套接字
@SuppressWarnings("resource")
ServerSocket server= new ServerSocket(8023);
System.out.println("服務器啟動完畢！");while (true) {//等待客戶端連接，只有當一個客戶端連接上才會返回已經連接到服務器的客戶端socket對象
Socket socket =server.accept();
System.out.println("客戶端已經連接上服務器啦！");//客戶端連接上服務器后，就開啟通信線程
newCommunicationThread(socket).start();
}
}catch(IOException e) {
e.printStackTrace();
}
}public static class CommunicationThread extendsThread{
Socket socket;
DataInputStream dataInputStream;
DataOutputStream dataOutputStream;publicCommunicationThread(Socket socket) {this.socket =socket;try{
dataInputStream= newDataInputStream(socket.getInputStream());
dataOutputStream= newDataOutputStream(socket.getOutputStream());
}catch(IOException e) {
e.printStackTrace();
}
}public voidrun() {super.run();
String message= null;try{//接收從客戶端發來的數據
while ((message = dataInputStream.readUTF()) != null) {
System.out.println("客戶端發來的信息是：" +message);
String replyMessage= "OK！我已經收到了：" +message;//發送回應數據給客戶端
dataOutputStream.writeUTF(replyMessage);
System.out.println("服務器發送給客戶端的回應：" +replyMessage);
}
}catch(IOException e) {
e.printStackTrace();
}
}
}
}
(4)client客戶端程序修改為：
packagebigjunoba.bjtu.CSTest2;importjava.io.DataInputStream;importjava.io.DataOutputStream;importjava.io.IOException;importjava.net.Socket;importjava.util.Scanner;public classClient {public static voidmain(String[] args) {try{
@SuppressWarnings("resource")//連接到服務器
Socket socket = new Socket("localhost", 8023);
System.out.println("客戶端啟動完畢！");
DataInputStream dataInputStream= newDataInputStream(socket.getInputStream());
DataOutputStream dataOutputStream= newDataOutputStream(socket.getOutputStream());
@SuppressWarnings("resource")
Scanner scanner= newScanner(System.in);
String line= null;
listenServerReply(dataInputStream);//讀取從鍵盤輸入的第一行
while ((line = scanner.nextLine()) != null) {//發送數據給服務器端
dataOutputStream.writeUTF(line);
System.out.println("客戶端發送給服務器的信息是：" +line);
}
}catch(Exception e) {
e.printStackTrace();
}
}//監聽服務器端發送回來的信息
public static void listenServerReply(finalDataInputStream dataInputStream) {newThread() {public voidrun() {super.run();
String line= null;try{//接收從服務器端發送回來的回應信息
while ((line = dataInputStream.readUTF()) != null) {
System.out.println("客戶端從服務器接收到的回應是：" +line);
}
}catch(IOException e) {
e.printStackTrace();
}
}
}.start();
}
}
(5)首先啟動服務器端，服務器端打印程序為：
服務器啟動完畢！
(6)然后啟動客戶端，
客戶端輸出為：
客戶端啟動完畢！
服務器端輸出為：
服務器啟動完畢！
客戶端已經連接上服務器啦！
(7)在客戶端控制臺出打印一些信息
客戶端輸出為：
客戶端啟動完畢！
Hello，你好啊！
客戶端發送給服務器的信息是：Hello，你好啊！
客戶端從服務器接收到的回應是：OK！我已經收到了：Hello，你好啊！
服務器端輸出為：
服務器啟動完畢！
客戶端已經連接上服務器啦！
客戶端發來的信息是：Hello，你好啊！
服務器發送給客戶端的回應：OK！我已經收到了：Hello，你好啊！
四、數據報
Java語言可以使用TCP和UDP兩種通信協議實現網絡通信，其中TCP通信由Socket套接字實現，而UDP通信需要使用DatagramSocket類實現。
和TCP通信不同，UDP傳遞信息的速度更快，但是沒有TCP的高可靠性，當用戶通過UDP發送信息之后，無法確定能否正確地傳送到目的地。雖然UDP是一種不可靠的通信協議，但是大多數場合并不需要嚴格的、高可靠性的通信，它們需要的是快速的信息發送，并能容忍一些小的錯誤，那么使用UDP通信來實現會更合適一些。
UDP將數據打包，也就是通信中所傳遞的數據包，然后將數據包發送到指定目的地，對方會接收數據包，然后查看數據包中的數據。
1.DatagramPacket
該類是UDP鎖傳遞的數據包，即打包后的數據。數據包用來實現無連接包投遞的服務，每個數據包僅根據包中包含的信息從一臺計算機傳送到另一臺計算機，傳送的多個包可以選擇不同的路由，也可能按不同的順序到達。
(1)DatagramPacket(byte[] buf, int length)
該構造方法用來創建數據包實例，這個數據包實例將接收長度為length的數據包。
語法格式為：
DatagramPacket(byte[] buf, int length)
(2)DatagramPacket(byte[] buf, int length, InetAddress address, int port)
創建數據包實例，用來將長度為length的數據包發送到address參數指定地址和port參數指定端口號的主機。length參數必須小于等于buf數組的長度。
語法格式為：
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
2.DatagramSocket
該類是用于發送和接收數據的數據包套接字。數據包套接字是數據包傳送服務的發送或接收點。要實現UDP通信的數據就必須創建數據包套接字。
常用的構造方法有3個：
(1)DatagramSocket()
默認的構造方法，該構造方法將使用本機任何可用的端口創建數據包套接字實例。在創建DatagramSocket類的實例時，有可能會產生SocketException異常，所以，在創建數據包套接字時，應該捕獲并處理該異常。
一般格式為：
try{
DatagramSocket datagramSocket= newDatagramSocket();
}catch(SocketException e) {
e.printStackTrace();
}
(2)DatagramSocket(int port)
創建數據包套接字并將其綁定到port參數指定的本機端口，端口號取值必須在0~65535.
一般格式為：
try{
DatagramSocket datagramSocket= new DatagramSocket(8023);
}catch(SocketException e) {
e.printStackTrace();
}
(3)DatagramSocket(int port， InetAddress Iaddr)
綁定數據包套接字，將其綁定到Iaddr參數指定的本機地址和port參數指定的本機端口號。本機端口號取值必須在0~65535之間。
一般格式為：
try{
InetAddress localHost=InetAddress.getLocalHost();
DatagramSocket datagramSocket= new DatagramSocket(8023, localHost);
}catch(SocketException e) {
e.printStackTrace();
}catch(UnknownHostException e) {
e.printStackTrace();
}
3.數據報通信程序
示例：使用兩個雷實現UDP通信程序設計。
創建服務器端程序：
packagebigjunoba.bjtu.UDPTest;importjava.io.IOException;importjava.net.DatagramPacket;importjava.net.DatagramSocket;importjava.net.SocketException;public classServer {public static voidmain(String[] args) {byte[] buf = new byte[1024];
DatagramPacket datagramPacket= newDatagramPacket(buf, buf.length);try{
@SuppressWarnings("resource")
DatagramSocket datagramSocket= new DatagramSocket(8023);
System.out.println("服務器啟動完畢！");
datagramSocket.receive(datagramPacket);int length =datagramPacket.getLength();
String message= new String(datagramPacket.getData(), 0, length);
String ip=datagramPacket.getAddress().getHostAddress();
System.out.println("從" + ip + "發送來了信息：" +message);
}catch(SocketException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
}
}
創建客戶端程序：
packagebigjunoba.bjtu.UDPTest;importjava.io.IOException;importjava.net.DatagramPacket;importjava.net.DatagramSocket;importjava.net.InetAddress;importjava.net.UnknownHostException;public classClient {public static voidmain(String[] args) {try{
InetAddress address= InetAddress.getByName("127.0.0.1");
@SuppressWarnings("resource")
DatagramSocket datagramSocket= newDatagramSocket();
System.out.println("客戶端啟動完畢！");byte[] data = "hello,我是客戶端，我來訪問服務器了！".getBytes();
DatagramPacket datagramPacket= new DatagramPacket(data, data.length, address, 8023);
datagramSocket.send(datagramPacket);
}catch(UnknownHostException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
}
}
先啟動服務器程序，然后再啟動客戶端程序，服務器控制臺的輸出為：
服務器啟動完畢！
從127.0.0.1發送來了信息：hello,我是客戶端，我來訪問服務器了！
五、網絡聊天程序開發
使用Swing設置程序UI界面，并結合Java語言多線程技術使網絡聊天程序更加符合實際需求，即可以不間斷地收發多條信息。
(1)創建ClientFrame類，該類包含多個成員變量。
總結
以上是生活随笔為你收集整理的java实现套接字网络编程_Java网络编程（一）Socket套接字的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java系统的标准输出对象_到了宋代，虽
- 下一篇： java synchronized关键字