Redis介绍(六)

Redis介绍

Redis 是一个速度非常快的非关系数据库,它可以存储键(key)与 5 种不同类型的值(value)之间的映射(mapping),
可以将存储在内存的键值对数据持久化到硬盘,可以使用复制特性来扩展读性能,还可以使用客户端分片来扩展写性能。
为了满足高性能,Redis 采用内存(in-memory)数据集(dataset)。根据使用场景,可以通过每隔一段时间转储数据
集到磁盘,或者追加每条命令到日志来持久化。持久化也可以被禁用,如果只是需要一个功能丰富,网络化的内存缓存。

支持的数据类型包括:

    string(字符串)
    hash(哈希)
    list(列表)
    set(集合)
    zset(sorted set:有序集合)

优势:

Redis 的优势包括它的速度、它对富数据类型的支持、它的操作的原子性,以及它的通用性:
    A、性能极高,它每秒可执行约 100,000 个 set 以及约 100,000 个 get 操作。
    B、丰富的数据类型,Redis 对大多数开发人员已知道的大多数数据类型提供了原生支持,这使得各种问题得以轻松解决。
    C、原子性,因为所有 Redis 操作都是原子性的,所以多个客户端会并发地访问一个 Redis 服务器,获取相同的更新值。
    D、丰富的特性,Redis 是一个多效用工具,有非常多的应用场景,包括缓存、消息队列(Redis 原生支持发布/订阅)、
       短期应用程序数据(如 Web 会话、Web 页面命中计数)等。

spring-boot-starter-data-redis

Spring Boot 提供了对 Redis 集成的组件包: spring-boot-starter-data-redis 。
spring-boot-starter-data-redis 依赖于 spring-data-redis  和 jedis 。

A、Jedis:Jedis 是 Redis 的 Java 版客户端实现,是官方推荐的 Java 版客户端。它封装了对 Redis 的各种操作,
   并且支持事务、管道及有 Jedis 自身实现的分布式。
B、Spring Data:Spring Data 是 Spring 框架中的一个主要项目,目的是为了简化构建基于 Spring 框架应用的数
   据访问,包括非关系数据库、Map-Reduce 框架、云数据服务等,另外也包含对关系数据库的访问支持。
C、Spring Data Redis :Spring Data Redis 是 Spring Data 项目中的一个主要模块,实现了对 Jedis 客户端
   API 的高度封装,使对 Redis 的操作更加便捷。

他们之间的关系:
        Jedis -> Spring Data Redis -> Spring Data -> spring-boot-starter-data-redis
        所以 Spring Data Redis 和 Jedis 具备的功能,spring-boot-starter-data-redis 都会有。

案例演示

POM.XML *****我们使用的是1.5.8版本

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>

User类:

    public class User implements Serializable{
        private Long id;
        private String userName;
        private String password;
        private String email;
        private String nickname;
        private String regTime;

        //setter、getter方法省略
    }

