zoukankan      html  css  js  c++  java
  • Java注解@Cacheable的工作原理

    In order to avoid unnecessary query on database it is a common pattern to define a cache in application layer to cache the query result from database. See one example below. Here the application cache is maintained in a custom class CacheContext.

    public class AccountService1 {
        private final Logger logger = LoggerFactory.getLogger(AccountService1.class);
        
        private CacheContext<Account> accountCacheContext;
     
        public Account getAccountByName(String accountName) {
            Account result = accountCacheContext.get(accountName);
            if (result != null) {
                logger.info("get from cache... {}", accountName);
                return result;
            }
     
            Optional<Account> accountOptional = getFromDB(accountName);
            if (!accountOptional.isPresent()) {
                throw new IllegalStateException(String.format("can not find account by account name : [%s]", accountName));
            }
     
            Account account = accountOptional.get();
            accountCacheContext.addOrUpdateCache(accountName, account);
            return account;
        }
    

    In Spring there is an annotation @Cacheable which can make the cache managed by Spring instead of application developer. See improved version:

    
    public class AccountService2 {
     
        private final Logger logger = LoggerFactory.getLogger(AccountService2.class);
    
        @Cacheable(value="accountCache")
        public Account getAccountByName(String accountName) {
            logger.info("in method getAccountByName, querying account... {}", accountName);
            Optional<Account> accountOptional = getFromDB(accountName);
            if (!accountOptional.isPresent()) {
                throw new IllegalStateException(String.format("can not find account by account name : [%s]", accountName));
            }
            return accountOptional.get();
        }
    

    In this example, there is no more cache evaluation and cache fill logic. All such stuff are taken over by Spring under the hood and completely transparent to application developer, with the help of following bean configuration in xml:

    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
    		<property name="caches">
    			<set>
    				<bean
    					class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
    					<property name="name" value="default" />
    				</bean>
    				<bean
    					class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
    					<property name="name" value="accountCache" />
    				</bean>
    			</set>
    		</property>
    	</bean>
    

    And how to research what magic has been done by Spring to achieve this behavior?
    We use the following code to research. It is expected that the request sent by line 31 will directly reach database, while the second request in line 34 will be handled by Spring cache handler.

    Here in line 31, in debugger we can find that accountService2 is not an instance of application class com.sap.AccountService2, but a dynamic proxy class generated by Spring.

    As a result after pressing F5, the intercept method of this dynamic proxy class is called:

    In this method, the execution will be delegated to Spring cache handler class:


    In example 1, the logic of cache evaluation and fill is done by application, and now it is done in method execute below.

    First internal cache managed by Spring is checked in line 336 via method findCachedItem. Due to expected cache miss, our application method will be called as usual via reflection, as demonstrated below:

    After application method to retrieve account from database is done, the result, Account instance with id 2495 is filled to Spring cache, the variable contexts below.

    Below is the screenshot for Spring internal cache to store application data, which is based on ConcurrentHashMap. Our cached Account instance with id 2495 could be found there.


    For the second query request issued by application, the cached result will be returned by Spring handler:

    The last question is, how and when the dynamic proxy is generated?
    Again let’s go to the entry point of Beans initialization:


    Here the dynamic proxy is created based on configuration defined in xml with the help of CGlibAopProxy. For more detail about CGlibAopProxy, please refer to Spring official document.

    要获取更多Jerry的原创文章,请关注公众号"汪子熙":

  • 相关阅读:
    unity 编辑器模拟Pause
    1.项目委托类参考 2.wiki unity 参考库
    unity excel导出json 并解析 存在项目 dict内
    技能子弹精确化 使用int个数进行度量比较好
    lua 程序设计 面向对象 赋值后字段申请了新的空间
    圆和射线相交 矩形和射线相交判断 lua
    DX11 DX10 DWORD 和WORD
    dx11 入门 Tutorial 06: 明白context->updateSubsource和setConstantBuffers DirectXSampleBrowser(June 2010)
    dx11 入门 Tutorial 05: DepthBuffer的创建 DirectXSampleBrowser(June 2010)
    dx11 入门 Tutorial 04: DX、HLSL中矩阵的内存存储和数学计算方式 DirectXSampleBrowser(June 2010)
  • 原文地址:https://www.cnblogs.com/sap-jerry/p/12845588.html
Copyright © 2011-2022 走看看