`
Elvis_Wu
  • 浏览: 51018 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

利用Java生成静态HMTL页面的方法收集

    博客分类：
  • JAVA
JavaServletJSPJSFOS 
阅读更多

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

转载者前言：这是一个全面的jsp动态页面静态化方案，本站的帖子静态化方案将借鉴这篇帖子中方法。向http://www.agilejava.org的single的共享精神致敬。

转帖正文：

       相信很多人都希望自己的页面越快越好，最好是能静态的，提高客户访问速度。也便于搜索引擎搜索。所以，就希望我们的动态读取数据库的页面，尽可能的生成静态页面。一下系列文章，介绍一下个人的解决方案。

      本系列将介绍个人的一种方法，在不改变原来jsp文件的基础上，只需要加入少量的代码，就让你的新闻发布系统，很容易就完全变成静态的页面。

            本文假设你是用java开发的web动态页面。

           第一步，加入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时加参数.如http://localhost/test/toHtml?file_name=index 

        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。如：http://localhost:8080/test/toHtml?file_name=index

      

      OK,这就在你的test项目的根目录下，生成了一个index.htm的静态文件。　

      

      局限性：本文只能生成一个文件！访问一次，生成一个文件。并且生成的文件名也与原来的文件名相同。

      比较适合主页生成静态页面。

      

      本系列的后续文章将解决更多的问题。使之在新闻发布系统中，很容易就集成应用。
----------------------------------------------------------------------------------------------------

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



            注意：转贴本文，请加上本文链接http://www.agilejava.org/space/?233/action_viewspace_itemid_21.html 

           在上一篇文章中，生成静态页面，是有一定的局限性的。生成主页是很方便，但要生成二级页面，就不方便了。

             本文假设一个新闻发布系统。希望后台发布的，前台显示的是静态的文档。这就涉及，主页要是静态的，同时二级列表也是静态的，新闻内容也是静态的。也就是说， 在发布一篇新闻的时候，可能涉及到三个地方生成静态文档。并且，要生成一个网页，必须访问一个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()); 
} 
%>

 

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

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

                } 
            } 
        } 
}

 

分享到：
| 连接查询不同数据库服务器上的表
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    静态网页爬虫

    静态网页爬虫，顾名思义，是专门针对不涉及动态交互、服务器端生成内容的网页进行数据抓取的工具。本项目是一个用Java编写的静态网页爬虫框架，特别适合初学者入门实践。 **Java 爬虫基础** Java作为一门面向对象...

    利用ASP实现JAVA动态参数的传递

    开发者无需频繁修改静态HTML代码，而是可以通过服务器端脚本动态生成参数，使得Web应用能够更好地适应不断变化的需求。这一技术的应用，无疑为现代Web开发提供了一种更为高效、灵活的解决方案。 总之，ASP与Java的...

    卷烟销售（静态页面，servlet）

    静态页面上的登录表单会收集用户凭证，Servlet验证这些凭证，如果有效，会创建或恢复会话（session），并设置会话属性以标识用户。之后，Servlet可以根据用户权限控制对不同功能的访问。 总的来说，卷烟销售系统...

    Java爬虫汽车之家图片

    在本案例中，项目组利用Java爬虫从汽车之家网站获取了12万张汽车图片，用于训练人工智能的图片识别模型。 1. **基础知识**： - **网络爬虫**：网络爬虫是自动化浏览互联网并收集信息的程序。它们遵循HTTP/HTTPS...

    java 简单的jsp

    JSP则在此基础上嵌入Java代码，使网页能够动态生成内容。例如，count.html中的form表单收集用户输入，传递至helloworld.jsp进行处理。 **JSP的工作机制**：当用户请求一个JSP页面时，Web服务器的JSP引擎将JSP源代码...

    美女图片站小偷程序源码，纯静态模版

    - **模板处理模块**：将下载的图片和信息结合，生成符合网站风格的静态HTML页面。 - **发布模块**：将生成的静态页面发布到网站，供用户浏览。 2. **小偷程序工作原理** - **URL发现**：程序首先需要知道要抓取...

    java进销存管理系统的设计与实现（jsp+mssql）包含源代码+毕设.zip

    JSP是一种动态网页技术，它允许开发者在HTML页面中嵌入Java代码，实现动态内容的生成。JSP页面由两部分组成：静态内容（HTML、CSS、JavaScript）和动态脚本（Java代码）。在服务器端，JSP被编译成Servlet，执行后...

    在线投票统计

    JSP是一种动态网页技术，它允许开发者在HTML页面中嵌入Java代码，以实现服务器端的数据处理和逻辑控制。JFreeChart则是一个强大的Java图形库，用于生成高质量的图表，包括饼图和直方图，非常适合用来展示投票统计...

    在线调查问卷

    JSP是Java Web开发中的视图层技术，它允许开发者在HTML页面中嵌入Java代码，使得动态网页的生成变得更加简单。 二、JSP核心概念 1. JSP元素：包括指令（directives）、脚本元素（scripting elements）和动作...

    java学籍管理系统毕业设计答辩PPT

    - JSP是一种动态网页技术，它允许将静态内容（HTML）和动态生成的部分（Java代码）混合在一起。 - JSP页面在服务器上执行，将Java代码转换为Servlet，然后生成HTML响应给客户端浏览器。 - JSP包含两个主要部分：...

    静态中小型网站电子教案

    【中小型网站电子教案】主要涵盖了中小型网站的建设目的、规划、方案选择以及动态网站与静态网站的区别，同时提到了网站建设的基本条件和常用方法。以下是详细的知识点解析： 1. **网站建设目的**： - 提升企业...

    JSP网页编程.ppt

    JavaServer Pages，简称JSP，是一种用于开发动态网页的技术，它是Java平台的一部分，旨在简化Web应用的开发。...学习和掌握JSP，不仅可以提升Web开发的效率，还能利用Java的强大功能构建复杂的Web应用程序。

    java 性能优化

    抛出异常时，需创建新对象，并调用`fillInStackTrace()`方法收集调用栈信息，这要求虚拟机调整调用栈。因此，异常应仅用于错误处理，而非控制程序流程，以提升效率。 **1.4 避免重复初始化变量** Java默认初始化...

    学生信息管理页面

    《学生信息管理页面》 学生信息管理系统是教育领域中常用的一种工具...对于学习者和开发者而言，这样的项目既能够锻炼HTML页面布局和交互设计的能力，也能加深对JSP和数据库操作的理解，是一次宝贵的学习和实践机会。

    java报表jfreechart开发

    `ChartFactory`类提供了一系列静态方法来创建不同类型的图表。 ##### 6.4 直方条形图的简单定制 可以定制条形的颜色、宽度等属性来使图表更具个性化。 ##### 6.5 定制外观 除了基础的定制选项，还可以进一步调整...

    基于Java的网上商城系统(JSP+MYSQL).zip

    【描述】该系统的核心在于利用Java的强类型特性和面向对象的编程思想，通过JSP来实现动态网页展示。JSP是Java在Web开发中的一个重要工具，它允许开发者将HTML代码与Java代码混合编写，使得网页能够根据服务器端的...

    图书管理__java实现(增删查改)

    在这个系统中，开发者利用Java的强大功能和MySQL的高效性能，构建了一个全面的图书信息管理平台，实现了对图书信息的增、删、查、改等基本操作。 在JavaEE（企业级Java）开发环境中，这个系统采用了三层架构设计...

Magicbox
Global site tag (gtag.js) - Google Analytics