性能调优之页面静态化

最新推荐文章于 2022-11-08 10:33:13 发布

ChrisTingTing

最新推荐文章于 2022-11-08 10:33:13 发布

阅读量676

点赞数

分类专栏：并发

并发专栏收录该内容

4 篇文章 0 订阅

订阅专栏

HTML静态化

1 介绍

其实大家都知道，效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。但是对于大量内容并且频繁更新的网站，我们无法全部手动去挨个实现，于是出现了我们常见的信息发布系统CMS，像我们常访问的各个门户站点的新闻频道，甚至他们的其他频道，都是通过信息发布系统来管理和实现的，信息发布系统可以实现最简单的信息录入自动生成静态页面，还能具备频道管理、权限管理、自动抓取等功能，对于一个大型网站来说，拥有一套高效、可管理的CMS是必不可少的。
除了门户和信息发布类型的网站，对于交互性要求很高的社区类型网站来说，尽可能的静态化也是提高性能的必要手段，将社区内的帖子、文章进行实时的静态化，有更新的时候再重新静态化也是大量使用的策略，像Mop的大杂烩就是使用了这样的策略，网易社区等也是如此。
同时，html静态化也是某些缓存策略使用的手段，对于系统中频繁使用数据库查询但是内容更新很小的应用，可以考虑使用html静态化来实现，比如论坛中论坛的公用设置信息，这些信息目前的主流论坛都可以进行后台管理并且存储再数据库中，这些信息其实大量被前台程序调用，但是更新频率很小，可以考虑将这部分内容进行后台更新的时候进行静态化，这样避免了大量的数据库访问请求。

提升网站性能的方式有很多，例如有效的使用缓存，生成静态页面等等，本文主要介绍Java高并发：HTML静态页化。

1.1 什么是静态页面

静态页面是独立的html、htm后缀文件，不需要经过服务器的编译，可以直接加载到客户浏览器上显示出来。

1.2 为什么要将网站修改为静态页面

1) 加快页面打开浏览速度，不用调用数据库，访问速度比一般动态网站快5-10倍。

2) 有利于搜索引擎优化SEO,百度谷歌等搜索引擎都会优先收录静态页面。不仅被收录的快还收录的全。并且在排名中静态页面的排名权重要高于动态路径的页面。

3) 网站更安全，静态页面从理论上讲是完全没有漏洞的。数据库出错时，不影响网站正常访问。

4) 缺点：无法即时更新，每次更新内容都需要生成静态页面。

1.3 静态化需要考虑三个方面的事情

1，对SEO,能够让搜索引擎更方便的进行采集和分类，提升其速度和准确性。

2，对用户,不能影响版面的展示，不能为了速度影响了美观和可用性。

3，对维护,一些内容可以方便的更换，比如菜单调整，连接调整，广告位的调整等。

2 Java实现html静态化方案

java页面静态化解释：简单的说，我们如果访问一个链接 ,服务器对应的模块会处理这个请求，转到对应的jsp界面，最后生成我们想要看到的数据。这其中的缺点是显而易见的：因为每次请求服务器都会进行处理，如果有太多的高并发请求，那么就会加重应用服务器的压力，弄不好就把服务器搞down 掉了。那么如何去避免呢？如果我们把对 test.do 请求后的结果保存成一个 html 文件，然后每次用户都去访问 ,这样应用服务器的压力不就减少了？那么静态页面从哪里来呢？总不能让我们每个页面都手动处理吧？这里就牵涉到我们要讲解的内容了，静态页面生成方案… 我们需要的是自动的生成静态页面，当用户访问 ,会自动生成 test.html ,然后显示给用户。

2.1 页面静态化方案应该掌握的知识点

1、基于- URL Rewrite

伪静态URL重写实际就是以静态地址（如：http://127.0.0.1:8080/pro/index.html）访问地态网页的方法（如：http://127.0.0.1:8080/pro/index.jsp）。

