Java学习笔记 - 网络编程简单理解

ASL-杰

已于 2022-10-03 11:34:51 修改

阅读量138

点赞数 3

分类专栏： Java学习笔记文章标签： java

于 2022-04-29 15:54:49 首次发布

本文链接：https://blog.csdn.net/qq_59059495/article/details/124360525

版权

Java学习笔记专栏收录该内容

15 篇文章 1 订阅

订阅专栏

网络相关概念

网络通信

网络通信，就是指多台设备之间通过网络实现数据的相互传输
Java编程中，java.net包下提供了一系列相关的类和接口，方便在进行网络编程时使用

网络

多台设备通过某种通信介质连接起来就形成了网络
根据网络的覆盖范围不同，网络可以分为：

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

IP地址

IP地址：用于唯一标识网络中的每一台计算机设备
IP地址 = 网络地址 + 主机地址
IP地址有 IPv4 和 IPv6 两种
IPv4 用4个字节（32位）表示，形式为：xxx.xxx.xxx.xxx
一个“xxx”代表一个字节，用十进制表示，范围：0~255
IPv6 用16个字节（128位）表示，形式为：xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx
一个“xxxx”代表两个字节，用十六进制表示，范围：0~65535

IPv4分为五类：

A类: 0.0.0.0 - 127.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 - 255.255.255.255
特殊：127.0.0.1表示本机地址

域名

域名：将IP地址根据HTTP协议映射成为域名
如：www.baidu.com，为了方便记忆，解决记IP的困难

端口号

端口号：用于标识计算机上的某个指定的网络程序
表现形式：0~65535（2个字节）的十进制整数表示
0 ~ 1024已经被占用，比如：ssh 22，ftp 21，smtp 25，http 80 等
常见的网络程序端口号：
tomcat：8080
mysql：3306
oracle：1521
sqlsever：1433

网络通信协议

协议（TCP/IP）

TCP/IP（Transmission Control Protocol / Internet Protocol）的简写，意思是传输控制协议/因特网互联协议，又叫网络通讯协议
主要由网络层的IP协议和传输层的TCP协议组成。
IP 或 ICMP、TCP 或 UDP、TELNET 或 FTP、以及 HTTP 等都属于 TCP/IP 协议，他们与 TCP 或 IP 的关系紧密。所以， TCP/IP 也称为网际协议群。

TCP和UDP

TCP协议：传输控制协议

使用TCP协议前，需要建立TCP连接，形成传输数据通道
传输前，采用“三次握手”的方式，是可靠的
TCP协议进行通信的两个应用进程：客户端、服务端
在连接中可进行大量的数据传输
传输完毕后，需要释放已建成的连接，效率低

UDP协议：用户数据协议

将数据、源、目的封装成为数据包，不需要建立连接
每个数据包的大小限制在64K内，不适合传输大量数据
因为没有建立连接，所以是不可靠的
发送数据包结束时无需释放资源（因为没有建立连接），速度快

InetAddress类

getLocalHost()
获取本机的 InetAddress 对象
getByName()
根据指定域名或主机名获取 InetAddress 对象
getHostAddress()
通过 InetAddress 对象，获取对应的地址
getHostName()
通过 InetAddress 对象，获取对应的域名或主机名

import java.net.InetAddress;

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

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

        //2. 根据指定 域名或主机名 获取 InetAddress 对象
        String name = "www.baidu.com";
        InetAddress host = InetAddress.getByName(name);
        System.out.println("域名或主机名为 " + name + " 的InetAddress：" + host);

        //3. 通过 InetAddress 对象，获取对应的地址
        String name1 = host.getHostAddress();
        System.out.println("host对象 对应的ip为：" + name1);

        //4. 通过 InetAddress 对象，获取对应的域名或主机名
        String name2 = host.getHostName();
        System.out.println("host对象 对应的域名或主机名为：" + name2);

    }
}

Socket（套接字）

套接字（Socket）或叫插口：

TCP协议用主机的IP地址 + 主机上的端口号作为TCP协议连接的端点，叫做Socket
表示为： IP地址 : 端口号

网络通信的两端都需要有Socket，它是两台机器之间的连接点
一般称发起通信的应用程序为客户端，等待通信请求的为服务端
网络通信实质上就是Socket之间的通信
Socket允许程序把网络连接当作一个流，数据在两个Socket之间通过IO流传输

区分不同应用程序进程间的网络通信和连接,主要有3个参数：

通信的目的IP地址
使用的传输层协议(TCP或UDP)
使用的端口号

TCP网络编程案例

编写一个服务器端和一个客户端
服务器端在9999端口监听
客户端连接到服务器端,发送"hello, server"，然后退出
服务器端接收到并输出客户端发送的信息，最后退出


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

/**
 * 服务端, 使用字符流、字节流方式读写 客户端信息
 */
public class SocketTCPServer {
    public static void main(String[] args) throws IOException {

        //1. 在本机 的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();
//方式一：字符流输入
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);

方式二：字节流输入
//        byte[] buf = new byte[1024];
//        int readLen = 0;
//        while ((readLen = inputStream.read(buf)) != -1) {
//            System.out.println(new String(buf, 0, readLen));//根据读取到的实际长度，显示内容.
//        }

