spring cache 配置 基于 redis

最新推荐文章于 2024-08-03 21:02:21 发布
最新推荐文章于 2024-08-03 21:02:21 发布
阅读量470 收藏 1
点赞数
分类专栏： java 文章标签： java redis 缓存 spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41839782/article/details/113370019
版权

一 : spring cache 配置 基于 redis

1: 添加pom依赖
<dependency>  
   <groupId>org.springframework.data</groupId>  
   <artifactId>spring-data-redis</artifactId>  
   <version>1.6.0.RELEASE</version>  
</dependency>
2:配置文件指定缓存使用redis
spring:
  cache:
    type: redis
3:RedisCacheManager配置
/**
 * 可以自动设置失效时间的RedisCacheManager
 * 失效时间设置规则 @Cacheable(cacheNames = "redisKey(10)S")
 * (为cacheNames 与自定义失效时间的分隔符
 * )为失效时间值与单位的分隔符
 *
 * @Author sjf
 * @Date 2021/01/21
 **/
@Slf4j
public class ExpireTimeRedisCacheManager extends RedisCacheManager {
    protected ExpireTimeRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter, defaultCacheConfiguration);
    }

    /**
     * 生成缓存配置
     * @param name        设置的缓存名称（完整配置的例子users#10_SECONDS）
     * @param cacheConfig redis缓存配置
     * @return
     */
    @Override
    protected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {
        name = GoodsRedisConst.PREFIX.concat(name);
        if (StringUtils.isBlank(name)) {
            return super.createRedisCache(name, cacheConfig);
        }
        String[] nameSplits = name.split(GoodsRedisConst.NAME_TIME_CONFIG_SEPARATOR);
        if (ArrayUtils.isNotEmpty(nameSplits) && 1 == nameSplits.length) {
            log.info("get default ttl unit mills {}", cacheConfig.getTtl());
            return super.createRedisCache(name, cacheConfig);
        }
        String finalName = nameSplits[0];
        String ttlTimeConfig = nameSplits[1];
        String[] ttlTimeConfigSplits = ttlTimeConfig.split(GoodsRedisConst.TTL_TIME_SEPARATOR);
        if (ArrayUtils.isEmpty(ttlTimeConfigSplits) || 2 != ttlTimeConfigSplits.length) {
            log.info("ttl time config {} is invalid!", ttlTimeConfig);
            return super.createRedisCache(finalName, cacheConfig);
        }
        try {
            Long time = Long.parseLong(ttlTimeConfigSplits[0]);
            TimeUnit timeUnit = getTimeUnitByName(ttlTimeConfigSplits[1].toUpperCase());
            Duration ttl = getAndAddRandomSeconds(time, timeUnit);
            RedisCacheConfiguration newTtlRedisCacheConfiguration = cacheConfig.entryTtl(ttl);
            return super.createRedisCache(finalName, newTtlRedisCacheConfiguration);
        } catch (Exception e) {
            log.warn("get ttl time config error!", e);
        }
        return super.createRedisCache(finalName, cacheConfig);
    }

    /**
     * 时间单位转换
     * @param name
     * @return
     */
    private TimeUnit getTimeUnitByName(String name){
        if ("d".equals(name) || "D".equals(name)){
            return TimeUnit.DAYS;
        }else if ("h".equals(name) || "H".equals(name)){
            return TimeUnit.HOURS;
        }else if ("m".equals(name) || "M".equals(name)){
            return TimeUnit.MINUTES;
        }else if ("s".equals(name) || "S".equals(name)){
            return TimeUnit.SECONDS;
        }else {
            return TimeUnit.SECONDS;
        }
    }

    /**
     * 获取ttl失效时间并且随机增加毫秒数
     * @param time 时间 time
     * @param timeUnit  单位 unit
     * @return
     */
    public Duration getAndAddRandomSeconds(Long time, TimeUnit timeUnit) {
        long seconds;
        switch (timeUnit) {
            case SECONDS:
                seconds = time;
                break;
            case MILLISECONDS:
                seconds = TimeUnit.MILLISECONDS.toSeconds(time);
                break;
            case HOURS:
                seconds = TimeUnit.HOURS.toSeconds(time);
                break;
            case MINUTES:
                seconds = TimeUnit.MINUTES.toSeconds(time);
                break;
            case DAYS:
                seconds = TimeUnit.DAYS.toSeconds(time);
                break;
            default:
                seconds = TimeUnit.SECONDS.toSeconds(time);
                break;
        }
        // 随机增加失效秒数，避免同一时间集体失效
        long secondsWithRandom = seconds + GoodsRedisConst.EXPIRE_RANDOM.nextInt(100);
        return Duration.ofSeconds(secondsWithRandom);
    }
}
4:指定 key的生成策略,全局异常处理 redisTemplate配置cacheManager配置
/**
 * @author sjf
 * @description
 * @date 2021/1/21
 **/
