springboot(缓存)

Cache缓存

1.导入缓存对应的依赖

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

2.启用缓存

@SpringBootApplication
//开启缓存
@EnableCaching
public class CacheApplication {

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

}

3.在对应的操作上设置缓存

//@CachePut(value = "smsCode",key = "#phone") 往缓存里放值
@Cacheable(value = "cacheSpace",key = "#id")
 public  Book getById(int id){
     return bookDao.selectById(id);
 }

//验证码
int hash = phone.hashCode();
      int encryption = 2020666;
      long result = hash ^ encryption;
      long nowTime = System.currentTimeMillis();
      result = result ^ nowTime;
      long code = result % 1000000;
      code = code < 0 ? -code : code;
      String strCode = code +  "";
      int len = strCode.length();
      return str[len] + strCode;

springboot整合Redis

cache:
    type: redis
    redis:
#      use-key-prefix: true    #
#      cache-null-values: false
#      key-prefix: aa  #指定key的前缀
      time-to-live: 10s  #设置生命周期时间

更换缓存供应商

memcached

pom.xml加入XMemcached依赖

<dependency>
    <groupId>com.googlecode.xmemcached</groupId>
    <artifactId>xmemcached</artifactId>
    <version>2.4.6</version>
</dependency>

配置memcached服务器必要属性

memcached:
  servers: localhost:11211 # memcached服务器地址
  poolSize: 10 # 连接池的数量
  opTimeout: 3000 # 设置默认操作超时

关键读取属性配置信息类，加载配置

@Component
@ConfigurationProperties(prefix = "memcached")
@Data
public class XMemcachedPeoprerties {

    private String servers;
    private int poolSize;
    private long opTimeout;

}

创建客户端配置类

@Configuration
public class XMemcachedConfig {

    @Autowired
    private XMemcachedPeoprerties memcachedPeoprerties;//属性配置信息类对象

    @Bean
    public MemcachedClient getMemcachedClient() throws IOException {

        MemcachedClientBuilder memcachedClientBuilder = new XMemcachedClientBuilder(memcachedPeoprerties.getServers());
        memcachedClientBuilder.setConnectionPoolSize(memcachedPeoprerties.getPoolSize());
        memcachedClientBuilder.setOpTimeout(memcachedPeoprerties.getOpTimeout());
        MemcachedClient memcachedClient = memcachedClientBuilder.build();

        return memcachedClient;
    }

}

配置memcached属性

@Service
public class SMSCodeServiceImpl implements SMSCodeService {

    @Autowired
    private CodeUtils codeUtils;


    /*@Override
    @CachePut(value = "smsCode",key = "#phone")
    public String getCode(String phone) {

        return codeUtils.generator(phone);
    }

    @Override
    public boolean checkCode(SMSCode smsCode) {
        String code = smsCode.getCode();
        String cacheCode = codeUtils.get(smsCode.getPhone());
        return code.equals(cacheCode);
    }*/

    //以下是springboot中使用xmemcached

    @Autowired
    private MemcachedClient memcachedClient;

