您现在的位置是：首页 >技术教程 >redis(4)网站首页技术教程

1)使用StringTemplateRedis操作String类型

1)判断redis中是否拥有key所对应的值，如果有返回true，没有那么直接返回false

redisTemplate.hasKey(key);

2)如果redis中有key那么直接取出key所对应的值

redisTemplate.opsForValue().get(key)

3)删除单个key值

redisTemplate.delete(key)

4)批量删除key值

redisTemplate.delete(keys)，这里面的keys是Collections<K> keys类型

5)将当前传入的key值序列化为byte[]类型

redisTemplate.dump(key)

6)设置过期时间

redisTemplate.expire(key, timeout, unit)

redisTemplate.expireAt(key, date);

@Controller
public class DemoRedis {
    @Autowired
    private StringRedisTemplate template;
    @RequestMapping("/Java100")
    @ResponseBody
    public String start(){
        template.opsForValue().set("name","zhangsan");
        template.expire("name",20, TimeUnit.SECONDS);
        return template.opsForValue().get("name");
    }
}

7)查找匹配的key值，返回一个Set集合类型

redisTemplate.keys(pattern)//patten可以传递一个*

redisTemplate.keys(pattern.concat("*)最终执行的命令是prefix *

/**
 * 根据前缀获取所有的key
 * 例如：pro_*
 */
public Set<String> getListKey(String prefix) {
    Set<String> keys = redisTemplate.keys(prefix.concat("*"));
    return keys;
}

@Controller
public class DemoRedis {
    @Autowired
    private StringRedisTemplate template;
    @RequestMapping("/Java100")
    @ResponseBody
    public String start(String pattern1,String pattern2){
        template.opsForValue().set("userID","1");
        template.opsForValue().set("username","zhangsna");
        template.opsForValue().set("userdata","12503487");
        StringBuilder builder=new StringBuilder();
        Set<String> set1=template.keys(pattern1);
        for(String key:set1){
            builder.append(key);
        }
        builder.append("
");
        //前缀进行获取
        Set<String> set2=template.keys(pattern2.concat("*"));
        for(String key:set2){
            builder.append(key);
        }
        builder.append("
");
        //批量获取value
        List<String> value1= template.opsForValue().multiGet(set1);
        value1.stream().forEach((String key)->{
            builder.append(value1);
        });
        return builder.toString();
    }

}

8)批量获取value

1)先获取你要查询的key:调用redisTemplate.keys("*)方法返回一个Set集合

2)调用redisTemplate的opsForValue方法中的multiGet()方法，里面传入Set集合的引用

/**
 * 获取所有的key
 */
public List<String> getListKey(String prefix) {
    Set<String> keys = redisTemplate.keys("*");
    List<String> values = redisTemplate.opsForValue().multiGet(keys);
    return values;
}

9)修改redis中的key的名称:redisTemplate.rename(oldKey, newKey)两个都是String类型

10)返回传入的key的所返回的值的类型: redisTemplate.type(key)

11)从redis中随机取出一个key:redisTemplate.randomKey()

12)返回当前key剩余的过期时间:redisTemplate.getExpire(key)

13)返回当前key剩余的过期时间并且指明单位:redisTemplate.getExpire(key,unit)

14)将当前数据库的key移动到指定redis中数据库当中:

redisTemplate.move(key,index)

15)设置当前的key以及value值并且设置过期时间

redisTemplate.opsForValue().set(key, value, timeout, unit)

16)返回key中字符串的子字符

redisTemplate.opsForValue().get(key, start, end)

17)批量获取value值:

 public List<String> multiGet(Collection<String> keys)
 { 
     return redisTemplate.opsForValue().multiGet(keys); 
}

18)在原有的值基础上新增字符串到末尾

redisTemplate.opsForValue().append(key, value)

Controller
public class UserController {
    @Autowired
    private StringRedisTemplate template;
    @RequestMapping("/Java200")
    @ResponseBody
    public String GetUser(String key){
        if(template.hasKey(key)){
            System.out.println("查询的是redis数据库");
            String value=template.opsForValue().get(key);
            return value;
        }else{
            System.out.println("查询的是MYSQL数据库");
            template.opsForValue().set(key,"我是中国人");
            return template.opsForValue().get(key);
        }
    }
}

