Redis的内存策略主要是指当Redis的内存达到某一个阈值后，它会使用哪些策略来决定如何回收内存中的数据。主要的策略包括：

1. 全局键替换：Redis会根据一定的策略来替换内存中的某些键，以释放内存。
2. volatile-lru：从设置了过期时间的键中选择最近最少使用的键进行淘汰。
3. allkeys-lru：从所有键中选择最近最少使用的键进行淘汰。
4. volatile-random：从设置了过期时间的键中随机选择一些键进行淘汰。
5. allkeys-random：从所有键中随机选择一些键进行淘汰。
6. volatile-ttl：从设置了过期时间的键中选择剩余时间（TTL）最短的键进行淘汰。
7. noeviction：不进行任何淘汰，当内存不足时，新写入命令会报错。

在配置文件中设置内存策略：

maxmemory-policy allkeys-lru

在运行时动态设置内存策略：

CONFIG SET maxmemory-policy allkeys-lru

在实际应用中，根据业务需求和数据的重要程度，可以选择合适的内存策略以达到最优的内存使用效率。

import redis
 
# 连接到Redis服务器
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 生产者：往List中插入数据
def produce(list_name, data):
    r.lpush(list_name, data)
 
# 消费者：从List中取出数据
def consume(list_name):
    while True:
        # 使用BLPOP阻塞地从List取出数据，超时时间为5秒
        data = r.blpop(list_name, timeout=5)
        if data:
            # 处理数据
            print(f"消费者取出数据: {data[1].decode()}")
        else:
            # 如果在指定时间内没有数据，循环结束
            print("超时，循环结束")
            break
 
# 测试代码
produce('mylist', 'data1')
produce('mylist', 'data2')
consume('mylist')

这段代码展示了如何使用Redis的List数据结构来实现一个简单的消息队列。生产者使用lpush将数据推入List，消费者使用blpop阻塞地从List取出数据。这里的List用作FIFO（First-In, First-Out）队列，保证了数据处理的顺序。

uses
  Redis.Client, Redis.NetLib.INDY, Redis.Values;
 
var
  RedisClient: IRedisClient;
  ByteValue: Byte;
  StringValue: string;
  SetValue: IRedisSet;
  ListValue: IRedisList;
  SortedSetValue: IRedisSortedSet;
  HashValue: IRedisHash;
 
begin
  // 创建一个使用INDY库的Redis客户端实例
  RedisClient := TRedisClientIndy.Create('localhost', 6379);
 
  // 连接到Redis服务器
  if RedisClient.Connect then
  try
    // 设置和获取字符串值
    RedisClient.Set('mykey', 'Hello, Redis!');
    StringValue := RedisClient.Get('mykey');
 
    // 设置和获取字节值
    RedisClient.Set('mybytekey', 123);
    ByteValue := RedisClient.Get('mybytekey');
 
    // 操作集合、列表、有序集合和哈希
    RedisClient.SAdd('myset', 'item1');
    RedisClient.RPush('mylist', 'item2');
    RedisClient.ZAdd('mysortedset', 1, 'item3');
    RedisClient.HSet('myhash', 'field1', 'value1');
 
    // 获取集合、列表、有序集合和哈希的值
    SetValue := RedisClient.SMembers('myset');
    ListValue := RedisClient.LRange('mylist', 0, -1);
    SortedSetValue := RedisClient.ZRange('mysortedset', 0, -1);
    HashValue := RedisClient.HGetAll('myhash');
 
  finally
    RedisClient.Disconnect;
  end;
end;

这段代码展示了如何使用Delphi创建并使用一个基于INDY库的Redis客户端实例。它连接到Redis服务器，设置并获取不同类型的值，包括字符串、字节、集合、列表、有序集合和哈希。最后，代码确保在完成操作后断开连接。

由于银河麒麟操作系统（Kylin）的确切版本可能不存在“V10 SP1.1”这个具体的版本号，我将以“Kylin V10”为例提供一个通用的离线安装Nginx和Redis的方法。

1. 安装Nginx:

首先，你需要获得Nginx的源码包或者预编译的二进制包。然后，可以通过以下步骤进行安装：

• 将Nginx源码包或者二进制包拷贝至银河麒麟系统中。
• 解压缩（如果是源码包）并进入解压后的目录。
• 配置Nginx（通常使用./configure命令）。
• 编译和安装Nginx（使用make和make install命令）。

