Spring boot 集成redis插件

最新推荐文章于 2023-02-13 20:15:00 发布
最新推荐文章于 2023-02-13 20:15:00 发布
阅读量413 收藏
点赞数
分类专栏： Java 文章标签： redis Spring boot redis集群 redis哨兵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26710443/article/details/82561963
版权

一、Spring boot 配置

配置redis三种模式，根据不同模式加载

spring:
    #redis相关配置
    redis:
        #ALONE：单机模式、CLUSTER：集群、SENTINEL：哨兵
         mode:ALONE
         hostName:47.93.16.119
        #password：
         port:6379
         timeout:10000
         maxIdle:300
         maxTotal:1000
         minEvictableIdleTimeMillis:30000
         numTestsPerEvictionRun:1024
         timeBetweenEvictionRunsMillis:30000
         testOnBorrow:true
         testWhileIdle:true
      #  cluster:
        #集群服务器，以“,”分隔
        #    nodes:
        #    max-redirects:
        # sentinel:
        #哨兵服务器，以“,”分隔
        #     nodes
        #    ...

二、动态读取配置文件

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * redis自动配置
 * @author Jang
 *
 */
@ConfigurationProperties(prefix="spring.redis")
public class RedisProperties {
	//模式
	private String mode;
	//Matser的ip地址  
	private String hostName;
	//端口号
	private Integer port;
	private String password;
	
	private Integer timeout;
	private Integer  maxIdle;
	//private String maxActive;
	private Integer  maxTotal;
	
	private Integer  maxWaitMillis;
	
	private Integer  minEvictableIdleTimeMillis;
	
	private Integer  numTestsPerEvictionRun;
	
	private long timeBetweenEvictionRunsMillis;
	
	private boolean  testOnBorrow;
	private boolean  testWhileIdle;
	//集群配置
	@Value("${cluster.nodes}")
	private String nodes;
	@Value("${cluster.max-redirects}")
	private Integer max_redirects;
	
	//哨兵配置
	
	

		
}

三、Redis工厂，以不同模式连接服务器

import java.util.HashSet;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import redis.clients.jedis.JedisPoolConfig;


