spring(三、spring中的eheche缓存、redis使用)

本文主要介绍为什么要构建ehcache+redis两级缓存？以及在实战中如何实现？思考如何配置缓存策略更合适？这样的方案可能遗留什么问题？JUST DO IT! GO!

问题描述

场景：我们的应用系统是分布式集群的，可横向扩展的。应用中某个接口操作满足以下一个或多个条件： 
1. 接口运行复杂代价大， 
2. 接口返回数据量大， 
3. 接口的数据基本不会更改， 
4. 接口数据一致性要求不高（只需满足最终一致）。

此时，我们会考虑将这个接口的返回值做缓存。考虑到上述条件，我们需要一套高可用分布式的缓存集群，并具备持久化功能，备选的有ehcache集群或redis主备（sentinel）。

  • ehcache集群因为节点之间数据同步通过组播的方式，可能带来的问题：节点间大量的数据复制带来额外的开销，在节点多的情况下此问题越发严重，N个节点会出现N-1次网络传输数据进行同步。（见下图，缓存集群中有三台机器，其中一台机器接收到数据，需要拷贝到其他机器，一次input后需要copy两次，两次copy是需要网络传输消耗的） 
  • redis主备由于作为中心节点提供缓存，其他节点都向redis中心节点取数据，所以，一次网络传输即可。（当然此处的一次网络代价跟组播的代价是不一样的）但是，随着访问量增大，大量的缓存数据访问使得应用服务器和缓存服务器之间的网络I/O消耗越大。（见下图，同样三台应用服务器，redis sentinel作为中心节点缓存。所谓中心，即所有应用服务器以redis为缓存中心，不再像ehcache集群，缓存是分散存放在应用服务器中，需要互相同步的，任何一台应用服务器的input，都会经过一次copy网络传输到redis，由于redis是中心共享的，那么就可以不用同步的步骤，其他应用服务器需要只需去get取即可。但是，我们会发现多了N台服务器的get的网络开销。）

提出方案

那么要怎么处理呢？所以两级缓存的思想诞生了，在redis的方案上做一步优化，在缓存到远程redis的同时，缓存一份到本地进程ehcache（此处的ehcache不用做集群，避免组播带来的开销），取缓存的时候会先取本地，没有会向redis请求，这样会减少应用服务器<–>缓存服务器redis之间的网络开销。（见下图，为了减少get这几条网络传输，我们会在每个应用服务器上增加本地的ehcache缓存作为二级缓存，即第一次get到的数据存入ehcache，后面output输出即可从本地ehcache中获取，不用再访问redis了，所以就减少了以后get的网络开销。get开销只要一次，后续不需要了，除非本地缓存过期需要再get。） 
 
如果用过j2cache的都应该知道，oschina用j2cache这种两级缓存，实践证明了该方案是可行的。该篇使用spring+ehcache+redis实现更加简洁。

方案实施

1、 spring和ehcache集成

主要获取ehcache作为操作ehcache的对象。

