Java http reverse proxy with response HTML URL rewriting - servlets

Question

I want my Java web application to seamless proxy content provided by abother web server.
http://myapp.com/proxy/* -> http://other_app_to_proxy.com:9090/
My application will handle all auth-related matters, and serve other application on sub-path under same domain.
I found how to do reverse proxy: HTTP-Proxy-Servlet.
The problem now is that other application has absolute URLs like /css/style.css and when page gets open in my application, this URL is not accessible, as in my setup it should be /proxy/css/style.css.
I figured out I need some kind of URL-rewriting filter that would alter outbound response that goes to client. I tried to study Tuckey UrlRewrite but it looks like it's for different purpose - it has plenty of tools to change inbound URL and redirect requests to other locations.
Could somebody point me to some solution?

Answer 1

I came up to several classes that allow full response body rewriting in filter.
A couple of base classes:
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);
}
And here final user class:
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;
}
}

Answer 2

I'm facing a similar issue, wanting to use the referenced HttpProxyServlet but also needing to alter URLs embedded in the response. I did the following, as part of subclassing the ProxyServlet, and it works (albeit the code is still a bit slanted towards my use case and not totally generic), but I'm curious if you ever found something simpler/already written, #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;
}
}
where RewriteOutputStream is
public class RewriteOutputStream extends FilterOutputStream {
// Provided implementation based on BufferedOutputStream adding
// config-based string replacement before writing to output.
}

Answer 3

This is admittedly a workaround rather than an actual solution, but this information may be useful to those who have control over the proxied application. We were able to use Smiley's Proxy Servlet as is and avoided having to do URL-rewriting by deploying the proxied application using a structure that matches the structure under which the proxied pages are made available by the proxy servlet.
http://myapp.com/proxy/* -> http://other_app_to_proxy.com:9090/proxy/*

Answer 4

Try changing location /proxy to /proxy/ (trailing slash) in the config file of Your reverse proxy's server.
Refer the link if your using nginx as reverse proxy server.
https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/