一步一步asp.net_页面静态化管理

最近事情多,中间还生病了一次,纠结,最近一年来都没有什么毛病,不知道咋了...头痛.....

今天闲下来写篇日志,页面静态化.

页面静态化是我们经常碰到的问题,在web中,要说速度,只有html静态页面最快,所以页面静态化对于web网站来说,是一个非常好的减少请求降低服务器压力的方式.

而常规的html静态页面也有很多问题,比如不能像php,aspx,jsp页面那样轻松的和数据库交互.

在以前,html静态化都是,对于一些子页面(比如新闻内容等),一旦发布基本上很少进行修改的页面,就可以通过数据库读取,然后生成html,

这种方式性能最好,而且对SEO友好,但不灵活,只对于那些很少修改的页面,如果页面发生修改又需要重新生成,这对于硬盘也是一种伤害.

于是乎,动态语言横行.

ajax技术的出现,再度让页面进入静态化.

html页面中大量的ajax,即有很高的灵活性,而且达到的降低服务器压力减少请求的目的.

但是这样也会造成SEO的问题,所以,对于一些需要SEO的页面就不要用ajax实现了.

那么哪些适合页面静态化呢?

对于那些私人的空间

比如:会员空间,大师空间,企业空间,登录,注册等等,这些地方,就不需要.

 

但是还有一个问题,对于这些页面静态化,我们经常性都是先做aspx页面(母板页,用户控件)等,最后做页面静态化操作,我们就需要重新把那些动态页面的链接全部改成静态,这就太痛苦了,这时候我们就需要事先写一个URL页面静态化管理,所有的链接经过这个URLManage.GetURL处理.

/// <summary>
   /// 获得路径(暂时只做静态页面管理)(/*在这里可以扩展出URL重写*/)
   /// </summary>
   /// <param name="PageUrl">页面的URL(不包括扩展名)</param>
   /// <param name="QueryString">页面参数</param>
   /// <returns></returns>
   public static string GetURL(string PageUrl,string QueryString)
   {
       //页面路径
       string PagePath = "";

       //如果当前的参数不为空,则加上?
       if (QueryString != "")
           QueryString = "?" + QueryString;
       //如果是静态页面(从配置文件中读取静态页面状态(是否))
       if (ReadURLConfig(PageUrl) == true)
       {
           PagePath = PageUrl + ".htm";
       }
       //如果是动态页面
       else
           PagePath = PageUrl + ".aspx";
       //把相对路径转化为绝对路径
       return   System.Web.VirtualPathUtility.ToAbsolute(PagePath)+QueryString ;
   }
   /// <summary>
   /// 从配置文件中读取是否生成静态页面
   /// </summary>
   /// <param name="PageName">页面的名称</param>
   /// <returns></returns>
   public static bool ReadURLConfig(string PageURL)
   {
       //读取配置文件
       string path = HttpContext.Current.Server.MapPath(@"~/Admin/ConfigManage/URLConfig.xml");
       //XmlHelper.Read(path, "/Node/Element[@Attribute='Name']", "Attribute")
       //是否生成HTML
       string IsHtml="false";
       IsHtml=XMlHelper.Read(path, "/PageSettings/Page[@PageURL='"+PageURL+"']", "IsHtml");
       if (IsHtml.ToLower() == "true")
       {
           return true;
       }
       else return false;

   }

这个类主要是帮助我们可以直接从配置文件中读取关于文件页面静态化的信息

对于我们大量的ajax页面(可能涉及到超链接),我们也需要通过这个URLManage来获取他的路径,由于js不能调用asp.net中的函数,所以我们需要在每个页面的开头定义,js中需要用到的超链接.

看看它的ajax文件中是怎么写的.

这时候,我们的前台的工作就完成了,主要是后台的页面静态化管理的设计了,

后台的页面静态化管理,主要实现,通过树形菜单的形式,可以自由选择,那些页面生成静态页面,方便测试和维护.

不过这里,少处理了关于新闻内容的页面静态化,新闻内容的页面静态化则是采用的第一种方法,完全的页面静态化,从数据库读取出数据,全部生成的方式.

主要效果:

把需要页面静态化的页面写在配置文件中,然后通过这个页面静态化管理,进行页面静态化.

这样做的好处就是方便开发和维护,可以很轻松的管理静态页面.

主要技术:

1.XML操作以及LINQ简单应用,

2.页面静态化,只需要通过简单的WebClient下载动态页面就达到了页面静态化的目的.简单方便.

 

 

