[SpringBoot的中间件生涯 ] SpringBoot+JPA+Cache+Redis实现缓存效果

于 2021-06-08 15:39:03 发布
阅读量417 收藏 1
点赞数
分类专栏： 工作总结相关 SpringBoot
汤圆
本文链接：https://blog.csdn.net/sqL520lT/article/details/117704215
版权

SpringBoot+JPA+Redis实现缓存

注意事项:

1:你可以下载对应的Redis Windows版本的,
启动redis-server.exe,默认是没有密码的,然后配置连接就行了
2:我这里踩坑, 在我配置properties/yml 的时候,自己不小心把数据库的url 和 数据库的账号密码 没有对应上, 导致无法访问接口！但是还是启动成功了！ 应该只是启动了一半，在启动的时候 ,在运行项目启动的 会校验yml 配置,可能没报错 但是yml有问题！！！我就是访问接口就是不通, 数据库密码是线上数据库的,url是本地数据库！！ 修改对应 就好了
3:初学者 注意iml 实现类里面的 注解

  • @CacheEvict 删除缓存
  • @Cacheable 读取缓存
  • @CachePut 写入缓存

主要所用的依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

<!--        切换缓存 ehcache-->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
        </dependency>

        <!--切换缓存 guava-->
        <!--<dependency>-->
            <!--<groupId>com.google.guava</groupId>-->
            <!--<artifactId>guava</artifactId>-->
            <!--<version>18.0</version>-->
        <!--</dependency>-->

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

        <!--db-->

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.4</version>
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

我自己版本完整依赖

1：怕有的小伙伴 版本不兼容 可以对应看来调整

<?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.us</groupId>
    <artifactId>springboot-Cache</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.0.RELEASE</version>
    </parent>

    <properties>
        <start-class>com.us.Application</start-class>

        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.source>1.8</maven.compiler.source>
    </properties>

    <!-- Add typical dependencies for a web application -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

<!--        切换缓存 ehcache-->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
        </dependency>

        <!--切换缓存 guava-->
        <!--<dependency>-->
            <!--<groupId>com.google.guava</groupId>-->
            <!--<artifactId>guava</artifactId>-->
            <!--<version>18.0</version>-->
        <!--</dependency>-->

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

        <!--db-->

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.4</version>
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

</project>

application.properties数据库配置

ms.db.driverClassName=com.mysql.jdbc.Driver
ms.db.url=jdbc:mysql://localhost:3306/test?prepStmtCacheSize=517&cachePrepStmts=true&autoReconnect=true&useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
ms.db.username=root
ms.db.password=123.com
ms.db.maxActive=500
#最多缓存 500 条 ，缓存在 30 分钟后失效
#spring.cache.guava.spec= maximumSize=500,expireAfterWrite=30m

redis.hostname=127.0.0.1
redis.port=6379

ehcache.xml 的配置

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <!--切换为ehcache 缓存时使用-->
<cache name="people" maxElementsInMemory="1000" />
</ehcache>

Application启动类配置

 package com.us.example;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;

import static org.springframework.boot.SpringApplication.*;

 

@ComponentScan(basePackages ="com.us.example")
@SpringBootApplication
@EnableCaching
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext run = run(Application.class, args);
    }

}

实体类

package com.us.example.bean;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;


@Entity
@Table(name = "person")
public class Person implements Serializable {

    private static final long serialVersionUID = 133938246231808718L;

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    private Integer age;

    private String address;

    public Person() {
        super();
    }
    public Person(Long id, String name, Integer age, String address) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }


}

数据库DB Config 配置类

package com.us.example.config;

 
import java.beans.PropertyVetoException;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import com.mchange.v2.c3p0.ComboPooledDataSource;

@Configuration
public class DBConfig {
    @Autowired
    private Environment env;

