restful传输大文件解决方案

因为对文件传输大文件没有去研究过，就自己思考了一种实现方式，这种方式不是最优解但是呢可以实现效果，就记录了下来

1.利用restful传输json数据方式，把文件分多次专为byte数组传输（restful传输json这里就不说了）
2.接受端利用文件断点续传方式，在文件末尾添加文件数据

客户端发送文件

public FileDom sendFile(String transferId, File tempFile) throws IOException {
        String fileName = tempFile.getName();
        String suffix = tempFile.getName().substring(tempFile.getName().lastIndexOf("."));
        FileDom fileDom = new FileDom();
        fileDom.setName("send_" + transferId + suffix);
        fileDom.setExt(suffix);
        fileDom.setTransferId(transferId);
        RandomAccessFile rad = null;
        if (tempFile.exists()) {
            try {
                rad = new RandomAccessFile(tempFile, "r");
                //从文件指定位置开始传输
                rad.seek(0);
                byte[] buf = new byte[1024];
                long longth = 0;
                while ((longth = rad.read(buf)) > 0) {
                    fileDom.setCurrentData(buf);
                    Result<Integer> resStatus = restFulService.getDataSys(Integer.class, "/pdf/resiveFile", fileDom);
                    if (resStatus.getData() != 1) {
                        return null;
                    }
                }
            } finally {
                if (rad != null) {
                    rad.close();
                }
            }
        }
        return fileDom;
    }

服务器接收端

@RestController
@RequestMapping(value = "/pdf")
public class PdfControllerServer {
    @Autowired
    PdfServiceServer pdfServiceServer;

    @ResponseBody
    @RequestMapping("/resiveFile")
    public Result<Integer> resiveFile(@RequestBody FileDom fileDom) {
        return Result.successfulResult("接受转换文件成功", pdfServiceServer.saveFile(fileDom));
    }
}

/**处理接受的service*/
public Integer saveFile(FileDom fileDom) {
        String fileName = PdfUtil.getServerTempFilePath() + File.separator + fileDom.getName();
        String suffix = fileDom.getExt();
        File saveFile = new File(fileName);
        RandomAccessFile rad = null;
        try {
            rad = new RandomAccessFile(saveFile, "rw");
            // 将指针移动到文件末尾
            rad.seek(rad.length());
            rad.write(fileDom.getCurrentData());
            System.out.println("接受:" + fileDom.getCurrentData().length);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (rad != null) {
                try {
                    rad.close(); // 关闭文件流
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return 1;
    }

后来百度了下，restful通过配置可以实现大文件传输，不会导致内存溢出，为了不枉费这一思考就记录下

restful转json：

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        //请求工厂类是否应用缓冲请求正文内部，默认值为true，
        // 当post或者put大文件的时候会造成内存溢出情况，设置为false将数据直接流入底层HttpURLConnection。
        factory.setBufferRequestBody(false);
        factory.setConnectTimeout(150000);
        factory.setReadTimeout(150000);
        RestTemplate rest = new RestTemplate(factory);
        return rest;
    }

    @Bean
    public MultipartConfigElement multipartConfigElement() {
        MultipartConfigFactory factory = new MultipartConfigFactory();
        //  单个数据大小
        factory.setMaxFileSize(DataSize.ofGigabytes(2));
        /// 总上传数据大小
        factory.setMaxRequestSize(DataSize.ofGigabytes(2));
        return factory.createMultipartConfig();
    }
}
@Configuration
public class RestTemplateDefine {
    @Autowired
    RestTemplate restTemplate;

    /**
     * get根据url获取对象
     */
    public String get(String url) {
        return restTemplate.getForObject(url, String.class,
                new Object[]{});
    }

    /**
     * post提交对象
     */
    public String post(String url, String data) {
        return restTemplate.postForObject(url, null,
                String.class, data);
    }

    /**
     * 发送post请求
     *
     * @param url   请求URL地址
     * @param data  json数据
     * @param token
     */
    public String post(String url, String data, String token)
            throws Exception {
        HttpHeaders headers = new HttpHeaders();
        headers.add("Accept", "application/json");
        headers.add("Accpet-Encoding", "gzip");
        headers.add("Content-Encoding", "UTF-8");
        headers.add("Content-Type", "application/json; charset=UTF-8");
        headers.add("Token", token);

        HttpEntity<String> formEntity = new HttpEntity<String>(data, headers);

        return restTemplate.postForObject(url, formEntity, String.class);
    }

}
@Configuration
public class RestFulService {
    @Value("${dataSysUrl:null}")
    String dataSysUrl;

    @Autowired
    RestTemplateDefine restTemplateDefine;

    public <T> Result<T> getDataSys(Class<T> clzz, String methodStr, Object parma) {
        String requestJson = null;
        String rst = null;
        try {
            requestJson = JSONObject.toJSONString(parma);
            String url = dataSysUrl;
            url += methodStr;
            rst = restTemplateDefine.post(url, requestJson, null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Result<T> result = JSONObject.parseObject(rst, new TypeReference<Result<T>>() {
        });
        if (result.getData() instanceof JSONArray) {
            List<T> list = JSONObject.parseArray(result.getData().toString(), clzz);
            result.setData((T) list);
        } else if (result.getData() instanceof JSONObject) {
            T obj = JSONObject.parseObject(result.getData().toString(), clzz);
            result.setData(obj);
        }
        return result;
    }
}