springboot redis简单结合

时间：2017-12-05 11:48:13 阅读：169 评论：0 收藏：0 [点我收藏+]

标签：blog move 查看 swa detail return int 数据移除

参考:
https://www.cnblogs.com/ityouknow/p/5748830.html
http://blog.csdn.net/i_vic/article/details/53081241
https://www.cnblogs.com/gdpuzxs/p/7222309.html
http://www.runoob.com/redis/redis-keys.html #redis命令

springboot和redis结合，这里只是单机版的配置，如果需要配置集群，可以在上面几个博客中看一下。附录中是一些redis常用命令，也可以在参考[3]中看。

springboot的应用，包路径一定要合格(所有的代码，都在启动类所在得包的下级目录中)，避免不必要的麻烦。

开始：

1. pom中添加

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

2. 启动类

添加  @EnableCaching

3. 配置

配置文件：

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=192.168.72.133
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0

配置类：

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport{

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${redis.cacheExpirationTime}")
    private long cacheExpirationTime;
    
    //自定义缓存key生成策略
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator(){
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuffer sb = new StringBuffer();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for(Object obj:params){
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
    
    //缓存管理器
    @Bean 
    public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        //设置缓存过期时间 
        cacheManager.setDefaultExpiration(10);
        return cacheManager;
    }
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory){
        StringRedisTemplate template = new StringRedisTemplate(factory);
        setSerializer(template);//设置序列化工具
        template.afterPropertiesSet();
        return template;
    }
    
    private void setSerializer(StringRedisTemplate template){
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
    }
}

其中的使用的是com.fasterxml.jackson。

4. redis操作接口和实现类(使用接口实现类的形式，可以使你在单机和集群形式快速切换，而且在其它地方使用的使用可以自动注入)

interface:

public interface JedisServer {

    public boolean set(String key, String value);  
    
    public String get(String key);  
      
    public boolean expire(String key,long expire);  
      
    public <T> boolean setList(String key ,List<T> list);  
      
    public <T> List<T> getList(String key,Class<T> clz);  
      
    public long lpush(String key,Object obj);  
      
    public long rpush(String key,Object obj);  
      
    public String lpop(String key);  
    
}

implements single:

@Service
public class JedisServerImpl implements JedisServer {

    @Resource  
    private RedisTemplate<String, ?> redisTemplate;  
      
    @Override  
    public boolean set(final String key, final String value) {  
        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
            @Override  
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                connection.set(serializer.serialize(key), serializer.serialize(value));  
                return true;  
            }  
        });  
        return result;  
    }  
  
    public String get(final String key){  
        String result = redisTemplate.execute(new RedisCallback<String>() {  
            @Override  
            public String doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                byte[] value =  connection.get(serializer.serialize(key));  
                return serializer.deserialize(value);  
            }  
        });  
        return result;  
    }  
  
    /**
     * 设置缓存剩余时间(s)
     */
    @Override  
    public boolean expire(final String key, long expire) {  
        return redisTemplate.expire(key, expire, TimeUnit.SECONDS);  
    }  
  
    @Override  
    public <T> boolean setList(String key, List<T> list) {  
        String value = JsonUtilFood.object2Json(list);  
        return set(key,value);  
    }  
  
    @Override  
    public <T> List<T> getList(String key,Class<T> clz) {  
        String json = get(key);  
        if(json!=null){  
            @SuppressWarnings("unchecked")
            List<T> list = (List<T>) JsonUtilFood.json2Object(json, clz);
            return list;  
        }  
        return null;  
    }  
  
    @Override  
    public long lpush(final String key, Object obj) {  
        final String value = JsonUtilFood.object2Json(obj);  
        long result = redisTemplate.execute(new RedisCallback<Long>() {  
            @Override  
            public Long doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                long count = connection.lPush(serializer.serialize(key), serializer.serialize(value));  
                return count;  
            }  
        });  
        return result;  
    }  
  
    @Override  
    public long rpush(final String key, Object obj) {  
        final String value = JsonUtilFood.object2Json(obj);  
        long result = redisTemplate.execute(new RedisCallback<Long>() {  
            @Override  
            public Long doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                long count = connection.rPush(serializer.serialize(key), serializer.serialize(value));  
                return count;  
            }  
        });  
        return result;  
    }  
  
    @Override  
    public String lpop(final String key) {  
        String result = redisTemplate.execute(new RedisCallback<String>() {  
            @Override  
            public String doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                byte[] res =  connection.lPop(serializer.serialize(key));  
                return serializer.deserialize(res);  
            }  
        });  
        return result;  
    }  
    
}

记得添加@Service注释

implements cluster：没写，百度挺多的。

可以在电脑安装虚拟机，安装linux，然后安装redis，在上面参考博客中有，然后关闭防火墙，启动redis服务端，之后启动客户端测试，可以的时候再使用代码测试。

配置中的缓存存在时间配置暂时测试，不知道为什么没用，所以先在代码中设置了，以后找到了再更新吧。。