WebClient下载文件类

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using System.Net;

   6:  using System.Web;

   7:  using System.IO;

   8:   

   9:  namespace Common

  10:  {

  11:      /// <summary>

  12:      /// 用webClient下载文件

  13:      /// </summary>

  14:      public partial class DownFile

  15:      {

  16:          #region 生成静态页面

  17:          /// <summary>

  18:          /// 生成静态页面

  19:          /// 调用实例:

  20:          ///   Common.DownFile webclient = new Common.DownFile();

  21:          ///    string RequestVirtualUrl= "/News/ViewNews.aspx?NewsId="+Info.Id;

  22:          ///   string SaveVirtualPath = "~/News/" + Info.Id + ".htm";

  23:          ///    webclient.CreateStaticByWebClient(RequestVirtualUrl, SaveVirtualPath);

  24:          /// </summary>

  25:          /// <param name="VirtualRequestUrl">要请求的虚拟路径,例如: "/News/ViewNews.aspx?NewsId="+Info.Id;</param>

  26:          /// <param name="SaveVirtualPath">要保存的虚拟路径,例如:"~/News/" + Info.Id + ".htm";</param>

  27:          public static void CreateStaticByWebClient(string VirtualRequestUrl, string SaveVirtualPath)

  28:          {

  29:              WebClient wc = new WebClient();

  30:              wc.Encoding = Encoding.UTF8;

  31:              //通过WebClient向服务器发Get请求,把服务器返回的html内容保存到磁盘上,以后用户直接请html文件请求.

  32:              string AppVirtualPath = HttpContext.Current.Request.ApplicationPath;

  33:              //由于网站应用程序虚拟目录是/czcraft,而传递过来/News是正确的,

  34:              //但是发布到iis上面,虚拟路径就是/,而传递过来的确实/News,路径就出错了,

  35:   

  36:              if (AppVirtualPath == "/")

  37:              {

  38:                  AppVirtualPath = "";

  39:              }

  40:              string FilePath = HttpContext.Current.Request.Url.Scheme + "://" + HttpContext.Current.Request.Url.Authority + AppVirtualPath + VirtualRequestUrl;

  41:   

  42:              //保存路径

  43:              string SaveFilePath = HttpContext.Current.Server.MapPath(SaveVirtualPath);

  44:   

  45:              //下载并保存文件

  46:              wc.DownloadFile(FilePath, SaveFilePath);

  47:   

  48:          } 

  49:          #endregion

  50:          #region 文件删除

  51:          /// <summary>

  52:          /// 文件删除

  53:          /// </summary>

  54:          /// <param name="VirtualFilePath">文件虚拟路径</param>

  55:          public void FileDelete(string VirtualFilePath)

  56:          {

  57:              //物理路径

  58:              string RealFilePath = HttpContext.Current.Server.MapPath(VirtualFilePath);

  59:   

  60:              //如果文件存在则删除

  61:              if (File.Exists(VirtualFilePath))

  62:              {

  63:                  File.Delete(VirtualFilePath);

  64:              }

  65:          } 

  66:          #endregion

  67:      }

  68:  }

页面静态化管理类(URLXMLInfoManage):

using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using System.Xml;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using Newtonsoft.Json;

