基于Java网络编程的云盘设计控制台版

最新推荐文章于 2023-10-10 07:31:39 发布

学无止步_穷其一生

最新推荐文章于 2023-10-10 07:31:39 发布

阅读量314

点赞数

分类专栏：案例练习文章标签： java 网络

本文链接：https://blog.csdn.net/qq_40756113/article/details/111461555

版权

案例练习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

资源链接：

https://download.csdn.net/download/qq_40756113/13740053

程序入口

package main;

import service.YunPanClientImp;
import service.YunPanService;

/**
 * 客户端程序的入口
 * @author WangJunHui
 * @date 2020/12/16 20:45
 */
public class ClouDiskClient {
    public static void main(String[] args) {
        //创建程序对象
        YunPanService yunPanService = new YunPanClientImp();
        //初始化程序
        yunPanService.init();
        //启动程序
        yunPanService.start();
    }
}


package main;

import service.YunPanService;
import service.YunPanServiceImp;

/**
 * 服务器程序的入口
 * @author WangJunHui
 * @date 2020/12/15 22:05
 */
public class ClouDiskServer {
    public static void main(String[] args) {
        //创建入口程序对象
        YunPanService yunPanService = new YunPanServiceImp();
        //调用初始化方法
        yunPanService.init();
        //启动程序
        yunPanService.start();
    }
}

客户端和服务器业务类接口

为了方便就用了一个接口，一般都是分开的，毕竟服务器和客户端属于不同的工程。

public interface YunPanService {
    //初始化方法，初始化程序，从配置文件中读取端口号根目录等
    void init();
    //启动程序
    void start();
}

客户端业务类

package service;

import bean.Protocol;

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

/**
 * 客户端的业务类，包含了程序初始化。和start业务方法，以及每个功能对应的业务方法。
 * @author WangJunHui
 * @date 2020/12/15 22:06
 */
public class YunPanClientImp implements YunPanService {
    //默认链接服务器的端口，如果配置文件中配置了，则使用配置文件中的。
    private static int port = 6667;//默认端口
    //默认的服务器IP，配置文件中可以配置。
    private static String ip = "127.0.0.1";//默认IP
    //默认客户端的下载根目录。配置文件中可以配置修改。
    private static File rootDir = new File("download");
    //用于记录当前路径，初始为根目录root
    private File file = new File("root");

    /**
     * 程序的初始化方法，用于读取配置文件，配置程序运行时的各种配置信息。
     */
    @Override
    public void init() {
        //通过配置文件获取根目录，连接端口号IP地址等云盘配置
        ResourceBundle bundle = ResourceBundle.getBundle("client");
        //获取配置文件中的端口号
        port = Integer.parseInt((String) bundle.getObject("port"));
        //获取配置文件中的服务器IP
        ip = (String) bundle.getObject("ip");
        //获取配置文件中的客户端下载根目录
        rootDir = new File((String) bundle.getObject("rootDir"));
    }

    /**
     * 程序的业务主界面，程序启动时，自动请求服务器根目录的目录列表，并显示到屏幕。
     * 然后读取用户输入的选项，根据选项，执行不同的业务方法。
     */
    @Override
    public void start() {
        //用于读取用户屏幕录入信息
        Scanner scanner = new Scanner(System.in);
        //欢迎词
        System.out.println("*******欢迎进入黑马网盘*******");
        wc:while (true){
            //显示云盘服务器当前目录文件列表
            scanDirectory();
            //显示选项信息
            System.out.println("*************************************************************************");
            System.out.println("1)浏览子目录 \t2)返回上一级目录 \t3)下载文件 \t4)上传文件 \t5)退出系统");
            System.out.println("*************************************************************************");
            //读取用户输入的选择序号
            String line = scanner.nextLine();
            //根据选择执行对应的业务方法
            switch (line){
                case "1":
                    //浏览子目录
                    scanChildDirectory();
                    break;
                case "2":
                    //返回上一级
                    scanPreviousDirectory();
                    break;
                case "3":
                    //下载文件
                    downloadFile();
                    break;
                case "4":
                    //上传文件
                    uploadFile();
                    break;
                case "5":
                    //退出系统
                    System.out.println("谢谢使用");
                    break wc;
                default:
                    //处理错误输入
                    System.out.println("输入的序号有误！");
            }
        }
    }

    /**
     * 浏览子目录业务功能，让用户输入子目录名称，然后和当前目录拼接为子目录路径，并作为当前路径，
     * start方法的死循环，每次都会调用浏览方法，获取当前目录的文件列表，所以我们在这里只需要更改当前目录即可。
     */
    private void scanChildDirectory(){
        System.out.println("请输入子文件夹：");
        Scanner scanner = new Scanner(System.in);
        //获取用户输入的子目录名称
        String line = scanner.nextLine();
        //将子目录和当前路径拼接，然后作为新的当前目录
        file = new File(file,line);
    }

