Java基础复习——网络编程

网络编程

网络通信

1. 概念：两台设备之间通过网络实现数据传输

2. 网络通信：将数据通过网络从一台设备传输到另一台设备

3. java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信

网络

1. 概念：两台或多台设备通过一定物理设备连接起来构成了网络

2. 根据网络的覆盖范围不同，对网络进行分类：

   • 局域网：覆盖范围最小，仅仅覆盖一个教室或一个机房
   • 城域网：覆盖范围较大，可以覆盖一个城市
   • 广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

IP地址

1. 概念：IP地址（Internet Protocol Address），指互联网协议地址，用于唯一标识网络中的每台计算机/生机

2. 查看ip地址：ipconfig

3. ip地址的表示形式：点分十进制 XX.XX.XX.XX

4. 每一个十进制数的范围：0 ~ 255

5. ip地址的组成 = 网络地址 + 主机地址，比如：192.168.16.69

6. iPv6 是互联网工程任务组设计的用于替代 IPv4 的下一代 IP 协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址。

7. 由于 IPV4 最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPV6 的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍

IPV4 地址分类

类型	范围
A	0.0.0.0 到 127.255.255.255
B	128.0.0.0 到 191.255.255.255
C	192.0.0.0 到 223.255.255.255
D	224.0.0.0 到 239.255.255.255
E	240.0.0.0 到 247.255.255.255

特殊的，127.0.0.1 表示本机地址

域名

1. 例如：www.baidu.com

2. 好处：为了方便记忆，解决记ip的困难

3. 概念：将ip地址映射成域名，这里怎么映射上，HTTP协议

端口号

1. 概念：用于标识计算机上某个特定的网络程序

2. 表示形式：以整数形式，端口范围0~65535【2个字节表示端口】

3. 0~1024 已经被占用，比如ssh 22，ftp 21，smtp 25 http 80

4. 常见的网络程序端口号：

   • tomcat:8080
   • mysql:3306
   • oracle:1521
   • sglserver:1433

网络通信协议

协议（tcp/ip）

TCP/IP （Transmission Control Protocol / Internet Protocol）的简写，中文译名为传输控制协议 / 因特网互联协议，又叫网络通讯协议，这个协议是Interneti最基本的协i议、Internet国际互联网络的基础，简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。【示意图】

TCP 和 UDP

TCP协议：传输控制协议

1. 使用TCP协议前，须先建立TCP连接，形成传输数据通道

2. 传输前，采用“三次握手“方式，是可靠的

3. TCP协议进行通信的两个应用进程：客户端、服务端

4. 在连接中可进行大数据量的传输

5. 传输完毕，需释放已建立的连接，效率低

UDP协议：用户数据协议

1. 将数据、源、目的封装成数据包，不需要建立连接

2. 每个数据报的大小限制在64K内，不适合传输大量数据

3. 因无需连接，故是不可靠的

4. 发送数据结束时无需释放资源（因为不是面向连接的），速度快

5. 举例 通知：发短信

InetAddress 类

1. 获取本机 InetAddress 对象 getLocalHost

2. 根据指定主机名/域名获取 ip 地址对象 getByName

3. 获取 InetAddress 对象的主机名 getHostName

4. 获取 InetAddress 对象的地址 getHostAddress

// 1.获取本机的InetAddress对象
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost);

// 2.指定主机名，返回InetAddress对象
InetAddress host1 = InetAddress.getByName("LAPTOP-3EG0TKV67");
System.out.println("host1=" + host1);

// 3.根据域名返回InetAddress对象
InetAddress bDHost = InetAddress.getByName("www.baidu.com");
System.out.println("Baidu host=" + bDHost);

// 4.通过InetAddress对象，获取对应的地址
String hostAddress = bDHost.getHostAddress();
System.out.println("bDHost对应的ip:" + hostAddress);

// 5.通过 InetAddress 对象，获取对应的主机名/域名
String hostName = bDHost.getHostName();
System.out.println("bDHost对应的主机名/域名:" + hostName);

输出结果：
LAPTOP-3EG0TKV5/192.168.11.1
host1=LAPTOP-3EG0TKV5/192.168.11.1
Baidu host=www.baidu.com/182.61.200.7
bDHost对应的ip:182.61.200.7
bDHost对应的主机名/域名:www.baidu.com

Socket

1. 套接字（Socket）开发网络应用程序被广泛采用，以至于成为事实上的标准。

2. 通信的两端都要有Socket，是两台机器间通信的端点

3. 网络通信其实就是Socket间的通信

4. Socket:允许程序把网络连接当成一个流，数据在两个Socketl间通过IO传输。

5. 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

TCP 网络通信编程

1. 基于客户端 一 服务端的网络通信

2. 底层使用的是TCP/IP协议

3. 应用场景举例：客户端发送数据，服务端接受并显示控制台

4. 基于Socket的TCP编程

