WebWork标签技术的简化版本--JSP模板

西部村里人 — Thu, 16 Mar 2006 14:57:00 GMT

   WebWork标签非常出色，在有些应用中，可能不想使用其环境，但希望能够使用其标签思路。JSP模板的使用面更广，随简化WebWork方式，提供思路供大家参考。

1、开发标签基础类：
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.io.Writer;
import java.util.Iterator;
import java.util.LinkedList;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.BodyTagSupport;
public abstract class AbstractTag extends BodyTagSupport {

    protected String templateName ;

    private final static String templatePath = "/WEB-INF/tags/";

    private static final long serialVersionUID = -1201668454354226175L;

    public String getTemplateName() {
        return templateName;
    }

    public void setTemplateName(String templateName) {
        this.templateName = templateName;
    }

    protected String getBody() {
        if (bodyContent == null) {
            return "";
        } else {
            return bodyContent.getString().trim();
        }
    }

    protected abstract void prepareData ();

    public int doEndTag() throws JspException {
        try {
            prepareData ();
            include(templatePath + this.getTemplateName(), pageContext.getOut(),
                    pageContext.getRequest(),
                    (HttpServletResponse) pageContext.getResponse());

        } catch (Exception e) {
            // e.printStackTrace();
            throw new JspException(e);
        }
        return EVAL_BODY_INCLUDE;
    }

    public int doStartTag() throws JspException {
        try {
            pageContext.getOut().write(getBody());
        } catch (IOException e) {
            throw new RuntimeException("IOError: " + e.getMessage(), e);
        }
        return EVAL_PAGE;
    }

    public static void include(String aResult, Writer writer,ServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
        String resourcePath = aResult;
        RequestDispatcher rd = request.getRequestDispatcher(resourcePath);
        if (rd == null) {
            throw new ServletException("Not a valid resource path:"
                    + resourcePath);
        }
        // Include the resource
        PageResponse pageResponse = new PageResponse(response);

        // Include the resource
        rd.include((HttpServletRequest) request, pageResponse);

        // write the response back to the JspWriter, using the correct encoding.
        String encoding = "GB2312";

        if (encoding != null) {
            // use the encoding specified in the property file
            pageResponse.getContent().writeTo(writer, encoding);
        } else {
            // use the platform specific encoding
            pageResponse.getContent().writeTo(writer, null);
        }
    }

    static final class PageResponse extends HttpServletResponseWrapper {

        protected PrintWriter pagePrintWriter;

        protected ServletOutputStream outputStream;

        private PageOutputStream pageOutputStream = null;

        /**
        * Create PageResponse wrapped around an existing HttpServletResponse.
        */
        public PageResponse(HttpServletResponse response) {
            super(response);
        }

        /**
        * Return the content buffered inside the {@link PageOutputStream}.
        *
        * @return
        * @throws IOException
        */
        public FastByteArrayOutputStream getContent() throws IOException {
            // if we are using a writer, we need to flush the
            // data to the underlying outputstream.
            // most containers do this - but it seems Jetty 4.0.5 doesn't
            if (pagePrintWriter != null) {
                pagePrintWriter.flush();
            }

            return ((PageOutputStream) getOutputStream()).getBuffer();
        }

        /**
        * Return instance of {@link PageOutputStream} allowing all data written
        * to stream to be stored in temporary buffer.
        */
        public ServletOutputStream getOutputStream() throws IOException {
            if (pageOutputStream == null) {
                pageOutputStream = new PageOutputStream();
            }

            return pageOutputStream;
        }

        /**
        * Return PrintWriter wrapper around PageOutputStream.
        */
        public PrintWriter getWriter() throws IOException {
            if (pagePrintWriter == null) {
                pagePrintWriter = new PrintWriter(new OutputStreamWriter(
                        getOutputStream(), getCharacterEncoding()));
            }

            return pagePrintWriter;
        }
    }

    static final class PageOutputStream extends ServletOutputStream {

        private FastByteArrayOutputStream buffer;

        public PageOutputStream() {
            buffer = new FastByteArrayOutputStream();
        }

        /**
        * Return all data that has been written to this OutputStream.
        */
        public FastByteArrayOutputStream getBuffer() throws IOException {
            flush();

            return buffer;
        }

        public void close() throws IOException {
            buffer.close();
        }

        public void flush() throws IOException {
            buffer.flush();
        }

        public void write(byte[] b, int o, int l) throws IOException {
            buffer.write(b, o, l);
        }

        public void write(int i) throws IOException {
            buffer.write(i);
        }

        public void write(byte[] b) throws IOException {
            buffer.write(b);
        }
    }


    static public class FastByteArrayOutputStream extends OutputStream {

        // Static --------------------------------------------------------
        private static final int DEFAULT_BLOCK_SIZE = 8192;

        private LinkedList buffers;

        // Attributes ----------------------------------------------------
        // internal buffer
        private byte[] buffer;

