springboot 集成redis 集群

最新推荐文章于 2024-06-14 23:41:47 发布
最新推荐文章于 2024-06-14 23:41:47 发布
阅读量859 收藏 1
点赞数
分类专栏： Springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/donkeyboy001/article/details/119547582
版权

maven 依赖

        <!-- redis -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

1.配置文件

#redis 集群节点信息
spring.redis.cluster.nodes=10.3.4.184:6379,10.3.4.184:6380,10.3.4.184:6381,10.3.4.185:6382,10.3.4.185:6383,10.3.4.185:6384
#redis 命令超时时间
spring.redis.commandTimeout=5000
spring.redis.password=
#redis最大连接数
spring.redis.pool.max-total=30
# redis最大空闲连接数
spring.redis.pool.max-idle=10
# redis最小空闲连接数
spring.redis.pool.min-idle=5
# redis 最大活跃时间
spring.redis.pool.max-active=5000
# redis 连接最大等待时间
spring.redis.pool.max-wait=1500
# 每次逐出检查时，逐出的最大数目
spring.redis.pool.numTestsPerEvictionRun=1024
# 逐出扫描的时间间隔（毫秒）如果为负数，则不运行逐出线程，默认-1
spring.redis.pool.timeBetweenEvictionRunsMillis=30000
# 逐出连接的最小空闲时间 默认1800000毫秒（30分钟）
spring.redis.pool.minEvictableIdleTimeMillis=1800000
# 对象空闲多久后逐出，当空闲时间> 该值 且空闲连接 > 最大空闲数 ，不再根据minEvictableIdleTimeMillis 判断
spring.redis.pool.softMinEvictableIdleTimeMills=10000
# 获取连接时检查有效性，默认false
spring.redis.pool.testOnBorrow=true
# 在空闲时检查有效性，默认false
spring.redis.pool.testWhileIdle=true
spring.redis.pool.blockWhenExhausted=false

2.增加配置类，加载配置到配置类RedisConfig.java（@EnableCaching 注解驱动的缓存管理功能 ）

package com.cfcc.bigdata.base.config.redis;

import com.cfcc.bigdata.base.config.cache.AbstractCacheConfig;
import com.cfcc.bigdata.common.base.mto.MessageEntity;
import com.cfcc.bigdata.voucher.thread.MessageQueue;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheManager;
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.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

import java.util.HashMap;
import java.util.Map;

/**
* Created by gzy
*/
@Configuration
@EnableCaching
public class RedisConfig  extends AbstractCacheConfig {

    @Value("${spring.redis.cluster.nodes}")
    private String nodes;

