网络编程笔记

最新推荐文章于 2024-08-16 09:41:10 发布

qq_47721411

最新推荐文章于 2024-08-16 09:41:10 发布

阅读量293

点赞数

文章标签：网络服务器运维

本文链接：https://blog.csdn.net/qq_47721411/article/details/128049737

版权

网络通信

1.概念：两台设备之间通过网络实现数据传输
2.网络通信：将数据通过网络从一台设备传输到另一台设备
3.java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信

网络相关概念

1.概念：两台或多台设备通过一定物理设备连接起来构成了网络
2.根据网络的覆盖范围不同，对网络进行分类：
局域网：覆盖范围最小，仅仅覆盖一个教师或一个机房
城域网：覆盖范围较大，可以覆盖一个城市
广域网：覆盖范围最大，可以覆盖全国甚至全球，万维网是广域网的代表

IP地址

1.概念：用于唯一标识网络中的每台计算机
2.查看ip地址：ipconfig
3.ip地址的表示形式：点分十进制 xx.xx.xx.xx
4.每一个十进制数的范围：0_{255，四个字节32位表示，0}255，0_255，0255，0~255
5.ip地址的组成=网络地址+主机地址，比如：192.168.16.69
6.IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址，使用128位表示地址，16个字节是IPv4的4倍
7.由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联的障碍

ipv4地址分类

A类：0 7位网络号 24位主机号 0.0.0.0~127.255.255.255
B类：1 0 14位网络号 16位主机号 128.0.0.0~191.255.255.255
C类：1 1 0 21位网络号 8位主机号 192.0.0.0~223.255.255.255
D类：1 1 1 0 28位多播组号 224.0.0.0~239.255.255.255
E类：1 1 1 1 0 27位（留待后用） 240.0.0.0~247.255.255.255
特殊的127.0.0.1表示本机地址

域名

www.baidu.com为了方便记忆，解决记ip的困难
将ip地址映射成域名

端口号

1.概念：用于标识计算机上某个特定的网络程序
2.表现形式：以整数形式，端口范围0~65535【2个字节表示端口 0~2^16-1】
3.0~1024已经被占用比如ssh 22,ftp 21,smtp 25,http 80
4.常见的网络程序端口号：
tomcat:8080
mysql:3306
oracle:1521
sqlserver:1433

网络通信协议

tcp/ip协议中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互连网络的基础，简单地说，就是由网络层的ip协议和传输层的TCP协议组成的
在这里插入图片描述

TCP和UDP

TCP协议：传输控制协议
1.使用TCP协议前，须先建立TCP连接，形成传输数据通道
2.传输前，采用三次握手方式，是可靠的
3.TCP协议进行通信的两个应用进程：客户端和服务端
4.在连接中可进行大数据量的传输
5.传输完毕，需释放已建立的连接，效率低
UDP协议：用户数据协议
1.将数据、源、目的封装成数据包，不需要建立连接
2.每个数据报的大小限制在64K内，不适合传输大量数据
3.因无需连接，故是不可靠的
4.发送数据结束时无需释放资源（因为不是面向连接的），速度快

InetAddress类

1.获取本机InetAddress对象getLocalHost
2.根据指定主机名/域名获取ip地址对象getByName
3.获取InetAddress对象的主机名getHostName
4.获取InetAddress对象的地址getHostAddress

 		// 1.获取本机的InetAddress对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);// // LAPTOP-5IKVUUKJ/192.168.41.1
        // 2.根据指定主机名，获取InetAddress对象
        InetAddress host1 = InetAddress.getByName("LAPTOP-5IKVUUKJ");
        System.out.println("host1=" + host1);// LAPTOP-5IKVUUKJ/192.168.41.1
        // 3.根据域名返回InetAddress对象，比如www.baidu.com
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println("host2="+host2);// www.baidu.com/39.156.66.14
        // 4.通过InetAddress对象获取对应的地址
        String hostAddress = host2.getHostAddress();
        System.out.println("host2对应的ip="+hostAddress);// 39.156.66.14
        // 5.通过InetAddress对象获取对应的主机名/域名
        String hostName = host2.getHostName();
        System.out.println("host2对应的主机名/域名"+hostName);// www.baidu.com