@Configuration
@Slf4j
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisCacheAutoConfiguration extends CachingConfigurerSupport {

    /**
     * redis FastJson序列化
     */
    @Bean
    @ConditionalOnMissingBean(value = RedisSerializer.class)
    public RedisSerializer<Object> redisSerializer() {
        return new GenericFastJsonRedisSerializer();
    }

    /**
     * 设置自定义序列化的RedisTemplate
     *
     * @param redisConnectionFactory
     * @param redisSerializer        序列化
     * @return
     */
    @Bean
    @ConditionalOnMissingBean(RedisTemplate.class)
    public RedisTemplate<String, Object> redisTemplate(@Autowired RedisConnectionFactory redisConnectionFactory,
                                                       @Autowired RedisSerializer<Object> redisSerializer) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        // key，hash key使用String序列化
        RedisSerializer<String> stringRedisSerializer = RedisSerializer.string();
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setKeySerializer(stringRedisSerializer);
        // value，hash value设置FastJson序列化
        template.setHashValueSerializer(fastJsonRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    /**
     * 配置 spring cache manager RedisCacheManager
     */
    @Bean
    @ConditionalOnMissingBean(value = CacheManager.class)
    public CacheManager cacheManager(@Autowired RedisConnectionFactory redisConnectionFactory) {

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        // 设置缓存的默认过期时间
        config = config.entryTtl(Duration.ofSeconds(GoodsRedisConst.DEFAULT_TIME))
                // 不缓存空值
                .disableCachingNullValues();
        RedisCacheManager cacheManager = new ExpireTimeRedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory), config);
        return cacheManager;
    }


    /**
     * 重写key的生成策略（）
     * @return
     */
    @Bean
    @ConditionalOnMissingBean(KeyGenerator.class)
    @Override
    public KeyGenerator keyGenerator() {
        return (o, method, objects) -> {
            StringBuilder stringBuilder = new StringBuilder();
            /**
             * //获取类目类目
             * stringBuilder.append(o.getClass().getSimpleName());
             * stringBuilder.append(".");
             * //获取方法名
             * stringBuilder.append(method.getName());
             * stringBuilder.append(":");
             */
            //请求参数数组
            for (Object obj : objects) {
                if (obj != null && obj.toString().contains("=")) {
                    HashMap<String, Object> hashMap = JSON.parseObject(JSON.toJSONString(obj), HashMap.class);
                    hashMap.forEach((k, v) -> {
                        stringBuilder.append(k + ":" + v + ":");
                    });
                }else {
                    stringBuilder.append(obj + ":");
                }
            }
            StringBuilder redisKey = stringBuilder.deleteCharAt(stringBuilder.length() - 1);
            log.info("redisKey============{}",redisKey);
            return redisKey;
        };
    }


    /**
     * redis数据操作异常处理 这里的处理：在日志中打印出错误信息，但是放行
     * 保证redis服务器出现连接等问题的时候不影响程序的正常运行，使得能够出问题时不用缓存
     * @return
     */
    @Bean
    @Override
    public CacheErrorHandler errorHandler() {
        CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {

            @Override
            public void handleCachePutError(RuntimeException exception, Cache cache,
                                            Object key, Object value) {
                RedisErrorException(exception, key);
            }

            @Override
            public void handleCacheGetError(RuntimeException exception, Cache cache,
                                            Object key) {
                RedisErrorException(exception, key);
            }

            @Override
            public void handleCacheEvictError(RuntimeException exception, Cache cache,
                                              Object key) {
                RedisErrorException(exception, key);
            }

            @Override
            public void handleCacheClearError(RuntimeException exception, Cache cache) {
                RedisErrorException(exception, null);
            }
        };
        return cacheErrorHandler;
    }

    protected void RedisErrorException(Exception exception,Object key){
        log.error("redis异常：key=[{}]", key, exception);
    }
}
5:缓存配置
public class GoodsRedisConst {

