在虚拟机安装Linux+Linux环境搭建Redis+.net core 3.1 使用Redis

一、安装linux这个比较简单，有安装包就可以了

下面就不写文字了，看图片跟着做就好了

这里需要一个镜像文件，去下载一个就好https://www.centos.org/ 我下载的版本是 CentOS-7-x86_64-DVD-2003.iso

然后开机，会自动安装，选项选第一个。接下来进行一些选项的选择，按Continue

然后就选择Done，等待安装就好了

好了如果到了这个界面就差一步了，需要把网络搞定

输入命令 vi /etc/sysconfig/network-scripts/ifcfg-ens32 这里的ens32是我的，你自己的网络是什么就选什么

进入之后按键盘“i” 然后移动光标把图片中的onboot 改成yes 按ESC 输入:wq 就能保存退出了，

输入:q! 就是直接退出不保存，如果改错了就不保存直接退出

接下来重启一下网卡 service network restart 看到了已经联网了，到这儿系统算是安装完成了，需要安装软件了

接下来我们使用yum 安装 redis，安装前先把yum更新一下

更新完成，如果有错误，就自行百度一下吧。我装了很多次只要按照步骤去走，很难报错的。

接下来需要下载redis，这里我们使用 wget 直接在网上下载 wget http://download.redis.io/releases/redis-stable.tar.gz，但是提示我们找不到wget

我们使用yum install wget 来安装

安装完成后按箭头向上键。。把之前输入的命令敲回来，回车执行，等一会儿ll

可以看到已经在根目录下有一个安装包了

这里我们新建一个文件夹，然后把压缩包移动到新建的文件夹中mkdir 创建 mv 移动 cd 是进入 ll查看目录文件

解压文件 tar -xzvf redis-stable.tar.gz 解压完成后，会多出来一个文件夹，我们会看到里面有很多子文件夹

接下来我们要make 但是在那之前，我们先安装一下gcc 因为安装redis 需要gcc yum install gcc 安装完成后，make一下

这里我们看到了在make的时候有两个错误。。一个 error1 一个error2 解决一下

原因是因为gcc版本过低，yum安装的gcc是4.8.5的。因此需要升级gcc，升级过程如下：

yum -y install centos-release-scl

yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils

scl enable devtoolset-9 bash

echo "source /opt/rh/devtoolset-9/enable" >> /etc/profile

gcc -v

最后在执行一下make，这次编译通过，我们接下来 make install

然后进入src 安装redis

为了方便管理，我们新建两个文件夹，etc 和bin

然后把 redis.conf 移动到etc 目录下，把常用的命令移动到bin 目录，

移动时需要注意，redis.conf 在redis-stable 目录下，其他的在 redis-stable/src目录下

mv redis.conf /usr/local/redis/etc

mv mkreleasehdr.sh redis-benchmark redis-check-aof redis-check-rdb redis-cli redis-server /usr/local/redis/bin/

查看结果，已经转移到相应的目录

接下来我们设置后台启动修改redis.conf vim redis.conf 按i 启动编辑

注释掉 bind 127.0.0.1 如果不注释掉只能本机访问

接着把 daemonize 改成yes 开启守护现成模式，后台运行，不然你退出exit 都会关闭

把 protected-mode 改成no 被保护，默认是yes 如果外部需要连接需要配置bind 和密码，直接改成no就方便一点（因为我这里是局域网使用）

按ESC 输入:wq

保存退出后，

启动redis 使用我们刚才配置好的配置文件启动

进入到bin 目录输入命令 ./redis-server /usr/local/redis/etc/redis.conf

然后使用客户端 ./redis-cli 这样redis 就算是启动了

接下来我们测试一下 yum install net-tools 先装一个 net-tools

然后输入命令netstat -tunpl|grep 6379，可以看到端口已经启动

也可以使用 ps -ef | grep redis