Socket

1.套接字Socket开发网络应用程序被广泛采用，以至于成为事实上的标准
2.通信的两端都要有Socket,是两台机器间通信的端点
3.网络通信其实就是Socket间的通信
4.Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输
5.一般主动发起通信的应用程序属于客户端，等待通信请求的为服务端

TCP网络通信编程

单向通信：字节流
服务端：

		 // 在本机的9999端口监听，等待连接
        // 要求本机没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        // 当没有客户端连接9999端口时，程序会阻塞，等待连接
        // 如果有客户端连接，则会返回Socket对象，程序继续
        // 这个ServerSocket可以通过accept()返回多个Socket[多个客户端连接服务器的并发]
        Socket socket = serverSocket.accept();
        System.out.println("服务端socket=" + socket.getClass());
        // 通过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));
        }
        // 关闭流和socket
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出...");

客户端：

		// 连接服务端(ip、端口)
        // 连接本机的9999端口，如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端socket返回=" + socket.getClass());
        // 连接上后，生成Socket,通过socket.getOutputStream()得到和socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        // 通过输出流，写入数据到数据通道
        outputStream.write("hello server".getBytes());
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");

双向通信：字节流
服务端：
设置输出流结束标记
socket.shutdownOutput();

 		ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        Socket socket = serverSocket.accept();
        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("hello client".getBytes());
        // 设置输出流结束标记
        socket.shutdownOutput();
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();

客户端：
设置输出流结束标记
socket.shutdownOutput();

 		Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server".getBytes());
        // 设置输出流结束标记
        socket.shutdownOutput();
        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));
        }
        inputStream.close();
        outputStream.close();
        socket.close();

双向通信：字符流
设置字符输出流结束标记
write.newLine()
字符输入流需要使用readLine()
使用字符输入字符流需要手动刷新bufferedWriter.flush()
服务端：

		ServerSocket serverSocket = new ServerSocket(9998);
        System.out.println("服务端，在9999端口监听，等待连接...");
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        // 输入字符流需要使用对应的readLine()
        String s = bufferedReader.readLine();
        System.out.println(s);
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello client 字符流");
        bufferedWriter.newLine();
        bufferedWriter.flush();
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出...");

客户端：

 		Socket socket = new Socket(InetAddress.getLocalHost(), 9998);
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello server 字符流");
        // 设置输出字符流的结束标记
        bufferedWriter.newLine();
        // 使用输出字符流需要手动刷新
        bufferedWriter.flush();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        bufferedReader.close();
        bufferedWriter.close();
        socket.close();
        System.out.println("客户端退出...");

TCP上传文件

编写的工具类：把文件的内容读入到byte[]和把读取内容写到磁盘上

	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;
    }
    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){
            builder.append(line+"\r\n");
        }
        return builder.toString();
    }
}

服务器：

		// 在本机的8888端口监听
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端，在8888端口监听，等待连接...");
        // 等待连接
        Socket socket = serverSocket.accept();
        // 读取客户端发送的数据
        // 通过Socket得到输入流
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        // 将得到bytes数组，写入到指定的路径，就得到一个文件了
        String destFilePath = "src/data/哀酱2.jpg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();
        // 向客户端回复“收到图片”
        // 通过socket获取到输出流（字符）
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到图片");
        writer.flush();// 把内容刷新到数据通道
        socket.shutdownOutput();// 设置写入结束标记
        // 关闭其他资源
        writer.close();
        bis.close();
        socket.close();
        serverSocket.close();

客户端：

		// 客户端连接服务器8888，得到Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        // 创建读取磁盘文件的输入流
        String filepath = "E:\\我的图片\\哀酱.jpg";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filepath));
        // bytes就是filepath对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        // 通过socket获取到输出流，将bytes数据发送给服务器
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);// 将文件对应的字节数组的内容，写入到数据通道
        bis.close();
        socket.shutdownOutput();// 设置写入数据的结束标记
        //===============接受从服务器端回复的消息
        InputStream inputStream = socket.getInputStream();
        // 使用StreamUtils的方法，直接将inputStream读取到的内容转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);
        // 关闭相关的流
        inputStream.close();
        bos.close();
        socket.close();

