redis集群搭建可参考：redis集群搭建-CSDN博客
一、简述
Redis（Remote Dictionary Server）是一个开源的、基于内存的高性能键值对存储系统，通常用作数据库、缓存和消息代理。它支持多种数据结构，包括字符串、哈希、列表、集合和有序集合
1.1 Redis相关问题
1、Redis是单线程模式，但速度很快，原因是：
1.Redis的数据存储在内存中，读写速度极快
2.Redis的单线程避免了多线程的上下文切换
3.采用I/O复用技术，可以同时处理多个请求
4.采用高效的数据结构，例如：哈希表
2、Redis序列化：
Redis的序列化作用是将对象转换为字节流以便存储或传输，在Redis中，所有数据都是以字节的形式存储的，因此当我们需要将对象存储到Redis时，需要先将其序列化为字节数组；
3、Redis序列化的形式：
StringRedisSerializer：将String类型的数据序列化为字节数组，适用于String或数值类型数据。
GenericJackson2JsonRedisSerializer：使用Jackson库将对象序列化为JSON字符串，这种方式适用于复杂的对象数据，因为它可以保留对象的结构和属性。
JdkSerializationRedisSerializer：使用Java内置的序列化机制，将对象转换为字节流。这是Redis的默认序列化方式
二、redis的使用
2.1 redis做数据库
1、添加依赖
XML
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>2、配置连接
bash
# application.yml
spring:
redis:
host: localhost
port: 6379
password: yourpassword3、创建配置类
java
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
// 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
// 使用GenericJackson2JsonRedisSerializer来序列化和反序列化redis的value值
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
// 设置hash key 和 value 序列化模式
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
template.afterPropertiesSet();
return template;
}
}4、服务层和redis交互
java
@Service
public class RedisService {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
public void setKey(String key, Object value) {
redisTemplate.opsForValue().set(key, value);
}
public Object getKey(String key) {
return redisTemplate.opsForValue().get(key);
}
//hash
public void setHash(String key, Map<String, Object> values) {
HashOperations<String, Object, Object> hashOperations = stringRedisTemplate.opsForHash();
hashOperations.putAll(key, values);
}
public Map<Object, Object> getHash(String key) {
HashOperations<String, Object, Object> hashOperations = stringRedisTemplate.opsForHash();
return hashOperations.entries(key);
}
//参数是hash表的键名和字段名
public Object getHashField(String key, String field) {
HashOperations<String, Object, Object> hashOperations = stringRedisTemplate.opsForHash();
return hashOperations.get(key, field);
}
//list
public void leftPush(String key, String value) {
ListOperations<String, String> listOperations = stringRedisTemplate.opsForList();
listOperations.leftPush(key, value);
}
//key是键 start开始索引，从0开始 end结束索引，如果设为-1，表示获取列表中的所有元素
public List<String> getRange(String key, long start, long end) {
ListOperations<String, String> listOperations = stringRedisTemplate.opsForList();
return listOperations.range(key, start, end);
}
//Zset
public void addZSetMember(String key, String value, double score) {
ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();
zSetOperations.add(key, value, score);
}
public Set<String> getZSetMembers(String key) {
ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();
return zSetOperations.range(key, 0, -1);
}
}2.2 redis做缓存
1、添加完依赖后，在启动类添加注解@EnableCaching
java
@SpringBootApplication
@EnableCaching
public class YourApplication {
public static void main(String[] args) {
SpringApplication.run(YourApplication.class, args);
}
}2、创建缓存的配置类
java
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
// 设置key和value的序列化器
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
return template;
}
@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofMinutes(10)) // 设置缓存过期时间
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())) // 设置key序列化方式
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())); // 设置value序列化方式
return RedisCacheManager.builder(factory).cacheDefaults(config).build();
}
}3、定义mapper和xml文件中的sql
java
public interface UserMapper {
User getUserById(Long id);
}
//有多个参数时
public interface UserMapper {
User getUserByIdAndName(@Param("id") Long id, @Param("name") String name);
}
XML
<!-- UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
<select id="getUserById" resultType="com.example.entity.User">
SELECT * FROM user WHERE id = #{id}
</select>
</mapper>
<!-- 多个参数时 -->
<select id="getUserByIdAndName" resultType="User">
SELECT * FROM users WHERE id = #{id} AND name = #{name}
</select>4、service层添加缓存注解
java
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
@Cacheable(value = "userCache", key = "#id")
public User getUserById(Long id) {
return userMapper.getUserById(id);
}
//多个参数时
@Cacheable(value = "users", key = "#id + '_' + #name")
public User getUserByIdAndName(Long id, String name) {
return userMapper.getUserByIdAndName(id, name);
}
}@Cacheable注解指定了缓存的名称为userCache，并使用用户的ID作为缓存的键。如果缓存中已经存在对应键的数据，则直接从缓存中获取，否则执行方法内的逻辑，并将结果存入缓存
2.3 redis做分布式锁
1、添加依赖
XML
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>2、获取和释放锁的类
java
@Component
public class RedisLock {
@Autowired
private StringRedisTemplate stringRedisTemplate;
private static final String LOCK_PREFIX = "lock:";
private static final long DEFAULT_EXPIRE_TIME = 30; // 锁默认过期时间，单位：秒
/**
* 尝试获取锁
*
* @param key 锁的键
* @param expireTime 锁的过期时间，单位：秒
* @return 是否获取锁成功
*/
public boolean tryLock(String key, long expireTime) {
String lockKey = LOCK_PREFIX + key;
// 使用SETNX命令尝试获取锁
//lockKey是键，"locked"是值，expireTime是过期时间，TimeUnit.SECONDS指定了过期时间的单位为秒
Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "locked", expireTime, TimeUnit.SECONDS);
return success != null && success;
}
/**
* 释放锁
*
* @param key 锁的键
*/
public void unlock(String key) {
String lockKey = LOCK_PREFIX + key;
// 删除锁键来释放锁
stringRedisTemplate.delete(lockKey);
}
}3、使用
java
@Service
public class YourService {
@Autowired
private RedisLock redisLock;
public void someMethod() {
//key值，可以是业务id，保证唯一性
String lockKey = "someResource";
boolean lockAcquired = redisLock.tryLock(lockKey, 30); // 尝试获取锁，过期时间30秒
if (lockAcquired) {
try {
// 执行需要同步的代码
} finally {
// 确保在代码执行完毕后释放锁
redisLock.unlock(lockKey);
}
} else {
// 处理获取锁失败的情况，例如重试或返回错误消息
}
}
}