MVC 之 缓存机制（二）

　　八、应用程序缓存

　　应用程序缓存提供了一种编程方式，可通过键/值对将任意数据存储在内存中。 使用应用程序缓存与使用应用程序状态类似。 但是，与应用程序状态不同的是，应用程序缓存中的数据是易失的， 即数据并不是在整个应用程序生命周期中都存储在内存中。 使用应用程序缓存的优点是由 ASP.NET 管理缓存，它会在项过期、无效、或内存不足时移除缓存中的项。 还可以配置应用程序缓存，以便在移除项时通知应用程序。

　　应用程序缓存的使用模式：确定在访问某一项时该项是否存在于缓存中，如果存在，则使用。 如果该项不存在，则可以重新创建该项，然后将其放回缓存中。 这一模式可确保缓存中始终有最新的数据。

　　Catch 密封类 及 相关枚举类 在“ using System.Web.Caching; ”命名空间下。在 Asp.Net 中，System.Web 命名空间下的 HttpRuntime.Cache 以及 HttpContext.Current.Cache 都是该类的实例。

　　1、Catch 类代码

#region 程序集 System.Web.dll, v4.0.30319
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Web.dll
#endregion

using System;
using System.Collections;
using System.Reflection;
using System.Runtime;

namespace System.Web.Caching
{
    // 摘要:
    //     实现用于 Web 应用程序的缓存。此类不能被继承。
    public sealed class Cache : IEnumerable
    {
        // 摘要:
        //     用于 System.Web.Caching.Cache.Insert(System.String,System.Object) 方法调用中的 absoluteExpiration
        //     参数中以指示项从不到期。此字段为只读。
        public static readonly DateTime NoAbsoluteExpiration;
        //
        // 摘要:
        //     用作 System.Web.Caching.Cache.Insert(System.String,System.Object) 或 System.Web.Caching.Cache.Add(System.String,System.Object,System.Web.Caching.CacheDependency,System.DateTime,System.TimeSpan,System.Web.Caching.CacheItemPriority,System.Web.Caching.CacheItemRemovedCallback)
        //     方法调用中的 slidingExpiration 参数，以禁用可调到期。此字段为只读。
        public static readonly TimeSpan NoSlidingExpiration;

        // 摘要:
        //     初始化 System.Web.Caching.Cache 类的新实例。
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        public Cache();

        // 摘要:
        //     获取存储在缓存中的项数。
        //
        // 返回结果:
        //     存储在缓存中的项数。
        public int Count { get; }
        //
        // 摘要:
        //     获取在 ASP.NET 开始从缓存中移除项之前应用程序可使用的物理内存百分比。
        //
        // 返回结果:
        //     可供应用程序使用的物理内存百分比。
        public long EffectivePercentagePhysicalMemoryLimit { get; }
        //
        // 摘要:
        //     获取可用于缓存的字节数。
        //
        // 返回结果:
        //     可用于缓存的字节数。
        public long EffectivePrivateBytesLimit { get; }

        // 摘要:
        //     获取或设置指定键处的缓存项。
        //
        // 参数:
        //   key:
        //     表示缓存项的键的 System.String 对象。
        //
        // 返回结果:
        //     指定的缓存项。
        public object this[string key] { get; set; }

