【业务功能篇41】调用分布式文件系统FastDFS系统服务-文件上传下载

逃离我推掉我的手 2024-03-17 15:25 20阅读 0赞

> 业务场景： 用户需要上传文件，那么随着文件量增多，我们需要借助一些分布式框架的文件系统，这里我们调用了其他工程系统，提供了FastDFS的相关接口，这里主要是记录，我们调用接口封装成的服务接口

### controller层 ###

package com.service;
    
    import com.delegate.CommonFileServiceDelegate;
    import org.springframework.web.bind.annotation.*;
    import com.model.CommonFileParam;
    import org.springframework.validation.annotation.Validated;
    import com.tools.commonlib.exception.ServiceException;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.multipart.MultipartFile;
    import javax.servlet.http.HttpServletResponse;
    import com.model.ResponseVo;
    
    
    
    @RestController
    @RequestMapping(value = "/commonFile", produces = {"application/json;charset=UTF-8"})
    @Validated
    public class CommonFileServiceController {
    
        @Autowired(required=false) 
        private CommonFileServiceDelegate delegate;  
    	
        @RequestMapping(
        		value = "/deleteFile", 
        		produces = { "application/json" }, 
        		method = RequestMethod.POST)
        public ResponseVo deleteFile(@RequestBody CommonFileParam queryParam) 
                throws ServiceException {
        	    
    		return delegate.deleteFile(queryParam);
        }
    
    	
        @RequestMapping(
        		value = "/downloadFile", 
        		produces = { "application/octet-stream" }, 
        		method = RequestMethod.POST)
        public void downloadFile(HttpServletResponse response, @RequestBody CommonFileParam queryParam) 
                throws ServiceException {
        	    
    		
    		delegate.downloadFile(response, queryParam);
    		
        }
    
    	
        @RequestMapping(
        		value = "/downloadFileByAttrId", 
        		produces = { "application/octet-stream" }, 
        		method = RequestMethod.POST)
        public void downloadFileByAttrId(HttpServletResponse response, @RequestBody CommonFileParam queryParam) 
                throws ServiceException {
        	    
    		
    		delegate.downloadFileByAttrId(response, queryParam);
    		
        }
    
    	
        @RequestMapping(
        		value = "/findFile", 
        		produces = { "application/json" }, 
        		method = RequestMethod.POST)
        public ResponseVo findFile(@RequestBody CommonFileParam queryParam) 
                throws ServiceException {
        	    
    		return delegate.findFile(queryParam);
        }
    
    	
        @RequestMapping(
        		value = "/uploadFile", 
        		produces = { "application/json" }, 
        		method = RequestMethod.POST)
        public ResponseVo uploadFile(  
    		@RequestPart(value="file", required=false) MultipartFile file,
        		 @RequestParam(value = "attrId", required = false) String attrId,
        		 @RequestParam(value = "functionName", required = false) String functionName) 
                throws ServiceException {
        	    
    		return delegate.uploadFile(file
    			, attrId
    			, functionName);
        }
    }

###  ###

### Service层 接口 ###

package com.delegate;
    
    import org.springframework.web.multipart.MultipartFile;
    import javax.servlet.http.HttpServletResponse;
    import com.model.ResponseVo;
    import com.exception.ServiceException;
    import com.model.CommonFileParam;
    
    
    
    public interface CommonFileServiceDelegate {
      
        ResponseVo deleteFile(CommonFileParam queryParam) 
        	throws ServiceException;
      
        void downloadFile(HttpServletResponse response, CommonFileParam queryParam) 
        	throws ServiceException;
      
        void downloadFileByAttrId(HttpServletResponse response, CommonFileParam queryParam) 
        	throws ServiceException;
      
        ResponseVo findFile(CommonFileParam queryParam) 
        	throws ServiceException;
      
        ResponseVo uploadFile( MultipartFile file,
                         String attrId,
                         String functionName) 
        	throws ServiceException;
      
    }

###  ###