    @Override
    public String getCode(String phone) {
        String code = codeUtils.generator(phone);
        try {
            memcachedClient.set(phone,10,code);//set(key,过期时间，value)
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return code;
    }

    @Override
    public boolean checkCode(SMSCode smsCode) {
        String code = null;
        try {
            code = memcachedClient.get(smsCode.getPhone()).toString();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return smsCode.getCode().equals(code);
    }
}

小结：xmemcached客户端加载方式（bean初始化），xmemcached客户端使用方式（set & get）

jetcache

jetCache对SpringCache进行了封装，在原有功能基础上实线了多级缓存、缓存统计、自动刷新、异步调用、数据报表等功能
jetCache设定了本地缓存与远程缓存的多级缓存解决方案
- 本地缓存（local）
  - LinkedHashMap
  - Caffeine
- 远程缓存（remote）
  - Redis
  - Tair

启动缓存（redis远程）

添加jetcache依赖

<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-starter-redis</artifactId>
    <version>2.6.4</version>
</dependency>

开启缓存开关

@SpringBootApplication
//jetcache启用缓存的主开关
@EnableCreateCacheAnnotation
public class JetcacheApplication {

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

}

配置参数（application.yml里面）

jetcache:
  local:
    default:
      type: linkedhashmap
      keyConvertor: fastjson

  remote:
    default:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50
    sms:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50

创建jetcache实例使用

@Service
public class SMSCodeServiceImpl implements SMSCodeService {

    @Autowired
    private CodeUtils codeUtils;

    //声明缓存对象
    @CreateCache(area = "sms",name = "jetCache::",expire = 3600)
    private Cache<String,String> jetCache;

    @Override
    public String getCode(String phone)
    {
        String code = codeUtils.generator(phone);
        jetCache.put(phone,code);
        return code;
    }

    @Override
    public boolean checkCode(SMSCode smsCode)
    {
        return smsCode.getCode().equals(jetCache.get(smsCode.getPhone()));
    }
}

启动方法注解

@SpringBootApplication
//jetcache启用缓存的主开关
@EnableCreateCacheAnnotation
//开启方法注解缓存
@EnableMethodCache(basePackages = "com.example")
public class JetcacheApplication {

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

}

使用方法注解操作缓存

@Service
public class BookServiceImpl implements BookService {

    @Autowired
    private BookDao bookDao;
    
    @Cached(name = "book::" ,key = "#id",expire = 3600,cacheType = CacheType.REMOTE)
    public  Book getById(int id){
        Book queryBook = bookDao.selectById(id);
        return queryBook;
    }

    @Override
    public List<Book> getAll() {
        return bookDao.selectList(null);
    }

    @Override
    public boolean insert(Book book) {
        return bookDao.insert(book) > 0;
    }

    @Override
    @CacheUpdate(name = "book::",key = "#book.id",value = "#book")
    public boolean update(Book book) {
        return bookDao.updateById(book) > 0;
    }

    @Override
    @CacheInvalidate(name = "book::",key = "#id")
    public boolean delete(int id) {
        return bookDao.deleteById(id) > 0;
    }
}

缓存对象必须保障可序列化

@Data
public class Book implements Serializable {//实线序列化接口

    private Integer id;
    private String name;
    private String type;
    private String description;

}

jetcache:
  statIntervalMinutes: 1//查看缓存统计报告
  local:
    default:
      type: linkedhashmap
      keyConvertor: fastjson

  remote:
    default:
      type: redis
      host: localhost
      port: 6379
      valueEncode: java
      valueDecode: java
      keyConvertor: fastjson
      poolConfig:
        maxTotal: 50
    sms:
      type: redis
      host: localhost
      port: 6379
      keyConvertor: fastjson
      poolConfig:
        maxTotal: 50

J2cache

导入相关的坐标

<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

<dependency>
    <groupId>net.oschina.j2cache</groupId>
    <artifactId>j2cache-core</artifactId>
    <version>2.8.2-release</version>
</dependency>
        
<dependency>
    <groupId>net.oschina.j2cache</groupId>
    <artifactId>j2cache-spring-boot2-starter</artifactId>
    <version>2.8.0-release</version>
</dependency>

在application.ymi里定义j2cache配置文件

1 2	j2cache: config-location: j2cache.properties

配置j2cache配置文件

#1级缓存
j2cache.L1.provider_class = ehcache
ehcache.config.xml = ehcache.xml

#2级缓存
j2cache.L2.provider_class =net.oschina.j2cache.cache.support.redis.SpringRedisProvider
j2cache.L2.config_section = redis
redis.hosts = localhost:6379

#1级缓存中的数据如何到达二级缓存
j2cache.broadcast =net.oschina.j2cache.cache.support.redis.SpringRedisPubSubPolicy

创建与配置ehcache.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
    <!--设置磁盘存储路径-->
    <diskStore path="D:\\ehcache\\"/>
    <defaultCache
            maxElementsInMemory="1000"
            eternal="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            overflowToDisk="true">
    </defaultCache>
</ehcache>

使用cacheChannel对象

@Service
public class SMSCodeServiceImpl implements SMSCodeService {

    @Autowired
    private CodeUtils codeUtils;

    @Autowired
    private CacheChannel cacheChannel;

    @Override
    public String getCode(String phone)
    {
        String code = codeUtils.generator(phone);
        cacheChannel.set("sms",phone,code);
        return code;
    }

    @Override
    public boolean checkCode(SMSCode smsCode)
    {
        String code = cacheChannel.get("sms",smsCode.getPhone()).asString();
        return smsCode.getCode().equals(code);
//        return smsCode.getCode().equals(null);
    }
}