        // 摘要:
        //     将指定项添加到 System.Web.Caching.Cache 对象，该对象具有依赖项、到期和优先级策略以及一个委托（可用于在从 Cache 移除插入项时通知应用程序）。
        //
        // 参数:
        //   key:
        //     用于引用该项的缓存键。
        //
        //   value:
        //     要添加到缓存的项。
        //
        //   dependencies:
        //     该项的文件依赖项或缓存键依赖项。当任何依赖项更改时，该对象即无效，并从缓存中移除。如果没有依赖项，则此参数包含 null。
        //
        //   absoluteExpiration:
        //     所添加对象将到期并被从缓存中移除的时间。如果使用可调到期，则 absoluteExpiration 参数必须为 System.Web.Caching.Cache.NoAbsoluteExpiration。
        //
        //   slidingExpiration:
        //     最后一次访问所添加对象时与该对象到期时之间的时间间隔。如果该值等效于 20 分钟，则对象在最后一次被访问 20 分钟之后将到期并从缓存中移除。如果使用绝对到期，则
        //     slidingExpiration 参数必须为 System.Web.Caching.Cache.NoSlidingExpiration。
        //
        //   priority:
        //     对象的相对成本，由 System.Web.Caching.CacheItemPriority 枚举表示。缓存在退出对象时使用该值；具有较低成本的对象在具有较高成本的对象之前被从缓存移除。
        //
        //   onRemoveCallback:
        //     在从缓存中移除对象时所调用的委托（如果提供）。当从缓存中删除应用程序的对象时，可使用它来通知应用程序。
        //
        // 返回结果:
        //     如果添加的项之前存储在缓存中，则为表示该项的对象；否则为 null。
        //
        // 异常:
        //   System.ArgumentNullException:
        //     key 或 value 参数设置为 null。
        //
        //   System.ArgumentOutOfRangeException:
        //     slidingExpiration 参数设置成小于 TimeSpan.Zero 或大于一年。
        //
        //   System.ArgumentException:
        //     为要添加到 Cache 中的项设置 absoluteExpiration 和 slidingExpiration 参数。
        public object Add(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback);
        //
        // 摘要:
        //     从 System.Web.Caching.Cache 对象检索指定项。
        //
        // 参数:
        //   key:
        //     要检索的缓存项的标识符。
        //
        // 返回结果:
        //     检索到的缓存项，未找到该键时为 null。
        public object Get(string key);
        //
        // 摘要:
        //     检索用于循环访问包含在缓存中的键设置及其值的字典枚举数。
        //
        // 返回结果:
        //     要循环访问 System.Web.Caching.Cache 对象的枚举数。
        public IDictionaryEnumerator GetEnumerator();
        //
        // 摘要:
        //     向 System.Web.Caching.Cache 对象插入项，该项带有一个缓存键引用其位置，并使用 System.Web.Caching.CacheItemPriority
        //     枚举提供的默认值。
        //
        // 参数:
        //   key:
        //     用于引用该项的缓存键。
        //
        //   value:
        //     要插入缓存中的对象。
        //
        // 异常:
        //   System.ArgumentNullException:
        //     key 或 value 参数为 null。
        public void Insert(string key, object value);
        //
        // 摘要:
        //     向 System.Web.Caching.Cache 中插入具有文件依赖项或键依赖项的对象。
        //
        // 参数:
        //   key:
        //     用于标识该项的缓存键。
        //
        //   value:
        //     要插入缓存中的对象。
        //
        //   dependencies:
        //     所插入对象的文件依赖项或缓存键依赖项。当任何依赖项更改时，该对象即无效，并从缓存中移除。如果没有依赖项，则此参数包含 null。
        //
        // 异常:
        //   System.ArgumentNullException:
        //     key 或 value 参数为 null。
        public void Insert(string key, object value, CacheDependency dependencies);
        //
        // 摘要:
        //     向 System.Web.Caching.Cache 中插入具有依赖项和到期策略的对象。
        //
        // 参数:
        //   key:
        //     用于引用该对象的缓存键。
        //
        //   value:
        //     要插入缓存中的对象。
        //
        //   dependencies:
        //     所插入对象的文件依赖项或缓存键依赖项。当任何依赖项更改时，该对象即无效，并从缓存中移除。如果没有依赖项，则此参数包含 null。
        //
        //   absoluteExpiration:
        //     所插入对象将到期并被从缓存中移除的时间。要避免可能的本地时间问题（例如从标准时间改为夏时制），请使用 System.DateTime.UtcNow
        //     而不是 System.DateTime.Now 作为此参数值。如果使用绝对到期，则 slidingExpiration 参数必须为 System.Web.Caching.Cache.NoSlidingExpiration。
        //
        //   slidingExpiration:
        //     最后一次访问所插入对象时与该对象到期时之间的时间间隔。如果该值等效于 20 分钟，则对象在最后一次被访问 20 分钟之后将到期并被从缓存中移除。如果使用可调到期，则
        //     absoluteExpiration 参数必须为 System.Web.Caching.Cache.NoAbsoluteExpiration。
        //
        // 异常:
        //   System.ArgumentNullException:
        //     key 或 value 参数为 null。
        //
        //   System.ArgumentOutOfRangeException:
        //     将 slidingExpiration 参数设置为小于 TimeSpan.Zero 或大于一年的等效值。
        //
        //   System.ArgumentException:
        //     为要添加到 Cache 中的项设置 absoluteExpiration 和 slidingExpiration 参数。
        public void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration);
        //
        // 摘要:
        //     将对象与依赖项、到期策略以及可用于在从缓存中移除项之前通知应用程序的委托一起插入到 System.Web.Caching.Cache 对象中。
        //
        // 参数:
        //   key:
        //     用于引用对象的缓存键。
        //
        //   value:
        //     要插入到缓存中的对象。
        //
        //   dependencies:
        //     该项的文件依赖项或缓存键依赖项。当任何依赖项更改时，该对象即无效，并从缓存中移除。如果没有依赖项，则此参数包含 null。
        //
        //   absoluteExpiration:
        //     所插入对象将到期并被从缓存中移除的时间。要避免可能的本地时间问题（例如从标准时间改为夏时制），请使用 System.DateTime.UtcNow
        //     而不是 System.DateTime.Now 作为此参数值。如果使用绝对到期，则 slidingExpiration 参数必须设置为 System.Web.Caching.Cache.NoSlidingExpiration。
        //
        //   slidingExpiration:
        //     缓存对象的上次访问时间和对象的到期时间之间的时间间隔。如果该值等效于 20 分钟，则对象在最后一次被访问 20 分钟之后将到期并被从缓存中移除。如果使用可调到期，则
        //     absoluteExpiration 参数必须设置为 System.Web.Caching.Cache.NoAbsoluteExpiration。
        //
        //   onUpdateCallback:
        //     从缓存中移除对象之前将调用的委托。可以使用它来更新缓存项并确保缓存项不会从缓存中移除。
        //
        // 异常:
        //   System.ArgumentNullException:
        //     key、value 或 onUpdateCallback 参数为 null。
        //
        //   System.ArgumentOutOfRangeException:
        //     将 slidingExpiration 参数设置为小于 TimeSpan.Zero 或大于一年的等效值。
        //
        //   System.ArgumentException:
        //     为要添加到 Cache 中的项设置 absoluteExpiration 和 slidingExpiration 参数。- 或 -dependencies
        //     参数为 null，absoluteExpiration 参数设置为 System.Web.Caching.Cache.NoAbsoluteExpiration
        //     并且 slidingExpiration 参数设置为 System.Web.Caching.Cache.NoSlidingExpiration。
        public void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemUpdateCallback onUpdateCallback);
        //
        // 摘要:
        //     向 System.Web.Caching.Cache 对象中插入对象，后者具有依赖项、到期和优先级策略以及一个委托（可用于在从 Cache 移除插入项时通知应用程序）。
        //
        // 参数:
        //   key:
        //     用于引用该对象的缓存键。
        //
        //   value:
        //     要插入缓存中的对象。
        //
        //   dependencies:
        //     该项的文件依赖项或缓存键依赖项。当任何依赖项更改时，该对象即无效，并从缓存中移除。如果没有依赖项，则此参数包含 null。
        //
        //   absoluteExpiration:
        //     所插入对象将到期并被从缓存中移除的时间。要避免可能的本地时间问题（例如从标准时间改为夏时制），请使用 System.DateTime.UtcNow
        //     而不是 System.DateTime.Now 作为此参数值。如果使用绝对到期，则 slidingExpiration 参数必须为 System.Web.Caching.Cache.NoSlidingExpiration。
        //
        //   slidingExpiration:
        //     最后一次访问所插入对象时与该对象到期时之间的时间间隔。如果该值等效于 20 分钟，则对象在最后一次被访问 20 分钟之后将到期并被从缓存中移除。如果使用可调到期，则
        //     absoluteExpiration 参数必须为 System.Web.Caching.Cache.NoAbsoluteExpiration。
        //
        //   priority:
        //     该对象相对于缓存中存储的其他项的成本，由 System.Web.Caching.CacheItemPriority 枚举表示。该值由缓存在退出对象时使用；具有较低成本的对象在具有较高成本的对象之前被从缓存移除。
        //
        //   onRemoveCallback:
        //     在从缓存中移除对象时将调用的委托（如果提供）。当从缓存中删除应用程序的对象时，可使用它来通知应用程序。
        //
        // 异常:
        //   System.ArgumentNullException:
        //     key 或 value 参数为 null。
        //
        //   System.ArgumentOutOfRangeException:
        //     将 slidingExpiration 参数设置为小于 TimeSpan.Zero 或大于一年的等效值。
        //
        //   System.ArgumentException:
        //     为要添加到 Cache 中的项设置 absoluteExpiration 和 slidingExpiration 参数。
        public void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback);
        //
        // 摘要:
        //     从应用程序的 System.Web.Caching.Cache 对象移除指定项。
        //
        // 参数:
        //   key:
        //     要移除的缓存项的 System.String 标识符。
        //
        // 返回结果:
        //     从 Cache 移除的项。如果未找到键参数中的值，则返回 null。
        public object Remove(string key);
    }
}

