ASP.Net Core -- 缓存

缓存的优点有很多,比如:

   1:提高网站的访问速度

   2:适用于不易改变的数据

当然也有缺点,比如:

   1:使用缓存之前需要仔细规划这个项目,不然容易引起一些奇怪的副作用

缓存地点

1:服务器

比如是一个单服务器的web应用,缓存就可以放到这个服务器上,就是和web服务器放在一起

2:缓存服务器

如果web应用涉及到多个服务器的话,这个时候可以考虑单做做一个缓存服务器,然后其它的web服务器都可以访问这个缓存服务器

3:客户端

也就是本地

In-Memory缓存

1:这是最简单的,它实现了InMemoryCache这个接口

2:它适用于Sticky session这样的会话,翻译成中文就是黏性的会话,比如web应用涉及到多个服务器,那么就要保证,你的请求之前是访问的那一台服务器,那么之后想访问缓存数据的话,就必须访问的还是那一台服务器

3:最后,由于In-Memory使用的内存缓存,所以适用于任何类型的对象

代码示例

添加缓存服务,在startup.cs的ConfigureServices()方法中添加:

services.AddMemoryCache();

这样就可以使用In-Memory这个缓存了,比如要在HomeController里使用,只需要将InMemoryCache这个服务注入即可:

private readonly ILogger<HomeController> _logger;
        private readonly IMemoryCache _memoryCache;

        public HomeController(ILogger<HomeController> logger,
            IMemoryCache memoryCache)
        {
            _logger = logger;
            _memoryCache = memoryCache;
        }

另外,我们还需要给缓存设置一些东西,比如:

1:缓存时间,

    绝对过期时间::Absolute expiration time,比如一天

    Sliding expiration time:这个不知道怎么翻译,比如当访问到某个缓存后,把该缓存的时间时间再往后调一个小时

2:缓存的优先级

3:PostEvictionDelegate:当缓存的数据被清除后将被调用

再新建一个类,存放一个常量,因为缓存需要一个Key,如下:

public class CacheEntryConstants
    {
        public const string AlbumsOfToday = nameof(AlbumsOfToday);
    }

然后在控制器中在Index里,把用户列表数据进行缓存

public IActionResult Index() 
        {
            if (!_memoryCache.TryGetValue(
                CacheEntryConstants.AlbumsOfToday,
                out IEnumerable<Student> cachedStudent))
            {
                cachedStudent =  _repository.GetAll();

                var cacheEntryOptions = new MemoryCacheEntryOptions()
                    // .SetAbsoluteExpiration(TimeSpan.FromSeconds(600))
                    .SetSlidingExpiration(TimeSpan.FromSeconds(30));

                cacheEntryOptions.RegisterPostEvictionCallback(FillCache, this);

                _memoryCache.Set(CacheEntryConstants.AlbumsOfToday, cachedStudent, cacheEntryOptions);
            }


            return View(cachedStudent);
        }

然后写一个当缓存被清除后被调用的函数:

private void FillCache(object key, object value, EvictionReason reason, object state)
        {
            
        }

这里边就不写东西了,主要是用来测试,当缓存被清除后,会不会走这里边

打断点调试:

第一次,没有缓存,进入判断里边:

第二次,直接返回视图:

 

等待30秒,再刷新页面,进入回调函数:

具体内容:

1:先判断缓存里是否有数据,有的话直接用,没有的话就去数据库读取:

2:然后设置缓存时间

3:当缓存被清除后进入回调函数

关于In-Memory就简单学习到这里,如果以后需要可以具体看官方文档

Cache Tag Helper

既然是Helper,就是用在Razor View里边,基本格式如下:

<cache>@await Component.InvokeAsync("xxx")</cache>

当然,里边也可以添加一些属性,所以它也是在服务器端进行操作的,实际上它使用的还是内存里的缓存

Tag Helper的属性比较多,这里介绍一些相对重要的,如下:

enabled:         是否启用
expires-on:      绝对过期时间
expires-after:   时间长度
expires-sliding: 可调式过期时间
vary-by-header
vary-by-query
vary-by-route
vary-by-cookie
vary-by-user
vary-by priority

具体可以看文档

代码示例

 在layout.cshtml里写入:

<cache expires-after="@TimeSpan.FromSeconds(30)">
         @await Component.InvokeAsync("InternetStatus")
 </cache>

这没啥功能,就是测试网络是否连接正常,如下:

public async Task<IViewComponentResult> InvokeAsync()
        {
            var httpClient = new HttpClient();

            var response = await httpClient.GetAsync("https://www.baidu.com");
            if (response.StatusCode == HttpStatusCode.OK)
            {
                return View(true);
            }

            return View(false);
        }

可以在layout里对加入哪一行代码打断点

1:第一次走进来,没问题

2:然后把电脑网络连接关闭,再刷新,还是没问题

