dubbo 结果缓存

已于 2022-02-22 16:55:36 修改
阅读量2.8k 收藏 2
点赞数
分类专栏： dubbo 文章标签： dubbo
于 2022-02-22 14:14:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43931625/article/details/123067162
版权

dubbo 结果缓存

           

官网：https://dubbo.apache.org/zh/docs/advanced/result-cache/

                

               

                                     

结果缓存

           

应用：加速热门数据访问速度，避免额外加缓存的工作量（如redis缓存）

           

配置

# 接口级别缓存
<dubbo:reference interface="com.foo.BarService" cache="lru" />

# 方法级别缓存
<dubbo:reference interface="com.foo.BarService">
    <dubbo:method name="findBar" cache="lru" />
</dubbo:reference>


# cache可选值：
lru：默认每个线程存储1000个缓存，缓存满后，删除最长时间没有使用的缓存
lfu：默认每个线程存储1000个缓存，缓存满后，删除一段时间使用次数最少的缓存
threadlocal：threadlocal使用jvm内存存储缓存，无过期和删除策略，应该给jvm设置合适的内存避免内存溢出
jcache：与jsr107集成，使用jcache在内存中存储缓存
expiring：使用map在内存中存储缓存，设置过期时间，默认为180s，每隔10s检查一次缓存是否过期

             

CacheFactory：默认为lru缓存

@SPI("lru")
public interface CacheFactory {

    /**
     * CacheFactory implementation class needs to implement this return underlying cache instance for method against
     * url and invocation.
     * @param url
     * @param invocation
     * @return Instance of Cache containing cached value against method url and invocation.
     */
    @Adaptive("cache")
    Cache getCache(URL url, Invocation invocation);

}

              

             

META-INF/dubbo/internal/org.apache.dubbo.cache.CacheFactory

threadlocal=org.apache.dubbo.cache.support.threadlocal.ThreadLocalCacheFactory
lru=org.apache.dubbo.cache.support.lru.LruCacheFactory
jcache=org.apache.dubbo.cache.support.jcache.JCacheFactory
expiring=org.apache.dubbo.cache.support.expiring.ExpiringCacheFactory
lfu=org.apache.dubbo.cache.support.lfu.LfuCacheFactory

                          

LruCacheFactory

public class LruCacheFactory extends AbstractCacheFactory {

    /**
     * Takes url as an method argument and return new instance of cache store implemented by LruCache.
     * @param url url of the method
     * @return ThreadLocalCache instance of cache
     */
    @Override
    protected Cache createCache(URL url) {
        return new LruCache(url);
    }   //创建LruCache

}

            

LruCache

/**
 * This class store the cache value per thread. If a service,method,consumer or provided is configured with key <b>cache</b>
 * with value <b>lru</b>, dubbo initialize the instance of this class using {@link LruCacheFactory} to store method's returns value
 * to server from store without making method call.
   //为每个线程存储缓存，service、method、consumer、provider需要配置cache=lru
   //如果缓存了值，就可使用缓存里面的数据，不触发方法调用

 * <pre>
 *     e.g. 1) &lt;dubbo:service cache="lru" cache.size="5000"/&gt;
 *          2) &lt;dubbo:consumer cache="lru" /&gt;
 * </pre>
 * <pre>
 * LruCache uses url's <b>cache.size</b> value for its max store size, if nothing is provided then
 * default value will be 1000
 * </pre>  //cache.size配置缓存个数，默认1000
 *
 * @see Cache
 * @see LruCacheFactory
 * @see org.apache.dubbo.cache.support.AbstractCacheFactory
 * @see org.apache.dubbo.cache.filter.CacheFilter
 */
public class LruCache implements Cache {

    /**
     * This is used to store cache records
     */
    private final Map<Object, Object> store;

    /**
     * Initialize LruCache, it uses constructor argument <b>cache.size</b> value as its storage max size.
     *  If nothing is provided then it will use 1000 as default value.
     * @param url A valid URL instance
     */
    public LruCache(URL url) {
        final int max = url.getParameter("cache.size", 1000);
        this.store = new LRUCache<>(max);
    }

    /**
     * API to store value against a key in the calling thread scope.
     * @param key  Unique identifier for the object being store.
     * @param value Value getting store
     */
    @Override
    public void put(Object key, Object value) {
        store.put(key, value);
    }

