是否可以自动加载

@param cache     Cache 注解
@param target    AOP 拦截到的实例
@param arguments 参数
@param retVal    return value
@return autoload 是否自动加载
@throws Exception 异常
19858
public boolean isAutoload(Cache cache, Object target, Object[] arguments, Object retVal) throws Exception {
        if (cache.opType() == CacheOpType.WRITE) {
            return false;
        }
        boolean autoload = cache.autoload();
        if (null != arguments && arguments.length > 0 && null != cache.autoloadCondition()
                && cache.autoloadCondition().length() > 0) {
            autoload = this.getElValue(cache.autoloadCondition(), target, arguments, retVal, true, Boolean.class);
        }
        return autoload;
    }
599286
public final Cache2kBuilder<K, V> retryInterval(long v, TimeUnit u) {
    config().setRetryInterval(u.toMillis(v));
    return this;
  }
950961
function loadMultiple ( map, baseUrl, cache ) {
	var promise = new Promise( function ( resolve, reject ) {
		var pending = 0, result = {}, name, load;

		load = function ( name ) {
			var path = map[ name ];

			loadSingle( path, baseUrl, baseUrl, cache ).then( function ( Component ) {
				result[ name ] = Component;

				if ( !--pending ) {
					resolve( result );
				}
			}, reject );
		};

		for ( name in map ) {
			if ( map.hasOwnProperty( name ) ) {
				pending += 1;
				load( name );
			}
		}
	});

	return promise;
}
41109
public static void addToCache(HttpServletRequest req, RequestProcessor s, WebApp app) {
        //Begin 253010  
        // check if cache is full
        if (_cacheSize.get() >= invocationCacheSize) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) //306998.15
            {
                logger.logp(Level.FINE, CLASS_NAME, "addToCache", "cache is full");
            }
            return;
        }

        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) //306998.15
        {
            logger.logp(Level.FINE, CLASS_NAME, "addToCache", "WebApp = " + app);
        }

        // PK80333 Start
        if (app.getDestroyed()) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) //306998.15
            {
                logger.logp(Level.FINE, CLASS_NAME, "addToCache", "Not caching as the webapp is destroyed");
            }
            return;
        }
        // PK80333 End

        StringBuilder cacheKey = (StringBuilder) cacheKeyStringBuilder.get();
        if (cacheKey == null) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) //306998.15
            {
                logger.logp(Level.FINE, CLASS_NAME, "addToCache", "cache key is null");
            }
            return;
        }
        String cacheKeyStr = cacheKey.toString();
        // Servlet 4.0 : Use CacheServletWrapperFactory
        CacheServletWrapper wrapper =  cacheServletWrapperFactory.createCacheServletWrapper((IServletWrapper) s, req, cacheKeyStr, app);
        if (_cacheMap.putIfAbsent(cacheKeyStr, wrapper) != null) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) //306998.15
            {
                logger.logp(Level.FINE, CLASS_NAME, "addToCache", "Already cached cacheKey --> " + cacheKey);
            }
        } else {
            ((IServletWrapper)s).addServletReferenceListener(wrapper);
            // keep a rough count of the number of items in the cache
            _cacheSize.incrementAndGet();
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) //306998.15 
            {
                logger.logp(Level.FINE, CLASS_NAME, "addToCache", "Added to cache cacheKey --> " + cacheKey + " uri -->" + req.getRequestURI() + " servletWrapper -->"
                                                                      + ((IServletWrapper) s).getServletName());
            }
        }
        // End 253010
    }
207651
protected function call( $arguments, &$retval = null ) {
		if ( !is_array( $arguments ) ) {
			$arguments = func_get_args();
		}

		array_unshift( $arguments, $this->gpgBinary, '--no-options', '--homedir',
			$this->homeDir->getPath(), '--batch', '--yes', '--trust-model', 'always' );

		return call_user_func_array( $this->exec, array( $arguments, &$retval ) );
	}
220527
public Object doSetHandle(Object bookmark, int iOpenMode, String strFields, int iHandleType) throws DBException, RemoteException
    {
        m_objCurrentCacheRecord = NONE;
        m_objCurrentLockedRecord = NONE;
        try {   // This caching logic is exactly the same as seek caching.
            Object objData = null;
            if ((m_mapCache == null) && (m_htCache == null))
                m_htCache = new Hashtable<Object,Object>();    // Okay, start caching keys and records
            if (m_htCache != null)
            {
                if (bookmark instanceof Integer)
                    objData = m_htCache.get(bookmark);    // Try to find this in the cache
            }
            m_mapCache = null;  // If seek is used, the grid cache is no good anymore.
            if (objData != null)
                m_objCurrentCacheRecord = bookmark;   // Current data is Cached
            if (objData == null)
            {
                m_objCurrentPhysicalRecord = NONE;
                objData = m_tableRemote.doSetHandle(bookmark, iOpenMode, strFields, iHandleType);
                if (objData instanceof Vector)
                    if (m_htCache != null)
                {
                    m_objCurrentPhysicalRecord = bookmark;    // Current data is current
                    m_objCurrentCacheRecord = bookmark;
                    m_htCache.put(bookmark, objData);
                }
            }
            return objData;
        } catch (RemoteException ex) {
            throw ex;
        }
    }
