springboot项目集成reids并使用

左手的ㄟ右手 2022-04-16 07:16 167阅读 0赞

# 声明： #

此文章为springboot 2.0版本集成redis。并简单示范，存储redis和获取redis中数据的方法、

此处springboot项目的搭建略过。主要记录redis的集成和使用

# 集成步骤： #

### 第一步：pom文件添加redis依赖 ###

<dependency>
                    <groupId>redis.clients</groupId>
                    <artifactId>jedis</artifactId>
                    <version>2.9.0</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-data-redis</artifactId>
                    <version>2.0.5.RELEASE</version>
                </dependency>

### 第二步：配置redis数据源 ###

spring:
      datasource:
        url: jdbc:mysql://localhost:3306/marketing?characterEncoding=utf-8&verifyServerCertificate=false&useSSL=false&requireSSL=false&allowMultiQueries=true
        driver-class-name: com.mysql.cj.jdbc.Driver
        username: marketing
        password: marketing
        type: com.zaxxer.hikari.HikariDataSource
      redis:
        host: 172.20.94.39
        password:（如果有密码就添加密码如果没有就空着）
        port: 6379

## ##

### 第三步：配置jedisService或者jedisUtils ###

1、jedisService

import com.rrc.marketing.core.query.Query;
    import org.apache.commons.lang.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    import redis.clients.jedis.exceptions.JedisConnectionException;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    import java.util.List;
    import java.util.Set;
    import java.util.function.Function;
    
    /**
     * JedisService
     *
     * @author lixb
     * @date 2016-11-29 下午8:24
     */
    @Service
    public class  JedisService {
    
    	private final static Logger logger = LoggerFactory.getLogger(JedisService.class);
    
    	@Value("${spring.redis.host}")
    	private String host;
    	@Value("${spring.redis.port}")
    	private Integer port;
    	@Value("${spring.redis.password}")
    	private String password;
    
    	@Value("${spring.redis.db}")
    	private Integer database;
    
    	private static JedisPool jedisPool;
    
    
    	public <Q extends Query> Integer getIntegerFromRedisOrSet(Function<Q, Integer> function, Q query, String key, int expire) {
    		logger.info("---getIntegerFromRedisOrSet()----, key: {}, query: {}", key, query);
    		String value = getByKey(key);
    		if (StringUtils.isBlank(value)) {
    			Integer integer = function.apply(query);
    			setByKey(key, integer + "", expire);
    			return integer;
    		}
    		return Integer.valueOf(value);
    	}
    
    	/**
    	 * 得到key中存储的内容
    	 *
    	 * @param key
    	 * @return
    	 */
    	public String getByKey(String key) {
    		if (StringUtils.isBlank(key)) {
    			logger.error("empty key, key {}", key);
    			return null;
    		}
    
    		Object s = oper(get(key));
    		return s == null ? null : s.toString();
    	}
    
    	/**
    	 * 根据表达式得到一组key
    	 *
    	 * @param pattern
    	 * @return
    	 */
    	public Set<String> getByPattern(String pattern) {
    		if (StringUtils.isBlank(pattern)) {
    			logger.error("empty pattern, pattern {}", pattern);
    			return null;
    		}
    		Set<String> keys = (Set<String>)oper(getKeys(pattern));
    		return keys;
    	}
    
    	/**
    	 * 根据一组key获取值
    	 */
    	public List<String> mgetByKeySet(Set<String> keySet){
    		if(null == keySet || keySet.isEmpty()){
    			logger.error("empty keys========");
    			return null;
    		}
    		String[] keys = keySet.toArray(new String[keySet.size()]);
    		List<String> list = (List<String>)oper(mget(keys));
    		return list;
    	}
    
    
    	/**
    	 * 设置redis的key为value，超时为expire
    	 *
    	 * @param key
    	 * @return
    	 */
    	public boolean setByKey(String key, String value, int expire) {
    		if (StringUtils.isBlank(key) || StringUtils.isBlank(value)) {
    			logger.error("empty key or value, key {}, value {}", key, value);
    			return false;
    		}
    
    		String s = oper(set(key, value, expire)).toString();
    		return !(StringUtils.isBlank(s) || !s.equals("OK"));
    	}
    
        /**
         * 设置一组key Value
         * @param keyValues
         * @return
         */
    	public boolean msetByKV(String... keyValues){
            if (keyValues.length <= 0) {
                logger.error("empty keyValues");
                return false;
            }
            String s =  oper(mset(keyValues)) == null ? null : oper(mset(keyValues)).toString() ;
            return  s != null && !StringUtils.isBlank(s.toString()) && s.toString().equals("OK");
        }
    
    	/**
    	 * 设置redis的key为value，不存在时设置
    	 *
    	 * @param key
    	 * @return
    	 */
    	public boolean setNxByKey(String key, String value, Integer expire) {
    		if (StringUtils.isBlank(key) || StringUtils.isBlank(value) || expire == null) {
    			logger.error("empty key or value, key {}, value {}, expire {}", key, value, expire);
    			return false;
    		}
    
    		Object s = oper(setnx(key, value, expire));
    
    		return s != null && !StringUtils.isBlank(s.toString()) && s.toString().equals("OK");
    	}
    
    	/**
    	 * 获取key的下一个值
    	 * @param key
    	 * @return
    	 */
    	public int getNextId(String key){
    		if(setNxByKey(key, String.valueOf(0), 24*3600)){
    			return 0;
    		}else{
    			return incByKey(key);
    		}
    	}
    
    	public boolean setNxByKey(String key, String value) {
    		if (StringUtils.isBlank(key) || StringUtils.isBlank(value)) {
    			logger.error("empty key or value, key {}, value {}", key, value);
    			return false;
    		}
    		Object s = oper(setnx(key, value));
    		return Integer.valueOf(s.toString()).intValue() == 1;
    	}
    
    	/**
    	 * 设置超时
    	 *
    	 * @param key
    	 * @return
    	 */
    	public boolean setExpire(String key, Integer expire) {
    		if (StringUtils.isBlank(key) || expire == null) {
    			logger.error("empty key or expire, key {}, expire {}", key, expire);
    			return false;
    		}
    
    		String s = oper(expire(key, expire)).toString();
    		return !(StringUtils.isBlank(s) || !s.equals("1"));
    	}
    
    	/**
    	 * 增加key的值
    	 *
    	 * @param key
    	 * @return
    	 */
    	public int incByKey(String key) {
    		if (StringUtils.isBlank(key)) {
    			logger.error("empty key , key {}", key);
    			return -1;
    		}
    
    		Object s = oper(inc(key, 1L));
    		return s == null ? -1 : Integer.parseInt(s.toString());
    	}
    
    	public int decByKey(String key) {
    		if (StringUtils.isBlank(key)) {
    			logger.error("empty key , key {}", key);
    			return -1;
    		}
    
    		Object s = oper(dec(key, 1L));
    		return s == null ? -1 : Integer.parseInt(s.toString());
    	}
    
    	/**
    	 * get redis conection
    	 *
    	 * @return
    	 */
    	private static Jedis getRedisResource() {
    		if (null == jedisPool) {
    			throw new NullPointerException("please connect to redis first!");
    		}
    
    		Jedis jedis = null;
    		try {
    			jedis = jedisPool.getResource();
    		} catch (JedisConnectionException e) {
    			logger.error("redis connection error", e);
    			return null;
    		}
    		return jedis;
    	}
    
    	/**
    	 * apply f to jedis
    	 *
    	 * @param f
    	 * @return
    	 */
    	private static Object oper(Function<Jedis, Object> f) {
    		if (f == null) {
    			return null;
    		}
    		Jedis jedis = getRedisResource();
            if (jedis == null) {
    			logger.error("get resource failed");
    			return null;
    		}
    
    		try {
    			Object o = f.apply(jedis);
    			return o;
    		} catch (Exception e) {
    			logger.error("redis operation failed", e);
    			return null;
    		} finally {
    			jedis.close();
    		}
    	}
    
    	@PostConstruct
    	public void init() {
    		logger.info("init jedis, host {}, port {}, password {}", host, port, password);
    		connect(host, port, password,database);
    	}
    
    	@PreDestroy
    	public void close() {
    		logger.info("close jedis, host {}, port {}, password {}", host, port, password);
    		if (jedisPool != null && !jedisPool.isClosed()) {
    			jedisPool.close();
    		}
    	}
    
    	/**
    	 * connect to redis
    	 *
    	 * @param host
    	 * @param port
    	 * @param password
    	 */
    	private synchronized static void connect(String host, Integer port, String password,int database){
    		if (jedisPool != null && !jedisPool.isClosed()) {
    			return;
    		} // 防止重复连接
    
    		if (StringUtils.isEmpty(host) || port == null || port < 0 || port > 65535) {
    			throw new IllegalArgumentException("redis connection error, host = " + host + ", port=" + port);
    		}
    
    		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    		jedisPoolConfig.setMaxTotal(1000);
    		jedisPoolConfig.setMaxIdle(100);
    		if (StringUtils.isEmpty(password)) {
    			jedisPool = new JedisPool(jedisPoolConfig, host, port, 10000,null,database);
    		} else {
    			jedisPool = new JedisPool(new JedisPoolConfig(), host, port, 10000, password,database);
    		}
    
        }
    
    	public boolean setByKey(String key, String value) {
    		if (StringUtils.isBlank(key) || StringUtils.isBlank(value)) {
    			logger.error("empty key or value, key {}, value {}", key, value);
    			return false;
    		}
    		String s = oper(set(key, value, null)).toString();
    		return !(StringUtils.isBlank(s) || !s.equals("OK"));
    	}
    
    	public boolean delByKey(String key) {
    		if (StringUtils.isBlank(key)) {
    			logger.error("empty key or value, key {}", key);
    			return false;
    		}
    		String s = oper(del(key)).toString();
    		return !(StringUtils.isBlank(s) || !s.equals("OK"));
    	}
    
        public boolean delByKeys(String... keys) {
            if (keys.length <= 0 ) {
                logger.error("empty key or value, keys {}", keys);
                return false;
            }
            String s = oper(del(keys)).toString();
            return !(StringUtils.isBlank(s) || !s.equals("OK"));
        }
    
    	/**
    	 * 操作set集合 向名称为key的set中添加元素member
    	 * 
    	 * @param key
    	 * @param members
    	 * @return
    	 */
    	public boolean addSetByKey(String key, String... members) {
    		if (StringUtils.isBlank(key) || members == null || members.length <= 0) {
    			logger.error("empty key or value, key {}", key);
    			return false;
    		}
    
    		String s = oper(sadd(key, members)).toString();
    
    		return !StringUtils.isBlank(s) || !s.equals("0");
    
    	}
    
    	/**
    	 * 操作set集合 返回名称为key的set的所有元素
    	 * 
    	 * @param key
    	 * @return
    	 */
    	public Set<String> smembersByKey(String key) {
    		if (StringUtils.isBlank(key)) {
    			logger.error("empty key, key {}", key);
    			return null;
    		}
    
    		Set<String> s = (Set<String>) oper(smembers(key));
    		return s;
    	}
    
    	public Boolean existByKey(String key) {
    		if (StringUtils.isBlank(key)) {
    			logger.error("empty key, key {}", key);
    			return false;
    		}
    		return (Boolean) oper(exists(key));
    	}
    
    	public static Function<Jedis, Object> get(String key) {
    		if (StringUtils.isEmpty(key)) {
    			throw new NullPointerException("key cannot be null");
    		}
    		return (Jedis jedis) -> jedis.get(key);
    	}
    
    
    
        public static Function<Jedis, Object> mset(String... keyValues) {
    	    if(keyValues.length <= 0){
    	        throw new NullPointerException("keyValues 必传");
            }
            return (Jedis jedis) -> jedis.mset(keyValues);
        }
    	/**
    	 * 根据主键设置, 不过期
    	 *
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	public static Function<Jedis, Object> set(String key, String value) {
    		return set(key, value, null);
    	}
    
    	public static Function<Jedis, Object> del(String key) {
    		return (Jedis jedis) -> jedis.del(key);
    	}
    
        public static Function<Jedis, Object> del(String... key) {
            return (Jedis jedis) -> jedis.del(key);
        }
    
    	/**
    	 * 根据主键设置, expire单位为s
    	 *
    	 * @param key
    	 * @param value
    	 * @param expire
    	 * @return
    	 */
    	public static Function<Jedis, Object> set(String key, String value, Integer expire) {
    		if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value)) {
    			throw new NullPointerException("key or value cannot be null");
    		}
    		if (expire == null) {
    			return (Jedis jedis) -> jedis.set(key, value);
    		} else {
    			return (Jedis jedis) -> jedis.setex(key, expire, value);
    		}
    	}
    
    
    
    
    	/**
    	 * 获取一组key值
    	 *
    	 * @param key
    	 * @return
    	 */
    	public static Function<Jedis, Object> mget(String... key) {
    
    		return (Jedis jedis) -> jedis.mget(key);
    	}
    
    
    
    	/**
    	 * 获取一组key
    	 *
    	 * @param pattern
    	 * @return
    	 */
    	public static Function<Jedis, Object> getKeys(String pattern) {
    
    		return (Jedis jedis) -> jedis.keys(pattern);
    	}
    	/**
    	 * 根据主键增加Value的值
    	 *
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	public static Function<Jedis, Object> inc(String key, Long value) {
    		if (StringUtils.isEmpty(key) || value == null) {
    			throw new NullPointerException("key or value cannot be null");
    		}
    
    		return (Jedis jedis) -> jedis.incrBy(key, value);
    	}
    	/**
    	 * 根据主键减少Value的值
    	 *
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	public static Function<Jedis, Object> dec(String key, Long value) {
    		if (StringUtils.isEmpty(key) || value == null) {
    			throw new NullPointerException("key or value cannot be null");
    		}
    		return (Jedis jedis) -> jedis.decrBy(key, value);
    	}
    
    	/**
    	 * 根据主键设置；不存在时设置
    	 *
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	public static Function<Jedis, Object> setnx(String key, String value) {
    		if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value)) {
    			throw new NullPointerException("key or value cannot be null");
    		}
    		return (Jedis jedis) -> jedis.setnx(key, value);
    	}
    
    	/**
    	 * 根据主键设置；不存在时设置，支持超时
    	 *
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	public static Function<Jedis, Object> setnx(String key, String value, Integer expire) {
    		if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value) || expire == null) {
    			throw new NullPointerException("key or value or expire cannot be null");
    		}
    		return (Jedis jedis) -> jedis.set(key, value, "nx", "ex", expire);
    	}
    
    	/**
    	 * 设置键的超时时间
    	 *
    	 * @param key
    	 * @param expire
    	 * @return
    	 */
    	public static Function<Jedis, Object> expire(String key, Integer expire) {
    		if (StringUtils.isEmpty(key) || expire == null) {
    			throw new NullPointerException("key or time cannot be null");
    		}
    		return (Jedis jedis) -> jedis.expire(key, expire);
    	}
    
    	public static Function<Jedis, Object> sadd(String key, String... members) {
    		return (Jedis jedis) -> jedis.sadd(key, members);
    	}
    
    	public static Function<Jedis, Object> smembers(String key) {
    		if (StringUtils.isEmpty(key)) {
    			throw new NullPointerException("key or time cannot be null");
    		}
    		return (Jedis jedis) -> jedis.smembers(key);
    	}
    
    	public static Function<Jedis, Object> exists(String key) {
    		if (StringUtils.isEmpty(key)) {
    			throw new NullPointerException("key cannot be null");
    		}
    		return (Jedis jedis) -> jedis.exists(key);
    	}
    }

