Redis+spring boot

最新推荐文章于 2024-08-17 17:52:41 发布
最新推荐文章于 2024-08-17 17:52:41 发布
阅读量202 收藏
点赞数
分类专栏： spring-boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haodanhui521/article/details/79556684
版权

1.配置文件： 

redis:
    database: 0
    host: //redisIp
    port: 16376
    password: ifValue@QA-Redis888@666
    timeout: 30000
    pool:
      max-active: 50
      max-wait: 1000
      max-idle: 10
      min-idle: 10

2.Config类配置： 

package com.ftvalue.sso.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
@EnableAutoConfiguration
@Slf4j
public class RedisConfig {

	@Value("${spring.redis.pool.max-active}")
    Integer maxActive;
    @Value("${spring.redis.pool.max-idle}")
    Integer maxIdle;
    @Value("${spring.redis.pool.max-wait}")
    Integer maxWait;
    @Value("${spring.redis.pool.min-idle}")
    Integer minIdle;
    @Value("${spring.redis.host}")
    String hostname;
    @Value("${spring.redis.password}")
    String password;
    @Value("${spring.redis.port}")
    String port;
    @Value("${spring.redis.database}")
    String database;
    @Value("${spring.redis.timeout}")
    String timeout;

	@Bean
    public JedisPoolConfig getRedisConfig(){
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxActive);
        config.setMaxIdle(maxIdle);
        config.setMinIdle(minIdle);
		config.setMaxWaitMillis(maxWait);
        return config;
    }

    @Bean
    public JedisConnectionFactory getConnectionFactory(){
        JedisConnectionFactory factory = new JedisConnectionFactory();
        JedisPoolConfig config = getRedisConfig();
        factory.setPoolConfig(config);
        factory.setHostName(hostname);
        factory.setPassword(password);
        factory.setPort(Integer.parseInt(port));
        factory.setDatabase(Integer.parseInt(database));
        factory.setTimeout(Integer.parseInt(timeout));
        log.info("JedisConnectionFactory bean init success.");
        return factory;
    }


    @Bean
    public RedisTemplate<String, Object> getRedisTemplate(){
    	RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
    	template.setConnectionFactory(getConnectionFactory());
    	template.setKeySerializer(template.getStringSerializer());
    	template.setValueSerializer(template.getStringSerializer());
    	template.setHashKeySerializer(template.getStringSerializer());
    	template.setHashValueSerializer(template.getStringSerializer());
        return template;
    }
}

3.RedisUtilServiceImpl 

package com.ftvalue.sso.service.impl;

import com.alibaba.fastjson.JSON;
import com.ftvalue.sso.service.IRedisUtilService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author hackerli
 */
@Service
public class RedisUtilServiceImpl implements IRedisUtilService {

    private static Logger logger = LoggerFactory.getLogger(RedisUtilServiceImpl.class.getName());

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public boolean set(final String key, final String value) {
        try{
            ValueOperations<String, Object> valueOps =  redisTemplate.opsForValue();
            valueOps.set(key, value);
            return true;
        }catch (Exception e) {
            logger.info("push string to redis error == [{}]", e.getMessage());
            return false;
        }
    }

    @Override
    public boolean increment(String key, String value) {
        redisTemplate.opsForValue().increment(key, new Long(value != null?value:"0"));
        return false;
    }

    @Override
    public boolean set(String key, String value, long expireTime,final TimeUnit unit) {
        try{
            ValueOperations<String, Object> valueOps =  redisTemplate.opsForValue();
            valueOps.set(key, value,expireTime,unit);
            return true;
        }catch (Exception e) {
            logger.info("push string to redis error == [{}]", e.getMessage());
            return false;
        }
    }