    /**
     * 全局RedisKey 前缀
     */
    public static final String PREFIX = "GD:";
    public static final String NAME_TIME_CONFIG_SEPARATOR = "\\(";
    public static final String TTL_TIME_SEPARATOR = "\\)";
    /**
     * 默认过期时间
     */
    public static final Long DEFAULT_TIME = 5 * 60L;
    public static Random EXPIRE_RANDOM = getInstanceC();
    public static Random getInstanceC() {
        // 先判断实例是否存在，若不存在再对类对象进行加锁处理
        if (EXPIRE_RANDOM == null) {
            synchronized (Random.class) {
                if (EXPIRE_RANDOM == null) {
                    EXPIRE_RANDOM = new Random();
                }
            }
        }
        return EXPIRE_RANDOM;
    }
}

二:注解详解

1. @Cacheable
1.1 使用场景

最常用的注解，将注解方法的返回值缓存。

工作原理是：首先在缓存中查找，如果没有执行方法并缓存结果，然后返回数据。此注解的缓存名必须指定

示例:

    @Override
    @Cacheable(value = {"idKey(600)s"},keyGenerator = "keyGenerator",condition = "#g.id.equals(1L)")
    public GoodsInfo getGoodsInfo(GoodsInfo g) {
        GoodsInfo goodsInfo = new GoodsInfo();
        goodsInfo.setCategoryId(1L);
        goodsInfo.setCategoryName("缓存测试");
        goodsInfo.setId(1L);
        System.err.println("没有命中缓存");
        if (g.getId().equals(goodsInfo.getId())){
            return goodsInfo;
        }
        goodsInfo.setCategoryName("不走缓存");
        return goodsInfo;
    }

    value、cacheNames
    缓存的名称，在 spring 配置文件中定义，必须指定至少一个
    例如: @Cacheable(value=”mycache”) @Cacheable(value={”cache1”,”cache2”}
    扩展后可以添加缓存过期时间
    设置的缓存名称（完整配置的例子 redisKey(10)s）
 		单位(不区分大小写)  s:seconds(秒)  m:minutes(分钟)  h:hours(小时)  d:days(天)

    key
    缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合
    例如: @Cacheable(value=”testcache”,key=”#userName”)

    condition
    缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存
    例如：@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
1.2 常用参数
  • value 等价于name 缓存中的命名空间
  • cacheNames 缓存中的命名空间 等价于value
  • cacheManager 使用哪一个缓存管理器
  • key 生成key值,与keyGenerator互斥,支持SpEL表达式,当我们没有指定该属性时,Spring将使用默认生成策略生成key值
  • keyGenerator key的生成策略是一个对象，可以使用默认的生成策略，也可以自定义生成策略
  • condition 缓存生成条件 支持SpEL表达式
  • unless 不生成缓存条件 支持SpEL表达式
1.3 默认生成策略

默认的key生成策略是通过KeyGenerator生成的，其默认策略如下：

  • 如果方法没有参数，则使用0作为key。

  • 如果只有一个参数的话则使用该参数作为key。

  • 如果参数多余一个的话则使用所有参数的hashCode作为key。

  • 下面重写了缓存 key 生成策略,也可以自定义缓存生成策略,然后通过keyGenerator = "keyGenerator"指定自己的 key 生成策略

    		/**
     * 重写key的生成策略（）
     * @return
     */
    @Bean
    @ConditionalOnMissingBean(KeyGenerator.class)
    @Override
    public KeyGenerator keyGenerator() {
        return (o, method, objects) -> {
            StringBuilder stringBuilder = new StringBuilder();
            /**
             * //获取类名
             * stringBuilder.append(o.getClass().getSimpleName());
             * stringBuilder.append(".");
             * //获取方法名
             * stringBuilder.append(method.getName());
             * stringBuilder.append(":");
             */
            //请求参数数组
            for (Object obj : objects) {
                if (obj != null && obj.toString().contains("=")) {
                    HashMap<String, Object> hashMap = JSON.parseObject(JSON.toJSONString(obj), HashMap.class);
                    hashMap.forEach((k, v) -> {
                        stringBuilder.append(k + ":" + v + ":");
                    });
                }else {
                    stringBuilder.append(obj + ":");
                }
            }
            StringBuilder redisKey = stringBuilder.deleteCharAt(stringBuilder.length() - 1);
            log.info("redisKey============{}",redisKey);
            return redisKey;
        };
    }
2. @CacheEvict
2.1 使用场景

常用注解，将@Cacheable缓存清除

示例:

    @CacheEvict(value = "idKey(600)s",beforeInvocation = false,allEntries = false)
    public void getGoodsInfoDel(GoodsInfo g) {

    }
    value
    缓存的名称，在 spring 配置文件中定义，必须指定至少一个
    例如: @CacheEvict(value=”my cache”)

    key
    缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合
    例如: @CacheEvict(value=”testcache”,key=”#userName”)

    condition
    缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存
    例如: @CacheEvict(value=”testcache”,condition=”#userName.length()>2”)

    allEntries
    是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存
    例如: @CachEvict(value=”testcache”,allEntries=true)

    beforeInvocation
    是否在方法执行前就清空，缺省为 false，如果指定为 true，则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法执行抛出异常，则不会清空缓存
    例如: @CachEvict(value=”testcache”，beforeInvocation=true)
2.2 常用参数
  • value 等价于name 缓存中的命名空间
  • cacheNames 缓存中的命名空间 等价于value
  • cacheManager 使用哪一个缓存管理器
  • key 生成key值 与keyGenerator互斥,支持SpEL表达式,当我们没有指定该属性时,Spring将使用默认生成策略生成key值
  • keyGenerator key的生成策略是一个对象，可以使用默认的生成策略，也可以自定义生成策略
  • condition 缓存清除条件 支持SpEL表达式
  • allEntries 是否清除所有缓存 默认:false(根据 value 中的值匹配)
  • beforeInvocation 方法调用前清除还是之后清除 默认:false (调用后清除)
3. @CachePut
3.1 使用场景

常用注解，用于在update和insert场景，在更新/添加之后，更新缓存值

示例:

    @CachePut(value = "idKey(600)s",
            key = "'id:'.concat(#goodsInfo.id).concat(':creatorId:').concat(#goodsInfo.creatorId)")
    public GoodsInfo getByIdUpdate(GoodsInfo g) {
        g.setCategoryId(1L);
        g.setCategoryName("修改缓存");
        g.setId(1L);
        return g;
    }
3.1 常用参数
  • value 等价于name 缓存中的命名空间
  • cacheNames 缓存中的命名空间 等价于value
  • cacheManager 使用哪一个缓存管理器
  • key 生成key值,与keyGenerator互斥,支持SpEL表达式,当我们没有指定该属性时,Spring将使用默认生成策略生成key值
  • keyGenerator key的生成策略是一个对象，可以使用默认的生成策略，也可以自定义生成策略
  • condition 缓存生成条件 支持SpEL表达式
  • unless 不生成缓存条件 支持SpEL表达式
4. @Caching
4.1 使用场景

用于多种普通注解组合,因为同一个方法只能使用一个相同注解，为了解决这个问题，引入了@caching注解

示例:

    @Caching(evict = {
            @CacheEvict(value = "queryMasterOrderDetail", key = "'queryMasterOrderDetail~'+ #orderNum", cacheManager = "shortCacheManager"),
            @CacheEvict(value = "queryCustomerBuildingAccountByOrderNum", key = "'queryCustomerBuildingAccountByOrderNum~' + #orderNum")
    })
    public Integer deleteOrderAccount(Long orderNum) {
        
    }
4.2 常用参数
  • cacheable 多个@Cacheable组合使用
  • put 多个@CachePut组合使用
  • evict 多个@CacheEvict组合使用

三: SpEL表达式

1. 基础
名字位置描述示例
methodNameroot对象当前被调用的方法名#root.methodName
methodroot对象当前被调用的方法#root.method
targetroot对象当前被调用的目标对象#root.target
targetClassroot对象当前被调用的目标对象类#root.targetClass
argsroot对象当前被调用的方法的参数列表#root.args
cachesroot对象当前方法调用使用的缓存列表（如@Cacheable(value={“cache1”, “cache2”})），则有两个cache#root.caches
参数名称执行上下文当前被调用的方法的参数，如findById(Long id)，我们可以通过#id拿到参数#id/#user.id
result执行上下文方法执行后的返回值（仅当方法执行之后的判断有效，如‘unless’，'cache evict’的beforeInvocation=false）#result
2:调用静态方法
//T(org.springframework.util.ObjectUtils).isEmpty(#orderNum)
  
    @CacheEvict(value = "query", key = "'query:'+ #orderNum",
                condition="T(org.springframework.util.ObjectUtils).isEmpty(#orderNum)")
    public Integer deleteOrderAccount(Long orderNum) {
        ...
    }

3:正则匹配

    @CacheEvict(value = "query", key = "'query:' + #orderNum",condition="#orderNum match '\d{6}'")
    public Integer deleteOrderAccount(Long orderNum) {
        ...
    }

四:异常

1:可能出现异常
    返回值强制转换的异常
    java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Long
    默认情况下,redis使用Jackson进行反序列化json，但是json不能告诉Jackson,这个数字是int还是long,所以当数字在小于Integer.MAX_INT时候,Jackson默认将数字序列化成int类型,当int类型数字注入Long型对象则会出现这个错误
jerry1237
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring Cache和redis结合使用
xushuai2333333的博客
09-02 1894
Spring Cache和redis结合使用
Spring Cache手动清理Redis缓存
08-25
Spring Cache手动清理Redis缓存 Spring Cache是Spring框架中的一种缓存机制，它可以将缓存数据存储在Redis中。然而，在某些情况下，我们需要手动清理Redis缓存，以便释放内存空间或更新缓存数据。在本文中，我们将...
Spring Cache及与Redis集成
ShootingStar_1998的博客
12-13 1183
Spring Cache一、什么是Spring Cache二、Springboot下Spring Cache与redis集成2.1 引入依赖2.2 配置redis2.3 缓存配置类RedisConfig2.4 使用 Spring Cache注解 一、什么是Spring Cache Spring Cache是Spring框架提供的对缓存使用的抽象类，支持多种缓存，比如Redis、EHCache等，...
Spring Cache基本使用
Charge8的博客
05-24 1064
Spring Cache基本使用
springBoot springCache redis 配置
ywtech的博客
12-04 1224
1）业务代码中如何使用缓存 1.1）注解配置使用redis缓存 快速启用缓存 @Override @Cacheable(value = RUBIK_APPOINTMENT_NEW_UIFLOW_UI_CONFIG, keyGenerator = "simpleSpringCacheKeyGenerator") public TUiFlow getUcUiFlowByprocessDefinition(String processDefinitionid) { TUiF
Spring Cache Redis配置
thebinso的博客
05-23 1199
1.导入cache依赖包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> 2.yml配置 选择Redis作为存储 cache: type: redis redis: #单位毫秒
Spring Cache结合redis使用
weixin_43811057的博客
12-09 993
Spring Cache 整合 Redis 做缓存使用~ 快速上手~Spring源码解析-Spring Cache
Spring Cache + Redis；用Spring Cache的注解自动管理Redis缓存
qq_45839663的博客
10-08 1431
Spring Cache + Redis；用Spring Cache的注解自动管理Redis缓存
使用Spring Cache简化使用Redis缓存
Herman _java开发
12-07 878
Spring Cache是一个框架，实现了基于注解的缓存功能，；只需要简单地加一个注解，就能实现缓存功能。
SpringCache与Redis
wyy的博客
03-25 3180
文章目录SpringCache简介常⽤注解Cacheable自定义CacheManager配置和过期时间自定义缓存KeyGenerator常用注解CachePut 和 CacheEvict多注解组合Caching SpringCache简介 ⽂档：https://spring.io/guides/gs/caching/ ⾃Spring 3.1起，提供了类似于@Transactional注解事务的注解Cache⽀持，且提供了Cache抽象提供基本的Cache抽象，⽅便切换各种底层Cache只需要更少的代码就
【spring cache整合redis】
workhard2的博客
09-11 603
spring cache整合redis，并给key设置过期时间
009-SpringCache基于Redis缓存
学习笔记
12-06 1082
🧑‍🎓 个人主页：Silence Lamb 📖 本章内容：【SpringCache基于Redis缓存】
Spring Cache整合Redis实现方法详解
08-18
Spring Cache整合Redis实现方法详解 Spring Cache是Spring框架中的一种缓存机制，可以帮助开发者快速实现缓存功能，而Redis是当前最流行的NoSQL数据库之一，高性能、持久化、数据类型丰富等特点使其成为当前最流行...
Spring cache整合redis代码实例
08-19
主要介绍了Spring cache整合redis代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Cache使用RedisCache案例解析
08-25
Spring Cache使用RedisCache案例解析 Spring Cache是Spring框架中的一种缓存机制，主要用于优化应用程序的性能和响应速度。通过使用缓存，可以减少对数据库的访问次数，降低系统的负载，提高系统的整体性能。在...
springcache+redis springboot maven
12-18
在这个项目中，"springcache+redis"的整合意味着我们要利用Spring Cache的特性，将缓存存储在Redis中，以提升应用的性能。 首先，Spring Cache提供了`@Cacheable`、`@CacheEvict`和`@Caching`等注解，允许我们在...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 183
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 527
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 520
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Spring Boot Cache 基于redis开发流程
02-11
Spring Boot 缓存基于 Redis 开发流程如下： 1. 引入依赖：在项目的 pom.xml 文件中添加 Redis 的依赖，比如 Jedis 和 Spring Data Redis。 2. 配置 Redis 连接：在项目的 application.properties 文件中添加 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值