docs: public Object proceed(CacheAopProxyChain pjp, Cache cache) throws Throwable {
          Object[] arguments = pjp.getArgs();
          CacheOpType opType = getCacheOpType(cache, arguments);
          if (log.isTraceEnabled()) {
              log.trace("CacheHandler.proceed-->{}.{}--{})", pjp.getTarget().getClass().getName(), pjp.getMethod().getName(), opType.name());
          }
          if (opType == CacheOpType.WRITE) {
              return writeOnly(pjp, cache);
          } else if (opType == CacheOpType.LOAD || !scriptParser.isCacheable(cache, pjp.getTarget(), arguments)) {
              return getData(pjp);
          }
          Method method = pjp.getMethod();
          if (MagicHandler.isMagic(cache, method)) {
              return new MagicHandler(this, pjp, cache).magic();
          }
  
          CacheKeyTO cacheKey = getCacheKey(pjp, cache);
          if (null == cacheKey) {
              return getData(pjp);
          }
          CacheWrapper<Object> cacheWrapper = null;
          try {
              // 从缓存中获取数据
              cacheWrapper = this.get(cacheKey, method);
          } catch (Exception ex) {
              log.error(ex.getMessage(), ex);
          }
          if (log.isTraceEnabled()) {
              log.trace("cache key:{}, cache data is {} ", cacheKey.getCacheKey(), cacheWrapper);
          }
          if (opType == CacheOpType.READ_ONLY) {
              return null == cacheWrapper ? null : cacheWrapper.getCacheObject();
          }
  
          if (null != cacheWrapper && !cacheWrapper.isExpired()) {
              AutoLoadTO autoLoadTO = autoLoadHandler.putIfAbsent(cacheKey, pjp, cache, cacheWrapper);
              if (null != autoLoadTO) {
                  autoLoadTO.flushRequestTime(cacheWrapper);
              } else {
                  // 如果缓存快要失效，则自动刷新
                  refreshHandler.doRefresh(pjp, cache, cacheKey, cacheWrapper);
              }
              return cacheWrapper.getCacheObject();
          }
          DataLoaderFactory factory = DataLoaderFactory.getInstance();
          DataLoader dataLoader = factory.getDataLoader();
          CacheWrapper<Object> newCacheWrapper = null;
          long loadDataUseTime = 0L;
          boolean isFirst;
          try {
              newCacheWrapper = dataLoader.init(pjp, cacheKey, cache, this).loadData().getCacheWrapper();
              isFirst = dataLoader.isFirst();
              loadDataUseTime = dataLoader.getLoadDataUseTime();
          } catch (Throwable e) {
              throw e;
          } finally {
              factory.returnObject(dataLoader);
          }
          if (isFirst) {
              AutoLoadTO autoLoadTO = autoLoadHandler.putIfAbsent(cacheKey, pjp, cache, newCacheWrapper);
              try {
                  writeCache(pjp, pjp.getArgs(), cache, cacheKey, newCacheWrapper);
                  if (null != autoLoadTO) {
                      autoLoadTO.flushRequestTime(newCacheWrapper);
                      autoLoadTO.addUseTotalTime(loadDataUseTime);
                  }
              } catch (Exception ex) {
                  log.error(ex.getMessage(), ex);
              }
          }
  
          return newCacheWrapper.getCacheObject();
      }