TypeScript依赖注入框架Typedi的使用、原理、源码解读

简介

typedi是一个基于TS的装饰器和reflect-metadata的依赖注入轻量级框架，使用简单易懂，方便拓展。

使用typedi的前提是安装reflect-metadata，并在项目的入口文件的第一行中声明import ‘reflect-metadata’，这样就会在原生的Reflect API上挂载metadata操作相关的API。

前提

  1. 项目中引入reflect-metadata依赖
pnpm add reflect-metadata
  1. 在项目的入口文件的第一行声明
import 'reflect-metadata'
  1. 在tsconfig.json中开启装饰器语法和装饰器元数据
{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

当开启了emitDecoratorMetadata后，TS会自动为装饰器生成metadata，有3个metadata：

  • design:type 被装饰器修饰的目标的类型，即成员的类型
  • design:paramtypes 方法的参数的类型集合，是一个数组，只有被修饰是方法时，此metadata才有效，否则就是undefined
  • design:returntype 方法的返回值类型，只有方法独有的metadata

安装typedi

pnpm add typedi

注册实例到容器中

typedi是基于IOC和DI的思想，因此需要有一个容器来容纳所有的bean

有三种方式注册你的实例到容器Container中：

  • 使用@Service()修饰的类(声明式)
  • 用Token注册一个实例(手动式)
  • 用字符串来注册一个实例(手动式)

Token和字符串标识符可以用来注册类以外的其他值。Token和字符串标识符都可以注册任何类型的值，包括除undefined之外的原始值。它们必须在容器上用Container.set()函数设置，然后才能通过Container.get()请求它们。

使用@Service注入：

import 'reflect-metadata'
import { Service, Container } from 'typedi'

@Service()
class Person {
  name: string = 'John'
  age: number = 30
}

const obj = Container.get(Person) as Person

console.log(obj)
// Person { name: 'John', age: 30 }

使用Token或字符串注入：

import 'reflect-metadata'
import { Service, Container, Token } from 'typedi'

Container.set('message', 'Hello World')
console.log(Container.get('message')) // Hello World

const token = new Token('TOKEN_INDEX')
Container.set(token, 'Nice to meet you!')
console.log(Container.get(token)) // Nice to meet you!

依赖注入

三种方式注入依赖的实例：

  • 通过类的构造函数参数自动注入
  • 使用@Inject()装饰器来标注需要注入的属性
  • 直接使用Container.get()来获取实例，手动注入

构造函数参数注入

import 'reflect-metadata'
import { Service, Container, Token } from 'typedi'

@Service()
class A {
  say(){
    console.log('A ...')
  }
}

@Service()
class B {
  constructor(public a: A){}

  say(){
    console.log('B ...')
    this.a.say()
  }
}

const b = Container.get(B) as B
b.say()
// B ...
// A ...

@Inject()属性注入

import 'reflect-metadata'
import { Service, Container, Token, Inject } from 'typedi'

@Service()
class A {
  say(){
    console.log('A ...')
  }
}

@Service()
class B {

  @Inject()
  a: A

  say(){
    console.log('B ...')
    this.a.say()
  }
}

const b = Container.get(B) as B
b.say()
// B ...
// A ...

bean的作用域

默认注入到容器中的实例都是单例的，即每次从容器中获取的对象都是同一个对象

import 'reflect-metadata'
import { Service, Container, Token, Inject } from 'typedi'

@Service()
class Person {
  name = 'John Doe'
  age = 21
}

const obj1 = Container.get(Person)
const obj2 = Container.get(Person)
// 判断两个对象是否是同一个对象
console.log(obj1 === obj2) // true

如果想要每次请求容器时，都会得到一个新的对象，可以这样做

import 'reflect-metadata'
import { Service, Container, Token, Inject } from 'typedi'

@Service({ transient: true })
class Person {
  name = 'John Doe'
  age = 21
}

const obj1 = Container.get(Person)
const obj2 = Container.get(Person)
// 判断两个对象是否是同一个对象
console.log(obj1 === obj2) // false

@Inject

@Inject是一个属性和参数装饰器，用于解决一个类的属性或构造函数参数的依赖

默认情况下，他能推断出属性或参数的类型，并初始化一个检测到的类型的实例，然而这种行为可以通过指定一个自定义的可构造类型、Token或已命名的Service作为第一个参数 来覆盖

属性注入

属性的类型是自动推断出来的，所以不需要定义所需的值来作为装饰器的参数

import 'reflect-metadata';
import { Container, Inject, Service } from 'typedi';

@Service()
class InjectedExampleClass {
  print() {
    console.log('I am alive!');
  }
}

@Service()
class ExampleClass {
  @Inject()
  withDecorator: InjectedExampleClass;

  withoutDecorator: InjectedExampleClass;
}

const instance = Container.get(ExampleClass);

/**
 * `instance`变量是一个ExampleClass实例
 * 其`withDecorator`属性包含一个InjectedExampleClass实例
 * 而`withoutDecorator`属性undefined
 */
console.log(instance);

instance.withDecorator.print();
// "I am alive!" (InjectedExampleClass.print 方法)
console.log(instance.withoutDecorator);
// undefined, 因为这个属性没有用@Inject装饰器标记

构造函数注入

构造函数注入，当一个类被@Service装饰器标注时，在构造器注入中不需要@Inject装饰器，TS会自动推断并为每个构造参数注入正确的类实例。

但是注意，@Inject可以用来覆盖注入的类型

import 'reflect-metadata';
import { Container, Inject, Service } from 'typedi';

@Service()
class InjectedExampleClass {
  print() {
    console.log('I am alive!');
  }
}

@Service()
class ExampleClass {
  constructor(
    @Inject()
    public withDecorator: InjectedExampleClass,
    public withoutDecorator: InjectedExampleClass
  ) {}
}

const instance = Container.get(ExampleClass);

/**
 * `instance'变量是一个ExampleClass实例
 * 它同时具有
`withDecorator`和`withoutDecorator`属性
 * 都包含一个
InjectedExampleClass实例。
 */
console.log(instance);

instance.withDecorator.print();
// 输出 "I am alive!" (InjectedExampleClass.print function)
instance.withoutDecorator.print();
// 输出 "I am alive!" (InjectedExampleClass.print function)

明确请求目标类型

默认情况下，TypeDI将尝试推断属性和参数的类型并注入适当的类实例。当必要时，可以覆盖注入值的类型：

  • 通过@Inject( () => type)，其中type是一个可构造的值（例如，一个类的定义）
  • 通过@Inject(myToken)，其中myToken是一个Token类的实例
  • 通过@Inject(serviceName)，其中serviceName是一个字符串，已经通过Container.set(serviceName, value)注册过了
import 'reflect-metadata';
import { Container, Inject, Service } from 'typedi';

@Service()
class InjectedExampleClass {
  print() {
    console.log('I am alive!');
  }
}

@Service()
class BetterInjectedClass {
  print() {
    console.log('I am a different class!');
  }
}

@Service()
class ExampleClass {
  @Inject()
  inferredPropertyInjection: InjectedExampleClass;

  /**
   * 我们告诉TypeDI，用`BetterInjectedClass`类初始化。
   * 不管推断的类型是什么。
   */
  @Inject(() => BetterInjectedClass)
  explicitPropertyInjection: InjectedExampleClass;

  constructor(
    public inferredArgumentInjection: InjectedExampleClass,
    /**
     * 我们告诉TypeDI，用`BetterInjectedClass`类初始化。
     * 不管推断的类型是什么。
     */
    @Inject(() => BetterInjectedClass)
    public explicitArgumentInjection: InjectedExampleClass
  ) {}
}

/**
 * `instance`变量是一个 ExampleClass 的实例，同时具有
 * - `inferredPropertyInjection` 和 `inferredArgumentInjection` 属性
 * 都包含一个`InjectedExampleClass`实例
 * - `explicitPropertyInjection`和`explicitArgumentInjection`属性
 * 都包含一个`BetterInjectedClass'实例。
 */
const instance = Container.get(ExampleClass);

instance.inferredPropertyInjection.print();
// "I am alive!" (InjectedExampleClass.print function)
instance.explicitPropertyInjection.print();
// "I am a different class!" (BetterInjectedClass.print function)
instance.inferredArgumentInjection.print();
// "I am alive!" (InjectedExampleClass.print function)
instance.explicitArgumentInjection.print();
// "I am a different class!" (BetterInjectedClass.print function)

循环依赖

依赖注入最常见的问题就是循环依赖，因此为了避免循环依赖，我们需要为属性指明类型
在循环依赖的情况下，TS无法推断出属性的类型，就导致design:type为undefined，typedi就无法实例化，因此我们需要强制给出类型。

// Car.ts
@Service()
export class Car {
  @Inject(type => Engine)
  engine: Engine;
}

// Engine.ts
@Service()
export class Engine {
  @Inject(type => Car)
  car: Car;
}

注意这种方式只能解决属性注入，不能解决构造参数的注入。

需要注意的是，通常循环依赖意味着：

  1. 模块间的指责分工不明
  2. 单个模块的指责过多(不满足单一职责原则)
  3. 缺少合理的抽象层

Service Token

在使用@Service()来注入一个实例到Container中时，我们可以给出@Service()参数，用来唯一标识这个实例，参数类型通常是字符串或Token类型。

使用字符串

import 'reflect-metadata'
import { Service, Token, Container, Inject } from 'typedi'

@Service('userComponet')
class Person {
  name = 'john'
}

@Service('userIndex')
class PersonController {
  
  @Inject('userComponet')
  obj: Person

  say(){
    console.log('userIndex ... ',this.obj.name)
  }
}

console.log((Container.get('userComponet') as Person).name); // john

(Container.get('userIndex') as PersonController).say() // userIndex ... john

使用Token

Service Token 可以用来标识Container中唯一的一个实例，可以安全地从Container中获取Bean

import 'reflect-metadata';
import { Container, Token } from 'typedi';

export const JWT_SECRET_TOKEN = new Token<string>('MY_SECRET');

Container.set(JWT_SECRET_TOKEN, 'wow-such-secure-much-encryption');

/**
 * 这个值是类型安全的，因为Token是类型化的。
 */
const JWT_SECRET = Container.get(JWT_SECRET_TOKEN);
console.log(JWT_SECRET)

可以与@Inject()搭配使用，覆盖属性或参数的推断类型

import 'reflect-metadata';
import { Container, Token, Inject, Service } from 'typedi';

export const JWT_SECRET_TOKEN = new Token<string>('MY_SECRET');

Container.set(JWT_SECRET_TOKEN, 'wow-such-secure-much-encryption');

@Service()
class Example {
  @Inject(JWT_SECRET_TOKEN)
  myProp: string;
}

const instance = Container.get(Example);
// instance.myProp属性有为Token分配的值。

同名的Token

两个具有相同名称的Token是不同的Token，一个Token实例是唯一的，类似于Symbol类型。

import 'reflect-metadata';
import { Container, Token } from 'typedi';

const tokenA = new Token('TOKEN');
const tokenB = new Token('TOKEN');

Container.set(tokenA, 'value-A');
Container.set(tokenB, 'value-B');

const tokenValueA = Container.get(tokenA);
// tokenValueA 是 "value-A"
const tokenValueB = Container.get(tokenB);
// tokenValueB 是 "value-B"

console.log(tokenValueA === tokenValueB);
// false

Token和字符串的对比

Token和字符串都可以用来标识一个Service实例，但是推荐使用Token，因为Token是类型安全的，而同一个string的名称真的就是唯一表示Service实例。

继承性

当基类和继承类都被标记为@Service()后，属性是支持继承性的。

在创建时，继承有装饰属性的类将收到这些属性上的初始化实例。

即当子类继承了父类的依赖注入的属性时，子类中的此属性也是可以直接使用的

import 'reflect-metadata';
import { Container, Token, Inject, Service } from 'typedi';

@Service()
class InjectedClass {
  name: string = 'InjectedClass';
}

@Service()
class BaseClass {
  name: string = 'BaseClass';

  @Inject()
  injectedClass: InjectedClass;
}

@Service()
class ExtendedClass extends BaseClass {
  name: string = 'ExtendedClass';
}

const instance = Container.get(ExtendedClass);

console.log(instance.injectedClass.name);
// 输出"InjectedClass"
console.log(instance.name);
// 输出 "ExtendedClass"

参考文章

https://static.kancloud.cn/czkme/dependency-inject/2511047

源码解读

原理说明

依赖注入的核心就是容器Container
Container.set(id, value)向容器中push一个实例
Container.get(id)从容器中get一个实例

Container容器对象中的核心概念：

  • ServiceMetadata,被容器接管的每个类都叫做一个Service，ServiceMetadata就是这个类对应的信息，每个类都有一个与之对应的ServiceMetadata实例
  • metadataMap,是一个map，保存的是某一个类的配置信息
  • handlers，是一个数组，所有@Inject()的属性都是一个handler，表示待注入的属性。此容器接管的所有类中的@Inject()标注的属性都在这个数组中

按照装饰器的执行顺序，一个类中的@Inject()先执行，然后是@Service()
@Inject可以用在属性和构造参数上。

看一下ServiceMetadata的结构

export interface ServiceMetadata<Type = unknown> {
  // service的唯一标识，
  id: string | Token | Constructable | AbstractConstructor | CallableFunction; 

  /**
   * 实例的作用域
   *  singleton 单例模式， 单例的实例会被放在default容器中
   *  container 从指定容器中创建实例，从此容器中也是单例的
   *  transient 瞬时的，每次从容器请求都会创建一个新的实例
   */
  scope: 'singleton' | 'container' | 'transient'; 

  // Service的类型，就是构造函数类型
  type: Constructable<Type> | null; 

  // 创建此类型实例的工厂，
  factory: [Constructable<unknown>, string] | CallableFunction | undefined; // 此实例的工厂方法

  // 目标类的实例
  value: unknown | Symbol;

  // 是否允许在同一个service id下注册多个实例
  multiple: boolean;

  /**
   * 是否立即实例化，当为true，容器创建完成后就会实例化此类的bean；
   * 当为false，只有当用时才会实例化
   */
  eager: boolean;

  /**
   * 引用此类的 metadata 的容器
   */
  referencedBy: Map<ContainerIdentifier, ContainerInstance>;
}

@Inject的原理

首先要清楚@Inject()的用法：

  • @Inject()中可以给Service的id，用来指定注入特定的实例
  • @Inject()中的参数还可以是一个函数，用来强制修改要注入的类型

一个Handler的结构

export interface Handler<T = unknown> {
  // 属性所在的类(构造函数)，即此属性需要注入的目标类
  object: Constructable<T>; 

  // 成员名称
  propertyName?: string;

  // 成员在构造函数参数中的索引，
  // 若@Inject()标注的是类中实例属性，则此属性为undefined
  index?: number;

  // 一个方法，在@Inject()中已经实现了，从指定的容器中获取此属性的实例
  value: (container: ContainerInstance) => any;
}

当在一个属性上标注了@Inject()后，实际上就发生了一件事情，向容器中注入一个此属性的handler

20240117154925

@Service发生了什么

@Service()发生了两件事：

  1. 初始化此class的ServiceMetadata
  2. 向Container.metadataMap()中push这个ServiceMetadata
    看图
    20240117155904

Container.get(id)

Container.get(id)是从容器中获取实例，在这个步骤中完成了类的实例化。
这个框架的核心就是get()方法
20240117163134

总结

基于Container的依赖注入，无非就是两件事，向Container中push实例和从Container中get实例。
typedi采用了惰性加载的方式，初始只保存类的metadata(类的配置信息)，
Container.get()时才会对类进行实例化，而在类实例化的过程中，如果检测都有需要注入的属性，则会继续调用Container.get()来实例化属性，经典的递归形式；后续如果如果要获取某个实例，判断已经实例化了直接返回，就不需要继续实例化了

typedi这个框架设计非常小巧强悍，代码简洁，支持自定义拓展。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/333756.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

大数据工作岗位需求分析

大数据工作岗位需求分析

前言&#xff1a;随着大数据需求的增多&#xff0c;许多中小公司和团队也新增或扩展了大数据工作岗位&#xff1b;但是却对大数据要做什么和能做什么&#xff0c;没有深入的认识&#xff1b;往往是招了大数据岗位&#xff0c;搭建起基础能力后&#xff0c;就一直处于重复开发和…
阅读更多...
分类预测 | Matlab实现ISSA-SVM基于多策略混合改进的麻雀搜索算法优化支持向量机的数据分类预测

分类预测 | Matlab实现ISSA-SVM基于多策略混合改进的麻雀搜索算法优化支持向量机的数据分类预测

分类预测 | Matlab实现ISSA-SVM基于多策略混合改进的麻雀搜索算法优化支持向量机的数据分类预测 目录 分类预测 | Matlab实现ISSA-SVM基于多策略混合改进的麻雀搜索算法优化支持向量机的数据分类预测分类效果基本描述程序设计参考资料 分类效果 基本描述 基于多策略混合改进的麻…
阅读更多...
录课视频太大怎么办？3种方法一键瘦身~

录课视频太大怎么办？3种方法一键瘦身~

录制视频是现代人常用的一种记录生活的方式&#xff0c;但是视频文件大小往往会很大&#xff0c;不利于存储和分享。为了解决这个问题&#xff0c;我们需要使用视频压缩软件来压缩视频文件大小&#xff0c;以便更方便地存储和分享。 方法一&#xff1a;嗨格式压缩大师 嗨格式压…
阅读更多...
Lucas求大组合数C（n,m）%p

Lucas求大组合数C（n,m）%p

将大组合数C&#xff08;n,m&#xff09;%p分解为小组合数C&#xff08;n,m&#xff09;%p乘积的模&#xff0c;n<10^18,m<10^18。 其中求解小组合数可以根据定义式计算&#xff08;质因子分解&#xff09;&#xff0c;也可以通过定义式的变形计算&#xff08;逆元&…
阅读更多...
如何使用Portainer部署web站点并实现无公网ip远程访问

如何使用Portainer部署web站点并实现无公网ip远程访问

文章目录 前言1. 安装Portainer1.1 访问Portainer Web界面 2. 使用Portainer创建Nginx容器3. 将Web静态站点实现公网访问4. 配置Web站点公网访问地址4.1公网访问Web站点 5. 固定Web静态站点公网地址6. 固定公网地址访问Web静态站点 前言 Portainer是一个开源的Docker轻量级可视…
阅读更多...
【根据loss曲线看模型微调效果】如何使用loss曲线诊断机器学习模型性能

【根据loss曲线看模型微调效果】如何使用loss曲线诊断机器学习模型性能

一、Loss曲线 在模型的预训练或者微调过程中&#xff0c;我们一般通过观察loss曲线来得出模型对于数据集的学习效果等信息。那么我们如何根据loss曲线得到一些信息呢&#xff1f; 通常数据集会被划分成三部分&#xff0c;训练集&#xff08;training dataset&#xff09;、验证…
阅读更多...
Flask 项目怎么配置并创建第一个小项目？附上完成第一个小案例截图

Flask 项目怎么配置并创建第一个小项目？附上完成第一个小案例截图

目录 1. 为什么要学习 flask&#xff1f; 2. flask 是什么&#xff1f; 3. flask 如何使用&#xff1f; 要安装 Flask&#xff0c;可以按照以下步骤进行&#xff1a; 4. 使用流程 4.1. 新建项目 4.1.1. 打开 pycharm&#xff0c;新建项目 4.1.2. 设置目录&#xff0c;并…
阅读更多...
解决系统开发中的跨域问题：CORS、JSONP、Nginx

解决系统开发中的跨域问题：CORS、JSONP、Nginx

文章目录 一、概述1.问题场景2.浏览器的同源策略3.解决思路 二、一点准备工作1.创建前端工程12.创建后端工程3.创建前端工程24.跨域问题 三、方法1&#xff1a;使用CORS四、方法2&#xff1a;JSONP五、方法3&#xff1a;Nginx1.安装和启动&#xff08;windows&#xff09;2.使用…
阅读更多...
匿名/箭头函数，立即执行函数IIFE；函数声明式和函数表达式

匿名/箭头函数，立即执行函数IIFE；函数声明式和函数表达式

目录 匿名/箭头函数&#xff1a;简洁 继承上一层作用域链的this 不绑定arguments,用rest参数 rest 参数&#xff1a;...真正的数组 因为没有function声明&#xff0c;所以没有原型prototype&#xff0c;所以不能作为构造函数 当函数体只有一句时&#xff0c;可省 return ,…
阅读更多...
【状态压缩】【动态规划】【C++算法】691贴纸拼词

【状态压缩】【动态规划】【C++算法】691贴纸拼词

作者推荐 【动态规划】【数学】【C算法】18赛车 本文涉及知识点 状态压缩 动态规划 LeetCode:691 贴纸拼词 我们有 n 种不同的贴纸。每个贴纸上都有一个小写的英文单词。 您想要拼写出给定的字符串 target &#xff0c;方法是从收集的贴纸中切割单个字母并重新排列它们。如…
阅读更多...
肇庆韶关异形件上门扫描服务龙岗3D抄数画图福田电脑抄数STL转STP

肇庆韶关异形件上门扫描服务龙岗3D抄数画图福田电脑抄数STL转STP

在当今的数字化时代&#xff0c;对于需要精确测量和设计的客户来说&#xff0c;CASAIM中科广电异形件上门扫描及抄数设计是一项非常重要的服务。这项服务不仅可以为客户提供高质量的测量和设计&#xff0c;还可以帮助他们减少时间和成本。 异形件是一种特殊的零件&#xff0c;…
阅读更多...
力扣 | 11. 盛最多水的容器

力扣 | 11. 盛最多水的容器

双指针解法–对撞指针 暴力解法public int maxArea1(int[] height) {int n height.length;int ans 0;for (int i 0; i < n; i) {for (int j i 1; j < n; j) {int area Math.min(height[i], height[j]) * (j - i);ans Math.max(ans, area);}}return ans;}双指针解法…
阅读更多...
java毕业设计 | springboot二手交易平台 闲置物品商城(附源码)

java毕业设计 | springboot二手交易平台 闲置物品商城(附源码)

1&#xff0c;项目背景 1.1 当前的问题和困惑 随着社会发展&#xff0c;网上购物已经成为我们日常生活的一部分。但是&#xff0c;至今为止大部分电商平台都是从人们日常生活出发&#xff0c;出售都是一些日常用品比如&#xff1a;食物、服装等等&#xff0c;并未发现一个专注…
阅读更多...
计算机网络-ACL实验

计算机网络-ACL实验

一、NAT实验配置 NAT实验配置 通过基本ACL匹配VLAN 10网段&#xff0c;然后在出口设备NAT转换只要匹配到VLAN10地址则进行转换。 核心交换机 # 配置VLAN和默认路由&#xff0c;配置Trunk和Access接口 interface Vlanif10ip address 192.168.10.254 255.255.255.0 # interface V…
阅读更多...
源聚达科技：个人怎么开抖音店铺

源聚达科技：个人怎么开抖音店铺

随着互联网的发展&#xff0c;电商平台已经成为了人们购物的主要渠道之一。而抖音作为目前最受欢迎的短视频平台之一&#xff0c;也逐渐成为了一个新兴的电商市场。那么&#xff0c;个人怎么开抖音店铺呢?下面就来详细介绍一下。 第一步&#xff1a;注册抖音账号 首先&#xf…
阅读更多...
深度学习进行数据增强(实战篇)

深度学习进行数据增强(实战篇)

本文章是我在进行深度学习时做的数据增强,接着我们上期的划分测试集和训练集来做. 文章目录 前言 数据增强有什么好处&#xff1f; 一、构造数据增强函数 二、数据增强 总结 前言 很多人在深度学习的时候在对数据的处理时一般采用先数据增强在进行对训练集和测试集的划分,…
阅读更多...
ORM Bee设计思想与功能思维导图

ORM Bee设计思想与功能思维导图

ORM Bee设计思想与功能思维导图 Bee&#xff0c;互联网新时代的Java ORM框架&#xff0c;支持Sharding&#xff1b;JDBC&#xff0c;Android&#xff0c;HarmonyOS&#xff1b;支持多种关系型数据库&#xff0c;还支持NoSQL的Cassandra&#xff0c;Mongodb等&#xff1b;更快、…
阅读更多...
NVIDIA 大模型 RAG 分享笔记

NVIDIA 大模型 RAG 分享笔记

文章目录 大语言模型在垂直领域落地的三个挑战&#xff1a;什么是 RAG以及为什么能解决大预言模型所带来的的这三个问题RAG 不是一项技术而是整体的 Pipeline非参数化 &#xff1a;数据库部分加载到数据库中检索阶段 提升检索效率的技术检索前&#xff1a;对query做处理use que…
阅读更多...
redis缓存和本地缓存的应用设计

redis缓存和本地缓存的应用设计

数据查询顺序 一级缓存&#xff1a;本地缓存 -》二级缓存&#xff1a;redis缓存 -》数据库 本地缓存和分布式缓存 本地缓存&#xff1a;基于jvm, 意思是程序放在哪&#xff0c;数据就存储在哪&#xff0c;不需要网络请求&#xff0c;特别快&#xff0c;但是需要占用jvm的内存…
阅读更多...
Redis--Zset使用场景举例(滑动窗口实现限流)

Redis--Zset使用场景举例(滑动窗口实现限流)

文章目录 前言什么是滑动窗口zset实现滑动窗口小结附录 前言 在Redis–Zset的语法和使用场景举例&#xff08;朋友圈点赞&#xff0c;排行榜&#xff09;一文中&#xff0c;提及了redis数据结构zset的指令语法和一些使用场景&#xff0c;今天我们使用zset来实现滑动窗口限流&a…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站