再贴一份调用的代码：

    @Resource
    private JedisServer jedisServer;
    
    @Override
    public String noodlesList() {
        //其中的key暂时先写的是固定的，之后可以根据表名+主键保存，防止重复，记得再次查询的时候，重新设置超时时间，修改和删除的时候删除/更新redis中的缓存
        try{
            String string = jedisServer.get("foodcom");
            if(null != string) {
                return string;
            }else{
                jedisServer.expire("foodcom", 10);
            }
        }catch(Exception e) {
            log.info("查询缓存异常(key=foodcom).");
        }
        
        FoodInfo food = foodInfoMapper.selectByPrimaryKey(1);
        jedisServer.set("foodcom", JsonUtilFood.object2Json(food));
        jedisServer.expire("foodcom", 10);
        return JsonUtilFood.object2Json(food);
    }

希望可以帮到你，如果是业余测试，获取有问题我可以帮到你，如果是企业大应用，我也。。不会，以后或许就会了，哈哈哈

附：

redis常用：

防火墙，需要用root用户。

从配置菜单关闭防火墙是不起作用的，索性在安装的时候就不要装防火墙
查看防火墙状态：
/etc/init.d/iptables status
暂时关闭防火墙：
/etc/init.d/iptables stop
禁止防火墙在系统启动时启动
/sbin/chkconfig --level 2345 iptables off
重启iptables:
/etc/init.d/iptables restart
题外话：
BT或者骡子速度慢用不着关防火墙，只要把相应端口开放就可以了
在文件
/etc/sysconfig/iptables
在系统原始配置的:RH-Firewall-1-INPUT规则链增加类似这样的行：
-A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 39764 -j ACCEPT
-A RH-Firewall-1-INPUT -m state --state NEW -m udp -p udp --dport 39764 -j ACCEPT
如果发现原有-j REJECT一类的语句，上面两句要放在它的前面

重启后生效 
开启： chkconfig iptables on 
关闭： chkconfig iptables off 或者 /sbin/chkconfig --level 2345 iptables off

2) 即时生效，重启后失效
service 方式
开启： service iptables start 
关闭： service iptables stop
iptables方式
查看防火墙状态：
/etc/init.d/iptables status
暂时关闭防火墙：
/etc/init.d/iptables stop
重启iptables:
/etc/init.d/iptables restart

1.    SET key value  设置指定 key 的值
2    GET key  获取指定 key 的值。
3    GETRANGE key start end  返回 key 中字符串值的子字符
4    GETSET key value  将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
5    GETBIT key offset  对 key 所储存的字符串值，获取指定偏移量上的位(bit)。
6    MGET key1 [key2..]  获取所有(一个或多个)给定 key 的值。
7    SETBIT key offset value  对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。
8    SETEX key seconds value  将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。
9    SETNX key value  只有在 key 不存在时设置 key 的值。
10    SETRANGE key offset value  用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始。
11    STRLEN key  返回 key 所储存的字符串值的长度。
12    MSET key value [key value ...]  同时设置一个或多个 key-value 对。
13    MSETNX key value [key value ...]  同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
14    PSETEX key milliseconds value  这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。
15    INCR key  将 key 中储存的数字值增一。
16    INCRBY key increment  将 key 所储存的值加上给定的增量值（increment） 。
17    INCRBYFLOAT key increment  将 key 所储存的值加上给定的浮点增量值（increment） 。
18    DECR key  将 key 中储存的数字值减一。
19    DECRBY key decrement  key 所储存的值减去给定的减量值（decrement） 。
20    APPEND key value  如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。 

1.    DEL key  该命令用于在 key 存在时删除 key。
2    DUMP key  序列化给定 key ，并返回被序列化的值。
3    EXISTS key  检查给定 key 是否存在。
4    EXPIRE key seconds  为给定 key 设置过期时间。
5    EXPIREAT key timestamp  EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置过期时间。 不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。
6    PEXPIRE key milliseconds  设置 key 的过期时间以毫秒计。
7    PEXPIREAT key milliseconds-timestamp  设置 key 过期时间的时间戳(unix timestamp) 以毫秒计
8    KEYS pattern  查找所有符合给定模式( pattern)的 key 。
9    MOVE key db  将当前数据库的 key 移动到给定的数据库 db 当中。
10    PERSIST key  移除 key 的过期时间，key 将持久保持。
11    PTTL key  以毫秒为单位返回 key 的剩余的过期时间。
12    TTL key  以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
13    RANDOMKEY  从当前数据库中随机返回一个 key 。
14    RENAME key newkey  修改 key 的名称
15    RENAMENX key newkey  仅当 newkey 不存在时，将 key 改名为 newkey 。
16    TYPE key  返回 key 所储存的值的类型。

springboot redis简单结合

标签：blog move 查看 swa detail return int 数据移除

原文地址：http://www.cnblogs.com/moly/p/7985661.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行