AOP+Cache

最新推荐文章于 2022-04-04 19:38:38 发布
最新推荐文章于 2022-04-04 19:38:38 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： 开源框架 文章标签： cache aop object import class string

需要使用Spring来实现一个Cache简单的解决方案，具体需求如下：使用任意一个现有开源Cache Framework，要求可以Cache系统中Service或则DAO层的get/find等方法返回结果，如果数据更新（使用Create/update/delete方法），则刷新cache中相应的内容。

根据需求，计划使用Spring AOP + ehCache来实现这个功能，采用ehCache原因之一是Spring提供了ehCache的支持，至于为何仅仅支持ehCache而不支持osCache和JBossCache无从得知(Hibernate???)，但毕竟Spring提供了支持，可以减少一部分工作量：)。二是后来实现了OSCache和JBoss Cache的方式后，经过简单测试发现几个Cache在效率上没有太大的区别(不考虑集群)，决定采用ehCahce。

AOP嘛，少不了拦截器,先创建一个实现了MethodInterceptor接口的拦截器,用来拦截Service/DAO的方法调用，拦截到方法后，搜索该方法的结果在cache中是否存在，如果存在，返回cache中的缓存结果，如果不存在，返回查询数据库的结果，并将结果缓存到cache中。

MethodCacheInterceptor.java

Java代码
package com.co.cache.ehcache;   
  
import java.io.Serializable;   
  
import net.sf.ehcache.Cache;   
import net.sf.ehcache.Element;   
  
import org.aopalliance.intercept.MethodInterceptor;   
import org.aopalliance.intercept.MethodInvocation;   
import org.apache.commons.logging.Log;   
import org.apache.commons.logging.LogFactory;   
import org.springframework.beans.factory.InitializingBean;   
import org.springframework.util.Assert;   
  
public class MethodCacheInterceptor implements MethodInterceptor, InitializingBean   
{   
    private static final Log logger = LogFactory.getLog(MethodCacheInterceptor.class);   
  
    private Cache cache;   
  
    public void setCache(Cache cache) {   
        this.cache = cache;   
    }   
  
    public MethodCacheInterceptor() {   
        super();   
    }   
  
    /**  
     * 拦截Service/DAO的方法，并查找该结果是否存在，如果存在就返回cache中的值，  
     * 否则，返回数据库查询结果，并将查询结果放入cache  
     */  
    public Object invoke(MethodInvocation invocation) throws Throwable {   
        String targetName = invocation.getThis().getClass().getName();   
        String methodName = invocation.getMethod().getName();   
        Object[] arguments = invocation.getArguments();   
        Object result;   
       
        logger.debug("Find object from cache is " + cache.getName());   
           
        String cacheKey = getCacheKey(targetName, methodName, arguments);   
        Element element = cache.get(cacheKey);   
  
        if (element == null) {   
            logger.debug("Hold up method , Get method result and create cache........!");   
            result = invocation.proceed();   
            element = new Element(cacheKey, (Serializable) result);   
            cache.put(element);   
        }   
        return element.getValue();   
    }   
  
    /**  
     * 获得cache key的方法，cache key是Cache中一个Element的唯一标识  
     * cache key包括 包名+类名+方法名，如com.co.cache.service.UserServiceImpl.getAllUser  
     */  
    private String getCacheKey(String targetName, String methodName, Object[] arguments) {   
        StringBuffer sb = new StringBuffer();   
        sb.append(targetName).append(".").append(methodName);   
        if ((arguments != null) && (arguments.length != 0)) {   
            for (int i = 0; i < arguments.length; i++) {   
                sb.append(".").append(arguments[i]);   
            }   
        }   
        return sb.toString();   
    }   
       
    /**  
     * implement InitializingBean，检查cache是否为空  
     */  
    public void afterPropertiesSet() throws Exception {   
        Assert.notNull(cache, "Need a cache. Please use setCache(Cache) create it.");   
    }   
  
}  
package com.co.cache.ehcache;

import java.io.Serializable;

import net.sf.ehcache.Cache;
import net.sf.ehcache.Element;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

public class MethodCacheInterceptor implements MethodInterceptor, InitializingBean
{
 private static final Log logger = LogFactory.getLog(MethodCacheInterceptor.class);

 private Cache cache;

 public void setCache(Cache cache) {
  this.cache = cache;
 }