### Service层 接口 实现类 ###

package com.impl;
    
    import com.domain.model.QualityCommonAttrT;
    import com.delegate.CommonFileServiceDelegate;
    import com.model.CommonFile;
    import com.model.CommonFileParam;
    import com.model.ResponseVo;
    import com.service.dao.mapper.QualityCommonAttrMapper;
    import com.utils.FastDfsUrl;
    import com.utils.FastDfsUtil;
    import com.utils.ResponseUtils;
    
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
    
    import lombok.extern.slf4j.Slf4j;
    
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.BufferedOutputStream;
    import java.io.IOException;
    import java.net.URLEncoder;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Locale;
    import java.util.stream.Collectors;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletResponse;
    
    /**
     * 公共文件上传下载服务类
     *
     */
    @Slf4j
    @Component
    public class CommonFileServiceDelegateImpl implements CommonFileServiceDelegate, FastDfsUrl {
    
        @Resource
        FastDfsUtil fastDfsUtil;
    
        @Autowired
        QualityCommonAttrMapper tMapper;
    
        @Value("${fastFileUrl}")
        private String fastFileUrl;
    
        /**
         * 删除文件
         *
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo deleteFile(CommonFileParam queryParam) {
            ResponseVo responseVo = new ResponseVo();
            // 删除远程服务器文件
            String result = fastDfsUtil.delete(queryParam.getFilePath());
            // 删除数据库保存文件信息数据
            tMapper.deleteFile(queryParam);
            responseVo.setMessage(result);
            return responseVo;
        }
    
        /**
         * 文件下载
         *
         * @param response response
         * @param commonFileParam commonFileParam
         */
        @Override
        public void downloadFile(HttpServletResponse response, CommonFileParam commonFileParam) {
            try {
                response.setCharacterEncoding("UTF-8");
                response.addHeader("Content-Disposition",
                    "attachment;filename=" + URLEncoder.encode(commonFileParam.getFileName(), "UTF-8"));
                response.setContentType("application/octet-stream;charset=UTF-8");
                fastDfsUtil.download(commonFileParam.getFileName(), commonFileParam.getFilePath(),
                    new BufferedOutputStream(response.getOutputStream()));
            } catch (IOException e) {
                log.error(e.toString());
            }
        }
    
    
        /**
         * downloadFileByAttrId
         * 
         * @param response response
         * @param queryParam queryParam
         */
        @Override
        public void downloadFileByAttrId(HttpServletResponse response, CommonFileParam queryParam) {
            try {
                QueryWrapper<QualityCommonAttrT> queryWrapper = new QueryWrapper<>();
                queryWrapper.lambda()
                    .eq(QualityCommonAttrT::getAttrid, queryParam.getAttrId())
                    .eq(QualityCommonAttrT::getFunctionname, queryParam.getFunctionName());
                QualityCommonAttrT commonFileParam = tMapper.selectOne(queryWrapper);
                response.setCharacterEncoding("UTF-8");
                response.addHeader("Content-Disposition",
                    "attachment;filename=" + URLEncoder.encode(commonFileParam.getFilename(), "UTF-8"));
                response.setContentType("application/octet-stream;charset=UTF-8");
                fastDfsUtil.download(commonFileParam.getFilename(), commonFileParam.getFilepath(),
                    new BufferedOutputStream(response.getOutputStream()));
            } catch (IOException e) {
                log.error(e.toString());
            }
        }
    
        /**
         * 单个文件上传
         *
         * @param file file
         * @param attrId attrId
         * @param functionName functionName
         * @return ResponseVo
         */
        @Override
        public ResponseVo uploadFile(MultipartFile file, String attrId, String functionName) {
            ResponseVo responseVo = new ResponseVo();
            // 调用上传方法，返回文件上传路径
            String result = fastDfsUtil.uploadFile(file);
            if (!StringUtils.isBlank(result)) {
                // 设置文件对象属性
                QualityCommonAttrT qualityCommonAttr = new QualityCommonAttrT();
                // 截取文件路径
                String fileUrl = result.split("fileUrl=")[1];
                if (fileUrl.contains("&")) {
                    fileUrl = fileUrl.split("&")[0];
                }
                qualityCommonAttr.setId(tMapper.getId());
                qualityCommonAttr.setFilename(file.getOriginalFilename());
                qualityCommonAttr.setFilesize(file.getSize());
                qualityCommonAttr.setFilepath(fileUrl);
                qualityCommonAttr.setAttrid(attrId);
                qualityCommonAttr.setFunctionname(functionName);
                // 获取上传文件是否为图片，如果不是图片返回"null"
                String mimeType = result.split("mimeType=")[1];
                String downloadFilePath = "";
                if ("null".equals(mimeType)) {
                    downloadFilePath = fastFileUrl.concat(
                        FILE_DOWNLOAD_STREAM_URL + "fileName=" + file.getOriginalFilename()).concat("&fileUrl=" + fileUrl);
                } else {
                    qualityCommonAttr.setMimetype(mimeType);
                    downloadFilePath = fastFileUrl.concat(FILE_DOWNLOAD_FILE_URL + "fileName=" + file.getOriginalFilename())
                        .concat("&fileUrl=" + fileUrl)
                        .concat("&mimeType=" + mimeType);
                }
                // 拼接文件下载路径，返回前端，图片上传后可以显示
                qualityCommonAttr.setDownloadfilepath(downloadFilePath);
                // 保存文件对象
                List<QualityCommonAttrT> list = new ArrayList<QualityCommonAttrT>();
                list.add(qualityCommonAttr);
                tMapper.insertCommonAttr(list);
                responseVo.setData(qualityCommonAttr);
            }
            return responseVo;
        }
    
        /**
         * 查询附件信息
         *
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo findFile(CommonFileParam queryParam) {
            List<QualityCommonAttrT> list = tMapper.findFile(queryParam);
            return ResponseUtils.successResponse(list, "");
        }
    
    
        /**
         * getFileList
         * 
         * @param attrId attrId
         * @param functionName functionName
         * @return List<CommonFile>
         */
        public List<CommonFile> getFileList(String attrId, String functionName) {
            return new LambdaQueryChainWrapper<>(tMapper).eq(QualityCommonAttrT::getAttrid, attrId)
                .eq(QualityCommonAttrT::getFunctionname, functionName)
                .list()
                .stream()
                .map(this::convertFile)
                .collect(Collectors.toList());
        }
    
    
        /**
         * convertFile
         * 
         * @param commonAttrT commonAttrT
         * @return CommonFile
         */
        private CommonFile convertFile(QualityCommonAttrT commonAttrT) {
            CommonFile file = new CommonFile();
            file.setId(commonAttrT.getId());
            file.setName(commonAttrT.getFilename());
            file.setDocumentPath(commonAttrT.getFilepath());
            file.setDownloadFilePath(commonAttrT.getDownloadfilepath());
            file.setDocId(commonAttrT.getDocId());
            String[] fileNameList = commonAttrT.getFilename().toLowerCase(Locale.ROOT).split("\\.");
            file.setIsImage(
                fileNameList.length > 0 && fileNameList[fileNameList.length - 1].matches("png|jpg|jpeg|bmp|gif|pdf"));
            return file;
        }
    }

