下面列出了怎么用org.springframework.data.redis.core.RedisOperations的API类实例代码及写法，或者点击链接到github查看源代码。
@Override
public void follow(int userId, int entityType, int entityId) {
// 自己的关注者key
String followeeKey = RedisKeyUtil.getFolloweeKey(userId, entityType);
// 被关注对象的粉丝key
String followerKey = RedisKeyUtil.getFollowerKey(entityType, entityId);
redisTemplate.execute(new SessionCallback() {
@Override
public Object execute(RedisOperations redisOperations) throws DataAccessException {
redisOperations.multi();
// 自己的关注列表
redisTemplate.opsForZSet().add(followeeKey, entityId, System.currentTimeMillis());
// 被关注对象的粉丝列表
redisTemplate.opsForZSet().add(followerKey, userId, System.currentTimeMillis());
return redisOperations.exec();
}
});
}
@Override
public void unfollow(int userId, int entityType, int entityId) {
String followeeKey = RedisKeyUtil.getFolloweeKey(userId, entityType);
String followerKey = RedisKeyUtil.getFollowerKey(entityType, entityId);
redisTemplate.execute(new SessionCallback() {
@Override
public Object execute(RedisOperations redisOperations) throws DataAccessException {
redisOperations.multi();
// 自己的关注列表
redisTemplate.opsForZSet().remove(followeeKey, entityId, System.currentTimeMillis());
// 被关注对象的粉丝列表
redisTemplate.opsForZSet().remove(followerKey, userId, System.currentTimeMillis());
return redisOperations.exec();
}
});
}
@Test
public void test2() {
System.out.println(11);
List<Object> results = (List<Object>) redisTemplate.execute(new SessionCallback<List<Object>>() {
@SuppressWarnings({"rawtypes", "unchecked"})
public List<Object> execute(RedisOperations operations) {
operations.multi();
//new Jedis().multi();
operations.opsForValue().set("abb", "233332");
if (true) {
throw new eeee("xx");
}
operations.opsForValue().set("abb", "2");
// operations.opsForValue().set("11", "22");
// operations.opsForValue().get("11");
// operations.opsForList().leftPush("aaa", 1);
// operations.opsForList().range("aaa", 0l, 1l);
// operations.opsForSet().add("bbbb", 12);
// operations.opsForSet().members("bbbb");
return operations.exec();
}
});
for (Object o : results) {
System.out.println(o);
}
}
@Bean(name = "redisTemplate")
@ConditionalOnClass(RedisOperations.class)
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.activateDefaultTyping(mapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(mapper);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
template.setKeySerializer(stringRedisSerializer);
template.setHashKeySerializer(stringRedisSerializer);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
@Test
public void test2() {
System.out.println(11);
List<Object> results = (List<Object>) redisTemplate.execute(new SessionCallback<List<Object>>() {
@SuppressWarnings({"rawtypes", "unchecked"})
public List<Object> execute(RedisOperations operations) {
operations.multi();
//new Jedis().multi();
operations.opsForValue().set("abb", "233332");
if (true) {
throw new eeee("xx");
}
operations.opsForValue().set("abb", "2");
// operations.opsForValue().set("11", "22");
// operations.opsForValue().get("11");
// operations.opsForList().leftPush("aaa", 1);
// operations.opsForList().range("aaa", 0l, 1l);
// operations.opsForSet().add("bbbb", 12);
// operations.opsForSet().members("bbbb");
return operations.exec();
}
});
for (Object o : results) {
System.out.println(o);
}
}
@Test
public void testRedisMap() {
Object object = redisTemplate.execute(new SessionCallback() {
@Override
public Object execute(RedisOperations operations) throws DataAccessException {
operations.multi();
operations.opsForValue().get("test");
operations.delete("test");
operations.opsForValue().set("test", "6");
List<String> rs = operations.exec();
System.out.println(" rs:" + rs.toString());
return rs;
}
});
List<Object> strings = (List<Object>) object;
for (Object str : strings) {
System.err.println(str.toString());
}
}
public CustomizedRedisCacheManager(
RedisConnectionFactory connectionFactory,
RedisOperations redisOperations,
List<CacheItemConfig> cacheItemConfigList) {
this(
RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory),
RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(30)),
cacheItemConfigList
.stream()
.collect(Collectors.toMap(CacheItemConfig::getName,cacheItemConfig -> {
RedisCacheConfiguration cacheConfiguration =
RedisCacheConfiguration
.defaultCacheConfig()
.entryTtl(Duration.ofSeconds(cacheItemConfig.getExpiryTimeSecond()))
.prefixKeysWith(cacheItemConfig.getName());
return cacheConfiguration;
}))
);
this.redisOperations=redisOperations;
CacheContainer.init(cacheItemConfigList);
}
/**
*
从数据库恢复数据
*/
public void inspectDataConsistency() {
if(checkIsNeedRollback()) {
//数据库与BlogIdGenerate的事物完整性检查
Long initTime = System.currentTimeMillis();
log.info("ueditor的文件数据从数据库中回滚");
//开启事务
SessionCallback sessionCallback = new SessionCallback() {
@Override
public Object execute(RedisOperations redisOperations) throws DataAccessException {
redisOperations.multi();
rollbackData();
return redisOperations.exec();
}
};
//事务执行
redisTemplate.execute(sessionCallback);
log.info("ueditor上传文件数据中的数据回滚完成 耗时:{}ms", System.currentTimeMillis() - initTime);
}
}
/**
* 从数据库恢复数据
*/
public void inspectDataConsistency() {
if(checkIsNeedRollback()) {
Long initTime = System.currentTimeMillis();
//进行点赞数据的事务完整性检查
log.info("投票数据进行数据回滚");
List<BlogVoteDO> blogVoteDOS = blogVoteMapper.selectAll();
List<IpBlogVoteDO> ipBlogVoteDOS = ipBlogVoteMapper.selectAll();
//开启事务
SessionCallback sessionCallback = new SessionCallback() {
@Override
public Object execute(RedisOperations redisOperations) throws DataAccessException {
redisOperations.multi();
rollbackData(blogVoteDOS, ipBlogVoteDOS);
return redisOperations.exec();
}
};
//执行
redisTemplate.execute(sessionCallback);
log.info("从数据库中回滚投票数据的完成 耗时:{}ms", System.currentTimeMillis() - initTime);
}else {
}
}
@Override
public void storeSignUpInformation(UUID aggregateId, String username, UUID signUpCode) {
var signUpCodeKey = SIGN_UP_CODE_NAMESPACE + signUpCode.toString();
redisTemplate.execute(new SessionCallback<List<Object>>() {
@Override
public List<Object> execute(RedisOperations operations) throws DataAccessException {
operations.multi();
operations.opsForHash().put(signUpCodeKey, "username", username);
operations.opsForHash().put(signUpCodeKey, "aggregateid",
aggregateId.toString());
operations.expire(signUpCodeKey, EXPIRATION_IN_MINUTES, TimeUnit.MINUTES);
return redisTemplate.exec();
}
});
}
@Override
public void saveSignUpUser(SignUpUser signUpUser) {
final var signUpUserKey = SIGN_UP_USER_NAMESPACE + signUpUser.getAggregateId();
final var signUpUserMap = Map.of(
"username", signUpUser.getUsername(),
"email", signUpUser.getEmail(),
"aggregateId", signUpUser.getAggregateId().toString(),
"signUpCode", signUpUser.getSignUpCode().toString(),
"confirmed", String.valueOf(signUpUser.isConfirmed()),
"encryptedPassword", signUpUser.getEncryptedPassword());
redisTemplate.execute(new SessionCallback<List<Object>>() {
@Override
public List<Object> execute(RedisOperations operations) throws DataAccessException {
operations.multi();
operations.opsForHash().putAll(signUpUserKey, signUpUserMap);
return redisTemplate.exec();
}
});
}
@Override
public void like(int userId, int entityType, int entityId, int entityUserId) {
redisTemplate.execute(new SessionCallback() {
@Override
public Object execute(RedisOperations redisOperations) throws DataAccessException {
String entityLikeKey = RedisKeyUtil.getEntityLikeKey(entityType, entityId);
String userLikeKey = RedisKeyUtil.getUserLikeKey(entityUserId);
// 当前用户是否点过赞
Boolean isMember = redisTemplate.opsForSet().isMember(entityLikeKey, userId);
// 开启事务
redisOperations.multi();
if (isMember) {
redisTemplate.opsForSet().remove(entityLikeKey, userId);
redisTemplate.opsForValue().increment(userLikeKey, -1);
} else {
redisTemplate.opsForSet().add(entityLikeKey, userId);
redisTemplate.opsForValue().increment(userLikeKey, 1);
}
return redisOperations.exec();
}
});
}
/**
* 批量操作
* @param runnable 业务体
* @param redisTemplate RedisTemplate
*/
public static void batchOps(Runnable runnable, RedisTemplate<String, String> redisTemplate) {
redisTemplate.executePipelined(new SessionCallback<Object>() {
@Override
public <K, V> Object execute(@NonNull RedisOperations<K, V> operations) throws DataAccessException {
runnable.run();
return null;
}
});
}
@Transactional(rollbackFor = Exception.class)
@CacheEvict(value = "illust_bookmarked", key = "#illustId+'1'+'30'")
public void bookmarkOperation(int userId, String username, int illustId, int increment, int relationId) {
//redis修改联系以及修改redis中该画作收藏数(事务)
// Boolean isMember = stringRedisTemplate.opsForSet().isMember(RedisKeyConstant.BOOKMARK_REDIS_PRE + userId, String.valueOf(illustId));
// if ((increment > 0 && isMember)
// || (increment < 0 && !isMember)
// ) {
// throw new BusinessException(HttpStatus.BAD_REQUEST, "用户与画作的收藏关系请求错误");
// }
stringRedisTemplate.execute(new SessionCallback<>() {
@Override
public List<Object> execute(RedisOperations operations) throws DataAccessException {
operations.multi();
if (increment > 0) {
operations.opsForSet().add(RedisKeyConstant.BOOKMARK_REDIS_PRE + userId, String.valueOf(illustId));
//异步往mysql中写入
businessMapper.bookmark(userId, illustId, username, LocalDateTime.now());
} else {
operations.opsForSet().remove(RedisKeyConstant.BOOKMARK_REDIS_PRE + userId, String.valueOf(illustId));
//异步往mysql中移除
businessMapper.cancelBookmark(userId, illustId);
}
operations.opsForHash().increment(RedisKeyConstant.BOOKMARK_COUNT_MAP_REDIS_PRE, String.valueOf(illustId), increment);
return operations.exec();
}
});
}
@Override
public void addTaskToQueue(String queueKey, String url, String itemKey, String field, String value, Request request) {
List<Object> txResults = redisTemplate.execute(new SessionCallback<List<Object>>() {
@Override
public List<Object> execute(RedisOperations operations) throws DataAccessException {
operations.multi();
operations.opsForList().rightPush(queueKey, url);
if (request != null && request.getExtras() != null) {
operations.opsForHash().put(itemKey, field, value);
}
// This will contain the results of all ops in the transaction
return operations.exec();
}
});
}
public UpdatableRedisCache(
String name,
byte[] prefix,
RedisOperations<? extends Object, ? extends Object> redisOperations,
long expiration) {
super(name, prefix, redisOperations, expiration);
this.redisOperations = redisOperations;
// self = PropertyAccessorFactory.forDirectFieldAccess(this);
this.expirationInSeconds = expiration;
}
@Bean
public RedisOperations<String, Object> sessionRedisOperations() {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(this.redisConnectionFactory);
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
return redisTemplate;
}
RedisSessionExpirationPolicy(RedisOperations<Object, Object> sessionRedisOperations,
Function<Long, String> lookupExpirationKey, Function<String, String> lookupSessionKey) {
super();
this.redis = sessionRedisOperations;
this.lookupExpirationKey = lookupExpirationKey;
this.lookupSessionKey = lookupSessionKey;
}
/**
* Creates a new instance. For an example, refer to the class level javadoc.
* @param sessionRedisOperations the {@link RedisOperations} to use for managing the
* sessions. Cannot be null.
*/
public RedisIndexedSessionRepository(RedisOperations<Object, Object> sessionRedisOperations) {
Assert.notNull(sessionRedisOperations, "sessionRedisOperations cannot be null");
this.sessionRedisOperations = sessionRedisOperations;
this.expirationPolicy = new RedisSessionExpirationPolicy(sessionRedisOperations, this::getExpirationsKey,
this::getSessionKey);
configureSessionChannels();
}
@Test
void qualifiedConnectionFactoryRedisConfig() {
registerAndRefresh(RedisConfig.class, QualifiedConnectionFactoryRedisConfig.class);
RedisIndexedSessionRepository repository = this.context.getBean(RedisIndexedSessionRepository.class);
RedisConnectionFactory redisConnectionFactory = this.context.getBean("qualifiedRedisConnectionFactory",
RedisConnectionFactory.class);
assertThat(repository).isNotNull();
assertThat(redisConnectionFactory).isNotNull();
RedisOperations redisOperations = (RedisOperations) ReflectionTestUtils.getField(repository,
"sessionRedisOperations");
assertThat(redisOperations).isNotNull();
assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
.isEqualTo(redisConnectionFactory);
}
@Test
void primaryConnectionFactoryRedisConfig() {
registerAndRefresh(RedisConfig.class, PrimaryConnectionFactoryRedisConfig.class);
RedisIndexedSessionRepository repository = this.context.getBean(RedisIndexedSessionRepository.class);
RedisConnectionFactory redisConnectionFactory = this.context.getBean("primaryRedisConnectionFactory",
RedisConnectionFactory.class);
assertThat(repository).isNotNull();
assertThat(redisConnectionFactory).isNotNull();
RedisOperations redisOperations = (RedisOperations) ReflectionTestUtils.getField(repository,
"sessionRedisOperations");
assertThat(redisOperations).isNotNull();
assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
.isEqualTo(redisConnectionFactory);
}
@Test
void qualifiedAndPrimaryConnectionFactoryRedisConfig() {
registerAndRefresh(RedisConfig.class, QualifiedAndPrimaryConnectionFactoryRedisConfig.class);
RedisIndexedSessionRepository repository = this.context.getBean(RedisIndexedSessionRepository.class);
RedisConnectionFactory redisConnectionFactory = this.context.getBean("qualifiedRedisConnectionFactory",
RedisConnectionFactory.class);
assertThat(repository).isNotNull();
assertThat(redisConnectionFactory).isNotNull();
RedisOperations redisOperations = (RedisOperations) ReflectionTestUtils.getField(repository,
"sessionRedisOperations");
assertThat(redisOperations).isNotNull();
assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
.isEqualTo(redisConnectionFactory);
}
@Test
void namedConnectionFactoryRedisConfig() {
registerAndRefresh(RedisConfig.class, NamedConnectionFactoryRedisConfig.class);
RedisIndexedSessionRepository repository = this.context.getBean(RedisIndexedSessionRepository.class);
RedisConnectionFactory redisConnectionFactory = this.context.getBean("redisConnectionFactory",
RedisConnectionFactory.class);
assertThat(repository).isNotNull();
assertThat(redisConnectionFactory).isNotNull();
RedisOperations redisOperations = (RedisOperations) ReflectionTestUtils.getField(repository,
"sessionRedisOperations");
assertThat(redisOperations).isNotNull();
assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
.isEqualTo(redisConnectionFactory);
}
@Override
public <T> T fetch(Function<Commands, T> block) {
try {
return redisTemplate.execute(new SessionCallback<T>() {
@Override
@SuppressWarnings("unchecked")
public <K, V> T execute(RedisOperations<K, V> operations) throws DataAccessException {
RedisConnectionCommands commands = new RedisConnectionCommands((RedisOperations<String, String>) operations);
return block.apply(commands);
}
});
} catch (RedisConnectionFailureException e) {
throw new RedisConnectException(e);
}
}
@Bean
@ConditionalOnBean(RedisOperations.class)
public RedisVerificationCodeCache redisVerificationCodeCache(StringRedisTemplate stringRedisTemplate){
return new RedisVerificationCodeCache(stringRedisTemplate);
}
public SpringRedisCacheManager(RedisOperations redisOperations) {
super(redisOperations);
}
public CustomizedRedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig, RedisOperations redisOperations) {
super(name, cacheWriter,cacheConfig);
this.redisOperations=redisOperations;
}
public AppCacheManager(RedisOperations redisOperations) {
super(redisOperations);
this.ops = redisOperations;
this.setUsePrefix(true);
}
public AppCacheManager(RedisOperations redisOperations, Collection<String> cacheNames) {
super(redisOperations, cacheNames);
this.ops = redisOperations;
this.setUsePrefix(true);
}
public RedisOperations<K, V> getOperations() {
return ops.getOperations();
}