使用Feign配置请求头以及支持Https协议

使用Feign配置请求头以及支持Https协议

目录Feign配置请求头及支持Https协议背景Feign配置请求头Feign支持Https协议Feignclient设置请求头信息Feignclient端配置文件application-dev.ymlfeignconfiguration这里配置全局的请求头和token feign异常处理

Feign配置请求头及支持Https协议

背景

最近跟第三方对接，请求头需要特殊处理，同时是 Https 协议。

第三方提供的是使用 OkHttp 调用。同时呢，使用 OkHttp 封装了调用和返回值。

今天对项目代码进行审查的时候，想着还是把这个替换调吧，实现起来更加的优雅。

Feign配置请求头

FeignParamsInterceptor 这个类实现了 RequestInterceptor ，可以实现对请求进行拦截处理。

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

import feign.RequestInterceptor;

import feign.RequestTemplate;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Component;

import java.io.UnsupportedEncodingException;

/**

* @Description feign参数拦截

*/

@Component

public class FeignParamsInterceptor implements RequestInterceptor {

private static final Logger logger = LoggerFactory.getLogger(FeignParamsInterceptor.class);

private static final String loanUrl = "x/";

private static final String accountUrl = "y/";

@Value("${xxxx}")

private String clientSecret;

@Value("${yyyy}")

private String clientId;

@Override

public void apply(RequestTemplate requestTemplate) {

String url = requestTemplate.url();

if (url.contains(loanUrl) || url.contains(accountUrl)) {

//获取请求体

byte[] body = requestTemplate.body();

JSONObject params;

try {

params = JSON.parseObject(new String(body, requestTemplate.charset() == null ? "utf-8": requestTemplate.charset().name()));

//设置请求体

requestTemplate.body(params.toJSONString());

requestTemplate.header("xx", CryptoEncrypt.signBytes(params.toJSONString().getBytes(), clientSecret.getBytes()));

requestTemplate.header("yyyy", clientId);

requestTemplate.header("Content-Type", "application/json;charset=utf-8");

} catch (UnsupportedEncodingException e) {

logger.info(e.getMessage(), e);

}

}

}

}

Feign支持Https协议

如下 FeignHttpsConfig 类内容：这个方案呢，目前是可以实现效果的。具体的内容是否可以简化，优化。这个还没有具体的研究。

本文的解决方案是有问题的。请点击这里

import feign.Client;

import feign.Feign;

import feign.Logger;

import org.apache.http.conn.ssl.NoopHostnameVerifier;

import org.springframwxowomMework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import javax-.ssl.*;

import java.io.IOException;

import java.io.InputStream;

import java-.InetAddress;

import java-.Socket;

import java.security.KeyStore;

import java.security.Principal;

import java.security.PrivateKey;

import java.security.SecureRandom;

import java.security.cert.Certificate;

import java.security.cert.X509Certificate;

import java.util.Arrays;

import java.util.LinkedHashMap;

import java.util.Map;

@Configuration

public class FeignHttpsConfig {

@Bean

public Feign.Builder feignBuilder() {

final Client trustSSLSockets = client();

return Feign.builder().client(trustSSLSockets);

}

@Bean

public Client client(){

return new Client.Default(

TrustingSSLSocketFactory.get(), new NoopHostnameVerifier());

}

}

class TrustingSSLSocketFactory extends SSLSocketFactory