    /**
     * API to return stored value using a key against the calling thread specific store.
     * @param key Unique identifier for cache lookup
     * @return Return stored object against key
     */
    @Override
    public Object get(Object key) {
        return store.get(key);
    }

}

              

                  

LfuCacheFactory

public class LfuCacheFactory extends AbstractCacheFactory {

    /**
     * Takes url as an method argument and return new instance of cache store implemented by LfuCache.
     * @param url url of the method
     * @return ThreadLocalCache instance of cache
     */
    @Override
    protected Cache createCache(URL url) {
        return new LfuCache(url);
    }   //创建LfuCache缓存

}

           

LfuCache

/**
 * This class store the cache value per thread. If a service,method,consumer or provided is configured with key <b>cache</b>
 * with value <b>lfu</b>, dubbo initialize the instance of this class using {@link LfuCacheFactory} to store method's returns value
 * to server from store without making method call.
   //为每个线程存储缓存，如果service、method、consumer、provider配置cache=lfu
   //如果缓存命中，就不会触发方法调用，直接返回缓存值

 * <pre>
 *     e.g. 1) &lt;dubbo:service cache="lfu" cache.size="5000" cache.evictionFactor="0.3"/&gt;
 *          2) &lt;dubbo:consumer cache="lfu" /&gt;
 * </pre>
 * <pre>
 * LfuCache uses url's <b>cache.size</b> value for its max store size, url's <b>cache.evictionFactor</b> value for its eviction factor,
 * default store size value will be 1000, default eviction factor will be 0.3
 * </pre>  //可用cache.size设置缓存个数，默认1000
 *
 * @see Cache
 * @see LfuCacheFactory
 * @see org.apache.dubbo.cache.support.AbstractCacheFactory
 * @see org.apache.dubbo.cache.filter.CacheFilter
 */
public class LfuCache implements Cache {

    /**
     * This is used to store cache records
     */
    private final LFUCache store;

    /**
     *  Initialize LfuCache, it uses constructor argument <b>cache.size</b> value as its storage max size.
     *  If nothing is provided then it will use 1000 as default size value. <b>cache.evictionFactor</b> value as its eviction factor.
     *  If nothing is provided then it will use 0.3 as default value.
     * @param url A valid URL instance
     */
    public LfuCache (URL url) {
        final int max = url.getParameter("cache.size", 1000);
        final float factor = url.getParameter("cache.evictionFactor", 0.75f);
        this.store = new LFUCache(max, factor);
    }

    /**
     * API to store value against a key in the calling thread scope.
     * @param key  Unique identifier for the object being store.
     * @param value Value getting store
     */
    @Override
    public void put(Object key, Object value) {
        store.put(key, value);
    }

    /**
     * API to return stored value using a key against the calling thread specific store.
     * @param key Unique identifier for cache lookup
     * @return Return stored object against key
     */
    @Override
    public Object get(Object key) {
        return store.get(key);
    }

}

           

             

JCacheFactory

/**
 * JCacheFactory is factory class to provide instance of javax spi cache.Implement {@link org.apache.dubbo.cache.CacheFactory} by
 * extending {@link AbstractCacheFactory} and provide
 * @see AbstractCacheFactory
 * @see JCache
 * @see org.apache.dubbo.cache.filter.CacheFilter
 * @see Cache
 * @see CachingProvider
 * @see javax.cache.Cache
 * @see javax.cache.CacheManager
 */
public class JCacheFactory extends AbstractCacheFactory {

    /**
     * Takes url as an method argument and return new instance of cache store implemented by JCache.
     * @param url url of the method
     * @return JCache instance of cache
     */
    @Override
    protected Cache createCache(URL url) {
        return new JCache(url);
    }

}

           

JCache

/**
 * This class store the cache value per thread. If a service,method,consumer or provided is configured with key <b>cache</b>
 * with value <b>jcache</b>, dubbo initialize the instance of this class using {@link JCacheFactory} to store method's returns value
 * to server from store without making method call.
 *
 * @see Cache
 * @see JCacheFactory
 * @see org.apache.dubbo.cache.support.AbstractCacheFactory
 * @see org.apache.dubbo.cache.filter.CacheFilter
 */
