取得对应的key String

@param key
@return
547357
private String getKey(Object key) {
        if (key == null) {
            throw new IllegalArgumentException("Cache key not be null");
        }

        return ObjectUtils.toString(key);
    }
347497
public String getKeyValue(String key){
        String keyName = keysMap.get(key);
        if (keyName != null){
            return keyName;
        }
        return ""; //key wasn't defined in keys properties file
    }
532905
public static String getString(String key, Object... params) {
		String message = getStringSafely(key);
		if (params != null && params.length > 0) {
			return MessageFormat.format(message, params);
		} else {
			return message;
		}
	}
1293109
public String getString(String key) {
        Object tmp = objectMap.get(key);
        return tmp == null ? null : tmp.toString();
    }
134323
public String[] getStringLines(String key) {
    String value = getString(key);
    if (StringUtils.isEmpty(value)) {
      return new String[0];
    }
    return value.split("\r?\n|\r", -1);
  }
1318776
public String getString(String key) {
    	String value = get(key);
    	Utils.require(value != null, key + " parameter is not set");
    	return value;
    }
241458
private static String getInnerMapKey(final String key) {
        final int index = key.indexOf(".");
        return key.substring(index + 1);
    }
462616
public static String getString(String key) {
        try {
            return RESOURCE_BUNDLE.getString(key);
        } catch (MissingResourceException e) {
            return '!' + key + '!';
        }
    }
841543
public static int[] getKeys(int key) {
        int[] keys = {0, 1, 1};
        if (key > 0) {
            // 自定义算Key
            if (key < TEN) {
                keys[0] = key;
                keys[1] = key - key / 2;
                keys[2] = Math.abs(keys[1] - key % keys[1]);
            } else if (key < HUNDRED) {
                keys[0] = key % 10;
                keys[1] = Math.abs(key / 10 - keys[0]) % 9 + 1;
                keys[2] = keys[0] * keys[1] / (keys[0] + keys[1]) % 10;
            } else if (key < THOUSAND) {
                int middle = key % 100 / 10;
                keys[0] = key % 10;
                keys[1] = key / 100;
                keys[2] = ((int) (Math.pow(keys[1], keys[0]) / middle) % 9 + 1);
            } else {
                int length = String.valueOf(key).length();
                keys[0] = key % 10;
                keys[1] = key / (int) Math.pow(10, length - 1);
                length = (keys[0] + keys[1] + keys[0] * keys[1]) % (length - 2) + 2;
                keys[2] = (int) (key % Math.pow(10, length) / Math.pow(10, length - 1));
            }
            keys[2] = keys[2] % 8 + 2;
        }
        return keys;
    }
419929
private String getString( String key )
    {
        try
        {
            return _resources.getString( key );
        }
        catch ( MissingResourceException mre )
        {
            return "Missing resource for: " + key;
        }
    }
264604
public Optional<String> getRawString(String key) {
    return get(definitions.validKey(requireNonNull(key)));
  }
394720
public boolean containsKey(String key) {
    key = key.toLowerCase();
    key = key.trim();
    return map.containsKey(key);
  }
1333388
public V get(String key)
    {
        int index = exactMatchSearch(key);
        if (index >= 0)
        {
            return v[index];
        }

        return null;
    }
550447
public Object get(String key) {
    	if(config != null) {
    		return config.get(key);
    	}
    	else
    		return null;
    }
725842
public String getRequiredString(String key) throws IllegalStateException {
        Optional<String> property = getString(key);
        if (property.isPresent()) {
            return property.get();
        } else {
            throw new IllegalStateException(String.format("required key [%s] not found", key));
        }
    }
960122
private static String buildKey(String key, Map<String, Object> parameters) {
        // 匹配符合  :name 格式的参数
        Matcher matcher = PATTERN.matcher(key);
        if (matcher.find()) {

            StringBuilder builder = new StringBuilder();

            int index = 0;

            do {
                // 提取参数名称
                final String name = matcher.group(1).trim();

                Object value = null;

                // 解析  a.b.c 类型的名称 
                int find = name.indexOf('.');
                if (find >= 0) {

                    // 用  BeanWrapper 获取属性值
                    Object bean = parameters.get(name.substring(0, find));
                    if (bean != null) {
                        value = new BeanWrapperImpl(bean)
                                .getPropertyValue(name.substring(find + 1));
                    }

                } else {

                    // 获取参数值
                    value = parameters.get(name);
                }

                // 拼装参数值
                builder.append(key.substring(index, matcher.start()));
                builder.append(value);

                index = matcher.end();

            } while (matcher.find());

            // 拼装最后一段
            builder.append(key.substring(index));

            return builder.toString();
        }

        return key;
    }
25432
public String getString(int key) {
        PebbleTuple tuple = getTuple(key, PebbleTuple.TupleType.STRING);
        if (tuple == null) {
            return null;
        }
        return (String) tuple.value;
    }