How to avoid sending HTTP request from a Java web server to itself?

Question

Real situation is like this: Java web server (Weblogic) recieves a request from user for which it has to send a ZIP archive in response. Archive has to be dynamically generated from some files user asked for and one HTML report generated by the server itself. I would like to reuse JSF servlets the server already uses in other cases to generate this report. So, basically, what I use is:

HttpURLConnection  self = new URL ("http://me.myself.com/report.jsf?...").openConnection ();
String  report_html = fetchHtmlFromConnection (self);

and then create the requested ZIP, including the generated HTML in it.

The question is, can I somehow avoid making an internal HTTP request (to report.jsf) in this scenario? That involves basically pointless (since application just "talks" to itself anyway) roundtrips through operating system, HTTPD (which might be on a different machine), etc.

Answer 1

You should have a business service layer so that a "generateReport" service could be used inside multiple presentation views (even the "zip file" one).

You could do this in standard J2EE way via EJBs or through any custom framework that let you specify injectable business services (e.g. spring).

I think the main problem here is that you can generate the report only through the client interface (http). That makes it an isolated service, not available to other parts of the application. Basically you need a refactoring.

Do not code business inside JSFs or similar. (by the way, try not using jsf at all :D )

---

  BUSINESS LAYER              PRESENTATION
generateReportService---|---jsf-HtmlReport
                     \__|___
                        |   \ 
someOtherContentService-|----jsf-Zip

Answer 2

I am not very familiar with JSF, but from what I understand of them you can use a technic that is also applicable to JSP pages:

• Create your own HttpServletResponseWrapper (a class used by the container that lets you modify the response)
• Use it to override the default Writer (that writes the rendered page to the output) and provide one that writes the output to a String or a temporary file that will feed the compressing code.

There is a nice and simple tutorial that shows you how to do that: http://blog.valotas.com/2011/09/get-output-of-jsp-or-servlet-response.html

Then

• As hinted by gyan, get a ServletRequestDispatcher from your servlet that will let you invoke the rendering of the JSF
• Forward the servlet call in order to provide your own HttpServletResponseWrapper
• Use your HttpServletResponseWrapper to get the rendered HTML and feed it to the zipping code.

So the zipping Servlet would be like:

TempFileRespWrapper respWrapper = new TempFileRespWrapper();
RequestDispatcher dispatcher = getServletContext().getRequestDispatcher( "/report.jsf");
dispatcher.forward(request, respWrapper);
File f = respWrapper.getOutputPath();
addFileToZip(f);

Answer 3

Think about request dispatcher strategy, where request/response object would be sent to the report servlet from the entry servlet. In turn report servlet would generate the report and control can be sent to next servlet, which completes the rest of zip and send process.

For constructing a RequestDispatcher object, you can use either the ServletRequest.getRequestDispatcher() method or the ServletContext.getRequestDispatcher() method.

RequestDispatcher dispatcher=getServletContext().getRequestDispatcher( "/report.jsf" );
dispatcher.forward( request, response );

The next servlet set mime type as 'application/zip' and write the zip binary to browser. The user's browser would handle the content in the form of download depending on the browser settings.

Answer 4

Make sure that your web server is configured to cache (generated) html and you will not have to worry about it. First request to full or partial URL will generate a call to jsf generator and later it will be fetched from web server cache.

Yes, there will be a little overhead involved

(your source -> we server -> generator page or cache)

But it is going to be easier in the end.

Answer 5

Tested Solution!

This solution actually get ideas already posted here (specially from @gyan).

1. Write a Servlet to zip

(you could use an filter for that too. For example, suppose that you have a ZipFilter. You could map the filter for all *.zip and chain that filter with a URLRewrite filter for respective .jsf URL).

public class ZipServlet
    extends HttpServlet {

    @Override
    public void doGet(final HttpServletRequest request, final HttpServletResponse response) throws ServletException,
            IOException {

        ZipEntry zipEntry = new ZipEntry("helloWorld.html");
        ZipHttpServletResponseWrapper respWrapper = new ZipHttpServletResponseWrapper(response, zipEntry);
        RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/helloWorld.jsf");
        dispatcher.forward(request, respWrapper);
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "inline; filename=output.zip;");
        response.flushBuffer();
        respWrapper.getOutputStream().close();

    }

}

• NOTE : Yes, you should use RequestDispatcher

  1. ZipHttpServletResponseWrapper

There's no much to say about that. From Java 7, you can use a native Class to create zip files properly. Using Decorator pattern with ZipOutputStream on top of response.getOutputStream() should be recommended way.

Remember that HttpServletResponseWrapper is a decorator. You should not use that if you don't want to reuse the target "servlet" output directly (you could use an stunt HttpServletResponse rather than use HttpServletResponseWrapper).

public class ZipHttpServletResponseWrapper
    extends HttpServletResponseWrapper {

    private ZipEntry entry;
    private ZipServletOutputStreamWrapper streamWrapper;
    private ZipOutputStream outputStream;
    private PrintWriter printWriter;

    public ZipHttpServletResponseWrapper(HttpServletResponse response, ZipEntry entry) {
        super(response);
        this.entry = entry;
    }

    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        if (streamWrapper == null) {
            outputStream = new ZipOutputStream(this.getResponse().getOutputStream());
            outputStream.putNextEntry(entry);
            streamWrapper = new ZipServletOutputStreamWrapper(outputStream);
        }
        return streamWrapper;
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        if (printWriter == null) {
            printWriter = new PrintWriter(getOutputStream());
        }
        return printWriter;
    }

    private class ZipServletOutputStreamWrapper
        extends ServletOutputStream {

        private ZipOutputStream outputStream;

        public ZipServletOutputStreamWrapper(ZipOutputStream outputStream) {
            this.outputStream = outputStream;
        }

        @Override
        public void close() throws IOException {
            outputStream.closeEntry();
            outputStream.finish();
        }

        @Override
        public void write(int b) throws IOException {
            outputStream.write(b);
        }
    }

}

1. Now, the secret: mapping wisely!

Some important parts of JSF could use Filter chain (for example, myfaces from Apache use some extensions to provide some JSF components). In this case, you should specify in these filters digest FORWARD and REQUEST

    <filter-mapping>
        <filter-name>extensionsFilter</filter-name>
        <url-pattern>*.jsf</url-pattern>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>    
    </filter-mapping>