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\n﹤html﹥\r\n﹤head﹥\r\n﹤body﹥\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技术实现动态页面到静态页面的方案,从动态页面到静态的转变就已经告一段落,你是否有点启发呢?

 

【编辑推荐】

  1. JSP开发中的脚本编程浅析
  2. JSP教程基础篇之JSP的技术特点
  3. JSP教程基础知识之JSP2.0特性
  4. JSP入门之网站环境搭建的步骤
  5. JSP入门之避免Form表单重复提交的几种方案
责任编辑:仲衡 来源: 互联网转载
相关推荐

2009-07-06 18:23:56

Struts和JSPJSP页面

2009-07-03 18:12:49

JSP页面

2009-11-23 16:09:50

PHP实现伪静态化页面

2009-01-18 10:56:27

JSTLEL表达式JSP标准标记库

2011-05-11 16:54:49

JSP

2011-05-06 09:36:16

动态页面

2009-08-24 18:00:52

ASP.NET模板生成

2009-07-02 09:25:41

JSP实现页面跳转

2009-02-05 17:09:02

动态图片JSPTomcat

2009-06-25 14:05:01

JavaBean实现J

2009-07-01 11:05:18

页面与代码分离JSP源码

2009-07-06 09:34:19

JSP页面

2009-07-01 18:50:29

Dreamweaver

2012-07-19 10:59:18

Jav并发

2012-06-13 02:10:46

Java并发

2009-07-24 10:53:51

ASP.NET实现静态

2010-03-25 18:09:23

Nginx配置文件

2009-07-06 10:00:31

JSP页面传值

2009-03-05 10:10:52

饼图数据库JSP

2012-05-04 09:40:01

JSP时间控件Java
点赞
收藏

51CTO技术栈公众号