spring boot 集成redis用jedis操作存储

笔记：

• 工程目录结构

• pox.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>

	<groupId>com.example</groupId>
	<artifactId>jedis</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>jedis</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.4.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-thymeleaf</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
		<dependency>
		    <groupId>org.slf4j</groupId>
		    <artifactId>slf4j-api</artifactId>
 		    <!-- <version>1.7.25</version> -->
		</dependency>

		<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
		<dependency>
		    <groupId>redis.clients</groupId>
		    <artifactId>jedis</artifactId>
		    <version>2.9.0</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.jfinal/jfinal -->
		<dependency>
		    <groupId>com.jfinal</groupId>
		    <artifactId>jfinal</artifactId>
		    <version>3.1</version>
		</dependency>
		
		<dependency>
		  <groupId>de.ruedigermoeller</groupId>
		  <artifactId>fst</artifactId>
		  <version>2.50</version>
		</dependency>
	</dependencies>

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


</project>

• 关键类

spring boot 简单集成redis

package com.example.jedis.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.jfinal.plugin.redis.IKeyNamingPolicy;
import com.jfinal.plugin.redis.serializer.FstSerializer;

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


@Configuration
public class JedisConfig extends CachingConfigurerSupport {

	
	private static final Logger logger = LoggerFactory.getLogger(JedisConfig.class);
	
	
	@Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.pool.max-wait}")
    private long maxWaitMillis;
    
    @Bean
    public JedisPool redisPoolFactory() {
    	JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    	jedisPoolConfig.setMaxIdle(maxIdle);
    	jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
    	jedisPoolConfig.setMaxTotal(maxActive);
    	jedisPoolConfig.setMinIdle(minIdle);
    	JedisPool jedisPool = new JedisPool(jedisPoolConfig,host,port,timeout,null);
    	
    	logger.info("=============JedisPool注入成功！");
    	logger.info("=============redis地址："+host+":"+port);
    	return jedisPool;
    }
    
    @Bean
    public IKeyNamingPolicy IKeyNamingPolicyStart() {
    	return IKeyNamingPolicy.defaultKeyNamingPolicy;
    }
	
    @Bean
    public FstSerializer FstSerializerStart() {
    	return new FstSerializer();
    }
}

序列化帮助类：

package com.example.jedis.util;

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

import org.springframework.stereotype.Component;

@Component
public class SerializerUtil {

	
	public static byte[] serializeKey(String key) {
		return key.getBytes();
	}
	
	public static byte[] serializeValue(Object object) {
		return serialize(object);
	}
	
	public static Object deserializeValue(byte[] bytes) {
		return deSerialize(bytes);
	}
	