这里有个很重要的点，如果不设置客户端就一直连接不上，那就是防火墙需要在防火墙下开启 6379的端口

firewall-cmd --zone=public --add-port=6379/tcp --permanent 然后重启 systemctl restart firewalld

redis服务已经启动成功了，就等着客户端连接了，下面我们开始使用.NET core 连接 redis

首先在appsettings.json增加一个redis配置串

在common类库中添加一个类SerializeHelper.cs，存放序列化方法先引用Nuget包 Newtonsoft.Json 代码如下

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Text;

namespace WebApi.Core.Common
{
    public class SerializeHelper
    {
        /// <summary>
        /// 序列化
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public static byte[] Serialize(object item)
        {
            var jsonString = JsonConvert.SerializeObject(item);

            return Encoding.UTF8.GetBytes(jsonString);
        }
        /// <summary>
        /// 反序列化
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="value"></param>
        /// <returns></returns>
        public static TEntity Deserialize<TEntity>(byte[] value)
        {
            if (value == null)
            {
                return default(TEntity);
            }
            var jsonString = Encoding.UTF8.GetString(value);
            return JsonConvert.DeserializeObject<TEntity>(jsonString);
        }
    }
}

继续在common类库中新建两个类RedisCacheManager.cs IRedisCacheManager.cs，redis接口和实现类引用Nuget包 StackExchange.Redis

代码如下

using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Text;

namespace WebApi.Core.Common.Redis
{
    public class RedisCacheManager:IRedisCacheManager
    {
        private readonly string redisConnenctionString;
        public volatile ConnectionMultiplexer redisConnection;
        private readonly object redisConnectionLock = new object();
        public RedisCacheManager()
        {
            string redisConfiguration = AppSettings.app(new string[] { "AppSettings", "RedisCaching", "ConnectionString" });//获取连接字符串

            if (string.IsNullOrWhiteSpace(redisConfiguration))
            {
                throw new ArgumentException("redis config is empty", nameof(redisConfiguration));
            }
            this.redisConnenctionString = redisConfiguration;
            this.redisConnection = GetRedisConnection();
        }

        /// <summary>
        /// 核心代码，获取连接实例
        /// 通过双if 夹lock的方式，实现单例模式
        /// </summary>
        /// <returns></returns>
        private ConnectionMultiplexer GetRedisConnection()
        {
            //如果已经连接实例，直接返回
            if (this.redisConnection != null && this.redisConnection.IsConnected)
            {
                return this.redisConnection;
            }
            //加锁，防止异步编程中，出现单例无效的问题
            lock (redisConnectionLock)
            {
                if (this.redisConnection != null)
                {
                    //释放redis连接
                    this.redisConnection.Dispose();
                }
                try
                {
                    this.redisConnection = ConnectionMultiplexer.Connect(redisConnenctionString);
                }
                catch (Exception)
                {

                    throw new Exception("Redis服务未启用，请开启该服务");
                }
            }
            return this.redisConnection;
        }

        public void Clear()
        {
            foreach (var endPoint in this.GetRedisConnection().GetEndPoints())
            {
                var server = this.GetRedisConnection().GetServer(endPoint);
                foreach (var key in server.Keys())
                {
                    redisConnection.GetDatabase().KeyDelete(key);
                }
            }
        }

        public bool Get(string key)
        {
            return redisConnection.GetDatabase().KeyExists(key);
        }

        public string GetValue(string key)
        {
            return redisConnection.GetDatabase().StringGet(key);
        }

        public TEntity Get<TEntity>(string key)
        {
            var value = redisConnection.GetDatabase().StringGet(key);
            if (value.HasValue)
            {
                //需要用的反序列化，将Redis存储的Byte[]，进行反序列化
                return SerializeHelper.Deserialize<TEntity>(value);
            }
            else
            {
                return default(TEntity);
            }
        }

        public void Remove(string key)
        {
            redisConnection.GetDatabase().KeyDelete(key);
        }

