Spring Boot—19Cache

Posted 2020-11-01 ParamousGIS

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.5.0</version>
</dependency>

application.properties

#
server.address=0.0.0.0
server.port=8080
server.servlet.context-path=/test
server.session.timeout=300
server.error.path=/error
#
server.tomcat.accesslog.enabled=true
server.tomcat.accesslog.buffered=true
server.tomcat.accesslog.directory=D:/Project/JavaWeb/SpringBoot/04JPASpringBoot/logs
#
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=Asia/Shanghai
#
spring.thymeleaf.cache=true
spring.thymeleaf.enabled=true

file.upload.path=D:/Project/JavaWeb/SpringBoot/04JPASpringBoot/fileUpLoad

spring.servlet.multipart.enabled=true
spring.servlet.multipart.file-size-threshold=0
spring.servlet.multipart.location=D:/Project/JavaWeb/SpringBoot/04JPASpringBoot/temp
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB
spring.servlet.multipart.resolve-lazily=false


spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.druid.one.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.druid.one.username=root
spring.datasource.druid.one.password=gis
spring.datasource.druid.one.driver-class-name=com.mysql.cj.jdbc.Driver

##Druid
spring.datasource.druid.one.initial-size=2
spring.datasource.druid.one.max-active=5
spring.datasource.druid.one.min-idle=1
spring.datasource.druid.one.max-wait=60000
spring.datasource.druid.one.pool-prepared-statements=true
spring.datasource.druid.one.max-pool-prepared-statement-per-connection-size=20
spring.datasource.druid.one.validation-query=SELECT 1 FROM DUAL
spring.datasource.druid.one.validation-query-timeout=60000
spring.datasource.druid.one.test-on-borrow=false
spring.datasource.druid.one.test-on-return=false
spring.datasource.druid.one.test-while-idle=true
spring.datasource.druid.one.time-between-eviction-runs-millis=60000
spring.datasource.druid.one.min-evictable-idle-time-millis=100000
#spring.datasource.druid.one.max-evictable-idle-time-millis=
spring.datasource.druid.one.filters=stat,wall,log
spring.datasource.druid.one.logSlowSql=true

#
# debug=true # Enable debug logs.
# trace=true # Enable trace logs.

# LOGGING
logging.config=classpath:logback.xml

spring.redis.host=127.0.0.1
spring.redis.password=gis
spring.redis.port=6379
spring.redis.pool.max-active=8
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.max-wait=-1ms
spring.redis.jedis.pool.min-idle=0
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.min-idle=0
spring.redis.lettuce.shutdown-timeout=100ms
spring.redis.ssl=false
spring.redis.timeout=5000

redis.message.topic=spring.news.*

# Cache
spring.cache.type=Redis
spring.cache.redis.cache-null-values=true
spring.cache.redis.key-prefix=spring:cache:
spring.cache.redis.time-to-live=0ms
spring.cache.redis.use-key-prefix=true

启动类

package com.smartmap.sample.test;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@EnableCaching
@EnableTransactionManagement
@SpringBootApplication
public class TestCacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestCacheApplication.class, args);

    }

}

配置类

package com.smartmap.sample.test.conf;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheManager.RedisCacheManagerBuilder;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializationContext.SerializationPair;
import org.springframework.data.redis.serializer.RedisSerializer;
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
public class RedisCacheManagerCustomizer {

    @Value("${spring.cache.redis.key-prefix}")
    private String keyPrefix;