public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连接服务端 (ip , 端口）
        //解读: 连接本机的 9999 端口, 如果连接成功， 返回 Socket 对象

        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回=" + socket.getClass());
        //2.连接上后，生成Socket, 通过socket.getOutputStream()
        // 得到 和 socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.//3. 通过输出流， 写入数据到 数据通道
        outputStream.write("hello, server".getBytes());
        //4. 关闭流对象和 socket, 必须关闭
        outputStream.close();
        socket.close();

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


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();

    }
}

public class ClientTCP02 {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        System.out.println("socket=" + socket.getClass());


        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("F:\\VSCode\\JAVA\\file\\test\\ai.jpg"));

        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        byte[] bytes = StreamUtils.streamToByteArray(bis);
        bos.write(bytes);
        bos.flush();
        socket.shutdownOutput();
        bis.close();
        System.out.println("客户端已发送图片");

        InputStream inputStream = socket.getInputStream();

        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);


        bos.close();
        socket.close();
        System.out.println("客户端退出");

    }
}


public class ServerTCP02 {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端， 在 8888 端口监听， 等待连接..");
        Socket socket = serverSocket.accept();

        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = streamToByteArray(bis);


        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("src/com/learning/javase/API/fileUpload02/pic1.jpg"));

        bos.write(bytes);
        bos.flush();

        System.out.println("图片接收完成");

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("服务端 收到图片");
        bw.flush();
        socket.shutdownOutput();

        bw.close();
        bos.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}

1. 当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP来分配的，是不确定的，是随机的.
2. 可以通过 netstat 来验证

netstat 指令

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

2. netstat -an more可以分页显示

3. 要求在dos控制台下执行win+r

说明：

• Listening表示某个端口在监听

• 如果有一个外部程序（客户端）连接到该端口，就会显示一条连接信息

• 可以输入ctrl+c退出指令

UDP 网络通信编程

基本介绍

1. 类 DatagramSocket 和 DatagramPacket【数据包/数据报】实现了基于UDP协议网络程序。

2. UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。

3. DatagramPacket对象封装了UDP 数据报，在数据报中包含了发送端的lP地址和端口号以及接收端的IP地址和端口号。

4. UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

基本流程

1. 核心的两个类/对象DatagramSocket 与DatagramPacket

2. 建立发送端，接收端（没有服务端和客户端概念）

3. 发送数据前，建立数据包/报 DatagramPacket 对象

4. 调用DatagramSocket的发送、接收方法

5. 关闭 DatagramSocket

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

        // 1.创建一个 DatagramSocket 对象，准备在9999接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        // 2.创建一个 DatagramPacket 对象，准备接收数据
        // UDP协议，一个数据包最大是64KB
        byte[] bytes = new byte[1024];
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
        // 3. 调用，接收方法，将通过网络传输的 DatagramPacket 对象
        // 填充到 packet 对象
        // 当有数据发送到 本机的9999端口时，就会接收数据
        // 没有数据包发送到本机的9999端口时，就会阻塞等待
        System.out.println("接收端A，等待接收数据。。");
        socket.receive(packet);

        // 4. 对 packet 拆包，取出数据，并显示
        int length = packet.getLength(); // 实际接收到的数据字节长度
        byte[] data = packet.getData();

        String s = new String(data, 0, length);
        System.out.println(s);

        //===回复信息给 B 端
        //将需要发送的数据， 封装到 DatagramPacket 对象
        byte[] bytes1 = "好的，明天见".getBytes();
        DatagramPacket packet1 =
                new DatagramPacket(bytes1, bytes1.length, InetAddress.getByName("172.17.107.81"), 9998);
//        new DatagramPacket(bytes1, bytes1.length, InetAddress.getByName("172.16.156.90"), 9998);

        socket.send(packet1);
        // 5. 关闭资源
        socket.close();

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


public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        // 1.创建 DatagramSocket 对象，准备接收和发送数据
        DatagramSocket socket = new DatagramSocket(9998); // 指定在9998端口接收数据

        // 2.将发送的数据，封装到 DatagramPacket 对象中
        byte[] data = "hello, 今天很高兴".getBytes();

        // 说明：封装的 DatagramPacket 对象 data 内容字节数组，data.length, 主机IP，端口
        DatagramPacket packet =
                new DatagramPacket(data, data.length, InetAddress.getByName("172.16.156.90"), 9999);
//        new DatagramPacket(data, data.length, InetAddress.getByName("172.17.107.81"), 9999);

        socket.send(packet);

        // === 接收从 A 端回复的信息
        byte[] bytes = new byte[1024];
        DatagramPacket packet1 = new DatagramPacket(bytes, bytes.length);
        socket.receive(packet1);
        int length = packet1.getLength();
        byte[] data1 = packet1.getData();
        String s = new String(data1, 0, length);
        System.out.println(s);
        
        socket.close();
        System.out.println("B端退出");
    }
}