迷途的小狼
迷途的小狼

浅谈缓存－注解驱动的缓存 Spring cache介绍

在我们平常的工作当中，有好多场景需要用到缓存技术，如redis，ehcache等来加速数据的访问。作为浅谈缓存的第一篇笔者不想谈论具体的缓存技术，我更想介绍一下Spring中每次阅读都会使我心中泛起波澜的一个东西，那就是基于注解的缓存技术。我们先看Spring参考文档中的一句话。
Since version 3.1, Spring Framework provides support for transparently adding caching into an existing Spring application. Similar to the  transaction  support, the caching abstraction allows consistent use of various caching solutions with minimal impact on the code.
简单翻译一下，基于注解的缓存技术是Spring3.1版本引入的，其目的是为了给一个已有的Spring应用最小侵入的引入缓存。其原理与Spring的事务类似都是基于Spring的AOP技术。他本质上不是一个具体的缓存实现方案（例如redis EHCache等），而是一个对缓存使用的抽象，通过在既有代码中添加少量的annotation，即能达到缓存方法返回对象的效果。她支持开箱即用的缓存临时存储方案，也支持集成主流的专业缓存，如：redis，EHCache。好，废话少说，下面笔者通过几个简单例子来总结看看Spring Cache的优点，并通过源码对其原理做一个简单介绍。

  注意：笔者的代码都是基于Spring boot 1.5.9.release版本，代码的风格也都是Spring boot式的。

先建一个基于Spring Boot 的web项目，本文的编程用例都会在此项目中完成。项目的pom.xml文件如下。

xml version ="1.0" encoding ="UTF-8" ?>
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 " >
    4.0.0

    com.snow.cache
    snow-cache
    0.0.1-SNAPSHOT
    jar

    snow-cache
    Demo for Spring Cache

   
        org.springframework.boot
        spring-boot-starter-parent
        1.5.9.RELEASE
       
   

   
        UTF-8
        UTF-8
        1.8
   

   
       
            org.springframework.boot
            spring-boot-starter-web
       

       
            org.springframework.boot
            spring-boot-starter-test
            test
       
   

   
       
           
                org.springframework.boot
                spring-boot-maven-plugin
           
       
   

partI.传统缓存的用法
在聊Spring Cache之前，我们先来看看我们以前是怎么使用缓存的。这里笔者不打算引入任何第三方缓存而是自己实现一个简易的缓存。
案例：电商的场景中，商品信息需要经常被用户浏览，不做缓存数据库肯定吃不消。我们就来对商品信息的查询做缓存，以商品信息的编号为key，商品信息对象为value，当以相同的编号查询商品时，若缓存中有，直接从缓存中返回结果，否则从数据库中查询，并将查询结果放入缓存。

先定义一个产品实体类代码如下：
package com.snow.cache ;

import java.io.Serializable ;

/**
*
* @author snowwolf-louis
* @date 18/4/10
*/
public class Product implements Serializable{
    private Long id ;
    private String name ;
    private String desc ;

    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 String getDesc() {
        return desc ;
    }

    public void setDesc(String desc) {
        this. desc = desc ;
    }

    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", name='" + name + ' \' ' +
                ", desc='" + desc + ' \' ' +
                '}' ;
    }
}

在定义一个缓存管理器，负责缓存逻辑，支持对象的增加，修改和删除。代码如下：
package com.snow.cache.tradition ;

import java.util.Map ;
import java.util.concurrent.ConcurrentHashMap ;

/**
*
* @author snowwolf-louis
* @date 18/4/10
*/
public class SimpleCacheManager< T> {
    /**
     * 用ConcurrentHashMap做为缓存
     */
    private Map, T> cache = new ConcurrentHashMap, T>() ;

    /**
     * 从缓存中获取给定key的值
     * @param key
     * @return 返回缓存中指定key的值，若无则返回null
     */
    public T get(String key){
        return cache.get(key) ;
    }

    /**
     * 将数据(key,value)放入缓存
     * @param key
     * @param value
     */
    public void put(String key , T value){
        cache.put(key ,value) ;
    }

    /**
     * 清除缓存中指定key的的数据
     * @param key
     */
    public void evict(String key){
        if ( cache.containsKey(key)){
            cache.remove(key) ;
        }
    }

    /**
     * 清空缓存
     */
    public void clearAll(){
        cache.clear() ;
    }
}

将我们自定义的缓存管理器交给Spring容器管理

package com.snow.cache.tradition.config ;

import com.snow.cache.Product ;
import com.snow.cache.tradition.SimpleCacheManager ;
import org.springframework.context.annotation.Bean ;
import org.springframework.context.annotation.Configuration ;

/**
* 传统缓存用法的配置类
* @author snowwolf-louis
* @date 18/4/10
*/
@Configuration
public class SimpleCacheConfig {

    @Bean
    public SimpleCacheManager cacheManager(){
        return new SimpleCacheManager() ;
    }
}


对商品的业务操作接口

package com.snow.cache.tradition.service ;

import com.snow.cache.Product ;

/**
* 对商品的业务操作接口
* @author snowwolf-louis
* @date 18/4/10
*/
public interface ProductService {

    /**
     * 根据id查询商品信息
     * @param id
     * @return
     */
    public Product getProductById(Long id) ;

}

对商品的业务操作实现

package com.snow.cache.tradition.service ;

import com.snow.cache.Product ;
import com.snow.cache.tradition.SimpleCacheManager ;
import org.springframework.beans.factory.annotation.Autowired ;
import org.springframework.stereotype.Service ;

import java.util.Objects ;


/**
* @author snowwolf-louis
* @date 18/4/10
*/
@Service
public class ProductServiceImpl implements ProductService {

    @Autowired
    private SimpleCacheManager cacheManager ;

    @Override
    public Product getProductById(Long id) {

        if (Objects. isNull(id)){
            throw new NullPointerException( "id不能为空") ;
        }

        Product product = null;
        //首先从缓存查询
        product = cacheManager.get(id.toString()) ;
        if (product != null) {
            return product ;
        }

        //缓存中没有在从数据库中查找,我这里就不从数据库中查了，而是调用一个私有方法模拟从数据库中查
        product = getproductFromDB(id) ;

        //将数据库中查到数据装载进缓存
        if (product != null && product.getId() != null){
            cacheManager.put(product.getId().toString() ,product) ;
        }

        return product ;
    }

    private Product getproductFromDB(Long id) {
        try {
            Thread. sleep( 10L) ;
        } catch (InterruptedException e) {
            e.printStackTrace() ;
        }
        System. out.println( "从数据库中查询商品信息") ;

        Product product = new Product() ;
        product.setId(id) ;
        product.setName( "iphone 11") ;
        product.setDesc( "iphone 11,smartisan R1") ;
        return product ;
    }
}

好，缓存设计好了，我们编写一个测试类

package com.snow.cache.tradition ;

import com.snow.cache.Product ;
import com.snow.cache.tradition.config.SimpleCacheConfig ;
import com.snow.cache.tradition.service.ProductService ;
import com.snow.cache.tradition.service.ProductServiceImpl ;
import org.junit.Test ;
import org.junit.runner.RunWith ;
import org.springframework.beans.factory.annotation.Autowired ;
import org.springframework.boot.test.context.SpringBootTest ;
import org.springframework.test.context.junit4.SpringRunner ;

@RunWith (SpringRunner. class )
@SpringBootTest ( classes = {Product. class, SimpleCacheConfig. class, ProductServiceImpl. class })
public class SimpleCacheTests {

   @Autowired
   private ProductService productService ;


   @Test
   public void getProductByIdTest (){
      long start1 = System. currentTimeMillis () ;
      System. out .println( "第一次查询商品..." ) ;
      Product product1 = productService .getProductById( 1L ) ;
      long end1 = System. currentTimeMillis () ;
      System. out .println( "第一次查询所需时间:" + (end1 - start1) + "ms" ) ;
      System. out .println( "第一次查询的商品信息为:" + product1) ;


      long start2 = System. currentTimeMillis () ;
      System. out .println( "第二次查询商品..." ) ;
      Product product2 = productService .getProductById( 1L ) ;
      long end2 = System. currentTimeMillis () ;
      System. out .println( "第二次查询所需时间:" + (end2 - start2) + "ms" ) ;
      System. out .println( "第二次查询的商品信息为:" + product2) ;

   }

}


