java 网络编程

最新推荐文章于 2023-03-31 17:03:13 发布

鱼尾巴选手

最新推荐文章于 2023-03-31 17:03:13 发布

阅读量415

点赞数

文章标签：网络 java tcp/ip

本文链接：https://blog.csdn.net/weixin_62918925/article/details/127019620

版权

文章目录

网络编程

网络编程

1. 网络基础

1.1 网络通信

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

1.2 网络

概念：两台或多台设备通过一定物理设备连接起来构成了网络。
根据网络的覆盖范围不同，对网络进行分类：局域网、城域网、广域网。

1.3 IP地址

概念：用于唯一标识网络中的每台计算机。
查看ip地址： ipconfig
ip地址的表示形式：点分十进制 XX.XX.XX.XX
每一个十进制数的范围: 0~255
ip地址的组成=网络地址+主机地址，比如: 192.168.16.69
iPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议。
由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍。

1.4 ipv4地址分类

特殊的，127.0.0.1表示本机地址。

1.5 域名和端口号

域名：
如www.baidu.com
好处：为了方便记忆，解决记ip的困难。
概念：将ip地址映射成域名，HTTP协议。

端口号：
概念：用于标识计算机上某个特定的网络程序。
表示形式：以整数形式，范围0~ 65535 。
0~1024已经被占用，比如ssh 22, ftp 21, smtp 25 http 80

1.6 网络通信协议

协议(tcp/ip)
TCP/IP，传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。

1.7 TCP和UDP

TCP（传输控制）协议：

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

UDP（用户数据）协议：

将数据、源、目的封装成数据包，不需要建立连接。
每个数据报的大小限制在64K内，不适合传输大量数据。
因无需连接，故是不可靠的。
发送数据结束时无需释放资源（因为不是面向连接的），速度快。
举例：发短信

1.8 netstat指令

netstat -an可以查看当前主机网络情况，包括端口监听情况和网络连接情况；
netstat -an | more可以分页显示；
要求在dos控制台下执行。

说明：

Listening表示某个端口在监听；
如果有一个外部程序（客户端）连接到该端口，就会显示一条连接信息；
可以输入Ctrl+c退出指令。

2. InetAddress

方法	描述
getLocalHost	获取本机InetAddress对象
getByName	根据指定主机名/域名获取ip地址对象
getHostName	获取InetAddress对象的主机名
getHostAddress	获取InetAddress对象的地址

3. Socket

基本介绍：

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

4. TCP编程

基本介绍：

基于客户端一服务端的网络通信。
底层使用的是TCP/IP协议。
应用场景举例：客户端发送数据，服务端接受并显示。
基于Socket的TCP编程。

4.1 TCP编程案例

一：（1）编写一个服务器端，和一个客户端；（2）服务器端在9999端口监听；（3）客户端连接到服务器端，发送"hello, server" ，然后退出；（4）服务器端接收到客户端发送的信息，输出，并退出。

服务端：

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

/**
 * 服务端
 */

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

        // 1. 在本机的9999端口监听，等待连接  (要求在本机没有其他服务在监听9999)
        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();

    }
}

客户端：

import java.io.IOException;
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 = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket = " + socket.getClass());
//        2.连接上后，生成Socket，通过 socket.getOutputStream()
        OutputStream outputStream = socket.getOutputStream();
//        3.通过输出流，写入数据到数据通道
        outputStream.write("hello,server".getBytes());
//        4.关闭流对象和socket
        outputStream.close();
        socket.close();
        System.out.println("客户端退出..");

    }
}

二：（1）编写一个服务器端，和一个客户端；（2）服务器端在9999端口监听；（3）客户端连接到服务器端，发送"hello, server" ，并接收服务器端回发的"hello,client"，再退出；（4）服务器端接收到客户端发送的信息，输出，并发送"hello, client", 再退出

服务端：

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

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

        // 1. 在本机的9999端口监听，等待连接  (要求在本机没有其他服务在监听9999)
        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.获取关联输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,client".getBytes());
        socket.shutdownOutput();    // 设置结束标记

        // 6.关闭流和socket
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

客户端：

import javax.jws.soap.SOAPBinding;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

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

//        1.连按服务端(ip 端口)

        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket = " + socket.getClass());

//        2.连接上后，生成Socket，通过 socket.getOutputStream()
        OutputStream outputStream = socket.getOutputStream();