ehcache.xml 代码如下：


  2. <ehcache updateCheck="false" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:noNamespaceSchemaLocation="http://ehcache.sf.net/ehcache.xsd">
  5.     <diskStore path="java.io.tmpdir/ehcache"/>
  7.    <!--  默认的管理策略
  8.     maxElementsOnDisk： 在磁盘上缓存的element的最大数目，默认值为0，表示不限制。
  9.     eternal:设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断。
  10.     diskPersistent： 是否在磁盘上持久化。指重启jvm后，数据是否有效。默认为false。
  11.     diskExpiryThreadIntervalSeconds:对象检测线程运行时间间隔。标识对象状态（过期/持久化）的线程多长时间运行一次。
  12.     -->
  13.     <defaultCache maxElementsInMemory="10000"
  14.                   eternal="false"
  15.                   timeToIdleSeconds="3600"
  16.                   timeToLiveSeconds="3600"
  17.                   overflowToDisk="true"
  18.                   diskPersistent="false"
  19.                   diskExpiryThreadIntervalSeconds="120"
  20.                   memoryStoreEvictionPolicy="LRU"/>
  22.     <!-- 对象无过期，一个1000长度的队列，最近最少使用的对象被删除 -->
  23.      <cache name="userCache"
  24.            maxElementsInMemory="1000"
  25.            eternal="true"
  26.            overflowToDisk="false"
  27.            timeToIdleSeconds="0"
  28.            timeToLiveSeconds="0"
  29.            memoryStoreEvictionPolicy="LFU">
  30.      </cache>
  32.     <!-- 组播方式：multicastGroupPort需要保证与其他系统不重复，进行端口注册  -->
  33.     <!-- 若因未注册，配置了重复端口，造成权限缓存数据异常，请自行解决  -->
  34.     <cacheManagerPeerProviderFactory
  35.             class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
  36.             properties="peerDiscovery=automatic,
  37.                         multicastGroupAddress=230.0.0.1,
  38.                         multicastGroupPort=4546, timeToLive=1"/>
  40. <!-- replicatePuts=true | false – 当一个新元素增加到缓存中的时候是否要复制到其他的peers. 默认是true。 -->
  41. <!-- replicateUpdates=true | false – 当一个已经在缓存中存在的元素被覆盖时是否要进行复制。默认是true。 -->
  42. <!-- replicateRemovals= true | false – 当元素移除的时候是否进行复制。默认是true。 -->
  43. <!-- replicateAsynchronously=true | false – 复制方式是异步的（指定为true时）还是同步的（指定为false时）。默认是true。 -->
  44. <!-- replicatePutsViaCopy=true | false – 当一个新增元素被拷贝到其他的cache中时是否进行复制指定为true时为复制，默认是true。 -->
  45. <!-- replicateUpdatesViaCopy=true | false – 当一个元素被拷贝到其他的cache中时是否进行复制（指定为true时为复制），默认是true。 -->
  47.      <cache name="webCache_LT"
  48.            maxElementsInMemory="10000"
  49.            eternal="false"
  50.            overflowToDisk="false"
  51.            timeToIdleSeconds="3600"
  52.            timeToLiveSeconds="3600"
  53.            memoryStoreEvictionPolicy="LRU">
  54.         <cacheEventListenerFactory
  55.                 class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
  56.                 properties="replicateRemovals=true"/>
  57.          <bootstrapCacheLoaderFactory
  58.                  class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"/>
  59.     </cache>
  61.     <cache name="webCache_ST"
  62.            maxElementsInMemory="1000"
  63.            eternal="false"
  64.            overflowToDisk="false"
  65.            timeToIdleSeconds="300"
  66.            timeToLiveSeconds="300"
  67.            memoryStoreEvictionPolicy="LRU">
  68.         <cacheEventListenerFactory
  69.                 class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
  70.                 properties="replicateRemovals=true"/>
  71.         <bootstrapCacheLoaderFactory
  72.                 class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"/>
  73.     </cache>
  75. </ehcache>

spring注入jedisPool、redisConnFactory、redisTemplate对象


  2. <!-- 加载redis.propertis -->
  3.     <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  4.         <property name="locations" value="classpath:redis.properties"/>
  5.     </bean>
  7.     <!-- Redis 连接池 -->
  8.     <bean id="jedisPool" class="redis.clients.jedis.JedisPoolConfig">
  9.         <property name="maxTotal" value="${redis.pool.maxActive}" />
  10.         <property name="maxIdle" value="${redis.pool.maxIdle}" />
  11.         <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
  12.         <property name="testOnReturn" value="${redis.pool.testOnReturn}" />
  13.         <property name="maxWaitMillis" value="${redis.pool.maxWait}" />
  14.     </bean>
  16.     <!-- Redis 连接工厂 -->
  17.     <bean id="redisConnFactory"
  18.         class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
  19.         <property name="hostName" value="${redis.ip}" />
  20.         <property name="port" value="${redis.port}" />
  21.         <!-- property name="password" value="${redis.password}" -->
  22.         <property name="timeout" value="${redis.timeout}" />
  23.         <property name="poolConfig" ref="jedisPool" />
  24.     </bean>
  26.     <!-- redis 操作对象 -->
  27.     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
  28.         <property name="connectionFactory" ref="redisConnFactory" />
  29.     </bean>

