Java Web 实现文件上传和下载接口功能

雨点打透心脏的1/2处 2024-03-30 12:29 79阅读 0赞

## 1.上传java代码实现 ##

@ResponseBody
        @PostMapping("/upload")
        public ResponseVo upload(@RequestParam(value = "file", required = false) MultipartFile multipartFile) {
            File file=new File("上传到服务器的文件地址");
            try {
                FileUtil.copy(multipartFile.getBytes(), file);
            } catch (IOException e) {
                return  ResultUtil.error();
            }
            return ResultUtil.success();
        }

上传用post或者get请求都可以，这里代码中用post做的示例。

## 2.文件流下载java代码实现 ##

文件下载除了静态访问（及nginx、tomcat等服务器映射到后的文件web路径）下载以外 ，还可以通过流的方式下载,代码如下：

/**
         * 下载
         */
        @PostMapping("/download")
        public void download(String fileName, HttpServletResponse response) throws IOException {
            FileInputStream fis=new FileInputStream("服务器文件所在路径");
            response.addHeader("Content-Disposition", "attachment;filename="+fileName+";"+"filename*=utf-8''"+fileName);
            FileUtil.copy(fis, response.getOutputStream());
        }

上传用post或者get请求都可以，这里代码中用post做的示例。

## 3.Fileutil工具类代码： ##