测试类中，我们两次调用商品查询接口结果如下

第一次查询商品...
从数据库中查询商品信息
第一次查询所需时间:11ms
第一次查询的商品信息为:Product{id=1, name='iphone 11', desc='iphone 11,smartisan R1'}
第二次查询商品...
第二次查询所需时间:0ms
第二次查询的商品信息为:Product{id=1, name='iphone 11', desc='iphone 11,smartisan R1'}

从结果中可以看出第一次查询商品是从数据库中查询商品信息的耗时11ms，第二次查询是走的缓存耗时不足1ms，两次返回结果也一摸一样，足见我们的缓存生效了。但是我们也不难发现传统方式的问题。
1.缓存代码和业务代码耦合度太高，如上面的例子中，ProductServiceImpl中的getProductById()方法有太多关于缓存的逻辑，不便于维护和变更。
2.不灵活，这种缓存方案不支持按照某种条件的缓存，比如只有某类商品才需要缓存，这种需求会导致代码的变更。
3.缓存的存储这块写的比较死，不能灵活的切换为使用第三方的缓存模块。

partII.Spring Cache 示例 & 原理：
以上我们代码中常见的问题，Spring Cache都很好的解决了。下面我们来看下Spring Cache的例子。
我们的缓存管理器使用Spring Cache提供的org.springframework.cache.concurrent.ConcurrentMapCacheManager
其内部使用org.springframework.cache.concurrent.ConcurrentMapCache作为缓存的存储容器，底层实际上也是java.util.concurrent.ConcurrentHashMap
好下面我将此缓存管理器交给Spring管理
package com.snow.cache.spring.config ;

import org.springframework.cache.CacheManager ;
import org.springframework.cache.annotation.CachingConfigurerSupport ;
import org.springframework.cache.annotation.EnableCaching ;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager ;
import org.springframework.context.annotation.Bean ;
import org.springframework.context.annotation.Configuration ;

import java.util.concurrent.ConcurrentMap ;

/**
*Spring Cache提供的开箱即用的缓存方案(使用{ @link ConcurrentMap }作为缓存的存储容器)
*
* @author snowwolf-louis
* @date 18/4/12
*/
@Configuration
@EnableCaching
public class ConcurrentMapCacheConfig extends CachingConfigurerSupport {

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

}

对商品的业务操作接口：

package com.snow.cache.spring.service ;

import com.snow.cache.Product ;

/**
* 对商品的业务操作接口
* @author snowwolf-louis
* @date 18/4/10
*/
public interface ProductService {

    /**
     * 根据id查询商品信息
     * @param id
     * @return
     */
    public Product getProductById(Long id) ;

}

对商品的业务操作实现

package com.snow.cache.spring.service ;

import com.snow.cache.Product ;
import com.snow.cache.tradition.SimpleCacheManager ;
import org.springframework.beans.factory.annotation.Autowired ;
import org.springframework.cache.annotation.Cacheable ;
import org.springframework.stereotype.Service ;

import java.util.Objects ;


/**
* @author snowwolf-louis
* @date 18/4/10
*/
@Service
public class ProductServiceImpl implements ProductService {


    @Override
    @Cacheable( value = "product" , key = "#id")
    public Product getProductById(Long id) {

        if (Objects. isNull(id)) {
            throw new NullPointerException( "id不能为空") ;
        }

        //缓存中没有在从数据库中查找,我这里就不从数据库中查了，而是调用一个私有方法模拟从数据库中查
        return getproductFromDB(id) ;

    }

    private Product getproductFromDB(Long id) {
        try {
            Thread. sleep( 10L) ;
        } catch (InterruptedException e) {
            e.printStackTrace() ;
        }
        System. out.println( "从数据库中查询商品信息") ;

        Product product = new Product() ;
        product.setId(id) ;
        product.setName( "iphone 11") ;
        product.setDesc( "iphone 11,smartisan R1") ;
        return product ;
    }
}

我们可以看到上述getProductById方法上面加了一行这个注解 @Cacheable( value = "product" , key = "#id")
而原先对缓存的操作的一些代码在这里全都没有了，代码变得非常的干净仅仅和所需的业务相关。下面就测试一下这个缓存是否生效了。测试类如下：
package com.snow.cache.spring ;

import com.snow.cache.Product ;
import com.snow.cache.spring.config.ConcurrentMapCacheConfig ;
import com.snow.cache.spring.service.ProductService ;
import com.snow.cache.spring.service.ProductServiceImpl ;
import org.junit.Test ;
import org.junit.runner.RunWith ;
import org.springframework.beans.factory.annotation.Autowired ;
import org.springframework.boot.test.context.SpringBootTest ;
import org.springframework.test.context.junit4.SpringRunner ;

@RunWith(SpringRunner. class)
@SpringBootTest( classes = {ConcurrentMapCacheConfig. class,
      Product. class, ProductServiceImpl. class})
public class SpringCacheTests {

   @Autowired
   private ProductService productService ;

   @Test
   public void getProductByIdTest(){
      long start1 = System. currentTimeMillis() ;
      System. out. println( "第一次查询商品...") ;
      Product product1 = productService.getProductById( 1L) ;
      long end1 = System. currentTimeMillis() ;
      System. out. println( "第一次查询所需时间:" + (end1 - start1) + "ms") ;
      System. out. println( "第一次查询的商品信息为:" + product1) ;


      long start2 = System. currentTimeMillis() ;
      System. out. println( "第二次查询商品...") ;
      Product product2 = productService.getProductById( 1L) ;
      long end2 = System. currentTimeMillis() ;
      System. out. println( "第二次查询所需时间:" + (end2 - start2) + "ms") ;
      System. out. println( "第二次查询的商品信息为:" + product2) ;

   }

}

执行结果：

第一次查询商品...
从数据库中查询商品信息
第一次查询所需时间:59ms
第一次查询的商品信息为:Product{id=1, name='iphone 11', desc='iphone 11,smartisan R1'}
第二次查询商品...
第二次查询所需时间:1ms
第二次查询的商品信息为:Product{id=1, name='iphone 11', desc='iphone 11,smartisan R1'}