public class JCache implements org.apache.dubbo.cache.Cache {

    private final Cache<Object, Object> store;

    public JCache(URL url) {
        String method = url.getParameter(METHOD_KEY, "");
        String key = url.getAddress() + "." + url.getServiceKey() + "." + method;
        // jcache parameter is the full-qualified class name of SPI implementation
        String type = url.getParameter("jcache");

        CachingProvider provider = StringUtils.isEmpty(type) ? Caching.getCachingProvider() : Caching.getCachingProvider(type);
        CacheManager cacheManager = provider.getCacheManager();
        Cache<Object, Object> cache = cacheManager.getCache(key);
        if (cache == null) {
            try {
                //configure the cache
                MutableConfiguration config =
                        new MutableConfiguration<>()
                                .setTypes(Object.class, Object.class)
                                .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.MILLISECONDS, url.getMethodParameter(method, "cache.write.expire", 60 * 1000))))
                                .setStoreByValue(false)
                                .setManagementEnabled(true)
                                .setStatisticsEnabled(true);
                cache = cacheManager.createCache(key, config);
            } catch (CacheException e) {
                // concurrent cache initialization
                cache = cacheManager.getCache(key);
            }
        }

        this.store = cache;
    }

    @Override
    public void put(Object key, Object value) {
        store.put(key, value);
    }

    @Override
    public Object get(Object key) {
        return store.get(key);
    }

}

           

             

ExpiringCacheFactory

public class ExpiringCacheFactory extends AbstractCacheFactory {

    /**
     * Takes url as an method argument and return new instance of cache store implemented by JCache.
     * @param url url of the method
     * @return ExpiringCache instance of cache
     */
    @Override
    protected Cache createCache(URL url) {
        return new ExpiringCache(url);
    }   //创建ExpiringCache
}

            

ExpiringCache

/**
 * This class store the cache value with the characteristic of expiration time. If a service,method,consumer or provided is configured with key <b>cache</b>
 * with value <b>expiring</b>, dubbo initialize the instance of this class using {@link ExpiringCacheFactory} to store method's returns value
 * to server from store without making method call.
 * <pre>
 *     e.g. 1) &lt;dubbo:service cache="expiring" cache.seconds="60" cache.interval="10"/&gt;
 *          2) &lt;dubbo:consumer cache="expiring" /&gt;
 * </pre>
   //使用cache="expiring"配置expiring缓存

 * <li>It used constructor argument url instance <b>cache.seconds</b> value to decide time to live of cached object.Default value of it is 180 second.</li>
 * <li>It used constructor argument url instance <b>cache.interval</b> value for cache value expiration interval.Default value of this is 4 second</li>
      //cache.seconds：缓存过期时间，默认180s
      //cache.interval：缓存过期时间检查间隔，默认为4s

 * @see Cache
 * @see ExpiringCacheFactory
 * @see org.apache.dubbo.cache.support.AbstractCacheFactory
 * @see org.apache.dubbo.cache.filter.CacheFilter
 */
public class ExpiringCache implements Cache {
    private final Map<Object, Object> store;    //使用map存储缓存

    public ExpiringCache(URL url) {
        // cache time (second)
        final int secondsToLive = url.getParameter("cache.seconds", 180);
        // Cache check interval (second)
        final int intervalSeconds = url.getParameter("cache.interval", 4);
        ExpiringMap<Object, Object> expiringMap = new ExpiringMap<>(secondsToLive, intervalSeconds);
        expiringMap.getExpireThread().startExpiryIfNotStarted();
        this.store = expiringMap;
    }

    /**
     * API to store value against a key in the calling thread scope.
     * @param key  Unique identifier for the object being store.
     * @param value Value getting store
     */
    @Override
    public void put(Object key, Object value) {
        store.put(key, value);
    }

    /**
     * API to return stored value using a key against the calling thread specific store.
     * @param key Unique identifier for cache lookup
     * @return Return stored object against key
     */

    @Override
    public Object get(Object key) {
        return store.get(key);
    }

}

             

              

ThreadLocalCacheFactory

public class ThreadLocalCacheFactory extends AbstractCacheFactory {

