Redis深入实践（二）构建redis服务使用redis缓存

在上文配置了redis服务器，和用sentinel配置出高可用的redis集群，接下来我们构建出redis的服务，使其提供服务，使用的是springcloud项目：

在idea中创建项目：itoken-service-redis：

1.pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>

    <parent>
        <groupId>com.kayleoi</groupId>
        <artifactId>itoken-dependencies</artifactId>
        <version>1.0.0-SNAPSHOT</version>
        <relativePath>../itoken-dependencies/pom.xml</relativePath>
    </parent>

    <artifactId>itoken-service-redis</artifactId>
    <packaging>jar</packaging>

    <name>itoken-service-redis</name>
    <url>http://www.funtl.com</url>
    <inceptionYear>2018-Now</inceptionYear>

    <dependencies>
        <!-- Project Begin -->
        <dependency>
            <groupId>com.kayleoi</groupId>
            <artifactId>itoken-common</artifactId>
            <version>${project.parent.version}</version>
        </dependency>
        <!-- Project End -->

        <!-- Spring Cloud Begin -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!-- Spring Cloud End -->

        <!-- Spring Boot Admin Begin -->
        <dependency>
            <groupId>org.jolokia</groupId>
            <artifactId>jolokia-core</artifactId>
        </dependency>
        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-client</artifactId>
        </dependency>
        <!-- Spring Boot Admin End -->

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.kayleoi.itoken.service.redis.RedisApplication</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2.配置中心的itoken-service-redis-dev.yml:

主要配置了

spring.letture.pool.max-active=8  #最大连接数

spring.letture.pool.max-idle=8  #最大空闲连接数

spring.letture.pool.max-wait= -1ms #l连接池阻塞等待时间

spring.letture.pool.min-idle=0  

#集群配置：

spring.sentinel.master: mymaster
spring.sentinel.nodes: 192.168.147.132:6379

spring:
  application:
    name: itoken-service-redis
  boot:
    admin:
      client:
        url: http://localhost:8084
  zipkin:
    base-url: http://localhost:9411
  redis:
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        max-wait: -1ms
        min-idle: 0
    sentinel:
      master: mymaster
      nodes: 192.168.147.132:6379

server:
  port: 8502

eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/





management:
  endpoint:
    health:
      show-detail: always
  endpoints:
    web:
      exposure:
        include: health,info

3.具体的业务逻辑实现：

package com.kayleoi.itoken.service.redis.controller;

import com.kayleoi.itoken.service.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author kay三石
 * @date:2019/6/27
 */
@RestController
public class RedisController {
    private static final String RESULT_OK="ok";

    @Autowired
    private RedisService redisService;

    /**
     * set关键字
     * @param key
     * @param value
     * @param seconds 超时时间
     * @return
     */
    @RequestMapping(value = "put", method = RequestMethod.GET)
    public String set(String key, String value, long seconds) {
        redisService.set(key, value, seconds);
        return RESULT_OK;
    }

    /**
     * 取关键字
     * @param key
     * @return
     */
    @RequestMapping(value = "find", method = RequestMethod.GET)
    public String find(String key) {
        String json = null;

        Object obj = redisService.get(key);
        if (obj != null) {
            json = (String) redisService.get(key);
        }

        return json;
    }
}
package com.kayleoi.itoken.service.redis.service;

/**
 * @Author kay三石
 * @date:2019/6/27
 */
public interface RedisService {
   /**
    *设置值
    * @param key
    * @param value
    * @param seconds  由于设置，几秒秒之内查询有结果，十秒之后返回为null
    */
   public void set(String key, String value, long seconds);

   /**
    *取得返回结果
    * @param key
    * @return
    */
   public Object get(String key);

   /**
    * 设置中不加入超时时间
    * @param key
    * @param value
    */
   public void set(String key,String value);



}
package com.kayleoi.itoken.service.redis.service.impl;

import com.kayleoi.itoken.service.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @Author kay三石
 * @date:2019/6/27
 */
@Service
public class RediServiceImpl implements RedisService {

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public void set(String key, String value, long seconds) {
        redisTemplate.opsForValue().set(key,value,seconds, TimeUnit.SECONDS);
    }

    @Override
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public void set(String key, String value) {
        redisTemplate.opsForValue().set(key,value);
    }

    public void test(){
        //用 value 参数覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始
        redisTemplate.opsForValue().set("name","hello word");
        redisTemplate.opsForValue().set("name","redis",6);
        System.out.println("***************"+redisTemplate.opsForValue().get("key"));//结果为 hello redis
        //为key设置它们的值，如果存在则返回false，不存在返回true
        redisTemplate.opsForValue().setIfAbsent("multi1","multi1");//false
        redisTemplate.opsForValue().setIfAbsent("multi111","multi111");//true  multi111之前不存在
        //为多个键分别设置它们的值
        Map<String,String> maps = new HashMap<String, String>();
            maps.put("multi1","multi1");
            maps.put("multi2","multi2");
            maps.put("multi3","multi3");
        redisTemplate.opsForValue().multiSet(maps);
        List<String> keys = new ArrayList<String>();
            keys.add("multi1");
            keys.add("multi2");
            keys.add("multi3");
        System.out.println(redisTemplate.opsForValue().multiGet(keys));


    }
}

通过以上的配置即可实现对缓存的操作这里主要使用了RedisTemplate这个类，下篇介绍RedisTemplate类的使用：