###  ###

### dao层 mapper接口 ###

package com.service.dao.mapper;
    
    import com.qualitybigdata.model.CommonFileParam;
    import com.domain.model.QualityCommonAttrT;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    
    import java.util.List;
    
    /**
     * QualityCommonAttrTMapper
     *
     */
    @Mapper
    public interface QualityCommonAttrMapper extends BaseMapper<QualityCommonAttrT> {
    
    
        /**
         * insertCommonAttr
         * 
         * @param list list
         */
        void insertCommonAttr(List<QualityCommonAttrT> list);
    
    
        /**
         * findFile
         * 
         * @param queryParam queryParam
         * @return List<QualityCommonAttrT>
         */
        List<QualityCommonAttrT> findFile(CommonFileParam queryParam);
    
    
        /**
         * deleteFile
         * 
         * @param queryParam queryParam
         */
        void deleteFile(CommonFileParam queryParam);
    
    
        /**
         * getId
         * 
         * @return int
         */
        int getId();
    
    
    
        /**
         * getAttachmentDetail
         * 
         * @param docId docId
         * @return QualityCommonAttrT
         */
        QualityCommonAttrT getAttachmentDetail(@Param("docId") String docId);
    
    }

###  ###

### dao层 xml映射 ###

<?xml version="1.0" encoding="UTF-8"?>
    
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.service.dao.mapper.QualityCommonAttrMapper">
    
    
    
       
    
        <insert id="insertCommonAttr">
            insert into quality_common_attr_t
                (
                 id,
                 attrid,
                 filename,
                 filepath,
                 filesize,
                 functionname,
                 mimetype,
                 downloadfilepath
                )
            values
            <foreach collection="list" item="item" separator=",">
                (
                 #{item.id},
                 #{item.attrid},
                 #{item.filename},
                 #{item.filepath},
                 #{item.filesize},
                 #{item.functionname},
                 #{item.mimetype},
                 #{item.downloadfilepath}
                )
            </foreach>
        </insert>
    
        <select id="findFile" resultType="com.domain.model.QualityCommonAttrT">
            select id,
                   attrid,
                   filename,
                   filepath,
                   filesize,
                   functionname,
                   mimetype,
                   downloadfilepath
                from quality_common_attr_t
                where attrid = #{attrId}
            <if test = "functionName != null" >
                and functionname = #{functionName}
            </if>
        </select>
    
        <delete id="deleteFile">
            delete from quality_common_attr_t where id = #{id}
        </delete>
    
        <select id="getId" flushCache="true" resultType="int">
            select NEXTVAL('COMMON_S')
        </select>
    
    
        <select id="getAttachmentDetail" resultType="com.domain.model.QualityCommonAttrT">
            select
                   t.id as id,
                   t.attrid as attrId,
                   t.filename as fileName,
                   t.filepath as filePath,
                   t.filesize as fileSize,
                   t.functionname as functionName,
                   t.mimetype as mimeType,
                   t.downloadfilepath as downloadFilePath,
                   t.docid as docId,
                   t.version as version,
                   t.userid as userId,
                   t.uploadtime as uploadTime
            from
                quality_common_attr_t t
            where
                t.docid = #{docId}
        </select>
    
    
    
    
    </mapper>

