根据请求参数和执行结果值，进行构造缓存Key

@param keyEL     生成缓存Key的表达式
@param target    AOP 拦截到的实例
@param arguments 参数
@param retVal    结果值
@param hasRetVal 是否有retVal
@return CacheKey 缓存Key
@throws Exception 异常
765011
public String getDefinedCacheKey(String keyEL, Object target, Object[] arguments, Object retVal, boolean hasRetVal)
            throws Exception {
        return this.getElValue(keyEL, target, arguments, retVal, hasRetVal, String.class);
    }
752570
public ParseException removeParseException( ResourceKey keyToRemove )
  {
    if( _lnf != null )
    {
      return (ParseException)removeParseIssue( keyToRemove, _lnf._parseExceptions );
    }
    return null;
  }
1349763
public void get(
    Object rootVal,
    MatchSpaceKey msg,
    EvalCache cache,
    Object contextValue,
    SearchResults result)
    throws MatchingException, BadMessageFormatMatchingException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(
          this,cclass,
        "get",
        "msg: " + msg + ", result: " + result);

    // type never used so removed
    //int type;

    List[] v = alwaysMatch.lists;
    if (v.length > 0)
      result.addObjects(v);

    if (msg != null)
    {
      int numExpr = roots.size();

      for (int current = 0; current < numExpr; current++)
      {
        Boolean res = null;

        // May need to call MFP multiple times, if our context has multiple nodes
        if(contextValue != null)
        {
          // Currently this must be a list of nodes
          if (contextValue instanceof SetValEvaluationContext)
          {
            SetValEvaluationContext evalContext = (SetValEvaluationContext)contextValue;
            
            // Get the node list
            ArrayList wrappedParentList = evalContext.getWrappedNodeList(); 
            // If the list is empty, then we have yet to get the document root
            if(wrappedParentList.isEmpty())
            {
        	    //Set up a root (document) context for evaluation
            	Object docRoot = Matching.getEvaluator().getDocumentRoot(msg);
                
                // Create an object to hold the wrapped node
                WrappedNodeResults wrapper = new WrappedNodeResults(docRoot);
                // Set the root into the evaluation context
                evalContext.addNode(wrapper);
            }
            
            // Iterate over the nodes
            Iterator iter = wrappedParentList.iterator();

            while(iter.hasNext())
            {
              WrappedNodeResults nextWrappedNode = (WrappedNodeResults)iter.next();       
              Object nextNode = nextWrappedNode.getNode();
                
                
              // If no cached value we'll need to call MFP
              //TODO: No caching here

              // Call MFP to get the results for this node
              res = 
                (Boolean) Matching.
                  getEvaluator().
                    eval((Selector) roots.get(current),
                         msg,
                         cache,
                         nextNode,
                         true); // Permissive is true  

              if(res !=null && res.booleanValue())
              {
                break;
              }     
     
            } // eof while
          } // eof instanceof XPathEvaluationContext
        }
        else
        {
          res = (Boolean) Matching.getEvaluator().eval(
              (Selector) roots.get(current),
              msg,
              cache,
              contextValue,
              false);            
        }
        
        if (res != null && res.booleanValue())
        {
          MatchTargetTypeList tlist = (MatchTargetTypeList) objs.get(current);
          v = tlist.lists;
          if (v.length > 0)
            result.addObjects(v);
        }
      }
    }
    // ContinueBranch has to be last to treat this node as if it was at the end of
    // a long chain of *, or a #.
    super.get(null, msg, cache, contextValue, result);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(this,cclass, "get");

  }
1310463
void get(
    Object value,
    MatchSpaceKey msg,
    EvalCache cache,
    Object contextValue,
    SearchResults result)
    throws MatchingException, BadMessageFormatMatchingException
  {
    if (value == null && msg != null)
      value = getValue(msg, contextValue);
    if (value == null)
    {
      if (nullChild != null)
        nullChild.get(null, msg, cache, contextValue, result);
    }
    else
    {
      handleGet(value, msg, cache, contextValue, result);
      if (notNullChild != null)
        notNullChild.get(null, msg, cache, contextValue, result);
    }
    super.get(null, msg, cache, contextValue, result);
  }
509760
private com.datastax.driver.core.policies.RetryPolicy getCustomRetryPolicy(Properties props)

    {
        String customRetryPolicy = (String) props.get(CUSTOM_RETRY_POLICY);
        Class<?> clazz = null;
        Method getter = null;
        try
        {
            clazz = Class.forName(customRetryPolicy);
            com.datastax.driver.core.policies.RetryPolicy retryPolicy = (com.datastax.driver.core.policies.RetryPolicy) KunderaCoreUtils
                    .createNewInstance(clazz);
            if (retryPolicy != null)
            {
                return retryPolicy;
            }
            getter = clazz.getDeclaredMethod(GET_INSTANCE);
            return (com.datastax.driver.core.policies.RetryPolicy) getter.invoke(null, (Object[]) null);
        }
        catch (ClassNotFoundException e)
        {
            logger.error(e.getMessage());
            throw new KunderaException("Please make sure class " + customRetryPolicy
                    + " set in property file exists in classpath " + e.getMessage());
        }
        catch (IllegalAccessException e)
        {
            logger.error(e.getMessage());
            throw new KunderaException("Method " + getter.getName() + " must be declared public " + e.getMessage());
        }
        catch (NoSuchMethodException e)
        {
            logger.error(e.getMessage());
            throw new KunderaException("Please make sure getter method of " + clazz.getSimpleName()
                    + " is named \"getInstance()\"");
        }
        catch (InvocationTargetException e)
        {
            logger.error(e.getMessage());
            throw new KunderaException("Error while executing \"getInstance()\" method of Class "
                    + clazz.getSimpleName() + ": " + e.getMessage());
        }
    }