        //4. 通过socket.getOutputStream() 向客户端发送数据
        OutputStream outputStream = socket.getOutputStream();
//方式一：字符流输出
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("服务端发来字符流 hello client");
        bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束, 注意，要求对方使用readLine()
        bufferedWriter.flush();// 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道

方式二：字节流输出
//        outputStream.write("服务端发来字符流 hello client".getBytes());
//        socket.shutdownOutput();

        //5.关闭流和socket
//关闭字符流
        bufferedWriter.close();
        bufferedReader.close();
关闭字节流
//        inputStream.close();
//        outputStream.close();

        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}


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

/**
 * 客户端， 使用字符流、字节流方式读写 服务端信息
 */
public class SocketTCPClient {
    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.getOutputStream() 向服务端发送数据
        OutputStream outputStream = socket.getOutputStream();
//方式一：字符流输出
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("客户端发来字符流 hello, server");
        bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束, 注意，要求对方使用readLine()
        bufferedWriter.flush();// 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道

方式二：字节流输出
//        outputStream.write("客户端发来字符流 hello, server".getBytes());
//        socket.shutdownOutput();

        //3.通过socket.getInputStream() 读取服务端回复的数据
        InputStream inputStream = socket.getInputStream();
//方式一：字符流输入
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);

方式二：字节流输入
//        byte[] buf = new byte[1024];
//        int readLen = 0;
//        while ((readLen = inputStream.read(buf)) != -1) {
//            System.out.println(new String(buf, 0, readLen));
//        }

        //4. 必须关闭流和socket
//关闭字符流
        bufferedReader.close();
        bufferedWriter.close();
关闭字节流
//        outputStream.close();
//        inputStream.close();

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

UDP网络编程案例

基本介绍

类 DatagramSocket 和 DatagramPacket实现了基于UDP协议网络程序
UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证UDP 数据报一定能够安全送到目的地，也不能确定什么时候可以抵达
DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

基本流程

核心的两个类/对象 DatagramSocket与DatagramPacket·
建立发送端，接收端
建立数据包
调用DatagramSocket的发送、接收方法
关闭DatagramSocket

示例：

编写一个接收端A 和一个发送端B
接收端A 在9999端口等待接收(receive)数据
发送端B 向接收端A 发送数据"hello，明天吃火锅~"
接收端A 接收到发送端B 发送的数据，回复"好的,明天见",再退出
发送端B 接收到接收端A 回复的数据,再退出

注意：一定得先有接收端，如果发送端先发送再创建接收端，则收不到数据


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

/**
 * UDP 接收端A
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {

        //1. 创建一个 DatagramSocket(9999) 对象，即 接收端A
        DatagramSocket socket = new DatagramSocket(9999);

        //2. 接收
        //(1)构建一个 DatagramPacket 对象，准备接收数据包，一个数据包最大 64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //(2)调用 接收方法, 把 packet 放进去
        //当有数据包发送到 本机的9999端口时，就会接收到数据，否则就会阻塞等待.
        System.out.println("接收端A 等待接收数据..");
        socket.receive(packet);
        System.out.print("接收端A收到 —— ");
        //(3)把收到的 packet 进行拆包，取出数据并显示.
        byte[] data = packet.getData();//接收到的数据
        int length = packet.getLength();//实际接收到的数据字节长度
        String s = new String(data, 0, length);
        System.out.println(s);//显示

        //3. 发送
        //将需要发送的数据，封装到 DatagramPacket 对象，在9998端口发送给 B端
        data = "好的, 明天见".getBytes();
        //说明: 封装的 DatagramPacket对象为 （data 字节数组内容 , data.length , 主机(IP) , 端口）
        packet = new DatagramPacket(data, data.length, InetAddress.getLocalHost(), 9998);
        socket.send(packet);
        System.out.println("接收端A回复完毕");

        //4.关闭资源
        socket.close();
        System.out.println("A端退出");
    }
}


import java.io.IOException;
import java.net.*;

/**
 * UDP 发送端B
 */
public class UDPSenderB {
    public static void main(String[] args) throws IOException {

        //1.创建 DatagramSocket(9998) 对象，即 发送端B
        DatagramSocket socket = new DatagramSocket(9998);

        //2.发送
        //将需要发送的数据，封装到 DatagramPacket对象
        byte[] data = "hello 明天吃火锅~".getBytes();
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getLocalHost(), 9999);
        socket.send(packet);
        System.out.println("发送端B发送完毕");

        //3.接收
        //(1)构建一个 DatagramPacket 对象，准备接收数据
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2)调用 接收方法, 把 packet 放进去
        //当有数据包发送到 本机的9998端口时，就会接收到数据，否则就会阻塞等待.
        System.out.println("发送端B 等待接收数据..");
        socket.receive(packet);
        System.out.print("发送端B收到 —— ");
        //(3)  可以把packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//实际接收到的数据字节长度
        data = packet.getData();//接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);

        //4.关闭资源
        socket.close();
        System.out.println("B端退出");
    }
}