Java笔记（二十六）：网络编程、IP地址、InetAddress类、TCP和UDP、Socket套接字、TCP&UDP网络编程

Axuer_Li

已于 2023-08-05 19:48:03 修改

阅读量383

点赞数

分类专栏： # Java基础文章标签：网络 java 笔记

于 2023-07-31 18:34:30 首次发布

本文链接：https://blog.csdn.net/X3272959/article/details/132005743

版权

Java基础专栏收录该内容

33 篇文章 4 订阅

订阅专栏

网络编程

一、网络通信

1、概念

两台设备之间通过网络实现数据传输；

2、网络通信

将数据通过网络从一台设备传输到另一台设备；

Java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信。
在这里插入图片描述

二、网络

1、概念

两台或多台设备通过一定物理设备连接起来构成了网络。

2、基于网络的覆盖范围进行分类

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

三、IP地址

（1）概念：用于唯一表示网络中的每台计算机/主机；

（2）查看ip地址：ipconfig；

（3）ip地址的表示形式：点分十进制 xx.xx.xx.xx；（4字节，32位）

（4）每一个十进制数的范围：0-255；

（5）ip地址的组成 = 网络地址 + 主机地址，比如：192.128.16.69；

（6）IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号可以称为全世界的每一粒沙子编上一个地址；（128位，16个字节，按照16进制表示X:X:X:X:X:X:X:X）这里X是一个四位16进制数，一个X有16位，2个字节

（7）由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍。
在这里插入图片描述

四、域名

在这里插入图片描述

五、端口号

用于区分监听的是哪个服务
在这里插入图片描述

1、概念

用于表示计算机上某个特定的网络程序

2、表示形式

以整数形式，端口范围0 ~ 65535【2个字节表示端口0~(2的16次方)-1】

3、常见的网络程序端口号

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

tomcat 8080，mysql 3306，oracle 1521，sqlserver 1433

【在网络开发中，不要使用0~1024端口】

六、网络通信协议

在这里插入图片描述

1、协议（tcp/ip）

TCP/IP（Transmission Control Protocol/Internet Protocol）。中文名为传输控制协议/因特网互联协议，又叫网络通讯协议

这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单来说，就是由网络层的IP协议和传输层的TCP协议组成的。

数据的组织形式就是协议

2、模型

在这里插入图片描述

3、示意图

在这里插入图片描述

七、TCP和UDP

1、TCP协议（传输控制协议）

在这里插入图片描述
① 使用TCP协议前，须先建立TCP连接，形成传输数据通道；

② 传输前，采用“三次握手”方式，确认是可靠的；

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

④ 在连接中可进行大数据量的传输；

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

2、UDP协议（用户数据协议）

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

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

③ 因无需连接，故是不可靠的；（有可能数据并没有传输过去）

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

⑤ 举例：测试通知：发短信。
在这里插入图片描述

八、InetAddress类

1、相关方法

1）`getLocalHost` 获取本机InetAddress对象

2）`getByName` 根据指定主机名/域名获取IP地址对象

3）`getHostName` 获取InetAddress对象的主机名

4）`getHostAddress` 获取InetAddress对象的地址

2、应用案例

public class API {
    public static void main(String[] args) throws UnknownHostException {
        //1. getLocalHost(): 获取本机的InetAddress对象，返回【主机名/IP地址】
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println("localHost=" + localHost); //RXLI-GAMECOMPUTER/192.168.220.1

        //2. getByName(String hostName): 根据主机名返回InetAddress对象，返回【主机名/IP地址】
        InetAddress host1 = InetAddress.getByName("RXLI-GAMECOMPUTER");
        System.out.println("host1=" + host1); //RXLI-GAMECOMPUTER/192.168.220.1

        //3. getByName(String domainName): 根据域名返回InetAddress对象，返回【域名/IP地址】
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println("host2=" + host2); //www.baidu.com/14.119.104.254(这个ip是服务器ip，可以变化的）

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

    }
}

九、Socket套接字

1、基本介绍

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

（2）通讯的两端都要有Socket，是两台机器之间的通讯端点；

（3）网络通信其实就是Socket间的通信；

（4）Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输（理解成客户端和服务端的插头）

（5）一般主动发起通信的应用程序属于客户端，等待通信请求的为服务端。
在这里插入图片描述