    /**
     * Takes url as an method argument and return new instance of cache store implemented by ThreadLocalCache.
     * @param url url of the method
     * @return ThreadLocalCache instance of cache
     */
    @Override
    protected Cache createCache(URL url) {
        return new ThreadLocalCache(url);
    }   //创建ThreadLocalCache

}

          

ThreadLocalCache

/**
 * This class store the cache value per thread. If a service,method,consumer or provided is configured with key <b>cache</b>
 * with value <b>threadlocal</b>, dubbo initialize the instance of this class using {@link ThreadLocalCacheFactory} to store method's returns value
 * to server from store without making method call.
 *  <pre>
 *      e.g. &lt;dubbo:service cache="threadlocal" /&gt;
 *  </pre>  //使用cache="threadlocal"配置使用threadlocal缓存

 * <pre>
 * As this ThreadLocalCache stores key-value in memory without any expiry or delete support per thread wise, if number threads and number of key-value are high then jvm should be
 * configured with appropriate memory.
 * </pre>
   //threadlocal在内存中存储缓存，没有过期和删除策略，
   //如果线程数很大、或者缓存数据很多，应该设置一个合适的jvm内存

 *
 * @see org.apache.dubbo.cache.support.AbstractCacheFactory
 * @see org.apache.dubbo.cache.filter.CacheFilter
 * @see Cache
 */
public class ThreadLocalCache implements Cache {

    /**
     * Thread local variable to store cached data.
     */
    private final ThreadLocal<Map<Object, Object>> store;  //每个线程使用map存储缓存

    /**
     * Taken URL as an argument to create an instance of ThreadLocalCache. In this version of implementation constructor
     * argument is not getting used in the scope of this class.
     * @param url
     */
    public ThreadLocalCache(URL url) {
        this.store = ThreadLocal.withInitial(HashMap::new);
    }

    /**
     * API to store value against a key in the calling thread scope.
     * @param key  Unique identifier for the object being store.
     * @param value Value getting store
     */
    @Override
    public void put(Object key, Object value) {
        store.get().put(key, value);
    }

    /**
     * API to return stored value using a key against the calling thread specific store.
     * @param key Unique identifier for cache lookup
     * @return Return stored object against key
     */
    @Override
    public Object get(Object key) {
        return store.get().get(key);
    }

}

            

                   

                                     

实现原理

      

CacheFilter：服务端、消费端均可设置缓存

@Activate(group = {CONSUMER, PROVIDER}, value = CACHE_KEY)
public class CacheFilter implements Filter {

    private CacheFactory cacheFactory;

    /**
     * Dubbo will populate and set the cache factory instance based on service/method/consumer/provider configured
     * cache attribute value. Dubbo will search for the class name implementing configured <b>cache</b> in file org.apache.dubbo.cache.CacheFactory
     * under META-INF sub folders.
     *
     * @param cacheFactory instance of CacheFactory based on <b>cache</b> type
     */
    public void setCacheFactory(CacheFactory cacheFactory) {
        this.cacheFactory = cacheFactory;
    }

    /**
     * If cache is configured, dubbo will invoke method on each method call. If cache value is returned by cache store
     * then it will return otherwise call the remote method and return value. If remote method's return value has error
     * then it will not cache the value.
     * @param invoker    service
     * @param invocation invocation.
     * @return Cache returned value if found by the underlying cache store. If cache miss it will call target method.
     * @throws RpcException
     */
    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        if (cacheFactory != null && ConfigUtils.isNotEmpty(invoker.getUrl().getMethodParameter(invocation.getMethodName(), CACHE_KEY))) {
            Cache cache = cacheFactory.getCache(invoker.getUrl(), invocation);
                                       //获取缓存
            if (cache != null) {       //如果缓存不为null，查找缓存中是否有对应的值
                String key = StringUtils.toArgumentString(invocation.getArguments()); //用方法参数创建key
                Object value = cache.get(key);  
                if (value != null) {   
                    if (value instanceof ValueWrapper) {
                        return AsyncRpcResult.newDefaultAsyncResult(((ValueWrapper) value).get(), invocation);
                    } else {
                        return AsyncRpcResult.newDefaultAsyncResult(value, invocation);
                    }  //如果有对应的value，直接返回value，不发起方法调用
                }
                Result result = invoker.invoke(invocation);  //如果缓存中没有对应的value，发起远程调用
                if (!result.hasException()) {
                    cache.put(key, new ValueWrapper(result.getValue()));
                }
                return result;
            }
        }
        return invoker.invoke(invocation);  //如果没有设置缓存，直接发起方法调用
    }

    /**
     * Cache value wrapper.
     */
    static class ValueWrapper implements Serializable {

        private static final long serialVersionUID = -1777337318019193256L;

        private final Object value;

        public ValueWrapper (Object value) {
            this.value = value;
        }

        public Object get() {
            return this.value;
        }
    }
}

              

               

                                     