netstat指令

1.netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况
2.netstat -an | more 可以分页查看按空格翻页
(1)Listening表示某个端口在监听
(2)如果有一个外部程序(客户端)连接到该端口，外部地址就会显示一条连接信息
(3)可以输入ctrl+c退出指令
0.0.0.0:xxx和127.0.0.1:xxx表示本机ip
4.netstat -anb | more 查看哪一个程序侦听的端口

补充

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

UDP网络通信编程

1.类DatagramSocket和DatagramPacket[数据包/数据报]实现了基于UDP协议网络程序
2.UDP数据报通过数据报套接字DatagramSocket发送和接受，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达
3.DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
4.UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接
(1)没有明确的服务端和客户端，演变成数据的发送端和接收端
(2)接收数据和发送数据是通过DatagramSocket对象完成
(3)将数据封装到DatagramPacket对象/装包
(4)当接收到DatagramPacket对象，需要进行拆包，取出数据
(5)DatagramSocket可以指定在哪个端口接收数据

UDP网络通信编程基本流程

1.核心的两个类/对象DatagramSocket与DatagramPacket
2.建立发送端，接收端（没有服务端和客户端概念）
3.发送数据前，建立数据包/报DatagramPacket对象
4.调用DatagramSocket的发送、接收方法
5.关闭DatagramSocket
接收端：

 		 // 创建一个DatagramSocket对象，准备在9999接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        // 构建一个DatagramPacket对象，准备接收数据，一个数据包最大64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        // 调用接收方法，将通过网络传输的DatagramPacket对象填充到packet对象
        // 当有数据包发送到本机的9999端口时，就会接收到数据
        // 如果没有数据包发送到本机的9999端口时，就会阻塞等待
        System.out.println("接收端A 等待接收数据...");
        socket.receive(packet);
        // 可以把packet进行拆包，取出数据，并显示
        int length = packet.getLength();// 实际接收到的数据字节长度
        byte[] data = packet.getData();// 接收到的数据
        String s = new String(data, 0, length);
        System.out.println(s);
        //=====================回复信息给B端
        // 将需要发送的数据，封装到DatagramPacket对象
        data = "好的，明天见".getBytes();
        // 封装的DatagramPacket对象包括:data内容字节数组,data.length,主机(ip),端口
        packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.43.221"), 9998);
        socket.send(packet);
        // 关闭资源
        socket.close();
        System.out.println("A端退出...");

发送端：

		// 创建DatagramSocket对象，准备在9998端口接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        // 将需要发送的数据，封装到DatagramPacket对象
        byte[] data = "hello 明天吃火锅~".getBytes();
        // 封装的DatagramPacket对象包括：data内容字节数组，data.length,主机(ip),端口
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.43.221"), 9999);
        socket.send(packet);
        //====================接收从A端回复的信息
        // 构建一个DatagramPacket对象，准备接收数据，一个数据包最大64k
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        // 调用接收方法，将通过网络传输的DatagramPacket对象填充到packet对象
        // 当有数据包发送到本机的9998端口时，就会接收到数据
        // 如果没有数据包发送到本机的9998端口时，就会阻塞等待
        socket.receive(packet);
        // 可以把packet进行拆包，取出数据，并显示
        int length = packet.getLength();// 实际接收到的数据字节长度
        data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);
        // 关闭资源
        socket.close();
        System.out.println("B端退出...");

客户端发出问题，服务端回答问题

服务端：

		ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        String answer = "";
        if ("name".equals(s)){
            answer = "我是xxx";
        } else if ("hobby".equals(s)){
            answer = "看动漫";
        } else {
            answer = "我听不懂呀";
        }
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write(answer);
        bufferedWriter.newLine();
        bufferedWriter.flush();
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();

客户端：

		Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的问题");
        String question = scanner.next();
        bufferedWriter.write(question);
        bufferedWriter.newLine();
        bufferedWriter.flush();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        bufferedReader.close();
        bufferedWriter.close();
        socket.close();

发送端发送问题，接收端回答问题