    @Override
    public String get(final String key){
        String result = redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                byte[] value =  connection.get(serializer.serialize(key));
                return serializer.deserialize(value);
            }
        });
        return result;
    }

    @Override
    public boolean expire(final String key, long expire,TimeUnit unit) {
        return redisTemplate.expire(key, expire, unit);
    }

    @Override
    public <T> boolean setList(String key, List<T> list) {
        String value = JSON.toJSONString(list);
        return set(key,value);
    }

    @Override
    public <T> List<T> getList(String key,Class<T> clz) {
        String json = get(key);
        if(json!=null){
            List<T> list = JSON.parseArray(json,clz);
            return list;
        }
        return null;
    }

    @Override
    public long lpush(final String key, Object obj) {
        String value = JSON.toJSONString(obj);
        ListOperations<String,Object> lops = redisTemplate.opsForList();
        long count = lops.leftPush(key,value);
        return count;
    }

    @Override
    public long rpush(String key, Object obj) {
        String value = JSON.toJSONString(obj);
        ListOperations<String,Object> lops = redisTemplate.opsForList();
        long count = lops.rightPush(key,value);
        return count;
    }

    @Override
    public <T> T lpop(String key,Class<T> clz) {
        ListOperations<String,Object> lops = redisTemplate.opsForList();
        String value = (String) lops.rightPop(key);
        T t = JSON.parseObject(value, clz);
        return t;
    }

    @Override
    public <T> T rpop(String key, Class<T> clz) {
        ListOperations<String,Object> lops = redisTemplate.opsForList();
        //String value = (String) lops.rightPop(key);
        String value = (String)lops.rightPop(key,100,TimeUnit.MILLISECONDS);
        T t = JSON.parseObject(value, clz);
        return t;
    }

    @Override
    public long removeIndexList(String key, long i, Object obj) {
        ListOperations<String,Object> lops = redisTemplate.opsForList();
        long result = lops.remove(key,i,obj);
        return result;
    }

    @Override
    public long setAdd(String key, Object obj) {
        String value = JSON.toJSONString(obj);
        SetOperations<String,Object> zops = redisTemplate.opsForSet();
        long count = zops.add(key,value);
        return count;
    }

    @Override
    public <T> T setPop(String key, Class<T> clz) {
        SetOperations<String,Object> zops = redisTemplate.opsForSet();
        String value = (String)zops.pop(key);
        T t = JSON.parseObject(value, clz);
        return t;
    }

    @Override
    public <T> List<T> getAllSet(String key, Class<T> clz) {
        SetOperations<String,Object> zops = redisTemplate.opsForSet();
        Set<Object> results = zops.members(key);
        if(results != null && results.size() > 0) {
            List<T> list = new ArrayList<>();
            for(Object result : results) {
                T t = JSON.parseObject((String)result, clz);
                list.add(t);
            }
            return list;
        }
        return null;
    }

    @Override
    public boolean zadd(String key, String value, double score) {
        ZSetOperations<String,Object> zSetOperations = redisTemplate.opsForZSet();
        boolean result = zSetOperations.add(key,value,score);
        return result;
    }

    @Override
    public Set<Object> zrank(String key, long start, long end, boolean flag) {
        ZSetOperations<String,Object> zSetOperations = redisTemplate.opsForZSet();
        //flag = true 表示正序
        Set<Object> set = null;
        if(flag) {
            set = zSetOperations.range(key,start,end);
        }else {
            set = zSetOperations.reverseRange(key,start,end);
        }
        return set;
    }

    @Override
    public long zsize(String key) {
        ZSetOperations<String,Object> zSetOperations = redisTemplate.opsForZSet();
        long size = zSetOperations.size(key);
        return size;
    }

    @Override
    public <T> List<T> getRangeList(String key, Class<T> clz) {
        ListOperations<String,Object> lops = redisTemplate.opsForList();
        long length = lops.size(key);
        List<Object> results = lops.range(key,0,length);
        if(results != null && results.size() > 0) {
            List<T> list = new ArrayList<>();
            for(Object result : results) {
                T t = JSON.parseObject((String)result, clz);
                list.add(t);
            }
            return list;
        }
        return null;
    }

    @Override
    public <T> List<T> listRangeList(String key, long start, long end, Class<T> clz) {
        ListOperations<String,Object> lops = redisTemplate.opsForList();
        List<Object> results = lops.range(key,start,end);
        if(results != null && results.size() > 0) {
            List<T> list = new ArrayList<>();
            for(Object result : results) {
                T t = JSON.parseObject((String)result, clz);
                list.add(t);
            }
            return list;
        }
        return null;
    }

    @Override
    public <T> T getIndexObject(String key, long index,Class<T> clz) {
        ListOperations<String,Object> lops = redisTemplate.opsForList();
        Object result = lops.index(key,index);
        T t = JSON.parseObject((String)result, clz);
        return t;
    }

    @Override
    public long getListIndex(String key) {
        return redisTemplate.boundValueOps(key).increment(1l);
    }

    @Override
    public long listLength(String key) {
        ListOperations<String,Object> lops = redisTemplate.opsForList();
        long length = lops.size(key);
        return length;
    }

    @Override
    public boolean containsKey(String key) {
        return redisTemplate.hasKey(key);
    }

    @Override
    public boolean existHashKey(String key, String hashKey) {
        HashOperations<String,String,String> hops = redisTemplate.opsForHash();
        return hops.hasKey(key,hashKey);
    }

    @Override
    public void setObj(String key, Object object) {
        try{
            ValueOperations<String, Object> valueOps =  redisTemplate.opsForValue();
            String value = JSON.toJSONString(object);
            valueOps.set(key, value);
        }catch (Exception e) {
            logger.info("push string to redis error == [{}]", e.getMessage());
        }
    }

    @Override
    public void setObj(String key, Object object, long timeout, TimeUnit unit) {
        try{
            ValueOperations<String, Object> valueOps =  redisTemplate.opsForValue();
            String value = JSON.toJSONString(object);
            valueOps.set(key, value,timeout,unit);
        }catch (Exception e) {
            logger.info("push string to redis error == [{}]", e.getMessage());
        }
    }

    @Override
    public <T> T getObj(String key, Class<T> clz) {
        ValueOperations<String, Object> valueOps =  redisTemplate.opsForValue();
        String value = (String) valueOps.get(key);
        T t = JSON.parseObject(value, clz);
        return t;
    }

    @Override
    public boolean setHash(String key, String field, String value) {
        try{
            HashOperations<String,String,String> hops = redisTemplate.opsForHash();
            hops.put(key, field,value);
            return true;
        }catch (Exception e) {
            logger.info("push hash to redis error == [{}]", e);
            return false;
        }
    }

    @Override
    public <T> List<T> getHash(String key,Class<T> clz) {
        HashOperations<String,String,String> hops = redisTemplate.opsForHash();
        List<String> list = hops.values(key);
        List<T> results = new ArrayList<T>();
        if(list != null && list.size() > 0) {
            for(String l : list) {
                T t = JSON.parseObject(l, clz);
                results.add(t);
            }
        }
        return results;
    }

    @Override
    public boolean setAllHash(String key, Map<String, String> map) {
        HashOperations<String,String,String> hops = redisTemplate.opsForHash();
        hops.putAll(key, map);
        return true;
    }

    public boolean removeKey(String key, String hashKey) {
        try{
            HashOperations<String,String,String> hops = redisTemplate.opsForHash();
            hops.delete(key, hashKey);
            return true;
        }catch (Exception e) {
            logger.info("remove key from redis request key is [{}],hashKey is [{}]", key,hashKey);
            logger.info("remove key from redis error == [{}]", e);
            return false;
        }
    }

    @Override
    public <T> T getKey(String key, String hashKey, Class<T> clz) {
        try{
            HashOperations<String,String,String> hops = redisTemplate.opsForHash();
            String value = hops.get(key, hashKey);
            T t = JSON.parseObject(value, clz);
            return t;
        }catch (Exception e) {
            logger.info("remove key from redis request key is [{}],hashKey is [{}]", key,hashKey);
            logger.info("remove key from redis error == [{}]", e.getMessage());
            return null;
        }
    }

    @Override
    public void delKey(String key) {
        redisTemplate.delete(key);
    }

    @Override
    public void delKeys(Set<String> keys) {
        redisTemplate.delete(keys);
    }

    @Override
    public Set<String> getAllKeys(String pattern) {
        return redisTemplate.keys(pattern+ "*");
    }

    @Override
    public boolean lock(String key) {
        boolean result = redisTemplate.boundValueOps(key).setIfAbsent("1");
        redisTemplate.expire(key,3,TimeUnit.HOURS);
        return result;
    }

    @Override
    public boolean lock(String key, long timeout, TimeUnit timeUnit) {
        boolean result = redisTemplate.boundValueOps(key).setIfAbsent("1");
        redisTemplate.expire(key,timeout,timeUnit);
        return result;
    }

    @Override
    public void unlock(String key) {
        redisTemplate.delete(key);
    }

}

