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);
            }
        }
    }

Redis介紹(六)