在这里插入图片描述

2、TCP网络通信编程

1）基本介绍

① 基于客户端-服务端的网络通信；

② 底层使用的是TCP/IP协议；

③ 应用场景举例：客户端发送数据，都无端接受并显示控制台；

④ 基于Sockte的TCP编程。

在这里插入图片描述
⭐注意：Socket最后一定要关闭！！

2）应用实例1

在这里插入图片描述

先运行server，再运行client

win10和Linux虚拟机网络搭建

虚拟机—Server

public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        //1. new ServerSocket(int port) 客户端监听
        //如果该端口被占用或者端口不存在，会报错
        //ServerSocket可以通过accept()方法返回多个Socket
        //不同的客户端连接同一个服务器时，对应不同的Socket，可以处理并发
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端9999端口开始监听，等待连接...");

        //2. accept() 等待连接
        // 如果没有得到连接，则一直阻塞在这，不会执行下面的代码
        // 如果得到连接，则返回一个Socket对象，是Server的socket
        Socket socket = serverSocket.accept();
        System.out.println("服务端得到连接...");

        //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(注意还有severSocket)
        inputStream.close();
        serverSocket.close();
        socket.close();
    }
}

主机—Client

 public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //1. 设置服务端主机ip
        String serverIP = "192.168.220.129";
        //2. 连接服务端 new Socket(String ip , int port)
        //  如果连接失败，则报错
        //  如果连接成功，则返回一个Socket对象，是客户端的socket
        Socket socket = new Socket(serverIP, 9999);
        System.out.println("客户端连接成功...");

        //3. 通过socket.getOutputStream() 获取输出流对象
        //  相当于把数据写入到两个socket连接的线路上
        OutputStream outputStream = socket.getOutputStream();
        //4. 通过IO输出流，写入数据到数据通道
        outputStream.write("hello server".getBytes()); //字节流，得将字符串转为字节数组
        //5. 关闭流对象和socket
        outputStream.close();
        socket.close();
    }
}

3）应用实例2

写入结束标记：
socket.shutdownOutput();

在这里插入图片描述

在每次输出流结束后写入结束标记

⭐分析：

如果不写入结束标记，程序会卡在服务端接收客户端传来消息的位置（服务端会一直接收，因为客户端并没有给它一个结束标记）

由于服务端没有接受完，就不会执行下面的写入hello client的语句，客户端也就更不会执行读取hello client的语句

虚拟机—server

public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        //1. new ServerSocket(int port) 客户端监听
        //如果该端口被占用或者端口不存在，会报错
        //ServerSocket可以通过accept()方法返回多个Socket
        //不同的客户端连接同一个服务器时，对应不同的Socket，可以处理并发
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端9999端口开始监听，等待连接...");

        //2. accept() 等待连接
        // 如果没有得到连接，则一直阻塞在这，不会执行下面的代码
        // 如果得到连接，则返回一个Socket对象，是Server的socket
        Socket socket = serverSocket.accept();
        System.out.println("服务端得到连接...");

        //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相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        //6. 通过IO输出流输出“hello client"
        outputStream.write("hello client".getBytes());
        //7. 写入结束标记
        socket.shutdownOutput();

        //8. 关闭流和socket(注意还有severSocket)
        inputStream.close();
        outputStream.close();
        serverSocket.close();
        socket.close();
        System.out.println("服务端退出...");
    }
}

客户端—client

public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        //1. 设置服务端主机ip
        String serverIP = "192.168.220.129";
        //2. 连接服务端 new Socket(String ip , int port)
        //  如果连接失败，则报错
        //  如果连接成功，则返回一个Socket对象，是客户端的socket
        Socket socket = new Socket(serverIP, 9999);
        System.out.println("客户端连接成功...");

        //3. 通过socket.getOutputStream() 获取输出流对象
        //  相当于把数据写入到两个socket连接的线路上
        OutputStream outputStream = socket.getOutputStream();
        //4. 通过IO输出流，写入数据到数据通道
        outputStream.write("hello server".getBytes()); //字节流，得将字符串转为字节数组
        //5. 写入结束标记
        socket.shutdownOutput();

        //6. 通过socket.getInputStream() 获取输入流对象
        InputStream inputStream = socket.getInputStream();
        //7. 通过IO输入流，读取服务端传过来的数据
        byte[] buf = new byte[1024];
        int readLen = 0;
        while((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf,0,readLen));
        }

        //8. 关闭流对象和socket
        outputStream.close();
        inputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

