[Java] 网络编程学习笔记

网络编程

学习视频

【零基础 快速学Java】韩顺平 零基础30天学会Java

1. InetAddress 类

常用方法:

import java.net.InetAddress;
import java.net.UnknownHostException;

public class API_ {

    public static void main(String[] args) throws UnknownHostException {
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);

        //通过主机名获取地址
        InetAddress byName = InetAddress.getByName("LAPTOP-7UI8DLHU");
        System.out.println(byName);

        //获取百度地址
        System.out.println(InetAddress.getByName("www.baidu.com"));

        //通过InetAddress对象获取对应的地址
        String hostAddress = localHost.getHostAddress();
        System.out.println(hostAddress);

        //通过InetAddress对象获取对应的主机名或者域名
        String hostName = localHost.getHostName();
        System.out.println(hostName);
    }
}

2. TCP

基本流程(通俗)：
通过两端的Socket对象建立起来通道, 然后创建输出流或者输入流进行数据传输，一次完整的传输结束后关闭流。

2.1 Socket 类

图解

1.案例：(字节读写)

客户端

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

public class Client1 {
    public static void main(String[] args) {
        
        try {
            //连接主机，参数: 主机地址(这里是本机), 端口号
            //Socket socket = new Socket("169.254.42.101", 9999);
            Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
            //如果连接成功，返回Socket对象
            System.out.println("客户端 socket= " + socket.getClass());

            //给服务端发消息
            //1. 获得输出流
            OutputStream outputStream = socket.getOutputStream();
            //2. 通过输出流写数据
            outputStream.write("hello, server".getBytes());
			//3. 以表闭嘴
			socket.shutdownOutput();
			//二、
			//接收服务端返回来的消息
            InputStream inputStream = null;
            if((inputStream = socket.getInputStream()) != null) {
                byte[] buf = new byte[1024];
                int readLen = 0;
                System.out.println("收到服务器端消息: ");
                while ((readLen = inputStream.read(buf)) != -1) {
                    System.out.println(new String(buf, 0, readLen));
                }
                inputStream.close();
            }

            outputStream.close();
            socket.close();
            System.out.println("客户端退出");
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

服务端

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

public class Server1 {
    public static void main(String[] args) {
        ServerSocket serverSocket;
        int port = 9999;

        try {
            //监听本机9999端口
            serverSocket = new ServerSocket(port);
            System.out.println("服务端,在端口"+ port +"监听，等待连接...");
            //如果有客户端连接会返回Socket对象
            Socket socket = serverSocket.accept();
            System.out.println("服务端 socket = " + socket.getClass());
            //通过输入流获取消息
            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));
            }

            //给客户端返回消息
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("服务器端已接收".getBytes());
            socket.shutdownOutput();

            outputStream.close();
            inputStream.close();
            socket.close();
            serverSocket.close();
        } catch (IOException e) {
            System.out.println("端口绑定失败: "+port+"被占用");
        }
    }
}

2.字符读写

客户端

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class Client2 {
    public static void main(String[] args) throws IOException {

        Socket socket = new Socket(InetAddress.getLocalHost(), 9998);
        //socket.getOutputStream()
        System.out.println("客户端 socket= " + socket.getClass());

        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8));
        bufferedWriter.write("hello, server");
        //socket.shutdownOutput();
        bufferedWriter.close();
        socket.close();
    }
}

服务端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class Server2 {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9998);
        System.out.println("服务器等待连接");
        Socket accept = serverSocket.accept();
        System.out.println("客户端连接");
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(accept.getInputStream(), StandardCharsets.UTF_8));
        String clientLine = "";
        while ((clientLine = bufferedReader.readLine()) != null){
            System.out.println(clientLine);
        }
        bufferedReader.close();
        accept.close();
        serverSocket.close();
    }
}

2.网络上传

3. netstat 指令

netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况

4. UDP

1. UDP没有明确的服务端和客户端，应该是发送端和接收端
2. 接收数据和发送数据是通过DatagramSocket 对象完成
3. 将数据封装到DatagramPacket 对象，拆包后取出数据
4. DatagramSocket 可以指定在那个端口接收数据

示意图：

4.1 基本流程

DatagramSocket 对象其实像 Socket 对象那样运筹帷幄，它不关心从哪个地址来，发往哪个地址去，它只关心端口。
而发送时 DatagramPacket 要把数据，接收端的端口号和地址一并包装进去, 由 DatagramSocket 对象发送出去。

因为UDP的方式不像TCP那样建立起稳定通道，通过流来传输数据, TCP是一个持续的过程。 而UDP呢不管这些，只要 DatagramPacket 对象把地址端口等包装好后一整个被发送出去了，剩下的事情就不关注了, 至于送没送到，地址对不对全都不关心了。所以这就是为什么前者是可靠的后者不可靠。

案例

A端接收B端发来的消息，然后给B端返回消息

ReceiveA.java

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class ReceiveA {
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象, 准备在9999端口接收
        DatagramSocket datagramSocket = new DatagramSocket(9999);
		
        //一:
        //构建DatagramPacket对象接收数据
        byte[] buf = new byte[1024]; //UDP的数据包最大限制在64KB内
        //byte[] buf = new byte[1024];仅用于初始化没有使用意义吗？receive(datagramPacket)会改变atagramPacket对象的buf内容,有意义，这里我们限制了一次接收的最大容量
        DatagramPacket datagramPacket = new DatagramPacket(buf, buf.length);

        //调用接受方法，将通过网络传输的 datagramSocket 填装到 datagramPacket 对象
        datagramSocket.receive(datagramPacket);  //如果一直没有数据报发过来，程序就会阻塞在这里一直等待

        //对datagramPacket拆包，取出数据
        int length = datagramPacket.getLength(); 
        //实际接收到的数据的字节长度,这个长度和data[]的长度不一样，经过实践data[]的长度是1024,即初始化对象时的长度
        byte[] data = datagramPacket.getData();
        String s = new String(data, 0, length);
        System.out.println("接收到数据: " + s);
		
        //二:
        //返回信息
        byte[] data1 = "ok, 我已收到".getBytes();
        DatagramPacket datagramPacket1 = new DatagramPacket(data1, data1.length, InetAddress.getLocalHost(), 9998);
        datagramSocket.send(datagramPacket1);
        datagramSocket.close();
    }
}

SendB.java

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class SendB {
    public static void main(String[] args) throws IOException {
        
        // 创建 DatagramSocket 对象，准备发送数据
        DatagramSocket datagramSocket = new DatagramSocket(9998);
		//一:
        //将发送到数据装入 DatagramPacket 对象
        byte[] buf = "hello, you".getBytes();
        DatagramPacket packet = new DatagramPacket(buf, buf.length, InetAddress.getByName("192.168.1.30"), 9999); 		 // 169.254.42.101

        //把packet发出去
        datagramSocket.send(packet);
	    
        //二:
        //接收A端送来的数据
        byte[] data = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(data, data.length);
        datagramSocket.receive(datagramPacket);
        
        //拆包
        byte[] data1 = datagramPacket.getData();
        System.out.println(new String(data1, 0, datagramPacket.getLength()));
        datagramSocket.close();
    }
}

---

二〇二四年八月十五日
王负剑 < dj.gooding@foxmail.com >