2024-09-03

Spring Boot整合Redis可以通过Spring Data Redis或Jedis两种方式实现。

  1. 使用Spring Data Redis

首先,添加依赖到你的pom.xml




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

然后,在application.propertiesapplication.yml中配置Redis连接:




# application.properties
spring.redis.host=localhost
spring.redis.port=6379

接下来,你可以使用RedisTemplateStringRedisTemplate来操作Redis:




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
 
@RestController
public class RedisController {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    @GetMapping("/set")
    public String setKey(@RequestParam String key, @RequestParam Object value) {
        redisTemplate.opsForValue().set(key, value);
        return "success";
    }
 
    @GetMapping("/get")
    public Object getKey(@RequestParam String key) {
        return redisTemplate.opsForValue().get(key);
    }
}
  1. 使用Jedis

如果你更喜欢Jedis的API,可以这样做:

添加依赖:




<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

配置Redis:




# application.properties
spring.redis.host=localhost
spring.redis.port=6379

使用Jedis操作Redis:




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.Jedis;
 
@RestController
public class RedisController {
 
    @Autowired
    private Jedis jedis;
 
    @GetMapping("/set")
    public String setKey(@RequestParam String key, @RequestParam String value) {
        jedis.set(key, value);
        return "success";
    }
 
    @GetMapping("/get")
    public String getKey(@RequestParam String key) {
        return jedis.get(key);
    }
}

注意:在实际生产环境中,你可能需要配置Redis连接池、密码、使用Lettuce代替Jedis等高级配置和优化措施。

2024-09-03

Redis 是一个开源的使用 C 语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value 数据库,并提供多种语言的 API。

安装 Redis

对于 Linux 系统,可以使用包管理器进行安装,例如在 Ubuntu 上可以使用以下命令:




sudo apt update
sudo apt install redis-server

安装完成后,Redis 服务会自动启动。你可以使用以下命令检查 Redis 服务器状态:




sudo systemctl status redis-server

Redis 常用命令

  1. 启动 Redis 服务器:



redis-server
  1. 连接到 Redis 服务器:



redis-cli
  1. 设置键值对:



SET key value
  1. 获取键对应的值:



GET key
  1. 删除键:



DEL key
  1. 检查键是否存在:



EXISTS key
  1. 列出所有键:



KEYS *
  1. 设置键的过期时间:



EXPIRE key seconds
  1. 查看键的数据类型:



TYPE key
  1. 在列表中添加元素:



RPUSH key value
  1. 获取列表中的元素:



LRANGE key start stop
  1. 在集合中添加成员:



SADD key member
  1. 获取集合中的成员:



SMEMBERS key
  1. 在有序集合中添加成员:



ZADD key score member
  1. 获取有序集合中的成员:



ZRANGE key start stop [WITHSCORES]
  1. 在哈希表中添加键值对:



HSET key field value
  1. 获取哈希表中的字段值:



HGET key field
  1. 获取哈希表中的所有字段和值:



HGETALL key

以上是 Redis 的基本使用方法,更多复杂的功能和配置需参考 Redis 官方文档。

2024-09-03

在Spring中使用Redis作为缓存,可以通过Spring Cache抽象层来简化缓存的操作。以下是一个使用Spring Cache和Redis的例子:

  1. 首先,在pom.xml中添加Spring Boot的缓存和Redis依赖:



<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
</dependencies>
  1. application.propertiesapplication.yml中配置Redis连接:



# application.properties
spring.redis.host=localhost
spring.redis.port=6379
  1. 在Spring Boot应用中启用缓存:



import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@EnableCaching
public class CacheConfig {
}
  1. 使用@Cacheable, @CachePut, @CacheEvict等注解来操作缓存:



import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
 
@Service
public class SomeService {
 
    @Cacheable(value = "itemCache", key = "#id")
    public Item findItemById(Long id) {
        // 实现查找逻辑
    }
 
    @CachePut(value = "itemCache", key = "#item.id")
    public Item updateItem(Item item) {
        // 实现更新逻辑
    }
 
    @CacheEvict(value = "itemCache", key = "#id")
    public void deleteItemById(Long id) {
        // 实现删除逻辑
    }
}