###  ###

### 附件记录表 实体类 ###

package com.domain.model;
    
    import java.io.Serializable;
    import com.baomidou.mybatisplus.annotation.TableName;
    import com.baomidou.mybatisplus.annotation.TableId;
    import com.baomidou.mybatisplus.annotation.TableField;
    import lombok.NoArgsConstructor;
    import lombok.Data;
    import lombok.EqualsAndHashCode;
    import lombok.experimental.Accessors;
    
    /**
     * QualityCommonAttrT
     * 
     */
    @Data
    @EqualsAndHashCode(callSuper = false)
    @Accessors(chain = true)
    @NoArgsConstructor
    @TableName("common_attr_t")
    public class QualityCommonAttrT implements Serializable {
    
        private static final long serialVersionUID = 1L;
    
        @TableField("id")
        private Integer id;
    
        @TableField("attrid")
        private String attrid;
    
        @TableField("filename")
        private String filename;
    
        @TableField("filepath")
        private String filepath;
    
        @TableField("filesize")
        private Long filesize;
    
        @TableField("functionname")
        private String functionname;
    
        @TableField("mimetype")
        private String mimetype;
    
        @TableField("downloadfilepath")
        private String downloadfilepath;
    
        @TableField("docid")
        private String docId;
    
        @TableField("version")
        private String version;
    
        @TableField("userid")
        private String userId;
    
        @TableField("uploadtime")
        private String uploadTime;
    
    
    
    }