import com.tarzan.navigation.common.exception.ForbiddenException;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.lang.NonNull;
    import org.springframework.util.Assert;
    import org.springframework.util.StreamUtils;
    
    import java.io.*;
    import java.nio.file.*;
    import java.nio.file.attribute.BasicFileAttributes;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Objects;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    import java.util.zip.ZipEntry;
    import java.util.zip.ZipInputStream;
    import java.util.zip.ZipOutputStream;
    
    @Slf4j
    public class FileUtil {
    
        /**
         * Copies folder.
         *
         * @param source source path must not be null
         * @param target target path must not be null
         */
        public static void copyFolder(@NonNull Path source, @NonNull Path target) throws IOException {
            Assert.notNull(source, "Source path must not be null");
            Assert.notNull(target, "Target path must not be null");
    
            Files.walkFileTree(source, new SimpleFileVisitor<Path>() {
    
                @Override
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                        throws IOException {
                    Path current = target.resolve(source.relativize(dir).toString());
                    Files.createDirectories(current);
                    return FileVisitResult.CONTINUE;
                }
    
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
                        throws IOException {
                    Files.copy(file, target.resolve(source.relativize(file).toString()),
                            StandardCopyOption.REPLACE_EXISTING);
                    return FileVisitResult.CONTINUE;
                }
            });
        }
    
        /**
         * Deletes folder recursively.
         *
         * @param deletingPath deleting path must not be null
         */
        public static void deleteFolder(@NonNull Path deletingPath) {
            Assert.notNull(deletingPath, "Deleting path must not be null");
    
            if (Files.notExists(deletingPath)) {
                return;
            }
            log.info("Deleting [{}]", deletingPath);
            delete(deletingPath.toFile());
            log.info("Deleted [{}] successfully", deletingPath);
        }
    
        private static void delete(File file) {
            if(file.isDirectory()){
                Arrays.asList(Objects.requireNonNull(file.listFiles())).forEach(FileUtil::delete);
            }
            file.delete();
        }
    
        /**
         * Renames file or folder.
         *
         * @param pathToRename file path to rename must not be null
         * @param newName new name must not be null
         */
        public static void rename(@NonNull Path pathToRename, @NonNull String newName)
                throws IOException {
            Assert.notNull(pathToRename, "File path to rename must not be null");
            Assert.notNull(newName, "New name must not be null");
    
            Path newPath = pathToRename.resolveSibling(newName);
            log.info("Rename [{}] to [{}]", pathToRename, newPath);
    
            Files.move(pathToRename, newPath);
    
            log.info("Rename [{}] successfully", pathToRename);
        }
    
    
    
        /**
         * Unzips content to the target path.
         *
         * @param zis zip input stream must not be null
         * @param targetPath target path must not be null and not empty
         * @throws IOException throws when failed to access file to be unzipped
         */
        public static void unzip(@NonNull ZipInputStream zis, @NonNull Path targetPath)
                throws IOException {
            // 1. unzip file to folder
            // 2. return the folder path
            Assert.notNull(zis, "Zip input stream must not be null");
            Assert.notNull(targetPath, "Target path must not be null");
    
            // Create path if absent
            createIfAbsent(targetPath);
    
            // Folder must be empty
           ensureEmpty(targetPath);
    
            ZipEntry zipEntry = zis.getNextEntry();
    
            while (zipEntry != null) {
                // Resolve the entry path
                Path entryPath = targetPath.resolve(zipEntry.getName());
    
                // Check directory
                checkDirectoryTraversal(targetPath, entryPath);
    
                if (zipEntry.isDirectory()) {
                    // Create directories
                    Files.createDirectories(entryPath);
                } else {
                    // Copy file
                    Files.copy(zis, entryPath);
                }
    
                zipEntry = zis.getNextEntry();
            }
        }
    
        /**
         * Unzips content to the target path.
         *
         * @param bytes zip bytes array must not be null
         * @param targetPath target path must not be null and not empty
         * @throws IOException io exception
         */
        public static void unzip(@NonNull byte[] bytes, @NonNull Path targetPath) throws IOException {
            Assert.notNull(bytes, "Zip bytes must not be null");
    
            ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(bytes));
            unzip(zis, targetPath);
        }
    
        /**
         * Zips folder or file.
         *
         * @param pathToZip file path to zip must not be null
         * @param pathOfArchive zip file path to archive must not be null
         * @throws IOException throws when failed to access file to be zipped
         */
        public static void zip(@NonNull Path pathToZip, @NonNull Path pathOfArchive)
                throws IOException {
            try (OutputStream outputStream = Files.newOutputStream(pathOfArchive)) {
                try (ZipOutputStream zipOut = new ZipOutputStream(outputStream)) {
                    zip(pathToZip, zipOut);
                }
            }
        }
    
        /**
         * Zips folder or file.
         *
         * @param pathToZip file path to zip must not be null
         * @param zipOut zip output stream must not be null
         * @throws IOException throws when failed to access file to be zipped
         */
        public static void zip(@NonNull Path pathToZip, @NonNull ZipOutputStream zipOut)
                throws IOException {
            // Zip file
            zip(pathToZip, pathToZip.getFileName().toString(), zipOut);
        }
    
        /**
         * Zips folder or file.
         *
         * @param fileToZip file path to zip must not be null
         * @param fileName file name must not be blank
         * @param zipOut zip output stream must not be null
         * @throws IOException throws when failed to access file to be zipped
         */
        private static void zip(@NonNull Path fileToZip, @NonNull String fileName,
                                @NonNull ZipOutputStream zipOut) throws IOException {
            if (Files.isDirectory(fileToZip)) {
                log.debug("Try to zip folder: [{}]", fileToZip);
                // Append with '/' if missing
                String folderName =
                        StringUtils.appendIfMissing(fileName, File.separator, File.separator);
                // Create zip entry and put into zip output stream
                zipOut.putNextEntry(new ZipEntry(folderName));
                // Close entry for writing the next entry
                zipOut.closeEntry();
    
                // Iterate the sub files recursively
                try (Stream<Path> subPathStream = Files.list(fileToZip)) {
                    // There should not use foreach for stream as internal zip method will throw
                    // IOException
                    List<Path> subFiles = subPathStream.collect(Collectors.toList());
                    for (Path subFileToZip : subFiles) {
                        // Zip children
                        zip(subFileToZip, folderName + subFileToZip.getFileName(), zipOut);
                    }
                }
            } else {
                // Open file to be zipped
                // Create zip entry for target file
                ZipEntry zipEntry = new ZipEntry(fileName);
                // Put the entry into zip output stream
                zipOut.putNextEntry(zipEntry);
                // Copy file to zip output stream
                Files.copy(fileToZip, zipOut);
                // Close entry
                zipOut.closeEntry();
            }
        }
    
        /**
         * Creates directories if absent.
         *
         * @param path path must not be null
         * @throws IOException io exception
         */
        public static void createIfAbsent(@NonNull Path path) throws IOException {
            Assert.notNull(path, "Path must not be null");
    
            if (Files.notExists(path)) {
                // Create directories
                Files.createDirectories(path);
    
                log.debug("Created directory: [{}]", path);
            }
        }
    
        /**
         * The given path must be empty.
         *
         * @param path path must not be null
         * @throws IOException io exception
         */
        public static void ensureEmpty(@NonNull Path path) throws IOException {
            if (!isEmpty(path)) {
                throw new DirectoryNotEmptyException("Target directory: " + path + " was not empty");
            }
        }
    
        /**
         * Checks directory traversal vulnerability.
         *
         * @param parentPath parent path must not be null.
         * @param pathToCheck path to check must not be null
         */
        public static void checkDirectoryTraversal(@NonNull String parentPath,
                                                   @NonNull String pathToCheck) {
            checkDirectoryTraversal(Paths.get(parentPath), Paths.get(pathToCheck));
        }
    
        /**
         * Checks directory traversal vulnerability.
         *
         * @param parentPath parent path must not be null.
         * @param pathToCheck path to check must not be null
         */
        public static void checkDirectoryTraversal(@NonNull Path parentPath,
                                                   @NonNull String pathToCheck) {
            checkDirectoryTraversal(parentPath, Paths.get(pathToCheck));
        }
    
        /**
         * Checks directory traversal vulnerability.
         *
         * @param parentPath parent path must not be null.
         * @param pathToCheck path to check must not be null
         */
        public static void checkDirectoryTraversal(@NonNull Path parentPath,
                                                   @NonNull Path pathToCheck) {
            Assert.notNull(parentPath, "Parent path must not be null");
            Assert.notNull(pathToCheck, "Path to check must not be null");
    
            if (pathToCheck.normalize().startsWith(parentPath)) {
                return;
            }
    
            throw new ForbiddenException("你没有权限访问 " + pathToCheck);
        }
    
        /**
         * Checks if the given path is empty.
         *
         * @param path path must not be null
         * @return true if the given path is empty; false otherwise
         * @throws IOException io exception
         */
        public static boolean isEmpty(@NonNull Path path) throws IOException {
            Assert.notNull(path, "Path must not be null");
    
            if (!Files.isDirectory(path) || Files.notExists(path)) {
                return true;
            }
    
            try (Stream<Path> pathStream = Files.list(path)) {
                return !pathStream.findAny().isPresent();
            }
        }
        /**
         * Copy the contents of the given input File to the given output File.
         * @param in the file to copy from
         * @param out the file to copy to
         * @return the number of bytes copied
         * @throws IOException in case of I/O errors
         */
        public static int copy(File in, File out) throws IOException {
            Assert.notNull(in, "No input File specified");
            Assert.notNull(out, "No output File specified");
            return copy(Files.newInputStream(in.toPath()), Files.newOutputStream(out.toPath()));
        }
    
        /**
         * Copy the contents of the given byte array to the given output File.
         * @param in the byte array to copy from
         * @param out the file to copy to
         * @throws IOException in case of I/O errors
         */
        public static void copy(byte[] in, File out) throws IOException {
            Assert.notNull(in, "No input byte array specified");
            Assert.notNull(out, "No output File specified");
            copy(new ByteArrayInputStream(in), Files.newOutputStream(out.toPath()));
        }
    
        /**
         * Copy the contents of the given InputStream to the given OutputStream.
         * Closes both streams when done.
         * @param in the stream to copy from
         * @param out the stream to copy to
         * @return the number of bytes copied
         * @throws IOException in case of I/O errors
         */
        public static int copy(InputStream in, OutputStream out) throws IOException {
            Assert.notNull(in, "No InputStream specified");
            Assert.notNull(out, "No OutputStream specified");
    
            try {
                return StreamUtils.copy(in, out);
            }
            finally {
                try {
                    in.close();
                }
                catch (IOException ex) {
                }
                try {
                    out.close();
                }
                catch (IOException ex) {
                }
            }
        }
        /**
         * Copy the contents of the given byte array to the given OutputStream.
         * Closes the stream when done.
         * @param in the byte array to copy from
         * @param out the OutputStream to copy to
         * @throws IOException in case of I/O errors
         */
        public static void copy(byte[] in, OutputStream out) throws IOException {
            Assert.notNull(in, "No input byte array specified");
            Assert.notNull(out, "No OutputStream specified");
    
            try {
                out.write(in);
            }
            finally {
                try {
                    out.close();
                }
                catch (IOException ex) {
                }
            }
        }
    
    
    }

