Java Constants.DEFAULT_GROUP属性代码示例

private String getSnapshotConfiginfomation(String dataId, String group) {
    if (group == null) {
        group = Constants.DEFAULT_GROUP;
    }
    try {
        CacheData cacheData = getCacheData(dataId, group);
        String config = this.snapshotConfigInfoProcessor.getConfigInfomation(dataId, group);
        if (config != null && cacheData != null) {
            cacheData.incrementFetchCountAndGet();
        }
        return config;
    }
    catch (Exception e) {
        log.error("获取snapshot出错， dataId=" + dataId + ",group=" + group, e);
        return null;
    }
}
 

public synchronized void removeDataId(String dataId, String group) {
    if (null == group) {
        group = Constants.DEFAULT_GROUP;
    }
    ConcurrentHashMap<String, CacheData> cacheDatas = this.cache.get(dataId);
    if (null == cacheDatas) {
        return;
    }
    cacheDatas.remove(group);

    log.warn("删除了DataID[" + dataId + "]中的Group: " + group);

    if (cacheDatas.size() == 0) {
        this.cache.remove(dataId);
        log.warn("删除了DataID[" + dataId + "]");
    }
}
 

private String getSnapshotConfiginfomation(String dataId, String group) {
	if (group == null) {
		group = Constants.DEFAULT_GROUP;
	}
	try {
		CacheData cacheData = getCacheData(dataId, group);
		String config = this.snapshotConfigInfoProcessor
				.getConfigInfomation(dataId, group);
		if (config != null && cacheData != null) {
			cacheData.incrementFetchCountAndGet();
		}
		return config;
	} catch (Exception e) {
		log.error("��ȡsnapshot���� dataId=" + dataId + ",group=" + group, e);
		return null;
	}
}
 

public synchronized void removeDataId(String dataId, String group) {
	if (null == group) {
		group = Constants.DEFAULT_GROUP;
	}
	ConcurrentHashMap<String, CacheData> cacheDatas = this.cache
			.get(dataId);
	if (null == cacheDatas) {
		return;
	}
	cacheDatas.remove(group);

	log.warn("ɾ����DataID[" + dataId + "]�е�Group: " + group);

	if (cacheDatas.size() == 0) {
		this.cache.remove(dataId);
		log.warn("ɾ����DataID[" + dataId + "]");
	}
}
 

public String getConfigureInfomation(String dataId, String group, long timeout) {
    // 同步接口流控
    // flowControl();
    if (null == group) {
        group = Constants.DEFAULT_GROUP;
    }
    CacheData cacheData = getCacheData(dataId, group);
    // 优先使用本地配置
    try {
        String localConfig = localConfigInfoProcessor.getLocalConfigureInfomation(cacheData, true);
        if (localConfig != null) {
            cacheData.incrementFetchCountAndGet();
            saveSnapshot(dataId, group, localConfig);
            return localConfig;
        }
    }
    catch (IOException e) {
        log.error("获取本地配置文件出错", e);
    }
    // 获取本地配置失败，从网络取
    String result = getConfigureInfomation(dataId, group, timeout, false);
    if (result != null) {
        saveSnapshot(dataId, group, result);
        cacheData.incrementFetchCountAndGet();
    }
    return result;
}
 

public void addDataId(String dataId, String group) {
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy年MM月dd日   HH:mm:ss");
    log.info("diamond client start:" + formatter.format(new Date(System.currentTimeMillis())));
    if (null == group) {
        group = Constants.DEFAULT_GROUP;
    }

    ConcurrentHashMap<String, CacheData> cacheDatas = this.cache.get(dataId);
    if (null == cacheDatas) {
        ConcurrentHashMap<String, CacheData> newCacheDatas = new ConcurrentHashMap<String, CacheData>();
        ConcurrentHashMap<String, CacheData> oldCacheDatas = this.cache.putIfAbsent(dataId, newCacheDatas);
        if (null != oldCacheDatas) {
            cacheDatas = oldCacheDatas;
        }
        else {
            cacheDatas = newCacheDatas;
        }
    }
    CacheData cacheData = cacheDatas.get(group);
    if (null == cacheData) {
        cacheDatas.putIfAbsent(group, new CacheData(dataId, group));
        if (log.isInfoEnabled()) {
            log.info("添加了DataID[" + dataId + "]，其Group为" + group);
        }
        this.start();
    }
}
 