### Service层 接口 ###

package com.utils;
    
    /**
     * FastDfs路径集合
     *
     */
    public interface FastDfsUrl {
    
        /**
         * 上传文件路径
         *
         */
        String FILE_UPLOAD_FILE_URL = "/uploadFile";
    
    
        /**
         * 文件删除路径
         *
         */
        String FILE_DELETE_URL = "/delete";
    
        /**
         * 图片文件下载路径
         *
         */
        String FILE_DOWNLOAD_FILE_URL = "/download?";
    
        /**
         * 文件下载路径
         *
         */
        String FILE_DOWNLOAD_STREAM_URL = "/download/stream?";
    }

### Service层 接口实现类 ###

>     @Value("${fastFileUrl}")   配置变量值 在配置文件中对应的值进行赋值变量
> 
> application-prod.xml中：
> 
>     fastFileUrl: https://xxx.com/fastdfs

package com.utils;
    
    import com.config.RestTemplateConfig;
    import lombok.Data;
    import lombok.extern.slf4j.Slf4j;
    
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.core.io.ByteArrayResource;
    import org.springframework.http.HttpEntity;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpMethod;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.MediaType;
    import org.springframework.http.ResponseEntity;
    import org.springframework.http.converter.ByteArrayHttpMessageConverter;
    import org.springframework.stereotype.Service;
    import org.springframework.util.LinkedMultiValueMap;
    import org.springframework.util.MultiValueMap;
    import org.springframework.web.client.RestTemplate;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Objects;
    
    /**
     * FastDFS微服务调用接口类
     *
     */
    @Slf4j
    @Data
    @Service
    public class FastDfsUtil implements FastDfsUrl {
    
        @Autowired
        private RestTemplateConfig restTemplateService;
    
        @Value("${fastFileUrl}")
        private String fastFileUrl;
    
    
        /**
         * 上传文件
         *
         * @param file 文件
         * @return fileUrl 文件在FastDFS文件系统上的路径，需要在数据库中保存，后续调用删除、下载接口时传入
         */
        public String uploadFile(MultipartFile file) {
            try {
                String fileName = file.getOriginalFilename();
                if (StringUtils.isBlank(fileName)) {
                    fileName = file.getName();
                }
                return this.doUploadFile(file.getInputStream(), fileName);
            } catch (IOException e) {
                log.error("uploadFile", e);
            }
            return "";
        }
    
    
    
        /**
         * doUploadFile
         * 
         * @param is is
         * @param fileName fileName
         * @return String
         * @throws IOException IOException
         */
        private String doUploadFile(InputStream is, String fileName) throws IOException {
            RestTemplate restTemplate = restTemplateService.restTemplateSsl();
            HttpHeaders headers = new HttpHeaders();
            headers.setAccept(Collections.singletonList(MediaType.TEXT_PLAIN));
            headers.setContentType(MediaType.MULTIPART_FORM_DATA);
            LinkedMultiValueMap<String, Object> data = new LinkedMultiValueMap<>();
            byte[] content = new byte[is.available()];
            is.read(content);
            ByteArrayResource resource = new ByteArrayResource(content) {
                @Override
                public String getFilename() {
                    return fileName;
                }
            };
            data.add("file", resource);
            HttpEntity<MultiValueMap<String, Object>> request = new HttpEntity<>(data, headers);
            //文件上传路径
            String uploadFileUrl = fastFileUrl.concat(FILE_UPLOAD_FILE_URL);
            ResponseEntity<String> responseEntity = restTemplate.postForEntity(uploadFileUrl,request,String.class);
            String body = responseEntity.getBody();
            log.info("upload file success:{}", body);
            return body;
        }
    
        /**
         * 下载
         *
         * @param fileName     导出文件名
         * @param fileUrl      导出的文件地址
         * @param outputStream 导出流
         * @return boolean
         */
        public boolean download(String fileName, String fileUrl, OutputStream outputStream) {
            RestTemplate restTemplateService1 = restTemplateService.restTemplateSsl();
            Map<String, String> uriVariables = new HashMap<>();
            uriVariables.put("fileName", fileName);
            uriVariables.put("fileUrl", fileUrl);
    
            HttpHeaders headers = new HttpHeaders();
            headers.setAccept(Collections.singletonList(MediaType.APPLICATION_OCTET_STREAM));
            HttpEntity<String> entity = new HttpEntity<>(headers);
            String downloadFileUrl = fastFileUrl.concat(FILE_DOWNLOAD_STREAM_URL);
            String uri =downloadFileUrl.concat("fileName="+fileName).concat("&fileUrl="+fileUrl);
            RestTemplate restTemplate = new RestTemplate();
            restTemplate.getMessageConverters().add(new ByteArrayHttpMessageConverter());
            ResponseEntity<byte[]> responseEntity = restTemplateService1.exchange(uri, HttpMethod.GET, entity,
                    byte[].class);
            if (responseEntity.getStatusCode().equals(HttpStatus.OK)) {
                try {
                    log.info("download file success:{}", responseEntity.getBody());
                    IOUtils.write(responseEntity.getBody(), outputStream);
                    return true;
                } catch (IOException e) {
                    log.error("", e);
                } finally {
                    IOUtils.closeQuietly(outputStream);
                }
            }
            return false;
        }
    
        /**
         * 删除文件
         *
         * @param fileUrl 在FastDFS文件系统上的路径，由upload接口返回
         * @return 执行结果，成功时返回：delete success
         */
        public String delete(String fileUrl) {
            RestTemplate restTemplateService1 = restTemplateService.restTemplateSsl();
            HttpHeaders headers = new HttpHeaders();
            headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON_UTF8));
    
            MultiValueMap<String, String> paramMap = new LinkedMultiValueMap<>();
            paramMap.add("fileUrl", fileUrl);
    
            HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(paramMap, headers);
            String deleteFileUrl = fastFileUrl.concat(FILE_DELETE_URL);
            ResponseEntity<Map> responseEntity = restTemplateService1.postForEntity(deleteFileUrl, request, Map.class);
    
            if (responseEntity.getStatusCode().equals(HttpStatus.OK)) {
                Object result = Objects.requireNonNull(responseEntity.getBody()).get("message");
                String resultStr = "";
                if (result != null) {
                    resultStr = result.toString();
                }
                log.info("delete {} result is {}", fileUrl, resultStr);
                return resultStr;
            }
    
            log.error("file delete error {}", fileUrl);
            return "call service error";
        }
    
    
    }

