SpringBoot实现多文件上传+http请求转发(base64的方式)

需求：用户端访服务器A，拿到请求数据后，将数据传送到B服务器上去进行业务的实现；请求数据包含普通参数和文件数组。

话不多说直接上代码

服务器A：

/**
   * 获取自动转换后的JavaBean对象
   *
   * @param clazz
   * @param <T>
   * @return
   */
public class Convert implements Serializable {
    public <T> T convert(Class<T> clazz) {
        return BeanConverter.convert(clazz, this);
    }
}

public class AddCommentParam extends Convert {
    private Integer recordId;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date recordTime;
    private String content;
    private MultipartFile[] file;
    private List<Long> userIds;
}

public class AddCommentPlatParam  extends Convert {
    private Integer recordId;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date recordTime;
    private String content;
    private List<Base64File> files;
    private List<Long> userIds;
}

HttpUtils的工具类

package com.hbte.sharp.util;

import com.alibaba.fastjson.JSONObject;
import com.hbte.sharp.exception.ServiceException;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ObjectUtils;

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

public class HttpUtils {
    protected static Logger logger = LoggerFactory.getLogger(HttpUtils.class);
    private static final int SOCKET_TIME_OUT = 60000;
    private static final int CONNECT_TIME_OUT = 60000;


    public static JSONObject doGet(String url, String toekn, Map<String, Object> paramMap) {
        //创建 CloseableHttpClient
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String result = null;
        try {
            URIBuilder uri = new URIBuilder(url);
            //get请求带参数
            List<NameValuePair> list = new LinkedList<>();
            Iterator<Map.Entry<String, Object>> iterator = paramMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Object> entry = iterator.next();
                BasicNameValuePair param = new BasicNameValuePair(entry.getKey(), ObjectUtils.isEmpty(entry.getValue()) ? null : entry.getValue().toString());
                list.add(param);
            }
            uri.setParameters(list);
            HttpGet httpGet = new HttpGet(uri.build());
            //设置请求状态参数
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectionRequestTimeout(3000)
                    .setSocketTimeout(3000)
                    .setConnectTimeout(3000)
                    .build();
            httpGet.setConfig(requestConfig);
            httpGet.setHeader("Authorization", toekn);
            response = httpClient.execute(httpGet);
            int status = response.getStatusLine().getStatusCode();//获取返回状态值
            if (status == HttpStatus.SC_OK) {//请求成功
                HttpEntity httpEntity = response.getEntity();
                if (httpEntity != null) {
                    result = EntityUtils.toString(httpEntity, "UTF-8");
                    EntityUtils.consume(httpEntity);//关闭资源
                    JSONObject jsonResult = JSONObject.parseObject(result);
                    return jsonResult;
                }
            } else {
                throw new ServiceException("系统异常");
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ServiceException("系统异常");
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    throw new ServiceException("系统异常");
                }
            }
            if (httpClient != null) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    throw new ServiceException("系统异常");
                }
            }
        }
        return null;
    }

    public static JSONObject doPost(String url, JSONObject param, Map<String, Object> headers) throws Exception {
        //目前HttpClient最新版的实现类为CloseableHttpClient
        CloseableHttpClient client = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        HttpEntity entity = null;
        try {
            if (param != null) {
                //建立Request的对象，一般用目标url来构造，Request一般配置addHeader、setEntity、setConfig
                HttpPost req = new HttpPost(url);
                logger.debug("请求地址："+url);
                entity = new StringEntity(param.toJSONString(), ContentType.APPLICATION_JSON);
                //setHeader,添加头文件
                Set<String> keys = headers.keySet();
                for (String key : keys) {
                    req.setHeader(key, headers.get(key).toString());
                }
                //setConfig,添加配置,如设置请求超时时间,连接超时时间
                RequestConfig reqConfig = RequestConfig.custom().setSocketTimeout(SOCKET_TIME_OUT).setConnectTimeout(CONNECT_TIME_OUT).build();
                req.setConfig(reqConfig);
                //setEntity,添加内容
                req.setEntity(entity);
                //执行Request请求,CloseableHttpClient的execute方法返回的response都是CloseableHttpResponse类型
                //其常用方法有getFirstHeader(String)、getLastHeader(String)、headerIterator（String）取得某个Header name对应的迭代器、getAllHeaders()、getEntity、getStatus等
                response = client.execute(req);
                entity = response.getEntity();
                //用EntityUtils.toString()这个静态方法将HttpEntity转换成字符串,防止服务器返回的数据带有中文,所以在转换的时候将字符集指定成utf-8就可以了
                String result = EntityUtils.toString(entity, "UTF-8");
                logger.debug("-------------------------" + result + "-------------");
                if (response.getStatusLine().getStatusCode() == 200) {
                    logger.debug(result + "-----------success------------------");
                    return JSONObject.parseObject(result);
                } else {
                    logger.debug(response.getStatusLine().getStatusCode() + "------------------fail-----------");
                    throw new ServiceException("系统异常");
                }
            }
            return null;
        } catch (Exception e) {
            logger.error("--------------------------post error: ", e);
            throw new ServiceException("系统异常");
        } finally {
            //一定要记得把entity fully consume掉，否则连接池中的connection就会一直处于占用状态
            EntityUtils.consume(entity);
        }
    }

    private static List<NameValuePair> createParam(Map<String, Object> param) {
        //建立一个NameValuePair数组，用于存储欲传送的参数
        List<NameValuePair> nvps = new ArrayList<NameValuePair>();
        if (param != null) {
            for (String k : param.keySet()) {
                nvps.add(new BasicNameValuePair(k, param.get(k).toString()));
            }
        }
        return nvps;
    }
}

 主代码

@PostMapping("/aTest")
public JSONObject aTest(AddCommentParam param) throws Exception {
    if (null == param.getContent()){
        throw new ServiceException("内容不能为空"); //参数校验
    }

    Map<String, Object> headers = new HashMap<>();
    headers.put("AUTHORIZATION", request.getHeader(AUTHORIZATION)); //请求头

    AddCommentPlatParam param1 = param.convert(AddCommentPlatParam.class);
    param1.setFiles(getByte(param.getFile())); //base64转换

    return HttpUtils.doPost("服务器B的地址" + "/addComment", (JSONObject) JSONObject.toJSON(param1), headers);
}

服务器B：

@PostMapping("/addComment")
public Boolean addComment(AddCommentPlatParam param) throws IOException {
    //参数校验
    AddCommentParam param1 = new AddCommentParam();
    if(param.getFiles()!=null && param.getFiles().size()>0){
        MultipartFile[] file = new MultipartFile[param.getFiles().size()];
        for (int i=0;i<param.getFiles().size();i++){
            file[i]= DragonBase64.fileBase64ToMultipartFile(param.getFiles().get(i));
        }
        param1.setFile(file);
    }
    param1.setContent(param.getContent());
    param1.setRecordId(param.getRecordId());
    param1.setRecordTime(param.getRecordTime());
    param1.setUserIds(param.getUserIds());
    //业务处理;
    return true;
}