3:等30秒后,就抛出异常了,因为缓存没了

分布式 缓存

以上的例子,因为用的是单个服务器,所以只对那一个服务器起作用,但是我们在实际企业项目开发时候,可能要做个集群什么的

比如,当用户发出请求后有多个web服务器,这个时候请求不一定请求的是那一台web服务器,所以这个时候我们就要把缓存数据提出来,单独放在一台缓存服务器上,来供其它web服务器来访问,如下:

分布式缓存的一些特点:

1:无需Sticky Session

2:可扩展

3:服务器重启不会影响缓存

4:性能更好

分布式缓存接口名和一些方法:

1:IDistributedCache

2:Get,GetAsnyc

3:Set,SetAsync

4:Refresh,RefreshAsync

5:Remove,RemoveAsync

方法的参数类型都是byte数组类型

分布式缓存默认使用一下几种:

1:分布式 Memory Cache       这个只在开发时候使用,不太分布式

2:分布式 SQL server Cache   可以在生产环境使用

3:分布式 Redis Chche        可以在生产环境使用(使用最多)

代码示例

 1:使用docker拉去Redis,打开cmd,执行:

docker pull redis

docker run --name second-redis -d -p 6379:6379 redis

docker run -it --link my-redis:my-redis --rm redis redis-cli -h my-redis -p 6379

2:在项目startup.cs添加服务:

services.AddDistributedRedisCache(options =>
            {
                options.Configuration = "localhost";
                options.InstanceName = "redis-for-home";
            });

3:在需要使用Redis缓存的控制器中注入IDistributedCache:

public readonly IRepository<Student> _repository;
        private readonly HostingEnvironment _hostingEnvironment;
        private readonly ILogger<HomeController> _logger;
        private readonly IMemoryCache _memoryCache;
        private readonly IDistributedCache _distributedCache;

        public HomeController(IRepository<Student> repository,
            HostingEnvironment hostingEnvironment,
            ILogger<HomeController> logger, 
            IDistributedCache distributedCache,
            IMemoryCache memoryCache)
        {
            _repository = repository;
            _hostingEnvironment = hostingEnvironment;
            _logger = logger;
            _memoryCache = memoryCache;
            _distributedCache = distributedCache;
        }

4:在index方法里使用缓存:

IEnumerable<Student> cachedStudent = null;

            var cachedStudentString = _distributedCache.Get(CacheEntryConstants.AlbumsOfToday);

            if (cachedStudentString == null)
            {
                cachedStudent = _repository.GetAll();
                var serializedString = JsonConvert.SerializeObject(cachedStudent);
                byte[] encodedAlbums = Encoding.UTF8.GetBytes(serializedString);

                var cacheEntryOptions = new MemoryCacheEntryOptions()
                    .SetSlidingExpiration(TimeSpan.FromSeconds(30));
                _distributedCache.Set(CacheEntryConstants.AlbumsOfToday, encodedAlbums);
            }
            else
            {
                byte[] encodedAlbums = _distributedCache.Get(CacheEntryConstants.AlbumsOfToday);
                string serializedString = Encoding.UTF8.GetString(encodedAlbums);
                cachedStudent = JsonConvert.DeserializeObject<List<Student>>(serializedString);
            }

可以断定调试一下,第一次进入if条件语句里边,第二次就进入else里边,说明已经成功使用到了Redis缓存。

目前缓存实在本地Redis上边,当然,也可以将Redis安装到其它服务器上边,就是所谓的分布式缓存。

Response缓存

一:理解、就是把响应缓存一下,如下:

  1:基于Header

  2:客户端缓存

  3:使用responseCache这个attribute

二:参数、它有一下几个参数:

  1:Location、设置缓存地点

  2:Duration、设置缓存时间

  3:NoStore、 设置不应该缓存

  4:VaryByHeader  、设置到底检查Header的值来决定是否使用缓存

代码示例

 1:在startup.cs里的services.AddMvc()里添加:

options.CacheProfiles.Add("Default", new CacheProfile
{
    Duration = 60
});
 options.CacheProfiles.Add("Never", new CacheProfile
 {
    Location = ResponseCacheLocation.None,
    NoStore = true
 });

2:在控制器中,就像属性路由或者过滤器一样,在需要缓存的数据的方法上边添加:

[ResponseCache(CacheProfileName = "Default")]

这样就会使用到在startup的Default缓存了,当然,也可以直接这样:

 

[ResponseCache(Duration = 30, Location = ResponseCacheLocation.Client)]

 

这样的话,就不需要在startup添加缓存服务了。但是需要注意的是,这种缓存,只能针对对网页的后退或者前进,如果刷新的话缓存就没了

 

 

posted @ 2020-08-28 00:09  初晨~  阅读(384)  评论(0编辑  收藏  举报