// 安全配置类
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Autowired
�123</s>

// 安全配置类
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Autowired
    private AuthenticationEntryPoint authenticationEntryPoint;
 
    @Autowired
    private AccessDeniedHandler accessDeniedHandler;
 
    @Autowired
    private UserDetailsService userDetailsService;
 
    @Autowired
    private TokenAuthenticationFilter tokenAuthenticationFilter;
 
    @Autowired
    public void configureAuthentication(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
        authenticationManagerBuilder
                .userDetailsService(userDetailsService)
                .passwordEncoder(passwordEncoder());
    }
 
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
 
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
 
    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity
                // 关闭CSRF
                .csrf().disable()
                // 设置会话管理策略
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                // 配置异常处理
                .exceptionHandling().authenticationEntryPoint(authenticationEntryPoint).accessDeniedHandler(accessDeniedHandler)
                .and()
                // 配置URL的访问权限
                .authorizeRequests()
                .antMatchers(HttpMethod.POST, "/login").permitAll()
                .anyRequest().authenticated();
 
        httpSecurity
                // 添加Token认证过滤器
                .addFilterBefore(tokenAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

// Token认证过滤器
public class TokenAuthenticationFilter extends OncePerRequestFilter {
 
    @Autowired
    private TokenManager tokenManager;
 
    @Autowired
    private AuthenticationManager authenticationManager;
 
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse

在CentOS上安装Redis，可以通过以下步骤进行：

1. 使用yum安装Redis：

sudo yum install epel-release -y
sudo yum update -y
sudo yum install redis -y

2. 启动Redis服务：

sudo systemctl start redis

3. 设置Redis在系统启动时自动启动：

sudo systemctl enable redis

4. 检查Redis服务状态：

sudo systemctl status redis

5. 使用Redis-cli连接到Redis服务器：

redis-cli

6. 在Redis-cli中执行命令，例如：

127.0.0.1:6379> SET key "value"
OK
127.0.0.1:6379> GET key
"value"

7. 停止Redis服务：

sudo systemctl stop redis

以上步骤涵盖了Redis的安装、启动、使用和停止。

Redis的双向链表不是Redis的一个组成部分，而是在Redis的源码中，为了实现某些功能如过期数据的快速删除，而自行设计的一种数据结构。

Redis中的双向链表结构体定义如下：

typedef struct listNode {
    struct listNode *prev;
    struct listNode *next;
    void *value;
} listNode;

其中，prev指针指向前一个节点，next指针指向后一个节点，value是节点的值。

Redis的双向链表结构体定义如下：

typedef struct list {
    listNode *head;
    listNode *tail;
    void (*free)(void *ptr);
    unsigned long len;
} list;

其中，head指针指向链表的表头节点，tail指针指向链表的表尾节点，free是链表节点值的释放函数，len是链表的长度。

在Redis中，双向链表主要用于管理客户端连接，发布/订阅，键空间等。

如果你在面试中被问到不了解Redis的双向链表，但你仍然说自己精通Redis，那么可能面试官想要听的是你对Redis数据结构的理解和应用场景，而不仅仅是数据结构本身。

如果你能从应用场景出发，比如你可以说：“Redis的双向链表在实现复杂的数据结构如快速列表、发布/订阅时有广泛的应用。通过双向链表，Redis可以快速地在某些操作如列表的左侧或右侧添加或删除元素。”

这样，你就能展示你对Redis的熟悉程度，同时也表达了你对Redis内部实现的理解。

Redis是一种开源的内存中数据结构存储系统，可以用作数据库、缓存和消息中间件。以下是一些关于Redis的常见问题和解答：

1. Redis的数据结构有哪些？

Redis支持的数据结构包括字符串(String), 哈希表(Hash), 列表(List), 集合(Set), 有序集合(Sorted Set), 位图(Bitmap), HyperLogLog和流(Stream)。

2. Redis分布式锁的实现方式？

Redis分布式锁通常使用SETNX命令（或在Redis 2.6.12以上版本中使用SET key value EX max-lock-time NX），这是因为SETNX只在键不存在时才设置值，即获得锁。解锁时使用DEL命令。

示例代码：

import redis
 
def acquire_lock(conn, lock_name):
    identifier = str(uuid.uuid4())
    end = time.time() + 10 # 10秒超时
    while time.time() < end:
        if conn.setnx(lock_name, identifier):
            return identifier
        time.sleep(0.001)
 
def release_lock(conn, lock_name, identifier):
    pipe = conn.pipeline(True)
    while True:
        try:
            pipe.watch(lock_name)
            if pipe.get(lock_name) == identifier:
                pipe.multi()
                pipe.delete(lock_name)
                pipe.execute()
                return True
            pipe.unwatch()
            break
        except redis.exceptions.WatchError:
            pass
    return False

3. Redis的持久化策略有哪些？

Redis支持两种持久化策略：RDB（默认）和AOF。

• RDB：定时将内存中的数据快照保存到磁盘的一个压缩二进制文件中。
• AOF：保存Redis服务器所执行的所有写操作命令到文本文件。

4. Redis的内存淘汰策略有哪些？

• noeviction：不进行内存淘汰。
• allkeys-lru：当内存不足以容纳更多数据时，使用最近最少使用算法进行淘汰。
• volatile-lru：只对设置了过期时间的键进行最近最少使用算法。
• allkeys-random：随机淘汰键。
• volatile-random：随机淘汰设置了过期时间的键。
• volatile-ttl：淘汰即将过期的键。

5. Redis的性能优化有哪些？

• 使用批量操作减少网络往返时间。
• 使用管道（pipeline）进行批量操作。
• 使用SCAN命令代替KEYS命令，避免大量占用主线程。
• 适当使用SORT, SORT BY, GET, DEL等命令优化集合操作。
• 使用Redis的集群功能分散负载。
• 配置合适的maxmemory和内存淘汰策略。

6. Redis的事务是什么？

Redis的事务可以一次执行多个命令，它可以保证一系列命令的原子性，要么全部执行，要么全部不执行。

7. Redis的发布/订阅机制是什么？

Redis的发布/订阅机制允许客户端订阅一个或多个频道，当发布者向频道发布消息时，订阅者会收到消息。

8. Redis的Geo是什么？

Redis 3.2版本开始支持地理位置功能，可以将用

当Spring Cache的Redis不可用时，原方法不会执行的问题通常是由于缓存的依赖失效导致的。为了解决这个问题，可以采取以下几种策略：

1. 使用@Cacheable注解时，设置unless属性，通过自定义条件判断缓存是否被使用。
2. 使用ErrorHandler来处理缓存依赖时的异常，并在异常发生时执行原方法。
3. 使用CacheManager的自定义实现，在缓存访问时捕获异常，并决定是否继续使用缓存。

以下是一个使用ErrorHandler来处理缓存依赖时的异常并执行原方法的示例：

import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.stereotype.Component;
 
@Component
public class CustomCacheErrorHandler implements CacheErrorHandler {
 
    @Override
    public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
        // 处理获取缓存时的异常
        if (e instanceof IllegalStateException) {
            // 如果是Redis不可用，执行原方法
            // 这里需要你自己实现一个逻辑来调用原方法
        }
    }
 
    @Override
    public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
        // 处理缓存放置时的异常
    }
 
    @Override
    public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
        // 处理缓存清除时的异常
    }
 
    @Override
    public void handleCacheClearError(RuntimeException e, Cache cache) {
        // 处理缓存清除全部时的异常
    }
}