    @Bean(name="dataSource")
    public ComboPooledDataSource dataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(env.getProperty("ms.db.driverClassName"));
        dataSource.setJdbcUrl(env.getProperty("ms.db.url"));
        dataSource.setUser(env.getProperty("ms.db.username"));
        dataSource.setPassword(env.getProperty("ms.db.password"));
        dataSource.setMaxPoolSize(20);
        dataSource.setMinPoolSize(5);
        dataSource.setInitialPoolSize(10);
        dataSource.setMaxIdleTime(300);
        dataSource.setAcquireIncrement(5);
        dataSource.setIdleConnectionTestPeriod(60);
        return dataSource;
    }
}

Jpa 的工具配置类

package com.us.example.config;

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

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

 

@Configuration
@EnableJpaRepositories("com.us.example.dao")
@EnableTransactionManagement
@ComponentScan
public class JpaConfig {
    @Autowired
    private DataSource dataSource;

    @Bean
    public EntityManagerFactory entityManagerFactory() {
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
//        vendorAdapter.setShowSql(true);
//        vendorAdapter.setGenerateDdl(true);

        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
        factory.setJpaVendorAdapter(vendorAdapter);
        factory.setPackagesToScan("com.us.example.bean");
        factory.setDataSource(dataSource);


        Map<String, Object> jpaProperties = new HashMap<>();
        jpaProperties.put("hibernate.ejb.naming_strategy","org.hibernate.cfg.ImprovedNamingStrategy");
        jpaProperties.put("hibernate.jdbc.batch_size",50);
        jpaProperties.put("hibernate.show_sql",true);

        factory.setJpaPropertyMap(jpaProperties);
        factory.afterPropertiesSet();
        return factory.getObject();
    }

    @Bean
    public PlatformTransactionManager transactionManager() {

        JpaTransactionManager txManager = new JpaTransactionManager();
        txManager.setEntityManagerFactory(entityManagerFactory());
        return txManager;
    }
}

Redis 配置类

package com.us.example.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
 
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{
    private static final Logger logger = LoggerFactory.getLogger(RedisConfig.class);

    @Autowired
    private Environment env;

    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory redisConnectionFactory = new JedisConnectionFactory();
        redisConnectionFactory.setHostName(env.getProperty("redis.hostname"));
        redisConnectionFactory.setPort(Integer.parseInt(env.getProperty("redis.port")));
        return redisConnectionFactory;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory cf) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(cf);
        return redisTemplate;
    }

    @Bean
    public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        cacheManager.setDefaultExpiration(600);
        return cacheManager;
    }

    public CacheErrorHandler errorHandler() {
        return new CacheErrorHandler(){

            @Override
            public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
                logger.warn("handleCacheGetError in redis: {}", exception.getMessage());
            }

            @Override
            public void handleCachePutError(RuntimeException exception, Cache cache, Object key, Object value) {
                logger.warn("handleCachePutError in redis: {}", exception.getMessage());
            }

            @Override
            public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
                logger.warn("handleCacheEvictError in redis: {}", exception.getMessage());
            }

            @Override
            public void handleCacheClearError(RuntimeException exception, Cache cache) {
                logger.warn("handleCacheClearError in redis: {}", exception.getMessage());
            }};
    }
}

控制台Controller 配置类

package com.us.example.controller;
import com.us.example.bean.Person;
import com.us.example.service.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

 
@RestController
@CrossOrigin
public class CacheController {

    @Autowired
   private DemoService demoService;

    @RequestMapping("/hello")
    public String aa(){
        return "hello";
    }

    //http://localhost:8080/put?name=abel&age=23&address=shanghai
    @RequestMapping("/put")
    public Person put(Person person){
        return demoService.save(person);
    }

    //http://localhost:8080/able?id=1
    @RequestMapping("/able")
    @ResponseBody
    public Person cacheable(Person person){
        return demoService.findOne(person);

    }

    //http://localhost:8080/evit?id=1
    @RequestMapping("/evit")
    public String  evit(Long id){
        demoService.remove(id);
        return "ok";
    }


}