        // is the stream closed?
        private boolean closed;
        private int blockSize;
        private int index;
        private int size;

        // Constructors --------------------------------------------------
        public FastByteArrayOutputStream() {
            this(DEFAULT_BLOCK_SIZE);
        }

        public FastByteArrayOutputStream(int aSize) {
            blockSize = aSize;
            buffer = new byte[blockSize];
        }

        public int getSize() {
            return size + index;
        }

        public void close() {
            closed = true;
        }

        public byte[] toByteArray() {
            byte[] data = new byte[getSize()];

            // Check if we have a list of buffers
            int pos = 0;

            if (buffers != null) {
                Iterator iter = buffers.iterator();

                while (iter.hasNext()) {
                    byte[] bytes = (byte[]) iter.next();
                    System.arraycopy(bytes, 0, data, pos, blockSize);
                    pos += blockSize;
                }
            }

            // write the internal buffer directly
            System.arraycopy(buffer, 0, data, pos, index);

            return data;
        }

        public String toString() {
            return new String(toByteArray());
        }

        // OutputStream overrides ----------------------------------------
        public void write(int datum) throws IOException {
            if (closed) {
                throw new IOException("Stream closed");
            } else {
                if (index == blockSize) {
                    addBuffer();
                }

                // store the byte
                buffer[index++] = (byte) datum;
            }
        }

        public void write(byte[] data, int offset, int length) throws IOException {
            if (data == null) {
                throw new NullPointerException();
            } else if ((offset < 0) || ((offset + length) > data.length) || (length < 0)) {
                throw new IndexOutOfBoundsException();
            } else if (closed) {
                throw new IOException("Stream closed");
            } else {
                if ((index + length) > blockSize) {
                    int copyLength;

                    do {
                        if (index == blockSize) {
                            addBuffer();
                        }

                        copyLength = blockSize - index;

                        if (length < copyLength) {
                            copyLength = length;
                        }

                        System.arraycopy(data, offset, buffer, index, copyLength);
                        offset += copyLength;
                        index += copyLength;
                        length -= copyLength;
                    } while (length > 0);
                } else {
                    // Copy in the subarray
                    System.arraycopy(data, offset, buffer, index, length);
                    index += length;
                }
            }
        }

        // Public
        public void writeTo(OutputStream out) throws IOException {
            // Check if we have a list of buffers
            if (buffers != null) {
                Iterator iter = buffers.iterator();

                while (iter.hasNext()) {
                    byte[] bytes = (byte[]) iter.next();
                    out.write(bytes, 0, blockSize);
                }
            }

            // write the internal buffer directly
            out.write(buffer, 0, index);
        }

        public void writeTo(RandomAccessFile out) throws IOException {
            // Check if we have a list of buffers
            if (buffers != null) {
                Iterator iter = buffers.iterator();

                while (iter.hasNext()) {
                    byte[] bytes = (byte[]) iter.next();
                    out.write(bytes, 0, blockSize);
                }
            }

            // write the internal buffer directly
            out.write(buffer, 0, index);
        }

        public void writeTo(Writer out, String encoding) throws IOException {
            // Check if we have a list of buffers
            if (buffers != null) {
                Iterator iter = buffers.iterator();

                while (iter.hasNext()) {
                    byte[] bytes = (byte[]) iter.next();

                    if (encoding != null) {
                        out.write(new String(bytes, encoding));
                    } else {
                        out.write(new String(bytes));
                    }
                }
            }

            // write the internal buffer directly
            if (encoding != null) {
                out.write(new String(buffer, 0, index, encoding));
            } else {
                out.write(new String(buffer, 0, index));
            }
        }

        /**
         * Create a new buffer and store the
         * current one in linked list
         */
        protected void addBuffer() {
            if (buffers == null) {
                buffers = new LinkedList();
            }

            buffers.addLast(buffer);

            buffer = new byte[blockSize];
            size += index;
            index = 0;
        }
    }
}

2、定义一个具体的标签类
public class ListTag extends RiseAbstractTag {

    private static final long serialVersionUID = 3385568988234498913L;

    protected String templateName = "list.jsp";

    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    protected void prepareData() {
        this.setTemplateName(this.templateName);
        pageContext.getRequest().setAttribute("id", this.id);
    }
}

3、定义TLD文件
   参考TLD文档
4、定义list.jsp模板
<%@ page contentType="text/html; charset=GBK" %>

<%
String id = (String)request.getAttribute("id");
%>

<%= id %>

5、使用默认模板

6、使用自定义模板
   a: 定义模板
<%@ page contentType="text/html; charset=GBK" %>

<%
String id = (String)request.getAttribute("id");
out.println("Id is : " + id);
%>
   b: use it , 模板名：testList.jsp，放在/WEB-INF/tags目录下

西部村里人 2006-03-16 22:57 发表评论

BlogJava-西部村里人-随笔分类-WebWork+FreeMarker

WebWork标签技术的简化版本--JSP模板