tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Bob Jamison <rjami...@lincom-asg.com>
Subject Re: Future of Filter?
Date Wed, 25 Apr 2001 21:35:39 GMT
Craig R. McClanahan wrote:

> 
> Yep, you've got the pattern down.  It's also legal to use
> HttpServletResponseWrapper if you're wrapping HTTP responses.  And, of
> course, you can wrap the request if you want to do input filtering, in
> pretty much the same manner.
> 
> Craig
> 
> 
> 


Ok, thanks for the help!  I finally got
my first Filter working, with a little
cajoling (and some begging)  ;-)

This is the typical XSL transform that I
plan to use on a set of generic servlets which
will produce XML only, with stylesheets giving
the pages 'skins.'

I know this initial implementation is not optimal,
but it works for now.  The XSLTOutputStream took
a bit of imagination.  It plugs in like this:



<filter>
  <filter-name>XSLT Filter for Skin1</filter-name>
  <filter-class>XSLTFilter</filter-class>
  <init-param>
    <param-name>xsltFileName</param-name>
    <param-value>skin1.xsl</param-value>
  </init-param>
</filter>

<filter-mapping>
  <filter-name>Skin1Command</filter-name>
  <servlet-name>command</servlet-name>
</filter-mapping>











Anyway, thanks again.




Bob
















================= BEGIN XSLTFilter ==================


import java.io.*;
import javax.servlet.*;