Cache 类

　　2、通过键和值直接设置项向缓存赋值

List<MODEL.Classes> list = null;
if (Cache["myDog"] == null)
{
　　Cache["myDog"] = new Dog() { name= "小瑞瑞", type= "柯基犬" };
　　Response.Write("保存了一只狗狗");
　　//查询数据库 存入缓存
　　list = new BLL.Classes().GetList();
　　Cache["list"] =  list;
}
else
{
　　Dog myDog = Cache["myDog"] as Dog;
　　Response.Write("myDog="+myDog.name);
　　//从缓存里获取数据
　　list = Cache["list"] as List<MODEL.Classes>;
}
//myDog, list 就可以使用了

　　3、Insert 的方式加入缓存

　　在 Cache 类代码中可以看到，Insert 方法有五重重载，最简单方式如下：

Cache.Insert("key", "value");

　　(1) 添加依赖项（其他已存在的缓存；已存在的文件）

//依赖其他缓存的缓存
Cache.Insert("key1", "value1");
Cache.Insert("key2", "value2",new CacheDependency(null, new string[]{"key1"})); //依赖于key为key1的缓存
//依赖文件的缓存
Cache.Insert("key3", "value3",new CacheDependency(Server.MapPath("路径")));

　　(2) 插入多依赖缓存

