- 浏览: 20713 次
- 性别:
最近访客 更多访客>>
最新评论
-
feijing:
回复2#,3#java
心情难受 -
feijing:
1#判断数据是否发生变化。可以比较数据的大小,或者长度,因为每 ...
动态网站生成静态页面技术解析 -
leon.s.kennedy:
What are you learning?
心情难受 -
程如序员:
支持楼上
心情难受 -
leon.s.kennedy:
静态化,把动态数据,保存成html静态格式,通过io输出流 到 ...
动态网站生成静态页面技术解析
jsp静态生成页面技术分析
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载入文件,最后动态组织数据到页面中
例子源码如下
第一步,加入servlet.代码如下。
public class ToHtml 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文件名,如index,不包括扩展名
// 则你访问这个servlet时加参数.如
url = "/" + file_name + ".jsf";// 你要生成的页面的文件名。我的扩展名为jsf .
name = ConfConstants.CONTEXT_PATH+"//"+ 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。
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 =DataSourc.getPass()+ 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的静态文件,显示最新的新闻。
3、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, 10241024, 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);
} 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="小样,破碎的心,http://www.fdpsj.com/Product/";
String content="小样,还搞不定你?";
String editer="webjxcom";
String filePath = "";
filePath = request.getRealPath("/")+"?exit.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载入文件,最后动态组织数据到页面中
例子源码如下
第一步,加入servlet.代码如下。
public class ToHtml 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文件名,如index,不包括扩展名
// 则你访问这个servlet时加参数.如
url = "/" + file_name + ".jsf";// 你要生成的页面的文件名。我的扩展名为jsf .
name = ConfConstants.CONTEXT_PATH+"//"+ 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。
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 =DataSourc.getPass()+ 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的静态文件,显示最新的新闻。
3、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, 10241024, 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);
} 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="小样,破碎的心,http://www.fdpsj.com/Product/";
String content="小样,还搞不定你?";
String editer="webjxcom";
String filePath = "";
filePath = request.getRealPath("/")+"?exit.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());
}
%>
相关推荐
### jsp生成静态页面的方法 在Web开发领域中,动态页面技术如JSP(Java Server Pages)被广泛应用于构建复杂的网站应用。然而,在某些场景下,为了提高网站性能、减轻服务器压力或便于SEO优化,将动态生成的内容...
**JSP页面静态化技术详解** 在Web开发中,JavaServer Pages(JSP)是一种常见的动态网页技术,它允许开发者将HTML代码与Java代码混合编写,以实现动态内容的生成。然而,在高流量的网站中,为了提高性能和降低...
这种方式称为"JSP生成静态页面",也就是标题和描述中提到的主题。 静态页面与动态页面的主要区别在于,静态页面的内容在服务器端被一次性生成,然后发送给客户端,而动态页面则是在每次请求时由服务器实时计算并...
### JSP结合JavaBean生成静态页面的技术要点及实现方法 #### 一、为什么要生成静态页面? 在Web开发中,动态页面(如JSP)虽然功能强大且易于维护,但每次请求都需要从数据库获取数据并执行复杂的逻辑处理,这无疑...
本话题主要探讨如何利用JSP技术来生成静态页面,并实现分页功能。 **1. JSP生成静态页** 生成静态页面的主要目的是提高网站的访问速度和降低服务器负载。当动态内容如新闻、博客等被频繁访问时,可以将其转换为...
**JSP电信管理系统静态页面详解** JavaServer Pages(JSP)是Java平台上的一个服务器端技术,用于创建动态网页。在这个“jsp电信管理系统静态页面”项目中,开发者使用纯JSP代码来构建了一个电信管理系统的前端展示...
在本示例中,"java自动生成静态页面Demo源码" 提供了一个完整的实现,包括源代码和可能使用的数据库连接,以便用户能够理解和应用这种技术。 1. **Java 语言基础**: Java 是一种广泛使用的面向对象的编程语言,以...
**JSP核心技术源代码分析** JavaServer Pages(JSP)是一种动态网页开发技术,由Sun Microsystems(现已被Oracle收购)于1999年推出,旨在简化Java Web应用程序的开发。JSP允许开发者将静态HTML内容与动态Java代码...
动态页面静态化是一种提高网站性能和搜索引擎友好度的技术手段,主要通过将原本由服务器动态生成的HTML页面转换为预先生成的静态HTML文件。这样,用户请求时,服务器无需执行数据库查询和其他复杂操作,而是直接返回...
总之,“struts2+freemarker 生成静态页面”是一个旨在提升Web应用性能的技术实践,通过结合Struts2的MVC框架和FreeMarker的模板引擎,实现了动态内容到静态HTML的转化,为用户提供更快的加载速度和更好的浏览体验。...
3. **JSP页面自定义标签库(Tag Library)**:开发自定义标签,用于在JSP页面中生成伪静态链接。这样可以确保所有链接都以.html形式出现,而实际处理仍由JSP完成。 4. **使用Spring MVC或其他MVC框架**:大多数现代...
【通用静态页面生成系统(Engineer) v.1】是一个基于Java JSP技术的应用程序,主要用于帮助学生进行毕业设计学习。这个系统的核心功能是将动态网页内容转化为静态HTML页面,以此提高网站的加载速度和搜索引擎优化...
动态JSP页面生成静态HTML文件的过程是Web开发中常用的技术手段,其目的通常是为了提高网站的响应速度和安全性,以及便于搜索引擎优化(SEO)。实现这一过程通常需要借助于Servlet过滤器(Filter)和Servlet技术。...
伪静态技术的主要目标是将动态生成的页面如JSP、ASP、PHP等以类似静态HTML的URL形式展现,使搜索引擎更容易抓取,同时保持服务器端的动态处理能力。 在【压缩包子文件的文件名称列表】中,只有一个文件名:“url...
综上所述,JSP源码分析主要关注JSP页面的结构、指令、脚本元素、动作标签的使用,以及与之相关的数据库操作、XML处理、样式控制等技术。每个JSP文件都有其特定的功能,通过它们的名称可以推测其大致用途。同时,SQL...
### JSP实现将动态网页转换成...通过上述步骤,我们可以有效地利用JSP技术将动态内容转换为静态页面,从而实现性能优化的目标。这种方法不仅适用于论坛类应用,还可以广泛应用于各类需要频繁访问数据库的Web项目中。
1. 内容生成与显示分离:开发者可以使用HTML或XML进行静态页面设计,而动态内容由JSP标识和小脚本在服务器端生成。 2. 强调可重用组件:JSP依赖于可跨平台复用的Java组件,促进了组件的共享和开发速度的提升。 然而...
JSP(JavaServer Pages)是一种基于Java的服务器端脚本技术,它允许将动态内容嵌入到静态HTML页面中。JSP页面本质上是Servlet的一种简化形式,开发者可以通过简单的标签语法来调用复杂的Java代码块,从而实现动态...
伪静态技术主要是为了优化搜索引擎排名和用户体验,使得动态生成的网页看起来像是静态页面。URLRewriteFilter是一个开源的过滤器,它可以帮助我们实现URL重写,从而达到伪静态的效果。 **描述分析:** 描述中提到...
Java JSP(JavaServer Pages)是一种用于开发动态网页的技术,它是Java平台的一部分,允许开发者将Java代码嵌入到HTML或XML文档中,从而在服务器端处理数据并生成响应的网页内容。本文将深入探讨Java JSP的基本语法...