发送端：

		 // 创建一个DatagramSocket对象，准备在8888接收数据
        DatagramSocket socket = new DatagramSocket(8889);
        // 将需要发送的数据，封装到DatagramPacket对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的问题");
        String question = scanner.next();
        byte[] data = question.getBytes();
        // 封装的DatagramPacket对象包括：data内容字节数组,data.length,主机(ip),端口
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.43.221"), 8888);
        socket.send(packet);
        //=============接收从A端回复的信息
        // 构建一个DatagramPacket对象，准备接收数据，一个数据包最大64K
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        // 调用接收方法，将通过网络传输的DatagramPacket对象填充到packet对象
        // 如果没有数据包发送到本机的8889，就会阻塞等待
        socket.receive(packet);
        // 可以把packet进行拆包，取出数据，并显示
        int length = packet.getLength();// 实际接收到的数据字节长度
        data = packet.getData();// 接收到的数据
        String s = new String(data, 0, length);
        System.out.println(s);
        // 关闭资源
        socket.close();
        System.out.println("B端退出...");

接收端：

		// 创建一个DatagramSocket对象，准备在8888接收数据
        DatagramSocket socket = new DatagramSocket(8888);
        System.out.println("接收端，在8888端口监听，等待连接...");
        // 构建一个DatagramPacket对象，准备接收数据，一个数据包最大64K
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        // 调用接收方法，将通过网络传输的DatagramPacket对象填充到packet对象
        // 如果没有数据包发送到本机的8888，就会阻塞等待
        socket.receive(packet);
        // 可以将packet进行拆包，取出数据，并显示
        int length = packet.getLength();// 实际接收到的数据字节长度
        byte[] data = packet.getData();// 接收到的数据
        String s = new String(data, 0, length);
        System.out.println(s);
        // 判断接收到的信息是什么
        String answer = "";
        if ("四大名著是哪些".equals(s)){
            answer = "四大名著 <<红楼梦>> <<西游记>> <<水浒传>> <<三国演义>>";
        } else {
            answer = "what";
        }
        //==============回复信息给B端
        // 将需要发送的数据，封装到DatagramPacket对象
        // 封装的DatagramPacket对象包括：data内容字节数组,data.length,主机(ip),端口
        data = answer.getBytes();
        packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.43.221"), 8889);
        socket.send(packet);// 发送
        // 关闭资源
        socket.close();
        System.out.println("A端退出...");

TCP下载文件

服务端：

		 // 监听9999端口
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        // 等待客户端连接
        Socket socket = serverSocket.accept();
        // 读取客户端发送要下载的文件名
        InputStream inputStream = socket.getInputStream();
        byte[] b = new byte[1024];
        int len = 0;
        String downLoadFileName = "";
        while ((len = inputStream.read(b))!= -1){
            downLoadFileName += new String(b,0,len);
        }
        System.out.println("客户端希望下载的文件名=" + downLoadFileName);
        // 如果客户下载的是高山流水，我们就返回该文件，否则一律返回无名.mp3
        String resFileName = "";
        if ("高山流水".equals(downLoadFileName)){
            resFileName = "src\\高山流水.mp3";
        } else {
            resFileName = "src\\无名.mp3";
        }
        // 创建一个输入流，读取文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(resFileName));
        // 使用工具类StreamUtils，读取文件到一个字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        // 得到Socket关联的输出流
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        // 写入到数据通道，返回给客户端
        bos.write(bytes);
        // 设置结束标记
        socket.shutdownOutput();
        // 关闭相关资源
        bos.close();
        bis.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出...");

客户端：

 		// 接收用户输入，指定下载文件名
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入下载文件名");
        String downloadFile = scanner.next();
        // 客户端连接服务器，准备发送
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        // 获取和Socket关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(downloadFile.getBytes());
        // 设置结束标记
        socket.shutdownOutput();
        // 读取服务端返回的文件(字节数据)
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        // 得到一个输出流，准备将bytes写入到磁盘文件
        // 如果你下载的是高山流水  => 下载的就是高山流水.mp3
        // 如果你在的是xxx        =>  下载的就是无名.mp3  =>文件名是xxx.mp3
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        String filepath = "e:\\" + downloadFile + ".mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filepath));
        bos.write(bytes);
        // 关闭相关资源
        bos.close();
        bis.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端下载完毕，正确退出...");