 public MethodCacheInterceptor() {
  super();
 }

 /**
  * 拦截Service/DAO的方法，并查找该结果是否存在，如果存在就返回cache中的值，
  * 否则，返回数据库查询结果，并将查询结果放入cache
  */
 public Object invoke(MethodInvocation invocation) throws Throwable {
  String targetName = invocation.getThis().getClass().getName();
  String methodName = invocation.getMethod().getName();
  Object[] arguments = invocation.getArguments();
  Object result;
 
  logger.debug("Find object from cache is " + cache.getName());
  
  String cacheKey = getCacheKey(targetName, methodName, arguments);
  Element element = cache.get(cacheKey);

  if (element == null) {
   logger.debug("Hold up method , Get method result and create cache........!");
   result = invocation.proceed();
   element = new Element(cacheKey, (Serializable) result);
   cache.put(element);
  }
  return element.getValue();
 }

 /**
  * 获得cache key的方法，cache key是Cache中一个Element的唯一标识
  * cache key包括 包名+类名+方法名，如com.co.cache.service.UserServiceImpl.getAllUser
  */
 private String getCacheKey(String targetName, String methodName, Object[] arguments) {
  StringBuffer sb = new StringBuffer();
  sb.append(targetName).append(".").append(methodName);
  if ((arguments != null) && (arguments.length != 0)) {
   for (int i = 0; i < arguments.length; i++) {
    sb.append(".").append(arguments[i]);
   }
  }
  return sb.toString();
 }
 
 /**
  * implement InitializingBean，检查cache是否为空
  */
 public void afterPropertiesSet() throws Exception {
  Assert.notNull(cache, "Need a cache. Please use setCache(Cache) create it.");
 }

}

 

上面的代码中可以看到，在方法public Object invoke(MethodInvocation invocation) 中，完成了搜索Cache/新建cache的功能。

Java代码
Element element = cache.get(cacheKey);  
Element element = cache.get(cacheKey);

这句代码的作用是获取cache中的element，如果cacheKey所对应的element不存在，将会返回一个null值


Java代码
result = invocation.proceed();  
result = invocation.proceed();

这句代码的作用是获取所拦截方法的返回值，详细请查阅AOP相关文档。

随后，再建立一个拦截器MethodCacheAfterAdvice，作用是在用户进行create/update/delete操作时来刷新/remove相关cache内容，这个拦截器实现了AfterReturningAdvice接口，将会在所拦截的方法执行后执行在public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3)方法中所预定的操作

Java代码
package com.co.cache.ehcache;   
  
import java.lang.reflect.Method;   
import java.util.List;   
  
import net.sf.ehcache.Cache;   
  
import org.apache.commons.logging.Log;   
import org.apache.commons.logging.LogFactory;   
import org.springframework.aop.AfterReturningAdvice;   
import org.springframework.beans.factory.InitializingBean;   
import org.springframework.util.Assert;   
  
public class MethodCacheAfterAdvice implements AfterReturningAdvice, InitializingBean   
{   
    private static final Log logger = LogFactory.getLog(MethodCacheAfterAdvice.class);   
  
    private Cache cache;   
  
    public void setCache(Cache cache) {   
        this.cache = cache;   
    }   
  
    public MethodCacheAfterAdvice() {   
        super();   
    }   
  
    public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {   
        String className = arg3.getClass().getName();   
        List list = cache.getKeys();   
        for(int i = 0;i<list.size();i++){   
            String cacheKey = String.valueOf(list.get(i));   
            if(cacheKey.startsWith(className)){   
                cache.remove(cacheKey);   
                logger.debug("remove cache " + cacheKey);   
            }   
        }   
    }   
  
    public void afterPropertiesSet() throws Exception {   
        Assert.notNull(cache, "Need a cache. Please use setCache(Cache) create it.");   
    }   
  
}  
package com.co.cache.ehcache;

import java.lang.reflect.Method;
import java.util.List;

import net.sf.ehcache.Cache;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

public class MethodCacheAfterAdvice implements AfterReturningAdvice, InitializingBean
{
 private static final Log logger = LogFactory.getLog(MethodCacheAfterAdvice.class);

 private Cache cache;

 public void setCache(Cache cache) {
  this.cache = cache;
 }

 public MethodCacheAfterAdvice() {
  super();
 }