    @Value("${spring.redis.commandTimeout}")
    private int commandTimeout;

    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.pool.max-wait}")
    private long maxWait;

    @Value("${spring.redis.pool.max-active}")
    private long maxActive;

    @Value("${spring.redis.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.pool.numTestsPerEvictionRun}")
    private int numTestsPerEvictionRun;

    @Value("${spring.redis.pool.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRunsMilliss;

    @Value("${spring.redis.pool.minEvictableIdleTimeMillis}")
    private long minEvictableIdleTimeMillis;

    @Value("${spring.redis.pool.softMinEvictableIdleTimeMills}")
    private long softMinEvictableIdleTimeMills;

    @Value("${spring.redis.pool.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${spring.redis.pool.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${spring.redis.pool.blockWhenExhausted}")
    private boolean blockWhenExhausted;



    /*对象池配置*/
    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWait);
        jedisPoolConfig.setMinIdle(minIdle);
        jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMilliss);
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMilliss);
        jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
        jedisPoolConfig.setSoftMinEvictableIdleTimeMillis(softMinEvictableIdleTimeMills);
        jedisPoolConfig.setTestOnBorrow(testOnBorrow);
        jedisPoolConfig.setBlockWhenExhausted(blockWhenExhausted);
        jedisPoolConfig.setTestWhileIdle(testWhileIdle);

        return jedisPoolConfig;

    }

   /* @Bean
    public JedisCluster getJedisCluster() {
        String[] nNodes = nodes.split(",");
        Set<HostAndPort> nodes = new HashSet<>();
        //分割集群节点
        for (String node : nNodes) {
            String[] hp = node.split(":");
            nodes.add(new HostAndPort(hp[0], Integer.parseInt(hp[1])));
        }

        return new JedisCluster(nodes, commandTimeout,jedisPoolConfig());

    }*/

    /**
     *  通过反射获取JedisCluster
     * @param factory
     * @return
     */
   @Bean
   public JedisCluster redisCluster(RedisConnectionFactory factory) {
       Object obj = null;
       try {
           obj = getFieldValueByObject(factory, "cluster");
       } catch (Exception e) {

       }
       return (JedisCluster)obj;
   }

    @Bean(name = "clusterConfig")
    public RedisClusterConfiguration clusterConfig() {

        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        String[] nNodes = nodes.split(",");
        //分割集群节点
        for (String node : nNodes) {
            String[] hp = node.split(":");
            RedisNode redis = new RedisNode(hp[0], Integer.parseInt(hp[1]));
            redisClusterConfiguration.addClusterNode(redis);
        }

        return redisClusterConfiguration;

    }


    @Bean(name = "factory")
    public RedisConnectionFactory jedisConnectionFactory(RedisClusterConfiguration clusterConfiguration) {
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(clusterConfiguration);
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        jedisConnectionFactory.setTimeout(30000);
        jedisConnectionFactory.setUsePool(true);
        return jedisConnectionFactory;
    }

    /**
     * 自定义RedisTemplate,修改序列化方式
     *
     * @param factory
     * @return
     */
    @Bean(name = "sqlCachRedisTemplate")
    @Primary
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        final StringRedisTemplate redisTemplate = new StringRedisTemplate(redisConnectionFactory);
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setValueSerializer(getJsonSerializer());
        redisTemplate.setHashKeySerializer(redisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean(name = "msgRedisTemplate")
    public RedisTemplate<String, MessageEntity> messageRedisTemplate(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<String, MessageEntity> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        redisTemplate.setHashKeySerializer(redisSerializer);
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setValueSerializer(getJsonSerializer());
        redisTemplate.setHashValueSerializer(getJsonSerializer());
        //开启事务支持，这个事务有点鸡肋不支持回滚
        redisTemplate.setEnableTransactionSupport(true);
        return redisTemplate;
    }

    /**
     * 缓存分页查询的数据
     * @param factory
     * @return
     */
    @Bean(name = "pageCacheRedisTemplate")
    public RedisTemplate<String, Object> redisPageTemplate(RedisConnectionFactory factory) {
        final RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setValueSerializer(getJsonSerializer());
        redisTemplate.setHashKeySerializer(redisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }


    /**
     * 定义Redis的缓存管理器
     * @return
     */
    @Bean
    public CacheManager redisCacheManager(@Qualifier("sqlCachRedisTemplate") RedisTemplate redisTemplate) {
        RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate);
        //设置默认缓存过期时间是7Day
        redisCacheManager.setDefaultExpiration(7 * 24 * 60 * 60);
        Map<String, Long> expiresMap = new HashMap<>();
        //设置sql 的缓存时间　30 M
        expiresMap.put("paramCache", 1800l);
        redisCacheManager.setExpires(expiresMap);

        return redisCacheManager;
    }


    /**
     * 设置数据序列化方式为json
     *
     * @return
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    private Jackson2JsonRedisSerializer<Object> getJsonSerializer() {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        return jackson2JsonRedisSerializer;
    }

AbstractCacheConfig.java （这里对sql 查询结果生成缓存的Key的方法进行了重写 ）

package com.cfcc.bigdata.base.config.cache;

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;

/**
* @author gzy
* @version : 1.0
* @date : 2018/11/17 0017
*/
public abstract class AbstractCacheConfig extends CachingConfigurerSupport {
    /**
     * 继承并修改缓存key的生成方式
     */
    @SuppressWarnings("rawtypes")
    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(".");
                sb.append(method.getName());
                for (Object param : params) {
                    if (param instanceof List) {
                        sb.append("#[");
                        List paramList = (List) param;
                        for (Object paramObj : paramList) {
                            sb.append("&" + ToStringBuilder.reflectionToString(paramObj, ToStringStyle.SHORT_PREFIX_STYLE));
                        }
                        sb.append("]");
                    } else if (param instanceof Map) {
                        sb.append("#[");
                        Map paramMap = (Map) param;
                        for (Object key : paramMap.keySet()) {
                            Object value = paramMap.get(key);
                            sb.append("&");
                            sb.append(ToStringBuilder.reflectionToString(key, ToStringStyle.SHORT_PREFIX_STYLE));
                            sb.append(":");
                            sb.append(ToStringBuilder.reflectionToString(value, ToStringStyle.SHORT_PREFIX_STYLE));
                        }
                        sb.append("]");
                    } else {
                        sb.append("#" + ToStringBuilder.reflectionToString(param, ToStringStyle.SHORT_PREFIX_STYLE));
                    }
                }
                return sb.toString();
            }
        };
    }

    public Object getFieldValueByObject(Object object, String targetFieldName) throws IllegalAccessException {

        // 获取该对象的Class
        Class objClass = object.getClass();
        // 获取所有的属性数组
        Field[] fields = objClass.getDeclaredFields();

        for (Field field : fields) {
            //属性名称
            field.setAccessible(true);
            String currentFieldName = field.getName();
            if (currentFieldName.equals(targetFieldName)) {
                return field.get(object);
            }
        }
        return  null;

    }
}