判断是否有key所对应的值，有则返回true，没有则返回false
redisTemplate.hasKey(key)

有则取出key值所对应的值
redisTemplate.opsForValue().get(key)

删除单个key值
redisTemplate.delete(key)

批量删除key
redisTemplate.delete(keys) //其中keys:Collection<K> keys

将当前传入的key值序列化为byte[]类型
redisTemplate.dump(key)

设置过期时间
public Boolean expire(String key, long timeout, TimeUnit unit) {
    return redisTemplate.expire(key, timeout, unit);
 }
 public Boolean expireAt(String key, Date date) {
    return redisTemplate.expireAt(key, date);
  }
  
查找匹配的key值，返回一个Set集合类型
public Set<String> getPatternKey(String pattern) {
    return redisTemplate.keys(pattern);
}

修改redis中key的名称
 public void renameKey(String oldKey, String newKey) {
    redisTemplate.rename(oldKey, newKey);
}

返回传入key所存储的值的类型
public DataType getKeyType(String key) {
    return redisTemplate.type(key);
}

如果旧值存在时，将旧值改为新值
public Boolean renameOldKeyIfAbsent(String oldKey, String newKey) {
    return redisTemplate.renameIfAbsent(oldKey, newKey);
}

从redis中随机取出一个key
redisTemplate.randomKey()

返回当前key所对应的剩余过期时间
 public Long getExpire(String key) {
    return redisTemplate.getExpire(key);
}

返回剩余过期时间并且指定时间单位
public Long getExpire(String key, TimeUnit unit) {
    return redisTemplate.getExpire(key, unit);
}

将key持久化保存
public Boolean persistKey(String key) {
    return redisTemplate.persist(key);
}

将当前数据库的key移动到指定redis中数据库当中
public Boolean moveToDbIndex(String key, int dbIndex) {
    return redisTemplate.move(key, dbIndex);
}

设置当前的key以及value值
redisTemplate.opsForValue().set(key, value)

设置当前的key以及value值并且设置过期时间
redisTemplate.opsForValue().set(key, value, timeout, unit)

返回key中字符串的子字符
public String getCharacterRange(String key, long start, long end) {
    return redisTemplate.opsForValue().get(key, start, end);
}

将旧的key设置为value，并且返回旧的key
public String setKeyAsValue(String key, String value) {
    return redisTemplate.opsForValue().getAndSet(key, value);
}

批量获取值
 public List<String> multiGet(Collection<String> keys) {
    return redisTemplate.opsForValue().multiGet(keys);
 }
 
在原有的值基础上新增字符串到末尾
redisTemplate.opsForValue().append(key, value)

以增量的方式将double值存储在变量中
 public Double incrByDouble(String key, double increment) {
    return redisTemplate.opsForValue().increment(key, increment);
 }
 
通过increment(K key, long delta)方法以增量方式存储long值（正值则自增，负值则自减）
public Long incrBy(String key, long increment) {
    return redisTemplate.opsForValue().increment(key, increment);
}


如果对应的map集合名称不存在，则添加否则不做修改
Map valueMap = new HashMap();  
valueMap.put("valueMap1","map1");  
valueMap.put("valueMap2","map2");  
valueMap.put("valueMap3","map3");  
redisTemplate.opsForValue().multiSetIfAbsent(valueMap); 


设置map集合到redis
Map valueMap = new HashMap();  
valueMap.put("valueMap1","map1");  
valueMap.put("valueMap2","map2");  
valueMap.put("valueMap3","map3");  
redisTemplate.opsForValue().multiSet(valueMap);  

获取字符串的长度
redisTemplate.opsForValue().size(key)

用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
redisTemplate.opsForValue().set(key, value, offset)

重新设置key对应的值，如果存在返回false，否则返回true
redisTemplate.opsForValue().setIfAbsent(key, value)

将值 value 关联到 key,并将 key 的过期时间设为 timeout
redisTemplate.opsForValue().set(key, value, timeout, unit)

将二进制第offset位值变为value
redisTemplate.opsForValue().setBit(key, offset, value)

对key所储存的字符串值，获取指定偏移量上的位(bit)
redisTemplate.opsForValue().getBit(key, offset)


 

2)使用StringTemplateRedis操作hash类型

获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null。
redisTemplate.opsForHash().get(key, field)