CacheDependency dep1 = new CacheDependency(null, new string[] { "key1" });
CacheDependency dep2 = new CacheDependency(Server.MapPath("路径"));
AggregateCacheDependency cacheList = new AggregateCacheDependency();
cacheList.Add(dep1);
cacheList.Add(dep2);
Cache.Insert("key", "value",cacheList);

　　4、Add的形式添加缓存(该方法没有重载)

　　（CacheItemPriority 枚举、CacheItemRemovedReason 枚举）在 System.Web.Caching 命名空间下，可添加移除回调。

Cache.Add("key", "value", null, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.Default, null);

　　5、绝对过期时间和滑动过期时间

　　绝对过期字段的英文是NoSlidingExpiration(不滑动)，滑动过期的英文是NoAbsoluteExpiration(不绝对)。

//绝对过期时间的时间为30s，过完30s之后就没有缓存
Cache.Insert("key1", "value1",null, DateTime.Now.AddSeconds(30), Cache.NoSlidingExpiration,CacheItemPriority.High, RemoveCall)；
//滑动过期时间的时间为1分钟，只要一直刷新一直有，如果刷新间隔超过一分钟的缓存就没啦
Cache.Insert("key2", "value2", null, Cache.NoAbsoluteExpiration,new TimeSpan(0, 0, 60));
public void RemoveCall(string key, object value, CacheItemRemovedReason call)
{
    if (key=="key1")
    {
        Cache.Remove("key1");
    }
}

　　九、可拓展缓存（自定义）

　　ASP.NET 1到3.5中的输出缓存有一个限制，就是缓存存储本身不是可扩展的，ASP.NET 4.0之后是支持缓存扩展的。 通过缓存的扩展，可以保存HTML页面或者内存中的数据， 这些存储选项包括本地或远程磁盘、云存储和分布式缓存引擎。ASP.NET 中的输出缓存提供程序扩展性，可以为网站设计更好的输出缓存策略。实现可扩展，需要创建一个继承自 System.Web.Caching 命名空间下的 OutputCacheProvider 的抽象基类。

　　例如，可以创建这样一个输出缓存提供程序，该程序在内存中缓存站点流量排名靠前的页面，而在磁盘上缓存流量较低的页面，也可以对所呈现页面的各种变化因素组合进行缓存，但应使用分布式缓存以减少前端 Web 服务器的内存消耗。

    public class MyCacheProvide : OutputCacheProvider
    {
        public override object Add(string key, object entry, DateTime utcExpiry)
        {
            throw new NotImplementedException();
        }

        public override object Get(string key)
        {
            throw new NotImplementedException();
        }

        public override void Remove(string key)
        {
            throw new NotImplementedException();
        }

        public override void Set(string key, object entry, DateTime utcExpiry)
        {
            throw new NotImplementedException();
        }
    }