示例代码：

# 假设你已经将nginx-1.21.5.tar.gz拷贝到/tmp目录下
cd /tmp
tar zxvf nginx-1.21.5.tar.gz
cd nginx-1.21.5
./configure
make
make install

2. 安装Redis:

对于Redis，你可以选择从源码编译或者使用预编译的二进制包。以下是使用预编译二进制包的方法：

• 将Redis的二进制包拷贝至银河麒麟系统中。
• 解压缩（如果是.tar.gz或.tgz）并进行安装。

示例代码：

# 假设你已经将redis-5.0.5.tar.gz拷贝到/tmp目录下
cd /tmp
tar zxvf redis-5.0.5.tar.gz
cd redis-5.0.5
make
make install

完成以上步骤后，你应该能在银河麒麟系统中启动Nginx和Redis服务。

注意：确保你的银河麒麟系统中已经安装了Nginx和Redis所需的依赖库，如果有缺失，你可能需要通过系统的包管理器（如yum）来安装它们。另外，确保你的银河麒麟系统版本与Nginx和Redis的预编译版本兼容。如果是自行编译，请确保编译环境配置正确。

Redis消息订阅和发布

Redis提供了发布订阅功能，可以通过PUBLISH命令发布消息，通过SUBSCRIBE命令订阅频道。

import redis
 
r = redis.Redis()
 
# 订阅消息
pubsub = r.pubsub()
pubsub.subscribe('channel-1')
 
# 发布消息
r.publish('channel-1', 'Hello World!')
 
# 接收订阅的消息
for message in pubsub.listen():
    print(message)

Redis事务概念和操作

Redis中的事务是一组命令的集合，它们将被序列化并按顺序执行。事务在执行EXEC命令时开始，而之前的所有命令都会被暂存。

import redis
 
r = redis.Redis()
 
# 开始事务
r.multi()
 
# 事务中的命令
r.set('key1', 'value1')
r.set('key2', 'value2')
 
# 执行事务
r.exec()

以上代码演示了如何在Redis中开始一个事务，将多个命令组合在一起，并且在最后一起执行。这确保了命令的原子性，要么全部成功，要么全部失败。

Redis 提供了两种持久化机制 RDB（Redis DataBase）和 AOF（Append Only File）。

RDB：

RDB 是 Redis 默认的持久化方式。在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是 Snapshot 快照，保存的文件后缀是 .rdb。

# 在 redis.conf 配置文件中设置
save 900 1      # 900 秒内至少 1 个键被修改则触发保存
save 300 10     # 300 秒内至少 10 个键被修改则触发保存
save 60 10000   # 60 秒内至少 10000 个键被修改则触发保存

AOF：

AOF 持久化是通过保存 Redis 服务器所执行的写命令来记录数据库状态的。在发起写命令时，Redis 会将命令追加到文件末尾。

# 在 redis.conf 配置文件中设置
appendonly yes       # 开启 AOF 持久化存储
appendfilename "appendonly.aof"  # AOF 文件名
# appendfsync 选项
#   always: 每个写命令都同步，最慢但最安全
#   everysec: 每秒同步一次，折衷方案
#   no: 由操作系统决定何时同步
appendfsync everysec

选择合适的持久化方式：

• 如果对数据的一致性和完整性要求较高，且对于数据的恢复速度要求不高，可以选择 RDB 方式。
• 如果对数据的完整性和恢复时间要求较高，且可以接受较长的停机时间，可以选择 AOF 方式。
• 可以同时开启两种持久化方式，Redis 会优先使用 AOF 来恢复数据。

from redis_sampler import RedisSampler
 
# 创建RedisSampler实例，连接到本地Redis服务
redis_sampler = RedisSampler(host='localhost', port=6379, db=0)
 
# 获取所有键的数量
key_count = redis_sampler.get_key_count()
print(f"Number of keys: {key_count}")
 
# 获取所有键的样本
key_sample = redis_sampler.get_key_sample()
print("Sample of keys:")
for key in key_sample:
    print(key)
 
# 获取特定模式的键的数量
pattern_key_count = redis_sampler.get_key_count(pattern='user:*')
print(f"Number of keys matching pattern 'user:*': {pattern_key_count}")
 