4）应用实例3【使用字符流】

在这里插入图片描述

⭐使用转换流 + 字符流需要写入完成后手动刷新bw.flush()才能写入

核心代码：


//第一种方法：newLine()结束，这种不能用while循环读取
	BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
	//3. 通过字符输出流，写入数据到 数据通道
	bw.write("hello, server");
	bw.newLine();//⭐ 插入一个换行符，表示写入的内容结束, 注意，要求对方使用readLine()!!!!
	bw.flush();// ⭐ 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道

//第二种方法：socket.shutdownOutput()：可以用while，但bw.flush得在结束标志前面
    OutputStream outputStream = socket.getOutputStream();
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
    bw.write("hello client");
    //  刷新写入
    bw.flush();
    //   设置结束标记
    socket.shutdownOutput();

虚拟机—server

public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        //1. new ServerSocket(int port) 客户端监听
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端9999端口开始监听，等待连接...");

        //2. accept() 等待连接
        Socket socket = serverSocket.accept();
        System.out.println("服务端得到连接...");

        //3. 通过socket.getInputStream() 获取输入流对象
        InputStream inputStream = socket.getInputStream();
        //4. 转换成字符流-->再转成处理流
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        //5. 通过IO输入流读取数据(用处理流一行行读取)
        System.out.println(br.readLine());

        //6. 获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        //7. 转换成字符流--->再转成处理流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        //8. 通过IO输出流输出“hello client"
        bw.write("hello client");
        //9. 写入结束标记
        //socket.shutdownOutput();
        bw.newLine();
        //10. 手动刷新(⭐重要！)
        bw.flush();

        //11. 关闭流和socket(注意还有severSocket)(只关闭外层流）
        br.close();
        bw.close();
        serverSocket.close();
        socket.close();
        System.out.println("服务端退出...");
    }
}

主机—client

public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        //1. 设置服务端主机ip
        String serverIP = "192.168.220.129";
        //2. 连接服务端 new Socket(String ip , int port)
        //  如果连接失败，则报错
        //  如果连接成功，则返回一个Socket对象，是客户端的socket
        Socket socket = new Socket(serverIP, 9999);
        System.out.println("客户端连接成功...");

        //3. 通过socket.getOutputStream() 获取输出流对象
        //  相当于把数据写入到两个socket连接的线路上
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        //4. 通过IO输出流，写入数据到数据通道
        bw.write("hello server"); //字节流，得将字符串转为字节数组
        //5. 写入结束标记
        //socket.shutdownOutput();
        bw.newLine();
        //6. 手动刷新(⭐重要！)
        bw.flush();

        //7. 通过socket.getInputStream() 获取输入流对象
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        //8. 通过IO输入流，读取服务端传过来的数据
        String line = "";
        line = br.readLine();
        System.out.println(line);

        //9. 关闭流对象和socket
        bw.close();
        br.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

在这里插入图片描述

5）应用实例4：上传图片

① 无工具类版（不打包）

在这里插入图片描述
注意：图片是二进制文件，需要用字节流

流程分析：

1. 客户端传文件给服务端：
	- 【客户端】
		- read文件
		- socket.output文件
	- 【服务端】
		- socket.input文件
		- write文件
2. 服务端传信息给客户端
	- 【服务端】
		- socket.output信息
	- 【客户端】
		- socket.input信息

在这里插入图片描述

虚拟机—服务端
【⭐】在java文件中设置linux下的文件路径 --> File.separator

public class TCPFileUploadServer {

    public static final String separator = File.separator; //用于区分windows和linuxs的文件路径分隔符

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

        Socket socket = serverSocket.accept();
        System.out.println("服务端连接成功...");

        String filePath = separator + "home" + separator + "rxli"
                        + separator + "Pictures" + separator + "qie.png";

