Java-网络编程


前言

哈喽!大家好,我是小简。今天开始学习《Java-网络编程》,此系列是我做的一个 “Java 从 0 到 1 ” 实验,给自己一年左右时间,按照我自己总结的 Java-学习路线,从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后的蜕变吧!<有同样想法的小伙伴,可以联系我一起交流学习哦!>

小简目前研一,每天都有很多课程,另外还有科研的压力,只能利用空余时间更新文章,目前的安排是每天学习一点 Java 基础知识,正所谓基础不牢,地动山摇,一起加油吧✊。

  • 🚩时间安排:预计5天更新完
  • 🎯开始时间:03-04
  • 🎉结束时间:03-06
  • 🍀总结:用时 3 天,提前两天完成任务,继续下一个 🚩

网络基础

简介

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

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

  • TCP协议: 传输控制协议

    • 1.使用TCP协议前,须先建立TCP连接,形成传输数据通道
    • 2.传输前,采用”三次握手”方式,是可靠的
    • 3.TCP协议进行通信的两个应用进程:客户端、服务端
    • 4.在连接中可进行大数据量的传输
    • 5.传输完毕,需释放已建立的连接,效率低
  • UDP协议: 用户数据协议

    • 1.将数据、源、目的封装成数据包,不需要建立连接
    • 2.因无需连接,故是不可靠的
    • 2.每个数据报的大小限制在64K内,不适合传输大量数据
    • 4.发送数据结束时无需释放资源(因为不是面向连接的),速度快

Java提供的网络功能类

  • InetAddress: 用于标识网络上的硬件资源
  • Socket和ServerSocket: 使用TCP协议实现网络通信的 Socket 相关的类
  • Datagram: 使用UDP协议,将数据保存在数据报中,通过网络进行通信

InetAddress

  • getLocalHost() 获取本机 InetAddress 对象
  • getByName() 根据指定主机名/域名获取 ip 地址对象
  • getHostName() 获取 InetAddress 对象的主机名
  • getHostAddress() 获取 InetAddress 对象的地址
package com.jwt.network;

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

public class InetAddress_ {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机InetAddress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);
        //根据指定主机名/域名获取对象
        InetAddress host2 = InetAddress.getByName("jianjian");
        System.out.println(host2);
        InetAddress host3 = InetAddress.getByName("www.baidu.com");
        System.out.println(host3);
        //获取InetAddress对象的主机名
        String host3Name = host3.getHostName();
        System.out.println(host3Name);
        //获取InetAddress对象的地址
        String host3Address = host3.getHostAddress();
        System.out.println(host3Address);
    }
}

/**
jianjian/192.168.50.204
jianjian/192.168.50.204
www.baidu.com/14.215.177.39
www.baidu.com
14.215.177.39
**/

Socket

简介

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

TCP编程

简介

  • 1.基于客户端-服务端的网络通信
  • 2.底层使用的是TCP/IP协议
  • 3.应用场景举例:客户端发送数据,服务端接受并显示控制台

流程

TCP,传输前先开服务端,accept,等客户端接入,然后获得客户端 socket 然后进行 IO 操作

服务端编写

  • Step 1:创建ServerSocket对象,绑定监听的端口
    • ServerSocket serverSocket = new ServerSocket(Port);
  • Step 2:调用accept()方法监听客户端的请求
    • Socket socket = serverSocket.accept();
  • step 3:连接建立后,通过输入流读取客户端发送的请求信息
    • InputStream inputStream = socket.getInputStream();
  • Step 4:通过输出流向客户端发送响应信息
    • OutputStream outputStream = socket.getOutputStream();
  • Step 5:关闭相关资源
    • outputStream.close();
    • inputStream.close();
    • socket.close();
    • serverSocket.close();

客户端编写

  • Step 1:创建Socket对象,指明需要链接的服务器的地址和端号

    • Socket socket = new Socket(“server address”, port);
  • Step 2:链接建立后,通过输出流向服务器发送请求信息

    • OutputStream outputStream = socket.getOutputStream();
  • Step 3:通过输入流获取服务器响应的信息

    • InputStream inputStream = socket.getInputStream();
  • Step 4:关闭相关资源

    • inputStream.close();
    • outputStream.close();
    • socket.close();

例子1:使用字节流通信

  • 1.编写一个服务器端和一个客户端
  • 2.服务器端监听 9999 端口
  • 3.客户端连接到服务器端, 发送”你好,服务端!”,并接收服务器端回发的”你好,客户端!”,再退出
  • 4.服务器端接收到客户端发送的信息,输出,并发送”你好,客户端!”, 再退出

服务端

