网站优化之页面级缓存方案

用缓存来优化网站性能的方法，估计是无人不知的。 ASP.NET提供了HttpRuntime.Cache对象来缓存数据，也提供了OutputCache指令来缓存整个页面输出。 虽然OutputCache指令使用起来更方便，也有非常好的效果， 不过，它需要我们在那些页面中添加这样一个指令。

对于设置过OutputCache的页面来说，浏览器在收到这类页面的响应后，会将页面响应内容缓存起来。 只要在指定的缓存时间之内，且用户没有强制刷新的操作，那么就根本不会再次请求服务端， 而对于来自其它的浏览器发起的请求，如果缓存页已生成，那么就可以直接从缓存中响应请求，加快响应速度。 因此，OutputCache指令对于性能优化来说，是很有意义的（除非所有页面页面都在频繁更新）。

在网站的优化阶段，我们可以用Fiddler之类的工具找出一些内容几乎不会改变的页面，给它们设置OutputCache， 但是，按照传统的开发流程，我们需要针对每个页面文件执行以下操作：

方式一、使用ASP.NET平台提供的OutputCache（运行时内存）机制

实现方式：

1. 为列表页配置输出缓存声明；
2. 根据页面不同的查询参数缓存不同的页面
   1. E.g.同样是列表页，分类1页面：http://www.wedn.net/cat/1/和 分类二页面：http://www.wedn.net/cat/2/分别缓存成不同的缓存对象

优点：

1. 配置简单、
2. 不侵入原本系统、
3. 访问速度非常快（因为是将执行结果缓存到内存）

缺点：

1. 占用资源比较多，无法缓存所有的页面。
2. 另外有个问题：没有解决使用时间长了以后访问缓存速度变慢；

方式二、同样使用ASP.NET平台提供的OutputCache（自定义Provider）机制

实现方式：

1. 开发自定义Provider程序提供给ASP.NET调用去存取输出缓存；
2. 其余同方式一

优点：

1. 可以自主控制缓存读写、
2. 不侵入原有系统、
3. 访问快

缺点：

1. 配置相对复杂、
2. 需要开发Provider
3. 需要额外的资源（分布式缓存）

附：

自定义OutputCacheProvider实现将输出缓存放到分布式缓存中

实现原理：

实现方式：

1. 实现抽象基类OutputCacheProvider的增删方法；
2. 附上大概的代码（简单的通过文件读写、JSON序列化和二进制序列化实现），思路仅供参考：

OutputCacheProvider

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.Cryptography;
using System.Text;
using System.Web.Caching;
using Micua.Utility;
namespace Micua.UI.Cache
{
    public class MicuaOutputCacheProvider : OutputCacheProvider, IDisposable
    {
        readonly IList<CacheItem> _cacheItems;
        public MicuaOutputCacheProvider()
        {
            if (File.Exists("z:\\cache.json"))
            {
                var json = File.ReadAllText("z:\\cache.json");
                _cacheItems = JsonHelper.Deserialize<List<CacheItem>>(json) ?? new List<CacheItem>();
            }
            else
            {
                _cacheItems = new List<CacheItem>();
            }
        }
        public override object Get(string key)
        {
            Debug.WriteLine(string.Format("Cache.Get({0})", key));
            key = MD5(key);
            var cacheItem = _cacheItems.FirstOrDefault(c => c.Id == key);
            if (cacheItem != null)
            {
                if (cacheItem.Expiration.ToUniversalTime() <= DateTime.UtcNow)
                {
                    _cacheItems.Remove(cacheItem);
                }
                else
                {
                    return Deserialize(cacheItem.Item);
                }
            }
            return null;
        }
        public override object Add(string key, object entry, DateTime utcExpiry)
        {
            Debug.WriteLine("Cache.Add({0}, {1}, {2})", key, entry, utcExpiry);
            key = MD5(key);
            if (utcExpiry == DateTime.MaxValue)
                utcExpiry = DateTime.UtcNow.AddMinutes(5);
            var item = _cacheItems.FirstOrDefault(c => c.Id == key);
            if (item != null)
            {
                if (item.Expiration.ToUniversalTime() <= DateTime.UtcNow)
                {
                    _cacheItems.Remove(item);
                }
                else
                {
                    SaveChange();
                    return Deserialize(item.Item);
                }
            }
            _cacheItems.Add(new CacheItem
            {
                Id = key,
                Item = Serialize(entry),
                Expiration = utcExpiry
            });
            SaveChange();
            return entry;
        }
        public override void Set(string key, object entry, DateTime utcExpiry)
        {
            Debug.WriteLine("Cache.Set({0}, {1}, {2})", key, entry, utcExpiry);
            key = MD5(key);
            var item = _cacheItems.FirstOrDefault(c => c.Id == key);
            if (item != null)
            {
                _cacheItems.Remove(item);
                item.Item = Serialize(entry);
                item.Expiration = utcExpiry;
                _cacheItems.Add(item);
            }
            else
            {
                _cacheItems.Add(new CacheItem
                {
                    Id = key,
                    Item = Serialize(entry),
                    Expiration = utcExpiry
                });
            }
            SaveChange();
        }
        public override void Remove(string key)
        {
            Debug.WriteLine("Cache.Remove({0})", key);
            key = MD5(key);
            _cacheItems.Remove(_cacheItems.FirstOrDefault(c => c.Id == key));
            SaveChange();
        }
        private static string MD5(string value)
        {
            var cryptoServiceProvider = new MD5CryptoServiceProvider();
            var bytes = Encoding.UTF8.GetBytes(value);
            var builder = new StringBuilder();
            bytes = cryptoServiceProvider.ComputeHash(bytes);
            foreach (var b in bytes)
                builder.Append(b.ToString("x2").ToLower());
            return builder.ToString();
        }
        private static byte[] Serialize(object entry)
        {
            var formatter = new BinaryFormatter();
            var stream = new MemoryStream();
            formatter.Serialize(stream, entry);
            return stream.ToArray();
        }
        private static object Deserialize(byte[] serializedEntry)
        {
            var formatter = new BinaryFormatter();
            var stream = new MemoryStream(serializedEntry);
            return formatter.Deserialize(stream);
        }
        private void SaveChange()
        {
            var json = JsonHelper.Serialize(_cacheItems);
            File.WriteAllText("z:\\cache.json", json);
        }
        public void Dispose()
        {
            var json = JsonHelper.Serialize(_cacheItems);
            File.WriteAllText("z:\\cache.json", json);
        }
    }
}