        //1. 读取socket通道上的数据，并存入图片目录，边读边写
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));

        int len = 0;
        byte[] buf = new byte[1024];
        while((len = bis.read(buf)) != -1) {
            bos.write(buf,0,len);
        }
        //写的时候一定要flush
        bos.flush();
        System.out.println("服务端图片存储完成");

        //2. 告知客户端已经存储完图片
        BufferedOutputStream bos2 = new BufferedOutputStream(socket.getOutputStream()); //前面个流可以弃掉了，这次输出流在socket上
        bos2.write("服务端收到图片啦".getBytes());
        //写的时候一定要flush
        bos2.flush();
        //给对方发消息一定要有结束标记
        socket.shutdownOutput();


        //关闭流和socket
        bos.close();
        bos2.close();
        bis.close();
        socket.close();
        serverSocket.close();

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

主机—客户端

public class TCPFileUploadClient {
    public static void main(String[] args) throws IOException {
        String serverIP = "192.168.220.129";
        Socket socket = new Socket(serverIP, 8888);

        //1. 读取磁盘上的图片文件并写入socket通道，边读边写
        String filePath = "D:\\IDEA_Projects\\Study\\hsp3\\src\\qie.png";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        int len = 0;
        byte[] buf = new byte[1024];
        while((len = bis.read(buf)) != -1) {
            //边读边写
            bos.write(buf,0,len);
        }
        //输出流在中间一定要flush才能写入
        bos.flush();
        //写完记得加结束标记
        socket.shutdownOutput();
        System.out.println("客户端传图片完成");

        //2. 接收服务端传来的信息
        BufferedInputStream bis2 = new BufferedInputStream(socket.getInputStream());
        while((len = bis2.read(buf)) != -1) {
            System.out.println(new String(buf,0,len));
        }

        //关闭流
        bos.close();
        bis.close();
        bis2.close();
        socket.close();

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

在这里插入图片描述

传过去的小企鹅：
在这里插入图片描述

② 有工具类版（IDEA打包，Linux运行jar包）

IDEA打包和Linux运行包教程

StreamUtils工具类

public class StreamUtils {
    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
            bos.write(b, 0, len);
        }
        byte[] array = bos.toByteArray();
        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();
    }
}

client类

public class TCPFileUploadClient {
    public static void main(String[] args) throws IOException {
        String serverIP = "192.168.220.129";
        Socket socket = new Socket(serverIP, 8888);

        //1. 读取磁盘上的图片文件
        String filePath = "D:\\IDEA_Projects\\Study\\hsp3\\src\\qie.png";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        //使用自定义工具类，直接得到输入流上的文件字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //2. 将文件字节数组上传到socket.output通道
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);
        //输出流在中间一定要flush或者close才能写入
        bos.flush();
        //写完记得加结束标记
        socket.shutdownOutput();
        System.out.println("客户端传图片完成");

        //2. 接收服务端传来的信息
        BufferedInputStream bis2 = new BufferedInputStream(socket.getInputStream());
        //使用自定义工具类，直接得到输入流上的文件信息（String）
        String s = StreamUtils.streamToString(bis2);
        System.out.print("服务端发来消息：" + s);

        //关闭流
        bos.close();
        bis.close();
        bis2.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

server类

public class TCPFileUploadServer {

    public static final String separator = File.separator; //用于区分windows和linuxs的文件路径分隔符

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

        Socket socket = serverSocket.accept();
        System.out.println("服务端连接成功...");

        String filePath = separator + "home" + separator + "rxli"
                        + separator + "Pictures" + separator + "qie.png";

        //1. 读取socket通道上的数据
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //转换成字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //2. 存入图片
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        bos.write(bytes);
        //写的时候一定要flush
        bos.flush();
        System.out.println("服务端图片存储完成");

        //3. 告知客户端已经存储完图片
        BufferedOutputStream bos2 = new BufferedOutputStream(socket.getOutputStream());
        bos2.write("我收到图片啦".getBytes());
        //写的时候一定要flush
        bos2.flush();
        //给对方发消息一定要有结束标记
        socket.shutdownOutput();