从结果中可以看出第一次查询是走的数据库，执行时间为59ms（每次执行会有差异，不同的机器也会有所差异），
第二次查询商品没有走数据库，执行时间1ms。两次查询结果一样。证明我们使用的缓存起作用了，是不是很神奇？
好到这里我们传统方式面临的耦合性太高的问题就完美的解决了。
下面我们在来看第二个问题：如果我想要缓存商品的id>50的商品怎么办？其实很简单只要将注解
@Cacheable( value = "product" , key = "#id" , condition = "#id. longValue () > 50L ”)加在getProductById的方法上即可
condition = "#id. longValue () > 50L ” 按条件缓存所加的条件。笔者就不测试该示例了，笔者会在本文的partIII部分介绍@Cacheable @CacheEvict @CachePut
的用法。


至于第三个问题（传统的缓存的存储这块写的比较死，不能灵活的切换为使用第三方的缓存模块）我们先来看下这个Spring Cache 内置的开箱即用的缓存的类图

浅谈缓存－注解驱动的缓存 Spring cache介绍_第1张图片

从上图可以看出Spring Cache对缓存存储的顶层接口为Cache，缓存管理的顶层接口为CacheManager
Cache源码：

package org.springframework.cache ;

import java.util.concurrent.Callable ;

/**
* 定义缓存通用操作的接口
*
* @author Costin Leau
* @author Juergen Hoeller
* @author Stephane Nicoll
* @since 3.1
*/
public interface Cache {

   /**
    * 返回缓存的名称
    */
   String getName() ;

   /**
    * 返回真实的缓存
    */
   Object getNativeCache() ;

   /**
    * 返回给定key在缓存中对应的value的包装类ValueWrapper的对象
    * 如何缓存中不存在key的键值对则返回null
    * 如果缓存中key的对应值为null，则返回一个ValueWrapper包装类的对象
    * @param key 
    * @return 
    * @see #get(Object, Class)
    */
   ValueWrapper get(Object key) ;

   /**
    * 返回缓存中key对应的value，并将其值强转为type
    * @param key 
    * @param type 
    * @return 
    * @throws  如果缓存着找到key对应的值，但是将其转化为指定的类型失败将抛出IllegalStateException
    * @since 4.0
    * @see #get(Object)
    */
   < T> T get(Object key , Class< T> type) ;

   /**
    * 如果缓存中存在key对应的value则return ，如果不存在则调用valueLoader生成一个并将其放入缓存
    * @param key
    * @return 
    * @throws  如果{ @code valueLoader} 抛出异常则将其包装成ValueRetrievalException抛出
    * @since 4.3
    */
   < T> T get(Object key , Callable< T> valueLoader) ;

   /**
    *将数据对(key,value)放入缓存（如果缓存中存在这对数据，原来的数据会被覆盖）
    * @param key 
    * @param value 
    */
   void put(Object key , Object value) ;

   /**
    * 如果缓存中不存在(key,value)映射对，则将其放入缓存
    * 其等效于下面这段代码
    * Object existingValue = cache.get(key);
    * if (existingValue == null) {
    *     cache.put(key, value);
    *     return null;
    * } else {
    *     return existingValue;
    * }
    *
    * @param key the key with which the specified value is to be associated
    * @param value the value to be associated with the specified key
    * @return 
    * @since 4.1
    */
   ValueWrapper putIfAbsent(Object key , Object value) ;

   /**
    * 如果缓存中存在key的映射存在则将其清除
    * @param key 
    */
   void evict(Object key) ;

   /**
    * 清空缓存
    */
   void clear() ;


   /**
    * 包装cache value的接口
    */
   interface ValueWrapper {

      /**
       * 返回缓存中的真实value值
       */
      Object get() ;
   }


   /**
    *用来包装 {@link #get(Object, Callable)}方法抛出的Exception异常
    * @since 4.3
    */
   @SuppressWarnings( "serial")
   class ValueRetrievalException extends RuntimeException {

      private final Object key ;

      public ValueRetrievalException(Object key , Callable loader , Throwable ex) {
         super(String. format( "Value for key '%s' could not be loaded using '%s'" , key , loader) , ex) ;
         this. key = key ;
      }

      public Object getKey() {
         return this. key ;
      }
   }

}

CacheManager源码：

package org.springframework.cache ;

import java.util.Collection ;

/**
* Spring的核心缓存管理SPI(Service Provider Interface 服务提供接口).
*允许检索指定名称缓存区域
* @author Costin Leau
* @since 3.1
*/
public interface CacheManager {

   /**
    * 返回指定名称的缓存
    * @param name 缓存名称，不能为null
    * @return 没有找到返回null
    */
   Cache getCache(String name) ;

   /**
    * 返回管理器知道的缓存的名称的集合
    * @return 
    */
   Collection getCacheNames() ;

}

在回过头来看切换到第三方缓存的问题，只要第三方缓存实现CacheManager接口就行了。好，现在我们就来引入redis

1.首先引入redis访问依赖,在pom.xml加入
   org.springframework.boot
   spring-boot-starter-redis
   1.3.5.RELEASE
2.application.properties中加入redis访问配置
# Redis数据库索引（默认为0）
spring.redis.database = 0
# Redis服务器地址
spring.redis.host =127.0.0.1
# Redis服务器连接端口
spring.redis.port = 6379
# Redis服务器连接密码（默认为空）
spring.redis.password = ******
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-idle = 8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait = -1
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle = 0
# 连接超时时间（毫秒）
spring.redis.timeout = 0

3.加入redisConfig
package com.snow.cache.spring.config.redis ;

import com.fasterxml.jackson.annotation.JsonAutoDetect ;
import com.fasterxml.jackson.annotation.PropertyAccessor ;
import com.fasterxml.jackson.databind.ObjectMapper ;
import org.springframework.cache.CacheManager ;
import org.springframework.cache.annotation.CachingConfigurerSupport ;
import org.springframework.cache.annotation.EnableCaching ;
import org.springframework.cache.interceptor.KeyGenerator ;
import org.springframework.context.annotation.Bean ;
import org.springframework.context.annotation.Configuration ;
import org.springframework.data.redis.cache.RedisCacheManager ;
import org.springframework.data.redis.connection.RedisConnectionFactory ;
import org.springframework.data.redis.core.RedisTemplate ;
import org.springframework.data.redis.core.StringRedisTemplate ;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer ;

import java.lang.reflect.Method ;

/**
* @author snowwolf-louis
* @date 18/4/2
*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @SuppressWarnings( "rawtypes")
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager rcm = new RedisCacheManager(redisTemplate) ;
        //设置缓存过期时间100s
        //rcm.setDefaultExpiration(100L);
        return rcm ;
    }

    @Bean
    public RedisTemplate, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory) ;
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object. class) ;
        ObjectMapper om = new ObjectMapper() ;
        om.setVisibility(PropertyAccessor. ALL , JsonAutoDetect.Visibility. ANY) ;
        om.enableDefaultTyping(ObjectMapper.DefaultTyping. NON_FINAL) ;
        jackson2JsonRedisSerializer.setObjectMapper(om) ;
        template.setValueSerializer(jackson2JsonRedisSerializer) ;
        template.afterPropertiesSet() ;
        return template ;
    }
}

4.编写一个测试类RedisCacheTests
package com.snow.cache.spring ;

import com.snow.cache.Product ;
import com.snow.cache.spring.config.ConcurrentMapCacheConfig ;
import com.snow.cache.spring.config.redis.RedisConfig ;
import com.snow.cache.spring.service.ProductService ;
import com.snow.cache.spring.service.ProductServiceImpl ;
import org.junit.Test ;
import org.junit.runner.RunWith ;
import org.springframework.beans.factory.annotation.Autowired ;
import org.springframework.boot.test.context.SpringBootTest ;
import org.springframework.test.context.junit4.SpringRunner ;

@RunWith(SpringRunner. class)
@SpringBootTest( classes = {RedisConfig. class,
      Product. class, ProductServiceImpl. class})
public class redisCacheTests {

   @Autowired
   private ProductService productService ;

   @Test
   public void getProductByIdTest(){
      long start1 = System. currentTimeMillis() ;
      System. out.println( "第一次查询商品...") ;
      Product product1 = productService.getProductById( 1L) ;
      long end1 = System. currentTimeMillis() ;
      System. out.println( "第一次查询所需时间:" + (end1 - start1) + "ms") ;
      System. out.println( "第一次查询的商品信息为:" + product1) ;


      long start2 = System. currentTimeMillis() ;
      System. out.println( "第二次查询商品...") ;
      Product product2 = productService.getProductById( 1L) ;
      long end2 = System. currentTimeMillis() ;
      System. out.println( "第二次查询所需时间:" + (end2 - start2) + "ms") ;
      System. out.println( "第二次查询的商品信息为:" + product2) ;

   }

}

执行结果如下

第一次查询商品...
从数据库中查询商品信息
第一次查询所需时间:69ms
第一次查询的商品信息为:Product{id=1, name='iphone 11', desc='iphone 11,smartisan R1'}
第二次查询商品...
第二次查询所需时间:1ms
第二次查询的商品信息为:Product{id=1, name='iphone 11', desc='iphone 11,smartisan R1'}

至此我们传统缓存的使用方法面临的三个问题已经完美解决了。爱思考的同学这时候肯定会问为
为什么在需要缓存结果的方法加上@Cacheable注解就可以完成对结果的缓存了？

下面我们就来看看Spring Cache的基本原理:
和 spring 的事务管理类似，spring cache 的关键原理就是 spring AOP，通过 spring AOP，其实现了在方法调用前、调用后获取方法的入参和返回值，进而实现了缓存的逻辑。我们来看一下下面这个图：
图 2. 原始方法调用图
浅谈缓存－注解驱动的缓存 Spring cache介绍_第2张图片
上图显示，当客户端“Calling code”调用一个普通类 Plain Object 的 foo() 方法的时候，是直接作用在 pojo 类自身对象上的，客户端拥有的是被调用者的直接的引用。
而 Spring cache 利用了 Spring AOP 的动态代理技术，即当客户端尝试调用 pojo 的 foo（）方法的时候，给他的不是 pojo 自身的引用，而是一个动态生成的代理类
图 3. 动态代理调用图
浅谈缓存－注解驱动的缓存 Spring cache介绍_第3张图片
如上图所示，这个时候，实际客户端拥有的是一个代理的引用，那么在调用 foo() 方法的时候，会首先调用 proxy 的 foo() 方法，这个时候 proxy 可以整体控制实际的 pojo.foo() 方法的入参和返回值，比如缓存结果，比如直接略过执行实际的 foo() 方法等，都是可以轻松做到的。

下面我们再来看看源码到底事怎么实现的
1.首先看我们的配置类ConcurrentMapCacheConfig上有一个注解@EnableCaching,先来看看这个注解的源码

package org.springframework.cache.annotation ;

import java.lang.annotation.Documented ;
import java.lang.annotation.ElementType ;
import java.lang.annotation.Retention ;
import java.lang.annotation.RetentionPolicy ;
import java.lang.annotation.Target ;

import org.springframework.context.annotation. AdviceMode ;
import org.springframework.context.annotation.Import ;
import org.springframework.core.Ordered ;

/**
* 该注解的作用是开启Spring 的注解驱动的缓存管理能力，类似于在 XML中配置*>
* 示例代码如下:
*
*
* @ Configuration
* @ EnableCaching
* public class AppConfig {
*
*     @ Bean
*     public MyService myService() {
*         // configure and return a class having @ Cacheable methods
*         return new MyService();
*     }
*
*     @ Bean
*     public CacheManager cacheManager() {
*         // configure and return an implementation of Spring's CacheManager SPI
*         SimpleCacheManager cacheManager = new SimpleCacheManager();
*         cacheManager.setCaches(Arrays.asList(new ConcurrentMapCache("default")));
*         return cacheManager;
*     }
* }
*
*

For reference, the example above can be compared to the following Spring XML

* configuration:
*
*
* { @code
*
*
*    
*
*    
*
*    
*        
*            
*                
*                    
*                
*            
*        
*    
*
*
* }
*
* In both of the scenarios above, { @code @EnableCaching} and { @code
* } are responsible for registering the necessary Spring
* components that power annotation-driven cache management, such as the
* { @link org.springframework.cache.interceptor.CacheInterceptor CacheInterceptor} and the
* proxy- or AspectJ-based advice that weaves the interceptor into the call stack when
* { @link org.springframework.cache.annotation.Cacheable @Cacheable} methods are invoked.
*
*

If the JSR-107 API and Spring's JCache implementation are present, the necessary

* components to manage standard cache annotations are also registered. This creates the
* proxy- or AspectJ-based advice that weaves the interceptor into the call stack when
* methods annotated with { @code CacheResult}, { @code CachePut}, { @code CacheRemove} or
* { @code CacheRemoveAll} are invoked.
*
*

A bean of type { @link org.springframework.cache.CacheManager CacheManager}

* must be registered , as there is no reasonable default that the framework can
* use as a convention. And whereas the { @code } element assumes
* a bean named "cacheManager", { @code @EnableCaching} searches for a cache
* manager bean by type . Therefore, naming of the cache manager bean method is
* not significant.
*
* @EnableCaching是根据类型来确定使用哪个cache manager 的，
*如果希望指定使用某个cache manager 让@EnableCaching所在的配置文件实现CachingConfigurer接口就行，代码如下
*
* @ Configuration
* @ EnableCaching
* public class AppConfig extends CachingConfigurerSupport {
*
*     @ Bean
*     public MyService myService() {
*         // configure and return a class having @ Cacheable methods
*         return new MyService();
*     }
*
*     @ Bean
*     @ Override
*     public CacheManager cacheManager() {
*         // configure and return an implementation of Spring's CacheManager SPI
*         SimpleCacheManager cacheManager = new SimpleCacheManager();
*         cacheManager.setCaches(Arrays.asList(new ConcurrentMapCache("default")));
*         return cacheManager;
*     }
*
*     @ Bean
*     @ Override
*     public KeyGenerator keyGenerator() {
*         // configure and return an implementation of Spring's KeyGenerator SPI
*         return new MyKeyGenerator();
*     }
* }
*
* This approach may be desirable simply because it is more explicit, or it may be
* necessary in order to distinguish between two { @code CacheManager} beans present in the
* same container.
*
*

Notice also the { @code keyGenerator} method in the example above. This allows for

* customizing the strategy for cache key generation, per Spring's { @link
* org.springframework.cache.interceptor.KeyGenerator KeyGenerator} SPI. Normally,
* { @code @EnableCaching} will configure Spring's
* { @link org.springframework.cache.interceptor.SimpleKeyGenerator SimpleKeyGenerator}
* for this purpose, but when implementing { @code CachingConfigurer}, a key generator
* must be provided explicitly. Return { @code null} or { @code new SimpleKeyGenerator()}
* from this method if no customization is necessary.
*
*

{ @link CachingConfigurer} offers additional customization options: it is recommended

* to extend from { @link org.springframework.cache.annotation.CachingConfigurerSupport
* CachingConfigurerSupport} that provides a default implementation for all methods which
* can be useful if you do not need to customize everything. See { @link CachingConfigurer}
* Javadoc for further details.
*
*

The { @link #mode} attribute controls how advice is applied: If the mode is

* { @link AdviceMode #PROXY} (the default), then the other attributes control the behavior
* of the proxying. Please note that proxy mode allows for interception of calls through
* the proxy only; local calls within the same class cannot get intercepted that way.
*
*

Note that if the { @linkplain #mode} is set to { @link AdviceMode #ASPECTJ}, then the

* value of the { @link #proxyTargetClass} attribute will be ignored. Note also that in
* this case the { @code spring-aspects} module JAR must be present on the classpath, with
* compile-time weaving or load-time weaving applying the aspect to the affected classes.
* There is no proxy involved in such a scenario; local calls will be intercepted as well.
*
* @author Chris Beams
* @author Juergen Hoeller
* @since 3.1
* @see CachingConfigurer
* @see CachingConfigurationSelector
* @see ProxyCachingConfiguration
* @see org.springframework.cache.aspectj.AspectJCachingConfiguration
*/
@Target(ElementType. TYPE)
@Retention(RetentionPolicy. RUNTIME)
@Documented
@Import(CachingConfigurationSelector. class)
public @ interface EnableCaching {

   /**
    *  确定是实用CGLIB的动态代理还是jdk的动态代理，默认为jdk的动态代理；只有在mode设为 AdviceMode . PROXY时 有效
    * 注意：设置为true会影响spring的所有动态代理实现而不仅仅是@Cacheable注解作用的对象。
    */
   boolean proxyTargetClass() default false;

   /**
    * 确定何种类型的增强被使用
    * AdviceMode #PROXY} 或者 AdviceMode#ASPECTJ
    * AdviceMode#PROXY}类型的增强，本地方法的调用缓存是不会生效的，必须是代理类中调用才生效
    */
   AdviceMode mode() default AdviceMode. PROXY ;

   /**
    *当有多个advice作用在同一个连接点时，确定caching advisor 的顺序
    */
   int order() default Ordered. LOWEST_PRECEDENCE ;

}

@EnableCaching开启spring的注解驱动的缓存能力，当mode设置为 AdviceMode #PROXY} 时，CachingConfigurationSelector
会选择使用 ProxyCachingConfiguration 的配置，其会将CacheInterceptor编入cache 的 advisor。

浅谈缓存－注解驱动的缓存 Spring cache介绍_第4张图片

当我们的测试代码 productService.getProductById( 1L)执行时会调用编入的CacheInterceptor的invoke()方法
浅谈缓存－注解驱动的缓存 Spring cache介绍_第5张图片
最终执行的是其父类CacheAspectSupport中的execute()方法
private Object execute( final CacheOperationInvoker invoker , Method method , CacheOperationContexts contexts) {
   // Special handling of synchronized invocation
   if (contexts.isSynchronized()) {
      CacheOperationContext context = contexts.get(CacheableOperation. class).iterator().next() ;
      if (isConditionPassing(context , CacheOperationExpressionEvaluator. NO_RESULT)) {
         Object key = generateKey(context , CacheOperationExpressionEvaluator. NO_RESULT) ;
         Cache cache = context.getCaches().iterator().next() ;
         try {
            return wrapCacheValue(method , cache.get(key , new Callable() {
               @Override
               public Object call() throws Exception {
                  return unwrapReturnValue(invokeOperation( invoker)) ;
               }
            })) ;
         }
         catch (Cache.ValueRetrievalException ex) {
            // The invoker wraps any Throwable in a ThrowableWrapper instance so we
            // can just make sure that one bubbles up the stack.
            throw (CacheOperationInvoker.ThrowableWrapper) ex.getCause() ;
         }
      }
      else {
         // No caching required, only call the underlying method
         return invokeOperation(invoker) ;
      }
   }


   // Process any early evictions
   processCacheEvicts(contexts.get(CacheEvictOperation. class) , true,
         CacheOperationExpressionEvaluator. NO_RESULT) ;

   // 查询缓存有没有满足条件的结果
   Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class));

   // Collect puts from any @Cacheable miss, if no cached item is found
   List cachePutRequests = new LinkedList() ;
   if (cacheHit == null) {
      collectPutRequests(contexts.get(CacheableOperation. class) ,
            CacheOperationExpressionEvaluator. NO_RESULT , cachePutRequests) ;
   }

   Object cacheValue ;
   Object returnValue ;

    //缓存命中
   if (cacheHit != null && cachePutRequests.isEmpty() && !hasCachePut(contexts)) {
      // If there are no put requests, just use the cache hit
      cacheValue = cacheHit.get() ;
      returnValue = wrapCacheValue(method , cacheValue) ;
   }
   else { //缓存没有命中调用原始方法获取结果
      // Invoke the method if we don't have a cache hit
      returnValue = invokeOperation(invoker) ;
      cacheValue = unwrapReturnValue(returnValue) ;
   }

   // Collect any explicit @CachePuts
   collectPutRequests(contexts.get(CachePutOperation. class) , cacheValue , cachePutRequests) ;

   //有@CachePut注解时 或者有 @Cacheable 注解且命中失败时，得到的结果存入缓存
   for (CachePutRequest cachePutRequest : cachePutRequests) {
      cachePutRequest.apply(cacheValue) ;
   }

   // Process any late evictions
   processCacheEvicts(contexts.get(CacheEvictOperation. class) , false, cacheValue) ;

   return returnValue ;
}