使用示例

        

*************

服务端

       

                   

          

application.yml

dubbo:
  application:
    name: dubbo-provider
    #register-mode: instance
  registry:
    address: localhost:2181
    protocol: zookeeper
    group: dubbo
  protocol:
    name: dubbo
    #port: 20880

          

HelloService

public interface HelloService {

    String get(Integer id);
}

         

HelloServiceImpl

@DubboService
public class HelloServiceImpl implements HelloService {

    @Override
    public String get(Integer id) {
        System.out.println("hello");

        return "hello";
    }
}

          

*************

消费端

     

                   

          

application.yml

dubbo:
  application:
    name: dubbo-consumer
  registry:
    protocol: zookeeper
    address: localhost:2181
    group: dubbo
    #register-mode: instance
  protocol:
    name: dubbo
    #port: 20880

server:
  port: 8081

            

HelloService

public interface HelloService {

    String get(Integer id);
}

            

HelloController

@RestController
public class HelloController {

    @DubboReference(cache = "lru")
    private HelloService helloService;

    @RequestMapping("/hello")
    public String hello(){
        helloService.get(1);
        helloService.get(1);
        helloService.get(1);
        helloService.get(1);
        helloService.get(1);
        helloService.get(1);

        return "hello";
    }
}

                      

*************

使用测试

     

localhost:8081/hello：cacheFilter缓存的key为1，value包含查询结果

              

                

                    