@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
	private static final Logger logger = LoggerFactory.getLogger(RedisAutoConfiguration.class);
	
	/**
	 * Redis连接模式：
	 * ALONE：单机
	 * CLUSTER：集群
	 * SENTINEL：哨兵
	 */
	public static String ALONE="ALONE";
	public static String CLUSTER="CLUSTER";
	public static String SENTINEL="SENTINEL";
	
	
	@Autowired
	private RedisProperties redisProperties;
	
	/**
	 * JedisPoolConfig 连接池
	 * @return
	 */
	@Bean
	public JedisPoolConfig  jedisPoolConfig() {
		JedisPoolConfig jedisPoolConfig =new JedisPoolConfig();
		 // 最大空闲数
		if(redisProperties.getMaxIdle()>0) {
			jedisPoolConfig.setMaxIdle(redisProperties.getMaxIdle());
			logger.info("setMaxIdle --->"+redisProperties.getMaxIdle());
		}
        // 连接池的最大数据库连接数
		if(redisProperties.getMaxTotal()>0) {
			jedisPoolConfig.setMaxTotal(redisProperties.getMaxTotal());
		}
        // 最大建立连接等待时间
		if(redisProperties.getMaxWaitMillis()>0) {
			 jedisPoolConfig.setMaxWaitMillis(redisProperties.getMaxWaitMillis());
		}
        // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
		if(redisProperties.getMinEvictableIdleTimeMillis()>0) {
			jedisPoolConfig.setMinEvictableIdleTimeMillis(redisProperties.getMinEvictableIdleTimeMillis());
		}
        // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
        jedisPoolConfig.setNumTestsPerEvictionRun(redisProperties.getNumTestsPerEvictionRun());
        // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(redisProperties.getTimeBetweenEvictionRunsMillis());
        // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
        jedisPoolConfig.setTestOnBorrow(redisProperties.isTestOnBorrow());
        // 在空闲时检查有效性, 默认false
        jedisPoolConfig.setTestWhileIdle(redisProperties.isTestWhileIdle());
		
		
		return jedisPoolConfig;
	}
	 /**
     * Redis集群的配置
    * @return RedisClusterConfiguration
    * @throws
     */
    @Bean
    public RedisClusterConfiguration redisClusterConfiguration(){
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        //Set<RedisNode> clusterNodes
        String clusterNodes=redisProperties.getNodes();
        logger.info("setClusterNodes-------->"+clusterNodes);
        String[] serverArray = clusterNodes.split(",");

        Set<RedisNode> nodes = new HashSet<RedisNode>();

        for(String ipPort:serverArray){
            String[] ipAndPort = ipPort.split(":");
            nodes.add(new RedisNode(ipAndPort[0].trim(),Integer.valueOf(ipAndPort[1])));
        }

        redisClusterConfiguration.setClusterNodes(nodes);
        redisClusterConfiguration.setMaxRedirects(redisProperties.getMax_redirects());

        return redisClusterConfiguration;
    }
    /**
     * 配置redis的哨兵
    * @return RedisSentinelConfiguration
    * @throws
     */
    @Bean
    public RedisSentinelConfiguration sentinelConfiguration(){
        RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
//        //配置matser的名称
//        RedisNode redisNode = new RedisNode(redisProperties.getHostName(), redisProperties.getPort());
//        redisNode.setName("mymaster");
//        redisSentinelConfiguration.master(redisNode);
//        //配置redis的哨兵sentinel
//        RedisNode senRedisNode = new RedisNode(senHost1,senPort1);
//        Set<RedisNode> redisNodeSet = new HashSet<>();
//        redisNodeSet.add(senRedisNode);
//        redisSentinelConfiguration.setSentinels(redisNodeSet);
        return redisSentinelConfiguration;
    }
	/**
	 * 配置工厂
	 * @param jedisPoolConfig
	 * @return
	 */
	@Bean
	public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig,RedisClusterConfiguration redisClusterConfiguration,RedisSentinelConfiguration redisSentinelConfiguration) {
		JedisConnectionFactory jedisConnectionFactory = null;
		//根据模式配置工厂
		//配置单机模式，或模式为空时采用单机模式连接
		if(RedisAutoConfiguration.ALONE.equals(redisProperties.getMode())||redisProperties.getMode()==null) {
			jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
		        //连接池  
			jedisConnectionFactory.setPoolConfig(jedisPoolConfig);  
		        //IP地址  
			jedisConnectionFactory.setHostName(redisProperties.getHostName());  
		        //端口号  
			jedisConnectionFactory.setPort(redisProperties.getPort());  
		        //如果Redis设置有密码  
		        if(redisProperties.getPassword()!=null&&redisProperties.getPassword()!="") {
		        	jedisConnectionFactory.setPassword(redisProperties.getPassword());  
		        }
		        //客户端超时时间单位是毫秒  
		        jedisConnectionFactory.setTimeout(redisProperties.getTimeout());  
		        
			logger.info("redis factory:"+RedisAutoConfiguration.ALONE);
		}else if(RedisAutoConfiguration.CLUSTER.equals(redisProperties.getMode())) {//集群模式
			jedisConnectionFactory = new JedisConnectionFactory(redisClusterConfiguration,jedisPoolConfig);
			logger.info("redis factory:"+RedisAutoConfiguration.CLUSTER);
			
		}else if(RedisAutoConfiguration.SENTINEL.equals(redisProperties.getMode())) {//哨兵模式
			jedisConnectionFactory = new JedisConnectionFactory(redisSentinelConfiguration,jedisPoolConfig);
			logger.info("redis factory:"+RedisAutoConfiguration.SENTINEL);
			
		}
	    return jedisConnectionFactory;
	}
	 /**
     * 实例化 RedisTemplate 对象
     *
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }
    /**
     * 设置数据存入 redis 的序列化方式,并开启事务
     * 
     * @param redisTemplate
     * @param factory
     */
    private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
        //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！  
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 开启事务
        redisTemplate.setEnableTransactionSupport(true);
        redisTemplate.setConnectionFactory(factory);
    }
    /**
     * 注入封装RedisTemplate
    * @Title: redisUtil 
    * @return RedisUtil
    * @throws
     */
    @Bean(name = "redisUtil")
    public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
        RedisUtil redisUtil = new RedisUtil();
        redisUtil.setRedisTemplate(redisTemplate);
        return redisUtil;
    }
}

三、RedisUtil

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

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;