 public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
  String className = arg3.getClass().getName();
  List list = cache.getKeys();
  for(int i = 0;i<list.size();i++){
   String cacheKey = String.valueOf(list.get(i));
   if(cacheKey.startsWith(className)){
    cache.remove(cacheKey);
    logger.debug("remove cache " + cacheKey);
   }
  }
 }

 public void afterPropertiesSet() throws Exception {
  Assert.notNull(cache, "Need a cache. Please use setCache(Cache) create it.");
 }

}


上面的代码很简单，实现了afterReturning方法实现自AfterReturningAdvice接口，方法中所定义的内容将会在目标方法执行后执行，在该方法中

Java代码
String className = arg3.getClass().getName();  
String className = arg3.getClass().getName();的作用是获取目标class的全名，如：com.co.cache.test.TestServiceImpl，然后循环cache的key list，remove cache中所有和该class相关的element。

随后，开始配置ehCache的属性，ehCache需要一个xml文件来设置ehCache相关的一些属性，如最大缓存数量、cache刷新的时间等等.
ehcache.xml

Java代码
<ehcache>   
    <diskStore path="c://myapp//cache"/>   
    <defaultCache   
        maxElementsInMemory="1000"  
        eternal="false"  
        timeToIdleSeconds="120"  
        timeToLiveSeconds="120"  
        overflowToDisk="true"  
        />   
  <cache name="DEFAULT_CACHE"  
        maxElementsInMemory="10000"  
        eternal="false"  
        timeToIdleSeconds="300000"  
        timeToLiveSeconds="600000"  
        overflowToDisk="true"  
        />   
</ehcache>  
<ehcache>
 <diskStore path="c://myapp//cache"/>
 <defaultCache
        maxElementsInMemory="1000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />
  <cache name="DEFAULT_CACHE"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300000"
        timeToLiveSeconds="600000"
        overflowToDisk="true"
        />
</ehcache>

配置每一项的详细作用不再详细解释，有兴趣的请google下 ，这里需要注意一点defaultCache标签定义了一个默认的Cache，这个Cache是不能删除的，否则会抛出No default cache is configured异常。另外，由于使用拦截器来刷新Cache内容，因此在定义cache生命周期时可以定义较大的数值，timeToIdleSeconds="300000" timeToLiveSeconds="600000"，好像还不够大？

然后，在将Cache和两个拦截器配置到Spring，这里没有使用2.0里面AOP的标签。
cacheContext.xml

Java代码
<?xml version="1.0" encoding="UTF-8"?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
<beans>   
    <!-- 引用ehCache的配置 -->   
    <bean id="defaultCacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">   
      <property name="configLocation">   
        <value>ehcache.xml</value>   
      </property>   
    </bean>   
       
    <!-- 定义ehCache的工厂，并设置所使用的Cache name -->   
    <bean id="ehCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">   
      <property name="cacheManager">   
        <ref local="defaultCacheManager"/>   
      </property>   
      <property name="cacheName">   
          <value>DEFAULT_CACHE</value>   
      </property>   
    </bean>   
  
    <!-- find/create cache拦截器 -->   
    <bean id="methodCacheInterceptor" class="com.co.cache.ehcache.MethodCacheInterceptor">   
      <property name="cache">   
        <ref local="ehCache" />   
      </property>   
    </bean>   
    <!-- flush cache拦截器 -->   
    <bean id="methodCacheAfterAdvice" class="com.co.cache.ehcache.MethodCacheAfterAdvice">   
      <property name="cache">   
        <ref local="ehCache" />   
      </property>   
    </bean>   
       
    <bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">   
      <property name="advice">   
        <ref local="methodCacheInterceptor"/>   
      </property>   
      <property name="patterns">   
        <list>   
            <value>.*find.*</value>   
            <value>.*get.*</value>   
        </list>   
      </property>   
    </bean>   
    <bean id="methodCachePointCutAdvice" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">   
      <property name="advice">   
        <ref local="methodCacheAfterAdvice"/>   
      </property>   
      <property name="patterns">   
        <list>   
          <value>.*create.*</value>   
          <value>.*update.*</value>   
          <value>.*delete.*</value>   
        </list>   
      </property>   
    </bean>   