3、 spring集成ehcache和redis

通过上面两步注入的ehcache和redisTemplate我们就能自定义一个方法将两者整合起来。详见EhRedisCache类。

EhRedisCache.java


  2. /**
  3.  * 两级缓存，一级:ehcache,二级为redisCache
  4.  * @author yulin
  5.  *
  6.  */
  7. public class EhRedisCache implements Cache{
  9.     private static final Logger LOG = LoggerFactory.getLogger(UserServiceImpl.class);
  11.     private String name;
  13.     private net.sf.ehcache.Cache ehCache;
  15.     private RedisTemplate<String, Object> redisTemplate;
  17.      private long liveTime = 1*60*60; //默认1h=1*60*60
  19.     @Override
  20.     public String getName() {
  21.         return this.name;
  22.     }
  24.     @Override
  25.     public Object getNativeCache() {
  26.         return this;
  27.     }
  29.     @Override
  30.     public ValueWrapper get(Object key) {
  31.          Element value = ehCache.get(key);
  32.          LOG.info("Cache L1 (ehcache) :{}={}",key,value);
  33.          if (value!=null) {
  34.              return (value != null ? new SimpleValueWrapper(value.getObjectValue()) : null);
  35.          }
  36.          //TODO 这样会不会更好？访问10次EhCache 强制访问一次redis 使得数据不失效
  37.          final String keyStr = key.toString();
  38.          Object objectValue = redisTemplate.execute(new RedisCallback<Object>() {
  39.             public Object doInRedis(RedisConnection connection)
  40.                     throws DataAccessException {
  41.                 byte[] key = keyStr.getBytes();
  42.                 byte[] value = connection.get(key);
  43.                 if (value == null) {
  44.                     return null;
  45.                 }
  46.                 //每次获得，重置缓存过期时间
  47.                 if (liveTime > 0) {
  48.                     connection.expire(key, liveTime);
  49.                 }
  50.                 return toObject(value);
  51.             }
  52.         },true);
  53.          ehCache.put(new Element(key, objectValue));//取出来之后缓存到本地
  54.          LOG.info("Cache L2 (redis) :{}={}",key,objectValue);
  55.          return  (objectValue != null ? new SimpleValueWrapper(objectValue) : null);
  57.     }
  59.     @Override
  60.     public void put(Object key, Object value) {
  61.         ehCache.put(new Element(key, value));
  62.         final String keyStr =  key.toString();
  63.         final Object valueStr = value;
  64.         redisTemplate.execute(new RedisCallback<Long>() {
  65.             public Long doInRedis(RedisConnection connection)
  66.                     throws DataAccessException {
  67.                 byte[] keyb = keyStr.getBytes();
  68.                 byte[] valueb = toByteArray(valueStr);
  69.                 connection.set(keyb, valueb);
  70.                 if (liveTime > 0) {
  71.                     connection.expire(keyb, liveTime);
  72.                 }
  73.                 return 1L;
  74.             }
  75.         },true);  
  77.     }
  79.     @Override
  80.     public void evict(Object key) {
  81.         ehCache.remove(key);
  82.         final String keyStr =  key.toString();
  83.         redisTemplate.execute(new RedisCallback<Long>() {
  84.             public Long doInRedis(RedisConnection connection)
  85.                     throws DataAccessException {
  86.                 return connection.del(keyStr.getBytes());
  87.             }
  88.         },true);
  89.     }
  91.     @Override
  92.     public void clear() {
  93.         ehCache.removeAll();
  94.         redisTemplate.execute(new RedisCallback<String>() {
  95.             public String doInRedis(RedisConnection connection)
  96.                     throws DataAccessException {
  97.                 connection.flushDb();
  98.                 return "clear done.";
  99.             }
  100.         },true);
  101.     }
  103.     public net.sf.ehcache.Cache getEhCache() {
  104.         return ehCache;
  105.     }
  107.     public void setEhCache(net.sf.ehcache.Cache ehCache) {
  108.         this.ehCache = ehCache;
  109.     }
  111.     public RedisTemplate<String, Object> getRedisTemplate() {
  112.         return redisTemplate;
  113.     }
  115.     public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
  116.         this.redisTemplate = redisTemplate;
  117.     }
  119.     public long getLiveTime() {
  120.         return liveTime;
  121.     }
  123.     public void setLiveTime(long liveTime) {
  124.         this.liveTime = liveTime;
  125.     }
  127.     public void setName(String name) {
  128.         this.name = name;
  129.     }
  130.     /**
  131.      * 描述 : Object转byte[]. <br>
  132.      * @param obj
  133.      * @return
  134.      */
  135.     private byte[] toByteArray(Object obj) {
  136.         byte[] bytes = null;
  137.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
  138.         try {
  139.             ObjectOutputStream oos = new ObjectOutputStream(bos);
  140.             oos.writeObject(obj);
  141.             oos.flush();
  142.             bytes = bos.toByteArray();
  143.             oos.close();
  144.             bos.close();
  145.         } catch (IOException ex) {
  146.             ex.printStackTrace();
  147.         }
  148.         return bytes;
  149.     }  
  151.     /**
  152.      * 描述 :  byte[]转Object . <br>
  153.      * @param bytes
  154.      * @return
  155.      */
  156.     private Object toObject(byte[] bytes) {
  157.         Object obj = null;
  158.         try {
  159.             ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
  160.             ObjectInputStream ois = new ObjectInputStream(bis);
  161.             obj = ois.readObject();
  162.             ois.close();
  163.             bis.close();
  164.         } catch (IOException ex) {
  165.             ex.printStackTrace();
  166.         } catch (ClassNotFoundException ex) {
  167.             ex.printStackTrace();
  168.         }
  169.         return obj;
  170.     }
  171. }

