初学Redis(自己做笔记用)

1 redis是什么?

  •   Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。换句话说,Redis就像是一个HashMap,不过不是在JVM中运行,而是以一个独立进程的形式运行。
  • 一般说来,会被当作缓存使用。 因为它比数据库(mysql)快,所以常用的数据,可以考虑放在这里,这样就提供了性能。
  • redis官网:http://redis.io   windows版本的下载地址是: http://redis.io/download 点击进去之后会跳转到: https://github.com/mythz/redis-windows 

2 常用命令

  •      5种数据类型     String(字符串) List(列表) Hash(字典) Set(集合)Sorted Set(有序集合)
  • 在客户端操作 :演示(String)
  •    如果还想查询每个命令的详细用法,请到redis官方命令手册:http://www.redis.cn/commands.html

3Java代码怎么访问和使用

  •        下载它第三方jar包 :Jedis就能方便地访问Redis的各种服务了

         

 

4 Spring 对 Redis的支持

  1.  配置redis.properties,指定链接redis服务器的相关信息
  2.       applicationContext.xml           配置连接池,连接工厂等,以上都是为了RedisTemplate 服务,这个类就提供常用的访问 Redis的方法。然后又把这个      RedisTemplate 类的实例,注入到 RedisUtil 工具类里,方便调用
  3. 工具类
    package com.dam;
    
     
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.util.CollectionUtils;
    	 
    	/**
    	 * 基于spring和redis的redisTemplate工具类
    	 * 针对所有的hash 都是以h开头的方法
    	 * 针对所有的Set 都是以s开头的方法                    不含通用方法
    	 * 针对所有的List 都是以l开头的方法
    	 */
    	public class RedisUtil {
    	    private RedisTemplate<String, Object> redisTemplate;
    	     
    	    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
    	        this.redisTemplate = redisTemplate;
    	    }
    	    //=============================common============================
    	    /**
    	     * 指定缓存失效时间
    	     * @param key 键
    	     * @param time 时间(秒)
    	     * @return
    	     */
    	    public boolean expire(String key,long time){
    	        try {
    	            if(time>0){
    	                redisTemplate.expire(key, time, TimeUnit.SECONDS);
    	            }
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 根据key 获取过期时间
    	     * @param key 键 不能为null
    	     * @return 时间(秒) 返回0代表为永久有效
    	     */
    	    public long getExpire(String key){
    	        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    	    }
    	     
    	    /**
    	     * 判断key是否存在
    	     * @param key 键
    	     * @return true 存在 false不存在
    	     */
    	    public boolean hasKey(String key){
    	        try {
    	            return redisTemplate.hasKey(key);
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 删除缓存
    	     * @param key 可以传一个值 或多个
    	     */
    	    @SuppressWarnings("unchecked")
    	    public void del(String ... key){
    	        if(key!=null&&key.length>0){
    	            if(key.length==1){
    	                redisTemplate.delete(key[0]);
    	            }else{
    	                redisTemplate.delete(CollectionUtils.arrayToList(key));
    	            }
    	        }
    	    }
    	     
    	    //============================String=============================
    	    /**
    	     * 普通缓存获取
    	     * @param key 键
    	     * @return 值
    	     */
    	    public Object get(String key){
    	        return key==null?null:redisTemplate.opsForValue().get(key);
    	    }
    	     
    	    /**
    	     * 普通缓存放入
    	     * @param key 键
    	     * @param value 值
    	     * @return true成功 false失败
    	     */
    	    public boolean set(String key,Object value) {
    	         try {
    	            redisTemplate.opsForValue().set(key, value);
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	         
    	    }
    	     
    	    /**
    	     * 普通缓存放入并设置时间
    	     * @param key 键
    	     * @param value 值
    	     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
    	     * @return true成功 false 失败
    	     */
    	    public boolean set(String key,Object value,long time){
    	        try {
    	            if(time>0){
    	                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    	            }else{
    	                set(key, value);
    	            }
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 递增
    	     * @param key 键
    	     * @param by 要增加几(大于0)
    	     * @return
    	     */
    	    public long incr(String key, long delta){ 
    	        if(delta<0){
    	            throw new RuntimeException("递增因子必须大于0");
    	        }
    	        return redisTemplate.opsForValue().increment(key, delta);
    	    }
    	     
    	    /**
    	     * 递减
    	     * @param key 键
    	     * @param by 要减少几(小于0)
    	     * @return
    	     */
    	    public long decr(String key, long delta){ 
    	        if(delta<0){
    	            throw new RuntimeException("递减因子必须大于0");
    	        }
    	        return redisTemplate.opsForValue().increment(key, -delta); 
    	    } 
    	     
    	    //================================Map=================================
    	    /**
    	     * HashGet
    	     * @param key 键 不能为null
    	     * @param item 项 不能为null
    	     * @return 值
    	     */
    	    public Object hget(String key,String item){
    	        return redisTemplate.opsForHash().get(key, item);
    	    }
    	     
    	    /**
    	     * 获取hashKey对应的所有键值
    	     * @param key 键
    	     * @return 对应的多个键值
    	     */
    	    public Map<Object,Object> hmget(String key){
    	        return redisTemplate.opsForHash().entries(key);
    	    }
    	     
    	    /**
    	     * HashSet
    	     * @param key 键
    	     * @param map 对应多个键值
    	     * @return true 成功 false 失败
    	     */
    	    public boolean hmset(String key, Map<String,Object> map){ 
    	        try {
    	            redisTemplate.opsForHash().putAll(key, map);
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * HashSet 并设置时间
    	     * @param key 键
    	     * @param map 对应多个键值
    	     * @param time 时间(秒)
    	     * @return true成功 false失败
    	     */
    	    public boolean hmset(String key, Map<String,Object> map, long time){ 
    	        try {
    	            redisTemplate.opsForHash().putAll(key, map);
    	            if(time>0){
    	                expire(key, time);
    	            }
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 向一张hash表中放入数据,如果不存在将创建
    	     * @param key 键
    	     * @param item 项
    	     * @param value 值
    	     * @return true 成功 false失败
    	     */
    	    public boolean hset(String key,String item,Object value) {
    	         try {
    	            redisTemplate.opsForHash().put(key, item, value);
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 向一张hash表中放入数据,如果不存在将创建
    	     * @param key 键
    	     * @param item 项
    	     * @param value 值
    	     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
    	     * @return true 成功 false失败
    	     */
    	    public boolean hset(String key,String item,Object value,long time) {
    	         try {
    	            redisTemplate.opsForHash().put(key, item, value);
    	            if(time>0){
    	                expire(key, time);
    	            }
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 删除hash表中的值
    	     * @param key 键 不能为null
    	     * @param item 项 可以使多个 不能为null
    	     */
    	    public void hdel(String key, Object... item){ 
    	        redisTemplate.opsForHash().delete(key,item);
    	    }
    	     
    	    /**
    	     * 判断hash表中是否有该项的值
    	     * @param key 键 不能为null
    	     * @param item 项 不能为null
    	     * @return true 存在 false不存在
    	     */
    	    public boolean hHasKey(String key, String item){
    	        return redisTemplate.opsForHash().hasKey(key, item);
    	    }
    	     
    	    /**
    	     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
    	     * @param key 键
    	     * @param item 项
    	     * @param by 要增加几(大于0)
    	     * @return
    	     */
    	    public double hincr(String key, String item,double by){ 
    	        return redisTemplate.opsForHash().increment(key, item, by);
    	    }
    	     
    	    /**
    	     * hash递减
    	     * @param key 键
    	     * @param item 项
    	     * @param by 要减少记(小于0)
    	     * @return
    	     */
    	    public double hdecr(String key, String item,double by){ 
    	        return redisTemplate.opsForHash().increment(key, item,-by); 
    	    } 
    	     
    	    //============================set=============================
    	    /**
    	     * 根据key获取Set中的所有值
    	     * @param key 键
    	     * @return
    	     */
    	    public Set<Object> sGet(String key){
    	        try {
    	            return redisTemplate.opsForSet().members(key);
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return null;
    	        }
    	    }
    	     
    	    /**
    	     * 根据value从一个set中查询,是否存在
    	     * @param key 键
    	     * @param value 值
    	     * @return true 存在 false不存在
    	     */
    	    public boolean sHasKey(String key,Object value){
    	        try {
    	            return redisTemplate.opsForSet().isMember(key, value);
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 将数据放入set缓存
    	     * @param key 键
    	     * @param values 值 可以是多个
    	     * @return 成功个数
    	     */
    	    public long sSet(String key, Object...values) {
    	        try {
    	            return redisTemplate.opsForSet().add(key, values);
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return 0;
    	        }
    	    }
    	     
    	    /**
    	     * 将set数据放入缓存
    	     * @param key 键
    	     * @param time 时间(秒)
    	     * @param values 值 可以是多个
    	     * @return 成功个数
    	     */
    	    public long sSetAndTime(String key,long time,Object...values) {
    	        try {
    	            Long count = redisTemplate.opsForSet().add(key, values);
    	            if(time>0) expire(key, time);
    	            return count;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return 0;
    	        }
    	    }
    	     
    	    /**
    	     * 获取set缓存的长度
    	     * @param key 键
    	     * @return
    	     */
    	    public long sGetSetSize(String key){
    	        try {
    	            return redisTemplate.opsForSet().size(key);
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return 0;
    	        }
    	    }
    	     
    	    /**
    	     * 移除值为value的
    	     * @param key 键
    	     * @param values 值 可以是多个
    	     * @return 移除的个数
    	     */
    	    public long setRemove(String key, Object ...values) {
    	        try {
    	            Long count = redisTemplate.opsForSet().remove(key, values);
    	            return count;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return 0;
    	        }
    	    }
    	    //===============================list=================================
    	     
    	    /**
    	     * 获取list缓存的内容
    	     * @param key 键
    	     * @param start 开始
    	     * @param end 结束  0 到 -1代表所有值
    	     * @return
    	     */
    	    public List<Object> lGet(String key,long start, long end){
    	        try {
    	            return redisTemplate.opsForList().range(key, start, end);
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return null;
    	        }
    	    }
    	     
    	    /**
    	     * 获取list缓存的长度
    	     * @param key 键
    	     * @return
    	     */
    	    public long lGetListSize(String key){
    	        try {
    	            return redisTemplate.opsForList().size(key);
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return 0;
    	        }
    	    }
    	     
    	    /**
    	     * 通过索引 获取list中的值
    	     * @param key 键
    	     * @param index 索引  index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
    	     * @return
    	     */
    	    public Object lGetIndex(String key,long index){
    	        try {
    	            return redisTemplate.opsForList().index(key, index);
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return null;
    	        }
    	    }
    	     
    	    /**
    	     * 将list放入缓存
    	     * @param key 键
    	     * @param value 值
    	     * @param time 时间(秒)
    	     * @return
    	     */
    	    public boolean lSet(String key, Object value) {
    	        try {
    	            redisTemplate.opsForList().rightPush(key, value);
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 将list放入缓存
    	     * @param key 键
    	     * @param value 值
    	     * @param time 时间(秒)
    	     * @return
    	     */
    	    public boolean lSet(String key, Object value, long time) {
    	        try {
    	            redisTemplate.opsForList().rightPush(key, value);
    	            if (time > 0) expire(key, time);
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 将list放入缓存
    	     * @param key 键
    	     * @param value 值
    	     * @param time 时间(秒)
    	     * @return
    	     */
    	    public boolean lSet(String key, List<Object> value) {
    	        try {
    	            redisTemplate.opsForList().rightPushAll(key, value);
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 将list放入缓存
    	     * @param key 键
    	     * @param value 值
    	     * @param time 时间(秒)
    	     * @return
    	     */
    	    public boolean lSet(String key, List<Object> value, long time) {
    	        try {
    	            redisTemplate.opsForList().rightPushAll(key, value);
    	            if (time > 0) expire(key, time);
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 根据索引修改list中的某条数据
    	     * @param key 键
    	     * @param index 索引
    	     * @param value 值
    	     * @return
    	     */
    	    public boolean lUpdateIndex(String key, long index,Object value) {
    	        try {
    	            redisTemplate.opsForList().set(key, index, value);
    	            return true;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return false;
    	        }
    	    }
    	     
    	    /**
    	     * 移除N个值为value
    	     * @param key 键
    	     * @param count 移除多少个
    	     * @param value 值
    	     * @return 移除的个数
    	     */
    	    public long lRemove(String key,long count,Object value) {
    	        try {
    	            Long remove = redisTemplate.opsForList().remove(key, count, value);
    	            return remove;
    	        } catch (Exception e) {
    	            e.printStackTrace();
    	            return 0;
    	        }
    	    }
    	     
    	}
    

    4 使用  

     public static void main(String[] args) throws Exception {
    	        ApplicationContext context=new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); 
    	        RedisUtil redisUtil=(RedisUtil) context.getBean("redisUtil");
    	         
    	        //=====================testString======================
    	        redisUtil.set("name", "hello");
    	        System.out.println(redisUtil.get("name"));
    	        redisUtil.del("name");
    	        System.out.println(redisUtil.get("name"));
    	         
    	        //=====================testNumber======================
    	        long incr = redisUtil.incr("number", 1);
    	        System.out.println(incr);
    	        incr =redisUtil.incr("number", 1);
    	        System.out.println(incr);
    	         
    	        //=====================testMap======================       
    	        Map<String,Object> map=new HashMap<>();
    	        map.put("name", "meepo");
    	        map.put("pwd", "password");
    	        redisUtil.hmset("user", map);
     	     //   System.out.println(redisUtil.get("user"));
    	        System.out.println(redisUtil.hget("user","name"));
    	        System.out.println(redisUtil.hget("user", "pwd"));
    	    }

     

 

 

 

 

 

 

 

 

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值