public class XSLTFilter implements Filter
{

FilterConfig filterConfig;
String xsltName;
ServletResponse xsltResponse;


//---##### Inner class ServletResponse
class XSLTResponse extends ServletResponseWrapper
{
OutputStream outs;
ServletOutputStream souts;

public ServletOutputStream getOutputStream()
{
  return souts;
}

public XSLTResponse(ServletResponse response,String xslFileName)
           throws ServletException,IOException
{
  super(response);
  outs = new XSLTOutputStream(response.getOutputStream(),xslFileName);
  souts = new ServletOutputStream()
    {
        public void write(int ch) throws IOException
        {
        outs.write(ch);
        }
    };
}
}
//---##### end inner class ServletResponse



public void init(FilterConfig val)
              throws ServletException
{
  filterConfig=val;
  xsltName=filterConfig.getInitParameter("xsltFileName");
  if (xsltName==null)
   throw new ServletException("XSLTFilter.init():no file name given for 
init-param 'xsltFileName'");
}

public void doFilter(ServletRequest request,ServletResponse 
response,FilterChain chain)
              throws IOException,ServletException
{
  if (xsltResponse==null)
   try
     {
     xsltResponse = new XSLTResponse(response,xsltName);
     }
   catch (Exception e)
     {
     throw new ServletException("XSLTFilter.doFilter():"+e);
     }
  chain.doFilter(request,xsltResponse);
}

public void destroy()
{
}


}


================= END XSLTFilter ==================










================= BEGIN XSLTOutputStream ==================

import java.io.*;
import javax.xml.transform.*;
import javax.xml.transform.stream.*;


/**
* This class uses a very simple piping mechanism to "push" XML data through
* an XSL transform.
* @author Bob Jamison
* @date 25 Apr 01
*/
public class XSLTOutputStream extends FilterOutputStream
                             implements Runnable
{
OutputStream outputStream;
Transformer transformer;
PipedInputStream pins;
PipedOutputStream pouts;

public void run()
{
  try
   {
   transformer.transform(new StreamSource(pins),new 
StreamResult(outputStream));
   }
  catch (Exception e)
   {
   }
}

//Implement OutputStream things
/**
* Closes this output stream and releases any system resources
* associated with this stream. The general contract of <code>close</code>
* is that it closes the output stream. A closed stream cannot perform
* output operations and cannot be reopened.
* <p>
* @exception  IOException  if an I/O error occurs.
*/
public void close() throws IOException
{
  pouts.flush();
  pouts.close();
  //pins.close();
}

/**
* Flushes this output stream and forces any buffered output bytes
* to be written out. The general contract of <code>flush</code> is
* that calling it is an indication that, if any bytes previously
* written have been buffered by the implementation of the output
* stream, such bytes should immediately be written to their
* intended destination.
* <p>
* @exception  IOException  if an I/O error occurs.
*/
public void flush() throws IOException
{
  pouts.flush();
}

/**
* Writes <code>b.length</code> bytes from the specified byte array
* to this output stream. The general contract for <code>write(b)</code>
* is that it should have exactly the same effect as the call
* <code>write(b, 0, b.length)</code>.
*
* @param      b   the data.
* @exception  IOException  if an I/O error occurs.
* @see        java.io.OutputStream#write(byte[], int, int)
*/
public void write(byte[] b) throws IOException
{
  pouts.write(b);
}

/**
* Writes <code>len</code> bytes from the specified byte array
* starting at offset <code>off</code> to this output stream.
* The general contract for <code>write(b, off, len)</code> is that
* some of the bytes in the array <code>b</code> are written to the
* output stream in order; element <code>b[off]</code> is the first
* byte written and <code>b[off+len-1]</code> is the last byte written
* by this operation.
* <p>
* The <code>write</code> method of <code>OutputStream</code> calls
* the write method of one argument on each of the bytes to be
* written out. Subclasses are encouraged to override this method and
* provide a more efficient implementation.
* <p>
* If <code>b</code> is <code>null</code>, a
* <code>NullPointerException</code> is thrown.
* <p>
* If <code>off</code> is negative, or <code>len</code> is negative,
or
* <code>off+len</code> is greater than the length of the array
* <code>b</code>, then an <tt>IndexOutOfBoundsException</tt> is thrown.
*
* @param      b     the data.
* @param      off   the start offset in the data.
* @param      len   the number of bytes to write.
* @exception  IOException  if an I/O error occurs. In particular,
*             an <code>IOException</code> is thrown if the output
*             stream is closed.
*/
public void write(byte[] b, int off, int len) throws IOException
{
  pouts.write(b,off,len);
}

/**
* Writes the specified byte to this output stream. The general
* contract for <code>write</code> is that one byte is written
* to the output stream. The byte to be written is the eight
* low-order bits of the argument <code>b</code>. The 24
* high-order bits of <code>b</code> are ignored.
* <p>
*
* @param      b   the <code>byte</code>.
* @exception  IOException  if an I/O error occurs. In particular,
*             an <code>IOException</code> may be thrown if the
*             output stream has been closed.
*/
public void write(int b) throws IOException
{
  pouts.write(b);
}

void setup(OutputStream outputStream, Transformer transformer)
                throws IOException
{
  this.transformer = transformer;
  this.outputStream = outputStream;
  pins = new PipedInputStream();
  pouts = new PipedOutputStream(pins);
  (new Thread(this)).start();
}

/**
* Creates an output stream that translates output according to the
* given XSLT Transformer.
*
* @param      outputStream  the existing XML stream to transform
* @param      transformer   the configured XSLT Transformer (see TRaX)
* @exception  IOException  if an I/O error occurs. In particular,
*             an <code>IOException</code> may be thrown if the
*             output stream has been closed.
*/
public XSLTOutputStream(OutputStream outputStream, Transformer transformer)
                 throws IOException
{
  super((OutputStream)null);
  setup(outputStream,transformer);
}

/**
* Creates an output stream that translates output according to the
* given XSLT source file..
*
* @param      outputStream  the existing XML stream to transform
* @param      xslFile       the name of the XSL stylesheet file
* @exception  TransformerException if there is a problem creating a
*             transformer from the named file
* @exception  IOException  if an I/O error occurs. In particular,
*             an <code>IOException</code> may be thrown if the
*             output stream has been closed.
*/
public XSLTOutputStream(OutputStream outputStream, String xslFile)
                throws IOException
{
  super((OutputStream)null);
  try
   {
   TransformerFactory factory = TransformerFactory.newInstance();
   Transformer transformer = factory.newTransformer(new 
StreamSource(xslFile));
   setup(outputStream,transformer);
   }
  catch (TransformerException e)
   {
   throw new IOException("XSLTOutputStreamConstructor:"+e);
   }
}

///### T E S T I N G
static boolean test(String xmlName,String xslName)
{
  try
   {
   FileInputStream ins = new FileInputStream(xmlName);
   XSLTOutputStream outs = new XSLTOutputStream(System.out,xslName);
   while (true)
     {
     int ch = ins.read();
     if (ch<0)
       break;
     outs.write(ch);
     }
   ins.close();
   outs.close();
   }
  catch (Exception e)
   {
   e.printStackTrace();
   return false;
   }
  return true;
}

public static void main(String argv[])
{
  if (argv.length==2)
   {
   test(argv[0],argv[1]);
   }
  else
   {
   System.out.println("usage: XSLOutputStream xmlFile xslFile");
   return;
   }
  }

}



================= END XSLTOutputStream ==================




Mime
View raw message