　　然后配置文件中进行相应配置：

    <caching>
      <outputCache defaultProvider="AspNetInternalProvider">
        <providers>
          <add name="DiskCache" type="MyWeb.Controllers.MyCacheProvide, MyWeb" />
        </providers>
      </outputCache>
    </caching>

　　默认情况下，所有 HTTP 响应、所呈现的页面和控件（其中 defaultProvider 特性设置为 AspNetInternalProvider）所示的内存输出缓存。通过为 defaultProvider 指定不同的提供程序名称，可以更改用于 Web 应用程序的默认输出缓存提供程序。默认值为“AspNetInternalProvider", 这是 ASP.NET 提供的内存缓存。

　　十、MVC 缓存问题

　　1、在 ASP.NET MVC 3 中如果使用了 OutputCache，一定要在 Action 中添加下面的代码，切记！

Response.Cache.SetOmitVaryStar(true);

　　这是一个伴随ASP.NET从1.0到4.0的OutputCache Bug，ASP.NET MVC 3 是基于 ASP.NET 4.0 的，所以也躲不过。

　　问题演示：

　　下面先来体验一下不加 Response.Cache.SetOmitVaryStar(true); 的情况。

　　示例Action代码：

[OutputCache(Duration = 120)]
public ActionResult SiteHome(int? pageIndex)
{
    ...
}

　　注意：OutputCache.Location的默认值是OutputCacheLocation.Any（服务端、客户端、代理服务器端等都进行缓存）

　　第一次请求：

　　

　　第二次请求（F5刷新浏览器）：

　　

　　第三次请求（F5刷新浏览器）：

　　

　　接着第四次请求会返回304，第五次请求又返回200。。。

　　再体验一下加“ Response.Cache.SetOmitVaryStar(true); ”的情况。

[OutputCache(Duration = 120)]
public ActionResult SiteHome(int? pageIndex)
{
    Response.Cache.SetOmitVaryStar(true);
    ...
}

　　第一次请求：

　　

　　第二次请求（F5刷新浏览器）：

　　

　　第三次请求（F5刷新浏览器）：

　　

　　注：只要在缓存有效期内，服务器一直返回304。

　　问题分析

　　1. 200与304的区别

　　当返回状态码是200时，服务器端会将当前请求的整个页面全部发送给客户端（消耗下行带宽）。

　　当返回状态码是304时，由于客户端浏览器提供的 Last-Modified 时间在服务器端的缓存有效期内，服务器端只发送这个状态码，不发送页面的任何内容（几乎不消耗下行带宽），浏览器直接从本地缓存中获取内容。

　　所以，304的好处就是节约带宽，响应速度更快。

　　2. 对服务端缓存的影响

　　加不加 Response.Cache.SetOmitVaryStar(true)，服务端的缓存情况都是一样的。只是不加 SetOmitVaryStar(true) 时，对于同一个客户端浏览器，每隔一次请求，服务器端就不管客户端浏览器的缓存，重新发送页面内容，但是只要在缓存有效期内，内容还是从服务器端缓存中读取。

　　问题危害

　　ASP.NET 缓存的这个诡异行为，导致在不知不觉中浪费了带宽资源。

　　十一、MVC4 缓存情况实例对比

　　1、未加缓存情况

[HttpPost]
public ActionResult Left(string parentId)
{
　　......
}

　　

　　2、添加缓存情况

[HttpPost]
[OutputCache(Duration = 10, VaryByParam = "*")]
public ActionResult Left(string parentId)
{
　　......
}

　　

　　3、添加缓存并添加 Response.Cache.SetOmitVaryStar(true);  情况

　　若在 MVC4 及以上版本中使用  Response.Cache.SetOmitVaryStar(true);  ，[OutputCache(Duration = 10)]中设置的 Duration 属性将失效，过期时间有效值为“ max-age=63625076997 ”秒。如下：

[HttpPost]
[OutputCache(Duration = 10)]
public ActionResult Left(string parentId)
{
    //Response.Cache.SetOmitVaryStar(true); //过期时间“max-age=63625076997”秒
}

　　

　　十二、ASP.NET MVC Action Filter - 缓存与压缩