3.使用缓存（所有的Service 继承此类就可以使用缓存管理功能了）

package com.cfcc.bigdata.common.base.service;

import com.cfcc.bigdata.common.base.helper.PageQueryHelper;
import com.cfcc.bigdata.common.base.vo.PropertyFilter;
import com.cfcc.bigdata.common.base.mybatis.base.BaseMapper;
import com.cfcc.bigdata.common.base.vo.EasyUIDatagridParam;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
* 所有Service的父类，提供通用CURD方法的默认实现。
*
*/
@Transactional
@CacheConfig(cacheNames = "paramCache")
public abstract class BaseCacheService<T extends Serializable> {

    @Autowired
    private BaseMapper<T> mapper;

    /**
     * 根据实体中的属性值进行查询，查询条件使用等号
     *
     * @param record
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public List<T> select(T record) {
        return mapper.select(record);
    }

    /**
     * 根据主键字段进行查询，方法参数必须包含完整的主键属性，查询条件使用等号
     *
     * @param key
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public T selectByPrimaryKey(Object key) {
        return mapper.selectByPrimaryKey(key);
    }

    /**
     * 查询全部结果，select(null)方法能达到同样的效果
     *
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public List<T> selectAll() {
        return mapper.selectAll();
    }

    /**
     * 根据条件分页查询记录列表
     *
     * @param page
     *            当前页码
     * @param rows
     *            每页记录数
     * @param record
     *            条件对象
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public PageInfo<T> selectPage(Integer page, Integer rows, T record) {
        PageHelper.startPage(page, rows);
        List<T> list = mapper.select(record);
        return new PageInfo<>(list);

    }

    /**
     * 根据条件分页查询记录列表
     *
     * @param page
     *            当前页码
     * @param rows
     *            每页记录数
     * @param example
     *            条件对象
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public PageInfo<T> selectPageByExample(Integer page, Integer rows, Example example) {
        PageHelper.startPage(page, rows);
        List<T> list = mapper.selectByExample(example);
        return new PageInfo<>(list);
    }

    /**
     * 根据实体中的属性进行查询，只能有一个返回值，有多个结果是抛出异常，查询条件使用等号
     *
     * @param record
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public T selectOne(T record) {
        return mapper.selectOne(record);
    }

    /**
     * 根据实体中的属性查询总数，查询条件使用等号
     *
     * @param record
     * @return
     */
    @Transactional(readOnly = true)
    public int selectCount(T record) {
        return mapper.selectCount(record);
    }

    /**
     * 根据主键字符串进行查询，类中只有存在一个带有@Id注解的字段
     * <p>
     * 通过操作ids字符串进行操作，ids 如 "1,2,3" 这种形式的字符串，这个方法要求实体类中有且只有一个带有@Id注解的字段，否则会抛出异常
     * </p>
     *
     * @param ids
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public List<T> selectByIds(String ids) {
        if (ids != null && !"".equals(ids)) {
            List<T> list = new ArrayList<>();
            String[] idArray = ids.split(",");
            for (String id : idArray) {
                list.add(mapper.selectByPrimaryKey(id));
            }
            return list;
        }
        return Collections.emptyList();
    }

    /**
     * 根据Example条件进行查询
     * <p>
     * 重点：这个查询支持通过Example类指定查询列，通过selectProperties方法指定查询列
     * </p>
     *
     * @param example
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public List<T> selectByExample(Object example) {
        return mapper.selectByExample(example);
    }

    /**
     * 根据Example条件进行查询总数
     *
     * @param example
     * @return
     */
    @Transactional(readOnly = true)
    public int selectCountByExample(Object example) {
        return mapper.selectCountByExample(example);
    }