implements X509TrustManager, X509KeyManager {

private static final Map sslSocketFactories =

new LinkedHashMap();

private static final char[] KEYSTORE_PASSWORD = "password".toCharArray();

private final static String[] ENABLED_CIPHER_SUITES = {"TLS_RSA_WITH_AES_256_CBC_SHA"};

private final SSLSocketFactory delegate;

private final String serverAlias;

private final PrivateKey privateKey;

private final X509Certificate[] certificateChain;

private TrustingSSLSocketFactory(String serverAlias) {

try {

SSLContext sc = SSLContext.getInstance("SSL");

sc.init(new KeyManager[] {this}, new TrustManager[] {this}, new SecureRandom());

this.delegate = sc.getSocketFactory();

} catch (Exception e) {

throw new RuntimeException(e);

}

this.serverAlias = serverAlias;

if (serverAlias.isEmpty()) {

this.privateKey = null;

this.certificateChain = null;

} else {

try {

KeyStore keyStore =

loadKeyStore(TrustingSSLSocketFactory.class.getResourceAsStream("/keystore.jks"));

this.privateKey = (PrivateKey) keyStore.getKey(serverAlias, KEYSTORE_PASSWORD);

Certificate[] rawChain = keyStore.getCertificateChain(serverAlias);

this.certificateChain = Arrays.copyOf(rawChain, rawChain.length, X509Certificate[].class);

} catch (Exception e) {

throw new RuntimeException(e);

}

}

}

public static SSLSocketFactory get() {

return get("");

}

public synchronized static SSLSocketFactory get(String serverAlias) {

if (!sslSocketFactories.containsKey(serverAlias)) {

sslSocketFactories.put(serverAlias, new TrustingSSLSocketFactory(serverAlias));

}

return sslSocketFactories.get(serverAlias);

}

static Socket setEnabledCipherSuites(Socket socket) {

SSLSocket.class.cast(socket).setEnabledCipherSuites(ENABLED_CIPHER_SUITES);

return socket;

}

private static KeyStore loadKeyStore(InputStream inputStream) throws IOException {

try {

KeyStore keyStore = KeyStore.getInstance("JKS");

keyStore.load(inputStream, KEYSTORE_PASSWORD);

return keyStore;

} catch (Exception e) {

throw new RuntimeException(e);

} finally {

inputStream.close();

}

}

@Override

public String[] getDefaultCipherSuites() {

return ENABLED_CIPHER_SUITES;

}

@Override

public String[] getSupportedCipherSuites() {

return ENABLED_CIPHER_SUITES;

}

@Override

public Socket createSocket(Socket s, String host, int port, boolean autoClose)

throws IOException {

return setEnabledCipherSuites(delegate.createSocket(s, host, port, autoClose));

}

@Override

public Socket createSocket(String host, int port) throws IOException {

return setEnabledCipherSuites(delegate.createSocket(host, port));

}

@Override

public Socket createSocket(InetAddress host, int port) throws IOException {

return setEnabledCipherSuites(delegate.createSocket(host, port));

}

@Override

public Socket createSocket(String host, int port, InetAddress localHost, int localPort)

throws IOException {

return setEnabledCipherSuites(delegate.createSocket(host, port, localHost, localPort));

}

@Override

public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)

throws IOException {

return setEnabledCipherSuites(delegate.createSocket(address, port, localAddress, localPort));

}

@Override

public X509Certificate[] getAcceptedIssuers() {

return null;

}

@Override

public void checkClientTrusted(X509Certificate[] certs, String authType) {}

@Override

public void checkServerTrusted(X509Certificate[] certs, String authType) {}

@Override

public String[] getClientAliases(String keyType, Principal[] issuers) {

return null;

}

@Override

public String chooseClientAlias(String[] keyType, Principal[] issuers, Socket socket) {

return null;

}

@Override

public String[] getServerAliases(String keyType, Principal[] issuers) {

return null;

}

@Override

public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {

return serverAlias;

}

@Override

public X509Certificate[] getCertificateChain(String alias) {

return certificateChain;

}

@Override

public PrivateKey getPrivateKey(String alias) {

return privateKey;

}

}

Feign client 设置请求头信息

Feign client端

@Feihttp://gnClient(url = "${test.url}", name = "cclient",configuration= ClientConfiguration.class,fallback = APIClientFallback.class)

public interface APIClient {

@RequestMapping(method = RequestMethod.POST, value = "/check/test")

String checkResult(@RequestParam("sendTelNo") String sendTelNo,@RequestParam("certType") String certType,@RequestParam("certCode") String certCode,@RequestParam("userName") String userName);

@RequestMapping(method = RequestMethod.POST, value = "/userstaus/test")

String inusetime(@RequestParam("sendTelNo") String sendTelNo);

@RequestMapping(method = RequestMethod.POST, value = "/userstaus/test")

String offnetIdentify(@RequestParam("sendTelNo") String sendTelNo,@RequestParam("date") String date);

配置文件 application-dev.yml

test:

url: https://xxxxxx:8243/test

tokenId: 11111112222222

feign configuration 这里配置全局的请求头和token

@Configuration

public class ClientConfiguration {

@Value("${test.tokenId}")

private String tokenId;

@Bean

public RequestInterceptor headerInterceptor() {

return new RequestInterceptor(){

@Override

public void apply(RequestTemplate template) {

List authorizationList = Lists.newArrayList("Bearer "+tokenId);

List contentTypeList = Lists.newArrayList("application/x-www-form-urlencoded;charset=utf-8");

Map> headers =ImmutableMap.of("Authorization", authorizationList,"Content-Type", contentTypeList);

template.headers(headers);

}

};

}

feign 异常处理

@Component

public class APIClientFallback implements APIClient{

@Override

public String checkResult(String sendTelNo, String certType, String certCode, String userName) {

return toJsonString();

}

@Override

public String inusetime(String sendTelNo) {

return toJsonString();

}

@Override

public String offnetIdentify(String sendTelNo, String date) {

return toJsonString();

}

private String toJsonString() {

BaseResult resultVo = new BaseResult();

resultVo.renderStatus(ResultTypeEnum.SERVICE_ERROR);

ObjectMapper mapper = new ObjectMapper();

try {

return mapper.writeValueAsString(resultVo);

} catch (JsonProcessingException e) {

e.printStackTrace();

}

return null;

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。