ForbiddenException 访问权限异常类

import org.springframework.http.HttpStatus;
    
    /**
     * Exception caused by accessing forbidden resources.
     *
     * @author johnniang
     */
    public class ForbiddenException extends RuntimeException {
    
        public ForbiddenException() {
            super();
        }
    
        public ForbiddenException(String message) {
            super(message);
        }
    
        public ForbiddenException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public HttpStatus getStatus() {
            return HttpStatus.FORBIDDEN;
        }
    }

图片示例

![da37fe73deba4657952f4bb9978b2dd0.png][]

![c558559ece65492c812e2be745ee2b72.png][]

![7c6eed701b124732a0689d0fe4646dab.png][]

完整代码请参考：

[tarzan-navigation: 泰山导航网站-java版][tarzan-navigation_ _-java]

## 4.相关知识 ##

MultipartFile、HttpServletResponse和FileInputStream都是在Java Web开发中常用的类。它们分别用于处理上传文件、响应HTTP请求和读取文件内容。下面将详细解释这三个类的特点和用法。

### MultipartFile： ###

MultipartFile是Spring框架提供的接口，用于处理上传的文件数据。它提供了一组方法来获取文件名、文件类型、文件大小以及文件内容等信息。

**以下是MultipartFile接口中常用的方法：**