/// <summary>
///URLXMLInfoManage 的摘要说明
/// </summary>
public class URLXMLInfoManage
{
    #region 字段
    //单例模式
    public static readonly URLXMLInfoManage XMLInfo = new URLXMLInfoManage();
    /// <summary>
    /// 路径(XML)
    /// </summary>
    private static readonly string XMLPath = "~/Admin/ConfigManage/URLConfig.xml";
    #endregion
    #region 实例化
    /// <summary>
    /// 私有实例化
    /// </summary>
    private URLXMLInfoManage()
    {
    }
    /// <summary>
    /// 实例化(静态)
    /// </summary>
    /// <param name="path">xml的路径</param>
    /// <returns></returns>
    public static URLXMLInfoManage Instance()
    {
        return XMLInfo;
    }
    #endregion
    #region 通过页面信息(返回json)
    /// <summary>
    /// 通过页面信息(返回json)
    /// </summary>
    /// <returns></returns>
    public string GetURLInfoForJson()
    {

        //加载XML
        XDocument xDoc = XDocument.Load(HttpContext.Current.Server.MapPath(XMLPath));

        IEnumerable<XElement> PageList = xDoc.Root.Descendants("Page");
        //linq分组(根据xml中Page的Type的名称分组
        var group = PageList.GroupBy(page => page.Attribute("Type").Value);
        //输出json格式数据
        StringBuilder json = new StringBuilder();
        StringWriter sw = new StringWriter(json);
        using (JsonWriter jsonWriter = new JsonTextWriter(sw))
        {
            jsonWriter.Formatting = Newtonsoft.Json.Formatting.Indented;
            jsonWriter.WriteStartArray();
            foreach (IGrouping<string, XElement> item in group)
            {
                jsonWriter.WriteStartObject();
                //-1代表不存在的id
                jsonWriter.WritePropertyName("id");
                jsonWriter.WriteValue(-1);
                jsonWriter.WritePropertyName("text");
                jsonWriter.WriteValue(item.First().Attribute("TypeName").Value);
                jsonWriter.WritePropertyName("expanded");
                jsonWriter.WriteValue(false);
                jsonWriter.WritePropertyName("children");

                jsonWriter.WriteStartArray();
                foreach (XElement XElem in item)
                {
                    //页面名称
                    string PageName = XElem.Attribute("PageName").Value;
                    //页面URL
                    string PageURL = XElem.Attribute("PageURL").Value;
                    //页面标识
                    string PageId = XElem.Attribute("Id").Value;
                    //是否是html页面
                    bool IsHtml = Convert.ToBoolean(XElem.Attribute("IsHtml").Value);
                    jsonWriter.WriteStartObject();
                    jsonWriter.WritePropertyName("id");
                    jsonWriter.WriteValue(PageId);
                    jsonWriter.WritePropertyName("text");
                    jsonWriter.WriteValue(PageName);
                    jsonWriter.WritePropertyName("expanded");
                    jsonWriter.WriteValue(IsHtml);
                    jsonWriter.WriteEndObject();
                }
                jsonWriter.WriteEndArray();

                jsonWriter.WriteEndObject();

            }
            jsonWriter.WriteEndArray();




        }
        return json.ToString();


    }

    #endregion
    #region 设置页面静态化信息
    /// <summary>
    /// 设置页面静态化信息
    /// </summary>
    /// <param name="Ids"></param>
    /// <returns></returns>
    public bool SetURLInfo(string Ids)
    {
        //获取URL的Id
        string[] IdList = Ids.Split(',');
        //加载XML
        XDocument xDoc = XDocument.Load(HttpContext.Current.Server.MapPath(XMLPath));

        IEnumerable<XElement> PageList = xDoc.Root.Descendants("Page");
        foreach (XElement Page in PageList)
        {
            //默认不生成HTML页面
            Page.SetAttributeValue("IsHtml", false);
            foreach (string Id in IdList)
            {

                if (Id == Page.Attribute("Id").Value)
                {
                    //页面静态化
                    CreateHTML(Page.Attribute("PageURL").Value);
                    //写回XML中
                    Page.SetAttributeValue("IsHtml", true);
                    break;
                }
            }
        }
        xDoc.Save(HttpContext.Current.Server.MapPath(XMLPath));
        return true;
    }
    #endregion
    #region 页面静态化(不适合文章等纯HTML)
    /// <summary>
    /// 页面静态化(不适合文章等纯HTML)
    /// </summary>
    /// <param name="PathURL"></param>
    /// <returns></returns>
    public bool CreateHTML(string PathURL)
    {

        //保存路径
        string SavePath = PathURL + ".htm";
        //请求路径(删除前缀的~标识)
        string RequestPath = PathURL.TrimStart('~')+".aspx";
        //下载文件(原路径保存)
        Common.DownFile.CreateStaticByWebClient(RequestPath, SavePath);
        return true;
    }
    #endregion
}

这里涉及到一个LINQ,以前没怎么用过LINQ,仅仅是会点基本语法,这次,感觉真是挺强大的,简洁清晰.

      //查找所有的Page节点

IEnumerable<XElement> PageList = xDoc.Root.Descendants("Page");
     //linq分组(根据xml中Page的Type的名称分组)
     var group = PageList.GroupBy(page => page.Attribute("Type").Value);
  不过,groupby的接口是IGrouping<string, XElement>,group的key就是Type,value就是Type相同的Page节点

以前我们也写过类似的分组的处理,可以对比一下:

下面这个是根据类别,输出前8个产品,跟上面是类似的.

