Spring bootキャッシュの使用

18694 ワード
java スプリングブック
プロジェクトの使用では、redis、ehcache、javaメモリキャッシュ(mapなど)がよく使用されます.メモリキャッシュは記録されません.主にspring bootでehcacheとredisキャッシュをどのように使用するかを記録します.
一、ehcache
1、導入依存


    org.springframework.boot
    spring-boot-starter-cache



    net.sf.ehcache
    ehcache
    2.10.4

2、入口注記
@SpringBootApplication//(exclude = {ConfigClientAutoConfiguration.class})
@EnableCaching
public class PortalZuulApplication {
    public static void main(String[] args) {
        //          
        new SpringApplicationBuilder(PortalZuulApplication.class).web(true).run(args);
    }
}

 3、ehcacheプロファイル、ファイルはresourceの下に置く

 4、CacheManagerを注入する
@Autowired
private  CacheManager cacheManager;

 注入CacheManagerについてもEhCachecacheManagerについても、ソースコードを確認すると、EhCachecacheManagerがCacheManagerを実現していることがわかりますが、内部の方法は少し異なります.以下の内容は転載です.
Springでは、CacheManagerとCacheインタフェースが異なるキャッシュ技術を統合することを定義します.ここでCacheManagerはSpringが提供する各種キャッシュ技術の抽象インタフェースである.Cacheインタフェースには、キャッシュのさまざまな操作が含まれています.
CacheManger
異なるキャッシュ・テクノロジーに対して、異なるcacheManagerを実装する必要があります.Springは、次のようなcacheManger実装を定義します.
 
CacheManger
説明
SimpleCacheManager
簡単なCollectionを使用してキャッシュを格納し、主にテストに使用します.
ConcurrentMapCacheManager
キャッシュ・テクノロジーとしてConcurrentMapを使用する(デフォルト)
NoOpCacheManager
テスト用
EhCacheCacheManager
キャッシュ技術としてEhCacheを使用しており、以前はhibernateでよく使われていました
GuavaCacheManager
Google guavaのGuavaCacheをキャッシュ技術として使用
HazelcastCacheManager
キャッシュ・テクノロジーとしてHazelcastを使用
JCacheCacheManager
Apache Commons JCSなどのキャッシュ技術としてJCache標準の実装を用いる
RedisCacheManager
Redisをキャッシュ・テクノロジーとして使用
通常のSpringBootでは、EhCache、Collection、Guava、ConcurrentMapなどのキャッシュが自動的に構成されており、デフォルトではConcurrentMapCacheManagerが使用されます.SpringBootのアプリケーション.propertiesプロファイルは、spring.cache接頭辞のプロパティを使用して構成されます.
アプリケーション構成
1 2 3 4 5 6 spring.cache.type=# spring.cache.cache-names= spring.cache.ehcache.config=ehcache spring.cache.infinispan.config=infinispan spring.cache.jcache.config=jcache spring.cache.jcache.provider= jcache ， jcache
 5、付属工具類
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.PreDestroy;
import org.apache.log4j.Logger;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.stereotype.Component;
@Component
public class EhcacheService{
   //      
   public final Logger logger = Logger.getLogger(this.getClass());
   public static final String TOKEN_CACHE = "tokenCache";
   @Autowired
   private  CacheManager cacheManager;

   /**
    *     Cache，       。
    * @param cacheName
    * @return
    */
   private Cache getCache(String cacheName){
      Cache cache = cacheManager.getCache(cacheName);
      if (cache == null){
         cacheManager.addCache(cacheName);
         cache = cacheManager.getCache(cacheName);
         cache.getCacheConfiguration().setEternal(true);
      }
      return cache;
   }

   /**
    *     (     )
    * @param cacheName
    * @param key
    * @param value
    * @param timeToLiveSeconds
    */
   public void setCacheElement(String cacheName, String key, Object value,int timeToLiveSeconds) {
      Element element = new Element(key, value);
      element.setEternal(false);
      element.setTimeToLive(timeToLiveSeconds);
      getCache(cacheName).put(element);
   }

    /**
     *       
     * @param key
     * @param cacheName
     * @param seconds
     * @return
     */
    public long expire(String key,String cacheName, int seconds) {

        Element element = getCache(cacheName).get(key);
        element.setEternal(false);
        element.setTimeToLive(seconds);
        return 0;
    }

   /**
    *      
    * @param cacheName
    * @param key
    * @return
    */
   public Object getCacheValue(String cacheName, String key) {
      Element element = getCache(cacheName).get(key);
      if(element != null)
      {
         return element.getObjectValue();
      }
      return null;
   }
   /**
    *         
    * @param cacheName
    * @param key
    * @return
    */
   public int getCacheExpire(String cacheName, String key) {
      Element element = getCache(cacheName).get(key);
      if(element != null)
      {
         return element.getTimeToLive();
      }
      return 0;
   }
}