//        3.通过输出流，写入数据到数据通道
        outputStream.write("hello,server".getBytes());
        socket.shutdownOutput();    // 设置结束标记
//        4.获取相关联的流
        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("客户端退出..");

    }
}

**注意：**在向服务端/客户端写数据后，需要一个结束标记，否则程序会一直在等待。

三：使用字符流对第二个案例进行编程。

服务端：

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

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

        // 1. 在本机的9999端口监听，等待连接  (要求在本机没有其他服务在监听9999)
        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读取，使用字符流
        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("hello,client 字符流");
        bufferedWriter.flush();
        socket.shutdownOutput();    // 设置结束标记

        // 6.关闭流和socket
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();

    }
}

客户端：

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

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

//        1.连按服务端(ip 端口)
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket = " + socket.getClass());

//        2.连接上后，生成Socket，通过 socket.getOutputStream()
        OutputStream outputStream = socket.getOutputStream();

//        3.通过输出流，写入数据到数据通道，使用字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,server 字符流");
        bufferedWriter.flush();     // 使用字符流，需要手动刷新
        socket.shutdownOutput();    // 设置结束标记

//        4.获取相关联的流
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);

//        5.关闭流对象和socket
        bufferedReader.close();
        bufferedWriter.close();
        socket.close();
        System.out.println("客户端退出..");

    }
}

**注意：**可以使用write.newLine()为结束标记，但是需要使用readLine()来读取。

4.2 网络上传文件

一：（1）编写一个服务端，和一个客户端；（2）服务器端在8888端口监听；（3）客户端连接到服务端，发送一张图片；（4）服务器端接收到客户端发送的图片，保存到src下，发送”收到图片“再退出；（5）客户端接收到服务端发送的”收到图片“ ，再退出。

服务端：

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

public class TCPFileUploadServer {
    public static void main(String[] args) throws IOException {
        // 在8888端口监听
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务器端在8888端口监听...");

        // 等待连接
        Socket socket = serverSocket.accept();

        // 读取客户端发送的文件
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        // 保存到src
        String filePath = "BasicGrammar\\src\\ball.jpg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        bos.write(bytes);

        // 发送确认收到的消息
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bw.write("收到图片");
        bw.flush();     // 手动刷新
        socket.shutdownOutput();    // 结束标记

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

    }
}

客户端：

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

public class TCPFileUploadClient {
    public static void main(String[] args) throws IOException {
        // 客户端连接服务端 8888，得到Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);

        // 创建输入流，获取磁盘中的文件
        String filePath = "e:\\ball.jpg";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));

        // bytes 就是filePath 对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        // 把bytes数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);

        socket.shutdownOutput();    // 设置结束标记

        // 接收服务端的消息
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        System.out.println(br.readLine());
        System.out.println("客户端退出...");

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

    }
}

StreamUtils类：

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class StreamUtils {
    /**
     * 将输入流转换成byte[]，即可以把文件的内容读取到byte[]
     *
     * @param is
     * @return
     * @throws IOException
     */
    public static byte[] streamToByteArray(InputStream is) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] b = new byte[1024];
        int len;
        while ((len = is.read(b)) != -1) {
            bos.write(b, 0, len);
        }
        byte[] array = bos.toByteArray();
        bos.close();
        return array;
    }
}

4.3 TCP连接秘密

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

5. UDP编程

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

应用案例：

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

接收端A：

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 {
        // 创建一个DatagramSocket 对象，准备在9999端口接收数据
        DatagramSocket socket = new DatagramSocket(9999);

        // 构建一个DatagramPacket 对象，准备接收数据
        // 一个数据包最大64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);

        // 调用方法，将传输的DatagramPacket 对象填充到packet
        System.out.println("接收端A 等待接收数据...");
        socket.receive(packet);     // 没有数据包发送到9999端口，就会阻塞

        // packet 拆包，取出数据，显示
        byte[] data = packet.getData();
        String s = new String(data, 0, data.length);
        System.out.println(s);

        // ====== 回复信息给B端
        data = "好的，明天见。".getBytes();
        packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.233.1"), 9998);
        socket.send(packet);


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

    }
}

发送端B：

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

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

        // 创建 对象，准备发送数据
        DatagramSocket socket = new DatagramSocket(9998);

        // 将需要发送的数据，封装到DatagramPacket 对象
        byte[] data = "hello,明天吃火锅".getBytes();
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.233.1"), 9999);

        // 发送
        socket.send(packet);

        // ====== 接收A端回复的信息
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        socket.receive(packet);
        data = packet.getData();
        System.out.println(new String(data, 0, data.length));

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