1367682
public void get(Object rootVal,
                  MatchSpaceKey msg,
                  EvalCache cache,
                  Object contextValue,
                  SearchResults result)
    throws MatchingException,BadMessageFormatMatchingException
  {
    if (tc.isEntryEnabled())
	    tc.entry(this,cclass, "get", new Object[]{rootVal,msg,cache,result});

    if (result instanceof CacheingSearchResults)
      ((CacheingSearchResults) result).setMatcher(vacantChild);
    vacantChild.get(null, msg, cache, contextValue, result);

    if (tc.isEntryEnabled())
	    tc.exit(this,cclass, "get");
  }
436839
public boolean isCacheable(Cache cache, Object target, Object[] arguments, Object result) throws Exception {
        boolean rv = true;
        if (null != cache.condition() && cache.condition().length() > 0) {
            rv = this.getElValue(cache.condition(), target, arguments, result, true, Boolean.class);
        }
        return rv;
    }
851677
function(rel, key, val, callback) {
    if (typeof key == 'function') {
      callback = key;
      key = val = undefined;
    }

    if (Array.isArray(rel)) {
      var txn = this._safeBatch();
      var args = [key, val];
      async.map(rel, naan.ecurry(txn.rel.update, args, [1, 2]), callback);
      return this._safeBatchCommit(txn);
    }

    var id = this._getId(rel);

    if (!this._isValidId(id)) {
      return callback(new Error("Invalid ID"));
    }

    var endpoint = util.format('%s/properties', this._relRoot(id));
    if (key) endpoint += '/' + key;

    var op = this.operation(endpoint, 'PUT', key ? val : rel.properties);
    this.call(op, function(err) {
      callback(err);
    });
  }
301111
public <ReturnValue> ReturnValue executeOnEntry(@NotNull Entry entry, @NotNull CacheEntryProcessor<Long, Entry, ReturnValue> entryProcessor) {
        long key = buildHashCode(entry);

        if (!cache.containsKey(key)) {
            List<Object> primaryKeys = getPrimaryKeys(entry);

            List<Entry> entries = super.fetch(primaryKeys);

            Optional<Entry> first = entries.stream().findFirst();

            if (first.isPresent()) {
                cache.putIfAbsent(key, first.get());
            }
        }

        return cache.invoke(key, entryProcessor);
    }
585091
public java.lang.String getRetOrThrow(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, java.lang.String> map =
        internalGetRet().getMap();
    if (!map.containsKey(key)) {
      throw new java.lang.IllegalArgumentException();
    }
    return map.get(key);
  }
480226
private static function doWith(Params $ret, $key, $value, $multiple = true)
    {
        if (!$multiple) {
            if (!is_scalar($value)) {
                throw new \InvalidArgumentException(
                    'Invalid argument $value to with(), expected scalar, got ' . gettype($value)
                );
            }
            if ($ret->contains($key, $value)) {
                $ret->remove($key, $value);
            } else {
                $ret->replace($key, [$value]);
            }
        } else {
            if ($ret->contains($key, $value)) {
                $ret->remove($key, $value);
            } else {
                $ret->add($key, $value);
            }
        }

        return $ret;
    }
1307112
public final void condition_key() throws RecognitionException {
		try {
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:158:5: ( VT_CONDITION )
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:158:7: VT_CONDITION
			{
			match(input,VT_CONDITION,FOLLOW_VT_CONDITION_in_condition_key500); 
			entry_stack.peek().retval.setSection(DSLMappingEntry.CONDITION);
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
	}
1256866
@Override
  public UnsafeRow getKeyRow(int rowId) {
    assert(rowId >= 0);
    assert(rowId < numRows);
    if (keyRowId != rowId) { // if keyRowId == rowId, desired keyRow is already cached
      long offset = keyOffsets[rowId];
      int klen = Platform.getInt(base, offset - 4);
      keyRow.pointTo(base, offset, klen);
      // set keyRowId so we can check if desired row is cached
      keyRowId = rowId;
    }
    return keyRow;
  }
913801
private static void setFieldValue(Object entity, Field member, Object retVal)
    {
        if (member != null && retVal != null && entity != null)
        {
            PropertyAccessorHelper.set(entity, member, retVal);
        }
    }
961555
public static final RetryPolicy retryByException(RetryPolicy defaultPolicy,
                                                   Map<Class<? extends Exception>, RetryPolicy> exceptionToPolicyMap) {
    return new ExceptionDependentRetry(defaultPolicy, exceptionToPolicyMap);
  }
304188
@SuppressWarnings("unchecked")
	@Override
	public <V> V get(String key) {
		V returnValue = null;
		try{
			returnValue = (V) _jedisClusterClient.get(key);
		}catch (Exception ex) {
			_logger.error("Exception in cache service: {} ", ex.getMessage());
		}
		return returnValue;
	}
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;
    }