public boolean containDataId(String dataId, String group) {
    if (null == group) {
        group = Constants.DEFAULT_GROUP;
    }
    ConcurrentHashMap<String, CacheData> cacheDatas = this.cache.get(dataId);
    if (null == cacheDatas) {
        return false;
    }
    return cacheDatas.containsKey(group);
}
 

public static String getConfigInfo(String dataId, String group) {
    if (null == group) {
        group = Constants.DEFAULT_GROUP;
    }
    Map<String, Pair> pairs = staticConfigInfos.get(dataId);
    if (null == pairs) {
        return null;
    }
    Pair pair = pairs.get(group);
    if (null == pair) {
        return null;
    }
    pair.checkable = false;
    return pair.configInfo;
}
 

public static String getUpdateConfigInfo(String dataId, String group) {
    if (null == group) {
        group = Constants.DEFAULT_GROUP;
    }
    Map<String, Pair> pairs = staticConfigInfos.get(dataId);
    if (null == pairs) {
        return null;
    }
    Pair pair = pairs.get(group);
    if (null != pair && pair.checkable) {
        pair.checkable = false;
        return pair.configInfo;
    }
    return null;
}
 

public static void setConfigInfo(String dataId, String group, String configInfo) {
    if (null == group) {
        group = Constants.DEFAULT_GROUP;
    }
    Pair pair = new Pair(configInfo);
    Map<String, Pair> newPairs = new ConcurrentHashMap<String, Pair>();
    Map<String, Pair> pairs = staticConfigInfos.putIfAbsent(dataId, newPairs);
    if (null == pairs) {
        pairs = newPairs;
    }
    pairs.put(group, pair);
}
 

public Builder addDataId(String dataId, String group) {
	if (null == group) {
		group = Constants.DEFAULT_GROUP;
	}
	synchronized (this.dataIdGroupPairs) {
		Set<String> groups = this.dataIdGroupPairs.get(dataId);
		if (null == groups) {
			Set<String> groupSet = new HashSet<String>();
			groupSet.add(group);
			this.dataIdGroupPairs.put(dataId, groupSet);
		}
	}
	return this;
}
 

public String getConfigureInfomation(String dataId, String group,
		long timeout) {
	// ͬ���ӿ�����
	// flowControl();
	if (null == group) {
		group = Constants.DEFAULT_GROUP;
	}
	CacheData cacheData = getCacheData(dataId, group);
	// ����ʹ�ñ�������
	try {
		String localConfig = localConfigInfoProcessor
				.getLocalConfigureInfomation(cacheData, true);
		if (localConfig != null) {
			cacheData.incrementFetchCountAndGet();
			saveSnapshot(dataId, group, localConfig);
			return localConfig;
		}
	} catch (IOException e) {
		log.error("��ȡ���������ļ�����", e);
	}
	// ��ȡ��������ʧ�ܣ�������ȡ
	String result = getConfigureInfomation(dataId, group, timeout, false);
	if (result != null) {
		saveSnapshot(dataId, group, result);
		cacheData.incrementFetchCountAndGet();
	}
	return result;
}
 

public boolean containDataId(String dataId, String group) {
	if (null == group) {
		group = Constants.DEFAULT_GROUP;
	}
	ConcurrentHashMap<String, CacheData> cacheDatas = this.cache
			.get(dataId);
	if (null == cacheDatas) {
		return false;
	}
	return cacheDatas.containsKey(group);
}
 

private String makeKey(String dataId, String group) {
    if (StringUtils.isBlank(group)) {
        group = Constants.DEFAULT_GROUP;
    }
    return dataId + "_" + group;
}
 

String defaultGroupOrClientGroup(String clientGroup) {
    if (clientGroup != null)
        return clientGroup;
    else
        return Constants.DEFAULT_GROUP;
}