在上述代码中，你需要自己实现handleCacheGetError方法里的逻辑，以便在检测到Redis不可用时执行原方法。这通常涉及到使用AOP（面向切面编程）来拦截方法的执行。

请注意，这只是一个概念性的示例，具体实现可能需要根据你的应用程序的具体需求和架构来定制。

在使用Redis时，获取权限的方式主要有以下几种：

1. 使用密码认证：在配置文件redis.conf中设置requirepass指令，客户端连接Redis服务时需要使用AUTH命令并提供正确的密码。

   配置文件示例：

   
   
   
   requirepass yourpassword

   客户端示例：

   
   
   
   import redis
   r = redis.StrictRedis(host='localhost', port=6379, db=0, password='yourpassword')

2. 使用Redis ACL (Access Control List)：从Redis 6.0开始，引入了ACL系统，允许更细粒度的权限控制。

   示例：

   
   
   
   # 创建用户并设置权限
   ACL SETUSER user1 on >mypassword ~* +@read
   # 连接Redis时使用该用户
   redis-cli -u user1 -a mypassword

3. 使用Redis Sentinel或者Redis Cluster的主从架构，通过合理的配置，可以实现读写分离，进而管理不同的权限等级。
4. 使用中间件或代理，如Twemproxy或者Redis Enterprise，它们提供了代理权限管理的功能。

5. 使用Redis的命令来查看或设置权限，例如ACL LIST、ACL WHOAMI、ACL CAT等。

   示例：

   
   
   
   # 查看当前用户权限
   ACL WHOAMI
   # 列出所有权限命令
   ACL CAT

这些方法可以根据实际需求和环境配置相结合使用，以达到权限管理的目的。

在CentOS 7上安装Redis并编写开机自启脚本的步骤如下：

1. 安装Redis

sudo yum install epel-release -y
sudo yum update -y
sudo yum install redis -y

2. 启动Redis服务并设置开机自启

sudo systemctl start redis
sudo systemctl enable redis

3. 编写Redis开机自启脚本（简化版）

   假设你已经有了一个简化版的Redis启动脚本，你可以将其放置在/etc/init.d/目录下，并确保它有执行权限。

sudo nano /etc/init.d/redis

以下是一个简化版的Redis启动脚本示例（请根据实际路径修改/usr/bin/redis-server和/etc/redis.conf到你的实际路径）：

#!/bin/sh
# chkconfig: 2345 10 90
# description: Redis is a persistent key-value database
 