伪静态URL重写是通过微软公司封装好了的一个URL重写组件（UrlReswriter.jar）来实现的，导入JAR包，在WEB服务中加载伪静态地址拦截器，客户端以静态地址向服务器发起请求，服务器端的拦截器拦截客户端请求，查找XML配置文件，把静态的URL地址转换成动态地址，发起请求。

2、基于 Servlet web.xml

Struts或servlet接收请求，如test.action，对请求的url进行处理，判断是否生成静态html页面。

其中，对于 URL Rewriter的部分，可以使用收费或者开源的工具来实现，如果 url不是特别的复杂，可以考虑在 servlet 中实现，那么就是下面这个样子：

2.2 JSP生成静态HTML页面最普遍的三种方法

Jsp静态化解释：对于现在的Web Application来说，动态页面是占有绝对高的地位的，正因为有了动态化，才有了现在Web的丰富多彩，但是如同所有别的事实一样，好处往往都是有代价的。为了产生出动态的效果，每一次对页面的请求都会要求服务器对页面进行编译或者执行，这些操作都很消耗系统资源。如果这期间还有和数据库的通讯，那么代价将会更大。
如果一个页面在一定的时间内，其内容没有发生改变，那么就不必为每一次对它的访问进行一次“新”的编译或执行。我们可以把它在这段没有发生改变的时间内的结果保存到一个静态的页面里面，然后每次访问这个页面时，就用刚才保存的静态页面进行回复。这样便能大大地减少系统资源的消耗，并且提高对客户的响应速度。而这个过程就称之为页面静态化。现在所面临的问题就是如何在JSP中将页面的内容保存下来。在访问JSP页面的时候，服务器会先将JSP文件编译为Servlet文件，然后对这个Servlet编译、执行，并最终把结果返回给客户端。而我们的任务就是要把这个最终生成的HTML静态页面保留下来，存放在服务器上。解决的方法其实很简单。普通的对于JSP的访问，最终的数据流是回写到客户端的，如果我们把它重定向，让它回写到服务器上一个本地的文件，这样就能把JSP的执行结果保存起来，而这个文件就是我们想要得到的静态化的结果。

2.2.1从数据库中取相应数据并替换掉模板中的对应标签。

1.buildhtml.jsp
<%@ page contentType="text/html; charset=gb2312"import="java.util.*,java.io.*"%>
<%
try{
String title="This is Title";
String content="This is Content Area";
String editer="LaoMao";
String filePath = "";
filePath = request.getRealPath("/")+"test/template.htm";
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);//建立文件输出流
byte tag_bytes[] = templateContent.getBytes();
fileoutputstream.write(tag_bytes);
fileoutputstream.close();
}
catch(Exception e){
out.print(e.toString());
}
%>

2. 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>
     <tdalign="center">###title###</td>
   </tr>
   <tr>
     <td align="center">author：###author###  </td>
   </tr>
   <tr>
     <td>###content###</td>
   </tr>
</table>
</body>
</html>

2.2.2从动态页的URL获取相应页面内容并写入到文件

/*
* Created on 2013-3-19
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code andComments
*/
package com.easydone.cn.tools.utils;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Date;

/**
* @author Administrator
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code andComments
*/
public class MakeHtml {
         private static long star = 0;
         private static long end = 0;
         private static long ttime = 0;

         //返回html代码
         public static StringgetHtmlCode(String httpUrl){
         Date before = new Date();
         star = before.getTime();
         String htmlCode ="";
         try {
         InputStream   in;
         URL url = newjava.net.URL(httpUrl);
         HttpURLConnection connection =(HttpURLConnection)url.openConnection();
         connection =(HttpURLConnection) url.openConnection();
        connection.setRequestProperty("User-Agent","Mozilla/4.0");
         connection.connect();
         in =connection.getInputStream();
         java.io.BufferedReader breader= new BufferedReader(new InputStreamReader(in , "GBK"));
         String currentLine;
          while((currentLine=breader.readLine())!=null){
         htmlCode+=currentLine;
           }
         } catch (Exception e) {
         e.printStackTrace();
         }finally{
         Date after = new Date();
         end = after.getTime();
         ttime = end-star ;
         System.out.println("执行时间:"+ttime +"秒");
         }
         return htmlCode;
         }
         //存储文件
         public static synchronizedvoid writeHtml(String filePath,String info,String flag) {

         PrintWriter pw = null;
         try {
         File writeFile = newFile(filePath);
         boolean isExit =writeFile.exists();
         if (isExit != true) {
         writeFile.createNewFile();
         } else {
         if(!flag.equals("NO")) {
         writeFile.delete();
         writeFile.createNewFile();
         }
         }
         pw = new PrintWriter(newFileOutputStream(filePath, true));
         pw.println(info);
         pw.close();
         } catch (Exception ex) {
        System.out.println(ex.getMessage());
         }finally{
         pw.close();
         }
         }