public class RedisUtil {

private RedisTemplate<String, Object> redisTemplate;  

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {  
        this.redisTemplate = redisTemplate;  
    }  
    //=============================common============================  
    /** 
     * 指定缓存失效时间 
     * @param key 键 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean expire(String key,long time){  
        try {  
            if(time>0){  
                redisTemplate.expire(key, time, TimeUnit.SECONDS);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 根据key 获取过期时间 
     * @param key 键 不能为null 
     * @return 时间(秒) 返回0代表为永久有效 
     */  
    public long getExpire(String key){  
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);  
    }  

    /** 
     * 判断key是否存在 
     * @param key 键 
     * @return true 存在 false不存在 
     */  
    public boolean hasKey(String key){  
        try {  
            return redisTemplate.hasKey(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 删除缓存 
     * @param key 可以传一个值 或多个 
     */  
    @SuppressWarnings("unchecked")  
    public void del(String ... key){  
        if(key!=null&&key.length>0){  
            if(key.length==1){  
                redisTemplate.delete(key[0]);  
            }else{  
                redisTemplate.delete(CollectionUtils.arrayToList(key));  
            }  
        }  
    }  

    //============================String=============================  
    /** 
     * 普通缓存获取 
     * @param key 键 
     * @return 值 
     */  
    public Object get(String key){  
        return key==null?null:redisTemplate.opsForValue().get(key);  
    }  

    /** 
     * 普通缓存放入 
     * @param key 键 
     * @param value 值 
     * @return true成功 false失败 
     */  
    public boolean set(String key,Object value) {  
         try {  
            redisTemplate.opsForValue().set(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  

    }  

    /** 
     * 普通缓存放入并设置时间 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 
     * @return true成功 false 失败 
     */  
    public boolean set(String key,Object value,long time){  
        try {  
            if(time>0){  
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);  
            }else{  
                set(key, value);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 递增 
     * @param key 键 
     * @param by 要增加几(大于0) 
     * @return 
     */  
    public long incr(String key, long delta){    
        if(delta<0){  
            throw new RuntimeException("递增因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, delta);  
    }  

    /** 
     * 递减 
     * @param key 键 
     * @param by 要减少几(小于0) 
     * @return 
     */  
    public long decr(String key, long delta){    
        if(delta<0){  
            throw new RuntimeException("递减因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, -delta);    
    }    

    //================================Map=================================  
    /** 
     * HashGet 
     * @param key 键 不能为null 
     * @param item 项 不能为null 
     * @return 值 
     */  
    public Object hget(String key,String item){  
        return redisTemplate.opsForHash().get(key, item);  
    }  

    /** 
     * 获取hashKey对应的所有键值 
     * @param key 键 
     * @return 对应的多个键值 
     */  
    public Map<Object,Object> hmget(String key){  
        return redisTemplate.opsForHash().entries(key);  
    }  

    /** 
     * HashSet 
     * @param key 键 
     * @param map 对应多个键值 
     * @return true 成功 false 失败 
     */  
    public boolean hmset(String key, Map<String,Object> map){    
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * HashSet 并设置时间 
     * @param key 键 
     * @param map 对应多个键值 
     * @param time 时间(秒) 
     * @return true成功 false失败 
     */  
    public boolean hmset(String key, Map<String,Object> map, long time){    
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            if(time>0){  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 向一张hash表中放入数据,如果不存在将创建 
     * @param key 键 
     * @param item 项 
     * @param value 值 
     * @return true 成功 false失败 
     */  
    public boolean hset(String key,String item,Object value) {  
         try {  
            redisTemplate.opsForHash().put(key, item, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 向一张hash表中放入数据,如果不存在将创建 
     * @param key 键 
     * @param item 项 
     * @param value 值 
     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间 
     * @return true 成功 false失败 
     */  
    public boolean hset(String key,String item,Object value,long time) {  
         try {  
            redisTemplate.opsForHash().put(key, item, value);  
            if(time>0){  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 删除hash表中的值 
     * @param key 键 不能为null 
     * @param item 项 可以使多个 不能为null 
     */  
    public void hdel(String key, Object... item){    
        redisTemplate.opsForHash().delete(key,item);  
    }   

    /** 
     * 判断hash表中是否有该项的值 
     * @param key 键 不能为null 
     * @param item 项 不能为null 
     * @return true 存在 false不存在 
     */  
    public boolean hHasKey(String key, String item){  
        return redisTemplate.opsForHash().hasKey(key, item);  
    }   

    /** 
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回 
     * @param key 键 
     * @param item 项 
     * @param by 要增加几(大于0) 
     * @return 
     */  
    public double hincr(String key, String item,double by){    
        return redisTemplate.opsForHash().increment(key, item, by);  
    }  

    /** 
     * hash递减 
     * @param key 键 
     * @param item 项 
     * @param by 要减少记(小于0) 
     * @return 
     */  
    public double hdecr(String key, String item,double by){    
        return redisTemplate.opsForHash().increment(key, item,-by);    
    }    

    //============================set=============================  
    /** 
     * 根据key获取Set中的所有值 
     * @param key 键 
     * @return 
     */  
    public Set<Object> sGet(String key){  
        try {  
            return redisTemplate.opsForSet().members(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  

    /** 
     * 根据value从一个set中查询,是否存在 
     * @param key 键 
     * @param value 值 
     * @return true 存在 false不存在 
     */  
    public boolean sHasKey(String key,Object value){  
        try {  
            return redisTemplate.opsForSet().isMember(key, value);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 将数据放入set缓存 
     * @param key 键 
     * @param values 值 可以是多个 
     * @return 成功个数 
     */  
    public long sSet(String key, Object...values) {  
        try {  
            return redisTemplate.opsForSet().add(key, values);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  

    /** 
     * 将set数据放入缓存 
     * @param key 键 
     * @param time 时间(秒) 
     * @param values 值 可以是多个 
     * @return 成功个数 
     */  
    public long sSetAndTime(String key,long time,Object...values) {  
        try {  
            Long count = redisTemplate.opsForSet().add(key, values);  
            if(time>0) expire(key, time);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  

    /** 
     * 获取set缓存的长度 
     * @param key 键 
     * @return 
     */  
    public long sGetSetSize(String key){  
        try {  
            return redisTemplate.opsForSet().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  

    /** 
     * 移除值为value的 
     * @param key 键 
     * @param values 值 可以是多个 
     * @return 移除的个数 
     */  
    public long setRemove(String key, Object ...values) {  
        try {  
            Long count = redisTemplate.opsForSet().remove(key, values);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
    //===============================list=================================  

    /** 
     * 获取list缓存的内容 
     * @param key 键 
     * @param start 开始 
     * @param end 结束  0 到 -1代表所有值 
     * @return 
     */  
    public List<Object> lGet(String key,long start, long end){  
        try {  
            return redisTemplate.opsForList().range(key, start, end);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  

    /** 
     * 获取list缓存的长度 
     * @param key 键 
     * @return 
     */  
    public long lGetListSize(String key){  
        try {  
            return redisTemplate.opsForList().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  

    /** 
     * 通过索引 获取list中的值 
     * @param key 键 
     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推 
     * @return 
     */  
    public Object lGetIndex(String key,long index){  
        try {  
            return redisTemplate.opsForList().index(key, index);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  

    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, Object value) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, Object value, long time) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            if (time > 0) expire(key, time);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, List<Object> value) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, List<Object> value, long time) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            if (time > 0) expire(key, time);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 根据索引修改list中的某条数据 
     * @param key 键 
     * @param index 索引 
     * @param value 值 
     * @return 
     */  
    public boolean lUpdateIndex(String key, long index,Object value) {  
        try {  
            redisTemplate.opsForList().set(key, index, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }   

    /** 
     * 移除N个值为value  
     * @param key 键 
     * @param count 移除多少个 
     * @param value 值 
     * @return 移除的个数 
     */  
    public long lRemove(String key,long count,Object value) {  
        try {  
            Long remove = redisTemplate.opsForList().remove(key, count, value);  
            return remove;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
}

 

丶沐风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring与Redis的整合&&Redis注解式缓存以及Redis雪崩等问题的解决
qq_63492318的博客
10-28 1443
Spring整合Redis步骤、redis注解缓存的三种使用、redis击穿、穿透、雪崩现象以及其解决方案。。。
Spring Cache与Redis结合使用
流水不腐小夏
11-19 1万+
Spring Cache与Redis结合使用 Spring Cache与Redis结合使用 Redis 创建Spring项目 集成Redis Cache部分代码 前不久做了一个需要查询多，更新少的功能，老司机同事建议用Redis来做缓存，同时结合Spring Cache来做，特来总结下。RedisRedis 是一个高性能key-value数据库，个人感觉就像java中的Map，不过比它更加强大。由
SpringBoot整合Redis
热门推荐
我的博客
04-01 2万+
前言 Redis 的优势及特性不必多言，大家应该都知道，那我们就直接进入正题。 Redis 下载地址：https://github.com/MicrosoftArchive/redis/releases redis-desktop-manager 下载地址：https://github.com/uglide/RedisDesktopManager/releases/tag/0.8...
spring boot整合Redis
lan墨的博客
12-31 2339
spring boot整合Redis spring boot与各个中间件的组合在其官方文档上面都有，，这里介绍下两种连接Redis的方式：Jedis、Lettuce。 本次spring boot版本是基于目前的最新版本：2.1.1.RELEASE。 1. 引入相关starter pom.xml里面添加如下依赖 &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;org.sprin..
Redis---------springboot整合Redis实例
lucky
08-04 1万+
之前用SpringBoot+MyBatisPlus+SpringMVC整合搭建了一个基础web开发框架，使用这三个框架搭建出来项目结构非常的清爽，没有过多的配置文件，各个模块之间有清晰的联系，非常适合敏捷开发。 最近学习了Redis这个基于内存的，Key-Value数据形式的高性能数据库，感觉学习了入门之后很简单，没有体会到它具体能干嘛，我就想着使用Redis这个数据库来整合之前搭建的框架，利用
spring boot 集成redis代码
10-26
综上所述，Spring Boot集成Redis主要涉及添加依赖、配置连接信息、注入RedisTemplate以及根据业务需求进行操作。通过这种方式，我们可以充分利用Redis的高效特性，为应用程序提供快速的数据访问和缓存功能。在实际...
SpringBoot集成Redis快速入门Demo
04-05
在本文中，我们将深入探讨如何使用SpringBoot集成Redis进行快速入门。这个Demo旨在展示如何配置SpringBoot项目，以便能够利用Redis进行数据的读、写和删除操作。首先，我们需要了解项目的基本环境设置。 1. **环境...
SpringBoot集成Redis哨兵Demo
02-18
总结来说，SpringBoot集成Redis哨兵提供了一种简单有效的方式，确保应用能够连接到高可用的Redis集群，并在主服务器出现问题时自动切换，保持服务的连续性。通过正确配置和使用，可以显著提升系统的稳定性和可靠性。
Springboot集成Redis操作缓存源码
最新发布
05-08
Redis（Remote Dictionary Server），即远程字典服务，是一个开源的、使用ANSI C语言编写的、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。详细操作可参考：...
Springboot集成Redis操作缓存-源码
05-08
Redis（Remote Dictionary Server），即远程字典服务，是一个开源的、使用ANSI C语言编写的、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。详细可参考 ...
intellj redis 插件
01-25
intellj redis 插件，可以直接在intellj idea中直接访问redis。
SpringBoot集成mybatis+PageHelper分页插件+redis+kafka+SpringCloud(Swagger2+Feign)+shiro权限框架(分布式项目 内含源码)
qq_42258587的博客
02-28 4116
SpringBoot集成mybatis+PegeHelper分页插件+redis+kafka+SpringCloud(Swagger2+Feign)+shiro权限框架(分布式项目 内含源码) 源码网盘下载地址：https://pan.baidu.com/s/1QEeIGrMC1Rc9ScCaOsbIhw 提取码:488z 虽然现在SprignBoot很火，但由于本人任职的公司项目都是采用常规的S...
spring redis组件区别
zlpzlpzyd的专栏
02-13 351
spring redis组件区别
Redis CLuster主备切换、故障转移测试
weixin_40693633的博客
12-22 3274
redis版本5.0.5 测试redis Cluster主备切换、故障转移 下线一个从节点，此时它的主节点打印的日志 集群状态 下线一台主节点，此时它的从节点打印的日志 集群状态 测试主备切换时客户端状态 第一步：查看当前集群状态 可以看到六个节点都是可用状态，其中83.46的6379是81.64上的6380的从节点，计划Kill掉81.64上的6380主节点，然后观察83.46的6379节点日志 第二步：kill掉81.64上的6380 10:11:25：kill掉81.64上的63
spring boot(三)：Spring Boot中Redis的使用
weixin_34228387的博客
08-08 178
spring boot对常用的数据库支持外，对nosql 数据库也进行了封装自动化。 redis介绍 Redis是目前业界使用最广泛的内存数据存储。相比memcached，Redis支持更丰富的数据结构，例如hashes, lists, sets等，同时支持数据持久化。除此之外，Redis还提供一些类数据库的特性，比如事务，HA，主从库。可以说Redis兼具了缓存系统和数据库的一些特性，因此有着丰...
springboot系列 | 与redis整合
菜 头笔记
02-05 3877
项目目录结构 依赖包引入 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http:/
SpringBoot集成Redis
山丘i
12-30 525
根据学生 id 查询学生的功能，先从 redis 缓存中查找，如果找不到，再从数据库中查找，然后放到 redis 缓存中 一、通过 MyBatis 逆向工程生成实体 bean 和数据持久层 具体过程看之前写的 二、在 pom.xml 文件中添加 redis 依赖 完整的pom文件 <?xml version="1.0" encoding="UTF-8"?> <proj...
SpringBoot使用spring-data-redis整合redis
runTimeAgain
07-13 135
pom依赖redis参数配置redis的bean声明
SpringBoot+Redis+mybatisPlus
04-11
至于Redis，Spring Boot通过`spring-boot-starter-data-redis`模块轻松集成。配置Redis连接后，我们可以利用Spring Data Redis库提供的Template或Reactive API进行数据的缓存操作。Redis不仅适用于缓存，还可以用作...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值