Springboot+Redis 实现基本缓存

 Springboot+Redis单个实现缓存

基本结构

1.pom.xml 相关的依赖

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.16.RELEASE</version>
</parent>
<dependencies>
<!-- SpringBoot 对lombok 支持 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- SpringBoot web 核心组件 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<!-- SpringBoot 外部tomcat支持 -->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<!-- springboot-log4j -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j</artifactId>
<version>1.3.8.RELEASE</version>
</dependency>
<!-- springboot-aop 技术 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-lang/commons-lang -->
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>
<!--开启 cache 缓存 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- ehcache缓存 -->
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.9.1</version><!--$NO-MVN-MAN-VER$ -->
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>
<!-- mysql 依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>

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

</dependencies>

2.application.yml配置相关

###端口号配置
server:
port: 8081
###数据库配置
spring:
datasource:
url: jdbc:mysql://localhost:3306/test
username: root
password: 123456DJC
driver-class-name: com.mysql.jdbc.Driver
test-while-idle: true
test-on-borrow: true
validation-query: SELECT 1 FROM DUAL
time-between-eviction-runs-millis: 300000
min-evictable-idle-time-millis: 1800000
# 缓存配置读取

redis:
database: 0
host: 127.0.0.1
port: 6379
password:
jedis:
pool:
max-active: 8
max-wait: -1
max-idle: 8
min-idle: 0
timeout: 10000

3.相关的代码  app启动类

@MapperScan(basePackages = { "com.mayikt.mapper" })
@EnableCaching
@SpringBootApplication
public class App {

public static void main(String[] args) {

SpringApplication.run(App.class, args);
}

}

 4.实体类 ，sql语句可以参照

package com.mayikt.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Users {

private Long id;
private String name;
private Integer age;

}

5. mapper 

package com.mayikt.mapper;

import com.mayikt.entity.Users;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface UserMapper {

@Select("SELECT * FROM users")
List<Users> getUser();

@Select("delete FROM users where users.id=#{id}")
void deleteById(Integer id);

}

6.service 接口 这里需要特别注意  （看相关的注释）

package com.mayikt.service;

import com.mayikt.entity.Users;
import com.mayikt.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@CacheConfig(cacheNames = "user")//该注解是用来开启声明的类参与缓存,
public class UserService {

@Autowired
private UserMapper userMapper;

@Cacheable//配置方法的缓存参数，可自定义缓存的key以及value。
public List<Users> getUser() {

return userMapper.getUser();
}

@CacheEvict(allEntries=true)//移除缓存
@Async
public void deleteById(Integer id){
userMapper.deleteById(id);
}

}

7.redis service

package com.mayikt.service.redis;

import java.util.List;

public interface RedisService {

/**
* 向Redis中存放字符串
*
* @param key
* @param value
*/
void set(String key, Object value);

/**
* 向Redis中存放字符串[并设置过期时间]
*
* @param key
* @param value
* @param expire 单位s
*/
void set(String key, Object value, Long expire);

/**
* 根据key值获取数据【操作字符串】
*
* @param key
* @return
*/
Object get(String key);

/**
* 删除指定的键值【操作字符串】
*
* @param key
* @return
*/
void delete(String key);

/**
* 添加数据到list的顶部【操作List】
*
* @param key List名称
* @param value 存放的数值
* @return 存放完毕之后，当前List的长度
*/
Long lpush(String key, String value);

/**
* 获取List集合中的数据【操作List】
*
* @param key List名称
* @return list中存放的数据
*/
List<Object> range(String key);

/**
* 向List集合中存放集合
*
* @param key 被操作的List
* @param list 需要添加的List
* @return 存放完毕之后，当前List的长度
*/
Long lPushAll(String key, List<Object> list);

/**
* 移除List中的元素
*
* @param key 被操作的List
* @param count 要删除的元素个数【为负数表示从尾部，向头部删除;正数则相反】
* @param value 要删除的元素值
* @return 移除完毕之后，当前List的长度
*/
Long remove(String key, long count, Object value);
}

8.redis 的impl 实现

package com.mayikt.service.impl;

import com.mayikt.service.redis.RedisService;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Service
public class RedisServiceImpl implements RedisService {

@Resource
private RedisTemplate<String,Object> redisTemplate;

/**
* 获取操作字符串的ValueOperations
*/
public ValueOperations<String,Object> getValueOperations(){
ValueOperations<String,Object> vo = redisTemplate.opsForValue();
return vo;
}

@Override
public void set(String key, Object value) {
getValueOperations().set(key, value);
}

@Override
public Object get(String key) {
return getValueOperations().get(key);
}

@Override
public void delete(String key) {
RedisOperations<String, Object> operations = getValueOperations().getOperations();
operations.delete(key);
}

public Long lpush(String key, String value){
//获取操作list的对象
ListOperations<String, Object> opsForList = redisTemplate.opsForList();
Long length = opsForList.leftPush(key,value);
return length;
}

@Override
public List<Object> range(String key) {
//获取操作list的对象
ListOperations<String, Object> opsForList = redisTemplate.opsForList();
return opsForList.range(key,0,-1);
}

@Override
public Long lPushAll(String key, List<Object> list) {
//获取操作list的对象
ListOperations<String, Object> opsForList = redisTemplate.opsForList();
return opsForList.leftPushAll(key,list);
}

@Override
public Long remove(String key, long count, Object value) {
//获取操作list的对象
ListOperations<String, Object> opsForList = redisTemplate.opsForList();
return opsForList.remove(key,count,value);
}

@Override
public void set(String key, Object value, Long expire) {
redisTemplate.opsForValue().set(key,value);
//设置过期时间
redisTemplate.expire(key,expire, TimeUnit.SECONDS);
}
}

9.RedisConfig redis的config配置文件（他可以实现缓存，获取用户的名+方法名 ）作为redis缓存的key 实现唯一

package com.mayikt.config;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
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.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;

/**
* Redis缓存配置类
* @author
*
*/
@Configuration
@EnableCaching//开启注解
public class RedisConfig extends CachingConfigurerSupport {

/**
* 自定义key
* @return
*/
@Override
public KeyGenerator keyGenerator() {
return new KeyGenerator() {
@Override
public Object generate(Object o, Method method, Object... objects) {
//格式化

StringBuilder sb = new StringBuilder();
sb.append(o.getClass().getName());
sb.append(method.getName());
for (Object obj : objects) {
sb.append(obj.toString());
}
System.out.println("调用redis缓存key：" + sb.toString());
return sb.toString();
}
};
}

@Bean
public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {

CacheManager cacheManager =new RedisCacheManager(redisTemplate);
return  cacheManager;
}

@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
redisTemplate.setConnectionFactory(factory);
//解决日期序列化问题
ObjectMapper om = new ObjectMapper();
om.setDateFormat(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"));
GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(om);
redisTemplate.setDefaultSerializer(genericJackson2JsonRedisSerializer);
return redisTemplate;
}
}

10.最好controller 实现查询和删除 操作

package com.mayikt.controller;

import com.mayikt.entity.Users;
import com.mayikt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class IndexController {

@Autowired
private UserService userService;

@RequestMapping("/getUser")
public List<Users> getUser() {

return userService.getUser();
}

@RequestMapping("/delete")
public String deleteById(Integer id) {

userService.deleteById(id);

return  "success";
}

}

备注： config 出错，可以使用这个

@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
RedisCacheManager cacheManager = RedisCacheManager.create(factory);
return cacheManager;
}