　　我们可以将HTTP请求在一个定义的时间内缓存在用户的浏览器中，如果用户在定义的时间内请求同一个URL，那么用户的请求将会从用户浏览器的缓存中加载，而不是从服务器。可以在ASP.NET MVC应用程序中使用下面的Action Filter来实现同样的事情：

using System;
using System.Web;
using System.Web.Mvc;

public class CacheFilterAttribute : ActionFilterAttribute
{
    /// <summary>
    /// Gets or sets the cache duration in seconds. The default is 10 seconds.
    /// </summary>
    /// <value>The cache duration in seconds.</value>
    public int Duration
    {
        get;
        set;
    }

    public CacheFilterAttribute()
    {
        Duration = 10;
    }

    public override void OnActionExecuted(FilterExecutedContext filterContext)
    {
        if (Duration <= 0) return;

        HttpCachePolicyBase cache = filterContext.HttpContext.Response.Cache;
        TimeSpan cacheDuration = TimeSpan.FromSeconds(Duration);

        cache.SetCacheability(HttpCacheability.Public);
        cache.SetExpires(DateTime.Now.Add(cacheDuration));
        cache.SetMaxAge(cacheDuration);
        cache.AppendCacheExtension("must-revalidate, proxy-revalidate");
    }
}

　　可以像下面一样在你的Controller Action 方法中使用这个Filter :

[CacheFilter(Duration = 60)]
public void Category(string name, int? page)

　　下面是在firebug中当 缓存Filter 没有应用的时候的截图 :

　　

　　下面的截图是应用了 Cache Filter 时候的截图 :

　　

　　另外一个很重要的事情就是压缩。现在的浏览器都可以接收压缩后的内容,这可以节省大量的带宽。你可以在你的ASP.NET MVC 程序中应用下面的Action Filter 来压缩你的Response :

using System.Web;
using System.Web.Mvc;

public class CompressFilter : ActionFilterAttribute
{
    public override void OnActionExecuting(FilterExecutingContext filterContext)
    {
        HttpRequestBase request = filterContext.HttpContext.Request;

        string acceptEncoding = request.Headers["Accept-Encoding"];

        if (string.IsNullOrEmpty(acceptEncoding)) return;

        acceptEncoding = acceptEncoding.ToUpperInvariant();

        HttpResponseBase response = filterContext.HttpContext.Response;

        if (acceptEncoding.Contains("GZIP"))
        {
            response.AppendHeader("Content-encoding", "gzip");
            response.Filter = new GZipStream(response.Filter, CompressionMode.Compress);
        }
        else if (acceptEncoding.Contains("DEFLATE"))
        {
            response.AppendHeader("Content-encoding", "deflate");
            response.Filter = new DeflateStream(response.Filter, CompressionMode.Compress);
        }
    }
}

　　然后将这个Filter应用到你的Controller Action 中 :

[CompressFilter]
public void Category(string name, int? page)

　　下面是没有应用压缩的时候的截图 :

　　

　　下面的截图是应用了压缩Filter后的情形 :

　　

　　当然也可以将这两个Filter都应用到同一个Action方法上,就好像下面所示 :

[CompressFilter(Order = 1)]
[CacheFilter(Duration = 60, Order = 2)]
public void Category(string name, int? page)

　　下面是截图 :

　　

时间： 2024-10-23 06:27:08

MVC 之 缓存机制（二）的相关文章

Solr4.8.0源码分析(19)之缓存机制(二)

Solr4.8.0源码分析(19)之缓存机制(二) 前文<Solr4.8.0源码分析(18)之缓存机制(一)>介绍了Solr缓存的生命周期,重点介绍了Solr缓存的warn过程.本节将更深入的来介绍下Solr的四种缓存类型,以及两种SolrCache接口实现类. 1.SolrCache接口实现类 前文已经提到SolrCache有两种接口实现类:solr.search.LRUCache 和 solr.search.LRUCache. 那么两者具体有啥区别呢? 1.1 solr.search.LR

全面剖析Smarty缓存机制二[清除缓存方法]

