静态生成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
*/
publicclass ToHtml extends HttpServlet {
privatestaticfinallong serialVersionUID =1L;

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

/**
 * 
*/
publicvoid 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() {
publicvoid write(byte[] data,int offset, int length){
 os.write(data, offset, length);
 }
 @Override
publicvoid 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)
*/
protectedvoid doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
 }

/**
 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protectedvoid 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文件要保存的真实路径。默认与文件所在的目录相同。 
*/ 
publicclass ToHtmlPath extends HttpServlet { 

publicvoid 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() { 
publicvoid write(byte[] data, int offset, int length) { 
 os.write(data, offset, length); 
 } 

publicvoid 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>

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

publicclass CallHtml { 

publicstaticvoid 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.*; 

publicclass test$jsp extends HttpJspBase { 

static { 
 } 
public testOutRedir$jsp( ) { 
 } 

privatestaticboolean _jspx_inited =false; 

publicfinalvoid _jspx_init() throws org.apache.jasper.runtime.JspException { 
 } 

publicvoid _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中可以找到它的定义。

abstractpublicclass javax.servlet.jsp.JspWriter extends java.io.Writer{ 
finalpublicstaticint NO_BUFFER =0; 
finalpublicstaticint DEFAULT_BUFFER =-1; 
finalpublicstaticint UNBOUNDED_BUFFER =-2; 
protectedint bufferSize; 
protected Boolean autoFlush; 
protected javax.servlet.jsp.JspWriter(int arg1, boolean arg2); 

abstractpublicvoid newLine() throws IOException ; 
abstractpublicvoid print(boolean arg0) throws IOException ; 
abstractpublicvoid print(char arg0) throws IOException ; 
abstractpublicvoid print(int arg0) throws IOException ; 
abstractpublicvoid print(long arg0) throws IOException ; 
abstractpublicvoid print(float arg0) throws IOException ; 
abstractpublicvoid print(double arg0) throws IOException ; 
abstractpublicvoid print(char[] arg0) throws IOException ; 
abstractpublicvoid print(String arg0) throws IOException ; 
abstractpublicvoid print(Object arg0) throws IOException ; 
abstractpublicvoid println() throws IOException ; 
abstractpublicvoid println(boolean arg0) throws IOException ; 
abstractpublicvoid println(char arg0) throws IOException ; 
abstractpublicvoid println(int arg0) throws IOException ; 
abstractpublicvoid println(long arg0) throws IOException ; 
abstractpublicvoid println(float arg0) throws IOException ; 
abstractpublicvoid println(double arg0) throws IOException ; 
abstractpublicvoid println(char[] arg0) throws IOException ; 
abstractpublicvoid println(String arg0) throws IOException ; 
 abtract publicvoid println(Object arg0) throws IOException ; 
abstractpublicvoid clear() throws IOException ; 
abstractpublicvoid clearBuffer() throws IOException ; 
abstractpublicvoid flush() throws IOException ; 
abstractpublicvoid close() throws IOException ; 
publicint getBufferSize() ; 
abstractpublicint getRemaining() ; 
publicboolean 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.*; 



publicclass Tools { 

finalstatic Object lock =new Object(); 

publicstaticvoid makeHtml(String page, String filePath)...{ 

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

 } 



publicstaticvoid 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(); 

 } 

 } 

 }