好到这里，Spring Cache的原理大致讲完了。下面来讲两个注意点和一个小技巧
注意点1.如果将@EnableCaching中mode设为AdviceMode. PROXY即默认，也即采用基于Proxy的Spring AOP回带来内部调用增强失效的问题。即在被增强的内中通过this调用被@Cacheable @CacheEvict @CachePut标记的方法缓存失效。解决方法当然是采用Apectj的AOP机制。
注意点2. 和内部调用问题类似，非 public 方法如果想实现基于注释的缓存，必须采用基于 AspectJ 的 AOP 机制，这里限于篇幅不再细述。
小技巧.本地调试的时常常遇到缓存环境没布置好如项目中使用redis作为缓存，本地却没有redis环境，我们又急着调试代码，这时又不太建议注掉缓存的代码，怎么办？其实对于这个问题，Spring Cache已经为我们想好了，其给我们提供了一个 CompositeCacheManager ，这是一个组合的cacheManager 它允许我们配置一个CacheManger集合，集合中的最后一个元素可以配置成 NoOpCacheManager （没有任何操作的缓存管理器）,当其他缓存管理器都不起作用时，会使用这个作为缓存实现。
 

partIII.@Cacheable @CacheEvict @CachePut的使用

1).@Cacheable、@CachePut、@CacheEvict 注释介绍

