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

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

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

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

下面是一个JSP文件test.jsp

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

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

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

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

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

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

实现替换

假设

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

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

更新问题

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

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

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

◆永远不更新

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

文章名称：JSP技术实现动态页面到静态页面的方案
当前网址：http://www.hantingmc.com/qtweb/news46/333846.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸网站建设知识

分类信息网站

中国电信成都枢纽中心　　 　成都棕树机房　　 　成都富士康招工　　 　南充网站建设　　 　雅安服务器托管　　 　绵竹网站建设　　 　自适应网页设计　　 　娃娃鱼鱼苗　　 　成都网站推广公司　　 　成都气球装饰　　 　成都品牌官网设计公司　　 　关键词优化　　 　公司宣传册设计　　 　成都网站建设　　 　公路钻孔机　　 　轻质隔墙板　　 　成都小程序定制开发公司　　 　电信服务器托管　　 　成都画册制作　　 　成都建站