Resttemplate池化使用

两人走

于 2023-11-14 10:42:56 发布

阅读量111

点赞数

文章标签： Resttemplat

本文链接：https://blog.csdn.net/weixin_43862280/article/details/134393790

版权

Resttemplate池化使用

依赖坐标

<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.2.4.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.13</version>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.5.9</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.1.16.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.8</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>

连接池配置

@Bean
    @ConditionalOnMissingBean(name = "resRestTemplatePool")
    public RestTemplate resRestTemplatePool(@Qualifier("resHttpRequestFactory") ClientHttpRequestFactory factory) {
        return new RestTemplate(factory);
    }

    @Bean
    @ConditionalOnMissingBean(name = "resHttpRequestFactory")
    public ClientHttpRequestFactory resHttpRequestFactory(ResAuthProperties resAuthProperties) {
        return new HttpComponentsClientHttpRequestFactory(httpClient(resAuthProperties));
    }

    @Bean
    @ConditionalOnMissingBean(HttpApiHelper.class)
    public HttpApiHelper resHttpApiHelper(@Qualifier("resRestTemplatePool") RestTemplate restTemplate) {
        return new HttpApiHelper(restTemplate);
    }


    private HttpClient httpClient(ResAuthProperties resAuthProperties) {
        PoolingHttpClientConnectionManager httpClientConnectionManager = new PoolingHttpClientConnectionManager();
        // 设置最大连接池的数量
        httpClientConnectionManager.setMaxTotal(resAuthProperties.getMaxHttpPoolSize());
        // 每个主机的最大并发量，route是指域名.是对MaxTotal的细化...
        httpClientConnectionManager.setDefaultMaxPerRoute(resAuthProperties.getMaxConnectPerRout());

        RequestConfig requestConfig = RequestConfig.custom()
                // 数据返回超时时间
                .setSocketTimeout(resAuthProperties.getSocketTimeout())
                // 连接超时时间
                .setConnectTimeout(resAuthProperties.getConnectTimeout())
                // 从连接池中获取连接的超时时间
                .setConnectionRequestTimeout(CONNECT_REQUEST_TIMEOUT)
                .build();

        return HttpClientBuilder.create()
                .setConnectionManager(httpClientConnectionManager)
                .setDefaultRequestConfig(requestConfig)
                .build();

    }

使用示例

基础类

package com.cmbchina.res.model.response.upload;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@Accessors(chain = true)
public class SmallUploadDTO implements Serializable {

    private String fileId;

    private String fileName;

    private int fileSize;

    private String pUrl;

    private String gUrl;

}

service层

 /**
     * 小文件上传接口
     *
     * @param file              文件
     * @param smallFileUploadVO 相关参数
     * @param headers           header中的对接方相关参数
     * @param queryParams       url中拼接的相关参数
     * @return jsonString
     */
    public ResResponse<SmallUploadDTO> uploadSmallFile(MultipartFile file, SmallFileUploadVO smallFileUploadVO,
                                                       Map<String, String> headers,
                                                       Map<String, Object> queryParams) throws IOException {
        SmallFileUploadVO.checkSmallFileUploadParam(smallFileUploadVO, resAuthProperties.getAppId());
        return dealUploadFile(
                file.getBytes(),
                new DealUploadVO()
                        .setOriginalFilename(file.getOriginalFilename())
                        .setParam(smallFileUploadVO)
                        .setHeaders(headers)
                        .setQueryParams(queryParams)
                        .setPath(ResServerPathConstant.SMALL_FILE_UPLOAD),
                new ParameterizedTypeReference<ResResponse<SmallUploadDTO>>() {
                }
        );
    }

    private <T> T dealUploadFile(byte[] file, DealUploadVO dealUploadVO, ParameterizedTypeReference<T> parameterizedTypeReference) {
        HttpHeaders targetHeaders = HttpApiHelper.buildResBaseRequestHeaders(dealUploadVO.getHeaders(), resAuthProperties, tokenHelper);
        Map<String, Object> form =
                BeanUtil.beanToMap(dealUploadVO.getParam(), ResDepConstant.IS_TO_UNDERLINE_CASE, ResDepConstant.IGNORE_NULL_VALUE);
        form.put(
                ResFormFieldConstant.FILE,
                new ByteArrayResource(file) {
                    @Override
                    public String getFilename() {
                        return dealUploadVO.getOriginalFilename();
                    }
                }
        );
        return httpApiHelper.httpFormRequest(
                UriUtils.buildUrl(resAuthProperties.getResGatewayUrl(), dealUploadVO.getPath(), dealUploadVO.getQueryParams()),
                form,
                targetHeaders,
                parameterizedTypeReference
        );
    }
	

	//这个在工具类里面
    public <T> T httpFormRequest(String url, Map<String, Object> form, HttpHeaders headers,
                                 ParameterizedTypeReference<T> parameterizedTypeReference) {
        MultiValueMap<String, Object> targetForm = new LinkedMultiValueMap<>();
        form.forEach(targetForm::add);
        if (!headers.containsKey(HttpHeaders.CONTENT_TYPE)) {
            headers.add(HttpHeaders.CONTENT_TYPE, MediaType.MULTIPART_FORM_DATA_VALUE);
        }
        HttpEntity<MultiValueMap<String, Object>> httpEntity = new HttpEntity<>(targetForm, headers);
        return exchange(url, httpEntity, HttpMethod.POST, parameterizedTypeReference);
    }

工具类

package com.cmbchina.res.http;

import com.alibaba.fastjson.JSONObject;
import com.cmbchina.res.configuration.ResAuthProperties;
import com.cmbchina.res.constant.ResDepConstant;
import com.cmbchina.res.constant.ResHeaderFieldConstant;
import com.cmbchina.res.http.auth.TokenHelper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.ParameterizedTypeReference;
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.util.CollectionUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;