RedisConfig类:

    @Configuration
    @EnableCaching  //开启缓存
    public class RedisConfig extends CachingConfigurerSupport{

        @Bean
        public KeyGenerator keyGenerator(){

            return new KeyGenerator() {
                @Override
                public Object generate(Object targe, Method method, Object... params) {
                    StringBuilder sb=new StringBuilder();
                    sb.append(targe.getClass().getName());
                    sb.append(method.getName());
                    for(Object obj:params){
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }

        @Bean
        public CacheManager cacheManager(RedisTemplate redisTemplate){
            RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
            rcm.setDefaultExpiration(60);
            return rcm;
        }
    }

application.properties

    # Redis 数据库索引(默认为0)
    spring.redis.database=0
    # Redis 服务器地址
    spring.redis.host=192.168.0.71
    # 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=10000

TestRedisTemplate测试类:

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class TestRedisTemplate {
        @Autowired
        private RedisTemplate redisTemplate;

        @Test
        public void testString(){
            redisTemplate.opsForValue().set("kid","doudou");
            Assert.assertEquals("doudou",redisTemplate.opsForValue());
        }

        //新建一个 User 对象,放到缓存中,再取出来
        @Test
        public void testObj() throws InterruptedException{
            User user=new User("[email protected]", "expire", "youknow", "expire","2020");
            ValueOperations<String,User> operations=redisTemplate.opsForValue();
            operations.set("expire",user,100, TimeUnit.MICROSECONDS);
            Thread.sleep(1000);
            boolean exists=redisTemplate.hasKey("expire");
            if(exists){
                System.out.println("exists is true");
            }else{
                System.out.println("exists is false");
            }
        }

        @Test
        public void testDelete() {
            ValueOperations<String, User> operations=redisTemplate.opsForValue();
            redisTemplate.opsForValue().set("deletekey", "ityouknow");
            redisTemplate.delete("deletekey");
            boolean exists=redisTemplate.hasKey("deletekey");
            if(exists){
                System.out.println("exists is true");
            }else{
                System.out.println("exists is false");
            }
        }

        @Test
        public void testHash() {
            HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
            hash.put("hash","you","you");
            String value=(String) hash.get("hash","you");
            System.out.println("hash value :"+value);
        }

        @Test
        public void testSet() {
            String key="set";
            redisTemplate.delete(key);
            SetOperations<String, String> set = redisTemplate.opsForSet();
            set.add(key,"it");
            set.add(key,"you");
            set.add(key,"you");
            set.add(key,"know");
            Set<String> values=set.members(key);
            for (String v:values){
                System.out.println("set value :"+v);
            }
        }

        @Test
        public void testSetMore() {
            SetOperations<String, String> set = redisTemplate.opsForSet();
            String key1="setMore1";
            String key2="setMore2";
            set.add(key1,"it");
            set.add(key1,"you");
            set.add(key1,"you");
            set.add(key1,"know");
            set.add(key2,"xx");
            set.add(key2,"know");
            Set<String> diffs=set.difference(key1,key2);
            for (String v:diffs){
                System.out.println("diffs set value :"+v);
            }

            String key3="setMore3";
            String key4="setMore4";
            set.add(key3,"it");
            set.add(key3,"you");
            set.add(key3,"xx");
            set.add(key4,"aa");
            set.add(key4,"bb");
            set.add(key4,"know");
            Set<String> unions=set.union(key3,key4);
            for (String v:unions){
                System.out.println("unions value :"+v);
            }
        }

        @Test
        public void testZset(){
            String key="zset";
            redisTemplate.delete(key);
            ZSetOperations<String, String> zset = redisTemplate.opsForZSet();
            zset.add(key,"it",1);
            zset.add(key,"you",6);
            zset.add(key,"know",4);
            zset.add(key,"neo",3);

            Set<String> zsets=zset.range(key,0,3);
            for (String v:zsets){
                System.out.println("zset value :"+v);
            }

            Set<String> zsetB=zset.rangeByScore(key,0,3);
            for (String v:zsetB){
                System.out.println("zsetB value :"+v);
            }
        }
    }

原文地址:https://www.cnblogs.com/miantiao312/p/9840272.html

时间: 2024-10-07 09:54:24

Redis介绍(六)的相关文章

转:Redis介绍及常用命令大全

一 Redis介绍 Redis是一个开源的使用ANSI C语言编写.支持网络.可基于内存亦可持久化的日志型.Key-Value数据库,并提供多种语言的API.从2010年3月15日起,Redis的开发工作由VMware主持. Redis能运行在大多数POSIX(Linux, *BSD, OS X 和Solaris等)系统上,官方没有支持Windows的版本.目前最新的版本是2.2.11,这个版本主要是修复了一个2.2.7版本中遍历方式优化带来的一个bug. 和普通的Key-Value结构不同,R

Redis介绍及常用命令

Redis介绍及常用命令 Redis是一个key-value存储系统.和Memcached类似,但是解决了断电后数据完全丢失的情况,而且她支持更多无化的value类型,除了和string外,还支持lists(链表).sets(集合).zsets(有序集合).Hashes(哈希表)几种数据类型.这些数据类型都支持push/pop.add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的. 博客分类: NoSql---Redis nosqlredis 一 Redis介绍 Red

NoSQL介绍(六)

NoSQL介绍(六) Redis集群 多个redis节点网络互联,数据共享.所有的节点都是一主一从(可以是多个从),其中从不提供服务,仅作为备用不支持同时处理多个键(如mset/mget),因为redis需要把键均匀分布在节点上,并发量很高的情况下同时创建键值会降低性能并导致不可预测的行为.支持在线增加.删除节点客户端可以连接任何一个主节点进行读写 原文地址:http://blog.51cto.com/13480443/2085252

redis介绍及搭建

redis介绍 Redis最适合所有数据in-momory的场景,虽然Redis也提供持久化功能,但实际更多的是一个disk-backed(以写入磁盘的方式进行同步,实现持久化)的功能,跟传统意义上的持久化有比较大的差别 如果简单地比较Redis与Memcached的区别,大多数都会得到以下观点: 1 .Redis不仅仅支持简单的k/v类型的数据,同时还提供list,set,zset,hash等数据结构的存储.     2 .Redis支持数据的备份,即master-slave模式的数据备份. 

redis介绍、主从配置

NoSQL之redis介绍: remote rerictionry server 是一个基于key-value键值对的持久化数据库存储系统,redis和memcached缓存服务很像. 但是redis支持的数据存储类型更丰富,包括string.list.set.和zset等,这些数据类型都支持push/pop.add/remove 及取交集.并集和差集及更丰富的操作,而且这些操作都是原子性的.在此基础上,redis支持各种不同方式的排序. 与memcached缓存服务一样,为了保证效率,数据都是

[NOSQL] Redis介绍

Redis概述 Redis是Salvatore Sanfilippo在2009年为其初创公司LLOOGG开发的,目前仍是独立项目,但VMWare赞劣了项目(作者是其雇员).它采用C语言实现,因此性能很好.采用BSD许可证,使用键值存储,和Amazon Dynamo,Cassandra,Riak,Voldemort,Memcache类似.支持丰富的数据类型,比如数组,链表,集合等,非常适合需要表达时间线的web服务,例如微博. Redis支持的数据类型有: 字符串 链表 集合 有序集合 散列表 R

Redis 介绍与使用

数据库主要类型有对象数据库,关系数据库,键值数据库等等,对象数据库太超前了,现阶段不提也罢:关系数据库就是平常说的MySQL,PostgreSQL这些熟的不能再熟的东西,至于键值数据库则是本文要着重说的,其代表主要有MemcacheDB,Tokyo Cabinet等等. Redis本质上也是一种键值数据库的,但它在保持键值数据库简单快捷特点的同时,又吸收了部分关系数据库的优点.从而使它的位置处于关系数据库和键值数 据库之间.Redis不仅能保存Strings类型的数据,还能保存Lists类型(有

数据库 --&gt; redis介绍

Redis介绍 接口说明 --> 连接数据库 redisContext* redisConnect(const char *ip, int port) 该函数用来连接redis数据库, 两个参数分别是redis数据库的ip和端口,端口号一般为6379.类似的还提供了一个函数,供连接超时限定,即 redisContext* redisConnectWithTimeout(const char *ip, int port, timeval tv). --> 执行命令 void *redisComm

Redis介绍 &amp;&amp; Java客户端操作Redis

Redis介绍 && Java客户端操作Redis 本文内容 redis介绍 redis的 shell 客户端简介 redis的 java 客户端简介 环境配置 redis 2.8.17 64bit JDK1.6 redis介绍 大多数时候,我们都将 redis 称作是内存数据库,它在运行过程中,将键值对信息存储在内存中,同时在后台以异步的形式写入本地数据库中(默认是:dump.rdb,在 redis.conf 中配置,如果需要考虑安全的持久化需求需要开启 AOF 功能,详细介绍可以查看这