</beans>  
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
 <!-- 引用ehCache的配置 -->
 <bean id="defaultCacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
   <property name="configLocation">
  <value>ehcache.xml</value>
   </property>
 </bean>
 
 <!-- 定义ehCache的工厂，并设置所使用的Cache name -->
 <bean id="ehCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
   <property name="cacheManager">
  <ref local="defaultCacheManager"/>
   </property>
   <property name="cacheName">
    <value>DEFAULT_CACHE</value>
   </property>
 </bean>

 <!-- find/create cache拦截器 -->
 <bean id="methodCacheInterceptor" class="com.co.cache.ehcache.MethodCacheInterceptor">
   <property name="cache">
  <ref local="ehCache" />
   </property>
 </bean>
 <!-- flush cache拦截器 -->
 <bean id="methodCacheAfterAdvice" class="com.co.cache.ehcache.MethodCacheAfterAdvice">
   <property name="cache">
  <ref local="ehCache" />
   </property>
 </bean>
 
 <bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
   <property name="advice">
  <ref local="methodCacheInterceptor"/>
   </property>
   <property name="patterns">
  <list>
   <value>.*find.*</value>
   <value>.*get.*</value>
  </list>
   </property>
 </bean>
 <bean id="methodCachePointCutAdvice" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
   <property name="advice">
  <ref local="methodCacheAfterAdvice"/>
   </property>
   <property name="patterns">
  <list>
    <value>.*create.*</value>
    <value>.*update.*</value>
    <value>.*delete.*</value>
  </list>
   </property>
 </bean>
</beans>

上面的代码最终创建了两个"切入点"，methodCachePointCut和methodCachePointCutAdvice，分别用于拦截不同方法名的方法，可以根据需要任意增加所需要拦截方法的名称。
需要注意的是

Java代码
<bean id="ehCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">   
      <property name="cacheManager">   
        <ref local="defaultCacheManager"/>   
      </property>   
      <property name="cacheName">   
          <value>DEFAULT_CACHE</value>   
      </property>   
    </bean>  
<bean id="ehCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
   <property name="cacheManager">
  <ref local="defaultCacheManager"/>
   </property>
   <property name="cacheName">
    <value>DEFAULT_CACHE</value>
   </property>
 </bean>

如果cacheName属性内设置的name在ehCache.xml中无法找到，那么将使用默认的cache(defaultCache标签定义).

事实上到了这里，一个简单的Spring + ehCache Framework基本完成了，为了测试效果，举一个实际应用的例子，定义一个TestService和它的实现类TestServiceImpl，里面包含

两个方法getAllObject()和updateObject(Object Object)，具体代码如下
TestService.java

Java代码
package com.co.cache.test;   
  
import java.util.List;   
  
public interface TestService {   
    public List getAllObject();   
  
    public void updateObject(Object Object);   
}  
package com.co.cache.test;

import java.util.List;

public interface TestService {
 public List getAllObject();

 public void updateObject(Object Object);
}


TestServiceImpl.java

Java代码
package com.co.cache.test;   
  
import java.util.List;   
  
public class TestServiceImpl implements TestService   
{   
    public List getAllObject() {   
        System.out.println("---TestService：Cache内不存在该element，查找并放入Cache！");   
        return null;   
    }   
  
    public void updateObject(Object Object) {   
        System.out.println("---TestService：更新了对象，这个Class产生的cache都将被remove！");   
    }   
}  
package com.co.cache.test;

import java.util.List;

public class TestServiceImpl implements TestService
{
 public List getAllObject() {
  System.out.println("---TestService：Cache内不存在该element，查找并放入Cache！");
  return null;
    }

 public void updateObject(Object Object) {
  System.out.println("---TestService：更新了对象，这个Class产生的cache都将被remove！");
    }
}

使用Spring提供的AOP进行配置
applicationContext.xml

Java代码
<?xml version="1.0" encoding="UTF-8"?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
  
<beans>   
    <import resource="cacheContext.xml"/>   
       
    <bean id="testServiceTarget" class="com.co.cache.test.TestServiceImpl"/>   
       
    <bean id="testService" class="org.springframework.aop.framework.ProxyFactoryBean">   
      <property name="target">   
          <ref local="testServiceTarget"/>   
      </property>   
      <property name="interceptorNames">   
        <list>   
          <value>methodCachePointCut</value>   
          <value>methodCachePointCutAdvice</value>   
        </list>   
      </property>   
    </bean>   
</beans>  


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/liuzhenwen/archive/2009/03/12/3983952.aspx

