我希望我的Java Web应用程序能够通过其他Web服务器提供的无缝代理内容。
http://myapp.com/proxy/* -> http://other_app_to_proxy.com:9090/
我的应用程序将处理所有与auth相关的事务，并在同一域下的子路径上提供其他应用程序。
我找到了如何做反向代理：HTTP-Proxy-Servlet。
现在的问题是其他应用程序有绝对的URL，如/css/style.css，当我的应用程序中的页面打开时，此URL无法访问，因为在我的设置中它应该是/proxy/css/style.css。
我想我需要某种URL重写过滤器来改变发送到客户端的出站响应。我试图研究Tuckey UrlRewrite，但看起来它的目的不同 - 它有很多工具可以更改入站URL并将请求重定向到其他位置。
有人能指点我解决一下吗？
我找到了几个允许在过滤器中完全响应正文重写的类。
几个基类：
import javax.servlet.*;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
public abstract class AbstractResponseAlteringFilter implements Filter {
public void init(FilterConfig fConfig) throws ServletException {
}
protected static class ByteArrayServletStream extends ServletOutputStream {
ByteArrayOutputStream baos;
ByteArrayServletStream(ByteArrayOutputStream baos) {
this.baos = baos;
}
public void write(int param) throws IOException {
baos.write(param);
}
}
protected static class ByteArrayPrintWriter {
private ByteArrayOutputStream baos = new ByteArrayOutputStream();
private PrintWriter pw = new PrintWriter(baos);
private ServletOutputStream sos = new ByteArrayServletStream(baos);
public PrintWriter getWriter() {
return pw;
}
public ServletOutputStream getStream() {
return sos;
}
byte[] toByteArray() {
return baos.toByteArray();
}
}
protected static class CharResponseWrapper extends HttpServletResponseWrapper {
private ByteArrayPrintWriter output;
private boolean usingWriter;
public CharResponseWrapper(HttpServletResponse response) {
super(response);
usingWriter = false;
output = new ByteArrayPrintWriter();
}
public byte[] getByteArray() {
return output.toByteArray();
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
// will error out, if in use
if (usingWriter) {
super.getOutputStream();
}
usingWriter = true;
return output.getStream();
}
@Override
public PrintWriter getWriter() throws IOException {
// will error out, if in use
if (usingWriter) {
super.getWriter();
}
usingWriter = true;
return output.getWriter();
}
public String toString() {
return output.toString();
}
}
public void destroy() {
}
}
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
public abstract class AbstractResponseBodyAlteringFilter extends AbstractResponseAlteringFilter {
private final static Logger logger = LoggerFactory.getLogger(AbstractResponseBodyAlteringFilter.class);
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
ServletException {
HttpServletResponse httpResponse = (HttpServletResponse) response;
CharResponseWrapper wrappedResponse = new CharResponseWrapper(httpResponse);
chain.doFilter(request, wrappedResponse);
logger.info("wrappedResponse.getContentType() = {}", wrappedResponse.getContentType());
byte[] responseBytes = wrappedResponse.getByteArray();
if (StringUtils.containsAny(wrappedResponse.getContentType(), "text/", "javascript")) {
responseBytes = modifyResponseBody(new String(responseBytes, "UTF-8")).getBytes("UTF-8");
}
OutputStream out = httpResponse.getOutputStream();
logger.info("wrappedResponse.getStatus() = {}", wrappedResponse.getStatus());
httpResponse.setStatus(wrappedResponse.getStatus());
httpResponse.setContentType(wrappedResponse.getContentType());
httpResponse.setContentLength(responseBytes.length);
out.write(responseBytes);
out.flush();
httpResponse.flushBuffer();
}
protected abstract String modifyResponseBody(String body);
}
最后的用户类：
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
public class ProxyResponseBodyRewriteFilter extends AbstractResponseBodyAlteringFilter {
@Value("${proxy.filter.prefix:/proxy/}")
String prefix;
private final static Logger logger = LoggerFactory.getLogger(ProxyResponseBodyRewriteFilter.class);
protected String modifyResponseBody(String body) {
body = body.replaceAll("href\\s*=\\s*\"\\s*/", "href=\"" + prefix);
body = body.replaceAll("src\\s*=\\s*\"\\s*/", "src=\"" + prefix);
body = body.replace("</head>", "<base href=\"/proxy/\"></head>");
return body;
}
}
我面临着类似的问题，想要使用引用的HttpProxyServlet，但还需要更改响应中嵌入的URL。我做了以下，作为子类化ProxyServlet的一部分，它的工作原理（尽管代码仍然有点倾向于我的用例而不是完全通用的），但我很好奇你是否发现了更简单/已编写的东西，@ snowindy？
public class CustomProxyServlet extends ProxyServlet {
@Override
protected void copyResponseEntity(
HttpResponse proxyResponse, HttpServletResponse servletResponse,
HttpRequest proxyRequest, HttpServletRequest servletRequest
) throws IOException {
HttpEntity entity = proxyResponse.getEntity();
if (entity != null) {
OutputStream servletOutputStream = servletResponse.getOutputStream();
if (isRewritable(proxyResponse)) {
RewriteOutputStream rewriter = null;
try {
rewriter = new RewriteOutputStream(servletOutputStream);
entity.writeTo(rewriter);
}
finally { rewriter.flush(); }
}
else {
// parent's default behavior
entity.writeTo(servletOutputStream);
}
}
}
private boolean isRewritable(HttpResponse httpResponse) {
boolean rewriteable = false;
Header[] contentTypeHeaders = httpResponse.getHeaders("Content-Type");
for (Header header : contentTypeHeaders) {
// May need to accept other types
if (header.getValue().contains("html")) rewriteable = true;
}
return rewriteable;
}
}
RewriteOutputStream的位置
public class RewriteOutputStream extends FilterOutputStream {
// Provided implementation based on BufferedOutputStream adding
// config-based string replacement before writing to output.
}
尝试在您的反向代理服务器的配置文件中将位置/代理更改为/ proxy /（尾部斜杠）。
如果您使用nginx作为反向代理服务器，请参阅链接。
https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/