Dao层

package com.us.example.dao;

import com.us.example.bean.Person;
import org.springframework.data.jpa.repository.JpaRepository;

 
public interface PersonRepository extends JpaRepository<Person, Long> {

}

Service 层

package com.us.example.service;

import com.us.example.bean.Person;

 
public  interface DemoService {
    public Person save(Person person);

    public void remove(Long id);

    public Person findOne(Person person);

}

ServiceIml 实现层

package com.us.example.service.Impl;

import com.us.example.bean.Person;
import com.us.example.dao.PersonRepository;
import com.us.example.service.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
 
@Service
public class DemoServiceImpl implements DemoService {

    @Autowired
    private PersonRepository personRepository;

    @Override
    //@CachePut缓存新增的或更新的数据到缓存,其中缓存名字是 people 。数据的key是person的id
    @CachePut(value = "people", key = "#person.id")
    public Person save(Person person) {
        Person p = personRepository.save(person);
        System.out.println("为id、key为:"+p.getId()+"数据做了缓存");
        return p;
    }

    @Override
    //@CacheEvict 从缓存people中删除key为id 的数据
    @CacheEvict(value = "people")
    public void remove(Long id) {
        System.out.println("删除了id、key为"+id+"的数据缓存");
        //这里不做实际删除操作
    }