spring注入自定义缓存


  2.  <!-- 自定义ehcache+redis-->
  3.    <bean id="ehRedisCacheManager" class="org.springframework.cache.support.SimpleCacheManager">
  4.         <property name="caches">
  5.             <set>
  6.                <bean  id="ehRedisCache" class="org.musicmaster.yulin.ercache.EhRedisCache">
  7.                      <property name="redisTemplate" ref="redisTemplate" />
  8.                      <property name="ehCache" ref="ehCache"/>
  9.                      <property name="name" value="userCache"/>
  10.                 <!-- <property name="liveTime" value="3600"/>  -->
  11.                 </bean>
  12.             </set>
  13.         </property>
  14.     </bean>  
  16.     <!-- 注解声明 -->
  17.     <cache:annotation-driven cache-manager="ehRedisCacheManager"
  18.             proxy-target-class="true"  />

4、 模拟问题中提到的接口

此处假设该接口满足上述条件。

UserService.java


  2. public interface UserService {
  4.     User findById(long id);
  6.     List<User> findByPage(int startIndex, int limit);
  8.     List<User> findBySex(Sex sex);
  10.     List<User> findByAge(int lessAge);
  12.     List<User> findByUsers(List<User> users);
  14.     boolean update(User user);
  16.     boolean deleteById(long id);
  17. }