        public void Set(string key, object value, TimeSpan cacheTime)
        {
            if (value != null)
            {
                //序列化，将object值生成RedisValue
                redisConnection.GetDatabase().StringSet(key, SerializeHelper.Serialize(value), cacheTime);
            }
        }

        public bool SetValue(string key, byte[] value)
        {
            return redisConnection.GetDatabase().StringSet(key, value, TimeSpan.FromSeconds(120));
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace WebApi.Core.Common.Redis
{
    public interface IRedisCacheManager
    {
        //获取 Reids 缓存值
        string GetValue(string key);

        //获取值，并序列化
        TEntity Get<TEntity>(string key);

        //保存
        void Set(string key, object value, TimeSpan cacheTime);

        //判断是否存在
        bool Get(string key);

        //移除某一个缓存值
        void Remove(string key);

        //全部清除
        void Clear();
    }
}

接下来该注册redis服务了，进入到startup中的 ConfigureServices 添加如下代码红色

public void ConfigureServices(IServiceCollection services)
        {
            //注册AppSettings读取类
            services.AddSingleton(new AppSettings(Configuration));

            //注册Swagger服务
            services.AddSwaggerSetup();

            //jwt授权验证
            services.AddAuthorizationJwtSetUp();

            //数据库配置
            BaseDBConfig.ConnectionString = Configuration.GetSection("AppSettings:ConnectionStringOrg").Value;

            //注册Redis
            services.AddSingleton<IRedisCacheManager, RedisCacheManager>();

            services.AddControllers();
        }

接下来测试一下，我们在UserORMController 添加一个函数，函数中使用的redis对象是注入进去的如下代码，红色代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WebApi.Core.Common.Redis;
using WebApi.Core.IService;
using WebApi.Core.Model;

namespace WebApi.Core.Api.Controllers
{
    /// <summary>
    /// 用户表测试ORMSqlSuggr
    /// </summary>
    public class UserORMController : BaseController
    {
        //声明一个常量
        private readonly IUserService userService;
        private readonly IRedisCacheManager redisManager;
        /// <summary>
        /// 通过构造函数依赖注入
        /// </summary>
        /// <param></param>
        public UserORMController(IUserService userSer,IRedisCacheManager redisCache)
        {
            userService = userSer;
            redisManager = redisCache;
        }

        /// <summary>
        /// 根据id获取数据
        /// </summary>
        /// <param>参数id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> GetUser(int id)
        {
            UsersModel user = await userService.QueryByID(id);
            return Ok(user);
        }


        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param>参数id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Add(UsersModel user)
        {
            var count = await userService.Add(user);
            return Ok(count);
        }

        /// <summary>
        /// 更新数据
        /// </summary>
        /// <param>参数id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Update(UsersModel user)
        {
            var sucess = await userService.Update(user);
            return Ok(sucess);
        }

        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param>参数id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Delete(object[] ids)
        {
            var sucess = await userService.DeleteByIds(ids);
            return Ok(sucess);
        }
        /// <summary>
        /// 测试sqlSugar 常用语句
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult testSqlSugar()
        {
            userService.testSqlSugar();
            return Ok("true");
        }

        /// <summary>
        /// 测试Redis
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<IActionResult> Redis(int id)
        {

            var key = $"Redis{id}";
            UsersModel user = new UsersModel();
            if (redisManager.Get<object>(key) != null)
            {
                user = redisManager.Get<UsersModel>(key);
            }
            else
            {
                user = await userService.QueryByID(id);
                redisManager.Set(key, user, TimeSpan.FromHours(2));//缓存2小时
            }

            return Ok(user);
        }
    }
}

运行F5一下可以看到已经连接redis 成功。

我们再来看一下 redis 是否有数据了，可以看到已经存入值了

可以在请求一次，就是从redis取数据了，也可以改一下controller里面的过期时间，自己调试一番