REDIS_SERVER_EXEC="/usr/bin/redis-server"
REDIS_CONF_FILE="/etc/redis.conf"
 
start() {
    echo "Starting Redis server..."
    $REDIS_SERVER_EXEC $REDIS_CONF_FILE
}
 
stop() {
    echo "Stopping Redis server..."
    pkill redis-server
}
 
case "$1" in
    start)
        start
        ;;
    stop)
        stop
        ;;
    restart)
        stop
        start
        ;;
    *)
        echo "Usage: $0 {start|stop|restart}"
        exit 1
esac
 
exit 0

确保脚本可执行：

sudo chmod +x /etc/init.d/redis

4. 将Redis启动脚本添加到chkconfig管理中

sudo chkconfig --add redis

5. 验证Redis是否已经设置为开机自启

sudo systemctl is-enabled redis

以上步骤完成后，Redis将被配置为开机自启。

# 安装 Redis for Windows
1. 下载最新的 Redis for Windows 压缩包:
   https://github.com/MicrosoftArchive/redis/releases
 
2. 解压缩到你选择的目录，例如 C:\redis。
 
3. 打开命令提示符或 PowerShell 并导航到 Redis 目录。
 
4. 运行 `redis-server.exe` 来启动 Redis 服务器。

# 使用 Redis for Windows
1. 安装 Redis 客户端库，例如使用 Python:
   ```shell
   pip install redis

2. 使用 Python 连接并操作 Redis 服务器:

   
   
   
   import redis
    
   # 创建 Redis 连接对象
   r = redis.Redis(host='localhost', port=6379, db=0)
    
   # 设置键值对
   r.set('key', 'value')
    
   # 获取键对应的值
   value = r.get('key')
   print(value)  # 输出 b'value'

注意事项

• 如果你想让 Redis 作为 Windows 服务运行，可以使用 redis-server --service-install redis.windows.conf 命令安装服务。
• 使用 redis-cli.exe 可以启动 Redis 客户端。

以上是一个基本的安装和使用 Redis for Windows 的指南。这里提供了在 Windows 系统上安装 Redis 的基本步骤，并展示了如何使用 Python 客户端与 Redis 服务器交互。 

# 使用Redis 6.x的基础镜像
FROM redis:6.2-alpine
 
# 设置环境变量
ENV REDIS_REPLICATION_MODE "master" 
ENV REDIS_PASSWORD "yourpassword"
 
# 复制Redis配置文件模板
COPY redis-node.tmpl /usr/local/bin/redis-node.tmpl
 
# 复制启动脚本
COPY entrypoint.sh /usr/local/bin/entrypoint.sh
 
# 赋予脚本执行权限
RUN chmod +x /usr/local/bin/entrypoint.sh /usr/local/bin/redis-node.tmpl
 
# 设置容器启动时执行的命令
CMD ["/usr/local/bin/entrypoint.sh"]

这个Dockerfile演示了如何为Redis Cluster创建一个Docker镜像。它从官方的Redis镜像开始，并添加了一个启动脚本和一个Redis配置文件模板。这个脚本和模板将被用来配置和启动每个Redis节点。环境变量被设置为在启动时调整Redis配置。最后，CMD指令被设置为在容器启动时执行这个启动脚本。

在Java 17中，实现Redis 7缓存双写一致性的核心是确保数据库和缓存更新操作的原子性。以下是一个简化的Java代码示例，展示了如何使用Jedis客户端来实现缓存的更新：

import redis.clients.jedis.Jedis;
 
public class CacheConsistency {
 
    private Jedis jedis;
    private String cacheKey;
 
    public CacheConsistency(String host, int port, String cacheKey) {
        this.jedis = new Jedis(host, port);
        this.cacheKey = cacheKey;
    }
 
    public void updateDatabaseAndCache(String newValue) {
        // 假设updateDatabase是一个更新数据库的方法
        boolean dbUpdateSuccess = updateDatabase(newValue);
 
        if (dbUpdateSuccess) {
            // 数据库更新成功，则更新缓存
            jedis.set(cacheKey, newValue);
        } else {
            // 数据库更新失败，应该回滚缓存的更新
            jedis.del(cacheKey);
        }
    }
 
    private boolean updateDatabase(String newValue) {
        // 实现数据库更新逻辑
        // 这里仅为示例，应该使用实际的数据库更新代码替换以下行
        // 返回操作是否成功
        return true; // 假设操作总是成功
    }
 
    public static void main(String[] args) {
        CacheConsistency cacheConsistency = new CacheConsistency("localhost", 6379, "myKey");
        cacheConsistency.updateDatabaseAndCache("newValue");
    }
}

在这个例子中，updateDatabaseAndCache 方法首先尝试更新数据库。如果数据库更新成功，它会更新缓存。如果数据库更新失败，它会删除缓存的条目，确保数据库和缓存的数据不会出现不一致。这种方法依赖于数据库的事务性来保证操作的原子性。如果数据库更新失败，缓存的更新也会被回滚，从而保持数据的一致性。