UserServiceImpl.java


  2. @Service
  3. public class UserServiceImpl implements UserService{
  5.     private static final Logger LOG = LoggerFactory.getLogger(UserServiceImpl.class);
  7.     @Cacheable("userCache")
  8.     @Override
  9.     public User findById(long id) {
  10.         LOG.info("visit business service findById,id:{}",id);
  11.         User user = new User();
  12.         user.setId(id);
  13.         user.setUserName("tony");
  14.         user.setPassWord("******");
  15.         user.setSex(Sex.M);
  16.         user.setAge(32);
  17.         //耗时操作
  18.         try {
  19.             Thread.sleep(3000);
  20.         } catch (InterruptedException e) {
  21.             e.printStackTrace();
  22.         }
  23.         return user;
  24.     }
  26.     @Override
  27.     public List<User> findByPage(int startIndex, int limit) {
  28.         return null;
  29.     }
  31.     @Cacheable("userCache")
  32.     @Override
  33.     public List<User> findBySex(Sex sex) {
  34.         LOG.info("visit business service findBySex,sex:{}",sex);
  35.         List<User> users = new ArrayList<User>();
  36.         for (int i = 0; i < 5; i++) {
  37.             User user = new User();
  38.             user.setId(i);
  39.             user.setUserName("tony"+i);
  40.             user.setPassWord("******");
  41.             user.setSex(sex);
  42.             user.setAge(32+i);
  43.             users.add(user);
  44.         }
  45.         return users;
  46.     }
  48.     @Override
  49.     public List<User> findByAge(int lessAge) {
  50.         // TODO Auto-generated method stub
  51.         return null;
  52.     }
  54.     //FIXME 此处将list参数的地址作为key存储，是否有问题？
  55.     @Cacheable("userCache")
  56.     @Override
  57.     public List<User> findByUsers(List<User> users) {
  58.         LOG.info("visit business service findByUsers,users:{}",users);
  59.         return users;
  60.     }
  62.     @CacheEvict("userCache")
  63.     @Override
  64.     public boolean update(User user) {
  65.         return true;
  66.     }
  68.     @CacheEvict("userCache")
  69.     @Override
  70.     public boolean deleteById(long id) {
  71.         return false;
  72.     }
  74. }

User.java

  1. public class User implements Serializable {
  3.     private static final long serialVersionUID = 1L;
  4.     public enum Sex{
  5.         M,FM
  6.     }
  7.     private long id;
  8.     private String userName;
  9.     private String passWord;
  10.     private int age;
  11.     private Sex sex;
  13.     public long getId() {
  14.         return id;
  15.     }
  16.     public void setId(long id) {
  17.         this.id = id;
  18.     }
  19.     public String getUserName() {
  20.         return userName;
  21.     }
  22.     public void setUserName(String userName) {
  23.         this.userName = userName;
  24.     }
  25.     public String getPassWord() {
  26.         return passWord;
  27.     }
  28.     public void setPassWord(String passWord) {
  29.         this.passWord = passWord;
  30.     }
  31.     public int getAge() {
  32.         return age;
  33.     }
  34.     public void setAge(int age) {
  35.         this.age = age;
  36.     }
  37.     public Sex getSex() {
  38.         return sex;
  39.     }
  40.     public void setSex(Sex sex) {
  41.         this.sex = sex;
  42.     }
  43.     @Override
  44.     public String toString() {
  45.         return "User [id=" + id + ", userName=" + userName + ", passWord="
  46.                 + passWord + ", age=" + age + ", sex=" + sex + "]";
  47.     }
  49. }

实施结果

我们写个测试类来模拟下

TestEhRedisCache.java


  2. public class TestEhRedisCache{
  4.     public static void main(String[] args) {
  5.         ApplicationContext context = new ClassPathXmlApplicationContext("spring-ehRedisCache.xml");
  6.         UserService userService= (UserService) context.getBean("userServiceImpl");
  7.         System.out.println(userService.findById(5l));
  8.         System.out.println(userService.findById(5l));
  9.         System.out.println(userService.findById(5l));
  10.         System.out.println(userService.findById(5l));
  11.         System.out.println(userService.findById(5l));
  12.     }
  13. }

