转载

JSP技术实现动态页面到静态页面的方案

对于JSP技术实现动态页面到静态页面的方案,我们从三个步骤来说明:

JSP技术实现动态页面到静态页面的方案第一:

为了能深入浅出的理解这个框架的由来,我们首先来了解一下JSP解析器将我们写的JSP代码转换成的JAVA文件的内容。

下面是一个JSP文件test.jsp

  1. %@ page language=java  contentType=text/html;charset=GB2312 %  
  2.  
  3. %  
  4. out.write(!--文件开始--);  
  5. %  
  6.  
  7. html  
  8. head  
  9. body  
  10. %=输出%  
  11. /body  
  12. /head  
  13. /html  
  14.  

经过Tomcat转换出的Java文件test$jsp.java内容如下:

  1. package org.apache.jsp;  
  2. import javax.servlet.*;  
  3. import javax.servlet.http.*;  
  4. import javax.servlet.jsp.*;  
  5. import org.apache.jasper.runtime.*;  
  6.  
  7. public class test$jsp extends HttpJspBase {  
  8.  
  9.  static {  
  10.  
  11.  }  
  12.  public testOutRedir$jsp( ) {  
  13.  }  
  14.  
  15.  private static boolean _jspx_inited = false;  
  16.  
  17.  public final void _jspx_init() throws org.apache.jasper.runtime.JspException {  
  18.  
  19.     }  
  20.    public void _jspService(HttpServletRequest request, HttpServletResponse  response)  
  21.  
  22.         throws java.io.IOException, ServletException {  
  23.  JspFactory _jspxFactory = null;  
  24.  PageContext pageContext = null;  
  25.  HttpSession session = null;  
  26.         ServletContext application = null;  
  27.         ServletConfig config = null;  
  28.        JspWriter outnull;  
  29.         Object page = this;  
  30.         String  _value = null;  
  31.         try {  
  32.  
  33.             if (_jspx_inited == false) {  
  34.                 synchronized (this) {  
  35.                     if (_jspx_inited == false) {  
  36.                         _jspx_init();  
  37.                        _jspx_inited = true;  
  38.  
  39.                     }  
  40.                 }  
  41.             }  
  42.             _jspxFactory = JspFactory.getDefaultFactory();  
  43.  
  44.             response.setContentType(text/html;charset=GB2312);  
  45.  
  46.             pageContext = _jspxFactory.getPageContext(this, request, response,  
  47.  
  48.                           , true, 8192, true);  
  49.  
  50.             application = pageContext.getServletContext();  
  51.             config = pageContext.getServletConfig();  
  52.             session = pageContext.getSession();  
  53.            outpageContext.getOut();  
  54.  
  55.                //为了节省篇幅,我删除了解释器添加的注释  
  56.  
  57.                out.write(/r/n);  
  58.  
  59.   //上一句是由于  
  60.  %@ page language=java  contentType=text/html;charset=GB2312 %后面的换行产生的  
  61.  
  62.                out.write(!--文件开始--);  
  63.  
  64.                out.write(/r/nhtml/r/nhead/r/nbody/r/n);  
  65.  
  66.                out.print(输出);  
  67.  
  68.                out.write(/r/n/body/r/n/head/r/n/html/r/n);  
  69.  
  70.         } catch (Throwable t) {  
  71.  
  72.             if (out!= null &&out.getBufferSize() != 0)  
  73.  
  74.                out.clearBuffer();  
  75.  
  76.             if (pageContext != null) pageContext.handlePageException(t);  
  77.  
  78.         } finally {  
  79.  
  80.             if (_jspxFactory != null) _jspxFactory.releasePageContext(pageContext);  
  81.  
  82.         }  
  83.  
  84.     }  
  85.  
  86. }  
  87.  

从上面的代码中可以清晰的看到JSP内建的几个对象(out、request、response、session、pageContext、application、config、page)是怎么产生的,懂servlet的朋友一看就能明白。

