प्रदर्शन और स्केलेबिलिटी के लिए रेडिस कैशिंग को .NET कोर एपीआई में एकीकृत करना

परिचय

• कैशिंग का परिचय
• कैश क्या है
• कैश के प्रकार
• कैश कार्यान्वयन

कैशिंग क्या है?

कैश के प्रकार

1. इन-मेमोरी कैशिंग
2. वितरित कैशिंग

वितरित कैशिंग

• मूल रूप से, वितरित कैशिंग में, जी डेटा को कई सर्वरों के बीच संग्रहीत और साझा किया जाता है
• इसके अलावा, जब हम मल्टी-टेनेंट एप्लिकेशन का उपयोग करते हैं, तो कई सर्वरों के बीच लोड को प्रबंधित करने के बाद एप्लिकेशन की स्केलेबिलिटी और प्रदर्शन में सुधार करना आसान होता है
• मान लीजिए, भविष्य में, यदि एक सर्वर क्रैश हो जाता है और पुनरारंभ होता है तो एप्लिकेशन पर कोई प्रभाव नहीं पड़ता है क्योंकि यदि हम चाहें तो एकाधिक सर्वर हमारी आवश्यकता के अनुसार हैं

रेडिस कैश

• रेडिस एक ओपन सोर्स (बीएसडी लाइसेंस प्राप्त) इन-मेमोरी डेटा स्ट्रक्चर स्टोर है जिसका उपयोग डेटाबेस के रूप में किया जाता है।
• मूल रूप से, इसका उपयोग अक्सर उपयोग किए जाने वाले और कुछ स्थिर डेटा को कैश के अंदर संग्रहीत करने और उपयोगकर्ता की आवश्यकता के अनुसार उपयोग और आरक्षित करने के लिए किया जाता है।
• रेडिस में कई डेटा संरचनाएं मौजूद हैं जिनका उपयोग हम डेटा को संग्रहीत करने के लिए सूची, सेट, हैशिंग, स्ट्रीम और कई अन्य जैसे उपयोग करने में सक्षम हैं।

रेडिस कैश की स्थापना

.NET कोर एपीआई का उपयोग करके रेडिस कैश का कार्यान्वयन

• Microsoft.EntityFrameworkCore
• Microsoft.EntityFrameworkCore.Design
• Microsoft.EntityFrameworkCore.SqlServer
• Microsoft.EntityFrameworkCore.Tools
• Swashbuckle.AspNetCore
• StackExchange.Redis

namespace RedisCacheDemo.Model
{
 public class Product
 {
 public int ProductId { get; set; }
 public string ProductName { get; set; }
 public string ProductDescription { get; set; }
 public int Stock { get; set; }
 }
}

using Microsoft.EntityFrameworkCore;
using RedisCacheDemo.Model;
namespace RedisCacheDemo.Data {
 public class DbContextClass: DbContext {
 public DbContextClass(DbContextOptions < DbContextClass > options): base(options) {}
 public DbSet < Product > Products {
 get;
 set;
 }
 }
}

using System;
namespace RedisCacheDemo.Cache
{
 public interface ICacheService
 {
 /// <summary>
 /// Get Data using key
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <returns></returns>
 T GetData<T>(string key);
 /// <summary> 
 /// Set Data with Value and Expiration Time of Key
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <param name="value"></param>
 /// <param name="expirationTime"></param>
 /// <returns></returns>
 bool SetData<T>(string key, T value, DateTimeOffset expirationTime);
 /// <summary>
 /// Remove Data 
 /// </summary>
 /// <param name="key"></param>
 /// <returns></returns>
 object RemoveData(string key);
 }
}

using Newtonsoft.Json;
using StackExchange.Redis;
using System;
namespace RedisCacheDemo.Cache {
 public class CacheService: ICacheService {
 private IDatabase _db;
 public CacheService() {
 ConfigureRedis();
 }
 private void ConfigureRedis() {
 _db = ConnectionHelper.Connection.GetDatabase();
 }
 public T GetData < T > (string key) {
 var value = _db.StringGet(key);
 if (!string.IsNullOrEmpty(value)) {
 return JsonConvert.DeserializeObject < T > (value);
 }
 return default;
 }
 public bool SetData < T > (string key, T value, DateTimeOffset expirationTime) {
 TimeSpan expiryTime = expirationTime.DateTime.Subtract(DateTime.Now);
 var isSet = _db.StringSet(key, JsonConvert.SerializeObject(value), expiryTime);
 return isSet;
 }
 public object RemoveData(string key) {
 bool _isKeyExist = _db.KeyExists(key);
 if (_isKeyExist == true) {
 return _db.KeyDelete(key);
 }
 return false;
 }
 }
}