	public static String deserializeKey(byte[] bytes) {
		return new String(bytes);
	}
	
	
	public static byte[] serialize(Object obj) {
		byte[] bytes = null;
		try {
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			;
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.writeObject(obj);
			bytes = baos.toByteArray();
			baos.close();
			oos.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return bytes;
	}

	public static Object deSerialize(byte[] bytes) {
		Object obj = null;
		try {
			ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
			ObjectInputStream ois = new ObjectInputStream(bais);
			obj = ois.readObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return obj;
	}

	
}

jedis操作封装类：

package com.example.jedis.config;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.example.jedis.util.SerializerUtil;
import com.jfinal.plugin.redis.IKeyNamingPolicy;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

@Component
@SuppressWarnings("static-access")
public class JedisCache {

	@Autowired
	private JedisPool jedisPool;

	@Autowired
	private IKeyNamingPolicy keyNamingPolicy;

	@Autowired
	private SerializerUtil serializer;

	// 给某个key设值
	public void set(String key, Object value) {
		Jedis client = getJedis();
		try {
			byte[] keyBytes = serializer.serializeKey(keyNamingPolicy.getKeyName(key));
			byte[] valueBytes = serializer.serializeValue(value);
			client.set(keyBytes, valueBytes);
		} finally {
			returnJedis(client);
		}

	}

	// 根据key获取value
	public Object get(String key) {
		Jedis client = getJedis();
		try {
			byte[] keyBytes = serializer.serializeKey(keyNamingPolicy.getKeyName(key));
			byte[] valueBytes = client.get(keyBytes);
			return serializer.deserializeValue(valueBytes);
		} finally {
			returnJedis(client);
		}
	}

	// 根据键值获取value
	public Object hashGet(String key, String field) {
		Jedis client = getJedis();
		try {
			byte[] keyBytes = serializer.serializeKey(keyNamingPolicy.getKeyName(key));
			byte[] fieldBytes = serializer.serializeKey(field);
			byte[] valueBytes = client.hget(keyBytes, fieldBytes);
			return serializer.deserializeValue(valueBytes);
		} finally {
			returnJedis(client);
		}

	}

	public void hashSet(String key, String field, Object value) {
		Jedis client = getJedis();
		try {
			byte[] keyBytes = serializer.serializeKey(keyNamingPolicy.getKeyName(key));
			byte[] fieldBytes = serializer.serializeKey(field);
			byte[] valueBytes = serializer.serializeValue(value);
			client.hset(keyBytes, fieldBytes, valueBytes);
		} finally {
			returnJedis(client);
		}

	}

	public Map<String, Object> hashAllGet(String key) {
		Jedis client = getJedis();
		try {
			byte[] keyBytes = serializer.serializeKey(keyNamingPolicy.getKeyName(key));
			Map<byte[], byte[]> map = client.hgetAll(keyBytes);
			Map<String, Object> valueMap = new HashMap<>();
			Set<Map.Entry<byte[], byte[]>> valueSet = map.entrySet();
			for (Map.Entry<byte[], byte[]> entry : valueSet) {
				valueMap.put(serializer.deserializeKey(entry.getKey()), serializer.deserializeValue(entry.getValue()));
			}
			return valueMap;
		} finally {
			returnJedis(client);
		}

	}

	// 判断key是否存在
	public boolean existKey(String key) {
		Jedis client = getJedis();
		try {
			byte[] keyBytes = serializer.serializeKey(keyNamingPolicy.getKeyName(key));
			return client.exists(keyBytes);
		} finally {
			returnJedis(client);
		}
	}
	
	// 删除
	public void delKey(String key) {
		Jedis client = getJedis();
		try {
			byte[] keyBytes = serializer.serializeKey(keyNamingPolicy.getKeyName(key));
			client.del(keyBytes);
		} finally {
			returnJedis(client);
		}
	}

	// 获取jedis链接
	private Jedis getJedis() {
		Jedis jedis = jedisPool.getResource();
		jedis.auth("rq1433");
		return jedis;
	}

	// 关闭jedis
	public void returnJedis(Jedis jedis) {
		if (jedis != null) {
			jedis.close();
		}
	}

}

service调用：

package com.example.jedis.service;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.example.jedis.config.JedisCache;
import com.example.jedis.constants.Constants;
import com.example.jedis.mapper.CityMapper;
import com.example.jedis.model.City;
import com.example.jedis.model.CityExample;

@Service
public class CityService {
	
	private static final Logger logger = LoggerFactory.getLogger(CityService.class);

	@Autowired
	private CityMapper cityMapper;
	
	@Autowired
	private JedisCache jedisCache;
	
	
	public List<City> queryCityList(){
		/**
		 * 判断key是否存在
		 * if 命中 取缓存
		 * else 取DB , 然后放入缓存
		 */
		String key = Constants.CITY;
		boolean hasKey = jedisCache.existKey(key);
		if(hasKey) {
			List<City> list = (List<City>) jedisCache.get(key);
			logger.info("取缓存中的集合");
			return list;
		}
		List<City> list = cityMapper.selectByExample(new CityExample());
		jedisCache.set(key, list);
		logger.info("取DB中的值，并存入缓存，key:{}",key);
		return list;
	}
	
	
	public City findCityById(Integer id) {
		/**
		 * 判断key是否存在
		 * if 命中 取缓存
		 * else 取DB , 然后放入缓存
		 */
		String key = Constants.CITY + id;
		boolean hasKey = jedisCache.existKey(key);
		if(hasKey) {
			City city = (City) jedisCache.get(key);
			logger.info("取缓存中的值！");
			return city;
		}
		
		City city = cityMapper.selectByPrimaryKey(id);
		jedisCache.set(key, city);
		logger.info("取DB中的值，存在缓存；key:{}",key);
		return city;
	}
	
}

• 调用

第一次调用

再次请求和后续请求刷新页面的时候都是读取缓存中的数据

资源地址：https://download.csdn.net/download/u012586389/10638126

注：key的命名一定不要太随便，不然后边很恶心