4.RedisServiceImpl

package com.ftvalue.sso.service.impl;import com.ftvalue.sso.repository.model.SysUserInfo;import com.ftvalue.sso.service.IRedisUtilService;import com.ftvalue.sso.service.RedisService;import com.ftvalue.sso.util.JsonUtil;import lombok.extern.slf4j.Slf4j;import org.apache.commons.lang3.StringUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Value;import org.springframework.stereotype.Service;/** * @author hackerli */@Service@Slf4jpublic class RedisServiceImpl implements RedisService { @Autowired IRedisUtilService iRedisUtilService;
//redis过期时间 @Value("${spring.redis.keyExpired:180}") Long expireTime;
//redis数据前缀 final static String USER_INFO_KEY = "sso:USER_INFO"; @Override public void setUserInfoToRedis(SysUserInfo sysUserInfo) { try { if(StringUtils.isNotBlank(sysUserInfo.getMobile())) { iRedisUtilService.set(USER_INFO_KEY + sysUserInfo.getMobile(), JsonUtil.toJson(sysUserInfo)); } if(StringUtils.isNotBlank(sysUserInfo.getLoginName())) { iRedisUtilService.set(USER_INFO_KEY + sysUserInfo.getLoginName(), JsonUtil.toJson(sysUserInfo)); } if(StringUtils.isNotBlank(sysUserInfo.getEmail())) { iRedisUtilService.set(USER_INFO_KEY + sysUserInfo.getEmail(), JsonUtil.toJson(sysUserInfo)); } }catch (Exception e){ log.error("保存用户信息入redis出错"); } } @Override public String getDataFromRedis(String loginName) { return iRedisUtilService.get(USER_INFO_KEY + loginName); } @Override public void updateDataToRedis(String loginName, String value) { iRedisUtilService.set(USER_INFO_KEY + loginName, value); }}

5.Controller类实现 
package com.ftvalue.sso.service.impl;

import com.ftvalue.sso.constants.AppIpEnum;
import com.ftvalue.sso.constants.UserStatusEnum;
import com.ftvalue.sso.repository.mapper.SysUserInfoMapper;
import com.ftvalue.sso.repository.model.SysUserInfo;
import com.ftvalue.sso.response.ResultCode;
import com.ftvalue.sso.response.UserResponse;
import com.ftvalue.sso.service.IncrementNumber;
import com.ftvalue.sso.service.RedisService;
import com.ftvalue.sso.service.SysUserInfoService;
import com.ftvalue.sso.util.DateUtils;
import com.ftvalue.sso.util.JsonUtil;
import com.ftvalue.sso.util.MapBuilder;
import com.ftvalue.sso.util.SHA1;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.text.MessageFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @author hackerli
 */
@Service
@Slf4j
public class SysUserInfoServiceImpl implements SysUserInfoService {
    private static final String LOGIN = "login";
    private static final String REGISTER = "register";
    @Autowired
    private SysUserInfoMapper sysUserInfoMapper;
    @Autowired
    private RedisService redisService;
    @Autowired
    private IncrementNumber incrementNumber;
    @Value("${login.loginErrorTimes}")
    private Integer loginErrorTimes;
    @Value("${login.loginErrorRemind}")
    private Integer loginErrorRemind;
    @Override
    public UserResponse register(SysUserInfo sysUserInfo){
        UserResponse userResponse = new UserResponse();
        log.info("用户注册开始，用户名为:[{}],登陆用户名为：[{}]",sysUserInfo.getUserName(), sysUserInfo.getLoginName());
        try {
            SysUserInfo queryResultSysUserInfo = null;
            if(StringUtils.isBlank(sysUserInfo.getLoginName()) && StringUtils.isBlank(sysUserInfo.getMobile()) && StringUtils.isBlank(sysUserInfo.getEmail())){
                userResponse = new UserResponse(ResultCode.ERROR_REQUIRED.val(), ResultCode.ERROR_REQUIRED.msg());
                return userResponse;
            }
            queryResultSysUserInfo = validateSysUserInfoExits(sysUserInfo,userResponse, REGISTER);
            if(queryResultSysUserInfo != null && userResponse != null){
                return userResponse;
            }
            String userId = incrementNumber.getCurNo("user","%09d");
            if(StringUtils.isBlank(userId)){
                log.error("用户id生成为空");
                userResponse = new UserResponse(ResultCode.SYSTEM_ERROR.val(), ResultCode.SYSTEM_ERROR.msg());
                return userResponse;
            }
            sysUserInfo.setUserId(userId);
            sysUserInfo.setUserStatus(AppIpEnum.getStartStatus(sysUserInfo.getAppId()));
            sysUserInfo.setUserPwd(SHA1.encode(userId + sysUserInfo.getUserPwd()));
            initSysUserInfo(sysUserInfo);
            sysUserInfoMapper.insertSelective(sysUserInfo);
            redisService.setUserInfoToRedis(sysUserInfo);
            sysUserInfo.setUserPwd("");
            userResponse = new UserResponse(ResultCode.SUCCESS.val(), ResultCode.SUCCESS.msg());
            userResponse.setData(JsonUtil.toJson(sysUserInfo));
        }catch (Exception e){
            log.error("用户注册异常[{}],[{}]",e.getMessage(),e);
            userResponse = new UserResponse(ResultCode.SYSTEM_ERROR.val(), ResultCode.SYSTEM_ERROR.msg());
        }

        return userResponse;
    }
    }

化猿和尚
关注
专栏目录
轻轻松松学习SpringBoot2：第二十六篇： Spring Boot和Redis整合（完整版）
美丽的泡沫
07-23 4万+
前面我们讲了Spring Boot和Mongodb数据库整合，今天说一下和另一个nosql的整合：redis redis安装就不说了，例子用的是win10版的redis（去git上下载，然后解压，然后启动即可redis-cli.exe redis.windows.conf） 看到这个就代表ok了，然后我们来看看代码端 pom.xml新增 &lt;dependency&...
通用权限管理系统+springboot+mybatis plus+spring security+jwt+redis+mysql
05-30
后端使用SpringBoot框架进行业务逻辑开发，利用Spring Security实现权限控制。数据库采用MySQL进行数据存储，使用MyBatis进行数据访问。 权限控制模块设计包括用户、角色和权限三个主要模块。用户模块用于管理用户...
Redis+SpringBoot整合
李长渊的博客
04-11 566
Redis（Remote Dictionary Server )，即远程字典服务。 是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
SpringBoot和Redis的交互数据操作以及Redis的持久化/删除策略和缓存问题
最新发布
weixin_71072718的博客
08-17 1307
当我们客户端访问不存在的数据时，先请求redis，但是此时redis中没有数据， 此时会访问到数据库，但是数据库中也没有数据，这个数据穿透了缓存，直击数据库，我们都知道数据 库能够承载的并发不如redis这么高，如果大量的请求同时过来访问这种不存在的数据，这些请求就都会 访问到数据库，简单的解决方案就是哪怕这个数据在数据库中也不存在，我们也把这个数据存入到redis 中去，这样，下次用户过来访问这个不存在的数据，那么在redis中也能找到这个数据就不会进入到缓存了。是用于指定该实体类对应的数据库表名。
Redis+SpringBoot的简单使用
舌尖上的蛋炒饭的博客
06-24 404
Redis Redis基础知识 一共五种类型 String 就像我们下面在springboot中的例子一样，单个USer在redis存储为String，如果多个用户的话，可能会存储为其他的类型 Hash Redis hash 是一个 string 类型的 field（字段） 和 value（值） 的映射表，hash 特别适合用于存储对象。 List Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边） Set Redis 的 Set 是 String 类
SpringBoot开发详解（十一） -- Redis在SpringBoot中的整合
热门推荐
尼斯湖水鬼的博客
07-01 3万+
各位小伙伴，好久不见。最近一直都没有更新，因为公司的项目一直在抓进度，又是表结构更替，又是重构，还要迭代需求。感觉项目都快做烂了……所以一个公司的好坏真的和领导者有极大的关系，许多程序员真的只是三年程序员，谢三年代码就去转岗管理了，最后导致技术水平有限，管理水平又跟不上。好，我废话少说，开始这次的内容，这次我们聊一下NoSql数据库Redis在SpringBoot中的使用。Redis在Spring
redis+springboot集成-data整合
(づ￣ 3￣)づxl
06-22 763
首先下载redis,及其可视化工具，这里是window本机的运行方式，如果是linux这些云服务器的话，则需要改一下配置文件如设置后台运行、支持远程访问等等，举个例子下载并解压： wget http://download.redis.io/releases/redis-4.0.4.tar.gz tar -zxvf redis-4.0.2.tar.gz 更改配置文件redis.conf ...
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
"Spring Boot+Spring Cache实现两级缓存(Redis+Caffeine)" 知识点一：缓存与两级缓存 缓存是将数据从读取较慢的介质上读取出来放到读取较快的介质上，如磁盘-->内存。平时我们会将数据存储到磁盘上，如：数据库。...
基于SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端商城系统源码
05-13
yshop基于当前流行技术组合的前后端分离商城系统： SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含分类、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、...
SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统
04-30
基于当前流行技术组合的前后端分离商城系统：SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含商城、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、优惠券...
Springboot+SpringSecurity+SpringSession+Redis+Mybatis-Plus+Swwager.zip
11-17
本项目“Springboot+SpringSecurity+SpringSession+Redis+Mybatis-Plus+Swwager”整合了Spring Boot、Spring Security、Spring Session、Redis、Mybatis-Plus以及Swagger等技术，旨在构建一个强大的、安全的、具有...
redis学习笔记+练习springboot-redisdemo
11-10
里面有关于redis的一些笔记介绍，PPT文档， 还有自己整合的springboot-redis的一个微博demo。有需要的可以下下来看下
redis+springboot
weixin_45063957的博客
08-30 158
Jedis 是直连模式，在多个线程间共享⼀个 Jedis 实例时是线程不安全的,需要使⽤连接池 其API提供了⽐较全⾯的Redis命令的⽀持，相⽐于其他Redis 封装框架更加原⽣Jedis中的⽅法调⽤是⽐较底层的暴露的Redis的API，Java⽅法基本和Redis的API保持着⼀致使⽤阻塞的I/O，⽅法调⽤同步，程序流需要等到socket处理完I/O才能执⾏，不⽀持异步操作。 lettuce：⾼级Redis客户端，⽤于线程安全同步，异步响应基于Netty的的事件驱动，可以在多个线程间并发访问,通过异步
Redis与SpringBoot整合
LiuY521的博客
05-31 339
Redis与SpringBoot整合 目录 Redis与SpringBoot整合 一.配置文件 二.创建一个Demo 三.运行输出 四.集群查看一下 一.配置文件 二.创建一个Demo 三.运行输出 四.集群查看一下 ...
Redis-与SpringBoot的集成
文天大人
08-02 460
怀念二抱三抱
redis+springboot系列
weixin_45573378的博客
07-10 181
springboot+redis系列（一）
redis+springboot整合
yy652的博客
12-16 246
redis配置类 package com.nxj.redis_test.config; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.boot.autoconfig
spring boot使用Redis
EaseMob.沈冲
07-09 483
    关系型数据库在性能上总存在一些这样那样的缺陷，所以大家有时候在使用传统型数据库时，会与具有高效存取功能的缓存系统结合使用，以提高系统的访问性能，如Redis。Redis是一种可以持久存储的缓存系统，是一个高性能的key-value数据库，它使用键值对的方式来存储数据。    1、Redis依赖配置        &lt;dependencies&gt; &lt;dependency...
springboot集成redis
Simple_Bo的博客
10-30 296
springboot集成redis时，在pom文件中引入spring-boot-starter-redis包报错，提示找不到相应的jar包，如下图： 在本地maven仓库中找了一遍，确实没有这个jar包，以为是没有从中央仓库下载下来，所以重新运行maven命令下载jar包并更新项目，依然报错。 网上搜下了问题，才知道，原来我项目用的spring boot是2.0以后的版本，spring-b...
redis+tomcat+spring boot +postgres技术框架描述
04-30
Redis是一款开源的NoSQL内存数据库，它支持键值对存储、发布/...这些技术框架常常被一起使用，如在Java Web项目中，常常使用Spring Boot作为应用程序框架，Tomcat作为Web服务器，Redis作为缓存，PostgreSQL作为数据库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

化猿和尚

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值