Feature之实现流量转发
Posted go大鸡腿
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Feature之实现流量转发相关的知识，希望对你有一定的参考价值。
前言
流量转发一般是由ng还有网关来处理，但是在架构组工作里面，有些应用是不能接到业务网关，技术网关还在建设中，暂时实现服务进行流量转发
实现思路
可以重写servlet，然后通过httpclient来请求，然后复制对应response值、header、cookie来实现流量转发
上代码
- 第一步配置servlet
@Bean
public ServletRegistrationBean servletRegistrationBean()
ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new MyProxyServlet(), "/proxy/*");
//这个setName必须要设置，并且多个的时候，名字需要不一样
servletRegistrationBean.setName("forward1");
servletRegistrationBean.addInitParameter("targetUri", "xx.com");
servletRegistrationBean.addInitParameter(ProxyServlet.P_LOG, "true");
return servletRegistrationBean;
就是/proxy的请求都会转发到xx.com这个域名
- MyProxyServlet 继承HttpServlet
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.http.*;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.AbortableHttpRequest;
import org.apache.http.client.params.ClientPNames;
import org.apache.http.client.params.CookiePolicy;
import org.apache.http.client.utils.URIUtils;
import org.apache.http.conn.ssl.AllowAllHostnameVerifier;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicHttpEntityEnclosingRequest;
import org.apache.http.message.BasicHttpRequest;
import org.apache.http.message.HeaderGroup;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.util.EntityUtils;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.HttpCookie;
import java.net.URI;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.BitSet;
import java.util.Enumeration;
import java.util.Formatter;
import java.util.List;
@Slf4j
public class MyProxyServlet extends HttpServlet
/* INIT PARAMETER NAME CONSTANTS */
/**
* A boolean parameter name to enable logging of input and target URLs to the servlet log.
*/
public static final String P_LOG = "log";
/**
* A boolean parameter name to enable forwarding of the client IP
*/
public static final String P_FORWARDEDFOR = "forwardip";
/**
* The parameter name for the target (destination) URI to proxy to.
*/
protected static final String P_TARGET_URI = "targetUri";
protected static final String ATTR_TARGET_URI =
org.mitre.dsmiley.httpproxy.ProxyServlet.class.getSimpleName() + ".targetUri";
protected static final String ATTR_TARGET_HOST =
org.mitre.dsmiley.httpproxy.ProxyServlet.class.getSimpleName() + ".targetHost";
/* MISC */
protected boolean doLog = false;
protected boolean doForwardIP = true;
/**
* User agents shouldn't send the url fragment but what if it does?
*/
protected boolean doSendUrlFragment = true;
//These next 3 are cached here, and should only be referred to in initialization logic. See the
// ATTR_* parameters.
/**
* From the configured parameter "targetUri".
*/
protected String targetUri;
protected URI targetUriObj;//new URI(targetUri)
protected HttpHost targetHost;//URIUtils.extractHost(targetUriObj);
private HttpClient proxyClient;
@Override
public String getServletInfo()
return "";
protected String getTargetUri(HttpServletRequest servletRequest)
return (String) servletRequest.getAttribute(ATTR_TARGET_URI);
private HttpHost getTargetHost(HttpServletRequest servletRequest)
return (HttpHost) servletRequest.getAttribute(ATTR_TARGET_HOST);
/**
* Reads a configuration parameter. By default it reads servlet init parameters but
* it can be overridden.
*/
protected String getConfigParam(String key)
return getServletConfig().getInitParameter(key);
@Override
public void init() throws ServletException
String doLogStr = getConfigParam(P_LOG);
if (doLogStr != null)
this.doLog = Boolean.parseBoolean(doLogStr);
String doForwardIPString = getConfigParam(P_FORWARDEDFOR);
if (doForwardIPString != null)
this.doForwardIP = Boolean.parseBoolean(doForwardIPString);
initTarget();//sets target*
HttpParams hcParams = new BasicHttpParams();
hcParams.setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.BROWSER_COMPATIBILITY);
readConfigParam(hcParams, ClientPNames.HANDLE_REDIRECTS, Boolean.class);
proxyClient = createHttpClient(hcParams);
protected void initTarget() throws ServletException
targetUri = getConfigParam(P_TARGET_URI);
if (targetUri == null)
throw new ServletException(P_TARGET_URI + " is required.");
//test it's valid
try
targetUriObj = new URI(targetUri);
catch (Exception e)
throw new ServletException("Trying to process targetUri init parameter: " + e, e);
targetHost = URIUtils.extractHost(targetUriObj);
private static CookieStore cookieStore = new BasicCookieStore();
/**
* Called from @link #init(javax.servlet.ServletConfig). HttpClient offers many opportunities
* for customization. By default,
* <a href="http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/impl/client/SystemDefaultHttpClient.html">
* SystemDefaultHttpClient</a> is used if available, otherwise it falls
* back to:
* <pre>new DefaultHttpClient(new ThreadSafeClientConnManager(),hcParams)</pre>
* SystemDefaultHttpClient uses PoolingClientConnectionManager. In any case, it should be thread-safe.
*/
@SneakyThrows
@SuppressWarnings("unchecked", "deprecation")
protected HttpClient createHttpClient(HttpParams hcParams)
/*try
//as of HttpComponents v4.2, this class is better since it uses System
// Properties:
Class clientClazz = Class.forName("org.apache.http.impl.client.SystemDefaultHttpClient");
Constructor constructor = clientClazz.getConstructor(HttpParams.class);
return (HttpClient) constructor.newInstance(hcParams);
catch (ClassNotFoundException e)
//no problem; use v4.1 below
catch (Exception e)
throw new RuntimeException(e);
*/
HttpClient httpClient = HttpClients.custom()
.setDefaultCookieStore(cookieStore)
.setHostnameVerifier(new AllowAllHostnameVerifier())
.setSslcontext(new SSLContextBuilder().loadTrustMaterial(null, (chain, authType) -> true).build()).build();
return httpClient;
//Fallback on using older client:
//return new DefaultHttpClient(new ThreadSafeClientConnManager(), hcParams);
/**
* The http client used.
*
* @see #createHttpClient(HttpParams)
*/
protected HttpClient getProxyClient()
return proxyClient;
/**
* Reads a servlet config parameter by the name @code hcParamName of type @code type, and
* set it in @code hcParams.
*/
protected void readConfigParam(HttpParams hcParams, String hcParamName, Class type)
String val_str = getConfigParam(hcParamName);
if (val_str == null)
return;
Object val_obj;
if (type == String.class)
val_obj = val_str;
else
try
//noinspection unchecked
val_obj = type.getMethod("valueOf", String.class).invoke(type, val_str);
catch (Exception e)
throw new RuntimeException(e);
hcParams.setParameter(hcParamName, val_obj);
@Override
public void destroy()
//As of HttpComponents v4.3, clients implement closeable
if (proxyClient instanceof Closeable) //TODO AutoCloseable in Java 1.6
try
((Closeable) proxyClient).close();
catch (IOException e)
log("While destroying servlet, shutting down HttpClient: " + e, e);
else
//Older releases require we do this:
if (proxyClient != null)
proxyClient.getConnectionManager().shutdown();
cookieStore = new BasicCookieStore();
super.destroy();
@Override
protected void service(HttpServletRequest servletRequest, HttpServletResponse servletResponse)
throws ServletException, IOException
//initialize request attributes from caches if unset by a subclass by this point
if (servletRequest.getAttribute(ATTR_TARGET_URI) == null)
servletRequest.setAttribute(ATTR_TARGET_URI, targetUri);
if (servletRequest.getAttribute(ATTR_TARGET_HOST) == null)
servletRequest.setAttribute(ATTR_TARGET_HOST, targetHost);
// Make the Request
//note: we won't transfer the protocol version because I'm not sure it would truly be compatible
String method = servletRequest.getMethod();
String proxyRequestUri = rewriteUrlFromRequest(servletRequest);
HttpRequest proxyRequest;
//spec: RFC 2616, sec 4.3: either of these two headers signal that there is a message body.
if (servletRequest.getHeader(HttpHeaders.CONTENT_LENGTH) != null ||
servletRequest.getHeader(HttpHeaders.TRANSFER_ENCODING) != null)
HttpEntityEnclosingRequest eProxyRequest = new BasicHttpEntityEnclosingRequest(method, proxyRequestUri);
// Add the input entity (streamed)
// note: we don't bother ensuring we close the servletInputStream since the container handles it
eProxyRequest.setEntity(new InputStreamEntity(servletRequest.getInputStream(), servletRequest.getContentLength()));
proxyRequest = eProxyRequest;
else
proxyRequest = new BasicHttpRequest(method, proxyRequestUri);
copyRequestHeaders(servletRequest, proxyRequest);
setXForwardedForHeader(servletRequest, proxyRequest);
HttpResponse proxyResponse = null;
try
// Execute the request
if (doLog)
log("proxy " + method + " uri: " + servletRequest.getRequestURI() + " -- " + proxyRequest.getRequestLine().getUri());
proxyResponse = proxyClient.execute(getTargetHost(servletRequest), proxyRequest);
// Process the response
int statusCode = proxyResponse.getStatusLine().getStatusCode();
for (org.apache.http.cookie.Cookie cookie : cookieStore.getCookies())
//set cookie name prefixed w/ a proxy value so it won't collide w/ other cookies
String proxyCookieName = cookie.getName();
Cookie servletCookie = new Cookie(proxyCookieName, cookie.getValue());
servletCookie.setComment(cookie.getComment());
servletCookie.setPath("/"); //set to the path of the proxy servlet
// don't set cookie domain
//servletCookie.setDomain("127.0.0.1");
servletCookie.setSecure(false);
servletCookie.setVersion(cookie.getVersion());
servletResponse.addCookie(servletCookie);
// copying response headers to make sure SESSIONID or other Cookie which comes from remote server
// will be saved in client when the proxied url was redirected to another one.
// see issue [#51](https://github.com/mitre/HTTP-Proxy-Servlet/issues/51)
copyResponseHeaders(proxyResponse, servletRequest, servletResponse);
if (doResponseRedirectOrNotModifiedLogic(servletRequest, servletResponse, proxyResponse, statusCode))
//the response is already "committed" now without any body to send
return;
// Pass the response code. This method with the "reason phrase" is deprecated but it's the only way to pass the
// reason along too.
//noinspection deprecation
servletResponse.setStatus(statusCode, proxyResponse.getStatusLine().getReasonPhrase());
// Send the content to the client
copyResponseEntity(proxyResponse, servletResponse);
catch (Exception e)
//abort request, according to best practice with HttpClient
if (proxyRequest instanceof AbortableHttpRequest)
AbortableHttpRequest abortableHttpRequest = (AbortableHttpRequest) proxyRequest;
abortableHttpRequest.abort();
if (e instanceof RuntimeException)
throw (RuntimeException) e;
if (e instanceof ServletException)
throw (ServletException) e;
//noinspection ConstantConditions
if (e instanceof IOException)
throw (IOException) e;
throw new RuntimeException(e);
finally
// make sure the entire entity was consumed, so the connection is released
if (proxyResponse != null)
consumeQuietly(proxyResponse.getEntity());
cookieStore.clear();
//Note: Don't need to close servlet outputStream:
// http://stackoverflow.com/questions/1159168/should-one-call-close-on-httpservletresponse-getoutputstream-getwriter
protected boolean doResponseRedirectOrNotModifiedLogic(
HttpServletRequest servletRequest, HttpServletResponse servletResponse,
HttpResponse proxyResponse, int statusCode)
throws ServletException网关开发5.Openresty 自定义负载均衡与流量转发