         public static void main(String[]args) {
         String url ="http://www.easydone.cn/index.htm";
        writeHtml("c:/demo.htm",getHtmlCode(url),"NO");
         }
}

2.2.3 利用Filter和定制Response，把服务器返回的JSP响应输出到我们自己的Response中，就可以将响应快速写入Html文件，然后再发送给客户。

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Calendar;

public class CacheFilter implements Filter {
   ServletContext sc;
   FilterConfig fc;
   long cacheTimeout = Long.MAX_VALUE;

   public void doFilter(ServletRequest req,
                       ServletResponse res,
                       FilterChain chain)
       throws IOException, ServletException {
     HttpServletRequest request =
         (HttpServletRequest) req;
     HttpServletResponse response =
         (HttpServletResponse) res;

     // check if was a resource that shouldn't be cached.
     String r = sc.getRealPath("");
     String path =
        fc.getInitParameter(request.getRequestURI());
     if (path!= null &&path.equals("nocache")) {
       chain.doFilter(request, response);
       return;
     }
     path = r+path;

     String id = request.getRequestURI() +
         request.getQueryString();
     File tempDir = (File)sc.getAttribute(
      "javax.servlet.context.tempdir");

     // get possible cache
     String temp = tempDir.getAbsolutePath();
     File file = new File(temp+id);

     // get current resource
     if (path == null) {
       path =sc.getRealPath(request.getRequestURI());
     }
     File current = new File(path);

     try {
       long now =
        Calendar.getInstance().getTimeInMillis();
       //set timestamp check
       if (!file.exists() || (file.exists()&&
          current.lastModified() > file.lastModified()) ||
           cacheTimeout <now - file.lastModified()) {
         String name =file.getAbsolutePath();
         name =
            name.substring(0,name.lastIndexOf("/"));
         new File(name).mkdirs();
         ByteArrayOutputStream baos =
             newByteArrayOutputStream();
         CacheResponseWrapperwrappedResponse =
           newCacheResponseWrapper(response, baos);
         chain.doFilter(req,wrappedResponse);

         FileOutputStream fos = newFileOutputStream(file);
         fos.write(baos.toByteArray());
         fos.flush();
         fos.close();
       }
     } catch (ServletException e) {
       if (!file.exists()) {
         throw new ServletException(e);
       }
     }
     catch (IOException e) {
       if (!file.exists()) {
         throw e;
       }
     }

     FileInputStream fis = new FileInputStream(file);
     String mt = sc.getMimeType(request.getRequestURI());
     response.setContentType(mt);
     ServletOutputStream sos = res.getOutputStream();
     for (int i = fis.read(); i!= -1; i = fis.read()) {
       sos.write((byte)i);
     }
   }

   public void init(FilterConfig filterConfig) {
     this.fc = filterConfig;
     String ct =
        fc.getInitParameter("cacheTimeout");
     if (ct != null) {
       cacheTimeout = 60*1000*Long.parseLong(ct);
     }
     this.sc = filterConfig.getServletContext();
   }

   public void destroy() {
     this.sc = null;
     this.fc = null;
   }
}

2.3 使用URLRewirte实现url地址伪静态化

URLRewirte的用处:
1.满足搜索引擎的要求
2.隐藏技术实现，提高网站的移植性
3.满足美感的要求。