o_瓜田李下_o
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dubbo+zookeeper缓存方案
06-03
dubbo+zookeeper缓存方案 dubbo+zookeeper缓存方案dubbo+zookeeper缓存方案dubbo+zookeeper缓存方案
dubbo-cache:@DubboCache提供dubbo消费者直接使用缓存的能力，当缓存不存在时，再访问远程dubbo服务
04-27
@DubboCache 提供dubbo消费者直接使用缓存的能力，当缓存不存在时，再访问远程dubbo服务。 相对于dubbo默认的缓存机制，此项目具有如下优点： 原生dubbo cache机制只能缓存结果到消费者jvm中，并且cache key不能选择。 缓存key生成灵活，和spring 声明式缓存一致，采用spring el表达式 可以扩展CacheKeyValidator接口，实现键缓存策略 可以扩展CacheValueValidator接口，实现值缓存策略 由于采用分布式缓存，服务提供端可以灵活控制缓存 目前仅提供redis实现，依赖spring-data-redis. 使用@DubboCache 在服务接口模块中依赖dubbo-cache-common <dependency> <groupId>com.github.bohrqiu.dubbo</groupId> <arti
dubbo.cache is not exclusive. Maybe multiple Dubbo instances are using the same folder. 错误解决
applebomb的专栏
02-14 294
dubbo.cache is not exclusive. Maybe multiple Dubbo instances are using the same folder. 错误解决
dubbo 缓存的使用和实现解析
weixin_34023863的博客
04-04 1120
2019独角兽企业重金招聘Python工程师标准>>> ...
dubbo系列二：dubbo常用功能总结(2)
进击30K的专栏
05-08 304
8. 结果缓存 缓存类型lru 基于最近最少使用原则删除多余缓存，保持最热的数据被缓存。 LRU的缺省cache.size为1000，执行1001次，会把最开始请求的缓存结果清除掉 在生产者dubbo-provider-web和消费者dubbo-consumer-web分别新建一个接口 package com.study.service; /** * * @Description: 结果缓存接口 * @author leeSmall * @date 2018年10月24日 *
dubbo结果缓存机制
weixin_33862188的博客
11-16 558
此文已由作者赵计刚授权网易云社区发布。 欢迎访问网易云社区，了解更多网易技术产品运营经验。dubbo提供了三种结果缓存机制：lru：基于最近最少使用原则删除多余缓存，保持最热的数据被缓存threadlocal：当前线程缓存jcache：可以桥接各种缓存实现一、使用方式1     &lt;dubbo:reference id="demoService" check="false" interface...
解决Dubbo 本地启动多个应用的缓存冲突问题
飞一站的博客
01-19 876
解决Dubbo 本地启动多个应用的缓存冲突问题
dubbo解析-服务结果缓存Cache实现类原理详解
龚厂长的博客
04-27 994
Cache的实现类也有四个：ThreadLocalCache、ExpiringCache、LruCache、JCache。 LruCache LruCache按照最近最少使用原则删除多余缓存。 public LruCache(URL url) { final int max = url.getParameter("cache.size", 1000); this.s...
Dubbo高级篇_13_Dubbo缓存
热门推荐
君子敏于行而讷于言
07-30 2万+
结果缓存，用于加速热门数据的访问速度， Dubbo提供声明式缓存，以减少用户加缓存的工作量。 按照SPI的要求，我们从配置文件中可以看到dubbo提供的三种缓存接口的入口： threadlocal=com.alibaba.dubbo.cache.support.threadlocal.ThreadLocalCacheFactory lru=com.alibaba.dubbo.cache...
Dubbo 服务本地缓存
huotongwangbs的专栏
10-15 4469
开篇 根据官方图，dubbo调用者需要通过注册中心（例如：ZK）注册信息，获取提供者，但是如果频繁往ZK获取信息，肯定会存在单点故障问题，所以dubbo提供了将提供者信息缓存在本地的方法。 Dubbo在订阅注册中心的回调处理逻辑当中会保存服务提供者信息到本地缓存文件当中（同步/异步两种方式），以url纬度进行全量保存。 Dubbo在服务引用过程中会创建registry对象并加载本地缓存文件，会优先订阅注册中心，订阅注册中心失败后会访问本地缓存文件内容获取服务提供信息。 核心
dubbo处理自定义异常
weixin_55850954的博客
05-20 1800
在实际项目中，我们不可避免地需要使用自定义的异常，一般这个异常会继承RuntimeException，然后我们通过@RestControllerAdvice注解，拦截业务异常类，做一些处理，但是在使用dubbo构建项目时，会发现provider抛出自定义异常，然后在消费者端，不会捕捉到我们的自定义异常，而是以RuntimeException的形式被捕获。
dubbo-dubbo
10-17
注册中心和监控中心全部宕机，不影响已运行的提供者和消费者，消费者在本地缓存了提供者列表 注册中心和监控中心都是可选的，服务消费者可以直连服务提供者 (2) 健壮性： 监控中心宕掉不影响使用，只是丢失部分采样...
dubbo接口测试调试工具
07-25
前段时间排查某问题的时候，想要快速知道某些dubbo接口（三无）的响应结果，但不想启动项目（因为这些项目不是你负责的，不会部署而且超级笨重），也不想新建一个dubbo客户端项目（占地方），也不想开telnet客户端...
Dubbo面试题.zip
02-14
可以通信的，启动 dubbo 时，消费者会从 zk 拉取注册的生产者的地址接口等数据，缓存在本地。每次调用时，按照本 地存储的地址进行调用； 注册中心对等集群，任意一台宕机后，将会切换到另一台；注册中心全部宕机后...
2024-2030全球与中国低脂凝乳奶酪市场现状及未来发展趋势.docx
04-30
2024-2030全球与中国低脂凝乳奶酪市场现状及未来发展趋势
毕业设计：vue+springboot乌鲁木齐南山冰雪旅游服务网站（源码 + 数据库 + 说明文档）
04-30
毕业设计：vue+springboot乌鲁木齐南山冰雪旅游服务网站（源码 + 数据库 + 说明文档） 2 开发工具及技术 2 2.1 B/S结构的介绍 2 2.2 JSP及SpringBoot技术的介绍 2 2.3 HTML及Vue技术的介绍 2 2.4 MYSQL数据库的介绍 3 2.5 开发环境的介绍 3 3 需求分析 4 3.1 可行性分析 4 3.2 功能需求分析 4 3.3 非功能需求分析 4 4 总体设计 6 4.1 系统总体结构设计 6 4.2 系统的数据库设计 6 5 系统功能实现 6 5.1 注册用户 6 5.2 管理员用户 6 6 系统测试 6 6.1 测试目的 6 6.2 测试内容 6 6.3 测试总结 6
C# 超简单的离线人脸识别库 ( 基于 SeetaFace6 ).zip
04-30
c
华为数字化转型实践28个精华问答.docx
最新发布
04-30
华为数字化转型实践28个精华问答.docx
2024年全球二极管阵列光谱仪行业总体规模、主要企业国内外市场占有率及排名.docx
04-30
2024年全球二极管阵列光谱仪行业总体规模、主要企业国内外市场占有率及排名
dubbo缓存怎么使用
08-17
### 回答1： Dubbo缓存可以帮助加快应用程序的性能，可以将数据存储在本地缓存中，以减少数据访问的次数，从而提高性能。可以通过配置Dubbo的缓存服务来使用缓存，例如使用Ehcache、Redis或Memcache。 ### 回答2： Dubbo是一款分布式框架，它支持缓存来提高系统的性能和响应速度。在Dubbo中，可以通过配置和编程的方式来使用缓存。 在配置上，可以通过在服务提供者的配置文件中为服务方法开启缓存。可以指定缓存策略、缓存类型、缓存的有效时间等参数。在Dubbo的缓存策略中，可以分为：设置缓存粒度为方法级别和接口级别。方法级别的缓存可以针对具体的方法进行缓存，而接口级别的缓存可以对整个接口进行缓存。可以根据具体的业务需求来选择合适的缓存策略。 在编程上，可以在服务提供者的实现类中手动添加缓存的逻辑。可以使用Dubbo提供的缓存API，在方法调用的前后来获取和设置缓存的数据。通过在方法的实现中先判断缓存中是否存在数据，如果存在则直接返回缓存数据，如果不存在则进行业务逻辑处理，并将结果存入缓存中。这样可以避免重复计算，提高系统的性能和响应速度。 在使用Dubbo缓存时，需要注意以下几点： 1. 需要根据具体的业务场景来选择合适的缓存策略和缓存类型。 2. 需要设置合理的缓存有效时间，避免数据过期或者缓存数据过多导致内存溢出。 3. 需要保证缓存的一致性，即在数据发生变化时及时更新缓存。 4. 需要合理配置缓存的大小和存储位置，以充分利用系统资源。 总之，Dubbo提供了灵活且易用的缓存机制，可以根据实际需要来使用和配置，从而提高系统的性能和响应速度。 ### 回答3： Dubbo是一款高性能的Java开源分布式服务框架，它提供了缓存功能来加速远程服务的访问速度。在Dubbo中，我们可以使用以下两种方式来使用缓存。 1. 服务提供方缓存： 在Dubbo服务提供方，我们可以通过在服务接口的方法上添加`cache`注解来启用缓存功能。例如： ```java @Service public class UserServiceImpl implements UserService { @Override @Cacheable(cache = "userCache") public User getUserById(int userId) { // 从数据库或其他数据源中获取用户信息 // ... } } ``` 在上述代码中，我们在`getUserById`方法上添加了`Cacheable`注解，并指定了缓存名称为`userCache`。这样在调用该方法时，Dubbo会自动将返回结果缓存起来，下次再次调用时直接从缓存中获取结果，避免了重复的查询操作，提高了性能。 2. 服务消费方缓存： 在Dubbo服务消费方，我们可以通过在`reference`元素中配置`cache`元素来启用缓存功能。例如： ```xml <dubbo:reference id="userService" interface="com.example.UserService"> <dubbo:method name="getUserById" cache="userCache" /> </dubbo:reference> ``` 在上述代码中，我们通过配置`cache`属性并指定缓存名称为`userCache`，来开启缓存功能。这样在调用`userService`的`getUserById`方法时，Dubbo会自动将返回结果缓存起来，下次再次调用时直接从缓存中获取结果。 无论是服务提供方缓存还是服务消费方缓存，我们都需要借助缓存框架来实现具体的缓存功能，Dubbo本身并不提供具体的缓存实现。在实际使用中，可以选择使用一些常见的缓存框架，例如Ehcache、Redis等来实现Dubbo缓存。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值