在上述代码中,@Cacheable标注的方法表示其返回值会被缓存,@CachePut标注的方法表示会更新缓存,而@CacheEvict标注的方法表示会从缓存中删除数据。value属性指定缓存的名称,key属性指定缓存的键。

这样,Spring Cache抽象层会自动使用Redis作为底层存储,实现缓存的操作。

2024-09-03



import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
 
@Configuration
public class RedisConfig {
 
    @Bean
    public JedisPool redisPool() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(10);
        jedisPoolConfig.setMaxTotal(50);
        jedisPoolConfig.setMinIdle(1);
 
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, "localhost", 6379);
        return jedisPool;
    }
}

这段代码定义了一个配置类RedisConfig,其中包含一个创建JedisPool的方法redisPool。这个方法使用JedisPoolConfig来配置连接池的参数,比如最大空闲连接数、最大连接数和最小空闲连接数。然后使用这些配置以及Redis服务器的地址和端口创建一个新的JedisPool实例。这个配置类会在Spring Boot应用程序启动时自动被扫描和加载。

2024-09-03

在配置Redis时,可以通过修改Redis配置文件redis.conf来进行配置和优化。以下是一些常见的配置和优化:

  1. 设置最大内存(maxmemory):

    
    
    
    maxmemory <bytes>

    设置Redis可以使用的最大内存,超过这个值会触发内存回收策略。

  2. 设置内存淘汰策略(maxmemory-policy):

    
    
    
    maxmemory-policy allkeys-lru

    常见的策略有volatile-lruallkeys-lruvolatile-randomallkeys-randomvolatile-ttlnoeviction

  3. 设置持久化(appendonlysave):

    
    
    
    appendonly yes
    appendfsync everysec

    开启AOF持久化,每秒同步到磁盘。

    或者

    
    
    
    save 900 1
    save 300 10
    save 60 10000

    根据不同的时间周期进行RDB快照持久化。

  4. 设置连接数(maxclients):

    
    
    
    maxclients 10000

    设置Redis服务器允许的最大客户端连接数。

  5. 设置超时时间(timeout):

    
    
    
    timeout 300

    客户端空闲超过指定时间后,断开连接。

优化实例:




# 设置最大内存为2GB
maxmemory 2gb
 
# 设置内存淘汰策略为allkeys-lru
maxmemory-policy allkeys-lru
 
# 开启AOF持久化,每秒同步
appendonly yes
appendfsync everysec
 
# 设置最大客户端连接数为5000
maxclients 5000
 
# 设置客户端空闲超时时间为300秒
timeout 300

这些配置可以在生产环境中根据实际需求进行调整,以达到最佳性能和稳定性。

2024-09-03

在Redis中实现分布式锁通常有两种方式:使用SETNX命令和使用Lua脚本。以下是使用Lua脚本的一个示例:




import redis.clients.jedis.Jedis;
 
public class RedisDistributedLock {
    private Jedis jedis;
    private String lockKey; // 锁的键值
    private int expireTime; // 锁的超时时间
 
    public RedisDistributedLock(Jedis jedis, String lockKey, int expireTime) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.expireTime = expireTime;
    }
 
    public boolean lock() {
        long end = System.currentTimeMillis() + expireTime;
        String identifier = UUID.randomUUID().toString(); // 生成唯一标识
        String expireTimeStr = String.valueOf(expireTime);
 
        while (System.currentTimeMillis() < end) {
            if (jedis.setnx(lockKey, identifier) == 1) {
                jedis.expire(lockKey, expireTimeStr); // 设置锁的过期时间
                return true;
            }
            // 尝试获取锁失败,休眠一段时间后重试
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        return false;
    }
 
    public boolean unlock() {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(identifier));
        return result.equals(1L);
    }
}

这个示例中,lock 方法使用Lua脚本来安全地设置键值和过期时间,以防止因为客户端宕机或网络问题导致的锁无法释放。unlock 方法使用另一个Lua脚本来安全地检查标识符并删除键,只有当标识符匹配时才释放锁。这样可以防止由于锁被不正确的客户端释放而引起的数据不一致问题。

2024-09-03

