笔记:
- 工程目录结构
- 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的命名一定不要太随便,不然后边很恶心