SpringBoot使用Redis缓存MySql

文章目录

      • 1 项目组成
      • 2 运行springboot
      • 3 访问mysql
      • 4 设置redis缓存

1 项目组成

  • 应用:springboot rest api
  • 数据库:mysql
  • jdbc框架:jpa
  • 缓存中间件:redis

2 运行springboot

  • 2.1 官网download最基本的restful应用

    教程地址:https://spring.io/guides/gs/rest-service/

    直接download成品,找到git命令 :git clone https://github.com/spring-guides/gs-rest-service.git

    创建一个文件夹,打开git bash here(安装git) SpringBoot使用Redis缓存MySql_第1张图片

    Idea打开成品 (complete文件夹)
    SpringBoot使用Redis缓存MySql_第2张图片

  • 2.2 运行应用

    gradle -> bootRun右键 -> Run/Deubg
    SpringBoot使用Redis缓存MySql_第3张图片

  • 通过http://localhost:8080/greeting?name=lanxingisthebest访问

3 访问mysql

  • 增加gradle依赖 (通过jpa)

    implementation(‘mysql:mysql-connector-java’)
    implementation(‘org.springframework.boot:spring-boot-starter-data-jpa’)

  • 增加配置文件及数据库配置

    创建文件application.yml
    SpringBoot使用Redis缓存MySql_第4张图片

    spring:
     datasource:
       url: jdbc:mysql://localhost:3306/user_info
       username: root
       password: root
     jpa:
       show-sql: true
    
  • 类调整
    SpringBoot使用Redis缓存MySql_第5张图片
    SpringBoot使用Redis缓存MySql_第6张图片
    SpringBoot使用Redis缓存MySql_第7张图片

  • mysql insert一条数据,然后通过 http://localhost:8080/listAllUser 查询数据库

4 设置redis缓存

  • 增加gradle依赖

    implementation(‘org.springframework.boot:spring-boot-starter-data-redis’)
    implementation(‘org.springframework.boot:spring-boot-starter-cache’)

  • 配置文件配置redis参数

    spring:
      datasource:
        url: jdbc:mysql://localhost:3306/user_info
        username: root
        password: root
      jpa:
        show-sql: true
      ## Redis 配置
      redis:
        ## Redis数据库索引(默认为0)
        database: 0
        ## Redis服务器地址
        host: localhost
        ## Redis服务器连接端口
        port: 6379
        ## Redis服务器连接密码(默认为空)
        password:
        jedis:
          pool:
            ## 连接池最大连接数(使用负值表示没有限制)
            #spring.redis.pool.max-active=8
            max-active: 8
            ## 连接池最大阻塞等待时间(使用负值表示没有限制)
            #spring.redis.pool.max-wait=-1
            max-wait: -1
            ## 连接池中的最大空闲连接
            #spring.redis.pool.max-idle=8
            max-idle: 8
            ## 连接池中的最小空闲连接
            #spring.redis.pool.min-idle=0
            min-idle: 0
        ## 连接超时时间(毫秒)
        timeout: 1200
    
  • Redis配置类
    SpringBoot使用Redis缓存MySql_第8张图片
    RedisConfig代码

    package com.example.restservice.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.cache.RedisCacheWriter;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.*;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.time.Duration;
    
    /**
     * @author lzh
     * create 2019-09-24-15:07
     */
    @Configuration
    @EnableCaching
    public class RedisConfig extends CachingConfigurerSupport {
    
        /**
         * 选择redis作为默认缓存工具
         * @param redisConnectionFactory
         * @return
         */
        /*@Bean
        //springboot 1.xx
        public CacheManager cacheManager(RedisTemplate redisTemplate) {
            RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
            return rcm;
        }*/
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofHours(1)); // 设置缓存有效期一小时
            return RedisCacheManager
                    .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                    .cacheDefaults(redisCacheConfiguration).build();
        }
    
        /**
         * retemplate相关配置
         * @param factory
         * @return
         */
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            // 配置连接工厂
            template.setConnectionFactory(factory);
    
            //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值(默认使用JDK的序列化方式)
            Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
    
            ObjectMapper om = new ObjectMapper();
            // 指定要序列化的域,field,get和set,以及修饰符范围,ANY是都有包括private和public
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            // 指定序列化输入的类型,类必须是非final修饰的,final修饰的类,比如String,Integer等会跑出异常
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jacksonSeial.setObjectMapper(om);
    
            // 值采用json序列化
            template.setValueSerializer(jacksonSeial);
            //使用StringRedisSerializer来序列化和反序列化redis的key值
            template.setKeySerializer(new StringRedisSerializer());
    
            // 设置hash key 和value序列化模式
            template.setHashKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(jacksonSeial);
            template.afterPropertiesSet();
    
            return template;
        }
    
        /**
         * 对hash类型的数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForHash();
        }
    
        /**
         * 对redis字符串类型数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForValue();
        }
    
        /**
         * 对链表类型的数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForList();
        }
    
        /**
         * 对无序集合类型的数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForSet();
        }
    
        /**
         * 对有序集合类型的数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForZSet();
        }
    }
    
    
  • 代码通过@Cacheable使用 redis缓存
    SpringBoot使用Redis缓存MySql_第9张图片

  • 访问接口后,通过redis工具查询数据

    点击 redis-lic.exe
    命令 keys * SpringBoot使用Redis缓存MySql_第10张图片

你可能感兴趣的:(redis,缓存,spring,boot,mysql,jpa)