可以看到LINQ的简洁,LINQ和Lambda表达式,更简洁,更清晰也更容易理解.

    #region 根据企业id查找企业的产品信息(每种分别显示前8个)
        /// <summary>
        /// 根据企业id查找企业的产品信息(每种分别显示前8个)
        /// </summary>
        /// <param name="CompanyId"></param>
        /// <returns></returns>
        public string GetCompanyWorkForJson(string CompanyId)
        {
            //查询状态
            bool Status = false;
            //获取企业的产品信息(每种显示前8个)
            DataTable dtListProduct = new VProductCraftTypeDAL().ListAllByCompanyIdToDatable(CompanyId);
            //转化为json格式
            StringBuilder json = new StringBuilder();
            StringWriter sw = new StringWriter(json);

            using (JsonWriter jsonWriter = new JsonTextWriter(sw))
            {

                jsonWriter.Formatting = Formatting.Indented;
                //判断数据读取状态
                if (dtListProduct.Rows.Count > 0)
                {
                    Status = true;
                }
                jsonWriter.WriteStartObject();
                jsonWriter.WritePropertyName("Status");
                jsonWriter.WriteValue(Status);
                jsonWriter.WritePropertyName("Data");

                jsonWriter.WriteStartArray();
                if (Status == true)
                {
                    //先输出第一个元素的类别信息
                    jsonWriter.WriteStartObject();
                    jsonWriter.WritePropertyName("TypeId");
                    jsonWriter.WriteValue(dtListProduct.Rows[0]["TypeId"].ToString());
                    jsonWriter.WritePropertyName("TypeName");
                    jsonWriter.WriteValue(dtListProduct.Rows[0]["TypeName"].ToString());
                    //第一个元素的开始
                    jsonWriter.WritePropertyName("Product");
                    jsonWriter.WriteStartArray();

                    //按照类别分组
                    //产品计数(一个分组下的产品,从1开始算起)

                    for (int num = 0, numProduct = 1; num < dtListProduct.Rows.Count; num++, numProduct++)
                    {

                        //获取该类别下的分组总个数
                        int Total = Convert.ToInt32(dtListProduct.Rows[num]["total"]);
                        //如果该类别下还存在未输出的产品
                        if (numProduct <= Total)
                        {


                            jsonWriter.WriteStartObject();
                            jsonWriter.WritePropertyName("ProductId");
                            jsonWriter.WriteValue(dtListProduct.Rows[num]["Id"].ToString());
                            jsonWriter.WritePropertyName("Name");
                            jsonWriter.WriteValue(dtListProduct.Rows[num]["Name"].ToString());
                            jsonWriter.WritePropertyName("SimpleName");
                            jsonWriter.WriteValue(dtListProduct.Rows[num]["SimpleName"].ToString());
                            jsonWriter.WritePropertyName("Lsprice");
                            jsonWriter.WriteValue(dtListProduct.Rows[num]["Lsprice"].ToString());
                            jsonWriter.WritePropertyName("Picturepath");
                            jsonWriter.WriteValue(dtListProduct.Rows[num]["Picturepath"].ToString());
                            jsonWriter.WriteEndObject();

                        }
                        else
                        {
                            //将该类别的产品计数重置为1
                            numProduct = 1;
                            //这里给上一个类别的产品结束标记

                            jsonWriter.WriteEndArray();
                            jsonWriter.WriteEndObject();

                            jsonWriter.WriteStartObject();
                            jsonWriter.WritePropertyName("TypeId");
                            jsonWriter.WriteValue(dtListProduct.Rows[num]["TypeId"].ToString());
                            jsonWriter.WritePropertyName("TypeName");
                            jsonWriter.WriteValue(dtListProduct.Rows[num]["TypeName"].ToString());
                            //如果还存在产品
                            if (num < dtListProduct.Rows.Count)
                            {
                                //下一个元素的开始
                                jsonWriter.WritePropertyName("Product");
                                jsonWriter.WriteStartArray();

                            }

                        }
                    }
                }


                jsonWriter.WriteEndArray();
                jsonWriter.WriteEndObject();

            }
            return json.ToString();
        }
        #endregion

接下来我们就可以写,UI层和业务层了,

UI层仍然是用的MUNIUI框架(以后再也不用这个了,其实,不太好用,感觉,换个其他的JQuery框架),

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>页面管理(静态页面生成管理)</title>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    <link href="../css/demo.css" rel="stylesheet" type="text/css" />

    <script src="../scripts/jquery-1.6.2.min.js" type="text/javascript"></script>

    <script src="../scripts/miniui/miniui.js" type="text/javascript"></script>

    <link href="../scripts/miniui/themes/default/miniui.css" rel="stylesheet" type="text/css" />
    <link href="../scripts/miniui/themes/icons.css" rel="stylesheet" type="text/css" />
