/*
SQLyog Enterprise v12.09 (64 bit)
MySQL - 5.5.40 : Database - springboot_cache
*********************************************************************
*/


/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`springboot_cache` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `springboot_cache`;

/*Table structure for table `employee` */

DROP TABLE IF EXISTS `employee`;

CREATE TABLE `employee` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `lastName` varchar(255) DEFAULT NULL,
  `email` varchar(255) DEFAULT NULL,
  `gender` int(2) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

/*Data for the table `employee` */

insert  into `employee`(`id`,`lastName`,`email`,`gender`) values (1,'花花','232342@',2),(2,'叶子','2342432323@',3);

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            2.1.3
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-cache
        
        
        
            mysql
            mysql-connector-java
            5.1.37
            runtime
        
        
        
            org.projectlombok
            lombok
            true
        

        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.4.0
        
     
        
            com.baomidou
            mybatis-plus-generator
            3.4.0
        
        
            org.apache.velocity
            velocity-engine-core
            2.2
        
        
        
            io.springfox
            springfox-swagger2
            2.7.0
        
        
            io.springfox
            springfox-swagger-ui
            2.7.0
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
    

spring:
  profiles:
    active: dev1

---
spring:
  profiles: dev1
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_cache
    username: root
    password: root
server:
  port: 8080
#控制台打印配置信息
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: com.yezi.redistest.pojo
  mapper-locations: classpath:com/yezi/redistest/mapper/xml/*.xml
debug: true
---

spring:
  profiles: dev2
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_cache
    username: root
    password: root
  redis:
    host: localhost
    port: 6379
    database: 0
    timeout: 1800000
    lettuce:
      pool:
        max-active: 20
        max-wait: -1  # 最大阻塞时间，负数表示没有限制
        max-idle: 5
        min-idle: 0
server:
  port: 8080
#控制台打印配置信息
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: com.yezi.redistest.pojo
  mapper-locations: classpath:com/yezi/redistest/mapper/xml/*.xml

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import org.junit.jupiter.api.Test;

/**
 *
 * @author 叶子
 * @since 2020/10/28
 */
public class CodeGenerator {

    @Test
    public void run() {

        // 1、创建代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 2、全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");//得到当前文件夹路径
        gc.setOutputDir(projectPath + "/src/main/java");//代码生成目录
        gc.setAuthor("叶子");
        gc.setOpen(false); //生成后是否打开资源管理器
        gc.setFileOverride(false); //重新生成时文件是否覆盖
        gc.setServiceName("%sService"); //去掉Service接口的首字母I
        gc.setIdType(IdType.ID_WORKER_STR); //主键策略
        gc.setDateType(DateType.ONLY_DATE);//定义生成的实体类中日期类型
        gc.setSwagger2(true);//开启Swagger2模式

        mpg.setGlobalConfig(gc);

        // 3、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/springboot_cache");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 4、包配置
        PackageConfig pc = new PackageConfig();
        pc.setParent("com.yezi.redistest");
        /*pc.setModuleName("ucenter"); //模块名*/
        pc.setController("controller");
        pc.setEntity("pojo");
        pc.setService("service");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);

        // 5、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("department","employee");//表名称
        strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略
        strategy.setTablePrefix(pc.getModuleName() + "_"); //生成实体时去掉表前缀

        strategy.setColumnNaming(NamingStrategy.underline_to_camel);//数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作

        strategy.setRestControllerStyle(true); //restful api风格控制器
        strategy.setControllerMappingHyphenStyle(true); //url中驼峰转连字符

        mpg.setStrategy(strategy);


        // 6、执行
        mpg.execute();
    }
}

@SpringBootApplication
@MapperScan(basePackages = "com.yezi.redistest.mapper")
@EnableCaching /* 开启缓存注解 */
public class SpringbootRedisCatchApplication {

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

}

package com.yezi.redistest.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.yezi.redistest.pojo.Employee;
import com.yezi.redistest.mapper.EmployeeMapper;
import com.yezi.redistest.service.EmployeeService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.cache.annotation.*;
import org.springframework.stereotype.Service;

/**
 * 

 *  服务实现类
 * 

 *
 * @author 叶子
 * @since 2020-10-27
 */
