SpringBoot 集成Ehcache实现缓存

最新推荐文章于 2023-02-10 15:20:27 发布

weixin_33805743

最新推荐文章于 2023-02-10 15:20:27 发布

阅读量114

点赞数

文章标签： java 数据库开发工具

原文链接：https://my.oschina.net/sdlvzg/blog/1594834

版权

为什么80%的码农都做不了架构师？>>>

EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。

Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。

本文档主要通过案例介绍一下，如何在SpringBoot中集中Ehcache，使用Ehcache。

使用的SpringBoot版本为1.5.9.RELEASE，Ehcache版本2.10.4，还使用MyBatis用于数据存取，并集成了mybatis-plus用于简化数据存取。

首先需要通过IDEA创建一个Maven项目。

一、代码

创建数据表，使用数据库为MySql

CREATE TABLE `tasklog` (
  `id` varchar(32) NOT NULL DEFAULT '' COMMENT '主键',
  `taskId` varchar(32) DEFAULT NULL COMMENT '任务ID',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

pom.xml

把项目的pom.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>org.lvgang</groupId>
	<artifactId>springboot-ehcache</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springboot-ehcache</name>
	<description>Demo project for Spring Boot</description>

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

		<!-- spring-boot mybatis依赖-->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.1</version>
		</dependency>

		<!-- mysql 数据库驱动. -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>

		<!-- mybatis-plus begin -->
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatisplus-spring-boot-starter</artifactId>
			<version>1.0.5</version>
		</dependency>
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus</artifactId>
			<version>2.1.8</version>
		</dependency>

		<!-- Spring boot Cache-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>

		<!-- Spring boot EhCache-->
		<dependency>
			<groupId>net.sf.ehcache</groupId>
			<artifactId>ehcache</artifactId>
		</dependency>

		<!-- Spring boot单元测试. -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

	</dependencies>

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

</project>

application.properties

########################################################
###datasource
########################################################
spring.datasource.url = jdbc:mysql://xxx.xxx.xxx.xxx:3306/taskdb
spring.datasource.username = root
spring.datasource.password = xxxxxxx
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10

########################################################
###mybatis-plus
########################################################
mybatis-plus.mapper-locations=classpath:org/lvgang/springbootehcache/mapper/*Mapper.xml

########################################################
###log
########################################################
logging.level.org.lvgang.springbootehcache.mapper=debug

编写Bean

package org.lvgang.springbootehcache.bean;

import java.io.Serializable;

public class Tasklog implements Serializable{

    public String id;
    public String taskId;

    public String getId() {
        return id;
    }

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

    public String getTaskId() {
        return taskId;
    }

    public void setTaskId(String taskId) {
        this.taskId = taskId;
    }

    @Override
    public String toString() {
        return "Tasklog{" +
                "id='" + id + '\'' +
                ", taskId='" + taskId + '\'' +
                '}';
    }
}

编写Mapper

package org.lvgang.springbootehcache.mapper;

import com.baomidou.mybatisplus.mapper.BaseMapper;
import org.lvgang.springbootehcache.bean.Tasklog;

public interface TaskLogMapper extends BaseMapper<Tasklog> {

}

mapper继承了mybatisplus用于简化数据存储编码

编写Service

package org.lvgang.springbootehcache.service;

import net.sf.ehcache.Cache;
import net.sf.ehcache.Element;
import org.lvgang.springbootehcache.bean.Tasklog;
import org.lvgang.springbootehcache.mapper.TaskLogMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.stereotype.Service;

import java.util.Map;

/**
 * 测试服务层
 */
@Service
public class TaskLogService {

    @Autowired  private TaskLogMapper taskLogMapper;
    @Autowired  private net.sf.ehcache.CacheManager cacheManager;

    /**
     * 缓存的key
     */
    public static final String CACHE_KEY   = "taskLog";

    /**
     * 添加tasklog
     * @param tasklog
     * @return
     */
    @CachePut(value = CACHE_KEY, key = "#tasklog.id")
    public Tasklog create(Tasklog tasklog){
        System.out.println("CREATE");
        System.err.println (tasklog);
        taskLogMapper.insert(tasklog);
        return tasklog;
    }

    /**
     * 根据ID获取Tasklog
     * @param id
     * @return
     */
    @Cacheable(value = CACHE_KEY, key = "#id")
    public Tasklog findById(String id){
        System.out.println("FINDBYID");
        System.out.println("ID:"+id);
        return taskLogMapper.selectById(id);
    }

    /**
     * 根据ID更新Tasklog
     * @param tasklog
     * @return
     */
    @CachePut(value = CACHE_KEY, key = "#tasklog.id")
    public Tasklog update(Tasklog tasklog){
        System.out.println("UPDATE");
        System.out.println (tasklog);
        taskLogMapper.updateById(tasklog);
        return tasklog;
    }

    /**
     * 根据ID删除Tasklog
     * @param id
     */
    @CacheEvict(value = CACHE_KEY, key = "#id")
    public void delete(String id){
        System.out.println("DELETE");
        System.out.println("ID:"+id);
        taskLogMapper.deleteById(id);
    }


    public void getCache(){
        System.out.println("GETCACHE");
        Cache cache = cacheManager.getCache(CACHE_KEY);
        Map<Object,Element> elements = cache.getAll(cache.getKeys());
        if(elements!=null){
            for (Map.Entry<Object, Element> entry : elements.entrySet()) {
                System.out.println("key= " + entry.getValue().getObjectKey());
                System.out.println("value= " + entry.getValue().getObjectValue());
            }
        }
    }

//    @Cacheable、@CachePut、@CacheEvict 注释介绍
//    @Cacheable 的作用 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存
//    @CachePut 的作用 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存，和 @Cacheable 不同的是，它每次都会触发真实方法的调用
//    @CachEvict 的作用 主要针对方法配置，能够根据一定的条件对缓存进行清空
}

编写Controller

package org.lvgang.springbootehcache.controller;

import org.lvgang.springbootehcache.bean.Tasklog;
import org.lvgang.springbootehcache.service.TaskLogService;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;


/**
 * 测试控制层
 */
@RestController
@RequestMapping("/taskLog")
public class TaskLogController {

    @Autowired
    private TaskLogService taskLogService;

    /**
     * 根据ID查询
     * @return
     */
    @RequestMapping("/get")
    public Tasklog getById(String id) {
        return taskLogService.findById(id);
    }

    /**
     * 添加数据
     * @return
     */
    @RequestMapping("/add")
    public String add() {
        Tasklog bean = new Tasklog();
        bean.setId(UUID.randomUUID().toString().replace("-", ""));
        bean.setTaskId(bean.getId());
        taskLogService.create(bean);
        return "插入成功";
    }

    /**
     * 更新数据
     * @return
     */
    @RequestMapping("/update")
    public String update(String id) {
        Tasklog bean = new Tasklog();
        bean.setId(id);
        bean.setTaskId(UUID.randomUUID().toString().replace("-", ""));

        bean = taskLogService.update(bean);
        if (bean != null) {
            return "更新成功";
        } else {
            return "更新失败";
        }
    }

    /**
     * 删除数据
     * @return
     */
    @RequestMapping("/romove")
    public String romove(String id) {
        taskLogService.delete(id);
        return "删除成功";
    }

    /**
     * 控制台输出缓存
     * @param id
     */
    @RequestMapping("/getCache")
    public void getCache(String id) {
        taskLogService.getCache();
    }
}

SpringBoot Ehcache配置类

package org.lvgang.springbootehcache;

import net.sf.ehcache.config.CacheConfiguration;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurer;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.CacheResolver;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cache.interceptor.SimpleKeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * EhCache配置文件，可以替代ehcache.xml 文件
 */

@Configuration
@EnableCaching
public class EhCacheConfiguration implements CachingConfigurer {

    @Bean(destroyMethod="shutdown")
    public net.sf.ehcache.CacheManager ehCacheManager() {
        CacheConfiguration cacheConfiguration = new CacheConfiguration();
        cacheConfiguration.setName("taskLog");
        cacheConfiguration.setMemoryStoreEvictionPolicy("LRU");
        cacheConfiguration.setMaxEntriesLocalHeap(1000);
        net.sf.ehcache.config.Configuration config = new net.sf.ehcache.config.Configuration();
        //可以创建多个cacheConfiguration，都添加到Config中
        config.addCache(cacheConfiguration);
        return net.sf.ehcache.CacheManager.newInstance(config);
    }

    @Bean
    @Override
    public CacheManager cacheManager() {
        return new EhCacheCacheManager(ehCacheManager());
    }

    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        return new SimpleKeyGenerator();
    }

    @Override
    public CacheResolver cacheResolver() { return null; }

    @Override
    public CacheErrorHandler errorHandler() {
        return null;
    }

}

SpringBoot 启动类

package org.lvgang.springbootehcache;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication // 等价于@Configuration，@EnableAutoConfiguration和@ComponentScan
@MapperScan("org.lvgang.springbootehcache.mapper")  //mybatis mapper搜索路径
public class SpringbootEhcacheApplication {
	public static void main(String[] args) {
		SpringApplication.run(SpringbootEhcacheApplication.class, args);
	}
}

二、测试

在执行以下测试时，必须先需要在数据库表中增加一条ID为9f829afb589542ffb4b7bff33345af2f的数据。