    @Override
    //@Cacheable缓存key为person 的id 数据到缓存people 中,如果没有指定key则方法参数作为key保存到缓存中。
    @Cacheable(value = "people", key = "#person.id")
    public Person findOne(Person person) {
        Person p = personRepository.findOne(person.getId());
        System.out.println("为id、key为:"+p.getId()+"数据做了缓存");
        return p;
    }

}
是汤圆丫
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
用redis和jpa实现缓存文章和点击量-SpringBoot（23）
weixin_43831002的博客
08-13 736
用redis和jpa实现缓存文章和点击量-SpringBoot（23）
java后端&redis缓存&缓存预热
weixin_52154534的博客
11-27 1297
NoSQL（非关系型数据库）key-value键值对存储系统（区别于mysql的键值对数据库）
spring data rest 缓存/spring boot Jpa 二级缓存 ehcache 与 redis
lgxzzz的博客
10-20 1446
这两天都在为学校的项目做准备，期间也遇到了很多问题，比如自己写代码生成器，比如授权这些，发现自己还是有点太弱了。但是最为棘手的莫过于缓存的问题。主要原因还是自己太想用 spring data rest 了，这个在假期就没有解决缓存的问题，现在还是要来再次面对，不过相隔几个月，今非昔比。 问题分析 项目直接使用 spring data rest 进行资源暴露，repository 完全接手，所以我舍去了 service 层，controller 也基本没有方法，就算有也被抽象出来了。那么没有 servic
使用 SpringBoot 之 JPA 整合 Redis 实现缓存
热门推荐
IT小村
03-26 1万+
一、前言 数据库中的 select 是使用最频繁的，而且每次基本都是一样的，而 update、delete、insert 使用的频率没有 select 高，并且每次基本都是不一样的。为了减少数据库的压力，有必要对 select 使用缓存，以前使用的是 Ehcache 做缓存，但是其有一个很明显的缺点，就是没有 ip、port，而是使用路径的，不容易起到共享缓存的作用。故使用 Redis 做缓存可...
springboot+jpa(hibernate配置redis为二级缓存) springboot2.1.4
04-23
基于springboot最新版本2.1.4.RELEASE，采用jpa为dao层框架，配置redis（redisson）为hibernate的二级缓存。
SpringBoot+JPA+MySQL+Swagger+Redis实现CRUD
04-04
通过SpringBoot+JPA+MySQL+Swagger+Redis实现CRUD，对数据库进行增删改查，分页查找的接口文档
SpringBoot+Shiro+Jpa+Redis.zip
05-15
Java实现SpringBoot+Shiro+Jpa+Redis实现权限管理，附sql文件，下载导入idea可直接运行。
后台管理系统+springBoot+Jpa+JWT+Redis+Vue
最新发布
04-29
一个基于 Spring Boot 2.6.4 、 Spring Boot Jpa、 JWT、Spring Security、Redis、Vue的前后端分离的后台管理系统 用户管理：提供用户的相关配置，新增用户后，默认密码为123456 角色管理：对权限与菜单进行分配，可...
springboot+Security+jWT+JPA+MyBatis
05-17
该demo使用springboot2.0建立，然后搭配Security+jsonwebToken实现了不同路径的权限控制访问，里面还实现了根据角色跳转不同页面的功能，里面也结合了mybatis和jpa的相关操作，也是一般大众学员的学习内容
springboot+shiro+jpa+email
11-15
springboot整合shiro简单的测试，加邮箱发送，连接mysql jpa自动创建数据库表
springboot springdata jpa 整合redis作为缓存使用
my的博客
08-30 5804
pom： &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;/dependency&gt;   在你的应用启动类上边 添加如下注解...
SpringBoot2+JPA+Redis 实现缓存
心猿意码
03-06 1226
pom文件 <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/mave...
SpringBoot+Jpa+Redis 简单入门
gzgmyj的博客
07-20 4383
1.Redis windows 服务器安装 百度很多方法 不懂可以来问我 qq:185624592 源码地址：https://gitee.com/GuoZG0328/jpa   2.创建项目  这是pom文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/...
整合SpringBoot+JPA+Mysql+Redis实现缓存机制的一个Demo
CQHaveADream的博客
01-12 3143
公司的项目中用到了Redis，最近一直在学习这一块。从开始学习到现在，总体给我的感觉是Redis上手比较容易，但是精通需要大量的实践和研究的。好在我们公司对Redis的使用并不是那么深入，目前只进行些简单的操作。总结这几天的学习结果，记录下来，希望有助于巩固和提高。 说明：我的Redis服务是搭建在虚拟机Linux(Read Heat6.2)系统上的，Mysql数据库安装在本机，虚拟机的...
springboot+shiro+jpa整合redis缓存
AbsolutelyNT的博客
08-26 1695
springboot之前已经介绍整合过了，今天来讲一下springboot对redis非关系型数据库的操作。redis非关系型数据库，完全不同于Oracle，MySQL，sqlserver 这种关系型数据库。 NOSQL(redis)与关系型数据库: Oracle，MySQL，sqlserver是关系型数据库，Redis是K/V数据库，就是一个key，一个value，类似于Java里面的map...
springboot2.0+jpa+redis数据缓存管理，扩展RedisTemplate操作各种数据类型
qq_44909430的博客
11-05 734
pom文件 <?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....
Spring boot 2.x + Spring data jpa 2.x + Redis 2.x 数据缓存
qq_41168942的博客
02-26 1853
本文案例使用 ：  Spring boot 2.1.3.RELEASE  、 Spring  Data  Jpa  2.1.3.RELEASE 、 Redis  2.1.3.RELEASE 浅谈 Redis 应用场景： 数据高并发的读写 海量数据的读写 对扩展性要求高的数据 不适场景：Redis 更多理论 需要事务支持（非关系型数据库） 基于sql结...
Spring Data JPA整合Redis缓存的配置
weixin_33672400的博客
10-16 540
1. 整合的配置文件如下 <!-- Spring整合redis --> <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"> <property name="maxTotal" value="30"/> </bean> ...
springboot+redis+mysql+uniapp实现点赞和评论功能
07-14
实现点赞和评论功能可以使用Spring Boot作为后端框架，Redis作为缓存数据库，MySQL作为持久化数据库，UniApp作为前端框架。以下是一个简单的实现步骤： 1. 创建Spring Boot项目并配置MySQL和Redis的连接。 2. 创建...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是汤圆丫

怎么 给1分?

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值