3分钟搞定springboot整合redis

Posted 2023-03-21

参考技术A 不多说直接上代码：

<!-- redis -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-redis</artifactId>

<exclusions>

<exclusion>

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

</exclusion>

<exclusion>

<groupId>io.lettuce</groupId>

<artifactId>lettuce-core</artifactId>

</exclusion>

</exclusions>

</dependency>

<!-- 添加jedis客户端 -->

<dependency>

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

</dependency>

<!--spring2.0集成redis所需common-pool2-->

<!-- 必须加上，jedis依赖此 -->

<dependency>

<groupId>org.apache.commons</groupId>

<artifactId>commons-pool2</artifactId>

<version>2.5.0</version>

</dependency>

<!-- 将作为Redis对象序列化器 -->

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>fastjson</artifactId>

<version>1.2.47</version>

</dependency>

#Matser的ip地址

redis.hostName=172.16.44.148

#端口号

redis.port=6379

#如果有密码

redis.password=

#客户端超时时间单位是毫秒 默认是2000

redis.timeout=10000

#最大空闲数

redis.maxIdle=300

#连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal

#redis.maxActive=600

#控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性

redis.maxTotal=1000

#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。

redis.maxWaitMillis=1000

#连接的最小空闲时间 默认1800000毫秒(30分钟)

redis.minEvictableIdleTimeMillis=300000

#每次释放连接的最大数目,默认3

redis.numTestsPerEvictionRun=1024

#逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1

redis.timeBetweenEvictionRunsMillis=30000

#是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个

redis.testOnBorrow=true

#在空闲时检查有效性, 默认false

redis.testWhileIdle=true

package com.junsi.demo.config;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.PropertySource;

import org.springframework.data.redis.connection.RedisConnectionFactory;

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 com.junsi.demo.utils.RedisUtil;

import redis.clients.jedis.JedisPoolConfig;

/**

* Redis配置类

* @author pzx

* 2019年6月8日

*/

@Configuration

@PropertySource("classpath:redis.properties")

public class RedisConfig

@Value("$redis.maxIdle")

private Integer maxIdle;

@Value("$redis.maxTotal")

private Integer maxTotal;

@Value("$redis.maxWaitMillis")

private Integer maxWaitMillis;

@Value("$redis.minEvictableIdleTimeMillis")

private Integer minEvictableIdleTimeMillis;

@Value("$redis.numTestsPerEvictionRun")

private Integer numTestsPerEvictionRun;

@Value("$redis.timeBetweenEvictionRunsMillis")

private long timeBetweenEvictionRunsMillis;

@Value("$redis.testOnBorrow")

private boolean testOnBorrow;

@Value("$redis.testWhileIdle")

private boolean testWhileIdle;

@Value("$spring.redis.cluster.nodes")

private String clusterNodes;

@Value("$spring.redis.cluster.max-redirects")

private Integer mmaxRedirectsac;

/**

* JedisPoolConfig 连接池

* @return

*/

@Bean

public JedisPoolConfig jedisPoolConfig()

JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

// 最大空闲数

jedisPoolConfig.setMaxIdle(maxIdle);

// 连接池的最大数据库连接数

jedisPoolConfig.setMaxTotal(maxTotal);

// 最大建立连接等待时间

jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);

// 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)

jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);

// 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3

jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);

// 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1

jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

// 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个

jedisPoolConfig.setTestOnBorrow(testOnBorrow);

// 在空闲时检查有效性, 默认false

jedisPoolConfig.setTestWhileIdle(testWhileIdle);

return jedisPoolConfig;



/**

* @param jedisPoolConfig

* @return

*/

@Bean

public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig)

JedisConnectionFactory JedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);

//连接池

JedisConnectionFactory.setPoolConfig(jedisPoolConfig);

//IP地址

JedisConnectionFactory.setHostName("172.16.44.148");

//端口号

JedisConnectionFactory.setPort(6379);

//如果Redis设置有密码

//JedisConnectionFactory.setPassword(password);

//客户端超时时间单位是毫秒

JedisConnectionFactory.setTimeout(5000);

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);



@Bean(name = "redisUtil")

public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate)

RedisUtil redisUtil = new RedisUtil();

redisUtil.setRedisTemplate(redisTemplate);

return redisUtil;

整合定时任务Task，一秒搞定定时任务

前面介绍了Spring Boot 中的整合Redis缓存已经如何实现数据缓存功能。不清楚的朋友可以看看之前的文章：https://www.cnblogs.com/zhangweizhong/category/1657780.html。

今天主要讲解Springboot整合定时任务。在SpringMvc中也会用到很多的定时任务，主要是通过Quartz实现。但是在Spring MVC中使用这些插件相对还是比较麻烦的：要增加一些依赖包，然后加入各种配置等等。Spring Boot相对就简单很多了，现在就来说说Spring Boot 是怎么实现定时任务的。

 

一、使用注解@EnableScheduling

在application启动类忠，加上@EnableScheduling 注解，Spring Boot 会会自动扫描任务类，开启定时任务。

package com.weiz;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import tk.mybatis.spring.annotation.MapperScan;


@SpringBootApplication
//扫描 mybatis mapper 包路径
@MapperScan(basePackages = "com.weiz.mapper")
//扫描 所有需要的包, 包含一些自用的工具类包 所在的路径
@ComponentScan(basePackages = {"com.weiz","org.n3r.idworker"})
//开启定时任务
@EnableScheduling
//开启异步调用方法
@EnableAsync
public class SpringBootStarterApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootStarterApplication.class, args);
    }

}

说明：

1、@EnableScheduling 为开启定时任务。

2、@ComponentScan 定义扫描包的路径。

 

二、创建任务类，定义@Component 组件

创建com.weiz.tasks包，在tasks包里增加TestTask任务类，加上@Component 注解，那么TestTask就会作为组件被容器扫描到。扫描到之后，Spring Boot容器就会根据任务类里面定义的时间，定时执行了。

package com.weiz.tasks;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class TestTask {

    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");

    // 定义每过3秒执行任务
    @Scheduled(fixedRate = 3000)
    // @Scheduled(cron = "4-40 * * * * ?")
    public void reportCurrentTime() {
        System.out.println("现在时间：" + dateFormat.format(new Date()));
    }
}

说明：@Scheduled 是定时任务执行的时间，可以每个一段时间执行，也可以使用cron 表达式定义执行时间。

三、Cron表达式

Spring Boot 定时任务支持每个一段时间执行或是使用cron 表达式定义执行时间。关于cron表达式，我之前的文章介绍过，大家可以看我以前的文章：《Quartz.NET总结（二）CronTrigger和Cron表达式》

 

四、测试

启动程序之后，就可以看到系统每隔3s，会打印系统时间。

 

最后

以上，就把Spring Boot整合定时任务简单介绍完了，是不是特别简单，下一篇我会介绍Spring boot 的异步任务。

这个系列课程的完整源码，也会提供给大家。大家关注我的微信公众号（架构师精进），回复：springboot源码。获取这个系列课程的完整源码。