        //关闭流和socket
        bos.close();
        bos2.close();
        bis.close();
        socket.close();
        serverSocket.close();

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

在这里插入图片描述

6）netstat指令

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

② netstat -an | more 可以分页显示；

③ netstat -anb 可以查看是哪个程序在使用端口

③ 要求在dos控制台下执行win + r（cmd或者powershell）
在这里插入图片描述

虚拟机：（Linux）
netstat -l：显示监听的套接口
netstat -a ：查看所有网络状态
在这里插入图片描述
运行客户端程序后（把结束标志注释掉，故意让连接一直存在）

可以看到主机53722端口连上了虚拟机8888端口
【⭐】客户端的端口是系统自动随机分配的，当传输完成就释放掉
【客户端的端口可变，服务端端口固定】

说明：

Listening 表示某个端口在监听；

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

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

查看是哪个程序在用端口

netstat -anb

在这里插入图片描述
可以看到是java.exe在用这个端口（主机53722）

3、UDP网络通信编程

1）基本介绍

在这里插入图片描述

2）基本流程

在这里插入图片描述
DatagramPacket(byte[], int, int, InetAddress ip, int port) //发送

DatagramPacket(byte[]) //接收

3）示意图

在这里插入图片描述

4）应用案例

在这里插入图片描述

public class A {
    public static void main(String[] args) throws IOException {
        //1. 创建一个 DatagramSocket 对象，准备在9999接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2. 构建一个 DatagramPacket 对象，准备接收数据
        //   在前面讲解UDP 协议时，老师说过一个数据包最大 64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.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对象
        data = "好的, 明天见".getBytes();
        //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
        packet =
                new DatagramPacket(data, data.length, InetAddress.getByName("192.168.220.1"), 9099);

        socket.send(packet);//发送

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

    }
}

/**
 * 发送端B ====> 也可以接收数据
 */
@SuppressWarnings({"all"})
public class B {
    public static void main(String[] args) throws IOException {

        //1.创建 DatagramSocket 对象，准备在9099端口 接收数据
        DatagramSocket socket = new DatagramSocket(9099);

        //2. 将需要发送的数据，封装到 DatagramPacket对象
        byte[] data = "hello 明天吃火锅~".getBytes(); //

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

        socket.send(packet);

        //3.=== 接收从A端回复的信息
        //(1)   构建一个 DatagramPacket 对象，准备接收数据
        //   UDP 协议一个数据包最大 64kB
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2)    调用 接收方法, 将通过网络传输的 DatagramPacket 对象
        //   填充到 packet对象
        //老师提示: 当有数据包发送到 本机的9998端口时，就会接收到数据，存放在packet中
        //   如果没有数据包发送到 本机的9998端口, 就会阻塞等待.
        socket.receive(packet);

        //(3)  可以把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端退出");
    }
}

4、课后作业

1）编程题

在这里插入图片描述

Server

public class Homework01Server {
    public static void main(String[] args) throws IOException {
        //获取服务端主机名
        String name = InetAddress.getLocalHost().getHostName();

        //接收客户端发来的消息
        //1. serverSocket建立连接
        ServerSocket serverSocket = new ServerSocket(9111);
        System.out.println("server正在等待连接...");
        Socket socket = serverSocket.accept();
        System.out.println("连接成功");
        //2. socket获取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        switch (br.readLine()) {
            case "name":
                bw.write("我是 " + name);
                break;
            case "hobby":
                bw.write("编写java程序");
                break;
            default:
                bw.write("你说啥呢");
                break;
        }
        //先刷新再socket结束
        bw.flush();
        socket.shutdownOutput();

        //关闭流
        br.close();
        bw.close();
        socket.close();
        System.out.println("server退出...");
    }
}

Client

public class Homework02Client {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        //和虚拟机建立连接
        Socket socket = new Socket("192.168.220.129", 9111);

        //键盘接收用户问题
        System.out.print("请输入你的问题(name-问名字 , hobby-问爱好): ");
        String question = scanner.next();
        //传数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(question);
        bw.flush();
        socket.shutdownOutput();

        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        System.out.println(br.readLine());

        //关闭资源
        bw.close();
        br.close();
        socket.close();
        System.out.println("client退出...");
    }
}

在这里插入图片描述

2）编程题

在这里插入图片描述

serverA端

