Java

Java 中使用 Jersey 实现上传文件（附加密和解密）

Posted by 暮夏有五 on 2019-04-09
Estimated Reading Time 9 Minutes
Words 1.8k In Total
Viewed Times

Jersey 简介

Jersey 是开源的 RESTful 框架，实现了 JAX-RS 规范，提供了更多的特性和工具， 可以进一步地简化 RESTful service 和 client 开发，与 Struts 类似，它同样可以和 Hibernate、Spring 框架整合。此处使用它实现文件上传功能。

引入依赖

在 pom.xml 中添加 Jersey 相关依赖

1
2
3
4
5
<dependency>
    <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-client</artifactId>
    <version>1.18.1</version>
</dependency>

然后创建一个名为 FileUtils 的文件工具类。

生成临时文件方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
   * MultipartFile 生成临时文件
   * @param multipartFile
   * @param tempFilePath 临时文件路径
   * @return File 临时文件
*/
public static File multipartFileToFile(MultipartFile multipartFile, String tempFilePath) {

    File file = new File(tempFilePath);
    // 获取文件原名
    String originalFilename = multipartFile.getOriginalFilename();
    // 获取文件后缀
    String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
    if (!file.exists()) {
        file.mkdirs();
    }
    // 创建临时文件
    File tempFile = new File(tempFilePath + "\\" + UUID.randomUUID().toString().replaceAll("-", "") + suffix);
    try {
        if (!tempFile.exists()) {
            // 写入临时文件
            multipartFile.transferTo(tempFile);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return tempFile;
}

加密 & 解密文件方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 加密 & 解密文件的密钥
public static final int CRYPTO_SECRET_KEY = 0x99;

/**
   * 加密 & 解密文件
   * @param srcFile 原文件
   * @param encFile 加密/解密后的文件
   * @return 加密/解密后的文件
   * @throws Exception
*/
public static File cryptoFile(File srcFile, File encFile) throws Exception {

    InputStream inputStream = new FileInputStream(srcFile);
    OutputStream outputStream = new FileOutputStream(encFile);
    while ((FILE_DATA = inputStream.read()) > -1) {
        outputStream.write(FILE_DATA ^ CRYPTO_SECRET_KEY);
    }
    inputStream.close();
    outputStream.flush();
    outputStream.close();
    return encFile;
}

上传文件方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
   * 上传文件
   * @param fileServerPath	文件服务器地址
   * @param folderPath    存放的文件夹路径（比如存放在文件服务器的 upload 文件夹下，即 ”/upload“）
   * @param uploadFile	需要上传的文件
   * @param isCrypto	是否加密
   * @return String	文件上传后的全路径
*/
public static String uploadByJersey(String fileServerPath, String folderPath, File uploadFile, boolean isCrypto) {

    String suffix = uploadFile.getName().substring(uploadFile.getName().lastIndexOf("."));
    String randomFileName = UUID.randomUUID().toString().replaceAll("-", "") + suffix;
    String fullPath = fileServerPath + folderPath + "/" + randomFileName;
    try {
        if (isCrypto) {
            // 创建待上传的文件
            File cryptoFile = new File(uploadFile.getPath().substring(0, uploadFile.getPath().lastIndexOf(".")) + "crypto" + uploadFile.getPath().substring(uploadFile.getPath().lastIndexOf(".")));
            // 执行加密并覆盖原文件
            uploadFile = cryptoFile(uploadFile, cryptoFile);
        }
        // 创建 Jersey 服务器
        Client client = Client.create();
        WebResource wr = client.resource(fullPath);
        // 上传文件
        wr.put(String.class, fileToByte(uploadFile));
    } catch (Exception e) {
        e.printStackTrace();
    }
    return fullPath;
}

下载文件方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/**
   * 下载文件
   * @param url   文件路径
   * @param filePath  文件保存路径
   * @param fileName  文件名称（包含文件后缀）
   * @param isCrypto  是否解密
   * @return File
*/
public static File downloadByURL(String url, String filePath, String fileName, boolean isCrypto) {

    File file = new File(filePath);
    if (!file.exists()) {
        file.mkdirs();
    }
    FileOutputStream fileOut;
    HttpURLConnection httpURLConnection;
    InputStream inputStream;
    try {
        URL httpUrl = new URL(url);
        httpURLConnection = (HttpURLConnection) httpUrl.openConnection();
        httpURLConnection.setDoInput(true);
        httpURLConnection.setDoOutput(true);
        httpURLConnection.setUseCaches(false);
        httpURLConnection.connect();
        inputStream = httpURLConnection.getInputStream();
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        if (!filePath.endsWith("\\")) {
            filePath += "\\";
        }
        file = new File(filePath + fileName);
        fileOut = new FileOutputStream(file);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOut);
        byte[] bytes = new byte[4096];
        int length = bufferedInputStream.read(bytes);
        //保存文件
        while (length != -1) {
            bufferedOutputStream.write(bytes, 0, length);
            length = bufferedInputStream.read(bytes);
        }
        bufferedOutputStream.close();
        bufferedInputStream.close();
        httpURLConnection.disconnect();
    } catch (Exception e) {
        e.printStackTrace();
    }
    if (isCrypto) {
        try {
            // 创建解密文件
            File cryptoFile = new File(((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest().getServletContext().getRealPath("/") +  "\\temp\\" + UUID.randomUUID().toString().replaceAll("-", "") + file.getName().substring(file.getName().lastIndexOf(".")));
            // 执行解密
            cryptoFile(file, cryptoFile);
            // 删除下载的原文件
            file.delete();
            // 保存解密后的文件
            file = cryptoFile;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return file;
}

删除文件方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
   * 删除文件服务器上的文件
   * @param url 文件路径
   * @return boolean
*/
public static boolean deleteByJersey(String url) {

    try {
        Client client = new Client();
        WebResource webResource = client.resource(url);
        webResource.delete();
        return true;
    } catch (UniformInterfaceException e) {
        e.printStackTrace();
    } catch (ClientHandlerException e) {
        e.printStackTrace();
    }
    return false;
}

完整工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientHandlerException;
import com.sun.jersey.api.client.UniformInterfaceException;
import com.sun.jersey.api.client.WebResource;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.UUID;

public class FileUtils {

    // 加密/解密文件的密钥
    public static final int CRYPTO_SECRET_KEY = 0x99;

    public static int FILE_DATA = 0;

    /**
     * 加密/解密 文件
     * @param srcFile 原文件
     * @param encFile 加密/解密后的文件
     * @throws Exception
     */
    public static void cryptoFile(File srcFile, File encFile) throws Exception {

        InputStream inputStream = new FileInputStream(srcFile);
        OutputStream outputStream = new FileOutputStream(encFile);
        while ((FILE_DATA = inputStream.read()) > -1) {
            outputStream.write(FILE_DATA ^ CRYPTO_SECRET_KEY);
        }
        inputStream.close();
        outputStream.flush();
        outputStream.close();
    }

    /**
     * MultipartFile 生成临时文件
     * @param multipartFile
     * @param tempFilePath 临时文件路径
     * @return File 临时文件
     */
    public static File multipartFileToFile(MultipartFile multipartFile, String tempFilePath) {

        File file = new File(tempFilePath);
        // 获取文件原名
        String originalFilename = multipartFile.getOriginalFilename();
        // 获取文件后缀
        String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
        if (!file.exists()) {
            file.mkdirs();
        }
        // 创建临时文件
        File tempFile = new File(tempFilePath + "\\" + UUID.randomUUID().toString().replaceAll("-", "") + suffix);
        try {
            if (!tempFile.exists()) {
                // 写入临时文件
                multipartFile.transferTo(tempFile);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return tempFile;
    }

    /**
     * 上传文件
     * @param fileServerPath	文件服务器地址
     * @param folderPath    存放的文件夹路径（比如存放在文件服务器的 upload 文件夹下，即 ”/upload“）
     * @param uploadFile	需要上传的文件
     * @param isCrypto	是否加密
     * @return String	文件上传后的全路径
     */
    public static String uploadByJersey(String fileServerPath, String folderPath, File uploadFile, boolean isCrypto) {

        String suffix = uploadFile.getName().substring(uploadFile.getName().lastIndexOf("."));
        String randomFileName = UUID.randomUUID().toString().replaceAll("-", "") + suffix;
        String fullPath = fileServerPath + folderPath + "/" + randomFileName;
        try {
            if (isCrypto) {
                // 创建加密文件
                File cryptoFile = new File(uploadFile.getPath().substring(0, uploadFile.getPath().lastIndexOf(".")) + "crypto" + uploadFile.getPath().substring(uploadFile.getPath().lastIndexOf(".")));
                // 执行加密
                cryptoFile(uploadFile, cryptoFile);
                // 保存加密后的文件
                uploadFile = cryptoFile;
            }
            // 创建 Jersey 服务器
            Client client = Client.create();
            WebResource wr = client.resource(fullPath);
            // 上传文件
            wr.put(String.class, fileToByte(uploadFile));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return fullPath;
    }

    /**
     * 下载文件
     * @param url   文件路径
     * @param filePath  文件保存路径
     * @param fileName	文件名称（包含文件后缀）
     * @param isCrypto  是否解密
     * @return File
     */
    public static File downloadByURL(String url, String filePath, String fileName, boolean isCrypto) {

        File file = new File(filePath);
        if (!file.exists()) {
            file.mkdirs();
        }
        FileOutputStream fileOut;
        HttpURLConnection httpURLConnection;
        InputStream inputStream;
        try {
            URL httpUrl = new URL(url);
            httpURLConnection = (HttpURLConnection) httpUrl.openConnection();
            httpURLConnection.setDoInput(true);
            httpURLConnection.setDoOutput(true);
            httpURLConnection.setUseCaches(false);
            httpURLConnection.connect();
            inputStream = httpURLConnection.getInputStream();
            BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
            if (!filePath.endsWith("\\")) {
                filePath += "\\";
            }
            file = new File(filePath + fileName);
            fileOut = new FileOutputStream(file);
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOut);
            byte[] bytes = new byte[4096];
            int length = bufferedInputStream.read(bytes);
            //保存文件
            while (length != -1) {
                bufferedOutputStream.write(bytes, 0, length);
                length = bufferedInputStream.read(bytes);
            }
            bufferedOutputStream.close();
            bufferedInputStream.close();
            httpURLConnection.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (isCrypto) {
            try {
                // 创建解密文件
                File cryptoFile = new File(((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest().getServletContext().getRealPath("/") +  "\\temp\\" + UUID.randomUUID().toString().replaceAll("-", "") + file.getName().substring(file.getName().lastIndexOf(".")));
                // 执行解密
                cryptoFile(file, cryptoFile);
                // 删除下载的原文件
                file.delete();
                // 保存解密后的文件
                file = cryptoFile;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return file;
    }

    /**
     * 删除文件服务器上的文件
     * @param url 文件路径
     * @return boolean
     */
    public static boolean deleteByJersey(String url) {

        try {
            Client client = new Client();
            WebResource webResource = client.resource(url);
            webResource.delete();
            return true;
        } catch (UniformInterfaceException e) {
            e.printStackTrace();
        } catch (ClientHandlerException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * File转Bytes
     * @param file
     * @return byte[]
     */
    public static byte[] fileToByte(File file) {

        byte[] buffer = null;
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bytes = new byte[1024];
            int n;
            while ((n = fileInputStream.read(bytes)) != -1) {
                byteArrayOutputStream.write(bytes, 0, n);
            }
            fileInputStream.close();
            byteArrayOutputStream.close();
            buffer = byteArrayOutputStream.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return buffer;
    }
}

测试上传

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
 * @param multipartFile 上传文件
 * @param isCrypto 是否加密文件
 * @return
 */
@Test
public String upload(MultipartFile multipartFile, boolean isCrypto) {

    HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    // 生成临时文件
    File tempFile = FileUtil.multipartFileToFile(multipartFile, request.getServletContext().getRealPath("/") + "\\static\\temp");
    // 上传文件并返回文件路径
    String uploadFilePath = FileUtil.uploadByJersey("http://localhost:8080", "/upload", tempFile, isCrypto);
    if (uploadFilePath != null) {
        return "上传成功";
    }
    else {
        return "上传失败";
    }
}

If you like this blog or find it useful for you, you are welcome to comment on it. You are also welcome to share this blog, so that more people can participate in it. If the images used in the blog infringe your copyright, please contact the author to delete them. Thank you !

FEATURED TAGS
Java
FRIENDS
ESC