*  getOriginalFilename()：获取上传文件的原始文件名。
 *  getContentType()：获取上传文件的内容类型。
 *  getSize()：获取上传文件的大小。
 *  getBytes()：获取上传文件的字节数组。
 *  getInputStream()：获取上传文件的输入流。

### HttpServletResponse： ###

HttpServletResponse是Java Servlet API提供的接口，用于向客户端发送HTTP响应。通过HttpServletResponse，我们可以设置响应的状态码、头部信息和内容等。

**以下是HttpServletResponse接口中常用的方法：**

*  setStatus(int sc)：设置HTTP响应的状态码。
 *  setHeader(String name, String value)：设置HTTP响应的头部信息。
 *  getWriter()：获取输出流，用于将数据写入响应体。

### FileInputStream： ###

FileInputStream是Java IO提供的类，用于读取文件内容。它继承自InputStream，可以打开一个文件并从中读取字节数据。

**以下是FileInputStream类常用的方法：**

*  read()：读取单个字节的数据。
 *  read(byte\[\] b)：将最多b.length个字节的数据读入到字节数组b中。
 *  close()：关闭输入流。

### 总结： ###

MultipartFile用于处理上传的文件数据，HttpServletResponse用于向客户端发送HTTP响应，FileInputStream用于读取文件内容。它们在Java Web开发中起着重要的作用，能够处理文件上传、下载和读取等常见任务。希望以上内容对您有所帮助，如有任何疑问，请随时提问。

[da37fe73deba4657952f4bb9978b2dd0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/0f4462d845f742a1ab70423196b0af23.png
[c558559ece65492c812e2be745ee2b72.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/08c31bcfd0e24405a7795486f2afe450.png
[7c6eed701b124732a0689d0fe4646dab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/66ec44eee2fd4a3f8a479f99bea06a8f.png
[tarzan-navigation_ _-java]: https://gitee.com/taisan/tarzan-navigation