public class Homework02ReceiverA {
    public static void main(String[] args) throws IOException {
        DatagramSocket datagramSocket = new DatagramSocket(8888);
        byte[] bytes = new byte[1024];
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
        System.out.println("B端等待A端传入数据...");
        datagramSocket.receive(packet);

        System.out.println("连接成功...");
        int len = packet.getLength();
        byte[] b = packet.getData();
        String s = new String(b,0,len);

        String b_ip = "192.168.220.1";
        String ans = "";
        if(s.equals("四大名著是哪些")){
            ans = "四大名著是《红楼梦》《西游记》《三国演义》《水浒传》";
        } else {
            ans = "what?";
        }
        b = ans.getBytes();
        packet = new DatagramPacket(b, 0 , b.length,
                        InetAddress.getByName(b_ip),9888);
        datagramSocket.send(packet);

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

ReceiverB端

public class Homework02SenderB {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);

        DatagramSocket datagramSocket = new DatagramSocket(9888);
        String a_ip = "192.168.220.129";

        //键盘输入问题
        System.out.print("请输入你的问题:");
        byte[] question = scanner.next().getBytes();
        DatagramPacket packet = new DatagramPacket(question,0,question.length,
                InetAddress.getByName(a_ip),8888);
        datagramSocket.send(packet);

        byte[] bytes = new byte[1024];
        packet = new DatagramPacket(bytes,bytes.length);
        datagramSocket.receive(packet);
        int len = packet.getLength();
        byte[] b = packet.getData();
        System.out.println(new String(b,0,len));

        datagramSocket.close();
        System.out.println("B端退出...");
    }
}

在这里插入图片描述

3）编程题

在这里插入图片描述
StreamUtils

public class StreamUtils {
    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
            bos.write(b, 0, len);
        }
        byte[] array = bos.toByteArray();
        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();
    }
}

Server

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

        //1 监听 9999端口
        ServerSocket serverSocket = new ServerSocket(8555);
        //2.等待客户端连接
        System.out.println("服务端，在8555端口监听，等待下载文件");
        Socket socket = serverSocket.accept();
        //3.读取 客户端发送要下载的文件名
        //  这里老师使用了while读取文件名，时考虑将来客户端发送的数据较大的情况
        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 高山流水.mp3
        //如果客户下载的是 高山流水 我们就返回该文件，否则一律返回 无名.mp3

        String resFileName = "";
        if("fire".equals(downLoadFileName)) {
            resFileName = "src\\fire.mp3";
        } else {
            resFileName = "src\\false.mp3";
        }

        System.out.println("取出的文件filePath=" + resFileName);

        //4. 创建一个输入流，读取文件
        BufferedInputStream bis =
                new BufferedInputStream(new FileInputStream(resFileName));

        //5. 使用工具类StreamUtils ，读取文件到一个字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //6. 得到Socket关联的输出流
        BufferedOutputStream bos =
                new BufferedOutputStream(socket.getOutputStream());
        //7. 写入到数据通道，返回给客户端
        bos.write(bytes);
        bos.flush();
        socket.shutdownOutput();//很关键.

        //8 关闭相关的资源
        bis.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出...");

    }
}

Client

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


        //1. 接收用户输入，指定下载文件名
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入下载文件名");
        String downloadFileName = scanner.next();

        //2. 客户端连接服务端，准备发送
        Socket socket = new Socket(InetAddress.getLocalHost(), 8555);
        //3. 获取和Socket关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(downloadFileName.getBytes());
        //设置写入结束的标志
        socket.shutdownOutput();

        //4. 读取服务端返回的文件(字节数据)
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //5. 得到一个输出流，准备将 bytes 写入到磁盘文件
        //比如你下载的是 高山流水 => 下载的就是 高山流水.mp3
        //    你下载的是 韩顺平 => 下载的就是 无名.mp3  文件名 韩顺平.mp3
        String filePath = "d:\\" + downloadFileName + ".mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        bos.write(bytes);

        //6. 关闭相关的资源
        bos.close();
        bis.close();
        outputStream.close();
        socket.close();

        System.out.println("客户端下载完毕，正确退出..");


    }
}

Axuer_Li

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java笔记（二十六）：网络编程、IP地址、InetAddress类、TCP和UDP、Socket套接字、TCP&UDP网络编程

（1）套接字（Socket）开发网络应用程序被广泛采用，以至于成为事实上的标准；（2）通讯的两端都要有Socket，是两台机器之间的通讯端点；（3）网络通信其实就是Socket间的通信；（4）Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输（理解成客户端和服务端的插头）（5）一般主动发起通信的应用程序属于客户端等待通信请求的为服务端。① 基于客户端-服务端的网络通信；② 底层使用的是TCP/IP协议；③ 应用场景举例：客户端发送数据，都无端接受并显示控制台；
复制链接

扫一扫