JavaSE-網路程式設計

InetAddress

java.net.InetAddress 代表ip的類

這個類沒有構造方法，所以不能new ，可以通過其方法返回一個ip的物件

static InetAddress getByName(String host), 在給定主機名的情況下確定主機的 IP 地址,返回一個InetAddress類的物件

String getHostAddress() 返回 IP 地址字串（以文字表現形式）

String getHostName()返回此IP地址的主機名

URL

類 URL 代表一個統一資源定位符，它是指向網際網路“資源”的指標。資源可以是簡單的檔案或目錄，也可以是對更為複雜的物件的引用，例如對資料庫或搜尋引擎的查詢。

URI 類在某些特定情況下對其組成欄位執行轉義。建議使用 URI管理 URL 的編碼和解碼，並使用 toURI() 和 URI.toURL() 實現這兩個類之間的轉換。

方法

public class  URLDown {
    public static void main(String[] args) throws Exception{

        URL url = new URL("https://pic.cnblogs.com/avatar/1835657/20210311181843.png");
				//建立與此url物件的http連線
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
				//獲取該連線中的輸入流
        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("/Users/bjdzbjba0152/Desktop/java2.png");
				//讀取輸入流並寫入檔案
        byte[] bytes = new byte[1024];
        int len;
        while ((len = inputStream.read(bytes)) != -1){
            fos.write(bytes, 0, len);
        }
				//關閉資源
        fos.close();
        inputStream.close();
      	//關閉http連線
        urlConnection.disconnect();
    }
}
 

TCP

Socket此類實現客戶端套接字（也可以就叫“套接字”）。套接字是兩臺機器間通訊的端點。

Socket

構造方法

Socket(InetAddress address, int port)

建立一個流套接字並將其連線到指定 IP 地址的指定埠號。

Socket(InetAddress address, int port, InetAddress localAddr, int localPort)

建立一個套接字並將其連線到指定遠端地址上的指定遠端埠。

Socket(Proxy proxy)

建立一個未連線的套接字並指定代理型別（如果有），該代理不管其他設定如何都應被使用。

Socket(String host, int port)
建立一個流套接字並將其連線到指定主機上的指定埠號。

Socket(String host, int port, InetAddress localAddr, int localPort)
建立一個套接字並將其連線到指定遠端主機上的指定遠端埠。

其他方法

ServerSocket

此類實現伺服器套接字。伺服器套接字等待請求通過網路傳入。

構造方法

ServerSocket(int port) 建立繫結到特定埠的伺服器套接字。

ServerSocket(int port, int backlog) 利用指定的 backlog 建立伺服器套接字並將其繫結到指定的本地埠號。

ServerSocket(int port, int backlog, InetAddress bindAddr)使用指定的埠、偵聽 backlog 和要繫結到的本地 IP 地址建立伺服器。

其他方法

TCP收發訊息

TCPClient

1. 建立socket連線.Socket(inetAddress, port) ，連線server socket ip(InetAddress.getByName("ip")), port
2. 傳送訊息，socket.getOutputStream , 利用該方法返回的OutputStream物件.write(message)
3. 釋放資源，先開後關

