JSP 静态生成html的原理

        在性能上讲，即使将JSP或ACTION转换成HTML文件还是不如将某张JSP或某个ACTION缓存起来再作应响这种策略。但是，对大型的系统，JSP页面和ACTION可能成千上万，页每张JSP或每个ACTION反回的数据大概有几K左右。当然，我们只是缓存访问最频繁的页面，即使最繁的页面也可能有很多，所以也不能全部缓存。再说，缓存起来的数据也要定时更新，如果多了，定时更新也存在一定的问题，这就是为什么要静态HTML的理由了。 
废话就不多说了，下面我们讨论一下如何将JSP或ACTION转换成HTML。其实这是一个非常简单的过程，你只要理解response对象的作用和知道如何正确编码就可以了。大家都知道，JSP在执行前是先被转译成Java文件，再编译成class文件再服务的。在每个JSP实例都有个service方法，而这个service方法将动态数据解释成以html标记的内容，然后再用response的writer对象将一段一段地内容写向服务器，完毕后刷新writer对象和关闭它，最后客户端所得到的就是html内容了。 
既然是这样，如果在客户访某个JSP或ACTION前，我们先在服务端访问它，然后将得到的内容存到一个字节数组中，当客户端要访问我们在服务端已经访问过的ACTION或JSP时，我们直接用response的OutputStream将储存这个页面或ACTIONR的字节数组输出到客户端。这不就是避勉当每一次请求那个action或jsp都要执行一次吗？如果这样是可行的话，那么剩下的就是如何在服务端虚构一个客户来访问要缓存一页面了。 
在虚构客户这方面，最直接的做法就是用一个SERVLET，在SERVLET的doPost或doGet方法中要实现：一、可以请求某个JSP或ACTION。二、在请求之后能获取一个InputStream。三、这个InputStream所读取的数据能保存到特定的地方。 

要实现doPost或doGet方法中的三个方面的要求有很多做法，但都基于读取服务器响应的数据。有种比较麻烦的实现是：

1.创建一个OutputStream。

2.用这个OutputStream来创建一个ServletOutputStream。

3.用这个OutputStream创建一个OutputStreamWriter。

4.用这个OuputStreamWriter创建一个PrintWriter。

5.用上面创建的ServletOutputStream和PrintWriter和response对象来新建一个HttpSerlvetResponse对象。

6.用request对象在指定的URL上获取一个RequestDispatcher对象。

7.用这个RequestDispatcher对象的include(req,res)方法，将请求的数据转到request和刚才新建一那个response对象上。

8.最后调用PrintWriter的close和OuputStream的close。 
经过上面一系列的处理，服务端响应的数据将写到特定的OutputStream上了。下面是代码：

String fileForOuput = “C: //xxx.html”; FileOutputStream os = new  FileOutputStream(fileForOuput); final  ServletOutputStream stream = new  ServletOutputStream() {        public  void  write( byte [] data, int  offset, int  length) {                  try  {                         os.write(data, offset, length);                  } catch  (IOException e) {                      e.printStackTrace();                  }        }        public  void  write( int  b) throws  IOException {                os.write(b);        } }; final  PrintWriter pw = new  PrintWriter( new  OutputStreamWriter(os)); HttpServletResponse rep = new  HttpServletResponseWrapper(response) {            public  ServletOutputStream getOutputStream() {                     return  stream;             }               public  PrintWriter getWriter() {                    return  pw;             } }; String url = http: //localhost:port/page; RequestDispatcher rd = request.getRequestDispatcher(url); rd.include(request, rep); pw.flush(); pw.close(); os.close();

这种方法是可行的，但比较罗索，代码比较长，URL和URLConnection为我们封装了上面的几步，我们只要从它那里直接获取InputStream以相应的编码格式读取服务器响应的html内容，再保存就可以了。 
如果真的要生成HTML的话，也不能“一劳永逸”式地实现，因为JSP和ACTION都是态动的，在不同时该所生成的内容可能不同，这就要一个底级线程定期实现上面的操作和注销缓存或删除旧的html文件以达到更新目的。

 

