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

冷不防 2023-10-04 15:48 36阅读 0赞

#### SpringBoot+JPA+Redis实现缓存 ####

*  注意事项:
 *   *  主要所用的依赖
     *  我自己版本完整依赖
     *  application.properties数据库配置
     *  ehcache.xml 的配置
     *  Application启动类配置
     *  实体类
     *  数据库DB Config 配置类
     *  Jpa 的工具配置类
     *  Redis 配置类
     *  控制台Controller 配置类
     *  Dao层
     *  Service 层
     *  ServiceIml 实现层

## 注意事项: ##

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>
    
    
            <dependency>
                <groupId>net.sf.ehcache</groupId>
                <artifactId>ehcache</artifactId>
            </dependency>
    
            
            
                
                
                
            
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-redis</artifactId>
            </dependency>
    
            
    
            <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>
    
        
        <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>
    
    
            <dependency>
                <groupId>net.sf.ehcache</groupId>
                <artifactId>ehcache</artifactId>
            </dependency>
    
            
            
                
                
                
            
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-redis</artifactId>
            </dependency>
    
            
    
            <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>
        
    <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;
        }
    
    }