    /**
     * 返回上一级业务功能，判断上一级是否存在，如返回到root时就不存在上一级目录，存在时获取当前目录的父目录，并作为当前路径，
     * 不存在时，提示用户已经处于根目录，没有上一级目录了。
     * start方法的死循环，每次都会调用浏览方法，获取当前目录的文件列表，所以我们在这里只需要更改当前目录即可。
     */
    private void scanPreviousDirectory(){
        //判断当前目录是否是root根目录
        if ("root".equals(file.getPath())){
            //提示用户已经处于根目录，没有上级目录了
            System.out.println("已返回到根目录，没有上级目录了");
        }else {
            //存在上级目录，将上级目录设置为当前目录。
            file = new File(file.getParent());
        }
    }

    /**
     * 浏览当前目录，每次在用户做出选择功能前都会显示当前目录供用户选择。
     */
    private void scanDirectory(){
        //将当前目录的路径写入到协议中
        Protocol protocol = Protocol.getScanDirProtocol(file.getPath());
        try {
            //获取和服务器的连接对象然后传递功能类的构造函数中创建对象，然后调用功能类的浏览方法，并传递浏览协议对象。
            //成功返回true，失败返回false。
            boolean b = new FileUpDownClientImp(connection()).scanDirectory(protocol);
            if (!b){
                /*
                浏览目录失败，获取父目录再次调用浏览功能。
                    1、当是浏览子目录功能改变当前目录后调用浏览失败时(子目录不存在)，起到回退作用，
                    将当前目录回退到父目录中，然后显示父目录文件列表，父目录肯定存在(从父目录选择的子目录)。
                    2、当是返回上一级功能改变当前目录后调用浏览失败时(进入子目录后，父目录被删除)，会退到上上一级，
                    如果上上一级不存在，还是会再次回到此处，然后继续向上返回直到返回到存在的上级目录或者最后返回到root根目录，
                    如果root目录不存在(也被删了)，那云盘服务器已经废了(根目录都没有)，可以报空指针异常(通过root获取的父目录为null)退出客户端了。
                 */
                file = file.getParentFile();
                scanDirectory();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 下载文件的业务方法，提示用户输入下载的文件名，然后将当前路径和文件名拼接为下载的文件路径，放于协议中。
     * 然后在客户端下载的根目录中创建文件父路径，创建不存在的父文件夹，然后调用功能类的下载方法，将请求协议和获取的客户端套接字传递过去。
     * 然后接受下载是否成功，失败时，删除创建的空文件，由于怕麻烦就没有删除创建的空的父文件夹，也可以通过循环获取父路径删除，
     * 直到删除到父目录不为空或者为根目录(因为有可能根目录也为空，但是不能删除)为止。
     */
    private void downloadFile(){
        System.out.println("请输入下载的文件名：");
        Scanner scanner = new Scanner(System.in);
        //获取客户输入的下载文件名称
        String line = scanner.nextLine();
        //将文件名和当前路径拼接为下载文件的路径。并设置到请求协议中
        Protocol protocol = Protocol.getDownloadProtocol(file.getPath() + "\\" + line);
        try {
            //将root替换为下载根目录。
            File root = new File(file.getPath().replaceFirst("root", rootDir.getPath()));
            //创建不存在的父目录
            root.mkdirs();
            File file = new File(root, line);
            //判断下载的文件在本地文件中是否是文件夹
            if (file.isDirectory()){
                //提示不能下载文件夹
                System.out.println("不能直接下载文件夹");
                //结束下载功能
                return;
            }
            //创建下载文件的字节输出流对象
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            //调用方法传递下载协议和文件输出流对象。
            boolean b = new FileUpDownClientImp(connection()).downloadFile(protocol, fileOutputStream);
            //获取下载执行结果
            if (!b){
                //下载失败，提示用户
                System.out.println("下载失败");
                fileOutputStream.close();
                //删除创建的空文件。
                file.delete();
            }
            //关闭文件输出字节流
            fileOutputStream.close();
        } catch (Exception e) {
            return;
           // e.printStackTrace();
        }
    }

    /**
     *上传功能的业务方法，提示用户输入要上传文件的路径，判断在本地硬盘上该路径是否存在，并且是否是文件类型，
     * 如果符合要求，将文件名拼接到当前目录上，组成在云盘上的文件路径，然后设置到协议里，创建文件字节读取流，
     * 调用方法传递文件字节读取流、协议对象、获取的客户端套接字。接受boolean类型的返回值，判断文件是否上传成功
     * 如果上传失败，给出提示信息。
     */
    private void uploadFile(){
        Scanner scanner = new Scanner(System.in);
        //死循环，直到用户输入的文件路径符合要求：存在、不是文件夹。
        while(true){
            System.out.println("请输入上传的文件路径：");
            String line = scanner.nextLine();
            //接受用户输入的文件路径。
            File file = new File(line);
            //判断是否符合上传要求
            if (file.exists()&&file.isFile()){
                //给出开始上传的提示信息
                System.out.println("开始上传"+file.getName());
                //将上传的文件路径封装到协议里。
                Protocol protocol = Protocol.getUploadProtocol(new File(this.file,file.getName()));
                try {
                    //创建文件字节读取流，用于读取要上传的文件数据。
                    FileInputStream fileInputStream = new FileInputStream(file);
                    //调用方法，传递文件字节读取流、协议对象、获取的客户端套接字。并接受返回值。
                    boolean b = new FileUpDownClientImp(connection()).uploadFile(protocol, fileInputStream);
                    //返回值为false，提示上传失败。
                    if (!b){
                        System.out.println("上传失败");
                    }
                    //关闭文件读取流。
                    fileInputStream.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //文件上传完毕结束死循环
                break;
            }else if(!file.exists()){
                //提示用户输入的文件路径不存在
                System.out.println("文件不存在！");
            }else if(file.isDirectory()){
                //提示用户输入的路径是文件夹
                System.out.println("不能直接上传文件夹");
            }
        }
    }

    /**
     * 获取客户端套接字，通过成员变量的配置属性，链接服务器，并返回客户端套接字对象。
     * @return
     * @throws Exception
     */
    private Socket connection() throws Exception{
        return new Socket(ip,port);
    }
}

客户端传输功能类接口

package service;

import bean.Protocol;

import java.io.InputStream;
import java.io.OutputStream;

/**
 * @author WangJunHui
 * @date 2020/12/15 21:56
 */
public interface FileUpDownClient {
    boolean uploadFile(Protocol protocol, InputStream inputStream) throws Exception;
    boolean downloadFile(Protocol protocol, OutputStream outputStream) throws Exception;
    boolean scanDirectory(Protocol protocol) throws Exception;
    Protocol parseProtocol(InputStream inputStream) throws Exception;
}

客户端传输功能类

package service;

import bean.Protocol;
import utils.IOUtils;
import java.io.*;
import java.net.Socket;

/**
 * 客户端用于上传下载浏览的专门工具类，只涉及和服务器交互，不涉及业务逻辑。
 * @author WangJunHui
 * @date 2020/12/16 21:04
 */
public class FileUpDownClientImp implements FileUpDownClient {
    //网络字节输入流，用于读取服务器发来的字节数据
    private InputStream netInputStream;
    //网络字节输出流，用于向服务器发送字节数据
    private OutputStream netOutputStream;
    //构造方法接受的客户端套接字，用于获取网络IO流对象
    private Socket socket;

    public FileUpDownClientImp(Socket socket) {
        //接受传递的客户端套接字
        this.socket = socket;
        try {
            //通过套接字获取网络字节输入流
            this.netInputStream = socket.getInputStream();
            //通过套接字获取网络字节输出流
            this.netOutputStream = socket.getOutputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 上传文件方法，向服务器发送请求协议，然后接受服务器回送的响应协议，判断协议status(状态)字段的内容，
     * OK：上传，通过IOUtils工具类的copy方法将文件字节输入流中的数据写入到网络字节输出流，否则打印协议中的失败信息。
     * @param protocol
     * @param inputStream
     * @return
     * @throws Exception
     */
    @Override
    public boolean uploadFile(Protocol protocol, InputStream inputStream) throws Exception {
        //向服务器发送请求协议
        sendProtocol(protocol, netOutputStream);
        //解析服务器发送的回送协议
        protocol = parseProtocol(netInputStream);
        //获取协议中的status字段内容
        String status = protocol.getStatus();
        //判断是否是OK(可以上传)
        if (Protocol.Status.OK.equals(status)) {
            //调用copy方法上传数据
            /*
                copy(inputStream,outputStream)将源数据流中数据写入到目标流中
                inputStream：源字节流，用于读取字节数据
                outputStream：目标字节流，用于写入字节数据。
             */
            boolean b = IOUtils.copy(inputStream, netOutputStream);
            //如果读写失败，返回false，告知用户上传失败。
            if (!b){
                return false;
            }
            //返回值为true提示上传成功
            System.out.println("上传成功");
            //写入结束标记。
            socket.shutdownOutput();
            socket.shutdownInput();
            //返回true
            return true;
        } else {
            //服务器不能接受该文件。打印服务器失败原因。
            System.out.println(protocol.getMessage());
            //关闭资源
            socket.shutdownOutput();
            socket.shutdownInput();
            //返回false
            return false;
        }
    }

    /**
     * 下载文件方法，向服务器发送请求协议，然后接受服务器回送的响应协议，判断协议status(状态)字段的内容，
     * 如果为OK下载网络流中的字节数据，否则提示用户下载失败(返回false)，打印响应协议的失败信息。
     * @param protocol
     * @param outputStream
     * @return
     * @throws Exception
     */
    @Override
    public boolean downloadFile(Protocol protocol, OutputStream outputStream) throws Exception {
        //向服务器发送请求协议
        sendProtocol(protocol,netOutputStream);
        //解析服务器的回送协议
        protocol = parseProtocol(netInputStream);
        //获取回送协议中的状态字段
        String status = protocol.getStatus();
        //判断字段是否是OK
        if (Protocol.Status.OK.equals(status)) {
            //提示用户开始下载
            System.out.println(new File(protocol.getFileName()).getName()+"开始下载");
            //调用方法读写字节数据
            boolean b = IOUtils.copy(netInputStream, outputStream);
            //判断是否读写成功
            if (!b){
                //不成功返回false
                return false;
            }
            //成功，提示下载成功
            System.out.println("下载成功");
            //关闭资源。
            socket.shutdownOutput();
            socket.shutdownInput();
            //成功返回true
            return true;
        } else {
            //状态字段不为OK，服务器不能传递下载的文件，打印失败信息
            System.out.println(protocol.getMessage());
            //关闭资源
            socket.shutdownOutput();
            socket.shutdownInput();
            //失败返回false
            return false;
        }
    }

    /**
     * 浏览文件方法，向服务器发送请求协议，然后接受服务器回送的响应协议，判断协议status(状态)字段的内容，
     * 状态字段是OK，向屏幕打印分割条和当前目录(即要浏览的目录，存储在协议的fileName字段中)，
     * 从网络流中读取数据(要浏览目录中的文件列表)，然后转换为字符打印到屏幕，返回true。
     * 状态字段不是Ok，打印协议中的浏览失败信息。返回false
     * @param protocol
     * @return
     * @throws Exception
     */
    @Override
    public boolean scanDirectory(Protocol protocol) throws Exception {
        //向服务器发送请求协议
        sendProtocol(protocol, netOutputStream);
        //解析服务器回送的响应协议
        protocol = parseProtocol(netInputStream);
        //获取状态字段内容
        String status = protocol.getStatus();
        //判断是否为Ok
        if (Protocol.Status.OK.equals(status)) {
            //创建字节缓冲流，并将网络字节输入流绑定到缓冲流对象。
            BufferedInputStream bufferedInputStream = new BufferedInputStream(netInputStream);
            //打印分割条
            System.out.println("---------------------------------------------------");
            //打印当前目录
            System.out.println("当前目录：" + protocol.getFileName());
            //创建缓冲字节数组
            byte[] bytes = new byte[1024 * 20];
            //从缓冲流读取字节信息
            int len = bufferedInputStream.read(bytes);
            //将字节信息转换成字符串打印到屏幕。
            System.out.println(new String(bytes, 0, len));
            //关闭资源
            socket.shutdownOutput();
            socket.shutdownInput();
            //浏览成功返回true
            return true;
        } else {
            //浏览失败，浏览的文件夹不存在或者不是文件夹。打印失败信息
            System.out.println(protocol.getMessage());
            //关闭资源
            socket.shutdownOutput();
            socket.shutdownInput();
            //失败返回false
            return false;
        }

    }

    /**
     * 用于向服务器发送请求协议。
     * @param protocol
     * @param outputStream
     * @throws IOException
     */
    private void sendProtocol(Protocol protocol, OutputStream outputStream) throws IOException {
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
        //将协议内容转化为字节输出到网络输出流。
        bufferedOutputStream.write(protocol.toString().getBytes());
        //刷新缓存区内容
        bufferedOutputStream.flush();
    }

    /**
     * 用于从网络字节输入流中解析服务器回送的响应协议。调用了Protocol的parseProtocol方法。
     * 返回解析的协议对象。
     * @param inputStream
     * @return
     * @throws Exception
     */
    @Override
    public Protocol parseProtocol(InputStream inputStream) throws Exception {
        return Protocol.parseProtocol(inputStream);
    }
}

服务器启动程序类

package service;

import java.io.File;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ResourceBundle;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

/**
 * 服务器端的初始化和启动类
 * @author WangJunHui
 * @date 2020/12/15 22:06
 */
public class YunPanServiceImp implements YunPanService {
    //默认端口，当配置文件不存在时，使用默认端口，配置文件存在时，使用配置文件中配置的端口
    private static int port = 6667;
    //默认根目录，当配置文件存在时，使用配置的根目录。
    private static File rootDir = new File("root");
    //定义服务器套接字变量
    private ServerSocket serverSocket;

    /**
     * 程序初始化方法，用于读取配置文件，然后根据配置文件的内容，初始化服务器套接字和程序运行的根目录
     * 配置文件名：server.properties
     * 读取配置信息：
     *      端口号：port
     *      根目录：rootDir
     */
    @Override
    public void init() {
        //通过配置文件获取根目录，监听端口号等云盘配置
        ResourceBundle bundle = ResourceBundle.getBundle("server");
        //获取端口号
        port = Integer.parseInt((String) bundle.getObject("port"));
        //获取根目录
        rootDir = new File((String) bundle.getObject("rootDir"));
        //检查根目录是否是文件夹
        if (rootDir.isFile()){
            System.out.println("跟目录是一个文件，不是文件夹，请检查配置文件");
            //根目录不是文件夹，初始化失败，给出提示，停止程序。
            System.exit(0);
        }
        //如果根目录不存在，创建根目录文件夹
        rootDir.mkdirs();
        try {
            //使用配置信息创建服务器套接字，用于监听来自服务器的请求。
            serverSocket = new ServerSocket(port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 程序启动的方法，创建线程池对象，然后监听客户端请求，为每个任务请求分配一个线程运行。
     * 线程池对象：executorService，初始化线程个数：10
     * 线程任务对象类:FileUpDownServiceImp(Socket socket),该类继承了Runnable接口，重写了run方法，
     *          创建对象时需要传递一个监听到的客户端接口。保存在该类对象的成员变量中。
     *
     */
    @Override
    public void start() {
        Socket s = null;
        //根据配置信息，创建服务器套接字
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //监听客户端套接字连接请求
        try {
            while(true) {
                //监听客户端的链接请求，并获取对应的客户端套接字
                s = serverSocket.accept();
                //FileUpDownServiceImp继承了Runnable接口，将客户端套接字传递给该类对象的成员变量。
                //每获取一个连接，创建一个多线程任务，然后从线程池中获取线程，submit提交任务FileUpDownServiceImp类
                executorService.submit(new FileUpDownServiceImp(s));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取根目录的File对象，用于在FileUpDownServiceImp对象的上传下载和浏览时，获得服务器的根目录。
     *      静态的，可以通过类名直接调用
     * @return
     */
    public static File getRootDir() {
        return rootDir;
    }
}

服务器业务类

package service;

import bean.Protocol;
import utils.IOUtils;

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

/**
 * 服务器端的业务类，包含了浏览、下载、上传等业务功能
 * @author WangJunHui
 * @date 2020/12/15 22:07
 */
public class FileUpDownServiceImp implements FileUpDownService , Runnable {
    //成员变量中存储客户端套接字。
    private Socket socket;
    //网络输入流
    private InputStream netInputStream=null;
    //网络输出流
    private OutputStream netOutputStream=null;
    //程序根目录
    private File rootdir = YunPanServiceImp.getRootDir();
    //构造方法，接受客户端套接字。
    public FileUpDownServiceImp(Socket socket) {
        this.socket = socket;
    }

    /**
     * 实现了Runnable接口中的run方法，用于多线程处理客户端的功能请求。
     * 每个客户端功能请求分配一个单独的线程。
     */
    @Override
    public void run() {
        //通过套接字获取网络流对象
        try {
            //获取网络字节输入流，用于读取客户端发送的数据。
            netInputStream = socket.getInputStream();
            //获取网络字节输出流，用于向客户端传递数据。
            netOutputStream = socket.getOutputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }
            //然后通过分析方法获取协议对象，根据协议对象的type字段值，选择对应的方法。
            try {
                //解析客户端的请求协议对象，判断是何种业务请求。
                Protocol protocol = parseProtocol(netInputStream);
                //获取业务类型字段
                String type = protocol.getType();
                switch (type){
                    case "scan":
                        //浏览指定目录
                        scanDirectory(protocol,netInputStream,netOutputStream);
                        break;
                    case "upload":
                        //客户端上传文件
                        uploadFile(protocol,netInputStream,netOutputStream);
                        break;
                    case "download":
                        //客户端下载文件
                        downloadFile(protocol,netOutputStream);
                        break;
                }
            } catch (Exception e) {
                return;
            }finally {
                //业务结束，关闭网络流和客户端套接字。
                if (socket!=null) {
                    try {
                        socket.shutdownOutput();
                        socket.getInputStream();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    }

    /**
     * 上传文件业务相应方法，根据客户端的请求协议，获取上传文件名和路径，
     * 判断文件是否存在，如果存在，为防止覆盖，为文件名添加系统毫秒值，保证文件名的唯一性。如果不存在，则使用原本的文件名称。
     * 然后向客户端回送响应请求。并调用IOUtils工具类的copy方法，将网络输入流中的文件数据，写入到文件输出流中。
     * @param protocol
     * @param inputStream
     * @param outputStream
     * @throws Exception
     */
    @Override
    public void uploadFile(Protocol protocol, InputStream inputStream, OutputStream outputStream) throws Exception {
        //获取协议中的filename字段，得到客户端要上传的文件路径root\...\文件名.后缀名
        String fileName = protocol.getFileName();
        //将root替换为服务器的根目录名称。如upload\...\文件名.后缀名，只替换root，其余路径保持不变。
        File file = new File(fileName.replaceFirst("root",rootdir.getPath()));
        //为防止文件重复时覆盖，判断服务器中是否已经存在该文件。至于是否是文件夹，已经在客户端判断。
        if (file.exists()){
            try {
                //文件名重复时，为文件名添加系统毫秒值。保证文件名的唯一性。
                file = new File(file.getParentFile(),System.currentTimeMillis()+"_"+file.getName());
                //创建空白文件，等待接受文件内容。
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //将协议字段的status设置为OK，表示服务器已经准备好接受文件数据。
        protocol.setStatus(Protocol.Status.OK);
        //将响应协议发送给客户端。
        sendProtocol(protocol,outputStream);
        //创建文件输出流，用于向文件中写入字节信息。
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        //调用IOUtils工具类中的copy方法，读取网络字节输入流中的文件数据，写入到文件字节输出流中。
        IOUtils.copy(inputStream,fileOutputStream);
        //关闭文件输出流。
        fileOutputStream.close();
    }

    /**
     * 下载文件业务相应方法，根据客户端的请求协议，获取下载文件的文件名名和路径，
     * 判断要下载的文件是否存在并且是否是文件，如果不存在或者不是文件，回送失败响应协议，并告知失败信息。
     * 如果文件存在并且是文件，回送OK响应协议，并发送文件数据。
     * @param protocol
     * @param outputStream
     * @throws Exception
     */
    @Override
    public void downloadFile(Protocol protocol, OutputStream outputStream) throws Exception {
        //获取要下载的文件路径和文件名
        String fileName = protocol.getFileName();
        //将root替换为服务器的根目录，并获取文件对象
        File file = new File(fileName.replaceFirst("root",rootdir.getPath()));
        //判断文件是否存在并且是否是文件类型
        if (file.exists()&&file.isFile()){
            //修改协议的status字段为OK
            protocol.setStatus(Protocol.Status.OK);
            //向客户端发送响应协议
            sendProtocol(protocol,outputStream);
            //创建文件字节输入流，用于读取文件数据
            FileInputStream fileInputStream = new FileInputStream(file);
            //调用方法，从文件字节输入流中读取文件数据，然后写到网络字节输出流中。
            IOUtils.copy(fileInputStream,outputStream);
            //关闭文件字节输入流。
            fileInputStream.close();
        }else{
            /*
            要下载的文件不存在或者不是文件类型。
             */

            //设置失败响应协议。
            protocol.setStatus(Protocol.Status.FAILED);
            //设置失败信息
            if (file.isDirectory()){
                //下载的文件是文件夹类型
                protocol.setMessage("不能直接下载文件夹");
            }else{
                //下载的文件不存在
                protocol.setMessage("文件不存在");
            }
            //向客户端发送失败响应协议。
            sendProtocol(protocol,outputStream);
        }
    }

    /**
     *浏览文件夹的业务方法，从客户端发来的协议中获取要浏览的文件夹，然后判断是否是文件夹，文件夹是否存在。
     * 如果不是文件夹或者文件夹不存在，回送失败的响应协议。
     * 如果存在并且是文件夹类型，回送成功的响应协议，调用listFile方法获取该文件夹的文件列表字符串。
     * 然后将字符串转化为字节数组，并写入到网络字节输出流中。
     * @param protocol
     * @param inputStream
     * @param outputStream
     * @throws Exception
     */
    @Override
    public void scanDirectory(Protocol protocol, InputStream inputStream, OutputStream outputStream) throws Exception {
        //获取浏览的文件夹，并将路径中的第一个root替换为服务器根目录。
        File file = new File(protocol.getFileName().replaceFirst("root",rootdir.getPath()));
        //判断文件夹是否存在，浏览的文件是否是文件夹类型
        if (file.exists()&&file.isDirectory()){
            //创建缓冲流对象，将网络字节输出流封装到缓冲流中。
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
            //设置响应协议的状态为OK
            protocol.setStatus(Protocol.Status.OK);
            //向客户端发送响应协议。
            sendProtocol(protocol, outputStream);
            //获取文件夹的目录列表字符串，并转换为字节数组，写入到网络字节输出流中。
            bufferedOutputStream.write(listFile(file).getBytes());
            bufferedOutputStream.flush();
        }else{
            /*
            文件夹不存在，或者不是文件夹
             */
            //设置协议状态为失败
            protocol.setStatus(Protocol.Status.FAILED);
            //设置协议的失败信息
            protocol.setMessage("文件不存在或者不是文件夹");
            //回送失败的协议响应
            sendProtocol(protocol, outputStream);
        }
    }

    /**
     * 用来向客户端发送响应协议的方法
     *  protocol：响应协议对象
     *  outputStream：网络字节输出流。
     * @param protocol
     * @param outputStream
     * @throws IOException
     */
    private void sendProtocol(Protocol protocol, OutputStream outputStream) throws IOException {
        //获取网络字节输出缓冲流。
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
        //将参数传递的协议对象转换为字节数组，写到网络字节输出流中。
        bufferedOutputStream.write(protocol.toString().getBytes());
        //刷新缓冲流中的内容。
        bufferedOutputStream.flush();
    }

    /**
     * 获取指定目录的内容列表，只包含一层的文件和文件夹，不递归。
     * @param file
     * @return
     */
    private String listFile(File file) {
        //创建字符串拼接对象
        StringBuilder sb = new StringBuilder();
        //获取该目录下的子文件和文件夹对象集合。
        File[] files = file.listFiles();
        //遍历集合，获得文件和文件夹的名称。
        for (File file1 : files) {
            //如果是目录就拼接"目录："+文件夹名，如果是文件就接"文件："+文件名。
            sb.append(file1.isDirectory() ? "目录："+file1.getName()+"\r\n" : "文件："+file1.getName()+"\r\n");
        }
        //返回拼接的目录列表字符串。
        return sb.toString();
    }

    /**
     * 用于从网络字节输入流中解析客户端发送的请求协议
     * @param inputStream
     * @return
     * @throws Exception
     */
    @Override
    public Protocol parseProtocol(InputStream inputStream) throws Exception {
        //调用协议类中的解析方法，返回解析的协议对象。
        return Protocol.parseProtocol(inputStream);
    }
}

工具类

package utils;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 用于IO操作
 *      方法
 *          copy(InputStream inputStream,OutputStream outputStream)
 *          从一个流中读取数据然后写到另一个流
 * @author WangJunHui
 * @date 2020/12/15 22:19
 */
public class IOUtils {
    /**
     * 从输入流中读取数据，然后写到输出流中，可以改进copy完毕后返回true，发生异常返回false。
     * @param inputStream：源字节流
     * @param outputStream：目标字节流
     * @return boolean
     */
    public static boolean copy(InputStream inputStream, OutputStream outputStream){
        byte[] bytes = new byte[1024*100];
        int len;
        try {
            while((len = inputStream.read(bytes))!=-1){
                outputStream.write(bytes,0,len);
                outputStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
}

自定义传输协议类

package bean;

import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;

/**
 * 协议类，用于客户端和服务器之间的请求与应答的格式规范。
 * 包含：
 * 成员变量：
 * type：浏览、上传、下载
 * fileName：请求的文件或文件夹名称
 * status：服务器对此次请求是否成功的状态提示，成功、失败
 * message：对于此次请求或应答的详细信息描述。
 * 内部类：
 * Type：包含静态变量，封装了type的各个功能
 * SCAN    //浏览
 * UPLOAD  //上传
 * DOWNLOAD//下载
 * Status：包含服务器应答请求的各个状态
 * OK      //成功
 * FAILED  //失败
 * 方法：
 * 无参构造
 * get/set
 * toString：
 * 各字段和值作为键值对，键值对之间用逗号隔开，键值对之间用等号连接。
 * 以下方法返回值都是本类对象。
 * getScanDirProtocol(String path)//返回浏览文件夹的协议对象
 * 将参数传递的文件路径封装到fileName属性中，type指定为浏览其余值为空
 * getDownloadProtocol(String path)//返回下载文件的协议对象
 * 将参数传递的文件路径封装到fileName属性中，type指定为下载其余值为空
 * getUploadProtocol(File file)//返回上传文件的协议对象
 * 将参数传递的文件的路径封装到fileName属性中，type指定为上传其余值为空
 * parseProtocol(String str)//根据协议头解析协议的各个字段内容
 * 将参数解析为各个字段的key和value，然后设置到协议对象中，返回设置好的协议对象
 * parseProtocol(InputStream netIn)//根据网络流解析出报头
 * 将报头获得并转换为字符串形式，调用parseProtocol(String str)方法进行解析，然后返回得到的协议对象。
 *
 * @author WangJunHui
 * @date 2020/12/15 20:43
 */
public class Protocol {
    private String type;
    private String fileName;
    private String status;
    private String message;

    public Protocol() {
    }

    /**
     * 静态内部类Type：使用成员常量列举四种操作类型
     */
    public static class Type {
        public static final String SCAN = "scan";//浏览
        public static final String UPLOAD = "upload";//上传
        public static final String DOWNLOAD = "download";//下载
    }

    /**
     * 静态内部类Status：使用静态成员常量列举两种请求状态
     */
    public static class Status {
        public static final String OK = "ok";//成功
        public static final String FAILED = "failed";//失败
    }

    /**
     *返回浏览文件夹的协议对象
     * @param path
     * @return Protocol
     */
    public static Protocol getScanDirProtocol(String path){
        Protocol protocol = new Protocol();
        protocol.setFileName(path);
        protocol.setType(Type.SCAN);
        return protocol;
    }

    /**
     *根据传递的文件名，获取下载的协议对象
     * @param path
     * @return Protocol
     */
    public static Protocol getDownloadProtocol(String path){
        Protocol protocol = new Protocol();
        protocol.setFileName(path);
        protocol.setType(Type.DOWNLOAD);
        return protocol;
    }

    /**
     * 根据参数传递的文件对象，获取上传文件的协议对象。
     * @param file
     * @return Protocol
     */
    public static Protocol getUploadProtocol(File file){
        Protocol protocol = new Protocol();
        protocol.setType(Type.UPLOAD);
        //文件上传路径
        protocol.setFileName(file.getPath());
        return protocol;
    }

    /**
     *根据协议头解析协议的各个字段内容,然后返回解析的协议对象
     * @param str
     * @return Protocol
     */
   public static Protocol parseProtocol(String str){
        //创建map集合，用于存储解析的键值对。
       if (str==null){
           return null;
       }
       HashMap<String, String> map = new HashMap<>();
       String[] split = str.split(",");
       for (String s : split) {
           //获取每个键值对
           String[] kv = s.split("=");
           //存放到集合中。
           map.put(kv[0],kv[1]);
       }
       //使用反射技术获取Protocol的各个字段然后封装对应的值
       //其实可以直接通过set方法设置，使用反射只是为了练习反射的使用。
       Protocol protocol = new Protocol();
       //使用该方法是因为成员字段都是private修饰，需要暴力反射
       Field[] declaredFields = protocol.getClass().getDeclaredFields();
       for (Field field : declaredFields) {
           //开启暴力反射
           field.setAccessible(true);
           try {
               //通过字段getName方法获取字段名称作为key值查找map集合中对应的value值，然后将该value值设置给对象的对应字段。
               field.set(protocol,map.get(field.getName()));
           } catch (IllegalAccessException e) {
               e.printStackTrace();
           }
       }
       return protocol;

   }

    /**
     * 根据网络流解析出报头,然后返回解析的协议对象
     * @param inputStream
     * @return Protocol
     */
   public static Protocol parseProtocol(InputStream inputStream) throws Exception{
       InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
       BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
       String line =null;

            line= bufferedReader.readLine();
       return parseProtocol(line);

   }

    /**
     * 返回协议的字符串形式，即报头。
     * @return String
     */
    public String toString() {
        Field[] fields = getClass().getDeclaredFields();
        StringBuilder sb = new StringBuilder();
        for (Field field : fields) {
            field.setAccessible(true);
            try {
                sb.append(field.getName()).append("=").append(field.get(this)).append(",");
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return sb.toString() + "\r\n";
    }
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getFileName() {
        return fileName;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

学无止步_穷其一生

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
基于Java网络编程的云盘设计控制台版

程序入口package main;import service.YunPanClientImp;import service.YunPanService;/** * 客户端程序的入口 * @author WangJunHui * @date 2020/12/16 20:45 */public class ClouDiskClient { public static void main(String[] args) { //创建程序对象 Yun
复制链接

扫一扫