jsp生成html
在接下來的應用中，我本身想到另外一種解決方案，就是經過Ajax + Struts + XML解決靜態頁面方案，一併寫下來，與你們分享！css
生成靜態頁面技術解決方案之一（轉載）
生成靜態頁面技術解決方案之二（轉載）
一個實現將動態頁面轉爲靜態的方案（轉載）
JSP生成靜態HTML頁面範例（轉載）
利用XML＋XSL生成靜態頁面技術方案（轉載）
Ajax + Struts + XML解決靜態頁面方案（原創）
隨着網站訪問量的加大，每次從數據庫讀取都是以效率做爲代價的，靜態頁加在搜索時，也會被優先考慮。互聯網上流行的作法是將數據源代碼寫入數據庫再從數據庫讀取生成靜態面，這樣無形間就加大了數據庫。將現有的JSP頁直接生成靜態頁，將會節省不少。
爲何要生成靜態首頁？
一、若是你首頁讀取的數據庫次數比較多，速度很慢，並且佔用不少服務器資源。使用靜態頁面訪問速度固然快多了
二、搜索引擎容易搜索到
三、若是程序出問題，也能保證首頁能訪問
諸如此類等等好處，那麼下面幾篇文章給你們幾個完整的解決方案！
----------------------------------------------------------------------------------------------------html
生成靜態頁面技術解決方案之一java
轉載者前言：這是一個全面的jsp動態頁面靜態化方案，本站的帖子靜態化方案將借鑑這篇帖子中方法。向http://www.agilejava.org的single的共享精神致敬。web
轉帖正文：數據庫
相信不少人都但願本身的頁面越快越好，最好是能靜態的，提升客戶訪問速度。也便於搜索引擎搜索。因此，就但願咱們的動態讀取數據庫的頁面，儘量的生成靜態頁面。一下系列文章，介紹一下我的的解決方案。apache
本系列將介紹我的的一種方法，在不改變原來jsp文件的基礎上，只須要加入少許的代碼，就讓你的新聞發佈系統，很容易就徹底變成靜態的頁面。服務器
本文假設你是用java開發的web動態頁面。session
第一步，加入servlet.代碼以下。app
public class ToHtml extends HttpServlet {框架
public void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String url = "";
String ;
ServletContext sc = getServletContext();
String file_name = request.getParameter("file_name");// 你要訪問的jsp文件名,如index，不包括擴展名
// 則你訪問這個servlet時加參數.如http://localhost/test/toHtml?file_name=index
url = "/" + file_name + ".jsf";// 你要生成的頁面的文件名。個人擴展名爲jsf .
\\"+ file_name + ".htm";// 這是生成的html文件名,如index.htm.文件名字與源文件名相同。擴展名爲htm
//ConfConstants.CONTEXT_PATH爲你的應用的上下文路徑。
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>頁面已經成功生成！single<br>http://www.agilejava.org/space/? 233</font></p>");
}
}
第二步、配置你的web.xml
<servlet>
<servlet-name>toHtml</servlet-name>
<servlet-class>mj.util.html.ToHtml</servlet-class>//你的servlet的類。
</servlet>
<servlet-mapping>
<servlet-name>toHtml</servlet-name>
<url-pattern>/toHtml</url-pattern>
</servlet-mapping>
第三步、運行servlet。如：http://localhost:8080/test/toHtml?file_name=index
OK,這就在你的test項目的根目錄下，生成了一個index.htm的靜態文件。
侷限性：本文只能生成一個文件！訪問一次，生成一個文件。而且生成的文件名也與原來的文件名相同。
比較適合主頁生成靜態頁面。
本系列的後續文章將解決更多的問題。使之在新聞發佈系統中，很容易就集成應用。
----------------------------------------------------------------------------------------------------
生成靜態頁面技術解決方案之二
注意：轉貼本文，請加上本文連接http://www.agilejava.org/space/?233/action_viewspace_itemid_21.html
在上一篇文章中，生成靜態頁面，是有必定的侷限性的。生成主頁是很方便，但要生成二級頁面，就不方便了。
本文假設一個新聞發佈系統。但願後臺發佈的，前臺顯示的是靜態的文檔。這就涉及，主頁要是靜態的，同時二級列表也是靜態的，新聞內容也是靜態的。也就是說， 在發佈一篇新聞的時候，可能涉及到三個地方生成靜態文檔。而且，要生成一個網頁，必須訪問一個servlet。在大量生成靜態網頁的時候，
如下方法，能夠解決這些問題。
1、加入一下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 ;
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文件,如
}
// 下面構造要保存的文件名，及路徑。
// 一、若是有realPath，則保存在realPath下。
// 二、若是有path則保存在path下。
// 三、不然，保存在根目錄下。
if (realPath == null || realPath == "") {
if (path == null || path == "") {
+ "\\" + realName + ".htm";// 這是生成的html文件名,如index.htm.說明： ConfConstants.CONTEXT_PATH爲你的上下文路徑。
} else {
+ "\\" + path + "\\"
+ realName + ".htm";// 這是生成的html文件名,如index.htm.
}
} else {
+ "\\" + 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>");
}
}
2、在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>
3、寫一個通用的方法， 供調用。
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
}
}
//這個方法適當重載，就能夠省去一些參數傳遞。
}
4、在你的新聞發佈save時，調用方法。
一、CallHtml.callOnePage("info.jsf?file_id=aaa",news,"", "");//將在news目錄下生成一個aaa.htm的靜態文件
二、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### </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());
}
%>
----------------------------------------------------------------------------------------------------
Ajax + Struts + XML解決靜態頁面方案（原創）
對於其餘幾位前輩提出的方案，我也是受益良深，因此方案中，最簡單的就是將JSP輸出爲HTML，最麻煩的是利用IO將輸出信息組成HTML文件，最難的對我來講應該是生成XML的方案。我沒有學XSL，但聽說比較難，遠不如HTML那麼容易。儘管如此，生成XML這種方案倒是我最欣賞的，緣由有四:
第一是實現了表示與數據的分離；
第二是易於操做，增刪改都至關方便；
第三是跨平臺特性讓它應用領域更廣；
第四XML自己就能夠當數據庫使用，使得它能夠合理組織數據。
OK，基於這些緣由，小弟在推敲中想到一個解決方案：若是咱們在服務器生成若干XML文檔，由統一的HTML裝載，而後客戶端執行HTML時，經過AJAX異步載入XML文檔數據，那麼結果是否會達到達人心動的效果呢？
實現此技術須要解決的問題：
1． 從數據庫取數據動態生成並寫入XML文件
2． 利用URL傳入XML文檔名
3． 客戶端使用JS解析URL取XML文檔名而後使用AJAX載入文件，最後動態組織數據到頁面中
以上分析是小弟一些拙見，高手勿笑！小弟在想到這個方案時，便立刻寫了一個Demo測試了一下，程序採用的是Strut框架寫的，完成功能就是以上三點的描述，不過爲了測試方便，並未使用數據庫，而是本身定義了用於構造XML文件的類手動輸入的，程序打包的下載地址：http://download.csdn.net/user/rodgersnow 你們找到利用AJAX生成靜態HTML的Demo就能夠下載了
- 1. html/jsp利用iText生成pdf
- 2. 動態jsp生成靜態html網頁
- 3. ob_start()生成html
- 4. axure生成html
- 5. html生成pdf
- 6. 將html（JSP）生成PDF，並能夠在瀏覽器下載
- 7. 將jsp或html頁面動態生成PDF（jsPDF插件）
- 8. MPDF，html生成PDF
- 9. eclipse-JSP-快速生成Servlet
- 10. jsp動態生成table
- 更多相關文章...
- • Eclipse 生成jar包 - Eclipse 教程
- • HTML 指南 - 網站建設指南
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • 適用於PHP初學者的學習線路和建議
-
每一个你不满意的现在，都有一个你没有努力的曾经。