### jedisService使用方法： ###

//注入jedisService  
    @Autowired
    private JedisService jedisService;
    
    
    //存储数据到redis中直接调用jedisService方法，
    //示例：存入key,value,过期时间24小时过期
    jedisService.setNxByKey(key,value,24 * 60 * 60);
    
    //获取redis中数据通过存储的key获取value 如果没有获取到值那么value的值为null
    String Value=jedisService.getByKey(key);

注意：如果想分层存储那么key的规则是用":"符号分开

例如：下图的key命名规则为：marketing:scheduler:fem:tencent:campaign:name:15501802,value值为：20180606

分层显示就可以按层级分开值像项目的包结构一样。

查看redis中的数据，安装redis可视化工具redisdesktopmanager

安装好之后添加连接查看数据

![20181119125741873.jpg][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsaWNlX3FpeGlu_size_16_color_FFFFFF_t_70][]

2、jedisUtils

package com.rrc.marketing.adsscheduler.utils;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    import redis.clients.jedis.Jedis;
    
    @Component
    /**
     * jedis封装
     * 用法
     * 注入 JedisClientUtil jedisClientUtil；
     * 		Jedis jedis= jedisClientUtil.getRedisClient();
     *      获取key
        	 jedis.get(tokenKey);
        	 //过期时间的key
        	  jedis.setex(tokenKey, 10*60, accessToken);
        	  //普通的key
        	  jedis.set(key, value);
     * @author xingxiangguo
     *
     */
    public class JedisClientUtil {
    	@Value("${spring.redis.host}")
    	String host;
    	@Value("${spring.redis.port}")
    	int port;
    	private byte[] temp_lock = new byte[1];
    	private Jedis jedis;
    	private JedisClientUtil(){};
    	public Jedis getRedisClient(){
    		if(jedis == null){
    			synchronized (temp_lock) {
    				if(jedis == null){
    					jedis = new Jedis(host,port);
    				}
    			}
    		}
    		return jedis;
    	}
    	
    }