下面重点理解一下out对象,它被声明为JspWriter类型,JspWriter是一个抽象类,在包javax.servlet.jsp中可以找到它的定义。

  1. abstractpublicclassjavax.servlet.jsp.JspWriterextends java.io.Writer{  
  2.  
  3.       final public static intNO_BUFFER = 0;  
  4.  
  5.       final public static intDEFAULT_BUFFER = -1;  
  6.  
  7.       final public static intUNBOUNDED_BUFFER = -2;  
  8.  
  9.       protected intbufferSize;  
  10.  
  11.       protected BooleanautoFlush;  
  12.  
  13.       protectedjavax.servlet.jsp.JspWriter(intarg1,booleanarg2);  
  14.  
  15.         
  16.  
  17.    abstractpublicvoidnewLine()throwsIOException;  
  18.  
  19.    abstractpublicvoidprint(booleanarg0)throwsIOException;  
  20.  
  21.    abstractpublicvoidprint(chararg0)throwsIOException;  
  22.  
  23.    abstractpublicvoidprint(intarg0)throwsIOException;  
  24.  
  25.    abstractpublicvoidprint(longarg0)throwsIOException;  
  26.  
  27.    abstractpublicvoidprint(floatarg0)throwsIOException;  
  28.  
  29.    abstractpublicvoidprint(doublearg0)throwsIOException;  
  30.  
  31.    abstractpublicvoidprint(char[]arg0)throwsIOException;  
  32.  
  33.    abstractpublicvoidprint(Stringarg0)throwsIOException;  
  34.  
  35.    abstractpublicvoidprint(Objectarg0)throwsIOException;  
  36.  
  37.    abstractpublicvoidprintln()throwsIOException;  
  38.  
  39.    abstractpublicvoidprintln(booleanarg0)throwsIOException;  
  40.  
  41.    abstractpublicvoidprintln(chararg0)throwsIOException;  
  42.  
  43.    abstractpublicvoidprintln(intarg0)throwsIOException;  
  44.  
  45.    abstractpublicvoidprintln(longarg0)throwsIOException;  
  46.  
  47.    abstractpublicvoidprintln(floatarg0)throwsIOException;  
  48.  
  49.    abstractpublicvoidprintln(doublearg0)throwsIOException;  
  50.  
  51.    abstractpublicvoidprintln(char[]arg0)throwsIOException;  
  52.  
  53.    abstractpublicvoidprintln(Stringarg0)throwsIOException;  
  54.  
  55.    abtractpublicvoidprintln(Objectarg0)throwsIOException;  
  56.  
  57.    abstractpublicvoidclear()throwsIOException;  
  58.  
  59.    abstractpublicvoidclearBuffer()throwsIOException;  
  60.  
  61.    abstractpublicvoidflush()throwsIOException;  
  62.  
  63.    abstractpublicvoidclose()throwsIOException;  
  64.  
  65.    publicintgetBufferSize() ;  
  66.  
  67.    abstractpublicintgetRemaining();  
  68.  
  69.    publicbooleanisAutoFlush();  
  70.  
  71. }  
  72.  

相信到这里你可能已经知道怎么做了。是的,来个偷天换日,继承JspWriter类,然后实现其定义的虚函数,然后把out变量替换成你自己实现的类的实例就ok了。

JSP技术实现动态页面到静态页面的方案第二:

实现替换

假设

  1. %@ page language=java  contentType=text/html;charset=GB2312 import=jwb.util.HtmlIntoFile,jwb.util.TempSinglet,java.io.File%  
  2. %  
  3.  
  4. JspWriter outout_bak =out;String arg1=argument1;String filePath = /cache/根据参数生成文件名_ + arg1 + .html;  
  5.  
  6. //首先判断文件是否已经存在,如果不存在则执行本页面,否则跳转到静态页面就OK了File f = new File(pageContext.getServletContext().getRealPath(filePath));  
  7.  
  8. if(f.exists()){ out_bak.clear(); pageContext.forward(filePath); System.out.println(直接转到静态页面);  
  9.  
  10.  return;}outnew HtmlIntoFile(pageContext.getServletContext().getRealPath(filePath));out.write(!--文件开始--);  
  11. %  
  12. html  
  13. head  
  14. body  
  15. %= 看吧,这就是输出被重定向到文件的实现,很简单吧^_^%  
  16. /body  
  17. /head  
  18. /html  
  19. %  
  20. out.close();  
  21.  
  22. //关闭生成的静态文件out_bak.clear();pageContext.forward(filePath);  
  23.  
  24. System.out.println(执行本页面后再转到静态页面);return;  
  25. %  
  26.  

JSP技术实现动态页面到静态页面的方案第三:

更新问题

下面就讨论一下如何更新生成静态文件,其实从上面实现中你可以看到,很简单的就是将生成的静态文件删除即可,至于什么时候删除,要看你的需求了。我能想到的几种情况如下

◆当用来生成页面的数据更新时

◆如果不需要很提供时时的数据可以定时更新

◆永远不更新

那么通过这个JSP技术实现动态页面到静态页面的方案,从动态页面到静态的转变就已经告一段落,你是否有点启发呢?

正文到此结束
Loading...