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.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.net.ssl.*;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.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配置请求头以及支持Https协议】参考地址：https://www.jianshu.com/p/7d6dcae818bf
推荐阅读
- vue-cli|vue-cli 3.x vue.config.js 配置
- 从战略性的角度可以配置股票
- https请求被提早撤回
- 遇到不正当请求怎么办
- 缓存有关的配置和属性
- Spring|Spring Boot 自动配置的原理、核心注解以及利用自动配置实现了自定义 Starter 组件
- 使用Promise对微信小程序wx.request请求方法进行封装
- AnyProxy抓取http/https请求
- Vagrant|Vagrant (三) - 网络配置
- java|java b2b2c shop 多用户商城系统源码- config 修改配置