springboot整合redis的比较全面的工具类

昨天整理了springboot整合redis的工具类分享给大家。

整个项目的目录结构：

client是redis客户端，config是redis客户端连接redis服务器的配置 ，lock是redis的lock工具，serailize是redis序列化工具。

springboot整合redis的maven依赖：

<dependencies>
            <!-- springBoot 相关 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
                <exclusions>
                    <exclusion>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-logging</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <exclusions>
                    <exclusion>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-logging</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-log4j2</artifactId>
            </dependency>
            <!-- redis client -->
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>${redis.clients.version}</version>
            </dependency>
            <!-- json -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.version}</version>
            </dependency>
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
        <!-- guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>21.0</version>
        </dependency>
    </dependencies>

redis客户端的配置信息：

#端口配置
server.port=8081
spring.profiles.active=dev
#redis 基础配置
# Redis数据库索引（默认为0）
spring.redis.database=1
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接密码（默认为空）
spring.redis.password=123456
# Redis服务器连接端口
spring.redis.port=6379
# 连接超时时间（毫秒）
spring.redis.timeout=0

#redis 连接池配置
#池中最大链接数
spring.redis.pool-config.max-total=256
# 连接池中的最大空闲连接
spring.redis.pool-config.max-idle=128
# 连接池中的最小空闲连接
spring.redis.pool-config.min-idle=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool-config.max-wait-millis=1000
# 调用者获取链接时，是否检测当前链接有效性
spring.redis.pool-config.test-on-borrow=false
# 向链接池中归还链接时，是否检测链接有效性
spring.redis.pool-config.test-on-return=false
# 调用者获取链接时，是否检测空闲超时, 如果超时，则会被移除-
spring.redis.pool-config.test-while-idle=true
# 空闲链接检测线程一次运行检测多少条链接
spring.redis.pool-config.num-tests-per-eviction-run=8
#空闲链接检测线程检测周期。如果为负值，表示不运行检测线程。（单位：毫秒，默认为-1）
spring.redis.pool-config.time-between-eviction-runs-millis=60000
#配置一个连接在池中最小生存的时间，单位是毫秒
spring.redis.pool-config.min-evictable-idle-time-millis=300000

#spring-session
spring.session.store-type=none
#日志配置
logging.level.root=info
logging.level.net.sf=info
logging.level.com.boot.redis=TRACE

我们先看看invoke的代码：

public interface RedisClientInvoker<T> {

    /**
     * invoke
     * @param jedis
     * @return
     * @throws IOException
     */
    T invoke(Jedis jedis) throws IOException;
}

然后我们在来看redisclient的代码：

@Component
public class RedisClient {

    private static final Logger LOGGER = LoggerFactory.getLogger(RedisClient.class);

    public <T> T invoke(JedisPool pool, RedisClientInvoker<T> clients) {
        T obj = null;
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            obj = clients.invoke(jedis);
        } catch (JedisException | IOException ex) {
            LOGGER.error(ex.getMessage(), ex);
        } finally {
            if (jedis != null) {
                if (jedis.isConnected()){
                    jedis.close();
                }
            }
        }
        return obj;
    }
}

我们在来看RedisCache某个redis客户端的具体操作：

	//redis连接资源池
   @Autowired
    private JedisPool jedisPool;  
    //redis客户端
    @Autowired
    private RedisClient redisClient;

 /**
     * 添加数据到redis
     * 自定义过期时间
     * 注：从 Redis 2.6.12 版本开始， SET 在设置操作成功完成时，返回 OK
     *
     * @param key
     * @param value
     * @param duration 时间量
     * @param timeUnit 时间单位枚举
     */
    public Boolean set(String key, Object value, int duration, TimeUnit timeUnit) {
        validateParam(key, value);
        String result = redisClient.invoke(jedisPool, (jedis) -> {
                    String srtResult = jedis.set(key.getBytes(), JsonSerializer.serialize(value));
                    if (duration <= ZERO) {
                        //默认5 分钟
                        jedis.pexpire(key.getBytes(), DEFAULT_CACHE_MILLIS);
                    } else {
                        //时间转换成毫秒
                        long millis = TimeUnitUtil.getMillis(timeUnit, duration);
                        jedis.pexpire(key.getBytes(), millis);
                    }
                    return srtResult;
                }

        );
        //是否成功
        return this.isStringEquals(OK, result);
    }

大家看出什么操作了吗？？一波很秀的操作。 这里大家思考一下。。

接下来我们看一下redislock的代码：

/**
     * 尝试获取分布式锁
     *
     * @param lockKey    锁key
     * @param requestId  (请求标识)加锁者标识
     * @param expireTime 超期时间 毫秒数
     * @return 是否获取成功
     */
    public boolean tryGetLock(String lockKey, String requestId, int expireTime) {
        return redisClient.invoke(jedisPool, jedis -> {
                    String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
                    if (OK.equals(result)) {
                        return true;
                    }
                    return false;
                }
        );
    }

项目代码启动类：

/**
 * exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class}  使用自己自定义的数据源配置
 */
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class RedisPractiseApplication {

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

}