</head>
<body>
    <h1>
        页面静态化管理</h1>
    <ul id="tree2" class="mini-tree" url="Data/UrlInfo.ashx?method=GetURLInfo" style="width: 300px;"
        showtreeicon="true" textfield="text" idfield="id" showcheckbox="true"
        checkrecursive="true">
    </ul>
    <br />

     <a class="mini-button" iconCls=" icon-new" href="javascript:ToHtml()">页面静态化</a>
   <!-- <input type="button" value="setCheckedNodes" onclick="setCheckedNodes()" />
    <input type="button" value="getCheckedNodes" onclick="getCheckedNodes()" />-->
    <br />

    <script type="text/javascript">


        function getCheckedNodes() {
            var tree = mini.get("tree2");
            var value = tree.getValue();
            alert(value);

        }
        //页面静态化
        function ToHtml(){
        var tree = mini.get("tree2");
            var value = tree.getValue();
            if(value==null){
            alert("请选择要生成的静态页面的页面名称");
            return;
            }
            else{
            //alert(value);
             $.ajax({
                    url: "Data/UrlInfo.ashx?method=ToHtml",
                    data:{Id:value},
                    cache: false,
                    success: function (text){
                     if(text)
                     {
                     alert("页面HTML生成成功!");
                     }
                    }
                });

            }

        }
        //--------------------------------
        function onBeforeCheckNode(e) {
            var tree = e.sender;
            var node = e.node;
            if (tree.hasChildren(node)) {
                //e.cancel = true;
            }
        }

    </script>


</body>
</html>

后台Ashx页面:

<%@ WebHandler Language="C#" Class="UrlInfo" %>

using System;
using System.Web;
using czcraft.BLL;
using czcraft.Model;
using Common;
using System.Collections.Generic;
using Newtonsoft.Json.Linq;
public class UrlInfo : IHttpHandler {


    public void ProcessRequest(HttpContext context)
    {
        String methodName = context.Request["method"];
        if (!string.IsNullOrEmpty(methodName))
            CallMethod(methodName, context);
    }
    /// <summary>
    /// 根据业务需求调用不同的方法
    /// </summary>
    /// <param name="Method">方法</param>
    /// <param name="context">上下文</param>
    public void CallMethod(string Method, HttpContext context)
    {
        switch (Method)
        {
            case "GetURLInfo":
                GetURLInfo(context);
                break;
            case "ToHtml":
                ToHtml(context);
                break;
            default:
                return;


        }
    }
    /// <summary>
    /// 页面html
    /// </summary>
    /// <param name="context"></param>
    public void ToHtml(HttpContext context)
    {
      string Ids= context.Request["Id"];

        URLXMLInfoManage xmlManage = URLXMLInfoManage.Instance();
        //写回XML中
       context.Response.Write(xmlManage.SetURLInfo(Ids));
    }
    /// <summary>
    /// 获取URL信息(生成html的)
    /// </summary>
    /// <param name="context"></param>
    public void GetURLInfo(HttpContext context)
    {
        URLXMLInfoManage xmlManage = URLXMLInfoManage.Instance();

        context.Response.Write(xmlManage.GetURLInfoForJson());
    }
    public bool IsReusable {
        get {
            return false;
        }
    }

}

页面静态化效果:

可以看到首页和右下角的超链接,后缀都变成了htm,而且,项目中可以看到都生成了html页面

 

最近再看3本好书,一本是.net设计规范

极品,看了之后才知道代码命名等等问题.

还有一本是博客园的. 小洋（燕洋天）写的,蛮不错的,叫做.net应用架构设计原则,模式与实践

比较适合我这种,web对于架构方面有点感觉,但是不知道怎么样设计的好,扩展性好的孩纸.

还有一本就是C# in Depth

买了本英文版,慢慢品读,学英语,英语太差真吃亏呀!

接下来就是写一个缓存管理,

以前设计的缓存,只适合asp.net的Cache,但是asp.net的缓存,不适合大型构架,大型构架都会把缓存单独放在缓存服务器中,经常性,别人扩展到大型应用就麻烦了,我们需要考虑周全就需要写一个可扩展性的缓存结构,

MemCache是一个很强力的高性能分布式缓存系统.

接下来就准备设计一个缓存管理组件,用来管理缓存,如果网站扩大可以轻松的把缓存往MemCache上移植.