SpringBoot项目集成Redis

pom

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

application.yml

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password: password

RedisUtil 工具类

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Component
@Slf4j
public class RedisUtil {

    @Autowired
    private RedisTemplate<Object, Object> redisTemplateBean;

    private static RedisTemplate<Object, Object> redisTemplate;

    @SuppressWarnings("static-access")
    @PostConstruct
    public void init() {
        redisTemplate = redisTemplateBean;
    }

    public static void save(final String key, Object value) {
        saveWithExpir(key, value, 0);
    }

    public static <T> T get(final String key) {
        return get(key, false);
    }

    public static void saveWithExpir(final String key, Object value, final long expirtime) {
        final byte[] vbytes = SerializeUtil.serialize(value);
        redisTemplate.execute((RedisCallback<Object>) connection -> {
            byte[] kbytes = redisTemplate.getStringSerializer().serialize(key);
            connection.set(kbytes, vbytes);
            if (expirtime > 0) {
                connection.expire(kbytes, expirtime);
            }
            return null;
        });
    }

    public static void saveWithExpir(final String key, Object value) {
        final byte[] vbytes = SerializeUtil.serialize(value);
        redisTemplate.execute((RedisCallback<Object>) connection -> {
            byte[] kbytes = redisTemplate.getStringSerializer().serialize(key);
            connection.set(kbytes, vbytes);
            return null;
        });
    }

    /**
     * 返回自增的key值
     *
     * @param key
     * @return
     * @date 2017年7月3日 下午3:49:26
     */
    public static <T> T getIncrKey(final String key) {
        final byte[] incrbytes = redisTemplate.getStringSerializer().serialize(key);
        return redisTemplate.execute((RedisCallback<T>) connection -> {
            Long key1 = connection.incr(incrbytes);
            return (T) key1;
        });
    }

    /**
     * 获取
     *
     * @param key
     * @return
     */
    public static <T> T get(final String key, final boolean delete) {
        return redisTemplate.execute((RedisCallback<T>) connection -> {
            byte[] keybytes = redisTemplate.getStringSerializer().serialize(key);
            if (connection.exists(keybytes)) {
                byte[] valuebytes = connection.get(keybytes);
                T value = (T) SerializeUtil.unserialize(valuebytes);
                if (delete) {
                    connection.del(keybytes);
                }
                return value;
            }
            return null;
        });
    }

    /**
     * 存值
     *
     * @param key
     * @param value
     * @return
     */
    public static boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.error("redis set error:{}", e.getMessage(), e);
            return false;

        }

    }

    /**
     * 存值并设置过期时间
     *
     * @param key
     * @param value
     * @param time
     * @return
     */
    public static boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error("redis set error:{}", e.getMessage(), e);
            return false;
        }
    }

    /**
     * 批量获取
     *
     * @param keys
     * @return
     */
    public static <T> T batchGet(final List<String> keys) {
        return redisTemplate.execute((RedisCallback<T>) connection -> {
            byte[][] byteKeys = new byte[keys.size()][128];
            for (int index = 0; index < keys.size(); ++index) {
                byteKeys[index] = redisTemplate.getStringSerializer().serialize(keys.get(index));
            }
            List<byte[]> byteValus = connection.mGet(byteKeys);
            List<T> result = new ArrayList<>();
            for (byte[] byteValue : byteValus) {
                T value = null;
                if (null != byteValue) {
                    value = (T) SerializeUtil.unserialize(byteValue);
                }
                result.add(value);
            }
            return (T) result;
        });
    }

    /**
     * 删除
     *
     * @param key
     * @return
     */
    public static void delete(final String key) {
        redisTemplate.execute((RedisCallback<Object>) connection -> {
            byte[] keybytes = redisTemplate.getStringSerializer().serialize(key);
            connection.del(keybytes);
            return null;
        });
    }

    public static Long getKeyTtl(final String key) {
        return redisTemplate.execute((RedisCallback<Long>) connection -> {
            byte[] keybytes = redisTemplate.getStringSerializer().serialize(key);
            return connection.ttl(keybytes);
        });
    }

    public static void setExpir(final String key, final long expirtime) {
        redisTemplate.execute((RedisCallback<Object>) connection -> {
            byte[] keybytes = redisTemplate.getStringSerializer().serialize(key);
            connection.expire(keybytes, expirtime);
            return null;
        });
    }

    public static String getMapValue(final String key, final String hashKey) {
        String value = (String) redisTemplate.opsForHash().get(key, hashKey);
        return value;
    }

    public static void setMapValue(final String key, final String hashKey, final String value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

}

SerializeUtil

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtil {

	/**
	 * 序列化
	 * 
	 * @param object
	 * @return<update
	 */
	public static byte[] serialize(Object object) {
		ObjectOutputStream oos = null;
		ByteArrayOutputStream baos = null;
		try {
			baos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(baos);
			oos.writeObject(object);
			return baos.toByteArray();
		} catch (Exception e) {
			throw new RuntimeException(e.getMessage(), e);
		}
	}

	/**
	 * 反序列化
	 * 
	 * @param bytes
	 * @return
	 */
	public static Object unserialize(byte[] bytes) {
		ByteArrayInputStream bais = null;
		try {
			bais = new ByteArrayInputStream(bytes);
			ObjectInputStream ois = new ObjectInputStream(bais);
			return ois.readObject();
		} catch (Exception e) {
			throw new RuntimeException(e.getMessage(), e);
		}
	}
	
}