package com.jwt.socket;

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

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. 通过输入流,读取客户端写入到数据通道的数据, 显示
        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. 通过输出流,写入数据到数据通道
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("服务端说:你好,客户端!".getBytes());
        // 设置结束标记
        socket.shutdownOutput();
        //6.关闭流和socket
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}

客户端

package com.jwt.socket;

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

public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //1. 连接服务端(ip , 端口)如果连接成功,返回Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端socket返回=" + socket.getClass());
        //2. 连接上后,生成Socket, 通过socket.getOutputStream()
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输出流,写入数据到数据通道
        outputStream.write("客户端说:你好,服务端!".getBytes());
        // 设置结束标记
        socket.shutdownOutput();
        //4. 获取和socket 关联的输入流. 读取数据(字节),并显示
        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));
        }

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

例子2:使用字符流通信

  • 1.编写一个服务端和一个客户端
  • 2.服务端在9999端口监听
  • 3.客户端连接到服务端,发送”你好,服务端!”,并接收服务端回发的”你好,客户端!”,再退出
  • 4.服务端接收到客户端发送的信息,输出,并发送”你好,客户端!”,再退出

服务端

package com.jwt.socket;

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

public class SocketTCP02Server {
    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 读取, 使用字符流, 使用InputStreamReader 将inputStream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        //5. 通过输出流,写入数据到数据通道
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("服务端说:你好,客户端!");
        // 设置结束标记
        bufferedWriter.newLine();// 插入一个换行符,表示回复内容的结束
        bufferedWriter.flush();//注意需要手动的flush
        //6.关闭流和socket
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}

客户端

package com.jwt.socket;

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

public class SocketTCP02Server {
    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 读取, 使用字符流, 使用InputStreamReader 将inputStream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        //5. 通过输出流,写入数据到数据通道
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("服务端说:你好,客户端!");
        // 设置结束标记
        bufferedWriter.newLine();// 插入一个换行符,表示回复内容的结束
        bufferedWriter.flush();//注意需要手动的flush
        //6.关闭流和socket
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}

例子3:文件传输

  • 1.编写一个服务端和一个客户端
  • 2.服务器端在 8888 端口监听
  • 3.客户端连接到服务端,发送一张图片 /Users/jianjian/Downloads/a.jpeg
  • 4.服务器端接收到客户端发送的图片,保存到 src 下,发送”收到图片”再退出
  • 5.客户端接收到服务端发送的”收到图片”,再退出
  • 6.该程序要求使用 StreamUtils.java,我们直接使用

服务端

package com.jwt.socket;

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

public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {
        //1. 服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端监听8888端口....");
        //2. 等待连接
        Socket socket = serverSocket.accept();
        //3. 读取客户端发送的数据,通过Socket 得到输入流
        System.out.println("服务端开始接收图片");
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //4. 将得到bytes 数组,写入到指定的路径,就得到一个文件了
        String destFilePath = "src//a.jpeg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.flush();
        System.out.println("服务端接收图片成功");
        //5.向客户端回复"收到图片"通过socket 获取到输出流(字符)
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("服务端:收到图片");
        bw.flush();//把内容刷新到数据通道
        socket.shutdownOutput();//设置写入结束标记
        //6.关闭其他资源
        bw.close();
        bos.close();
        bis.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出.....");
    }
}
/**
服务端监听8888端口....
服务端开始接收图片
服务端接收图片成功
服务端退出.....
**/

客户端

package com.jwt.socket;

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

public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {
        //1.客户端连接服务端8888,得到Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //2.创建读取磁盘文件的输入流
        System.out.println("客户端开始发送图片");
        String filePath = "/Users/jianjian/Downloads/a.jpeg";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        //bytes 就是filePath 对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //3.通过socket 获取到输出流, 将bytes 数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);
        bos.flush();
        socket.shutdownOutput();//设置写入数据的结束标记
        System.out.println("客户端发送图片成功");
        //4.接收从服务端回复的消息
        InputStream inputStream = socket.getInputStream();
        //使用StreamUtils 的方法,直接将inputStream 读取到的内容转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);
        //5.关闭相关的流
        inputStream.close();
        bos.close();
          bis.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}
/**
客户端开始发送图片
客户端发送图片成功
服务端:收到图片

客户端退出.....
**/

UDP编程

简介

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

流程

UDP,以数据报作为数据的传输载体,在进行传输时首先要把传输的数据定义成数据报(Datagram),在数据报中指明数据要到达的Socket(主机地址和端口号),然后再将数据以数据报的形式发送出去,然后就没有然后了,服务端收不收到我就不知道了,除非服务端收到后又给我回一段确认的数据报。