/**
 * @author IT803300
 * @date 2023-08-16 13:57:00
 */
@Slf4j
public class HttpApiHelper {

    private RestTemplate restTemplate;


    public HttpApiHelper() {
    }

    public HttpApiHelper(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    private <T> T exchange(String url, HttpEntity<?> httpEntity, HttpMethod method, ParameterizedTypeReference<T> parameterizedTypeReference) {
        T t = null;
        try {
            URI uri = new URI(url);
            ResponseEntity<T> response = exchange(uri, httpEntity, method, parameterizedTypeReference);
            if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
                t = response.getBody();
            } else {
                log.warn(
                        ResDepConstant.RDC_406_MSG,
                        response.getStatusCode(),
                        JSONObject.toJSONString(httpEntity.getHeaders()),
                        url);
            }
        } catch (Exception e) {
            log.error(String.format(ResDepConstant.RDC_405_MSG, JSONObject.toJSONString(httpEntity.getHeaders()), url), e);
        }

        return t;
    }

    private <T> ResponseEntity<T> exchange(URI uri, HttpEntity<?> httpEntity, HttpMethod method,
                                           ParameterizedTypeReference<T> parameterizedTypeReference) {
        ResponseEntity<T> response = null;
        try {
            response = restTemplate.exchange(uri, method, httpEntity, parameterizedTypeReference);
        } catch (Exception e) {
            log.error(String.format(ResDepConstant.RDC_404_MSG, JSONObject.toJSONString(httpEntity.getHeaders()), uri), e);
        }

        return response;
    }

    private <T> ResponseEntity<T> exchange(String uri, HttpEntity<?> httpEntity, HttpMethod method,
                                           Class<T> calzz) {
        ResponseEntity<T> response = null;
        try {
            response = restTemplate.exchange(new URI(uri), method, httpEntity, calzz);
        } catch (Exception e) {
            log.error(String.format(ResDepConstant.RDC_403_MSG, JSONObject.toJSONString(httpEntity.getHeaders()), uri), e);
        }
        return response;
    }

    public <T> ResponseEntity<T> httpPostRequest(String url, String jsonBody, HttpHeaders headers,
                                                 Class<T> calzz) {
        if (!headers.containsKey(HttpHeaders.CONTENT_TYPE)) {
            headers.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
        }
        HttpEntity<String> httpEntity = new HttpEntity<>(jsonBody, headers);
        return exchange(url, httpEntity, HttpMethod.POST, calzz);
    }

    public <T> T httpFormRequest(String url, Map<String, Object> form, HttpHeaders headers,
                                 ParameterizedTypeReference<T> parameterizedTypeReference) {
        MultiValueMap<String, Object> targetForm = new LinkedMultiValueMap<>();
        form.forEach(targetForm::add);
        if (!headers.containsKey(HttpHeaders.CONTENT_TYPE)) {
            headers.add(HttpHeaders.CONTENT_TYPE, MediaType.MULTIPART_FORM_DATA_VALUE);
        }
        HttpEntity<MultiValueMap<String, Object>> httpEntity = new HttpEntity<>(targetForm, headers);
        return exchange(url, httpEntity, HttpMethod.POST, parameterizedTypeReference);
    }


    public <T> T httpPostRequest(String url, String jsonBody, ParameterizedTypeReference<T> parameterizedTypeReference) {
        return httpPostRequest(url, jsonBody, new HttpHeaders(), parameterizedTypeReference);
    }

    public <T> T httpPostRequest(String url, String jsonBody, HttpHeaders headers,
                                 ParameterizedTypeReference<T> parameterizedTypeReference) {
        if (!headers.containsKey(HttpHeaders.CONTENT_TYPE)) {
            headers.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
        }
        HttpEntity<String> httpEntity = new HttpEntity<>(jsonBody, headers);
        return exchange(url, httpEntity, HttpMethod.POST, parameterizedTypeReference);
    }

    public <T> ResponseEntity<T> httpGetRequest(String url, HttpHeaders headers, ParameterizedTypeReference<T> parameterizedTypeReference) {
        ResponseEntity<T> response = null;
        HttpEntity<String> httpEntity = new HttpEntity<>(null, headers);
        try {
            response = exchange(new URI(url), httpEntity, HttpMethod.GET, parameterizedTypeReference);
        } catch (URISyntaxException e) {
            log.error(String.format(ResDepConstant.RDC_407_MSG, JSONObject.toJSONString(httpEntity.getHeaders()), url), e);
        }
        return response;
    }


    public static HttpHeaders buildResBaseRequestHeaders(Map<String, String> headers, ResAuthProperties resAuthProperties,
                                                         TokenHelper tokenHelper) {

        Map<String, String> targetHeaders = headers;
        if (CollectionUtils.isEmpty(targetHeaders)) {
            targetHeaders = new HashMap<>();
        }

        targetHeaders.put(ResHeaderFieldConstant.SYSTEM_USER_ID, resAuthProperties.getSystemUserId());
        if (resAuthProperties.isEnable()) {
            targetHeaders.put(ResHeaderFieldConstant.TOKEN, tokenHelper.refreshToken());
        }
        targetHeaders.put(ResHeaderFieldConstant.APP_ID, resAuthProperties.getAppId());
        MultiValueMap<String, String> httpTargetHeaders = new LinkedMultiValueMap<>();
        httpTargetHeaders.setAll(targetHeaders);
        return new HttpHeaders(httpTargetHeaders);
    }

}

两人走

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Resttemplate池化使用

Resttemplate池化使用依赖坐标<dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </dependency> <dependency> <groupId>org.springframe
复制链接

扫一扫