TEST1 输出结果：


  2. Cache L1 (ehcache) :UserServiceImpl/findById/5=null
  3. Cache L2 (redis) :UserServiceImpl/findById/5=null
  4. visit business service findById,id:5
  5. User [id=5, userName=tony, passWord=******, age=32, sex=M]
  6. Cache L1 (ehcache) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=******, age=32, sex=M]
  7. User [id=5, userName=tony, passWord=******, age=32, sex=M]
  8. Cache L1 (ehcache) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=******, age=32, sex=M]
  9. User [id=5, userName=tony, passWord=******, age=32, sex=M]
  10. Cache L1 (ehcache) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=******, age=32, sex=M]
  11. User [id=5, userName=tony, passWord=******, age=32, sex=M]
  12. Cache L1 (ehcache) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=******, age=32, sex=M]
  13. User [id=5, userName=tony, passWord=******, age=32, sex=M]

上面第一次访问，一级缓存ehcache和二级缓存redis都没有数据，访问接口耗时操作，打印日志：

visit business service findById,id:5

第二次之后的访问，都会访问一级缓存ehcache，此时响应速度很快。

TEST2 在TEST1结束后，我们在liveTime的时间内，也就是redis缓存还未过期再次执行，会出现以下结果


  2. Cache L1 (ehcache) :UserServiceImpl/findById/5=null
  3. Cache L2 (redis) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=******, age=32, sex=M]
  4. User [id=5, userName=tony, passWord=******, age=32, sex=M]
  5. Cache L1 (ehcache) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=******, age=32, sex=M]
  6. User [id=5, userName=tony, passWord=******, age=32, sex=M]
  7. Cache L1 (ehcache) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=******, age=32, sex=M]
  8. User [id=5, userName=tony, passWord=******, age=32, sex=M]
  9. Cache L1 (ehcache) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=******, age=32, sex=M]
  10. User [id=5, userName=tony, passWord=******, age=32, sex=M]
  11. Cache L1 (ehcache) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=******, age=32, sex=M]
  12. User [id=5, userName=tony, passWord=******, age=32, sex=M]

由于TEST1执行完结束后，ehcache为进程间的缓存，自然随着运行结束而释放，所以TEST2出现：

Cache L1 (ehcache) :UserServiceImpl/findById/5=null

然而在第二次访问二级缓存redis，还未到缓存过期时间，所以在redis中找到数据（同时数据入一级缓存ehcache）：

Cache L2 (redis) :UserServiceImpl/findById/5=User [id=5, userName=tony, passWord=**, age=32, sex=M]

此处不会visit….没有经过接口的耗时操作，接下来数据都可以在本地缓存ehcache中获取。