接收端编写

  • Step 1:创建DatagramSocket,指定端口号

    • DatagramSocket socket = new DatagramSocket(9999);
  • Step 2:创建DatagramPacket

    • DatagramPacket packet = new DatagramPacket(buf,buf.length);
  • Step 3:接收发送端发送的数据信息

    • socket.receive(packet);
  • Step 4:读取数据

    • packet.getLength();
    • packet.getData();
  • Step 5:关闭相关资源

    • socket.close();

发送端编写

  • Step 1:定义发送信息

    • byte[] data = “发送端:hello 明天吃火锅~”.getBytes();
  • Step 2:创建DatagramPacket,包含将要发送的信息

    • DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName(“jianjian”), 9999);
  • Step 3:创建DatagramSocket

    • DatagramSocket socket = new DatagramSocket(9998);
  • Step 4:发送数据

    • socket.send(packet);
  • Step 5:关闭相关资源

    • socket.close();

例子:接受端发送端通信

  • 1.编写一个接收端 A 和一个发送端 B
  • 2.接收端 A 在 9999 端口等待接收数据
  • 3.发送端 B 向接收端 A 发送数据”hello ,明天吃火锅~”
  • 4.接收端 A 接收到发送端 B 发送的数据,回复”好的,明天见”,再退出
  • 5.发送端接收回复的数据,再退出

接受端

package com.jwt.socket;

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

public class UDPReceiverA {
    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);
        System.out.println("接收端A等待接收数据..");
        //3. 调用接收方法, 将通过网络传输的DatagramPacket 对象,填充到packet 对象
        //当有数据包发送到本机的9999 端口时,就会接收到数据
        // 如果没有数据包发送到本机的9999 端口, 就会阻塞等待.
        socket.receive(packet);
        //4. 把packet进行拆包,取出数据,并显示
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);
        //5. 回复信息给B端,将需要发送的数据,封装到DatagramPacket 对象
        data = "接收端:好的, 明天见".getBytes();
        //内容字节数组, 数组长度,主机(IP),端口
        packet = new DatagramPacket(data, data.length, InetAddress.getByName("jianjian"), 9998);
        socket.send(packet);
        //6. 关闭资源
        socket.close();
        System.out.println("A 端退出...");
    }
}
/**
接收端A等待接收数据..
发送端:hello 明天吃火锅~
A 端退出...
**/

发送端

package com.jwt.socket;

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

public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket 对象,准备在9998 端口接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        //2. 将需要发送的数据,封装到DatagramPacket 对象
        byte[] data = "发送端:hello 明天吃火锅~".getBytes();
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("jianjian"), 9999);
        socket.send(packet);
        //3. 接收从A 端回复的信息
        //(1).构建一个DatagramPacket 对象,准备接收数据
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2) 调用接收方法, 将通过网络传输的DatagramPacket 对象,填充到packet 对象
        socket.receive(packet);
        //(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 端退出");
    }
}
/**
接收端:好的, 明天见
B 端退出
**/

本章练习

1.编程题Homework01.java

  • (1)使用字符流的方式,编写一个客户端程序和服务器端程序
  • (2)客户端发送”name”,服务器端接收到后,返回”我是nova”,nova 是你自己的名字
  • (3)客户端发送”hobby”,服务器端接收到后,返回”编写java程序”
  • (4)不是这两个问题,回复”你说啥呢”
  • 问题:目前,我们只能问一次,就退出了,怎么可以问多次? ->while ->聊天

服务端

package com.jwt.socket.homework;

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

public class Homework01Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("我是服务端,正在监听9999端口,等待连接...");
        Socket socket = serverSocket.accept();
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = br.readLine();
        System.out.println(s);
        
        String answer = "";
        if ("name".equals(s)) {
            answer = "我是nova";
        } else if("hobby".equals(s)) {
            answer = "编写java程序";
        } else {
            answer = "你说啥呢";
        }

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(answer);
        bw.flush();
        socket.shutdownOutput();

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

客户端

package com.jwt.socket.homework;

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

public class Homework01Client {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getByName("jianjian"),9999);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        //从键盘读取用户的问题
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的问题:");
        String question = scanner.next();
        bw.write(question);
        bw.flush();
        socket.shutdownOutput();

        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = br.readLine();
        System.out.println(s);

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

2.编程题Homework02.java

  • (1)编写一个接收端A和一个发送端B,使用UDP协议完成
  • (2)接收端在8888端口等待接收数据
  • (3)发送端向接收端发送数据”四大名著是哪些”
  • (4)接收端接收到发送端发送的问题后,返回”四大名著是<<红楼梦>> ..”,否则返回what?
  • (5)接收端和发送端程序退出