    @Bean
    public RedisCacheConfiguration redisCacheConfiguration() {        
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        return RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(
                        RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(
                        RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
                .prefixKeysWith(keyPrefix);
    }

    /*@Bean
    public RedisCacheManager getRedisCacheManager(RedisConnectionFactory connectionFactory) {

        RedisCacheManagerBuilder redisCacheManagerBuilder = RedisCacheManagerBuilder.fromConnectionFactory(connectionFactory);
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        // Key
        RedisSerializer<String> redisSerializerKey = new StringRedisSerializer();
        SerializationPair<String> serializationPairKey = SerializationPair.fromSerializer(redisSerializerKey);
        // Value
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
                Object.class);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        //
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(
                objectMapper);
        //RedisSerializer<Object> redisSerializerValue = jackson2JsonRedisSerializer; 
        //
        RedisSerializer<Object> redisSerializerValue = genericJackson2JsonRedisSerializer;
        //
        SerializationPair<Object> serializationPairValue = SerializationPair.fromSerializer(redisSerializerValue);
        //RedisSerializationContext.SerializationPair<Object> serializationPairValue = RedisSerializationContext.SerializationPair.fromSerializer(redisSerializerValue); //
        redisCacheConfiguration.serializeKeysWith(serializationPairKey);
        redisCacheConfiguration.serializeValuesWith(serializationPairValue);
        redisCacheManagerBuilder.cacheDefaults(redisCacheConfiguration);
        RedisCacheManager redisCacheManager = redisCacheManagerBuilder.build(); //
        return redisCacheManager;
    }*/

}

实体类 Menu

package com.smartmap.sample.test.entity;

public class Menu {
    Long id;
    String code;
    String name;
    Long parentId;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Long getParentId() {
        return parentId;
    }

    public void setParentId(Long parentId) {
        this.parentId = parentId;
    }
}

实体类 MenuNode

package com.smartmap.sample.test.entity;

import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.annotation.JsonIgnore;

public class MenuNode {
    private Menu menu;
    private List<MenuNode> children = new ArrayList<MenuNode>();
    @JsonIgnore
    private MenuNode parent;

    public Menu getMenu() {
        return menu;
    }

    public void setMenu(Menu menu) {
        this.menu = menu;
    }

    public List<MenuNode> getChildren() {
        return children;
    }

    public void setChildren(List<MenuNode> children) {
        this.children = children;
    }

    public MenuNode getParent() {
        return parent;
    }

    public void setParent(MenuNode parent) {
        this.parent = parent;
    }

}

缓存应用

package com.smartmap.sample.test.service.impl;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;

import com.smartmap.sample.test.entity.Menu;
import com.smartmap.sample.test.entity.MenuNode;
import com.smartmap.sample.test.service.MenuService;

@Service
public class MenuServiceImpl implements MenuService {
    Log log = LogFactory.getLog(this.getClass());

    /**
     * 清除缓存
     */
    @CacheEvict(cacheNames = { "menu", "menuTree" }, allEntries = true)
    public void addMenu(Menu menu) {

    }

    /**
     * 添加缓存(含条件)
     */
    @Cacheable(cacheNames = "menu", key = "‘menu:‘ + {#id}", condition = "#id > 0")
    public Menu getMenu(Long id) {
        log.info("call service getMenu " + id);
        // 模拟
        Menu menu = new Menu();
        menu.setCode("test");
        menu.setId(id);
        menu.setName("菜单" + id);
        menu.setParentId(1l);

        return menu;
    }

    /**
     * 添加缓存
     */
    @Cacheable(cacheNames = "menuTree", key = "‘menuTree‘")
    public MenuNode getMenuTree() {

        log.info("call menu tree ");
        Menu root = new Menu();
        root.setCode("root");
        root.setId(1l);
        root.setName("系统管理");
        root.setParentId(null);

        Menu menu = new Menu();
        menu.setCode("menu");
        menu.setId(1l);
        menu.setName("菜单管理");
        menu.setParentId(1l);

        MenuNode tree = new MenuNode();
        tree.setMenu(root);
        tree.setParent(null);

        MenuNode menuTree = new MenuNode();
        menuTree.setMenu(menu);
        menuTree.setParent(tree);
        tree.getChildren().add(menuTree);

        return tree;

    }

    /**
     * 更新缓存
     */
    @CachePut(cacheNames = "menu", key = "‘menu:‘ + {#menu.id}")
    public Menu update(Menu menu) {
        return menu;
    }

    /**
     * 组合处理多种缓存
     * 
     * @param menu
     */
    @Caching(evict = { @CacheEvict(cacheNames = { "menu" }, allEntries = true),
            @CacheEvict(cacheNames = { "menuTree" }, allEntries = true) })
    public void updateCascading(Menu menu) {

    }
}

Controller类

package com.smartmap.sample.test.controller.rest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.smartmap.sample.test.entity.Menu;
import com.smartmap.sample.test.entity.MenuNode;
import com.smartmap.sample.test.service.MenuService;

@RestController
@RequestMapping("/api/v1.1/system/menu")
public class MenuController {
    private final Log logger = LogFactory.getLog(MenuController.class);

    @Autowired
    MenuService menuService;
    
    /**
     * curl -XPOST ‘http://127.0.0.1:8080/test/api/v1.1/system/menu/‘
     * -H‘Content-type:application/json;charset=UTF-8‘ -d ‘ { "id":123, "code":"menuCode1", "name":"123" }‘
     * 
     * @return
     * @throws Exception
     */
    @PostMapping("/") 
    public String addMenu(@RequestBody Menu menu) throws Exception{
        menuService.addMenu(menu);
        //模拟改变缓存
        return "{\"success\":true}";
    }
    
    /**
     * curl -XGET ‘http://127.0.0.1:8080/test/api/v1.1/system/menu/123‘
     * 
     * @param menuId
     * @return
     * @throws Exception
     */
    @GetMapping("/{menuId}") 
    public Menu getMenu(@PathVariable("menuId") Long menuId) throws Exception{
        return menuService.getMenu(menuId);
    }
    
    /**
     * curl -XGET ‘http://127.0.0.1:8080/test/api/v1.1/system/menu/tree‘
     * 
     * @return
     * @throws Exception
     */
    @GetMapping("/tree") 
    public MenuNode getMenuTree() throws Exception{
        return menuService.getMenuTree();
    }
    
    
}