spring boot2.0(二 ) lettcute访问redis

前言

　　此处已经省略redis的安装，请自行百度查找redis的服务端安装过程。

1.pom文件配置：

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.aaron</groupId>
  <artifactId>framework</artifactId>
  <packaging>war</packaging>
  <version>1.0.0</version>
  <name>framework Maven Webapp</name>
  <url>http://maven.apache.org</url>
  
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
        <relativePath /> 
    </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>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
        </dependency>
    
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- 单元测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        
        <!-- redis客户端lettuce -->
        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency>
        
        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.0.2.RELEASE</version>
        </dependency>

        <!-- 热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
            <scope>true</scope>
        </dependency>
        
    </dependencies>
    
  <build>
    <finalName>framework</finalName>
    
    <plugins>
        <!-- Spring Boot包含一个Maven插件 ，可以将项目打包为可执行的jar。 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <!-- 没有该配置，devtools 不生效 -->
                <fork>true</fork>
                <addResources>true</addResources>  
            </configuration>
        </plugin>
    </plugins>
  </build>
</project>

2.新增redis配置类：

package com.aaron.framework.common.configuration;

import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;

import javax.annotation.Resource;

import org.springframework.cache.CacheManager;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.ReactiveRedisOperations;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.fasterxml.jackson.databind.ObjectMapper;


@Configuration
@EnableTransactionManagement//事务支持
public class ReidsConfig {
    
    @Resource
    private LettuceConnectionFactory lettuceConnectionFactory;
    
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator(){
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuffer sb = new StringBuffer();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for(Object obj:params){
                    sb.append(obj.toString());
                }
                return sb.toString();
           }
        };
    }
   //缓存管理器
   @Bean
   public CacheManager cacheManager() {
       RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
               .RedisCacheManagerBuilder
               .fromConnectionFactory(lettuceConnectionFactory);
       Set<String> cacheNames = new HashSet<String>() {{
           add("codeNameCache");
       }};
       builder.initialCacheNames(cacheNames);
       return builder.build();
   }

   /**
    * RedisTemplate配置
    *
    * @param jedisConnectionFactory
    * @return
    */
   @Bean
   public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory ) {
       //设置序列化
       Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
       ObjectMapper om = new ObjectMapper();
       om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
       jackson2JsonRedisSerializer.setObjectMapper(om);
       //配置redisTemplate
       RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
       redisTemplate.setConnectionFactory(lettuceConnectionFactory);
       RedisSerializer<?> stringSerializer = new StringRedisSerializer();
       redisTemplate.setKeySerializer(stringSerializer);//key序列化
       redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);//value序列化
       redisTemplate.setHashKeySerializer(stringSerializer);//Hash key序列化
       redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);//Hash value序列化
       redisTemplate.afterPropertiesSet();
       return redisTemplate;
}
    
    /**
     * redis连接工厂
     * @return
     */
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory(new RedisStandaloneConfiguration("127.0.0.1", 6379));
    }
    
//    /**
//     * redis响应式连接工厂
//     * @return
//     */
//    @Bean
//    public ReactiveRedisConnectionFactory connectionFactory() {
//      return new LettuceConnectionFactory("localhost", 6379);
//    }
    
    
//    /**
//     * Lettuce
//     * 高可用redis连接工厂（容灾）
//     */
//    @Bean
//    public RedisConnectionFactory lettuceConnectionFactory() {
//      RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
//      .master("mymaster")
//      .sentinel("127.0.0.1", 26379)
//      .sentinel("127.0.0.1", 26380);
//      return new LettuceConnectionFactory(sentinelConfig);
//    }
}

3.编写服务类和接口：

package com.aaron.framework.common.service;

public interface IRedisService {
    
    /**
     * 设置redis值
     * @param key
     * @param value
     */
    void setValue(String key,Object value);
    

    /**
     * 设置redis值
     * @param key
     * @param value
     */
    void setValue(String key,Object value,long timeout);
    
    /**
     * 从redis获取值
     * @param key
     * @return
     */
    Object getValue(String key);

}

package com.aaron.framework.common.service.impl;

import java.util.concurrent.TimeUnit;

import javax.annotation.Resource;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import com.aaron.framework.common.service.IRedisService;

@Service("redisService")
public class RedisService implements IRedisService{
    
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    public void setValue(String key, Object value) { 
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        vo.set(key, value);
    }

    @Override
    public void setValue(String key, Object value, long timeout) {
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        vo.set(key, value, timeout, TimeUnit.MILLISECONDS);
    }

    public Object getValue(String key) {
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        return vo.get(key);
    }
    
    
}