接受端

package com.jwt.socket.homework;

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

public class Homework02ReceiverA {
    //- (1)编写一个接收端A和一个发送端B,使用UDP协议完成
    //- (2)接收端在8888端口等待接收数据
    //- (3)发送端向接收端发送数据"四大名著是哪些"
    //- (4)接收端接收到发送端发送的问题后,返回"四大名著是<<红楼梦>> ..”,否则返回what?
    //- (5)接收端和发送端程序退出

    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(8888);
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf,0,buf.length);
        System.out.println("接收端A等待接收数据..");
        socket.receive(packet);
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data,0,length);
        System.out.println(s);

        String anser = "";
        if("四大名著是哪些".equals(s)){
            anser = "四大名著是<<红楼梦>>...";
        } else {
            anser = "What?";
        }

        buf = anser.getBytes();


        packet = new DatagramPacket(buf, buf.length, InetAddress.getByName("jianjian"), 9999);
        socket.send(packet);

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




    }
}

发送端

package com.jwt.socket.homework;

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

public class Homework02SenderB {
    //- (1)编写一个接收端A和一个发送端B,使用UDP协议完成
    //- (2)接收端在8888端口等待接收数据
    //- (3)发送端向接收端发送数据"四大名著是哪些"
    //- (4)接收端接收到发送端发送的问题后,返回"四大名著是<<红楼梦>> ..”,否则返回what?
    //- (5)接收端和发送端程序退出
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(9999);

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的问题:");
        String question = scanner.next();
        byte[] buf = question.getBytes();
        DatagramPacket packet = new DatagramPacket(buf, buf.length, InetAddress.getByName("jianjian"), 8888);
        socket.send(packet);

        buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        socket.receive(packet);

        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);

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

3.编程题Homework03.java

  • (1)编写客户端程序和服务器端程序
  • (2)客户端可以输入一个音乐文件名,比如高山流水,服务端收到音乐名后,可以给客户端返回这个音乐文件,如果服务器没有这个文件,返回一个默认的音乐即可
  • (3)客户端收到文件后,保存到本地
  • (4)提示:该程序可以使用StreamUtils.java
  • 本质:其实就是指定下载文件的应用先自己结合老师讲的文件上传来做

服务端

package com.jwt.socket.homework;

import com.jwt.socket.StreamUtils;

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

public class Homework03Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端监听9999端口....");
        Socket socket = serverSocket.accept();
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = br.readLine();
        System.out.println(s);
        //发送音乐
        System.out.println("服务端开始发送音乐");
        String music = "";
        if ("高山流水".equals(s)){
            music = "高山流水.mp3";
        } else {
            music = "无名.mp3";
        }
        String filePath = "src//" + music;
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);
        bos.flush();
        socket.shutdownOutput();//设置写入数据的结束标记
        System.out.println("客户端发送音乐成功");

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

客户端

package com.jwt.socket.homework;

import com.jwt.socket.StreamUtils;

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

public class Homework03Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入音乐名:");
        String downMusic = scanner.next();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write(downMusic);
        bw.flush();
        socket.shutdownOutput();
        //读取客户端发送的数据,通过Socket 得到输入流
        System.out.println("客户端开始接收音乐");
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        // 将得到bytes 数组,写入到指定的路径,就得到一个文件了
        String destFilePath = "/Users/jianjian/Downloads/" + downMusic + ".mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.flush();
        System.out.println("客户端接收音乐成功");

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

❤️Sponsor

您的支持是我不断前进的动力,如果您恰巧财力雄厚,又感觉本文对您有所帮助的话,可以考虑打赏一下本文,用以维持本博客的运营费用,拒绝白嫖,从你我做起!🥰🥰🥰

支付宝支付 微信支付

文章作者: 简简
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 简简 !
评论
填上邮箱会收到评论回复提醒哦!!!
 上一篇
Java-JDBC Java-JDBC
前言哈喽!大家好,我是小简。今天开始学习《Java-JDBC》,此系列是我做的一个 “Java 从 0 到 1 ” 实验,给自己一年左右时间,按照我自己总结的 Java-学习路线,从 0 开始学 Java 知识,并不定期更新所学笔记,期待一
2022-03-06
下一篇 
牛客-SQL练习 牛客-SQL练习
小简计划 入门篇:【题数:39道题】【难度:🌟🌟| 用时:3☀️】 必会篇:【题数:50道题】【难度:🌟|用时:3☀️】 进阶篇:【题数:46道题】【难度:🌟🌟🌟|用时:7☀️】 真题篇:【题数:3
2022-02-28
  目录