6. Homework

第一题：（1）使用字符流的方式，编写一个客户端程序和服务器端程序；（2）客户端发送" name"，服务器端接收到后，返回"我是nova “，
nova是你自己的名字；（3）客户端发送"hobby”，服务器端接收到后，返回"编写java程序"；（4）不是这两个问题，回复"你说啥呢"；

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

        // 读取数据
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        // 按情况判断，选择回复的话
        String answer = "";
        if ("name".equals(s)) {
            answer = "我是cat";
        } else if ("hobby".equals(s)) {
            answer = "编写java程序";
        } else {
            answer = "你说啥呢？";
        }
        // 将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();
        System.out.println("服务端退出..");

    }
}

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.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();   // 用作结束标记，需要对方用readLine()
        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("客户端退出.");

    }
}

第二题：（1）编写一个接收端A，和一个发送端B，使用UDP协议完成；（2）接收端在8888端口等待接收数据(receive)；（3）发送端向接收端发送数据"四大名著是哪些"；（4）接收端接收到发送端发送的问题后，返回"四大名著是< <红楼梦>> …"否则返回what？（5）接收端和发送端程序退出。

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

public class Homework02ReceiverA {
    public static void main(String[] args) throws IOException {
        // 在端口等待接收
        DatagramSocket socket = new DatagramSocket(8888);
        // 准备接收
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        // receive方法
        System.out.println("等待接收...");
        socket.receive(packet);

        //取出数据
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);
        // 判断收到的信息是什么
        String answer = "";
        if ("四大名著是哪些".equals(s)) {
            answer = "西游记、红楼梦、三国演义、水浒传";
        } else {
            answer = "what?";
        }

        // 回复
        data = answer.getBytes();
        packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.233.1"), 9999);
        socket.send(packet);

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

    }
}

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

public class Homework02SenderB {
    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[] data = question.getBytes();
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.233.1"), 8888);
        socket.send(packet);

        // 接收回复的消息
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        socket.receive(packet);
        int length = packet.getLength();
        data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);

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

    }
}

注：在接收数据进行拆包的时候，packet.getLength()和data.length不是总是一样的，需要使用packet方法获得的长度。

第三题：（1）编写客户端程序和服务器端程序；（2）客户端可以输入一个图片文件名，比如高山流水，服务端收到图片名后，可以给客户端返回这个图片文件，如果服务器没有这个文件，返回一个默认的图片即可。（3）客户端收到文件后，保存到本地e: \ \

服务器端：

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

public class Homework03Server {
    public static void main(String[] args) throws IOException {
        // 9999端口监听
        ServerSocket serverSocket = new ServerSocket(9999);
        // 等待客户端连接
        System.out.println("服务端监听等待...");
        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);

        // 读取并比较服务器上文件的文件名，默认返回ball.jpg
        String resFileName = "";  // 返回的文件名
        File file = new File("BasicGrammar\\src\\" + DownloadFileName + ".jpg");
        if (file.exists()) {
            resFileName = "BasicGrammar\\src\\" + DownloadFileName + ".jpg";
        } else {
            resFileName = "BasicGrammar\\src\\ball.jpg";
        }

        // 读取文件,放在字节数组
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(resFileName));
        byte[] bytes = StreamUtils.streamToByteArray(bufferedInputStream);
        // 将文件的字节数组返回给客户端
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(socket.getOutputStream());
        bufferedOutputStream.write(bytes);
        socket.shutdownOutput();    // !!!结束标记

        // 关闭流
        bufferedOutputStream.close();
        bufferedInputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出...");
        
    }
}

客户端：

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 IOException {
        // 接收用户输入，指定文件名
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入下载文件名：");
        String DownloadFileName = scanner.next();
        // 连接服务端
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        // 获取输出流，发送数据
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(DownloadFileName.getBytes());
        socket.shutdownOutput();

        // 读取服务端返回的文件
        BufferedInputStream bufferedInputStream = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bufferedInputStream);
        // 将文件写入到磁盘
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("e:\\" + DownloadFileName + ".jpg"));
        bufferedOutputStream.write(bytes);

        // 关闭
        bufferedOutputStream.close();
        bufferedInputStream.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端下载完毕，退出..");

    }
}