yxpjx
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring aop 自定义缓存实现
12-11
spring aop 自定义缓存实现的一个小实例，地址：http://blog.csdn.net/maoyeqiu/article/details/50260357
aop cache再讨论
bluesky
10-09 126
开门见山,一刀见血,让我们说说烦人的aop cache. aop cache解释使用aop技术的cache,可以cache被代理对象的方法返回结果,还可以通过方法的参数值来控制缓存的粒度,看上去很美,用的人估计也颇多,好东西啊,面试的时候经常有人告诉我"我用过aop cache",看来是居家必备啊.不过居家必备的东西也得升个级什么滴啊,就想汽车一样,每年拉一次皮,照卖,还自夸是新一袋.aop c...
Spring AOP 中Cache操作实现
weixin_43694465的博客
01-07 568
6.1缓存场景分析 在业务方法中我们可能调用数据层方法获取数据库中数据,假如访问数据的频率比较为高,为了提高的查询效率,降低数据库的访问压力,可以在业务对数据进行缓存. 6.2Spring 中业务缓存应用实现 6.2.1启动缓存配置 在项目(SpringBoot项目)的启动类上添加@EnableCaching注解,以启动缓存配置。关键代码如下： 6.2.2业务方法上应用缓存配置 在需要进行缓存的...
利用AOP实现一个简单的缓存存储、清除的工具
Eric的博客
07-26 2814
基本要求：利用aop实现一个简单的缓存存储、清除的工具，从实际使用上来说，切面应该在provider层。在service层方法调用和数据库查询之间生效。为了简化过程，不要求与数据库交互，数据可以随机生成，不要求使用redis等中间件，可以直接缓存到内存中。 代码实现非常的基础，能够很好的理解AOP以及缓存的基本原理，想要深入理解可以去查阅更多的资料。仅供自己学习。 1、实体类： public...
Spring AOP+ehCache简单缓存系统解决方案.doc
最新发布
09-18
缘起需求：需要使用Spring来实现一个Cache简单的解决方案，具体需求如下：使用任意一个现有开源Cache Framework，要求可以Cache系统中Service或者DAO层的get/find等方法返回结果，如果数据更新（使用Create/update/...
AOP Cache源代码
08-26
使用Spring AOP技术 + ehcache做的一个缓存。此代码为转载，供大家学习使用。
Spring AOP+ehCache简单缓存系统解决方案
07-20
需要使用Spring来实现一个Cache简单的解决方案，具体需求如下：使用任意一个现有开源Cache Framework，要求可以Cache系统中Service或则DAO层的get/find等方法返回结果，如果数据更新（使用Create/update/delete方法...
实战项目-AOP-cache
09-28
运用AOP和escache一起对数据进行缓存处理。
AutoLoadCache：AutoLoadCache是​​基于AOP + Annotation等技术实现的高效的缓存管理解决方案，实现缓存与业务逻辑的解压缩，并增加异步刷新及“拿来主义机制”，以适应高并发环境下的使用
02-03
然后我们就使用AOP + Annotation来解决这个问题，同时使用自动加载机制来实现数据“常驻内存”。 在infoq发表的文章 推荐使用这个， 中也有可运行的例子。 原始阅读 已经实现基于aspectj的AOP，代码在。想通过阅读...
Spring AOP中Cache操作实现
weixin_49792497的博客
11-01 404
缓存场景分析 在业务方法中我们可能调用数据层方法获取数据库中数据,假如访问数据的频率比较高,为了提高的查询效率,降低数据库的访问压力,可以在业务层对数据进行缓存。 Spring 中业务缓存应用实现 首先我们要创建一个新的项目 这里我们暂时不添加任何依赖，直接next 这样子我们的项目就创建成功了。 然后将我们的项目转成maven项目 建一个包 在这个包下建一个接口 在这个接口类里面定义一个查询的方法，然后将查询的结果定义到一个集合里 package com.
使用AOP自己实现SpringCache的功能
weixin_45754452的博客
04-04 665
文章目录总结自己实现SpringCache的功能项目地址项目结构自定义缓存AOP实现类自定义缓存实现类使用 总结 SpringCache定义了@Cacheable、@CachePut、@CacheEvict三个注解，分别对应查询、更新、删除时对缓存的处理 只需要在Server类添加该注解，就可以通过AOP自动代理实现缓存查询、缓存更新、缓存删除，使用形式如下，@Cacheable、@CachePut会在unless条件成立时将返回值添加进缓存，而@Cacheable在有缓存时不会执行Server类方法。@
AOP缓存实现
weixin_47409774的博客
08-13 2279
AOP AOP是一种设计思想,是软件设计领域中的的面向切面编程,它是对面向对象编程的一种补充和完善,可以在不修改源代码的情况下给程序动态统一添加额外功能的技术 项目中的非核心业务一般是通过特定方式切入到系统中,一般这种方式就是要借助AOP实现. 实现AOP的两种方式 (1) 如果目标对象实现了接口,底层可以采用JDK动态代理来为目标创建代理对象,目标类和代理类会实现共同接口(组合方式) (2) 如果目标对象没有实现接口name底层可以采用CGLIB代理机制为目标对象创建代理对象默认创建的代理类汇集成目标对象
Spring注解驱动开发——AOP原理笔记
如不來的博客
03-20 396
AOP：动态代理，指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式 1、导入aop模块；Spring AOP：(spring-aspects) 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx） 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCal...
spring 之aop 异常Unable to load cache item
热门推荐
weixin_40230655的博客
06-09 2万+
这个异常有两种情况： 一、缺少aop包 二 、aop包的版本和spring的版本不对 spring-aop版本与 aspectjweaver 包版本冲突 解决办法 maven项目的spring-aop版本是5.1.9,其他的spring版本是5.2.1，aspectjweaver 版本是1.8.3，将spring-aop的版本改成5.2.1，运行正常 项目中并没有用到spring-aop包，用的是aspectjweaver ，直接将spring-aop删掉，运行正常 Exception in thread
Aspecj Cache 利用AspectJ的AOP模式来解决缓存方法内部调用
Uply233的博客
05-15 605
本方法适用于main()方法调用，但是web环境的解决方案应该差不多。首先在spring-config.xml中加入如下代码： &lt;context:load-time-weaver /&gt; &lt;context:component-scan base-package="xin.uply.dao"/&gt; &lt;cache:annotation-driven ca...
使用AOP实现自定义缓存策略
波特多的博客
04-15 893
一 、目标 本文将会通过实例说明如何通过AOP自定义一个缓存策略，主要是调整缓存刷新的时间节点，兼顾查询速度的同时，保证数据的可靠性 一般情况下， 缓存失效是由缓存框架来进行管理的，用户可以通过设置ttl来指定key的有效时间， TTL设置太长，数据更新的不及时，TTL太短，缓存刷新也存在等待时间，达不到目标效果。 这是最常用最常用的体逻辑如： 失效：应用程序先从cache取数据，没有得到，则从...
Spring AOP异步操作实现及Cache操作实现(PROJECT04_DAY03_01)
weixin_47253919的博客
10-20 927
5. Spring AOP异步操作实现 5.1 异步场景分析 在开发系统的过程中，通常会考虑到系统的性能问题，提升系统性能的一个重要思想就是“串行”改“并行”。说起“并行”自然离不开“异步”，今天我们就来聊聊如何使用Spring的@Async的异步注解。 5.2 Spring 业务的异步实现 5.2.1 启动异步配置 在基于注解方式的配置中，借助@EnableAsync注解进行异步启动声明，Spring Boot版的项目中，将@EnableAsync注解应用到启动类上，代码示例如下： @EnableAsyn
通过aop进行缓存配置
scholery的专栏
09-29 2339
缓存可以说是无处不在，比如 PC 电脑中的内存、CPU 中的二级缓存、HTTP 协议中的缓存控制、CDN 加速技术都是使用了缓存的思想来解决性能问题。 缓存是用于解决高并发场景下系统的性能及稳定性问题的银弹。 本文主要是讨论我们经常使用的分布式缓存 Redis 在开发过程中的相关思考。 一、 如何将业务逻辑与缓存之间进行解耦？ 大部分情况，大家都是把缓存操作和业务逻辑之间的
aop实现redis缓存
08-18
AOP（面向切面编程）可以用于实现 Redis 缓存的功能。下面是一种常见的实现方式： 1. 首先，需要配置 Redis 客户端，确保你的应用程序可以与 Redis 进行通信。 2. 创建一个自定义注解，用于标记需要缓存的方法。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值