在CentOS/Linux系统上安装和配置Redis可以通过以下步骤进行:

  1. 使用yum安装Redis:



sudo yum install epel-release -y
sudo yum update -y
sudo yum install redis -y
  1. 启动Redis服务并设置开机自启:



sudo systemctl start redis
sudo systemctl enable redis
  1. 配置Redis(可选,如果需要特定配置):

    编辑Redis配置文件 /etc/redis.conf,可以使用vinano 等编辑器进行编辑。




sudo vi /etc/redis.conf

在配置文件中,你可以根据需要修改例如绑定地址、端口、持久化选项等。

  1. 重启Redis服务以应用新配置:



sudo systemctl restart redis
  1. 测试Redis是否正常工作:



redis-cli ping

如果返回 PONG,则表示Redis已成功安装并运行。

以上步骤提供了一个基本的Redis安装和配置流程。根据具体需求,可能还需要进行安全设置(如设置密码、配置防火墙规则等)。

2024-09-03

要在Spring Boot中集成Redis,你需要做以下几步:

  1. 添加Spring Data Redis和Jedis依赖到你的pom.xml文件中。



<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
  1. application.propertiesapplication.yml中配置Redis连接。



# application.properties
spring.redis.host=localhost
spring.redis.port=6379
  1. 使用RedisTemplateStringRedisTemplate操作Redis。



import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
 
@Component
public class RedisService {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    public void setKeyValue(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
 
    public Object getValueByKey(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}
  1. 在Spring Boot应用中使用上述RedisService来操作Redis。



import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class RedisController {
 
    @Autowired
    private RedisService redisService;
 
    @GetMapping("/set")
    public String setKeyValue(String key, String value) {
        redisService.setKeyValue(key, value);
        return "Set key-value successfully";
    }
 
    @GetMapping("/get")
    public Object getValueByKey(String key) {
        return redisService.getValueByKey(key);
    }
}

确保你的Spring Boot版本和Spring Data Redis版本兼容。上述代码提供了一个简单的例子,展示了如何在Spring Boot应用中集成Redis。

2024-09-03



import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
 
@Service
public class RedisService {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    public void setKey(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
 
    public void setKey(String key, Object value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }
 
    public Object getKey(String key) {
        return redisTemplate.opsForValue().get(key);
    }
 
    public boolean deleteKey(String key) {
        return redisTemplate.delete(key);
    }
}

这段代码提供了一个简单的Redis服务类,用于设置、获取和删除缓存。它使用了Spring Data Redis的RedisTemplate来操作Redis。setKey方法用于设置键值对到缓存,可以选择设置过期时间;getKey方法用于从缓存中获取键对应的值;deleteKey方法用于删除缓存中的键。这个类可以被Spring Boot应用的其他组件注入和使用。

2024-09-03

在云服务器上安装Redis,可以通过以下步骤进行:

  1. 更新包管理器索引并安装必要的依赖项:



sudo apt-get update
sudo apt-get install build-essential tcl
  1. 下载Redis源码:



wget http://download.redis.io/releases/redis-6.0.9.tar.gz
  1. 解压源码并编译安装:



tar xzf redis-6.0.9.tar.gz
cd redis-6.0.9
make
make test # 可选,运行测试
sudo make install
  1. 创建配置文件目录并复制配置文件:



sudo mkdir /etc/redis
sudo cp redis.conf /etc/redis
  1. 修改/etc/redis/redis.conf配置文件,设置Redis为守护进程运行:



# 找到daemonize no
# 修改为
daemonize yes
  1. 修改/etc/redis/redis.conf配置文件,设置Redis监听地址为所有接口:



# 找到bind 127.0.0.1
# 注释掉或者移除
  1. 启动Redis服务:



redis-server /etc/redis/redis.conf
  1. 设置Redis开机自启动(可选):



sudo bash -c 'echo "/usr/local/bin/redis-server /etc/redis/redis.conf" >> /etc/rc.local'

以上步骤适用于基于Debian的系统,如Ubuntu。对于其他Linux发行版,比如CentOS,步骤可能略有不同。请根据您的云服务器的操作系统选择适当的安装步骤。