    /**
     * 根据通用条件进行分页查询
     *
     * @param param
     *            easyui传来的参数信息
     * @param filters
     *            通用条件对象
     * @param entityClass
     *            查询的实体对象类型
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public PageInfo<T> selectEasyUIPageByFilters(final EasyUIDatagridParam param, final List<PropertyFilter> filters, Class<?> entityClass) {
        PageQueryHelper pageQueryHelper = new PageQueryHelper();
        Example example = pageQueryHelper.generateExampleByFilters(param, filters, entityClass);
        return selectPageByExample(param.getPage(), param.getRows(), example);
    }

    /**
     * 根据通用条件查询所有符合条件记录
     *
     * @param param
     *            easyui传来的参数信息
     * @param filters
     *            通用条件对象
     * @param entityClass
     *            查询的实体对象类型
     * @return
     */
    @Cacheable
    @Transactional(readOnly = true)
    public List<T> selectEasyUIAllByFilters(final EasyUIDatagridParam param, final List<PropertyFilter> filters, Class<?> entityClass) {
        PageQueryHelper pageQueryHelper = new PageQueryHelper();
        Example example = pageQueryHelper.generateExampleByFilters(param, filters, entityClass);
        return mapper.selectByExample(example);
    }

    /**
     * 保存一个实体，null的属性也会保存，不会使用数据库默认值
     * beforeInvocation　在执行ｓｑｌ之前清除缓存
     * @param record
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int insert(T record) {
        return mapper.insert(record);
    }

    /**
     * 保存一个实体，null的属性不会保存，会使用数据库默认值
     *
     * @param record
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int insertSelective(T record) {
        return mapper.insertSelective(record);
    }

    /**
     * 批量插入，支持批量插入的数据库可以使用，例如MySQL,H2等
     *
     * @param recordList
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int insertList(List<T> recordList) {
        return mapper.insertListUseAllCols(recordList);
    }

    /**
     * 根据主键更新实体全部字段，null值会被更新
     *
     * @param record
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int updateByPrimaryKey(T record) {
        return mapper.updateByPrimaryKey(record);
    }

    /**
     * 根据主键更新属性不为null的值
     *
     * @param record
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int updateByPrimaryKeySelective(T record) {
        return mapper.updateByPrimaryKeySelective(record);
    }

    /**
     * 根据Example条件更新实体record包含的全部属性，null值会被更新
     *
     * @param record
     * @param example
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int updateByExample(T record, Object example) {
        return mapper.updateByExample(record, example);
    }

    /**
     * 根据Example条件更新实体record包含的不是null的属性值
     *
     * @param record
     * @param example
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int updateByExampleSelective(T record, Object example) {
        return mapper.updateByExampleSelective(record, example);
    }
    
    /**
     * 批量更新
     *
     * @param recordList
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public void updateList(List<T> recordList) {
        for(T t : recordList) {
            mapper.updateByPrimaryKey(t);
        }
    }

    /**
     * 根据实体属性作为条件进行删除，查询条件使用等号
     *
     * @param record
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int delete(T record) {
        return mapper.delete(record);
    }

    /**
     * 根据主键字符串进行删除，类中只有存在一个带有@Id注解的字段
     * <p>
     * 通过操作ids字符串进行操作，ids 如 "1,2,3" 这种形式的字符串，这个方法要求实体类中有且只有一个带有@Id注解的字段，否则会抛出异常
     * </p>
     *
     * @param ids
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int deleteByIds(String ids) {
        if (ids != null && !"".equals(ids)) {
            String[] idArray = ids.split(",");
            for (String id : idArray) {
                mapper.deleteByPrimaryKey(id);
            }
            return idArray.length;
        }
        return 0;
    }

    /**
     * 根据主键字段进行删除，方法参数必须包含完整的主键属性
     *
     * @param key
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int deleteByPrimaryKey(Object key) {
        return mapper.deleteByPrimaryKey(key);
    }

    /**
     * 根据Example条件删除数据
     *
     * @param example
     * @return
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public int deleteByExample(Object example) {
        return mapper.deleteByExample(example);
    }
    
    /**
     * 刷新缓存
     */
    @CacheEvict(beforeInvocation = true, allEntries = true)
    public void reload() {

    }
}