spring(三、spring中的eheche缓存、redis使用)的更多相关文章

  1. 在Spring、Hibernate中使用Ehcache缓存(2)

    这里将介绍在Hibernate中使用查询缓存.一级缓存.二级缓存,整合Spring在HibernateTemplate中使用查询缓存.,这里是hibernate3,使用hibernate4类似,不过不 ...

  2. Spring Web MVC中的页面缓存支持 ——跟我学SpringMVC系列

    Spring Web MVC中的页面缓存支持 ——跟我学SpringMVC系列

  3. spring(三) spring事务操作

    前面一篇博文讲解了什么是AOP.学会了写AOP的实现,但是并没有实际运用起来,这一篇博文就算是对AOP技术应用的进阶把,重点是事务的处理. --wh 一.jdbcTemplate 什么是JdbcTem ...

  4. Spring(三) Spring IOC

    Spring 核心之 IOC 容器 再谈 IOC 与 DI IOC(Inversion of Control)控制反转:所谓控制反转,就是把原先我们代码里面需要实现的对象创 建.依赖的代码,反转给容器 ...

  5. Spring(三) Spring IOC 初体验

    Web IOC 容器初体验 我们还是从大家最熟悉的 DispatcherServlet 开始,我们最先想到的还是 DispatcherServlet 的 init() 方法.我们发现在 Dispath ...

  6. ASP.Net Core使用分布式缓存Redis从入门到实战演练

    一.课程介绍 人生苦短,我用.NET Core!缓存在很多情况下需要用到,合理利用缓存可以一方面可以提高程序的响应速度,同时可以减少对特定资源访问的压力.  所以经常要用到且不会频繁改变且被用户共享的 ...

  7. 第04项目：淘淘商城(SpringMVC+Spring+Mybatis)【第七天】(redis缓存)

    https://pan.baidu.com/s/1bptYGAb#list/path=%2F&parentPath=%2Fsharelink389619878-229862621083040 ...

  8. 【开源项目系列】如何基于 Spring Cache 实现多级缓存（同时整合本地缓存 Ehcache 和分布式缓存 Redis）

    一.缓存 当系统的并发量上来了,如果我们频繁地去访问数据库,那么会使数据库的压力不断增大,在高峰时甚至可以出现数据库崩溃的现象.所以一般我们会使用缓存来解决这个数据库并发访问问题,用户访问进来,会先从 ...

  9. 在spring boot环境中使用fastjson + redis的高速缓存技术

    因为项目需求,需要在spring boot环境中使用redis作数据缓存.之前的解决方案是参考的http://wiselyman.iteye.com/blog/2184884,具体使用的是Jackso ...

随机推荐

  1. Shell data、timedatectl

     data系统时间管理命令 命令date +%F xxxx—xx--xx #查看当前日期. 命令date +%T xx:xx:xx #查看当前时间. 命令date +%y xx #年2位 命令date ...

  2. [pytorch修改]dataloader.py 实现darknet中的subdivision功能

    dataloader.py import random import torch import torch.multiprocessing as multiprocessing from torch. ...

  3. PIL PNG格式通道问题的解决方法

    近来研究图片的剪切拼接,用到PIL,在打开PNG格式保存为JPEG格式的图片发现报错: import os from PIL import Image im = Image.open(r'E:\wor ...

  4. Learning-Python【19】：Python常用模块（2）—— os、sys、shutil

    os模块:与操作系统相关的模块 import os # 获取当前的工作目录 print(os.getcwd()) # 切换工作目录 os.chdir(r'E:\Python\test') print( ...

  5. JS对象、数据类型区别、函数

    对象 基本数据类型都是单一的值,值和值之间没有任何联系,变量之间独立,不能成为一个整体. 对象属于一种符合的数据类型,对象中可以保存对个不同数据类型的属性. 对象分类:  1.内建对象   由ES标准 ...

  6. [shell]输出内容到剪切板

    commandline和GUI下的clipboard的交互Mac下echo $PATH | pbcopy,copy to clipboardecho "$(pbpaste -Prefer t ...

  7. CSS font-family字体大合集

    在写文字内容占大篇幅的页面是,总是会面临着改变字体的需求,以下为font-family常用合集以及一部分文字效果: windows常见内置中文字体 字体中文名             字体英文名    ...

  8. 在git服务器上创建项目过程及遇到的问题

    一: 登录git服务器,输入用户名,密码等 二: New Project 添加项目 设置组可见,项目名称等. 创建成功的项目可以看到该项目的clone地址,可以通过http,ssh两种方式来获取: 三 ...

  9. linux是什么，有什么特点

    (1)Linux是一套免费使用和自由传播的类Unix操作系统,是一个基于POSIX和UNIX的多用户.多任务.支持多线程和多CPU的操作系统.它能运行主要的UNIX工具软件.应用程序和网络协议.它支持 ...

  10. map传参上下文赋值的问题

    今天开发遇到一个问题就是声明一个map<String,String> param ,给param赋值,明明有结果但是就是返回为空:下面附上代码: 因为在一个大的循环中,param是公用赋值 ...