public class TcpClientDemo01 {
    public static void main(String[] args) {

        Socket socket = null;
        OutputStream os =null;
        //連線socket server
        try {
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");

            int port = 9999;

            //建立socket連線
            socket = new Socket(inetAddress, 9999);

            //傳送訊息
            os = socket.getOutputStream();
            os.write("Hello i am ClientSocket!".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

TCPServer

1. 生成一個server socket ,new ServerScoket(port)
2. 阻塞socket，等待client端的socket連線，Socket.accept()
3. 準備讀取訊息，獲取accept.getInputStream()物件,這裡的accept物件就是client端的socket物件
4. 使用管道流new ByteArrayOutputStream()讀取位元組序列
5. 釋放資源，先開後關

public class TcpServerDemo01 {
    public static void main(String[] args) {
        //提升作用域
        ServerSocket serverSocket = null;
        Socket accept = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            //生成一個servser socket
            serverSocket = new ServerSocket(9999);

            //等待客戶端連線,這裡的accept即為Client端的socket物件
            accept = serverSocket.accept();

            //讀取客戶端訊息
            is = accept.getInputStream();

            //管道流
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1){
                baos.write(buffer, 0, len);
            }

            System.out.println(baos.toString());

        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            //管道流 先開後關
            if (baos != null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (accept != null){
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

TCP檔案上傳

TCPClient

1. 建立一個socket，new Scoket(InetAddress.getByName("ip"), port)
2. 建立一個輸出流socket.getOutputStream
3. 讀取要傳輸的本地檔案new FileInputStream(new File("file path"))
4. 輸出檔案byte[] buffer,int len,while,此時檔案被寫入流裡
5. 告知server socket已經傳輸完成,socket.shutdownOutput
6. 接受server socket通知socket.getInputStream(), new ByteArrayOutputStream()
7. 關閉資源，先開後關

public static void main(String[] args) throws Exception{
        //建立一個Socket連線
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);

        //建立一個輸出流
        OutputStream os = socket.getOutputStream();

        //讀取檔案
        FileInputStream fis = new FileInputStream(new File("/Users/b/Desktop/java2.txt"));

        //輸出檔案
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1){
            os.write(buffer,0,len);
        }

        //告知server socket已經傳輸完檔案
        socket.shutdownOutput();

        //接受server端的通知
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        int len2;
        byte[] buffer2 = new byte[1024];
        while ((len2 = inputStream.read(buffer2)) != -1){
            baos.write(buffer2, 0, len2);
        }
        System.out.println(baos.toString());

        //關閉資源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();

    }
}

TCPServer

1. 建立server socket new ServerSocket(int port)
2. 阻塞socket，等待client端連線serverScoket.accept()
3. 獲取輸入流accept.getInputStream
4. 輸出檔案到指定位置new FileOutputStream(new File(String filepath))
5. 通知client已經接受完畢，accept.getOutputstream , .write("msg".getBytes())
6. 關閉資源，先開後關

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception{

        //建立服務server sockett
        ServerSocket serverSocket = new ServerSocket(9999);

        //監聽連線 accept
        Socket accept = serverSocket.accept();

        //獲取輸入流
        InputStream is = accept.getInputStream();

        //檔案輸出
        FileOutputStream fos = new FileOutputStream(new File("/Users/b/Desktop/java3.txt"));
        int len;
        byte[] buffer = new byte[1024];
        while ((len = is.read(buffer)) != -1){
            fos.write(buffer, 0, len);
        }

        //通知client端已經接受完了
        OutputStream os = accept.getOutputStream();
        os.write("我已經接受完了，可以關閉socket".getBytes());

        //關閉資源
        fos.close();
        is.close();
        accept.close();
        serverSocket.close();
    }
}

UDP

DatagramPacket

此類表示資料報包。

資料報包用來實現無連線包投遞服務。每條報文僅根據該包中包含的資訊從一臺機器路由到另一臺機器。從一臺機器傳送到另一臺機器的多個包可能選擇不同的路由，也可能按不同的順序到達。不對包投遞做出保證。

構造方法

DatagramPacket(byte[] buf, int length) 構造 DatagramPacket，用來接收長度為 length 的資料包。

DatagramPacket(byte[] buf, int length, InetAddress address, int port) 構造資料報包，用來將長度為 length 的包傳送到指定主機上的指定埠號。

DatagramPacket(byte[] buf, int offset, int length) 構造 DatagramPacket，用來接收長度為 length 的包，在緩衝區中指定了偏移量。

DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port) 構造資料報包，用來將長度為 length 偏移量為 offset 的包傳送到指定主機上的指定埠號。

DatagramPacket(byte[] buf, int offset, int length, SocketAddress address) 構造資料報包，用來將長度為 length 偏移量為 offset 的包傳送到指定主機上的指定埠號。

DatagramPacket(byte[] buf, int length, SocketAddress address) 構造資料報包，用來將長度為 length 的包傳送到指定主機上的指定埠號。

其他方法

DatagramSocket

此類表示用來傳送和接收資料報包的套接字。

資料報套接字是包投遞服務的傳送或接收點。每個在資料報套接字上傳送或接收的包都是單獨編址和路由的。從一臺機器傳送到另一臺機器的多個包可能選擇不同的路由，也可能按不同的順序到達。

構造方法

DatagramSocket() 構造資料報套接字並將其繫結到本地主機上任何可用的埠。

DatagramSocket(int port) 建立資料報套接字並將其繫結到本地主機上的指定埠。

DatagramSocket(int port, InetAddress laddr) 建立資料報套接字，將其繫結到指定的本地地址。

DatagramSocket(SocketAddress bindaddr) 建立資料報套接字，將其繫結到指定的本地套接字地址。

其他方法

UDP收發訊息

UDPClient

1. 建立DtagramSocket,new DatagramSocket
2. 建立UDP資料包,String msg, InetAddress.getByName("ip"),int port ,new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, InetAddress.getByName("ip"), port)
3. 傳送資料包datagramSocket.send(datagramPacket)
4. 釋放資源datagramSocket.close()

public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception{

        //建立一個datagramsocket
        DatagramSocket datagramSocket = new DatagramSocket();

        //建立資料包
        String msg = "Hello UDPServer";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9999;

        DatagramPacket datagramPacket = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //傳送資料包
        datagramSocket.send(datagramPacket);

        //釋放資源
        datagramSocket.close();


    }
}

UDPServer

1. 建立DatagramSocket,new DatagramSocket(port)
2. 接受資料包（阻塞接受）new byte[1024],new DatagramPacket(buffer, 0, buffer.length) datagramSocket.recive(packet)
3. 輸出資訊packet.getxxx()
4. 釋放資源datagramSocket.close()

public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception{

        //建立datagramSocket
        DatagramSocket datagramSocket = new DatagramSocket(9999);

        //接受資料包
        byte[] buffer = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(buffer,0,buffer.length);
        datagramSocket.receive(datagramPacket); //阻塞接受

        //輸出
        System.out.println("getAddress().getHostAddress(): " + datagramPacket.getAddress().getHostAddress());
        System.out.println("getData(): "+ datagramPacket.getData());
        System.out.println("new String(packet.getData()): " + new String(datagramPacket.getData()));
        System.out.println("getLength(): " + datagramPacket.getLength());
        System.out.println("getSocketAddress(): " + datagramPacket.getSocketAddress());
        System.out.println("getPort(): " + datagramPacket.getPort());
        System.out.println("getOffset: " + datagramPacket.getOffset());

        //釋放資源
        datagramSocket.close();

    }
}