独行客-编码爱好者
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springboot整合redis
P_YUX的博客
11-30 285
注解标签 @Configuration @Configuration底层是含有@Component ，所以@Configuration 具有和 @Component 的作用。 @Configuration可理解为用spring的时候xml里面的标签。 注： 1) 配置类必须以类的形式提供（不能是工厂方法返回的实例），允许通过生成子类在运行时增强（cglib 动态代理）。 2) 配置...
SpringBoot整合redis使用指南
自救 唯有自强
11-05 266
文章目录一、下载redis及redis可视化工具RedisDesktopManager二、引入依赖POM YML三、建立redis配置类四、在controller中的使用五、关于可视化工具RedisDesktopManager 一、下载redis及redis可视化工具RedisDesktopManager ​ redis的话下载解压版就行了、可视化工具直接百度就可，是免费的。 这里贴一个redis的下载地址：https://github.com/MicrosoftArchive/redis/r
springboot使用redis
aici0819的博客
10-07 168
概述 springboot通常整合redis,采用的是RedisTemplate的形式,除了这种形式以外,还有另外一种形式去整合,即采用spring支持的注解进行访问缓存. 准备工作 pom.xml 1 <dependency> 2 <groupId>redis.clients</groupId>...
如何使用Spring Boot框架整合Redis：超详细案例教程
最新发布
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
06-14 3110
成功在 Spring Boot 项目中整合了 Redis 并配置了连接池。我们使用连接池可以显著提高 Redis 操作的性能和资源管理效率。启动应用程序后，可以选中通过 Postman 或浏览器访问以下 URL，验证 Redis 操作是否成功。保持 Redis 操作类和控制器不变。它们已经实现了基本的 Redis 操作。是用于 Lettuce 连接池配置的依赖。目录下，添加 Redis 连接池的配置。确保你的项目包含了以下依赖。，这里就无需再次添加。类以支持连接池即可。
Spring+Redis Cluster3.0.x
z69183787的专栏
07-03 1057
Redis 3.0集群搭建方法：     http://hot66hot.iteye.com/blog/2050676 Redis 3.0.x使用方法 1.Maven依赖 dependency> groupId>redis.clientsgroupId> artifactId>jedisartifactId> version>2.7.2version> dependency>
springboot之redis客户端配置
weixin_39648534的博客
07-30 752
Jedis配置 #Redis服务器地址 spring.redis.host=127.0.0.1 #Redis服务器连接密码（默认为空） spring.redis.password=123456 #Redis服务器连接端口 spring.redis.port=6379 #连接超时时间（毫秒） spring.redis.timeout=3000 #redis 连接池配置 #池中最大链接数 spring...
SpringBoot集成Redis集群
09-28
SpringBoot集成Redis集群 在本文档中，我们将指导您如何在SpringBoot 2.X中集成Redis集群。下面是相关的知识点： 集成Redis集群的必要性 在实际应用中，使用Redis集群可以提高系统的可扩展性和可靠性。Redis集群...
springboot集成redis集群,redis安装包配置
09-02
在本文中，我们将深入探讨如何在SpringBoot应用中集成Redis集群以及如何配置Redis服务器。首先，Redis是一个开源的、基于键值对的数据存储系统，常用于数据库、缓存和消息中间件。它以其高性能和易用性而备受青睐。...
springboot整合redis集群零配置
07-28
首先，让我们来看看"Springboot整合Redis集群,零配置方式"。在Spring Boot中，我们可以通过引入`spring-boot-starter-data-redis`依赖来启用Redis支持。但是，要配置Redis集群，通常需要设置多个节点地址、密码、...
SpringBoot集成Redis集群就这么Easy
01-06
这次写一下springboot与redis的结合，这里使用的是redis集群模式（主从），主从环境的搭建，请参考redis集群搭建 搭建完redis集群环境后，开始springboot之旅 1、REDIS介绍 redis的介绍及应用场景参考 redis介绍 2、...
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
SpringBoot整合Redis
Davie's Happy Life
09-12 328
前言 在本篇文章中将SpringBoot整合Redis，使用的是RedisTemplate，分别实现了SpringBoot与redis的单机版、集群版、哨兵模式的整合。 Maven依赖 &lt;!-- 整合redis --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&l...
SpringBoot整合Redis——两种方式（Jedis、RedisTemplate）
linchaoyang_的博客
05-18 9742
前言 redis是一种nosql数据库，以<key，value>的形式存储数据，其速度相比于MySQL之类的数据库，相当于内存读写与硬盘读写的差别，所以常常用作缓存。接下来就分别看看在springboot项目中如何使用redis 本篇基于SpringBoot + Redis实现数据缓存以及分库存储，首先我们要知道，SpringBoot整合Redis有两种方式，分别是Jedis和RedisTemplate，这两者有何区别？ Jedis是Redis官方推荐的面向Java的操作Redis的客户端
配置Redis踩坑合集
WC949464367的博客
04-17 830
之前我已在docker中配置好Redis,学习了一些redis的基本操作 redis是map的形式存储键值，相比于mysql来说，消耗内存更小，更加轻量级。 1.配置文件redis.conf出错。这个文件我在上一篇文章里面附上了。 2.配置初始密码，也写在原来的配置文件中了 3.JAVA结合redis，这里如果redis配置过密码的话，在建立jedis对象后，需要添加代码 jedis.auth("123456"); jedis所需要的依赖如下 <dependency&gt
连接池中的maxIdle,MaxActive,maxWait参数
热门推荐
生命不息，折腾不止
07-17 4万+
name：表示你的连接池的名称也就是你要访问连接池的地址 auth：是连接池管理权属性，Container表示容器管理 type：是对象的类型 driverClassName：是数据库驱动的名称 url：是数据库的地址 username：是登陆数据库的用户名 password：是登陆数据库的密码 maxIdle，最大空闲数，数据库连接的最大空闲时间
Redis学习笔记（一）：基础
12-31 313
核心 一、Redis单机多实例原理 每个实例对应不同的配置文件，配置文件对应不同的端口、数据库文件位置、日志位置。 二、Redis单实例多数据库 每个Redis实例都有16个数据库，下标从0-15，当 set 一个数据时，默认添加到 db0，而select 命令可以切换当前使用的数据库，例：select 15 Redis 三、数据库构造 每个数据库相当于一棵树的根节点，子节点可以是Redis定义的...
redis连接池参数
aoxiaojun的博客
01-18 1378
minldle(最小空闲连接数)，与其说是最小空闲连接数，不如说是"至少需要保持的空闲连接数"，在使用连接的过程中，如果连接数超过了minldle，那么继续建立连接，如果超过了maxldle，当超过的连接执行完业务后会慢慢被移出连接池释放掉。，比如快速的创建一些redis连接，执行简单命令，类似ping()，快速的将连接池里的空闲连接提升到minldle的数量。redis初始化的时候，不会自动初始化连接，只有用到的时候，才会初始化。如果系统启动完马上就会有很多的请求过来，那么可以给redis连接池做。
Spring Boot 中Redis的使用
stujike123456的博客
03-14 230
一、引入jar包 引入 spring-boot-starter-redis &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-redis&lt;/artifactId&gt; &lt;/de...
SpringBoot - Redis的整合与使用
鱼的博客
08-18 687
一、Redis 的整合与使用：单 Redis 实例 1，安装配置 （1）首先编辑 pom.xml 文件，添加相关依赖： Spring Boot 借助于 Spring Data Redis 为 Redis 提供了开箱即用的自动化配置，我们只需要添加相关依赖并配置 Redis 连接信息即可。 默认情况下，spring-boot-starter-data-redis 使用的 Redis 工具是 Lettuce。考虑到有的开发者习惯使用 Jedis，这里从 spring-boot-starter-data-red
springboot 集成redis集群
09-01
在Spring Boot项目中，有三种方式可以集成Redis集群，包括使用Jedis、Lettuce和RedisTemplate。 对于Jedis的整合步骤，你需要先导入相应的依赖，包括spring-boot-starter-data-redis和lettuce-core。然后，你可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

独行客-编码爱好者

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

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

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

打赏作者

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

抵扣说明：

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

余额充值