精华内容
下载资源
问答
  • Redis实践

    2020-09-24 18:01:32
    Redis实践 实际项目中redis的应用场景

    Redis实践

    RedisUtil是工具类,封装了Java对redis操作

    1.计数

    • 限制接口访问量 INCR

      场景:为了防止询价接口被恶意刷,需要限制用户每日询价次数

      key:evaluate_limit_+用户唯一标识UID 例如:evaluate_limit_391128438125228

      String value = RedisUtil.get(key);
      Integer count = Strings.isEmpty(value)? 0:Integer.parseInt(value);
      if(count>=20) {
      return Result.notOk(-1, "已达到今日询价次数上限")
      }
      ....
      估价
      ....
      RedisUtil.incr(key, 24*60*60);
      
    • 统计日活,七日活,月活 HyperLogLog

      key:activity_日期 例如:activity_20200924 value:用户唯一标识比如用户UID

      Redisutil.pfAdd(key,UID );

      统计日活的话,只需要根据当日的日期拼接key:activity_+当日日期,然后调用HyperLogLog 的

      PFCOUNT即可;统计月活的话,使用PFMERGE命令合并该月每日的HyperLogLog 存储的数值即可。

    2.缓存

    • String

      场景:小程序AccessToken每两个小时需要获取一次,获取之后存到缓存中,同时设置缓存时间为expire_time。
      在这里插入图片描述

    • List

      场景:批量生成太阳码,放入list构成的队列中,需要的时候从队列中获取,避免接口直接调用小程序接口带来的接口超时

      预生成太阳码并放入队列中

      在这里插入图片描述

    在这里插入图片描述

    获取太阳码

    在这里插入图片描述

    • Hash

      场景:存储对象

      img

      比起将对象转化为json字符串再存入缓存,直接用Hash存储对象的话,可以单独更改某个filed的值。hset key field value

      hset是以哈希散列表的形式存储,超时时间只能设置在键key上,单个域field不能设置过期时间。

    • Sorted set

      场景:需要记录用户的搜索记录并且把最近一个月的历史搜索记录展示给用户(按照用户搜索时的时间倒序)

      添加用户搜索记录

      在这里插入图片描述

      注意score为当前时间时间戳+30天的毫秒数

      获取用户搜索记录

      在这里插入图片描述

      相比于集合Set,有序集合增加了score,引入了分数的概念,可以按照分数来进行排序。比如

      排行榜。在实际应用中,可以按照是否需要排序来选择使用集合Set还是有序集合Sorted set

    3.消息队列 List

    除了使用list作为队列缓存数据之外,List也可以作为消息队列。不过由于已经有比较流行的RocketMq

    等消息中间件,所以在实际的应用中一般不使用Redis作为消息队列。

    4.分布式锁

    分布式锁的实现方式有多种,比如数据库,etcd,zookeeper等,比较热门的还有redis来实现分布式锁。感兴趣可以查阅先关分布式锁资料

    展开全文
  • Redis 实践

    2011-11-03 09:41:17
    节约内存:Redis实践,节约内存:Redis实践
  • redis实践

    2015-07-15 19:34:04
    Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库

    Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库。

    ================

    redis特点:
    异常快速:Redis的速度非常快,每秒能执行约11万集合,每秒约81000+条记录。

    支持丰富的数据类型:Redis支持最大多数开发人员已经知道像列表,集合,有序集合,散列数据类型。这使得它非常容易解决各种各样的问题,因为我们知道哪些问题是可以处理通过它的数据类型更好。
    
    操作都是原子性:所有Redis操作是原子的,这保证了如果两个客户端同时访问的Redis服务器将获得更新后的值。
    
    多功能实用工具:Redis是一个多实用的工具,可以在多个用例如缓存,消息,队列使用(Redis原生支持发布/订阅),任何短暂的数据,应用程序,如Web应用程序会话,网页命中计数等。
    

    redis的安装以及配置
    1.到官网http://redis.io下载压缩文件并解压
    2.cd到redis根目录 cd /usr/local/redis-3.0.2
    3.在redis根目录编译源程序:make
    启动服务以及客户端连接
    1.启动服务:在reids根目录下输入 src/redis-server
    2.客户端连接:在reids根目录下输入 src/redis-cli

    redis数据类型
    1.string
    2.hash
    3.列表(list)
    4.集合(set)
    5.有序集合(zset)

    redis数据库基本操作
    1、插入数据,设置一个key-value对。
    set name zpeng

    2、查询数据,取出key所对应的value。
    get name

    3、删除键值,删除这个key及对应的value。
    del name

    4、验证键是否存在 ,其中0,代表此key不存在;1代表存在。
    exists name \

    5、 设置密码
    config set requirepass 123456
    config get requirepass
    auth 123456

    使用spring-redis对 redis CRUD
    参考blog: http://blog.csdn.net/java2000_wl/article/details/8543203/
    watch out:showcase使用maven构建

    pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.company.redis</groupId>
      <artifactId>spring2redis</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <dependencies>  
        <dependency>  
            <groupId>org.springframework.data</groupId>  
            <artifactId>spring-data-redis</artifactId>  
            <version>1.0.2.RELEASE</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-test</artifactId>  
            <version>3.1.2.RELEASE</version>  
            <scope>test</scope>  
        </dependency>  
    
        <dependency>  
            <groupId>redis.clients</groupId>  
            <artifactId>jedis</artifactId>  
            <version>2.1.0</version>  
        </dependency>  
    
         <dependency>  
            <groupId>junit</groupId>  
            <artifactId>junit</artifactId>  
            <version>4.8.2</version>  
            <scope>test</scope>  
        </dependency>  
    </dependencies>  
    </project>

    AbstractBaseRedisDao.java

    package com.company.dao;
    
    import org.springframework.beans.factory.annotation.Autowired;  
    import org.springframework.data.redis.core.RedisTemplate;  
    import org.springframework.data.redis.serializer.RedisSerializer;  
    
    /**  
     * AbstractBaseRedisDao 
     * @author http://blog.csdn.net/java2000_wl  
     * @version <b>1.0</b>  
     */   
    public abstract class AbstractBaseRedisDao<K, V> {  
    
        @Autowired  
        protected RedisTemplate<K, V> redisTemplate;  
    
        /** 
         * 设置redisTemplate 
         * @param redisTemplate the redisTemplate to set 
         */  
        public void setRedisTemplate(RedisTemplate<K, V> redisTemplate) {  
            this.redisTemplate = redisTemplate;  
        }  
    
        /** 
         * 获取 RedisSerializer 
         * <br>------------------------------<br> 
         */  
        protected RedisSerializer<String> getRedisSerializer() {  
            return redisTemplate.getStringSerializer();  
        }  
    }  

    IUserDao.java

    package com.company.dao;
    
    import java.util.List;  
    
    import com.company.entity.User;  
    
    /**  
     * @version <b>1.0</b>  
     */   
    public interface IUserDao {  
    
        /** 
         * 新增 
         * <br>------------------------------<br> 
         * @param user 
         * @return 
         */  
        boolean add(User user);  
    
        /** 
         * 批量新增 使用pipeline方式 
         * <br>------------------------------<br> 
         * @param list 
         * @return 
         */  
        boolean add(List<User> list);  
    
        /** 
         * 删除 
         * <br>------------------------------<br> 
         * @param key 
         */  
        void delete(String key);  
    
        /** 
         * 删除多个 
         * <br>------------------------------<br> 
         * @param keys 
         */  
        void delete(List<String> keys);  
    
        /** 
         * 修改 
         * <br>------------------------------<br> 
         * @param user 
         * @return  
         */  
        boolean update(User user);  
    
        /** 
         * 通过key获取 
         * <br>------------------------------<br> 
         * @param keyId 
         * @return  
         */  
        User get(String keyId);  
    }  

    UserDao.java

    package com.company.dao;
    
    
    import java.util.ArrayList;  
    import java.util.List;  
    
    import org.springframework.dao.DataAccessException;  
    import org.springframework.data.redis.connection.RedisConnection;  
    import org.springframework.data.redis.core.RedisCallback;  
    import org.springframework.data.redis.serializer.RedisSerializer;  
    import org.springframework.util.Assert;  
    
    import com.company.dao.AbstractBaseRedisDao;  
    import com.company.dao.IUserDao;  
    import com.company.entity.User;  
    
    /**  
    * Dao 
    * @version <b>1.0</b>  
    */   
    public class UserDao extends AbstractBaseRedisDao<String, User> implements IUserDao {  
    
      /**  
       * 新增 
       *<br>------------------------------<br> 
       * @param user 
       * @return 
       */  
      public boolean add(final User user) {  
          boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
              public Boolean doInRedis(RedisConnection connection) throws DataAccessException {  
                  RedisSerializer<String> serializer = getRedisSerializer();  
                  byte[] key  = serializer.serialize(user.getId());  
                  byte[] name = serializer.serialize(user.getName());  
                  return connection.setNX(key, name);  
              }  
          });  
          return result;  
      }  
    
      /** 
       * 批量新增 使用pipeline方式   
       *<br>------------------------------<br> 
       *@param list 
       *@return 
       */  
      public boolean add(final List<User> list) {  
          Assert.notEmpty(list);  
          boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
              public Boolean doInRedis(RedisConnection connection) throws DataAccessException {  
                  RedisSerializer<String> serializer = getRedisSerializer();  
                  for (User user : list) {  
                      byte[] key  = serializer.serialize(user.getId());  
                      byte[] name = serializer.serialize(user.getName());  
                      connection.setNX(key, name);  
                  }  
                  return true;  
              }  
          }, false, true);  
          return result;  
      }  
    
      /**  
       * 删除 
       * <br>------------------------------<br> 
       * @param key 
       */  
      public void delete(String key) {  
          List<String> list = new ArrayList<String>();  
          list.add(key);  
          delete(list);  
      }  
    
      /** 
       * 删除多个 
       * <br>------------------------------<br> 
       * @param keys 
       */  
      public void delete(List<String> keys) {  
          redisTemplate.delete(keys);  
      }  
    
      /** 
       * 修改  
       * <br>------------------------------<br> 
       * @param user 
       * @return  
       */  
      public boolean update(final User user) {  
          String key = user.getId();  
          if (get(key) == null) {  
              throw new NullPointerException("数据行不存在, key = " + key);  
          }  
          boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
              public Boolean doInRedis(RedisConnection connection)  
                      throws DataAccessException {  
                  RedisSerializer<String> serializer = getRedisSerializer();  
                  byte[] key  = serializer.serialize(user.getId());  
                  byte[] name = serializer.serialize(user.getName());  
                  connection.set(key, name);  
                  return true;  
              }  
          });  
          return result;  
      }  
    
      /**  
       * 通过key获取 
       * <br>------------------------------<br> 
       * @param keyId 
       * @return 
       */  
      public User get(final String keyId) {  
          User result = redisTemplate.execute(new RedisCallback<User>() {  
              public User doInRedis(RedisConnection connection) throws DataAccessException {  
                  RedisSerializer<String> serializer = getRedisSerializer();  
                  byte[] key = serializer.serialize(keyId);  
                  byte[] value = connection.get(key);  
                  if (value == null) {  
                      return null;  
                  }  
                  String name = serializer.deserialize(value);  
                  return new User(keyId, name, null);  
              }  
          });  
          return result;  
      }  
    }  

    User.java

    package com.company.entity;
    
    import java.io.Serializable;  
    
    public class User implements Serializable {  
    
        private static final long serialVersionUID = -6011241820070393952L;  
    
        private String id;  
    
        private String name;  
    
        private String password;  
    
        /** 
         * <br>------------------------------<br> 
         */  
        public User() {  
    
        }  
    
        /** 
         * <br>------------------------------<br> 
         */  
        public User(String id, String name, String password) {  
            super();  
            this.id = id;  
            this.name = name;  
            this.password = password;  
        }  
    
        /** 
         * 获得id 
         * @return the id 
         */  
        public String getId() {  
            return id;  
        }  
    
        /** 
         * 设置id 
         * @param id the id to set 
         */  
        public void setId(String id) {  
            this.id = id;  
        }  
    
        /** 
         * 获得name 
         * @return the name 
         */  
        public String getName() {  
            return name;  
        }  
    
        /** 
         * 设置name 
         * @param name the name to set 
         */  
        public void setName(String name) {  
            this.name = name;  
        }  
    
        /** 
         * 获得password 
         * @return the password 
         */  
        public String getPassword() {  
            return password;  
        }  
    
        /** 
         * 设置password 
         * @param password the password to set 
         */  
        public void setPassword(String password) {  
            this.password = password;  
        }  
    
        @Override
        public String toString() {
            return this.id + "+" + this.name + "+" + this.password;
        }
    }  

    Spring2RedisTest.java

    package com.company.test;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import junit.framework.Assert;
    
    import org.junit.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
    
    import com.company.dao.IUserDao;
    import com.company.entity.User;
    
    /**  
     * 测试 
     * @author http://blog.csdn.net/java2000_wl  
     * @version <b>1.0</b>  
     */    
    @ContextConfiguration(locations = {"classpath*:applicationContext.xml"})  
    public class Spring2RedisTest extends AbstractJUnit4SpringContextTests {  
        @Autowired
        private IUserDao userDao;  
    
        /** 
         * 新增 
         * <br>------------------------------<br> 
         */  
        @Test  
        public void testAddUser() {  
            User user = new User();  
            user.setId("user2");  
            user.setName("123456");  
            user.setPassword("520loveu");
            boolean result = userDao.add(user);  
            Assert.assertTrue(result);  
        }  
    
        /** 
         * 批量新增 普通方式 
         * <br>------------------------------<br> 
         */  
        @Test  
        public void testAddUsers1() {  
            List<User> list = new ArrayList<User>();  
            for (int i = 10; i < 50000; i++) {  
                User user = new User();  
                user.setId("user" + i);  
                user.setName("java2000_wl" + i);  
                list.add(user);  
            }  
            long begin = System.currentTimeMillis();  
            for (User user : list) {  
                userDao.add(user);  
            }  
            System.out.println(System.currentTimeMillis() -  begin);  
        }  
    
        /** 
         * 批量新增 pipeline方式 
         * <br>------------------------------<br> 
         */  
        @Test  
        public void testAddUsers2() {  
            List<User> list = new ArrayList<User>();  
            for (int i = 10; i < 1500000; i++) {  
                User user = new User();  
                user.setId("user" + i);  
                user.setName("java2000_wl" + i);  
                list.add(user);  
            }  
            long begin = System.currentTimeMillis();  
            boolean result = userDao.add(list);  
            System.out.println(System.currentTimeMillis() - begin);  
            Assert.assertTrue(result);  
        }  
    
        /** 
         * 修改 
         * <br>------------------------------<br> 
         */  
        @Test  
        public void testUpdate() {  
            User user = new User();  
            user.setId("user1");  
            user.setName("new_password");  
            boolean result = userDao.update(user);  
            Assert.assertTrue(result);  
        }  
    
        /** 
         * 通过key删除单个 
         * <br>------------------------------<br> 
         */  
        @Test  
        public void testDelete() {  
            String key = "user1";  
            userDao.delete(key);  
        }  
    
        /** 
         * 批量删除 
         * <br>------------------------------<br> 
         */  
        @Test  
        public void testDeletes() {  
            List<String> list = new ArrayList<String>();  
            for (int i = 0; i < 10; i++) {  
                list.add("user" + i);  
            }  
            userDao.delete(list);  
        }  
    
        /** 
         * 获取 
         * <br>------------------------------<br> 
         */  
        @Test  
        public void testGetUser() {  
            String id = "user2";  
            User user = userDao.get(id);  
            System.out.println(user);
            Assert.assertNotNull(user);  
            Assert.assertEquals(user.getName(), "123456");  
        }  
    
        /** 
         * 设置userDao 
         * @param userDao the userDao to set 
         */  
        public void setUserDao(IUserDao userDao) {  
            this.userDao = userDao;  
        }  
    }  
    展开全文
  • Redis实践合集

    2020-04-09 14:57:22
  • Windows下Redis实践

    2017-12-20 10:50:39
    Windows下Redis实践 目录如下: 1、Redis简介 2、Redis实践 3、Redis命令
  • 美团redis实践

    2017-11-21 15:03:05
    美团redis实践踩过的一些坑。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • Redis实践与总结

    2018-10-20 14:58:10
    Redis实践与总结 内容详尽使用,适合一线开发人员使用
  • redis合集(深入了解redis,redis实践,redis适用场景及实现,redis学习笔记整理,redis命令参考手册,python简明教程.chm,redis_cmd.chm)
  • redis实践小结

    2019-08-27 11:03:46
    redis实践小结redis快速入门下载安装启动服务端(使用默认参数)使用内置的客户端redis的命令手册可以通过官网查看,非常齐全[redis commonds](https://redis.io/commands)redis 安装进阶一修改配置文件,增加安全性...

    redis快速入门

    下载安装

    wget http://download.redis.io/releases/redis-5.0.5.tar.gz
    tar xzf redis-5.0.5.tar.gz
    cd redis-5.0.5
    make
    

    启动服务端(使用默认参数)

    src/redis-server
    

    使用内置的客户端

    $src/redis-cli
    redis> set foo bar
    OK
    redis> get foo
    "bar"
    redis> keys f*
    1) "foo"
    redis>del foo
    (integer) 1
    

    redis的命令手册可以通过官网查看,非常齐全redis commonds

    redis 安装进阶一

    修改配置文件,增加安全性

    • 设置密码,增加安全性
    • 修改密码
    • 增加日志文件

    执行vi redis.conf 文件修改

    requirepass 123456 # 登录密码
    port 6380   #  修改端口
    logfile /var/log/redis_6379.log  #日志目录
    

    重启redis服务
    由于重启服务根据不同的安装方式, 有不同的重启方式,这里就不一一列出了, 我使用的中级重启大法kill -9,因为修改了配置文件, 所以在启动redis时需要之指定配置文件

    src/redis-server redis.conf
    

    配置主机自启动和后台运行

    执行vim /etc/rc.local在最后添加

    /data/redis-5.0.5/src/redis-server /data/redis-5.0.5/6379.conf
    

    最后执行

    /data/redis-5.0.5/src/redis-server&
    

    安装redis客户端

    看网上用的比较多的是:Medis

    欢迎斧正

    展开全文
  • 节约内存:Instagram的Redis实践
  • Redis 实践笔记

    2012-12-22 22:40:00
    Redis 实践笔记 最近在项目中实践了一下Redis,过程中遇到并解决了若干问题,记录之. Why Redis 我们这个项目是对原有缓存系统的改进,应用场景是论坛发帖,回帖,置顶,以及操作日志等等;原有系统会有...
  • 新浪微博开放平台redis 实践,,,,,为点资源分..上传资料..
  • 新浪微博中redis实践: 好友关系 计数器 redis简介 内存中的database? 数据能够刷到硬盘上,能够持久化。 数据结构:string(字符串)、list(链表)、set(集合)、zset(有序集合sorted set)和hash...
  • Qcon2011 杭州上的ppt:新浪微博开放平台中的 redis 实践
  • Redis实践C# vs2015

    2019-06-21 20:54:29
    vs2015 .net4.6.1 windows Redis-x64-3.2.100.mis StackExchange.Redis2.0.601 发布日期:2019.04.16(请在NuGet下载)
  • redis实践中的常见问题及解决 1.fork耗时导致高并发请求延时 RDB和AOF的时候,其实会有生成RDB快照,AOF rewrite,耗费磁盘IO的过程,主进程fork子进程,fork的时候,子进程是需要拷贝父进程的空间内存页表的,也会...
  • 《深入理解Spring Cloud与微服务构建》学习笔记(六)-整合redis实践,可以直接运行学习参考。
  • 新浪微博-redis实践

    2017-12-07 18:43:43
    redis使用用及优化建议 redis不是万能的:合理的业务选型 明确redis业务使用规范 按照业务线独立部署:避免混用 线上版本尽量统一 拥抱需求,持续优化
  • Instagram的Redis实践

    2012-04-10 10:43:31
    节约内存:Instagram的Redis实践 作者:nosqlfan on 星期三, 十一月 2, 2011 · 9条评论 【阅读:3,933 次】  Instagram可以说是网拍App的始祖级应用,也是当前最火热的拍照App之一,Instagram的...
  • Spring Data Redis 实践

    千次阅读 2016-10-24 11:12:06
    关于Spring Data Redis的简单应用以及1.7新特性Redis Repositories简介~
  • 文章目录redisredis性能redis三大问题缓存穿透缓存雪崩缓存击穿redis应用发布订阅模式redis事务Lua脚本分布式锁redis数据加速数据一致性问题热点key监控redis客户端redis优化策略 redis redis性能 redis的速度有多快...
  • cas4.1.2+redis实践

    2017-03-28 11:47:52
    jdk1.8,其中用到redis存储tickets,使用了代理模式、restful、自定义用户验证等,由于文件大小的限制,client1和casproxy只有应用,把其解压后下面的目录拷贝到tomcat下的webapp即能使用,如果没有redis需要修改...
  • Redis实践(一):安装和部署

    千次阅读 2017-08-02 16:54:09
    memcache,Redis,MongoDB 是目前常用的内存数据库。他们应用的场景大致如下: redis:数据量较小的更性能操作和运算上 memcache:用于在动态系统中减少...本章开始介绍redis实践的过程,只有经过自己的实践才能成
  • REDIS实践应用

    2016-09-03 10:21:38
    一.Redis是什么 1 Redis是一个高效率的内存存储系统,内存数据库,类似memcached 2 也可将其称为一种数据结构服务器,因其可以支持丰富的数据结构。 3 可持久存储 端口:6379 Alessia Merz   linux...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,443
精华内容 2,177
关键字:

redis实践

redis 订阅