# 获取内存使用情况的统计信息
memory_stats = redis_sampler.get_memory_stats()
print("Memory stats:")
for key, value in memory_stats.items():
    print(f"{key}: {value}")
 
# 获取数据库大小的统计信息
db_size = redis_sampler.get_db_size()
print(f"Database size: {db_size}")
 
# 获取客户端连接信息的统计信息
clients_info = redis_sampler.get_clients_info()
print("Clients info:")
for key, value in clients_info.items():
    print(f"{key}: {value}")

这段代码展示了如何使用RedisSampler类来获取Redis服务器的关键指标，包括键的数量、键的样本、匹配特定模式的键的数量、内存统计信息、数据库大小以及客户端连接信息。这是一个简单的实用指南，可以帮助开发者快速了解如何使用Redis-Sampler这个开源项目。

以下是一个简化的Spring Boot后端和Vue 3前端实现登录和注销的示例。

后端（Spring Boot）:

1. 引入依赖（pom.xml）:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

2. 配置Redis和JWT（application.properties）:

spring.redis.host=localhost
spring.redis.port=6379
 
jwt.secret=your_secret_key
jwt.expiration=3600000

3. 创建JWT工具类:

@Component
public class JwtTokenProvider {
    @Value("${jwt.secret}")
    private String secret;
 
    @Value("${jwt.expiration}")
    private long expiration;
 
    public String generateToken(Authentication authentication) {
        ...
    }
 
    public boolean validateToken(String token) {
        ...
    }
}

4. 创建拦截器:

@Component
public class JwtInterceptor implements HandlerInterceptor {
    @Autowired
    private JwtTokenProvider tokenProvider;
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        ...
    }
}

5. 配置拦截器:

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private JwtInterceptor jwtInterceptor;
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor).excludePathPatterns("/login");
    }
}

前端（Vue 3）:

1. 安装axios和vuex:

npm install axios vuex

2. 创建Vuex store:

// store.js
import { createStore } from 'vuex'
 
export default createStore({
  state: {
    token: null
  },
  mutations: {
    setToken(state, token) {
      state.token = token
    }
  },
  actions: {
    login({ commit }, userData) {
      ...
    },
    logout({ commit }) {
      ...
    }
  }
})

3. 创建axios实例并配置拦截器:

// http-common.js
import axios from 'axios'
 
const http = axios.create({
  baseURL: 'http://localhost:8080/api',
  timeout: 10000,
  headers: {'Content-Type': 'application/json

在Spring Boot中，使用RedisTemplate或StringRedisTemplate的keys方法来获取所有的key，如果数据集很大，这将是一个耗时的操作，因为它会扫描整个key空间。

如果你想要更高效地获取所有的key，你可以使用scan方法，这是一个基于游标的迭代器，可以分批次逐步遍历key空间。

scan方法返回一个Cursor对象，你可以遍历这个对象来获取所有的key。

以下是使用scan方法的示例代码：

@Autowired
private StringRedisTemplate redisTemplate;
 
public void printAllKeys() {
    Cursor<byte[]> cursor = redisTemplate.getConnectionFactory()
                                .getConnection()
                                .scan(ScanOptions.scanOptions().count(1000).match("*").build());
    try {
        while (cursor.hasNext()) {
            byte[] key = cursor.next();
            System.out.println(new String(key));
        }
    } finally {
        cursor.close(); // 记得关闭游标
    }
}

在这个例子中，ScanOptions.scanOptions().count(1000).match("*").build()定义了scan的参数，count(1000)表示每次扫描的数量上限是1000个，match("*")表示匹配所有的key。

底层做了什么：scan命令会从指定的游标位置开始遍历key空间，每次返回一定数量的key，并更新游标位置，直至遍历完成。这样可以避免一次性加载所有的key，从而减少了内存和CPU的使用。

在Mac上快速搭建Redis服务，可以使用Homebrew进行安装。以下是安装和启动Redis服务的步骤：

1. 打开终端。

2. 如果尚未安装Homebrew，请安装Homebrew。

   
   
   
   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

3. 使用Homebrew安装Redis。

   
   
   
   brew install redis

4. 启动Redis服务。

   
   
   
   brew services start redis

5. （可选）检查Redis是否正在运行。

   
   
   
   redis-cli ping

   如果Redis正在运行，你将收到一个响应：PONG。

以上步骤将在Mac上安装Redis，并将其作为服务启动，使得Redis随系统启动而自动启动。