一、安裝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 -yinstallcentos-release-scl

yum -yinstalldevtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils

sclenabledevtoolset-9bash

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 把 protected-mode 改成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，可以看到埠已經啟動

這裡有個很重要的點，如果不設定客戶端就一直連線不上，那就是防火牆需要在防火牆下開啟 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裡面的過期時間，自己除錯一番