项目部署
1.首先在http://tuckey.org/urlrewirte/下载urlrewirtefilter
2.解压所下载的文件,把urlrewrite-2.6.0.jar复制到项目的WebRoot/WEB-INF/lib/目录下,然后编译
3.把urlrewrite.xml复制到项目的WebRoot/WEB-INF/目录下
4.在web.xml文件中加入以下:

1 
2 <filter>
3   <filter-name>UrlRewriteFilter</filter-name>
4   <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
5   <init-param>
6     <param-name>logLevel</param-name>
7     <param-value>WARN</param-value>
8   </init-param>
9 </filter>
10 <filter-mapping>
11   <filter-name>UrlRewriteFilter</filter-name>
12   <url-pattern>/*</url-pattern>
13 </filter-mapping>
14

5.需要配置urlrewrite.xml文件来实现url静态化,下面将详细说明

到这里相关的配置已经完成,下面看如何把动态地址静态化
1.普通url静态化
例如:要把http://localhost/prjtest/user/list.jsp转换成http://localhost/prjtest/user/list.html
这种是最简单的,当一个servlet跳转到list.jsp页面列出user列表时,在urlrewrite.xml中这样配置:

1 <rule>
2   <from>^/user/list.html</from>
3   <to type="redirect">/user/list.jsp</to>
4 </rule>

当请求/user/list.html这个页面时,实际上相当于请求/user/list.jsp页面
在servlet的跳转要这样写:
response.sendRedirect("./user/list.html");
2.带参数的url静态化
例如:要把http://localhost/prjtest/user/view.jsp?cid=1&cname=admin转换成
http://localhost/prjtest/user/view/1_admin.html
在urlrewrite.xml中这样配置:

1 <rule>
2   <from>^/user/view/([0-9]+)_([a-z]+).html$</from>
3   <to type="redirect">/user/view.jsp?cid=$1&cname=$2</to>
4 </rule>

当请求/user/view/1_admin.html这个页面时,实际上相当于请求/user/list.jsp?cid=1&cname=admin页面
在servlet的跳转要这样写(cid,cname为变量):
response.sendRedirect("./user/view/"+cid +"_"+ cname +".html");
注意:配置文件中用"&"来代替"&"
一个通用的正则表达式:[a-zA-Z0-9]+

2.4 JAVA 利用freemarker生成html静态页面。

Freemarker是一个用java编写的模版引擎，主要用来生成web html页面，通常由java程序准备要显示的数据，与freemarker生成静态页面。（编写ftl模版可以生成html代码，必须导入freemarker包）

核心代码：

1. private ConfigurationtempConfiguration;

2.   public voidsetTempConfiguration(Configuration tempConfiguration) {
        this.tempConfiguration =tempConfiguration;
    }

2. public static void crateHTML(ServletContext context,

3. Map<String, Object> data, String templatePath, String targetHtmlPath) {

4. try {

5. //filepath:ftl存放路径（/template/file/static）

6. this.tempConfiguration.setDirectoryForTemplateLoading(new File(filePath));

7. //templatePath:ftl文件名称（template.ftl）

8. Template template = this.tempConfiguration.getTemplate(templatePath);

9. template.setEncoding("UTF-8");

10. // 静态页面要存放的路径

11. String htmlPath = targetHtmlPath;

12. File htmlFile = new File(htmlPath);

13. Writer out = new BufferedWriter(new OutputStreamWriter(

14. new FileOutputStream(htmlFile), "UTF-8"));

15. // 处理模版 map数据 ,输出流

16. template.process(data, out);

17. out.flush();

18. out.close();

19.

20. } catch (Exception e) {

21. e.printStackTrace();

22. }

23.

24. }

ChrisTingTing

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
性能调优之页面静态化

HTML静态化1 介绍其实大家都知道，效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。但是对于大量内容并且频繁更新的网站，我们无法全部手动去挨个实现，于是出现了我们常见的信息发布系统CMS，像我们常访问的各个门户站点的新闻频道，甚至他们的其他频道，都是通过信息发布系统来管理
复制链接

扫一扫