### 请求配置类 ###

package com.config;
    
    import lombok.extern.slf4j.Slf4j;
    
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.impl.client.DefaultConnectionKeepAliveStrategy;
    import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
    import org.apache.http.impl.client.HttpClientBuilder;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    import org.apache.http.ssl.SSLContextBuilder;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.client.ClientHttpRequestFactory;
    import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
    import org.springframework.http.converter.StringHttpMessageConverter;
    import org.springframework.web.client.RestTemplate;
    
    import java.nio.charset.StandardCharsets;
    import java.util.concurrent.TimeUnit;
    
    import javax.net.ssl.SSLContext;
    
    /**
     * restTemplate 配置类
     *
     */
    @Slf4j
    @Configuration
    public class RestTemplateConfig {
    
        private static final int CONNECT_TIMEOUT = 60000; // 连接超时 60000ms
    
        private static final int SOCKET_TIMEOUT = 180000; // socket超时 180000ms
    
        private static final int READ_TIMEOUT = 180000; // 读超时 180000ms
    
        private static final int REQUEST_TIMEOUT = 30000; // 请求超时 30000ms
    
        private static final int MAX_CONN_TOTAL = 500; // 最大连接数500
    
        private static final int MAX_CONN_ROUTE = 500; // 最大并发数500
    
        private static final int RETRY_TIMES = 2; // 重试次数2
    
        private static final int TIME_TO_LIVE = 30; // 长连接保持时长 30s
    
        /**
         * restTemplate
         *
         * @return restTemplate
         */
        @Bean
        public RestTemplate restTemplate() {
            RestTemplate restTemplate = new RestTemplate(simpleClientHttpRequestFactory());
            restTemplate.getMessageConverters().add(new StringHttpMessageConverter(StandardCharsets.UTF_8));
            return restTemplate;
        }
    
        /**
         * 自定义ClientHttpRequestFactory配置
         *
         * @return ClientHttpRequestFactory
         */
        @Bean
        public static ClientHttpRequestFactory simpleClientHttpRequestFactory() {
            // 长连接保持时长30秒
            PoolingHttpClientConnectionManager pollingConnectionManager = new PoolingHttpClientConnectionManager(
                TIME_TO_LIVE, TimeUnit.SECONDS);
            // 最大连接数
            pollingConnectionManager.setMaxTotal(MAX_CONN_TOTAL);
            // 单路由的并发数
            pollingConnectionManager.setDefaultMaxPerRoute(MAX_CONN_ROUTE);
            HttpClientBuilder httpClientBuilder = HttpClients.custom();
            httpClientBuilder.setConnectionManager(pollingConnectionManager);
            // 重试次数2次，并开启
            httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(RETRY_TIMES, true));
            // 保持长连接配置，需要在头添加Keep-Alive
            httpClientBuilder.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy());
            HttpClient httpClient = httpClientBuilder.build();
            // httpClient连接底层配置clientHttpRequestFactory
            HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(
                httpClient);
            clientHttpRequestFactory.setReadTimeout(READ_TIMEOUT); // ms
            clientHttpRequestFactory.setConnectTimeout(CONNECT_TIMEOUT); // ms
            return clientHttpRequestFactory;
        }
    
        /**
         * 通过SSLContextBuilder绕过https安全验证
         *
         * @return restTemplateSSL
         */
        @Bean
        public RestTemplate restTemplateSsl() {
            ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
            try {
                HttpClient httpClient = httpClientCrossOverSsl(getDefaultReqConfig());
                requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
            } catch (Exception e) {
                log.error("init ClientHttpRequestFactory error.", e);
            }
            return new RestTemplate(requestFactory);
        }
    
        /**
         * Apache HttpClient 绕过ssl 验证
         *
         * @param requestConfig 请求配置
         * @return httpClientCrossOverSSL
         * @throws Exception 异常
         */
        public HttpClient httpClientCrossOverSsl(RequestConfig requestConfig) throws Exception {
            SSLContext sslContext = SSLContextBuilder.create()
                .useProtocol(SSLConnectionSocketFactory.SSL)
                .loadTrustMaterial((x, y) -> true)
                .build();
            return HttpClientBuilder.create()
                .setDefaultRequestConfig(requestConfig)
                .setSSLContext(sslContext)
                .setSSLHostnameVerifier((x, y) -> true)
                .setMaxConnTotal(MAX_CONN_TOTAL) // 最大连接数
                .setMaxConnPerRoute(MAX_CONN_ROUTE) // 每个路由设置并发数
                .build();
        }
    
    
        /**
         * getDefaultReqConfig
         * 
         * @return RequestConfig
         */
        private RequestConfig getDefaultReqConfig() {
            return RequestConfig.custom().setSocketTimeout(SOCKET_TIMEOUT) // 服务器返回数据(response)的时间，超时抛出read timeout
                .setConnectTimeout(SOCKET_TIMEOUT) // 连接上服务器(握手成功)的时间，超时抛出connect timeout
                .setConnectionRequestTimeout(REQUEST_TIMEOUT) // 从连接池中获取连接的超时时间，超时抛出ConnectionPoolTimeoutException
                .build();
        }
    }