jedisUtils的使用方法

//注入jedisClientUtil
    @Autowired
    public       JedisClientUtil     jedisClientUtil;
    
    //向redis中存储数据
     Jedis jedis = jedisClientUtil.getRedisClient();
    //增加指定的值，返回操作后的值
     usedQuota = jedis.incrBy(typeKey, currentQuota);
    //减少指定的值
     count =jedis.decrBy("count", 100);
    //保存一个字符串
     jedis.set(nameKey, allQuota.toString());
     //设置有效期
     jedis.expireAt(typeKey, expireTime);
     jedis.expireAt(nameKey, expireTime);
     //获取key的旧值，并给其设置新值,返回值是被修改之前的值
     String oldName=jedis.getSet("name", "Higgin");
     //获取指定长度的字符串
     jedis.getrange("name", 0, -1);
            
     //替换字符串部分内容
     jedis.setrange("name", 0, "ab");
    //只有key不存在的时候才进行保存(key若已经存在不错任何改变，返回0，若不存在，则创建一个key并赋值，返回1)
    long result=jedis.setnx("name", "abc");

等等方法。请看连接jeids方法点击跳转

[jedis方法][jedis]

存入数据同jedis一样可以用可视化工具查看

![20181119131023632.jpg][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsaWNlX3FpeGlu_size_16_color_FFFFFF_t_70 1][]

结束

感谢观看！

[20181119125741873.jpg]: /images/20220416/b5d3b9ef881e42d88477170b500c82dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsaWNlX3FpeGlu_size_16_color_FFFFFF_t_70]: /images/20220416/7db3048e28d644ff9d14a26e31c35a5c.png
[jedis]: https://www.cnblogs.com/HigginCui/p/6594385.html
[20181119131023632.jpg]: /images/20220416/f3a69773b7d64d8ba753c79375e27334.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsaWNlX3FpeGlu_size_16_color_FFFFFF_t_70 1]: /images/20220416/a49907c653a549a080fc92565afdc00b.png