1.Maven依赖

我这里整合引入的相关jar包

<!--springboot整合redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.2.2.RELEASE</version>
        </dependency>

        <!-- 用来转换数据 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>

2.配置文件

只贴出redis相关的,注意是在spring的下一级的

配置文件

redis:
    host: 192.168.0.103
    port: 6379
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 500
        min-idle: 0
      lettuce:
        shutdown-timeout: 0

3.更改默认的redisTemplate

因为SpringBoot整合Redis的时候会自动帮我们生成一个RedisTemplate和一个StringRedisTemplate。但因为这个RedisTemplate的泛型是<Object,Object>,对我们很多操作都不太方便,所以一般自己定义一个

RedisConfig

package com.jbit.springboot.springbootredis.conf;


import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Autowired
    private RedisConnectionFactory redisConnectionFactory;


    @Bean("redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(objectMapper);

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(serializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(serializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

4.使用

就是在需要使用到的地址声明对象(我这里在ServiceImpl中使用的)

	@Autowired
    private RedisTemplate<String,String> redisTemplate;

相关的方法中使用(我这里实现的是一个查询所有商品信息的功能)

@Override
    public List<Goods> selectAll() {
        //判断reids中是否存在(键为商品的Id,这里根据自己的需求设置合适的键就行)
        List<Goods> goods = goodsDao.selectAll();

        //声明一个集合存放redis中转化成对象后的数据
        List<Goods> redisList=new ArrayList<>();

        for(Goods good:goods){
            String s = redisTemplate.opsForValue().get(String.valueOf(good.getId()));

            //我这里存储到redis中的情况是
            //如果redis中有值就代表数据库的全部数据都在里面
            if(s!=null && !s.equals("")){
                System.out.println("redis中有值");
                //如果有值则依次取出来
                Goods g=JSON.parseObject(s,Goods.class);
                redisList.add(g);
            }else{
                //如果没有则去数据库中查询
                System.out.println("redis中无值");
                List<Goods> goods1 = goodsDao.selectAll();
                //查询出来后放到redis中
                for(Goods good2:goods1){
                    redisTemplate.opsForValue().set(String.valueOf(good2.getId()),JSON.toJSONString(good));
                }
                //因为数据库中都查出来了,所以直接返回数据库中的
                return goods1;
            }
        }

        //没有返回数据库的则返回redis中的
        return redisList;
    }

5.测试

1.第一次进来,redis中无值

可以看到后台正常返回,且redis数据库中生成了我们规定的键对值

2.第二次进来

因为我的打印语句是放在取redis的时候有值的循环中的,所以redis中有多少数据就会打印多少次(从redis中取出数据并转换成相应的对象放到集合中返回成功了)

SpringBoot整合redis的步骤大概就是这个样子了~

springboot整合redis系列集合

• 1.springboot整合redis序列化（3步搞定）- 本文
• 2.springboot整合redis发布订阅（4步搞定）
• 3.springboot整合redis数据结构对应使用场景讲解
• 4.springboot整合redis分布式锁

项目结构图

1、pom文件添加依赖

1.依赖版本springboot会自动匹配，所以不用关注
2.fastjson依赖方便我们管理json格式数据

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
   <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.72</version>
</dependency>

2、yml文件配置连接

redis安装教程请移步查看: docker快速安装redis（两步轻松搞定）

port：端口号
host：ip地址
password：密码

spring:
  redis:
    port: 6379
    host: 127.0.0.1
    password: 123456

3、添加序列化配置类

package com.phy.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * redis 序列化配置
 * @author phy
 */
@Configuration
public class RedisConfig {
    /**
     * redis序列化配置
     * @param connectionFactory 连接工厂
     * @return
     */
    @Bean
    public RedisTemplate redisTemplate(LettuceConnectionFactory connectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(connectionFactory);
        // 替换默认序列化
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

至此，springboot整合redis并设置序列化就已完成，下面我们测试一下

测试

添加一个DemoController

package com.phy.demo.controller;

import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

/**
 * demo redis 前端控制器
 * @author phy
 * @since 2021-09-29
 */
@RestController
@RequestMapping("/demo")
public class DemoController {
    @Autowired
    private RedisTemplate redisTemplate;

    @PostMapping("set")
    public void set(@RequestBody JSONObject data) {
        redisTemplate.opsForValue().set(data.get("key"),data.get("value"));
    }

    @GetMapping("get")
    public String get(String key) {
        return (String)redisTemplate.opsForValue().get(key);
    }
}

运行项目，Postman调用测试

添加redis键

通过键获取值

1. 导入Redis相关依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

导入了相关的依赖后会有自动配置类，找到自动配置类RedisAutoConfiguration。该自动配置类有两个方法，如下。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
		return new StringRedisTemplate(redisConnectionFactory);
	}

}

RedisTemplate和StringRedisTemplate的区别。

RedisTemplate键值对可以是Object类型，但是StringRedisTemplate，的键只能是String类型，值可以是Object类型。

2. 配置Redis

在application.yml中配置redis。

spring:
    redis:
        host: 127.0.0.1

Redis底层默认是使用Lettuce作为客户端的，如需要使用jedis作为客户端管理工具，需要在pom.xml中引入jedis的依赖。

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

application.yml配置则如下。

spring:
    redis:
        host: 127.0.0.1
        client-type: jedis
        jedis:
          pool:
            max-active: 10
            min-idle: 5

如果你的redis配置了连接密码，可以用下面的方式进行配置。

spring:
    redis:
        host: 127.0.0.1
        password: 123456

编写技术器

首先我们需要写一个拦截器的组件，然后将组件注册进来。

编写redis拦截组件。

@Component
public class RedisUrlCountInterceptor implements HandlerInterceptor {

    @Autowired
    StringRedisTemplate redisTemplate;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String uri = request.getRequestURI();

        // 默认每次访问当前 uri 就会计数+1
        redisTemplate.opsForValue().increment(uri);

        return true;
    }
}

把该组件注册到拦截器中。

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    @Autowired
    RedisUrlCountInterceptor redisUrlCountInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(redisUrlCountInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/", "/login", "/css/**", "/fonts/**", "/images/**", "/js/**");
    }
}

分析Redis自动装配原理

找到RedisAutoConfiguration类，可以看到该类有连个方法，RedisTemplate<Object, Object>和StringRedisTemplate，这两者的区别上面已经介绍了，这里就不再叙述。

该类的注解如下图所示。

• 其中@Configuration(proxyBeanMethods = false)表示lite模式。lite模式中，每次都会创建新的bean实例。不用到容器中检查是否存在该bean实例，能够加快SpringBoot的启动速度。
• @ConditionalOnClass(RedisOperations.class)表示某个RedisOperations位于类路径上，才会实例化一个Bean。
• @EnableConfigurationProperties(RedisProperties.class)表示使使用了@ConfigurationProperties的类生效，即我们配置的properties文件可以生效，可以从properties配置文件中读取数据，当然也可以是yml文件。这里表示绑定了RedisProperties类中的属性，我们可以在application.yml中配置redis的属性值。
• @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })的作用是导入这两种连接的配置类。

下面这个是RedisProperties类，首先是使用@ConfigurationProperties注解进行配置文件的绑定，这里绑定了前缀spring.redis所以我们可以直接在配置文件application.yml中配置redis。并且在该类中有很多默认的配置，比如端口号默认是6379，连接的主机默认是本地等等。redis一共有16个数据库，从源码可以看到，默认使用第一个数据库，也就是databases = 0。客户端类型有两种，可以选择LETTUCE，这是默认的，还有一个是JEDIS。这里需要注意，如果使用JEDIS作为客户端连接工具，则需要在pom.xml中引入jedis的依赖。

RedisTemplate对象通过调用setConnectionFactory方法，产生redis连接工厂，这样就可以连接到redis了。

StringRedisTemplate是使用了构造方法来产生一个redis连接工厂。

etConnectionFactory方法，产生redis连接工厂，这样就可以连接到redis`了。

StringRedisTemplate是使用了构造方法来产生一个redis连接工厂。

更多内容欢迎关注我