---------------------------------------------

 

方法：

第一步，加入servlet.代码如下。

import  java.io.ByteArrayOutputStream;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.OutputStreamWriter;
import  java.io.PrintWriter;

import  javax.servlet.RequestDispatcher;
import  javax.servlet.ServletContext;
import  javax.servlet.ServletException;
import  javax.servlet.ServletOutputStream;
import  javax.servlet.http.HttpServlet;
import  javax.servlet.http.HttpServletRequest;
import  javax.servlet.http.HttpServletResponse;
import  javax.servlet.http.HttpServletResponseWrapper;
/**
* Title: PageToHtml
* Description:JspToHtml Servlet
*  @author  dark
*  @version  1.0
* @Date Nov 04, 2010
*/
public class  ToHtml  extends  HttpServlet {
private static final long  serialVersionUID  = 1L ;

/**
* Default constructor. 
*/
public  ToHtml() {
//  TODO Auto-generated constructor stub
}

/**
* 
*/
public void  service(HttpServletRequest request, HttpServletResponse response)  throws  ServletException, IOException {
String url  = "" ;
String name  = "" ;
ServletContext sc  =  getServletContext();
// 你要访问的jsp文件名，如index,不包括扩展名 // 则你访问这个servlet是加参数，如http: // localhost/test/toHtml?file_name=index 
String file_name  =  request.getParameter( " file_name " );
// 你要生成的也没的文件名
url  = " / " +  file_name  + " .jsp " ;
//  这是生成的html文件名,如index.htm.文件名字与源文件名相同。扩展名为htm
name  = " F:\\work\\eclipse\\PageToHtml\\WebContent " + " \\ " +  file_name  + " .html " ;
RequestDispatcher rd  =  sc.getRequestDispatcher(url);
final  ByteArrayOutputStream os  = new  ByteArrayOutputStream();

final  ServletOutputStream stream  = new  ServletOutputStream() {
public void  write( byte [] data, int  offset,  int  length){
os.write(data, offset, length);
}
@Override
public void  write( int  b)  throws  IOException {
os.write(b);
}
};

final  PrintWriter pw  = new  PrintWriter( new  OutputStreamWriter(os));
HttpServletResponse rep  = new  HttpServletResponseWrapper(response){
public  ServletOutputStream getOutputStream(){
return  stream;
}

public  PrintWriter getWriter(){
return  pw;
}

};

rd.include(request, rep);
pw.flush();
FileOutputStream fos  = new  FileOutputStream(name); // 把jsp输出的内容写到xxx.html
os.writeTo(fos);
fos.close();
PrintWriter out  =  response.getWriter();
out.print( " <p align=center><font size=3 color=red>页面已经成功生成！single<br>http://www.agilejava.org/space/? 233</font></p> " ); 





}


/**
*  @see  HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void  doGet(HttpServletRequest request, HttpServletResponse response)  throws  ServletException, IOException {
//  TODO Auto-generated method stub
}

/**
*  @see  HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void  doPost(HttpServletRequest request, HttpServletResponse response)  throws  ServletException, IOException {
//  TODO Auto-generated method stub
}

}

 第二步、配置你的web.xml

< servlet >
< description >
</ description >
< display-name > ToHtml </ display-name >
< servlet-name > ToHtml </ servlet-name >
< servlet-class >
com.dark.tohtml.ToHtml </ servlet-class >
</ servlet >
< servlet >
< description >
</ description >
< display-name > ServletContext </ display-name >
< servlet-name > ServletContext </ servlet-name >
< servlet-class >
com.dark.tohtml.ServletContext </ servlet-class >
</ servlet >

第三步、运行servlet。如：http://localhost:8080/test/toHtml?file_name=index 
 OK,这就在你的test项目的根目录下，生成了一个index.htm的静态文件。　 
局限性：本文只能生成一个文件！访问一次，生成一个文件。并且生成的文件名也与原来的文件名相同。 
比较适合主页生成静态页面。 
本系列的后续文章将解决更多的问题。使之在新闻发布系统中，很容易就集成应用。

生成静态页面技术解决方案之二

    在上一篇文章中，生成静态页面，是有一定的局限性的。生成主页是很方便，但要生成二级页面，就不方便了。 
    本文假设一个新闻发布系统。希望后台发布的，前台显示的是静态的文档。这就涉及，主页要是静态的，同时二级列表也是静态的，新闻内容也是静态的。也就是说， 在发布一篇新闻的时候，可能涉及到三个地方生成静态文档。并且，要生成一个网页，必须访问一个servlet。在大量生成静态网页的时候， 
    以下方法，可以解决这些问题。 
    一、加入一下servelet 

/**  
* @file_name 文件名及文件之后的参数.最好为a.jsf?fileId=aaaa 
* @path 文件所在的路径.相对于根目录而言的. 
* @realName文件要保存的名字 
* @realPath文件要保存的真实路径。默认与文件所在的目录相同。 
*/  
public class  ToHtmlPath  extends  HttpServlet { 

public void  service(HttpServletRequest request, HttpServletResponse response) 
throws  ServletException, IOException { 
String url  = "" ; 
String name  = "" ; 

ServletContext sc  =  getServletContext(); 

String file_name  =  request.getParameter( " file_name " ); //  你要访问的jsp文件,如news.jsf。 
//  file_name如：fileDetail.jsf?fileId=56.要是有参数， 只有一个参数。并且以参数名作为文件名。 
String realName  =  request.getParameter( " realName " ); //  要保存的文件名。如aaa;注意可以没有这个参数。 

String path  =  request.getParameter( " path " ); //  你要访问的jsp文件路径。如news。注意可以没有这个参数。 

String realPath  =  request.getParameter( " realPath " ); //  你要保存的文件路径,如htmlNews.注意可以没有这个参数。 
//  下面确定要保存的文件名字。 
if  (realName  == null ||  realName  == "" ) { 
int  a  = 0 ; 
a  =  file_name.indexOf( " = " )  + 1 ; 
realName  =  file_name.substring(a); 
if  (realName.indexOf( " . " ) > 0 ) { 
realName  =  file_name.substring( 0 , file_name.indexOf( " . " )); 
} 
} 
//  下面构造要访问的页面。 
if  (path  == null ||  path  == "" ) { 
url  = " / " +  file_name; //  这是你要生成HTML的jsp文件,如 
}  else  { 
url  = " / " +  path  + " / " +  file_name; //  这是你要生成HTML的jsp文件,如 
} 
//  下面构造要保存的文件名，及路径。 
//  1、如果有realPath，则保存在realPath下。 
//  2、如果有path则保存在path下。 
//  3、否则，保存在根目录下。 
if  (realPath  == null ||  realPath  == "" ) { 
if  (path  == null ||  path  == "" ) { 
name  =  ConfConstants.CONTEXT_PATH  + " \\ " +  realName  + " .htm " ; //  这是生成的html文件名,如index.htm.说明： ConfConstants.CONTEXT_PATH为你的上下文路径。 
}  else  { 
name  =  ConfConstants.CONTEXT_PATH  + " \\ " +  path  + " \\ "  
+  realName  + " .htm " ; //  这是生成的html文件名,如index.htm. 
} 
}  else  { 
name  =  ConfConstants.CONTEXT_PATH  + " \\ " +  realPath  + " \\ "  
+  realName  + " .htm " ; //  这是生成的html文件名,如index.htm. 
} 

//  访问请求的页面，并生成指定的文件。 
RequestDispatcher rd  =  sc.getRequestDispatcher(url); 

final  ByteArrayOutputStream ōs  = new  ByteArrayOutputStream(); 

final  ServletOutputStream stream  = new  ServletOutputStream() { 
public void  write( byte [] data,  int  offset,  int  length) { 
os.write(data, offset, length); 
} 

public void  write( int  b)  throws  IOException { 
os.write(b); 
} 
}; 

final  PrintWriter pw  = new  PrintWriter( new  OutputStreamWriter(os)); 

HttpServletResponse rep  = new  HttpServletResponseWrapper(response) { 
public  ServletOutputStream getOutputStream() { 
return  stream; 
} 

public  PrintWriter getWriter() { 
return  pw; 
} 
}; 
rd.include(request, rep); 
pw.flush(); 
FileOutputStream fos  = new  FileOutputStream(name);  //  把jsp输出的内容写到xxx.htm 
os.writeTo(fos); 
fos.close(); 
PrintWriter ōut  =  response.getWriter(); 
out.print( " <p align=center><font size=3 color=red>success！</font></p> " ); 
} 
}

二、在web.xml里面配置你的servlet 

< servlet >  
< servlet-name > toHtmlPath </ servlet-name >  
< servlet-class > mj.util.html.ToHtmlPath </ servlet-class >  
</ servlet >  
< servlet-mapping >  
< servlet-name > toHtmlPath </ servlet-name >  
< url-pattern > /toHtmlPath </ url-pattern >  
</ servlet-mapping >

三、写一个通用的方法，　供调用。

public class  CallHtml { 

public static void  callOnePage(String fileName, String path, 
String realName, String realPath) { 
try  { 
String str  = " http://localhost:8080/test/toHtmlPath?file_name= "  
+  fileName  + " &&path= " +  path  + " &&realName= " +  realName 
+ " &&realPath= " +  realPath; 
int  httpResult; 
URL url  = new  URL(str); 
URLConnection connection  =  url.openConnection(); 
connection.connect(); 
HttpURLConnection httpURLConnection  =  (HttpURLConnection) connection; 
httpResult  =  httpURLConnection.getResponseCode(); 
if  (httpResult  !=  HttpURLConnection.HTTP_OK) { 
System.out.println( " 没有连接成功 " ); 
}  else  { 
System.out.println( " 连接成功了　 " ); 
} 
}  catch  (Exception e) { 
//  TODO: handle exception 
} 
} 

// 这个方法适当重载，就可以省去一些参数传递。 

}

