Java網路編程02

4.TCP網路通信編程

基本介紹
1. 基于客戶端--服務端的網路通信
2. 底層使用的是TCP/IP協議
3. 應用場景舉例：客戶端發送資料，服務端接收并顯示控制臺
4. 基于Scoket的TCP編程

4.1應用案例1:(使用位元組流)

撰寫一個服務器端，和一個客戶端
服務器端在9999埠監聽
客戶端連接到服務器端，發送“hello，server”，然后退出
服務器端接收到客戶端發送的資訊，輸出，并結束

客戶端思路：

1.連接服務端（ip，埠）

2.連接上后，生成socket，通過socket.getOutputStream()

3.通過輸出流，寫入資料到資料通道

package li.network.socket;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

//發送"hello,server"給服務端
public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //1.連接服務端（ip，埠）
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);//連接服務端的主機的埠，在這里是本機
        System.out.println("客戶端 socket回傳=" + socket.getClass());

        //2.連接上后，生成socket，通過socket.getOutputStream()
        //  得到和 socket 物件關聯的輸出流物件
        OutputStream outputStream = socket.getOutputStream();

        //3.通過輸出流，寫入資料到資料通道
        outputStream.write("hello,server".getBytes());

        //4. 關閉流物件和socket（必須關閉）
        outputStream.close();
        socket.close();

        System.out.println("客戶端退出");
    }
}

服務器端思路：

1.在本機的9999埠監聽，等待連接

2.當沒有客戶端連接9999埠時，程式將會阻塞，等待連接

3.通過socket.getInputStream()讀取客戶端寫入到資料通道的資料，顯示

package li.network.socket;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        // 1.在本機的9999埠監聽，等待連接
        // 要求在本機沒有其他服務在監聽9999
        // ServerSocket 可以通過 accept() 方法回傳多個 Socket[多個客戶端連接服務器的并發]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服務端在9999埠監聽，等待連接...");

        // 2.當沒有客戶端連接9999埠時，程式會阻塞，等待連接
        // 如果有客戶端連接則會回傳一個socket物件，程式繼續

        Socket socket = serverSocket.accept();

        System.out.println("服務器端 socket=" + socket.getClass());

        // 3.通過socket.getInputStream()讀取客戶端寫入到資料通道的資料，顯示
        InputStream inputStream = socket.getInputStream();

        // 4.IO讀取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));//根據實際讀取到的長度顯示內容
        }

        // 5. 關閉流物件和socket（必須關閉）
        inputStream.close();
        socket.close();
        serverSocket.close();//關閉serverSocket
    }
}

要先運行服務端，這里顯示正在等待連接客戶端：

再運行客戶端程式，得到一個socket，通過輸出流將資料寫入到數通道里面，然后退出：

服務器端會通過輸入流不停地讀取，把資料輸出到控制臺上，然后關閉退出：

4.2應用案例2:(使用位元組流)

撰寫一個服務器端，和一個客戶端
服務器端在9999埠監聽
客戶端連接到服務器端，發送“hello，server”，并接收服務器端回發的“hello，client”，再退出
服務器端接收到客戶端發送的資訊然后輸出，并發送“hello，client”，再退出

注意設定寫入結束標記socket.shutdownOutput(); 否則程式會認為還在寫入資料，

服務端Server：

package li.network.socket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

@SuppressWarnings("all")
public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        // 1.在本機的9999埠監聽，等待連接
        // 要求在本機沒有其他服務在監聽9999
        // ServerSocket 可以通過 accept() 方法回傳多個 Socket[多個客戶端連接服務器的并發]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服務端在9999埠監聽，等待連接...");

        // 2.當沒有客戶端連接9999埠時，程式會阻塞，等待連接
        // 如果有客戶端連接則會回傳一個socket物件，程式繼續

        Socket socket = serverSocket.accept();

        System.out.println("服務器端 socket=" + socket.getClass());

        // 3.獲取資料，通過socket.getInputStream()讀取客戶端寫入資料通道的資料，并顯示
        InputStream inputStream = socket.getInputStream();
        //IO讀取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));//根據實際讀取到的字串長度顯示內容
        }

        // 4. 回話，寫入資料
        // 獲取socket相關的輸出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,client".getBytes());
        //設定寫入結束標記
        socket.shutdownOutput();


        // 5. 關閉流物件和socket（必須關閉）
        inputStream.close();
        outputStream.close();
        socket.close();
        serverSocket.close();//關閉serverSocket
    }
}

