Springboot 配置Redis基本操作

加载配置
package com.monkey01.springbootstart.config;

import java.lang.reflect.Method;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

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

@Bean
public KeyGenerator keyGenerator() {
    return new KeyGenerator() {
        @Override
        public Object generate(Object target, Method method, Object... params) {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(obj.toString());
            }
            return sb.toString();
        }
    };
}    
/**
 * 申明缓存管理器，会创建一个切面（aspect）并触发Spring缓存注解的切点（pointcut）
 * 根据类或者方法所使用的注解以及缓存的状态，这个切面会从缓存中获取数据，将数据添加到缓存之中或者从缓存中移除某个值
 
 * @return
 */
@Bean
public RedisCacheManager cacheManager(RedisTemplate<String, Object> redisTemplate) {
    return new RedisCacheManager(redisTemplate);
}


@Bean
@Primary
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    // 创建一个模板类
    RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
    // 将刚才的redis连接工厂设置到模板类中
    template.setConnectionFactory(factory);
    // 设置key的序列化器
    template.setKeySerializer(new StringRedisSerializer());
    // 设置value的序列化器
    //使用Jackson 2，将对象序列化为JSON
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
    //json转对象类，不设置默认的会将json转成hashmap
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    template.setValueSerializer(jackson2JsonRedisSerializer);

    return template;
}

}

application.properties配置
server.port=8081

REDIS (RedisProperties)

Redis数据库索引（默认为0）

spring.redis.database=0

Redis服务器地址

spring.redis.host=192.168.1.186

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=0

pom.xml配置

<?xml version="1.0" encoding="UTF-8"?>

4.0.0

<groupId>com.monkey01</groupId>
<artifactId>springboot-start</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>springboot-start</name>
<description>Demo project for Spring Boot</description>

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.4.7.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-web</artifactId>
	</dependency>
	<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    </dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
<dependency>
 <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>

	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	<!-- https://mvnrepository.com/artifact/com.whalin/Memcached-Java-Client -->
	<dependency>
	    <groupId>com.whalin</groupId>
	    <artifactId>Memcached-Java-Client</artifactId>
	    <version>3.0.2</version>
	</dependency>
	<!-- https://mvnrepository.com/artifact/com.google.code.simple-spring-memcached/spymemcached -->
	<dependency>
	    <groupId>com.google.code.simple-spring-memcached</groupId>
	    <artifactId>spymemcached</artifactId>
	    <version>2.8.4</version>
	</dependency>
	
	
</dependencies>

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>

junitTest

package com.monkey01.springbootstart;

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

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringbootStartApplication.class)
public class RedisTest {

@Autowired
RedisConnectionFactory factory;
    
@Test
public void testRedis(){
    //得到一个连接
    RedisConnection conn = factory.getConnection();
    conn.set("hello".getBytes(), "world".getBytes());
    System.out.println(new String(conn.get("hello".getBytes())));
}
@Autowired    
RedisTemplate<String, Object> redisTemplate;

@Test
public void testRedisTemplate(){

// redisTemplate.opsForValue();//操作字符串
// redisTemplate.opsForHash();//操作hash
// redisTemplate.opsForList();//操作list
// redisTemplate.opsForSet();//操作set
// redisTemplate.opsForZSet();//操作有序set

	redisTemplate.opsForHash().put("zhagnsan", "kkkkk", "value");
	System.out.println(redisTemplate.opsForHash().get("zhangsan", "kkkkk"));
	redisTemplate.opsForList().leftPush("duilie", "队列1");
	redisTemplate.opsForList().leftPush("duilie", "队列2");
	redisTemplate.opsForList().rightPush("duilie", "队列3");
	List<Object> _lsit = redisTemplate.opsForList().range("duilie", 0, 9);
	for (Object object : _lsit) {
		System.out.println(object);
	}
	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));

	System.out.println(redisTemplate.opsForSet().add("setjihe", "jihe1","jihe2"));
	redisTemplate.opsForValue().set("key1", "value1");
    System.out.println(redisTemplate.opsForValue().get("key1"));
}

}