@Service
@CacheConfig(cacheNames = "employee") /* 指定Cache组件名，本类的所有缓存都会被存储在名为employee的缓存组件中 */
public class EmployeeServiceImpl extends ServiceImpl implements EmployeeService {

    /**
     * 将方法的运行结果进行缓存；以后再要相同的数据，直接从缓存中获取，不用调用方法；
     * CacheManager管理多个Cache组件的，对缓存的真正CRUD操作在Cache组件中，每一个缓存组件有自己唯一一个名字；
     * CacheManager和Cache的关系类似于MySQL数据库中 数据库和表的关系
     *   @Cacheable标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存，
     *   如果没有就运行方法并将结果放入缓存；以后再来调用就可以直接使用缓存中的数据；
     *
     *   核心：
     *      1）、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件
     *      2）、key使用keyGenerator生成的，默认是SimpleKeyGenerator
     * @param id
     * @return
     */
    @Override
    @Cacheable(key = "#id")
    public Employee getEmployeeById(Integer id) {
        return baseMapper.selectById(id);
    }
}

    /**
     * unless = "#result == null"
     *  当返回值为null时就不进行缓存
     * @param employee
     * @return
     */
    @Override
    @CachePut(key = "#employee.id",unless = "#result == null")
    public Employee update(Employee employee) {
        System.out.println(employee.getId());
        UpdateWrapper wrapper = new UpdateWrapper<>();
        
        int i = baseMapper.updateById(employee);
        if (i > 0){
            return employee;
        }

        return null;
    }

    @Override
    @CacheEvict(key = "#id")
    public void deleteById(Integer id) {
        baseMapper.deleteById(id);
    }

    /**
     * 这里我没有具体指定缓存策略
     * 但是我们可以看到：
     *      使用这个注解可以同时使用@Cacheable、@CachePut和@CacheEvict注解
     *      从而实现一些复杂的缓存策略
     * @param lastName
     * @return
     */
    @Override
    @Caching(cacheable = {
            @Cacheable
    },put = {
            @CachePut
    },evict = {
            @CacheEvict
    })
    public Employee getByLastName(String lastName) {
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("lastName",lastName);
        Employee employee = baseMapper.selectOne(wrapper);

        return employee;
    }

/**
  * {@link ImportSelector} to add {@link CacheType} configuration classes.
  */
static class CacheConfigurationImportSelector implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        CacheType[] types = CacheType.values();
        String[] imports = new String[types.length];
        for (int i = 0; i < types.length; i++) {
            imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
        }
        return imports;
    }

}

debug: true

/**
 * Simplest cache configuration, usually used as a fallback.
 *
 * @author Stephane Nicoll
 */
@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean(CacheManager.class)
@Conditional(CacheCondition.class)
class SimpleCacheConfiguration {

 @Bean
 ConcurrentMapCacheManager cacheManager(CacheProperties cacheProperties,
   CacheManagerCustomizers cacheManagerCustomizers) {
  ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
  List cacheNames = cacheProperties.getCacheNames();
  if (!cacheNames.isEmpty()) {
   cacheManager.setCacheNames(cacheNames);
  }
  return cacheManagerCustomizers.customize(cacheManager);
 }

}

    /**
     * 非源码注释
     * @param name cache名称，即由cacheNames和value属性指定的那个名称
     * @return 如果不存在指定Cache，就根据名称创建Cache。如果存在，就返回该Cache
     */
    @Override
    @Nullable
    public Cache getCache(String name) {
        Cache cache = this.cacheMap.get(name);
        if (cache == null && this.dynamic) {
            synchronized (this.cacheMap) {
                cache = this.cacheMap.get(name);
                if (cache == null) {
                    cache = createConcurrentMapCache(name);//其实就是创建了一个Map集合，后面会讲到
                    this.cacheMap.put(name, cache);
                }
            }
        }
        return cache;
    }

 /**
  * Create a new ConcurrentMapCache instance for the specified cache name.
  * @param name the name of the cache
  * @return the ConcurrentMapCache (or a decorator thereof)
  */
 protected Cache createConcurrentMapCache(String name) {
  SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
  return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256), isAllowNullValues(), actualSerialization);
 }