通过上面的源码，我们可以看到 spring cache 主要使用两个注释标签，即 @Cacheable、@CachePut 和 @CacheEvict，我们总结一下其作用和配置方法。
表 1. @Cacheable 作用和配置方法
@Cacheable 的作用 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存
@Cacheable 主要的参数
value 缓存的名称，在 spring 配置文件中定义，必须指定至少一个
例如：

@Cacheable(value=”mycache”) 或者 

@Cacheable(value={”cache1”,”cache2”}
key 缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合
例如：

@Cacheable(value=”testcache”,key=”#userName”)
condition 缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存
例如：

@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
表 2. @CachePut 作用和配置方法
@CachePut 的作用 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存，和 @Cacheable 不同的是，它每次都会触发真实方法的调用
@CachePut 主要的参数
value 缓存的名称，在 spring 配置文件中定义，必须指定至少一个
例如：

@Cacheable(value=”mycache”) 或者 

@Cacheable(value={”cache1”,”cache2”}
key 缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合
例如：

@Cacheable(value=”testcache”,key=”#userName”)
condition 缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存
例如：

@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
表 3. @CacheEvict 作用和配置方法
@CachEvict 的作用 主要针对方法配置，能够根据一定的条件对缓存进行清空
@CacheEvict 主要的参数
value 缓存的名称，在 spring 配置文件中定义，必须指定至少一个
例如：

@CachEvict(value=”mycache”) 或者 

@CachEvict(value={”cache1”,”cache2”}
key 缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合
例如：

@CachEvict(value=”testcache”,key=”#userName”)
condition 缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才清空缓存
例如：

@CachEvict(value=”testcache”,

condition=”#userName.length()>2”)
allEntries 是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存
例如：

@CachEvict(value=”testcache”,allEntries=true)
beforeInvocation 是否在方法执行前就清空，缺省为 false，如果指定为 true，则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法执行抛出异常，则不会清空缓存
例如：

@CachEvict(value=”testcache”，beforeInvocation=true)
2)本文配套代码中有个对图书增删改查的使用缓存的例子，大家可以自行下载查看


本文代码示例： https://gitee.com/goodIsNotEnough/snow-cache


我可以接受失败，但不可以接受放弃！ 

你可能感兴趣的:(Spring)

  • springboot开启异步注解功能 白不懂黑的静 spingboot
    主要记录内容：在springboot中如何开启异步注解功能，异步注解功能开启后，可以让在调用异步功能时，系统可以自动接着往下走，而不用一直在等待异步功能完成才可以接着走下一步任务。前提：内容时基于springboot实现的。一、service层代码：在service中定义了一个测试异步的代码：在方法上增加@Async注解packagecom.demo.service;importorg.sprin
  • springcloud nacos 负载均衡 权重 牛马狗猪猴 springbootspringcloud负载均衡java
    springcloudnacos负载均衡权重项目搭建代码在这里https://blog.csdn.net/weixin_45730866/article/details/128930496?spm=1001.2014.3001.5502假设我们consumer-order要调用consumer-user（这个服务启动了两个)；不知道怎么在idea启动两个相同的服务可以看看下面这个https://b
  • springboot 配置redis Leaf吧 springbootspringbootredis后端
    环境配置springboot3.4redis5.0.14redis准备参考下面文章window下安装redis以及启动redis客户端安装引入依赖org.springframework.bootspring-boot-starter-data-redis该依赖默认引入Lettuce作为默认客户端从SpringBoot2.x版本开始，Redis的默认客户端是Lettuce。如果你没有特别指定客户端，
  • SpringBoot如何开启异步编程 肥肥技术宅 javaspringbootjavaspring
    一、什么是异步？现在我们假设有一个接口方法，里面又调用了三个子方法，分别是A，B，C。先从A执行，执行完毕再执行B，B执行完最后执行C。这也是我们代码最常见的执行方式。ABC顺序执行，其中一个出问题了，如果抛出了异常，后续则不再执行。这中方式就是同步执行。那么异步执行是什么样子的呢？假设B方法改为异步，那么A方法执行完毕，执行B方法。此时不需要等B方法执行完毕，代码会直接执行C方法。也就是B方法不
  • 基于springboot在线考试系统 2201_75927219 计算机毕业设计springboot后端java
    基于SpringBoot的在线考试系统是一种现代化的教育考试解决方案，它结合了SpringBoot框架的高效性和在线考试的便捷性，为教育机构、教师和学生提供了一个功能强大、易于使用的在线考试平台。一、系统背景与意义随着教育数字化的推进和在线学习需求的增长，传统的纸质考试方式已经逐渐显示出局限性，特别是在灵活性和可访问性方面。在线考试系统的开发正是响应这一趋势，它允许教育机构在任何时间、任何地点进行
  • 企业级应用框架guns架构与开发实践 福建低调
    本文还有配套的精品资源，点击获取简介：在IT领域，企业架构是组织信息和技术集成设计的关键。"guns"项目提供了一套高效、灵活且可扩展的企业管理架构设计框架。本文深入探讨guns项目的核心特性、应用场景和开发实践，以及如何使用不同的集成开发环境（IDE）进行项目开发。guns基于SpringBoot框架，集成MyBatis和Shiro，简化了微服务开发和权限控制，确保了数据安全。文章还详细介绍了g
  • Spring注解09——BeanPostProcessor后置处理器深度剖析 大黄奔跑 Spring注解驱动
    该系列文章主要学习雷丰阳老师的《Spring注解驱动》课程总结。原课程地址：课程地址包括了自己阅读其他书籍《Spring揭秘》《SpringBoot实战》等课程。该系列文档会不断的完善，欢迎大家留言及提意见。文章目录1.写在之前2.BeanPostProcessor是什么3.xxxBeanPostProcessor源码分析4.Spring框架用该接口干嘛呢？总结1.写在之前本篇会有一些源码的分析，
  • 【Nginx系列】Nginx配置超时时间 m0_74824552 面试学习路线阿里巴巴nginx运维
    ???欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,G
  • 简单的springboot使用sse功能 smile_life_ springboot后端java
    什么是sse?1、SSE是Server-SentEvents（服务器发送事件）2、SSE是一种允许服务器主动向客户端推送实时更新的技术。3、它基于HTTP协议，并使用了其长连接特性，在客户端与服务器之间建立一条持久化的连接。通过这条连接，服务器可以实时地向客户端发送事件流，而客户端可以监听这些事件并作出相应的处理。4、SSE是单向通信机制，即只能由服务器向客户端推送数据，客户端不能通过SSE向服务
  • Tomcat调优相关理解 smile_life_ javatomcattomcat调优
    什么是QPS？是QueriesPerSecond的缩写，是指服务器每秒查询数，比如定义一个a接口，该接口是10QPS，那么就是指该接口每秒可以处理10个请求springboot默认并发处理数是多少？springboot并发处理要看servlet容器，而servlet容器默认是Tomcat，而Tomcat容器可以处理的并发请求数主要受到最大线程数（max-threads）的限制，Tomcat的默认最
  • 关于Jedis和lettuce以及springDataRedis的一些区别 追光的人（陈聪） 第三阶段redis相关redisjedisjava
    1：三者其实都是用来操作redis的2：springDataRedis是对Jedis和lettuce的一系列封装，简化了很多方法3：公司里面之所以不怎么用Jedis也是因为其指令比较繁琐难以记忆，不如就用简化了的springDataRedis4:使用springDataRedis时，首先要导入springDataRedis的依赖，然后导入Jedis或者lettuce，如果是Jedis，需要再导入s
  • JAVA开发 在 Spring Boot 中集成 Swagger 天之涯上上 javaspringboot开发语言
    Swagger是一个广泛使用的API文档生成工具，可以帮助你自动生成和维护RESTfulAPI的文档。在不同的框架中集成Swagger通常需要添加相应的依赖项。以下是几种常见Java框架（如SpringBoot）中集成Swagger的依赖配置。在SpringBoot中集成SwaggerSpringBoot结合Swagger可以通过springfox-swagger2和springfox-swagg
  • 微服务中常用注解 陈鹏的博客 分布式微服务java后端
    1.@Component（spring注解）用来标注将普通类交给Spring管理。交给Spring管理就是注册到spring容器中，让spring帮你创建对象。可以通过spring容器获得该对象。相当于springxml配置文件中的bean标签2.@Repository（spring注解）用来标注将mapper层接口的实现类交给Spring管理。@Component的衍生注解，用于标注mapper
  • 使用IDEA创建一个SpringBoot项目 web13293720476 面试学习路线阿里巴巴springbootintellij-ideajava服务器linux
    文章目录一、SpringBoot是什么？二、使用idea创建SpringBoot项目1.使用idea的SpringInitiallizr创建项目2.初步配置3.编写简单代码及运行4.两个好玩的小东西总结一、SpringBoot是什么？Spring框架是Java平台上的一种开源应用框架，提供具有控制反转特性的容器。SpringBoot基于Spring4.0设计，不仅继承了Spring框架原有的优秀特
  • 【wiki知识库】05.分类管理模块--后端SpringBoot模块 熊哈哈O_o 从0到1带你搭建wiki知识库springboot后端javaspring
    个人主页：哈__期待您的关注目录一、今日目标二、☀SpringBoot代码修改1.使用逆向工程生成Category表结构2.新增CategoryQueryParam3.新增CategorySaveParam4.新增CategotyQueryVo三、新增分类管理的相关接口1./category/all2./category/save3./category/delete1.我们删除的是一个二级分类2.
  • Springboot启动原理 长乐_ 知识杂记springbootjavaspring
    Springboot启动原理一、开始启动一个springboot项目，最简单的就是配置一个springboot启动类，然后运行即可@SpringBootApplicationpublicclassSpringBoot{publicstaticvoidmain(String[]args){SpringApplication.run(SpringBoot.class,args);}}二、@Spring
  • JavaEE进阶知识学习----SpringBoot高级（五）SpringBoot与消息 四川码匠 SpringBoot
    SpringBoot与消息概述在大多数应用中，可以通过消息服务来提升系统异步通信，扩展解耦能力。在消息服务中存在两个重要的概念：消息代理（messagebroker）和目的地（destination），当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地消息队列主要有两种形式的目的地：队列（queue:点对点消息通信），主题（topic:发布/订阅消息通信）点对点式消息发送
  • Spring config location file not found exception qq361301276 MavenMaven
    1downvotefavorite1Inmywebappi'mtryingtousespringsecurity.Ihavethefollowingprojectstructure:Inmyweb.xmlisettheconfigLocationslikethis:AndinmyHibernateUtil,icreatetheClassPathXmlApplicationContextliketh
  • Spring Boot 启动原理 Java大联盟 SpringCloud极简入门
    SpringBoot自动配置原理通过上节课的学习，大家已经掌握了SpringBoot框架的基本使用，你会发现使用SpringBoot进行项目开发真的是非常简单，可以极大地提升开发效率。这是因为SpringBoot框架已经预先帮助开发者完成了各种自动配置，使得开发者可以将精力全部集中在业务代码的开发中，而非配置文件。SpringBoot最核心的功能简单概括就是四个字：自动配置，那么SpringBoo
  • Spring Boot + Jasypt 实现application.yml 属性加密的快速示例 oscar999 SpringBoot实战开发大全springbootjava属性加密
    Jasypt（JavaSimplifiedEncryption）是一个专为Java应用程序设计的开源加密库，旨在简化加密和解密流程，保护敏感数据如密码、API密钥等。jasypt-spring-boot-starter允许开发者在SpringBoot应用中轻松地实现加密和解密功能。本篇介绍使用jasypt-spring-boot-starter以达成在application.yml等配置文件中使用
  • 引入正确依赖但还是爆红 笑发财了1 springbootjavamavenspringmybatis
    springboot项目，maven工程。这个问题是我在成功运行这个项目后出现的，再次打开的时候居然又爆红了。尝试了clean和重编译也没用，于是尝试重新加载，就好了
  • springboot 启动原理 chikoucha6215 javaruntime测试
    我们开发任何一个SpringBoot项目，都会用到如下的启动类@SpringBootApplicationpublicclassApplication{publicstaticvoidmain(String[]args){SpringApplication.run(Application.class,args);}}从上面代码可以看出，Annotation定义（@SpringBootApplica
  • 打包springcloud微服务时，终端执行java -jar报错，没有主清单属性 ZL_do_it jarjavamaven
    打包springcloud微服务时，终端执行java-jar报错，没有主清单属性使用SpringBoot微服务搭建框架，在eclipse和Idea下能正常运行，但是在打成jar包部署或者直接使用java-jar命令的时候，提示了xxxxxx.jar中没有主清单属性：C:\Users\zl\.m2\repository\com\kkb\eureka-server\1.0-SNAPSHOT>java-
  • 【微服务33】分布式事务Seata源码解析一：在IDEA中启动Seata Server 秃秃爱健身 #分布式事务Seata入门到精通微服务分布式intellij-idea
    文章目录一、前言二、IDEA中运行SeataServer1、把源码从Github中荡下来坑：一定要从mavenmodules中移除序列化的包SeataServer使用到的DB2、调整seata-server的配置seata-server3、运行seata-server三、总结和后续一、前言至此，博主介绍了一些Seata环境搭建的常见坑、Seata的两种案例（SpringCloud集成Seata、S
  • 【SpringBoot】SpringBoot：实现文件上传和下载功能 E绵绵 Everythingspringboot后端java
    文章目录引言项目初始化添加依赖配置文件存储位置实现文件上传功能创建文件上传控制器创建上传页面实现文件下载功能创建文件下载控制器安全性和最佳实践文件大小限制文件类型验证文件名和路径验证文件下载时的安全性测试与部署示例：编写单元测试部署结论引言文件上传和下载是Web应用程序中常见的需求。在现代应用中，用户需要上传各种类型的文件，如图片、文档、视频等，或者下载生成的报告和数据文件。SpringBoot通
  • 【SpringBoot 框架】- SpringBoot 配置文件 2401_84408404 程序员springbootjavaspring
    【SpringBoot框架】-入门——环境搭建、工程热部署、idea快捷创建SpringBoot项目【SpringBoot框架】-SpringBoot原理分析【SpringBoot框架】-SpringBoot配置文件【SpringBoot框架】-SpringBoot整合Mybatis、Junit、Redis目录一、SpringBoot配置文件类型1.application.properties配置
  • springboot接入deepseek深度求索 java 笑发财了1 javaspringboot服务器
    以下是在springboot中接入aideepseek的过程。官网并没有java的示例。1.创建APIkeydeepseekAPIkeys点击创建APIkey，把创建的key值复制下来，以后就不能再查看了，只能重新创建。2.封装询问deepseek的工具方法添加key值和询问路径。API_KEY为你创建的key值。privatestaticfinalStringAPI_URL="https://a
  • SpringBoot配置文件高级用法实战 码到三十五 Spring全家桶springboot人工智能机器学习AIGC
    ❃博主首页：「码到三十五」，同名公众号:「码到三十五」，wx号:「liwu0213」☠博主专栏：♝博主的话：搬的每块砖，皆为峰峦之基；公众号搜索「码到三十五」关注这个爱发技术干货的coder，一起筑基SpringBoot配置文件的优先级是一个重要的概念，它决定了当存在多个配置文件时，哪个配置文件中的配置将被优先采用。文章目录一、总体优先级顺序二、应用配置文件的详细优先级三、文件类型优先级四、特定环
  • Spring Clound + Spring Clound Alibaba 全家桶 更容易记住我 SpringCloundjavaspringcloudalibaba
    官方网站：https://spring.io/projects/spring-cloud/一、服务注册中心Eureka服务注册中心EurekaZookeeperZookeeperConsul服务注册中心ConsulNacos（推荐）服务注册中心Nacos二、服务调用1Ribbon+LoadBalancer服务调用Ribbon三、服务调用2OpenFegin服务调用OpenFeign四、服务降级Hy
  • Java程序设计（二十四）：基于SSM框架的基于的快递代取系统的设计与实现 人工智能_SYBH 2025年java程序设计javapython开发语言springbootspring后端
    引言随着电子商务的发展，越来越多的高校学生通过网购获取日常所需物品，快递服务也逐渐成为大学生活中不可或缺的一部分。然而，繁忙的学习与生活让部分学生无法及时领取自己的快递，因此基于高校校园的快递代取服务应运而生。本文将详细介绍如何基于SSM（Spring、SpringMVC、MyBatis）技术栈设计并实现一个高校快递代取系统，解决高校学生快递代取问题。通过该系统，管理员、代取人和发布者三类用户可以
  • 集合框架 天子之骄 java数据结构集合框架
       集合框架 集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。   简单介绍：   Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
  • Table Driven（表驱动）方法实例 bijian1013 javaenumTable Driven表驱动
    实例一： /** * 驾驶人年龄段 * 保险行业，会对驾驶人的年龄做年龄段的区分判断 * 驾驶人年龄段：01-[18,25);02-[25,30);03-[30-35);04-[35,40);05-[40,45);06-[45,50);07-[50-55);08-[55,+∞) */ public class AgePeriodTest { //if...el
  • Jquery 总结 cuishikuan javajqueryAjaxWebjquery方法
    1.$.trim方法用于移除字符串头部和尾部多余的空格。如：$.trim('   Hello   ') // Hello2.$.contains方法返回一个布尔值，表示某个DOM元素（第二个参数）是否为另一个DOM元素（第一个参数）的下级元素。如：$.contains(document.documentElement, document.body); 3.$
  • 面向对象概念的提出 麦田的设计者 java面向对象面向过程
            面向对象中，一切都是由对象展开的，组织代码，封装数据。   在台湾面向对象被翻译为了面向物件编程，这充分说明了，这种编程强调实体。       下面就结合编程语言的发展史，聊一聊面向过程和面向对象。      c语言由贝尔实
  • linux网口绑定 被触发 linux
    刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。 一、环境描述 我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。 二、双网卡绑定步骤： 2.1 修改/etc/sysconfig/network
  • XML基础语法 肆无忌惮_ xml
    一、什么是XML？ XML全称是Extensible Markup Language，可扩展标记语言。很类似HTML。XML的目的是传输数据而非显示数据。XML的标签没有被预定义，你需要自行定义标签。XML被设计为具有自我描述性。是W3C的推荐标准。   二、为什么学习XML？ 用来解决程序间数据传输的格式问题 做配置文件 充当小型数据库   三、XML与HTM
  • 为网页添加自己喜欢的字体 知了ing 字体 秒表 css
    @font-face { font-family: miaobiao;//定义字体名字 font-style: normal; font-weight: 400; src: url('font/DS-DIGI-e.eot');//字体文件 } 使用： <label style="font-size:18px;font-famil
  • redis范围查询应用-查找IP所在城市 矮蛋蛋 redis
    原文地址： http://www.tuicool.com/articles/BrURbqV 需求 根据IP找到对应的城市 原来的解决方案 oracle表（ip_country）： 查询IP对应的城市： 1.把a.b.c.d这样格式的IP转为一个数字，例如为把210.21.224.34转为3524648994 2. select city from ip_
  • 输入两个整数， 计算百分比 alleni123 java
    public static String getPercent(int x, int total){ double result=(x*1.0)/(total*1.0); System.out.println(result); DecimalFormat df1=new DecimalFormat("0.0000%");
  • 百合——————>怎么学习计算机语言 百合不是茶 java 移动开发
        对于一个从没有接触过计算机语言的人来说，一上来就学面向对象，就算是心里上面接受的了，灵魂我觉得也应该是跟不上的，学不好是很正常的现象，计算机语言老师讲的再多，你在课堂上面跟着老师听的再多，我觉得你应该还是学不会的，最主要的原因是你根本没有想过该怎么来学习计算机编程语言，记得大一的时候金山网络公司在湖大招聘我们学校一个才来大学几天的被金山网络录取，一个刚到大学的就能够去和
  • linux下tomcat开机自启动 bijian1013 tomcat
    方法一： 修改Tomcat/bin/startup.sh 为: export JAVA_HOME=/home/java1.6.0_27 export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:. export PATH=$JAVA_HOME/bin:$PATH export CATALINA_H
  • spring aop实例 bijian1013 javaspringAOP
    1.AdviceMethods.java package com.bijian.study.spring.aop.schema; public class AdviceMethods { public void preGreeting() { System.out.println("--how are you!--"); } } 2.beans.x
  • [Gson八]GsonBuilder序列化和反序列化选项enableComplexMapKeySerialization bit1129 serialization
    enableComplexMapKeySerialization配置项的含义  Gson在序列化Map时，默认情况下，是调用Key的toString方法得到它的JSON字符串的Key，对于简单类型和字符串类型，这没有问题，但是对于复杂数据对象，如果对象没有覆写toString方法，那么默认的toString方法将得到这个对象的Hash地址。   GsonBuilder用于
  • 【Spark九十一】Spark Streaming整合Kafka一些值得关注的问题 bit1129 Stream
    包括Spark Streaming在内的实时计算数据可靠性指的是三种级别： 1. At most once，数据最多只能接受一次，有可能接收不到 2. At least once, 数据至少接受一次，有可能重复接收 3. Exactly once  数据保证被处理并且只被处理一次，   具体的多读几遍http://spark.apache.org/docs/lates
  • shell脚本批量检测端口是否被占用脚本 ronin47
    #!/bin/bash cat ports |while read line do#nc -z -w 10 $line nc -z -w 2 $line 58422>/dev/null2>&1if[ $?-eq 0]then echo $line:ok else echo $line:fail fi done 这里的ports 既可以是文件
  • java-2.设计包含min函数的栈 bylijinnan java
    具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/ import java.util.ArrayList; import java.util.List; public class MinStack { //maybe we can use origin array rathe
  • Netty源码学习-ChannelHandler bylijinnan javanetty
    一般来说，“有状态”的ChannelHandler不应该是“共享”的，“无状态”的ChannelHandler则可“共享” 例如ObjectEncoder是“共享”的, 但 ObjectDecoder 不是 因为每一次调用decode方法时，可能数据未接收完全（incomplete）， 它与上一次decode时接收到的数据“累计”起来才有可能是完整的数据，是“有状态”的 p
  • java生成随机数 cngolon java
    方法一： /** * 生成随机数 * @author [email protected] * @return */ public synchronized static String getChargeSequenceNum(String pre){ StringBuffer sequenceNum = new StringBuffer(); Date dateTime = new D
  • POI读写海量数据 ctrain 海量数据
    import java.io.FileOutputStream; import java.io.OutputStream; import org.apache.poi.xssf.streaming.SXSSFRow; import org.apache.poi.xssf.streaming.SXSSFSheet; import org.apache.poi.xssf.streaming
  • mysql 日期格式化date_format详细使用 daizj mysqldate_format日期格式转换日期格式化
    日期转换函数的详细使用说明  DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
  • 一个程序员分享8年的开发经验 dcj3sjt126com 程序员
      在中国有很多人都认为IT行为是吃青春饭的，如果过了30岁就很难有机会再发展下去!其实现实并不是这样子的，在下从事.NET及JAVA方面的开发的也有8年的时间了，在这里在下想凭借自己的亲身经历，与大家一起探讨一下。 明确入行的目的 很多人干IT这一行都冲着“收入高”这一点的，因为只要学会一点HTML, DIV+CSS，要做一个页面开发人员并不是一件难事，而且做一个页面开发人员更容
  • android欢迎界面淡入淡出效果 dcj3sjt126com android
    很多Android应用一开始都会有一个欢迎界面，淡入淡出效果也是用得非常多的，下面来实现一下。 主要代码如下： package com.myaibang.activity; import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.os.CountDown
  • linux 复习笔记之常见压缩命令 eksliang tar解压linux系统常见压缩命令linux压缩命令tar压缩
    转载请出自出处:http://eksliang.iteye.com/blog/2109693 linux中常见压缩文件的拓展名 *.gz gzip程序压缩的文件 *.bz2 bzip程序压缩的文件 *.tar tar程序打包的数据，没有经过压缩 *.tar.gz tar程序打包后，并经过gzip程序压缩 *.tar.bz2 tar程序打包后，并经过bzip程序压缩 *.zi
  • Android 应用程序发送shell命令 gqdy365 android
    项目中需要直接在APP中通过发送shell指令来控制lcd灯，其实按理说应该是方案公司在调好lcd灯驱动之后直接通过service送接口上来给APP，APP调用就可以控制了，这是正规流程，但我们项目的方案商用的mtk方案，方案公司又没人会改，只调好了驱动，让应用程序自己实现灯的控制，这不蛋疼嘛！！！！ 发就发吧！ 一、关于shell指令： 我们知道，shell指令是Linux里面带的
  • java 无损读取文本文件 hw1287789687 读取文件无损读取读取文本文件charset
    java 如何无损读取文本文件呢？ 以下是有损的 @Deprecated public static String getFullContent(File file, String charset) { BufferedReader reader = null; if (!file.exists()) { System.out.println("getFull
  • Firebase 相关文章索引 justjavac firebase
    Awesome Firebase 最近谷歌收购Firebase的新闻又将Firebase拉入了人们的视野，于是我做了这个 github 项目。 Firebase 是一个数据同步的云服务，不同于 Dropbox 的「文件」，Firebase 同步的是「数据」，服务对象是网站开发者，帮助他们开发具有「实时」（Real-Time）特性的应用。 开发者只需引用一个 API 库文件就可以使用标准 RE
  • C++学习重点 lx.asymmetric C++笔记
    1.c++面向对象的三个特性：封装性，继承性以及多态性。   2.标识符的命名规则：由字母和下划线开头，同时由字母、数字或下划线组成；不能与系统关键字重名。   3.c++语言常量包括整型常量、浮点型常量、布尔常量、字符型常量和字符串性常量。   4.运算符按其功能开以分为六类：算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符和条件运算符。 &n
  • java bean和xml相互转换 q821424508 javabeanxmlxml和bean转换java bean和xml转换
    这几天在做微信公众号 做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题， 然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ， 还是贴出来记录一下      顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。   packag
  • C 语言初级 位运算 1140566087 位运算c
    第十章 位运算   1、位运算对象只能是整形或字符型数据，在VC6.0中int型数据占4个字节   2、位运算符： 运算符 作用 ~ 按位求反 << 左移 >> 右移 & 按位与 ^ 按位异或 | 按位或 他们的优先级从高到低；   3、位运算符的运算功能： a、按位取反： ~01001101 = 101
  • 14点睛Spring4.1-脚本编程 wiselyman spring4
    14.1 Scripting脚本编程 脚本语言和java这类静态的语言的主要区别是:脚本语言无需编译,源码直接可运行; 如果我们经常需要修改的某些代码,每一次我们至少要进行编译,打包,重新部署的操作,步骤相当麻烦; 如果我们的应用不允许重启,这在现实的情况中也是很常见的; 在spring中使用脚本编程给上述的应用场景提供了解决方案,即动态加载bean; spring支持脚本