using Microsoft.AspNetCore.Mvc;
using RedisCacheDemo.Cache;
using RedisCacheDemo.Data;
using RedisCacheDemo.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace RedisCacheDemo.Controllers {
 [Route("api/[controller]")]
 [ApiController]
 public class ProductController: ControllerBase {
 private readonly DbContextClass _dbContext;
 private readonly ICacheService _cacheService;
 public ProductController(DbContextClass dbContext, ICacheService cacheService) {
 _dbContext = dbContext;
 _cacheService = cacheService;
 }
 [HttpGet("products")]
 public IEnumerable < Product > Get() {
 var cacheData = _cacheService.GetData < IEnumerable < Product >> ("product");
 if (cacheData != null) {
 return cacheData;
 }
 var expirationTime = DateTimeOffset.Now.AddMinutes(5.0);
 cacheData = _dbContext.Products.ToList();
 _cacheService.SetData < IEnumerable < Product >> ("product", cacheData, expirationTime);
 return cacheData;
 }
 [HttpGet("product")]
 public Product Get(int id) {
 Product filteredData;
 var cacheData = _cacheService.GetData < IEnumerable < Product >> ("product");
 if (cacheData != null) {
 filteredData = cacheData.Where(x => x.ProductId == id).FirstOrDefault();
 return filteredData;
 }
 filteredData = _dbContext.Products.Where(x => x.ProductId == id).FirstOrDefault();
 return filteredData;
 }
 [HttpPost("addproduct")]
 public async Task < Product > Post(Product value) {
 var obj = await _dbContext.Products.AddAsync(value);
 _cacheService.RemoveData("product");
 _dbContext.SaveChanges();
 return obj.Entity;
 }
 [HttpPut("updateproduct")]
 public void Put(Product product) {
 _dbContext.Products.Update(product);
 _cacheService.RemoveData("product");
 _dbContext.SaveChanges();
 }
 [HttpDelete("deleteproduct")]
 public void Delete(int Id) {
 var filteredData = _dbContext.Products.Where(x => x.ProductId == Id).FirstOrDefault();
 _dbContext.Remove(filteredData);
 _cacheService.RemoveData("product");
 _dbContext.SaveChanges();
 }
 }
}

{
 "Logging": {
 "LogLevel": {
 "Default": "Information",
 "Microsoft": "Warning",
 "Microsoft.Hosting.Lifetime": "Information"
 }
 },
 "AllowedHosts": "*",
 "RedisURL": "127.0.0.1:6379",
 "ConnectionStrings": {
 "DefaultConnection": "Data Source=Server;Initial Catalog=RedisCache;User Id=sa;Password=***;"
 }
}

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.OpenApi.Models;
using RedisCacheDemo.Cache;
using RedisCacheDemo.Data;
namespace RedisCacheDemo {
 public class Startup {
 public Startup(IConfiguration configuration) {
 Configuration = configuration;
 }
 public IConfiguration Configuration {
 get;
 }
 // This method gets called by the runtime. Use this method to add services to the container.
 public void ConfigureServices(IServiceCollection services) {
 services.AddControllers();
 services.AddScoped < ICacheService, CacheService > ();
 services.AddDbContext < DbContextClass > (options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
 services.AddSwaggerGen(c => {
 c.SwaggerDoc("v1", new OpenApiInfo {
 Title = "RedisCacheDemo", Version = "v1"
 });
 });
 }
 // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
 public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
 if (env.IsDevelopment()) {
 app.UseDeveloperExceptionPage();
 app.UseSwagger();
 app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "RedisCacheDemo v1"));
 }
 app.UseHttpsRedirection();
 app.UseRouting();
 app.UseAuthorization();
 app.UseEndpoints(endpoints => {
 endpoints.MapControllers();
 });
 }
 }
}

using Microsoft.Extensions.Configuration;
using System.IO;
namespace RedisCacheDemo {
 static class ConfigurationManager {
 public static IConfiguration AppSetting {
 get;
 }
 static ConfigurationManager() {
 AppSetting = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json").Build();
 }
 }
}

using StackExchange.Redis;
using System;
namespace RedisCacheDemo.Cache {
 public class ConnectionHelper {
 static ConnectionHelper() {
 ConnectionHelper.lazyConnection = new Lazy < ConnectionMultiplexer > (() => {
 return ConnectionMultiplexer.Connect(ConfigurationManager.AppSetting["RedisURL"]);
 });
 }
 private static Lazy < ConnectionMultiplexer > lazyConnection;
 public static ConnectionMultiplexer Connection {
 get {
 return lazyConnection.Value;
 }
 }
 }
}

add-migration “FirstMigration”
update-database

• जब पहला उपयोगकर्ता सभी उत्पादों का डेटा लाने के लिए अनुरोध भेजता है, तो पहला अनुरोध आता है, और फिर यह जांच करेगा कि डेटा कैश के अंदर मौजूद है या नहीं। यदि डेटा कैश के अंदर मौजूद है, तो यह डेटाबेस से डेटा लाएगा और इसे कैश में भी सेट करेगा।
• इस बीच, दूसरा उपयोगकर्ता उत्पाद विवरण प्राप्त करने के लिए अनुरोध भेजता है। हुआ यह है कि पहले उपयोगकर्ता के अनुरोध को पूरा करने से पहले अनुरोध भी डेटाबेस को हिट करता है, और उसके कारण दूसरा उपयोगकर्ता भी उत्पाद विवरण प्राप्त करने के लिए डेटाबेस को हिट करता है।
• तो, इसके लिए नीचे दिखाए अनुसार लॉक तंत्र का उपयोग करना एक समाधान है

private static object _lock = new object()

public IEnumerable < Product > Get() {
 var cacheData = _cacheService.GetData < IEnumerable < Product >> ("product");
 if (cacheData != null) {
 return cacheData;
 }
 lock(_lock) {
 var expirationTime = DateTimeOffset.Now.AddMinutes(5.0);
 cacheData = _dbContext.Products.ToList();
 _cacheService.SetData < IEnumerable < Product >> ("product", cacheData, expirationTime);
 }
 return cacheData;
}