 四、在你的新闻发布save时，调用方法。 

          1、CallHtml.callOnePage("info.jsf?file_id=aaa",news,"", "");//将在news目录下生成一个aaa.htm的静态文件 

          2、CallHtml.callOnePage("newsList.jsf",news,"", "");//将在news目录下生成一个newsList.htm的静态文件,显示最新的新闻。 

          ３、CallHtml.callOnePage("index.jsf","","", "");//生成主页。 

          好了，这就保持了，主页、列表、新闻内容都是最新的静态页面了。 


---------------------------------------------------------------------------------------------------- 
一个实现将动态页面转为静态的方案 

1.前言 
为了能深入浅出的理解这个框架的由来，我们首先来了解一下JSP解析器将我们写的JSP代码转换成的JAVA文件的内容。 
下面是一个JSP文件test.jsp 
经过TOMCAT转换出的JAVA文件test$jsp.java内容如下：

package  org.apache.jsp; 
import  javax.servlet. * ; 
import  javax.servlet.http. * ; 
import  javax.servlet.jsp. * ; 
import  org.apache.jasper.runtime. * ; 

public class  test$jsp  extends  HttpJspBase { 

static  { 
} 
public  testOutRedir$jsp( ) { 
} 

private static boolean  _jspx_inited  = false ; 

public final void  _jspx_init()  throws  org.apache.jasper.runtime.JspException { 
} 

public void  _jspService(HttpServletRequest request, HttpServletResponse response) 
throws  java.io.IOException, ServletException { 

JspFactory _jspxFactory  = null ; 
PageContext pageContext  = null ; 
HttpSession session  = null ; 
ServletContext application  = null ; 
ServletConfig config  = null ; 
JspWriter out  = null ; 
Object page  = this ; 
String _value  = null ; 
try  { 

if  (_jspx_inited  == false ) { 
synchronized  ( this ) { 
if  (_jspx_inited  == false ) { 
_jspx_init(); 
_jspx_inited  = true ; 
} 
} 
} 
_jspxFactory  =  JspFactory.getDefaultFactory(); 
response.setContentType(text / html;charset = GB2312); 
pageContext  =  _jspxFactory.getPageContext( this , request, response, 
,  true ,  8192 ,  true ); 

application  =  pageContext.getServletContext(); 
config  =  pageContext.getServletConfig(); 
session  =  pageContext.getSession(); 
out  =  pageContext.getOut(); 
// 为了节省篇幅，我删除了解释器添加的注释 
out.write(\r\n); 
// 上一句是由于后面的换行产生的 
out.write(); 
out.write(\r\n\r\n\r\n\r\n); 
out.print( 输出 ); 
out.write(\r\n\r\n\r\n\r\n); 
}  catch  (Throwable t) { 
if  (out  != null &&  out.getBufferSize()  != 0 ) 
out.clearBuffer(); 
if  (pageContext  != null ) pageContext.handlePageException(t); 
}  finally  { 
if  (_jspxFactory  != null ) _jspxFactory.releasePageContext(pageContext); 
} 
} 
}

从上面的代码中可以清晰的看到JSP内建的几个对象（out、request、response、session、pageContext、application、config、page）是怎么产生的，懂servlet的朋友一看就能明白。 
下面重点理解一下out对象，它被声明为JspWriter类型，JspWriter是一个抽象类，在包javax.servlet.jsp中可以找到它的定义。

abstract public class  javax.servlet.jsp.JspWriter  extends  java.io.Writer{ 
final public static int  NO_BUFFER  = 0 ; 
final public static int  DEFAULT_BUFFER  = - 1 ; 
final public static int  UNBOUNDED_BUFFER  = - 2 ; 
protected int  bufferSize; 
protected  Boolean autoFlush; 
protected  javax.servlet.jsp.JspWriter( int  arg1,  boolean  arg2); 

abstract public void  newLine()  throws  IOException ; 
abstract public void  print( boolean  arg0)  throws  IOException ; 
abstract public void  print( char  arg0)  throws  IOException ; 
abstract public void  print( int  arg0)  throws  IOException ; 
abstract public void  print( long  arg0)  throws  IOException ; 
abstract public void  print( float  arg0)  throws  IOException ; 
abstract public void  print( double  arg0)  throws  IOException ; 
abstract public void  print( char [] arg0)  throws  IOException ; 
abstract public void  print(String arg0)  throws  IOException ; 
abstract public void  print(Object arg0)  throws  IOException ; 
abstract public void  println()  throws  IOException ; 
abstract public void  println( boolean  arg0)  throws  IOException ; 
abstract public void  println( char  arg0)  throws  IOException ; 
abstract public void  println( int  arg0)  throws  IOException ; 
abstract public void  println( long  arg0)  throws  IOException ; 
abstract public void  println( float  arg0)  throws  IOException ; 
abstract public void  println( double  arg0)  throws  IOException ; 
abstract public void  println( char [] arg0)  throws  IOException ; 
abstract public void  println(String arg0)  throws  IOException ; 
abtract  public void  println(Object arg0)  throws  IOException ; 
abstract public void  clear()  throws  IOException ; 
abstract public void  clearBuffer()  throws  IOException ; 
abstract public void  flush()  throws  IOException ; 
abstract public void  close()  throws  IOException ; 
public int  getBufferSize() ; 
abstract public int  getRemaining() ; 
public boolean  isAutoFlush() ; 
}

我相信当我写到这里你可能已经知道我想怎么做了。是的，来个偷天换日，继承JspWriter类，然后实现其定义的虚函数，然后把out变量替换成你自己实现的类的实例就ok了。 
2.实现替换 
假设 
3.更新问题 
下面就讨论一下如何更新生成静态文件，其实从上面实现中你可以看到，很简单的就是将生成的静态文件删除即可，至于什么时候删除，要看你的需求了。我能想到的几种情况如下 
当用来生成页面的数据更新时 
如果不需要很提供时时的数据可以定时更新 
永远不更新 
---------------------------------------------------------------------------------------------------- 

JSP生成静态HTML页面范例 

先建立一个模本页面:template.htm 

< Html >  
< head >  
< title > ###title### </ title >  
< meta  http-equiv ="Content-Type"  content ="text/html; charset=gb2312" >  
< LINK  href ="../Css.css"  rel =stylesheet  type =text/css >  
</ head >  
< body >  
< table  width ="500"  border ="0"  align ="center"  cellpadding ="0"  cellspacing ="2" >  
< tr >  
< td  align ="center" > ###title### </ td >  
</ tr >  
< tr >  
< td  align ="center" > 作者：###author### &nbsp;&nbsp; </ td >  
</ tr >  
< tr >  
< td > ###content### 
</ td >  
</ tr >  
</ table >  
</ body >  
</ html >

========================================= 
再写一个jsp页面: buildhtml.jsp

<%@ page contentType= "text/html; charset=gb2312"  import = "Java.util.*,java.io.*" %> <% try { String title= "jsp生成静态html文件" ; String content= "小样，还搞不定你？" ; String editer= "webjxcom" ; String filePath = "" ; filePath = request.getRealPath( "/" )+ "template.htm" ; out.print(filePath); String templateContent= "" ; FileInputStream fileinputstream = new  FileInputStream(filePath); //读取模块文件 int  lenght = fileinputstream.available(); byte  bytes[] = new  byte [lenght]; fileinputstream.read(bytes); fileinputstream.close(); templateContent = new  String(bytes); out.print(templateContent); templateContent=templateContent.replaceAll( "###title###" ,title); templateContent=templateContent.replaceAll( "###content###" ,content); templateContent=templateContent.replaceAll( "###author###" ,editer); //替换掉模块中相应的地方 out.print(templateContent); // 根据时间得文件名 Calendar calendar = Calendar.getInstance(); String fileame = String.valueOf(calendar.getTimeInMillis()) + ".html" ; fileame = request.getRealPath( "/" )+fileame; //生成的html文件保存路径 FileOutputStream fileoutputstream = new  FileOutputStream(fileame); //建立文件输出流 out.print( "文件输出路径:<br>" ); out.print(fileame); byte  tag_bytes[] = templateContent.getBytes(); fileoutputstream.write(tag_bytes); fileoutputstream.close(); } catch (Exception e){ out.print(e.toString()); } %>

---------------------------------------------------------------------------

mport java.io. * ; 

import  java.net. * ; 



public class  Tools { 

final static  Object lock  = new  Object(); 

public static void  makeHtml(String page, String filePath)...{ 

makeHtml(page,filePath, " UTF-8 " ); 

} 



public static void  makeHtml(String page, String filePath,String chartset) { 

synchronized  (lock) { 

HttpURLConnection huc  = null ; 

BufferedReader br  = null ; 

BufferedWriter bw  = null ; 

try  { 

huc  =  (HttpURLConnection) new  URL(page).openConnection(); 

System.setProperty( " sun.net.client.defaultConnectTimeout " ,  " 30000 " ); 

System.setProperty( " sun.net.client.defaultReadTimeout " ,  " 30000 " ); 

huc.connect(); 

InputStream stream  =  huc.getInputStream(); 

bw  = new  BufferedWriter( new  OutputStreamWriter ( new  FileOutputStream(filePath),chartset)); 

br  = new  BufferedReader( new  InputStreamReader(stream, chartset)); 

String line; 

while ((line  =  br.readLine()) != null ){ 

if (line.trim().length()  > 0 ){ 

bw.write(line); 

bw.newLine(); 

} 

} 

} catch  (Exception e) { 

e.printStackTrace(); 

} finally  { 

try  { 

br.close(); 

bw.close(); 

huc.disconnect(); 

} catch  (Exception e) { 

e.printStackTrace(); 

} 

} 

}