SpringBoot使用RestTemplate发网络请求

SpringBoot使用RestTemplate发网络请求

依赖

    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
            <scope>test</scope>
        </dependency>

        <!--        适配 IntelliJ IDEA版本和junit版本-->
        <dependency>
            <groupId>org.junit.platform</groupId>
            <artifactId>junit-platform-launcher</artifactId>
            <scope>test</scope>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

  
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.22</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.1.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-oas</artifactId>
            <version>3.0.0</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.6</version>
        </dependency>

    </dependencies>

配置类

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.HttpClientBuilder;
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.web.client.RestTemplate;

import javax.net.ssl.SSLContext;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;

@Slf4j
@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate()
    {
        ClientHttpRequestFactory requestFactory = null;
        try {
            requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient());
        } catch (Exception e) {
            log.error("init ClientHttpRequestFactory error.",e);
        }
        return new RestTemplate(requestFactory);
    }

    /**
     * Apache HttpClient
     * 绕过ssl 验证
     *
     * @return
     * @see [类、类#方法、类#成员]
     */
    private HttpClient httpClient() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
        RequestConfig requestConfig = RequestConfig.custom()
            .setSocketTimeout(1000*100) // 服务器返回数据(response)的时间，超时抛出read timeout
            .setConnectTimeout(1000*100) // 连接上服务器(握手成功)的时间，超时抛出connect timeout
            .setConnectionRequestTimeout(1000)// 从连接池中获取连接的超时时间，超时抛出ConnectionPoolTimeoutException
            .build();
        SSLContext sslContext = SSLContextBuilder.create().setProtocol(SSLConnectionSocketFactory.SSL).loadTrustMaterial((x, y) -> true).build();
        return HttpClientBuilder.create().setDefaultRequestConfig(requestConfig).
            setSSLContext(sslContext)
            .setMaxConnTotal(200)
            .setMaxConnPerRoute(200).setSSLHostnameVerifier((x, y) -> true).build();
    }

}

工具类

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;

@Component
@Slf4j
public class RestTemplateUtil {

    @Autowired
    RestTemplate restTemplate;


    public <T> T post(String url, Object messageInfo, HttpHeaders headers,Class<T> tClass) {
        log.info("url:{},messageInfo:{}", url, messageInfo);
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Object> entity = new HttpEntity<Object>(messageInfo, headers);
        ResponseEntity<T> responseEntity = restTemplate.postForEntity(url, entity, tClass);
        log.info("result:{}", responseEntity.getBody());
        return responseEntity.getBody();
    }

    public <T> T postObject(String url, Object messageInfo,Class<T> tClass) {
        log.info("url:{},messageInfo:{}", url, messageInfo);
        HttpEntity<String> entity = new HttpEntity(JSONObject.toJSONString(messageInfo));
        ResponseEntity<T> responseEntity = restTemplate.postForEntity(url, entity, tClass);
        log.info("result:{}", responseEntity.getBody());
        return responseEntity.getBody();
    }

    public <T> T getForObject(String url,Class<T> tClass){
        log.info("url:{}",url);
        T forObject = restTemplate.getForObject(url
                , tClass);
        log.info("result:{}",forObject);
        return forObject;
    }

    public <T> T exchange(String url,Class<T> tClass){
        HttpHeaders headers = new HttpHeaders();
        headers.add("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36");
        HttpEntity httpEntity = new HttpEntity(headers);
        ResponseEntity<T> resp = restTemplate.exchange(url, HttpMethod.GET, httpEntity, tClass);
        return resp.getBody();
    }

    public <T> T exchangeHeader(String url,Class<T> tClass,HttpHeaders headers){
        log.info("url:{}",url);
        HttpEntity httpEntity = new HttpEntity(headers);
        ResponseEntity<T> resp;
        try {
            resp = restTemplate.exchange(url, HttpMethod.GET, httpEntity, tClass);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
        return resp.getBody();
    }

    public <T> T exchange(String url,Class<T> tClass, Map<String,?> param){
        HttpHeaders headers = new HttpHeaders();
        headers.add("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36");
        HttpEntity httpEntity = new HttpEntity(headers);

        ResponseEntity<T> resp = restTemplate.exchange(url, HttpMethod.GET, httpEntity, tClass,param);
        return resp.getBody();
    }

    public <T> T exchangeNoHeader(String url,Class<T> tClass, Map<String,?> param){
        HttpHeaders headers = new HttpHeaders();
        //headers.add("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36");
        HttpEntity httpEntity = new HttpEntity(headers);
        ResponseEntity<T> resp = restTemplate.exchange(url, HttpMethod.GET, httpEntity, tClass,param);
        return resp.getBody();
    }

    public  void showBytes(String url, HttpServletResponse httpServletResponse) {
        HttpHeaders headers = new HttpHeaders();
        HttpEntity httpEntity = new HttpEntity(headers);
        httpServletResponse.setHeader("Content-Disposition", "inline;");
        httpServletResponse.setContentType("image/jpeg");
        //如果返回的是String 则改用 String 若为文件流 则改用 Resource
        ResponseEntity<Resource> responseEntity = restTemplate.exchange(url, HttpMethod.POST, httpEntity,Resource.class);
        if (responseEntity.getStatusCodeValue()!= HttpStatus.OK.value()){
            return ;
        }
        if (responseEntity != null) {
                InputStream responseInputStream=null;
                try {
                    responseInputStream = responseEntity.getBody().getInputStream();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (responseInputStream == null) {
                    return ;
                } else {
                    try {
                        OutputStream outputStream = httpServletResponse.getOutputStream();
                        outputStream.write(toByteArray(responseInputStream));
                        outputStream.flush();
                        outputStream.close();
                        return ;
                    } catch (IOException e) {
                        log.error("图片数据转化为byte[]失败");
                        return ;
                    }
                }
        }
        return ;
    }
    public  byte[] toByteArray(InputStream input) throws IOException {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024*4];
        int n = 0;
        while (-1 != (n = input.read(buffer))) {
            output.write(buffer, 0, n);
        }
        return output.toByteArray();
    }

}

使用与测试

YourRetuenObject res=new YourRetuenObject();
        String url="your url";
//        设置header
        HttpHeaders httpHeaders=new HttpHeaders();
        httpHeaders.add("X-Accept","application/json");
        httpHeaders.add("Accept-Encoding","deflate, gzip");

        JSONObject result = null;
        try{
            // 发起请求
            result = restTemplateUtil.exchangeHeader(url, JSONObject.class,httpHeaders);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
        Integer ret = -1;
        if (result!=null){
            // 获取返回值
            ret = (Integer)((LinkedHashMap)result.get("status")).get("error_code");
        }

//       请求成功，解析数据
        if (ret==0){
            Collection data = ((LinkedHashMap) result.get("data")).values();
            for (Object datum : data) {
                JSONObject json = (JSONObject) JSON.toJSON(datum);
                if (json!=null){
//                    基本信息
                    res.setSymbol(json.getString("symbol"));
                    res.setCoinLogo(json.getString("logo"));
//                    设置社交网络信息
                    JSONObject urls = json.getJSONObject("urls");
                    if(urls!=null){
                        res.setOfficialWebsite( urls.getJSONArray("website").get(0).toString());
                        res.setTwitter( urls.getJSONArray("twitter").get(0).toString());
                    }

                }
            }
        }

        return res;