前段时间,写了一篇 Smaryt缓存机制的几种缓存方式 ,详细介绍了三种缓存方式:全局缓存.部分缓存.局部缓存,以及通过is_cache()判断是否存在缓存来进行缓存生成.本来这篇早该完成,由于时间关系推到今天,还好思绪没有忘掉,闲话不多说,今天主要讲解Smarty缓存机制中如何清除缓存以及缓存集合的使用技巧,下面步入正题. 一.普通清除缓存方法总所周知,当你看了上一篇文章,会知道通过如下方法,对Smarty的缓存进行清除:代码示例:$smarty->clear_cache("index.

Java缓存学习之二：浏览器缓存机制

浏览器端的九种缓存机制介绍 浏览器缓存是浏览器端保存数据用于快速读取或避免重复资源请求的优化机制,有效的缓存使用可以避免重复的网络请求和浏览器快速地读取本地数据,整体上加速网页展示给用户.浏览器端缓存的机制种类较多,总体归纳为九种,这里详细分析下这九种缓存机制的原理和使用场景.打开浏览器的调试模式->resources左侧就有浏览器的8种缓存机制. 一.http缓存 http缓存是基于HTTP协议的浏览器文件级缓存机制.即针对文件的重复请求情况下,浏览器可以根据协议头判断从服务器端请求文件还是从

本地缓存机制之二

4.下面我们设计缓存项下载成功和失败的两个委托方法: @protocol CacheItemDelegate <NSObject> //下载成功执行该方法 - (void) cacheItemDelegateSucceeded :(CacheItem *)paramSender withRemoteURL:(NSURL *)paramRemoteURL withAboutToBeReleasedData:(NSData *)paramAboutToBeReleasedData; //下载失败执

MyBatis学习手记（二）MyBatis缓存机制

MyBatis学习手记二 前:MyBatis官方学习(中文)文档 http://mybatis.github.io/mybatis-3/zh/index.html 一,首先,要使用MyBatis必须使用官方提供的MyBatis的JAR包              链接:https://github.com/mybatis/mybatis-3/releases 这里使用的数据库是MySQL,所以还需要Mysql的驱动包. 二,看MyBatis官方介绍,说MyBatis支持一级缓存,二级缓存.这里才

深入理解http（二）------http的缓存机制及原理

一.概念基础 参考原文:https://blog.csdn.net/hiredme/article/details/73468040 http的缓存,主要存在于本地浏览器和web代理服务器中. 在这里,我们讲的是浏览器缓存. 1. 响应头ETag(Entity Tag) Etag用来表示一个资源.在服务器返回响应时包含这个值,不同的资源response返回不一样的Etag.在下次请求相同的资源时,浏览器会在 if-None-Match中带着Etag的传给服务器,如果服务器发现Etag和上次相同,

C#无限极分类树-创建-排序-读取 用Asp.Net Core+EF实现之方法二：加入缓存机制

在上一篇文章中我用递归方法实现了管理菜单,在上一节我也提到要考虑用缓存,也算是学习一下.Net Core的缓存机制. 关于.Net Core的缓存,官方有三种实现: 1.In Memory Caching 我理解是在内容中实现,这种方法适用于单服务器的生产环境. 2.a Distributed Cache 分部式缓存实现. 3.Response Cache 这种方式我理解为客户端缓存. 今天我只用了第一种实现方法,内存中缓存,之所以用这种方法我是觉得我这里用缓存的初衷是为了减少访问数据库的次数,

Android笔记（二十五） ListView的缓存机制与BaseAdapter

之前接触了ListView和Adapter,Adapter将数据源和View连接起来,实际应用中,我们要显示的数据往往有很多,而屏幕只有那么大,系统只能屏幕所能显示的内容,当我们滑动屏幕,会将旧的内容放入到缓冲池中,再从缓存池中拿出新的内容显示出来,这就是ListView的缓存机制,这一机制可以极大的节省系统资源. BaseAdapter BaseAdapter通常用于被扩展,扩展BaseAdapter可以对各项列表进行最大限度的定制. 我们可以用自己的类去继承BaseAdapter,然后实现g

Spring Boot2(二)：使用Spring Boot2集成Mybatis缓存机制

前言 学习SpringBoot集成Mybatis的第二章,了解到Mybatis自带的缓存机制,在部署的时候踩过了一些坑.在此记录和分享一下Mybatis的缓存作用. 本文章的源码再文章末尾 什么是查询缓存 MyBatis有一级缓存和二级缓存.记录可以看下这篇博文: 一级缓存 首先看一下什么是一级缓存,一级缓存是指SqlSession.一级缓存的作用域是一个SqlSession.Mybatis默认开启一级缓存. 在同一个SqlSession中,执行相同的查询SQL,第一次会去查询数据库,并写到缓存