二、Redis
1、導入依存


    org.springframework.boot
    spring-boot-starter-data-redis

2、redis配置、yml中
spring:
#redis  
  redis:
      host: 127.0.0.1
      password:
      port: 6379
      pool:
        max-idle: 100
        min-idle: 1
        max-active: 1000
        max-wait: -1

 3、注入RedisTemplate
このbeanは@Resourceの方法で注入する必要があります.RedisTemplateは名前で注入するため、@Autowiredは使用できません.
@Resource
private RedisTemplate redisTemplate;

4、付属工具類
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author lhj
 * @Description: redis     
 * @date 2018/7/314:03
 */
@Component
public class RedisService {
    @Resource
    private RedisTemplate redisTemplate;

    /**
     *         
     * @param key  
     * @param time   ( )
     * @return
     */
    public boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *   key       
     * @param key      null
     * @return   ( )   0       
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     *   key    
     * @param key  
     * @return true    false   
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *     
     * @param key           
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================
    /**
     *       
     * @param key  
     * @return  
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     *       
     * @param key  
     * @param value  
     * @return true   false  
     */
    public boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     *            
     * @param key  
     * @param value  
     * @param time   ( ) time   0   time    0       
     * @return true   false   
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *   
     * @param key  
     * @param delta     (  0)
     * @return
     */
    public long incr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("        0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     *   
     * @param key  
     * @param delta     (  0)
     * @return
     */
    public long decr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("        0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    //================================Map=================================
    /**
     * HashGet
     * @param key      null
     * @param item      null
     * @return  
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     *   hashKey       
     * @param key  
     * @return        
     */
    public Map hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key  
     * @param map       
     * @return true    false   
     */
    public boolean hmset(String key, Map map){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet      
     * @param key  
     * @param map       
     * @param time   ( )
     * @return true   false  
     */
    public boolean hmset(String key, Map map, long time){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *    hash      ,        
     * @param key  
     * @param item  
     * @param value  
     * @return true    false  
     */
    public boolean hset(String key,String item,Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *    hash      ,        
     * @param key  
     * @param item  
     * @param value  
     * @param time   ( )    :      hash    ,           
     * @return true    false  
     */
    public boolean hset(String key,String item,Object value,long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *   hash    
     * @param key      null
     * @param item            null
     */
    public void hdel(String key, Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }

    /**
     *   hash         
     * @param key      null
     * @param item      null
     * @return true    false   
     */
    public boolean hHasKey(String key, String item){
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash        ,                
     * @param key  
     * @param item  
     * @param by     (  0)
     * @return
     */
    public double hincr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash  
     * @param key  
     * @param item  
     * @param by     (  0)
     * @return
     */
    public double hdecr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item,-by);
    }

    //============================set=============================
    /**
     *   key  Set     
     * @param key  
     * @return
     */
    public Set sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     *   value   set   ,    
     * @param key  
     * @param value  
     * @return true    false   
     */
    public boolean sHasKey(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *      set  
     * @param key  
     * @param values        
     * @return     
     */
    public long sSet(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     *  set      
     * @param key  
     * @param time   ( )
     * @param values        
     * @return     
     */
    public long sSetAndTime(String key,long time,Object...values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if(time>0) expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     *   set     
     * @param key  
     * @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     *     value 
     * @param key  
     * @param values        
     * @return      
     */
    public long setRemove(String key, Object ...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

    /**
     *   list     
     * @param key  
     * @param start   
     * @param end     0   -1     
     * @return
     */
    public List lGet(String key, long start, long end){
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     *   list     
     * @param key  
     * @return
     */
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     *        list   
     * @param key  
     * @param index     index>=0 ， 0   ，1      ，    ；index<0 ，-1，  ，-2       ，    
     * @return
     */
    public Object lGetIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     *  list    
     * @param key  
     * @param value  
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *  list    
     * @param key  
     * @param value  
     * @param time   ( )
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *  list    
     * @param key  
     * @param value  
     * @return
     */
    public boolean lSet(String key, List value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *  list    
     * @param key  
     * @param value  
     * @param time   ( )
     * @return
     */
    public boolean lSet(String key, List value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *       list      
     * @param key  
     * @param index   
     * @param value  
     * @return
     */
    public boolean lUpdateIndex(String key, long index,Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     *   N   value
     * @param key  
     * @param count      
     * @param value  
     * @return      
     */
    public long lRemove(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}
JAvaエラーjava.lang.UnsupportedOperationException
【ゴッドバッハ予想】