1035827
public Object invoke(Object target, String... args) throws Exception
    {
        if (getter || method.getParameterTypes().length == 0)
        {
            return method.invoke(target);
        }
        else
        {
            Object[] values = TypeConversion.convert(args, method.getParameterTypes());

            return method.invoke(target, values);
        }
    }
855900
protected boolean onCacheMiss(T target) {
        boolean cached = matcher.matches(target);
        map.put(target, cached);
        return cached;
    }
808040
public static Object invokeTarget(Object target, Method method, Object[] args,
			final String requestName) throws IllegalAccessException, InvocationTargetException {
		boolean systemError = false;
		try {
			SERVICES_COUNTER.bindContextIncludingCpu(requestName);
			return method.invoke(target, args);
		} catch (final InvocationTargetException e) {
			if (e.getCause() instanceof Error) {
				// on catche Error pour avoir les erreurs systèmes
				// mais pas Exception qui sont fonctionnelles en général
				systemError = true;
			}
			throw e;
		} finally {
			// on enregistre la requête dans les statistiques
			SERVICES_COUNTER.addRequestForCurrentContext(systemError);
		}
	}
1128544
@SuppressWarnings("unchecked")
    protected <T> T getFromCache(String cacheName, String key, Class<T> clazz) {
        Object obj = getFromCache(cacheName, key);
        if (obj == null) {
            return null;
        }
        if (clazz.isAssignableFrom(obj.getClass())) {
            return (T) obj;
        }
        return null;
    }
510686
public static <R> Retryer<R> of(Callable<R> target) {
        return new Retryer<R>(target);
    }
395386
@SuppressWarnings({ "unchecked" })
    /* package */<T> HystrixCachedObservable<T> get(String cacheKey) {
        ValueCacheKey key = getRequestCacheKey(cacheKey);
        if (key != null) {
            ConcurrentHashMap<ValueCacheKey, HystrixCachedObservable<?>> cacheInstance = requestVariableForCache.get(concurrencyStrategy);
            if (cacheInstance == null) {
                throw new IllegalStateException("Request caching is not available. Maybe you need to initialize the HystrixRequestContext?");
            }
            /* look for the stored value */
            return (HystrixCachedObservable<T>) cacheInstance.get(key);
        }
        return null;
    }
1172189
@SuppressWarnings("unchecked")
  @Override
  public <T> T get(final Object key, final Callable<T> valueLoader) {
    try {
      return (T) cache.computeIfAbsent(key, (Callable<Object>) valueLoader);
    } catch (RuntimeException ex) {
      throw new ValueRetrievalException(key, valueLoader, ex);
    }
  }
1315241
public static Object loadInstance(Class clazz, Object[] args, Object defaultValue) {
	if (args == null || args.length == 0) return loadInstance(clazz, defaultValue);
	try {
	    Class[] cArgs = new Class[args.length];
	    for (int i = 0; i < args.length; i++) {
		if (args[i] == null) cArgs[i] = Object.class;
		else cArgs[i] = args[i].getClass();
	    }
	    Constructor c = clazz.getConstructor(cArgs);
	    return c.newInstance(args);

	}
	catch (Throwable t) {
	    ExceptionUtil.rethrowIfNecessary(t);
	    return defaultValue;
	}

    }
170969
protected void refreshItem(CacheItem item, Cache cache) throws Exception {
        CacheLoader loader = item.getLoader();
        Object[] loaderParams = item.getLoaderParams();

        if (loader == null) {
            throw new InternalCacheEngineException("No cache loader for " + getScopeAndKeyString(item));
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Refreshing " + getScopeAndKeyString(item));
        }

        Object newValue = loader.load(loaderParams);
        if (newValue != null) {
            cache.put(item.getScope(), item.getKey(), newValue, item.getTicksToExpire(), item.getTicksToRefresh(),
                      item.getLoader(), item.getLoaderParams());
        } else {
            // If newValue returned is null, remove the item from the cache
            cache.remove(item.getScope(), item.getKey());
        }
    }
762907
public Object execute(TargetMetaDef targetMetaDef, MethodMetaArgs methodMetaArgs, AppContextWrapper acw) throws Exception {
		Debug.logVerbose("[JdonFramework]enter service execution core ", module);
		userTargetMetaDefFactory.createTargetMetaRequest(targetMetaDef, acw);
		TargetMetaRequest targetMetaRequest = userTargetMetaDefFactory.targetMetaRequestsHolder.getTargetMetaRequest();
		targetMetaRequest.setMethodMetaArgs(methodMetaArgs);
		return webServiceAccessor.execute();
	}
727061
@SuppressWarnings("unchecked")
    public static <T> T execMethod(Method method, Object target, Object... params) {
        allowAccess(method);
        try {
            return (T) method.invoke(target, params);
        } catch (Throwable e) {
            throw new ReflectException(e);
        }
    }