获取变量中的键值对
public Map<Object, Object> hGetAll(String key) {
   return redisTemplate.opsForHash().entries(key);
}

新增hashMap值
redisTemplate.opsForHash().put(key, hashKey, value)

以map集合的形式添加键值对
public void hPutAll(String key, Map<String, String> maps) {
   redisTemplate.opsForHash().putAll(key, maps);
}

仅当hashKey不存在时才设置
public Boolean hashPutIfAbsent(String key, String hashKey, String value) {
   return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
}

删除一个或者多个hash表字段
public Long hashDelete(String key, Object... fields) {
   return redisTemplate.opsForHash().delete(key, fields);
}

查看hash表中指定字段是否存在
public boolean hashExists(String key, String field) {
   return redisTemplate.opsForHash().hasKey(key, field);
}

给哈希表key中的指定字段的整数值加上增量increment
public Long hashIncrBy(String key, Object field, long increment) {
   return redisTemplate.opsForHash().increment(key, field, increment);
}
public Double hIncrByDouble(String key, Object field, double delta) {
   return redisTemplate.opsForHash().increment(key, field, delta);
}

获取所有hash表中字段
redisTemplate.opsForHash().keys(key)

获取hash表中字段的数量
redisTemplate.opsForHash().size(key)

获取hash表中存在的所有的值
public List<Object> hValues(String key) {
   return redisTemplate.opsForHash().values(key);
}

匹配获取键值对，ScanOptions.NONE为获取全部键对
public Cursor<Entry<Object, Object>> hashScan(String key, ScanOptions options) {
   return redisTemplate.opsForHash().scan(key, options);
}

@Controller
public class UserController {
    @Autowired
    private StringRedisTemplate template;
    @RequestMapping("/Java200")
    @ResponseBody
    public User GetUser(int userID) {
        //1.先生成key
        String key = "spring:user" + userID;
        //2.判断key是否在redis中存在
        if (template.hasKey(key)) {
            String username = (String) template.opsForHash().get(key, "username");
            String password = (String) template.opsForHash().get(key, "password");
            String classID = (String) template.opsForHash().get(key, "classID");
            User user = new User();
            user.setUserID(userID);
            user.setUsername(username);
            user.setPassword(password);
            user.setClassID(Integer.parseInt(classID));
            System.out.println("查询的是redis数据库");
            return user;
        } else {
            System.out.println("查询的是MYSQL数据库");
            User user=new User();
            user.setUserID(userID);
            user.setUsername("lisi");
            user.setPassword("1250");
            user.setClassID(2);
            HashMap<String,String> result=new HashMap<>();
            result.put("userID",String.valueOf(user.getUserID()));
            result.put("username",user.getUsername());
            result.put("password",user.getPassword());
            result.put("classID",String.valueOf(user.getClassID()));
            template.opsForHash().putAll(key,result);
            return user;
        }
    }
}

上面是将对象中的属性存放到redis中

key:"spring:user:userID"

value

hashkey:username   hashvalue:"zhangsan"

hashkey:password   hashvalue:"12503487"

hashkey:userID     hashvalue:"1"

hashkey:classID    hashvalue:"1"

将对象存放到redis中:使用RedisTemplate类

key:"user"

value

hashkey:"1"

hashvalue:

import java.util.HashMap;

@Controller
public class UserController {
    @Autowired
    @Qualifier(value = "username")
    private RedisTemplate template;

    @RequestMapping("/Java200")
    @ResponseBody
    public User GetUser(int userID) {
        if (template.opsForHash().hasKey("user", String.valueOf(userID))) {
            User user = new User();
            user.setUserID(userID);
            user.setUsername("张三");
            user.setPassword("王五");
            user.setClassID(1);
            template.opsForHash().put("user", String.valueOf(userID), user);
            return user;
        }else{
            User user= (User) template.opsForHash().get("user",String.valueOf(userID));
            return user;
        }
    }
}

@Configuration
public class redisConfig {
    @Bean(name="username")
    public RedisTemplate<String,Object> GetRedisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template=new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //之前默认是JDK序列化,现在进行更换
        StringRedisSerializer serializer=new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer=new GenericJackson2JsonRedisSerializer();
        template.setKeySerializer(serializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(serializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }
}