客戶端Client：

package li.network.socket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

@SuppressWarnings("all")
//發送"hello,server"給服務端
public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        //1.連接服務端（ip，埠）
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);//連接服務端的主機的埠，在這里是本機
        System.out.println("客戶端 socket回傳=" + socket.getClass());

        //2.連接上后，生成socket，通過socket.getOutputStream()
        //  得到和 socket 物件關聯的輸出流物件
        OutputStream outputStream = socket.getOutputStream();

        //3.通過輸出流，寫入資料到資料通道
        outputStream.write("hello,server".getBytes());
        //設定寫入結束標記
        socket.shutdownOutput();

        //4. 獲取資料
        // 獲取和socket相關聯的輸入流，并顯示
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));
        }

        //5. 關閉流物件和socket（必須關閉）
        outputStream.close();
        inputStream.close();
        socket.close();

        System.out.println("客戶端退出");
    }
}

服務端等待客戶端連接：

客戶端往資料通道寫入資料“hello，server，并接受到服務端發送的資料“hello，client”

服務端接收到資料：

4.3應用案例3:(使用字符流)

撰寫一個服務端，一個客戶端
服務端在9999埠監聽
客戶端連接到服務端，發送“hello，server”，并接收到服務端會發的“hello，client”，然后退出
服務端接收到客戶端發送的資訊，輸出，并發送“hello，client”，再退出

思路答題與應用案例2一致，這里要求使用字符流，那么在拿到輸入/輸出字符流之后，使用轉換流，將其轉換為字符流即可，

PS：設定寫入結束標記：除了使用socket.shutdownOutput(); 還可以使用writer.newLine()，如果使用這種結束標志的話，需要使用readLine()的方式讀取

注意點：如果使用的是字符流，需要我們手動重繪xx.flush();，否則資料不會寫入資料通道

服務端Server：

package li.network.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

//使用字符流
@SuppressWarnings("all")
public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        // 1.在本機的9999埠監聽，等待連接
        // 要求在本機沒有其他服務在監聽9999
        // ServerSocket 可以通過 accept() 方法回傳多個 Socket[多個客戶端連接服務器的并發]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服務端在9999埠監聽，等待連接...");

        // 2.當沒有客戶端連接9999埠時，程式會阻塞，等待連接
        // 如果有客戶端連接則會回傳一個socket物件，程式繼續

        Socket socket = serverSocket.accept();

        System.out.println("服務器端 socket=" + socket.getClass());

        // 3.獲取資料，通過socket.getInputStream()讀取客戶端寫入資料通道的資料，并顯示
        InputStream inputStream = socket.getInputStream();
        //IO讀取---使用字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);//輸出

        // 4. 回話，寫入資料
        // 獲取socket相關的輸出流
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,client 字符流");
        bufferedWriter.newLine();//插入一個換行符，表示回復內容的結束
        bufferedWriter.flush();//手動重繪


        // 5. 關閉流物件和socket（必須關閉）
        bufferedWriter.close();//關閉外層流
        bufferedReader.close();
        socket.close();
        serverSocket.close();//關閉serverSocket
    }
}

客戶端Client：

package li.network.socket;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

@SuppressWarnings("all")
//發送"hello,server"給服務端,使用字符流
public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        //1.連接服務端（ip，埠）
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);//連接服務端的主機的埠，在這里是本機
        System.out.println("客戶端 socket回傳=" + socket.getClass());

        //2.連接上后，生成socket，通過socket.getOutputStream()
        //  得到和 socket 物件關聯的輸出流物件
        OutputStream outputStream = socket.getOutputStream();

        //3.通過輸出流，寫入資料到資料通道----使用字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,server 字符流");
        bufferedWriter.newLine();//插入一個換行符，表示寫入的內容結束，注意：要求對方使用readLine()!!!!
        //如果使用的是字符流，需要我們手動重繪，否則資料不會寫入資料通道
        bufferedWriter.flush();


        //4. 獲取資料
        // 獲取和socket相關聯的輸入流，并顯示
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);

        //5. 關閉流物件和socket（必須關閉）
        bufferedReader.close();//關閉外層流
        bufferedWriter.close();
        socket.close();

        System.out.println("客戶端退出");
    }
}

4.4應用案例4：

撰寫一個服務端和一個客戶端
服務器端在埠8888監聽
客戶端連接到服務端，并發送一張圖片
服務器端接收到客戶端發送的圖片，保存到src目錄下，然后發送“收到圖片”，再退出
客戶端接收到服務端的回話：“收到圖片“ 之后，再退出
該程式要求使用StreamUtils.java

說明：使用BufferedInputStreasm和BufferedOutputStream位元組流

思路如下：

客戶端這邊先將資料傳輸到客戶端程式中，然后通過socket獲取資料通道，將檔案資料發送給服務端；
服務端這邊，先是得到資料通道上的資料（傳輸到服務端程式中），然后使用將程式中的檔案資料輸出到某個目錄下，之后在將“收到圖片”的訊息輸出到資料通道上
客戶端通過socket，從資料通道上獲取回復訊息，并列印在控制臺上

工具類StreamUtils：

package li.network.upload;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 此類用于演示關于流的讀寫方法
 *
 */
public class StreamUtils {
   /**
    * 功能：將輸入流轉換成byte[],即可以把檔案的內容寫入到byte[]
    * @param is
    * @return
    * @throws Exception
    */
   public static byte[] streamToByteArray(InputStream is) throws Exception{
      ByteArrayOutputStream bos = new ByteArrayOutputStream();//創建輸出流物件
      byte[] b = new byte[1024];//位元組陣列
      int len;
      while((len=is.read(b))!=-1){//回圈讀取
         bos.write(b, 0, len);//把讀取到的資料寫入到 bos流中
      }
      byte[] array = bos.toByteArray();//然后將bos 轉成為一個位元組陣列
      bos.close();
      return array;
   }

   /**
    * 功能：將InputStream轉換成String
    * @param is
    * @return
    * @throws Exception
    */
   
   public static String streamToString(InputStream is) throws Exception{
      BufferedReader reader = new BufferedReader(new InputStreamReader(is));
      StringBuilder builder= new StringBuilder();
      String line;
      while((line=reader.readLine())!=null){ //當讀取到 null時，就表示結束
         builder.append(line+"\r\n");
      }
      return builder.toString();
      
   }

}

服務端Server：

package li.network.upload;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

//檔案上傳的服務端
public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {

        // 1.服務端在監聽8888埠(這里是在本機進行)
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服務端在8888埠監聽...");
        // 2.等待連接
        Socket socket = serverSocket.accept();

        //3.讀取資料通道的資料
        //通過socket獲得輸入流
        //創建物件
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //寫入到程式中
        byte[] bytes = StreamUtils.streamToByteArray(bis);//streamToByteArray方法：將輸入流轉換成byte[]

        //4.將得到的bytes陣列（檔案資料）寫入到指定的路徑，就得到一個檔案
        String destFilePath = "src\\copy.png";
        //創建物件
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        //寫入資料到目錄中
        bos.write(bytes);
        bos.close();

        //5.收到圖片后，向客戶端回復“收到圖片”
        //通過socket獲得輸出流
        //創建物件
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("收到圖片");
        bw.flush();//把內容重繪到資料通道
        socket.shutdownOutput();//設定寫入結束標記

        //6.關閉其他資源
        bw.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}

客戶端Client：

package li.network.upload;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;

//檔案上傳的客戶端
public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {
        //1.客戶端連接服務端，得到一個socket物件
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);

        //2.創建讀取磁盤檔案的輸入流
        String filePath = "d:\\ggmm.jpg";
        //創建物件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        //這里的 bytes 就是 檔案filePath 對應的位元組陣列
        //讀取資料到程式中
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //3.通過socket獲取輸出流，將bytes資料發送到服務端
        //創建物件
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        //寫入資料通道
        bos.write(bytes);//將檔案對應的位元組陣列寫入到資料通道
        bis.close();
        socket.shutdownOutput();//設定寫入資料的結束標志

        //4.獲取服務端回復的訊息
        InputStream inputStream = socket.getInputStream();
        String s = StreamUtils.streamToString(inputStream);//streamToString方法：把一個輸入流的資料直接轉成字串
        System.out.println(s);

        //關閉相關的流
        inputStream.close();
        bos.close();
        socket.close();
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/508985.html

標籤：Java

上一篇：從華為離職了

下一篇：批量轉換檔案字符集

day40-網路編程02

Java網路編程02

4.TCP網路通信編程

4.1應用案例1:(使用位元組流)

4.2應用案例2:(使用位元組流)

4.3應用案例3:(使用字符流)

4.4應用案例4：