Diamond-Client执行流程

来源：互联网发布：webservice soap java 编辑：程序博客网时间：2024/06/05 10:29

简单调用：

public static void main(String[] str) {        DiamondManager manager = new DefaultDiamondManager("group_test", "dataId_test", new ManagerListener() {            public void receiveConfigInfo(String configInfo) {                System.out.println("changed config: " + configInfo);            }            public Executor getExecutor() {                return null;            }        }, "10.58.50.203,10.58.50.204");        String availableConfigureInfomation = manager.getAvailableConfigureInfomation(5000);        System.out.println("start config: " + availableConfigureInfomation);    }

public DefaultDiamondManager(String group, String dataId, ManagerListener managerListener,String diamondServer) {        this.dataId = dataId;        this.group = group;        // 获取单例订阅者        diamondSubscriber = DiamondClientFactory.getSingletonDiamondSubscriber();        // 加入监听列表        this.managerListeners.add(managerListener);        // 将监听器设置入监听者        ((DefaultSubscriberListener) diamondSubscriber.getSubscriberListener()).addManagerListeners(this.dataId,            this.group, this.managerListeners);         String s[] = diamondServer.split(",");        if (s != null && s.length > 0) {            for (String o : s) {                if (o != null && !o.trim().equals(""))                    diamondSubscriber.getDiamondConfigure().getDomainNameList().add(o.trim());            }        }        diamondSubscriber.addDataId(this.dataId, this.group);        // 开启监听者线程        diamondSubscriber.start();     }

DefaultDiamondSubscriber：

public synchronized void start() {        if (isRun) {            // 防止多次启动            return;        }        if (null == scheduledExecutor || scheduledExecutor.isTerminated()) {            scheduledExecutor = Executors.newSingleThreadScheduledExecutor();        }        localConfigInfoProcessor.start(this.diamondConfigure.getFilePath() + "/" + DATA_DIR);        serverAddressProcessor = new ServerAddressProcessor(this.diamondConfigure, this.scheduledExecutor);        serverAddressProcessor.start();        this.snapshotConfigInfoProcessor =                new SnapshotConfigInfoProcessor(this.diamondConfigure.getFilePath() + "/" + SNAPSHOT_DIR);        // 设置domainNamePos值        randomDomainNamePos();        initHttpClient();        // 初始化完毕        isRun = true;        if (log.isInfoEnabled()) {            log.info("当前使用的域名有：" + this.diamondConfigure.getDomainNameList());        }        if (MockServer.isTestMode()) {            bFirstCheck = false;        }        else {            // 设置轮询间隔时间            this.diamondConfigure.setPollingIntervalTime(Constants.POLLING_INTERVAL_TIME);        }        // 轮询        rotateCheckConfigInfo();        addShutdownHook();    }

    /**     * 循环探测配置信息是否变化，如果变化，则再次向DiamondServer请求获取对应的配置信息     */    private void rotateCheckConfigInfo() {        scheduledExecutor.schedule(new Runnable() {            public void run() {                if (!isRun) {                    log.warn("DiamondSubscriber不在运行状态中，退出查询循环");                    return;                }                try {                    // 检查本地配置信息                    checkLocalConfigInfo();                    // 从Server端拉取最新的配置信息                    checkDiamondServerConfigInfo();                    // 持久化配置信息                    checkSnapshot();                }                catch (Exception e) {                    e.printStackTrace();                    log.error("循环探测发生异常", e);                }                finally {                    rotateCheckConfigInfo();                }            }             //方法内部启动一个定时线程，默认每隔20秒执行一次        }, bFirstCheck ? 20 : diamondConfigure.getPollingIntervalTime(), TimeUnit.SECONDS);        bFirstCheck = false;    }

检查本地的配置信息：

private void checkLocalConfigInfo() {        for (Entry<String/* dataId */, ConcurrentHashMap<String/* group */, CacheData>> cacheDatasEntry : cache            .entrySet()) {            ConcurrentHashMap<String, CacheData> cacheDatas = cacheDatasEntry.getValue();            if (null == cacheDatas) {                continue;            }            for (Entry<String, CacheData> cacheDataEntry : cacheDatas.entrySet()) {                final CacheData cacheData = cacheDataEntry.getValue();                try {                    String configInfo = getLocalConfigureInfomation(cacheData);                    // 获取本地持久化的配置信息                    if (null != configInfo) {                        if (log.isInfoEnabled()) {                            log.info("本地配置信息被读取, dataId:" + cacheData.getDataId() + ", group:" + cacheData.getGroup());                        }                        // 通知Listener数据变化                        popConfigInfo(cacheData, configInfo);                        continue;                    }                    if (cacheData.isUseLocalConfigInfo()) {                        continue;                    }                }                catch (Exception e) {                    log.error("向本地索要配置信息的过程抛异常", e);                }            }        }    }

getLocalConfigureInfomation：

public String getLocalConfigureInfomation(CacheData cacheData, boolean force) throws IOException {        // 获取文件路径        String filePath = getFilePath(cacheData.getDataId(), cacheData.getGroup());        if (!existFiles.containsKey(filePath)) {            if (cacheData.isUseLocalConfigInfo()) {                cacheData.setLastModifiedHeader(Constants.NULL);                cacheData.setMd5(Constants.NULL);                cacheData.setLocalConfigInfoFile(null);                cacheData.setLocalConfigInfoVersion(0L);                cacheData.setUseLocalConfigInfo(false);            }            return null;        }        if (force) {            log.info("主动从本地获取配置数据, dataId:" + cacheData.getDataId() + ", group:" + cacheData.getGroup());            String content = FileUtils.getFileContent(filePath);            return content;        }        // 判断是否变更，没有变更，返回null        // 文件路径不等或者版本号不同，返回最新的数据        if (!filePath.equals(cacheData.getLocalConfigInfoFile())                || existFiles.get(filePath) != cacheData.getLocalConfigInfoVersion()) {            String content = FileUtils.getFileContent(filePath);            cacheData.setLocalConfigInfoFile(filePath);            cacheData.setLocalConfigInfoVersion(existFiles.get(filePath));            cacheData.setUseLocalConfigInfo(true);            if (log.isInfoEnabled()) {                log.info("本地配置数据发生变化, dataId:" + cacheData.getDataId() + ", group:" + cacheData.getGroup());            }            return content;        }        else {            cacheData.setUseLocalConfigInfo(true);            if (log.isInfoEnabled()) {                log.debug("本地配置数据没有发生变化, dataId:" + cacheData.getDataId() + ", group:" + cacheData.getGroup());            }            return null;        }    }

popConfigInfo：

void popConfigInfo(final CacheData cacheData, final String configInfo) {        final ConfigureInfomation configureInfomation = new ConfigureInfomation();        configureInfomation.setConfigureInfomation(configInfo);        final String dataId = cacheData.getDataId();        final String group = cacheData.getGroup();        configureInfomation.setDataId(dataId);        configureInfomation.setGroup(group);        cacheData.incrementFetchCountAndGet();        if (null != this.subscriberListener.getExecutor()) {            this.subscriberListener.getExecutor().execute(new Runnable() {                public void run() {                    try {                        // 调用Listener的接受数据方法                        subscriberListener.receiveConfigInfo(configureInfomation);                        saveSnapshot(dataId, group, configInfo);                    }                    catch (Throwable t) {                        log.error("配置信息监听器中有异常，group为：" + group + ", dataId为：" + dataId, t);                    }                }            });        }        else {            try {                subscriberListener.receiveConfigInfo(configureInfomation);                saveSnapshot(dataId, group, configInfo);            }            catch (Throwable t) {                log.error("配置信息监听器中有异常，group为：" + group + ", dataId为：" + dataId, t);            }        }    }

从服务端获取更新的数据

private void checkDiamondServerConfigInfo() {        Set<String> updateDataIdGroupPairs = checkUpdateDataIds(diamondConfigure.getReceiveWaitTime());        if (null == updateDataIdGroupPairs || updateDataIdGroupPairs.size() == 0) {            log.debug("没有被修改的DataID");            return;        }        // 对于每个发生变化的DataID，都请求一次对应的配置信息        for (String freshDataIdGroupPair : updateDataIdGroupPairs) {            int middleIndex = freshDataIdGroupPair.indexOf(WORD_SEPARATOR);            if (middleIndex == -1)                continue;            String freshDataId = freshDataIdGroupPair.substring(0, middleIndex);            String freshGroup = freshDataIdGroupPair.substring(middleIndex + 1);            ConcurrentHashMap<String, CacheData> cacheDatas = cache.get(freshDataId);            if (null == cacheDatas) {                continue;            }            CacheData cacheData = cacheDatas.get(freshGroup);            if (null == cacheData) {                continue;            }            receiveConfigInfo(cacheData);        }    }

checkUpdateDataIds：检查发生更新的Dataid

Set<String> checkUpdateDataIds(long timeout) {        if (!isRun) {            throw new RuntimeException("DiamondSubscriber不在运行状态中，无法获取修改过的DataID列表");        }        // =======================使用测试模式=======================        if (MockServer.isTestMode()) {            return testData();        }        // ==========================================================        long waitTime = 0;        // Set<String> localModifySet = getLocalUpdateDataIds();        String probeUpdateString = getProbeUpdateString();        if (StringUtils.isBlank(probeUpdateString)) {            return null;        }        while (0 == timeout || timeout > waitTime) {            // 设置超时时间            long onceTimeOut = getOnceTimeOut(waitTime, timeout);            waitTime += onceTimeOut;            PostMethod postMethod = new PostMethod(Constants.HTTP_URI_FILE);            postMethod.addParameter(Constants.PROBE_MODIFY_REQUEST, probeUpdateString);            // 设置HttpMethod的参数            HttpMethodParams params = new HttpMethodParams();            params.setSoTimeout((int) onceTimeOut);            // ///////////////////////            postMethod.setParams(params);            try {                httpClient.getHostConfiguration()                    .setHost(diamondConfigure.getDomainNameList().get(this.domainNamePos.get()),                        this.diamondConfigure.getPort());                int httpStatus = httpClient.executeMethod(postMethod);                switch (httpStatus) {                case SC_OK: {                    Set<String> result = getUpdateDataIds(postMethod);                    return result;                }                case SC_SERVICE_UNAVAILABLE: {                    rotateToNextDomain();                }                    break;                default: {                    log.warn("获取修改过的DataID列表的请求回应的HTTP State: " + httpStatus);                    rotateToNextDomain();                }                }            }            catch (HttpException e) {                log.error("获取配置信息Http异常", e);                rotateToNextDomain();            }            catch (IOException e) {                log.error("获取配置信息IO异常", e);                rotateToNextDomain();            }            catch (Exception e) {                log.error("未知异常", e);                rotateToNextDomain();            }            finally {                postMethod.releaseConnection();            }        }        throw new RuntimeException("获取修改过的DataID列表超时 "                + diamondConfigure.getDomainNameList().get(this.domainNamePos.get()) + ", 超时时间为：" + timeout);    }

receiveConfigInfo：

private void receiveConfigInfo(final CacheData cacheData) {        scheduledExecutor.execute(new Runnable() {            public void run() {                if (!isRun) {                    log.warn("DiamondSubscriber不在运行状态中，退出查询循环");                    return;                }                try {                    String configInfo =                            getConfigureInfomation(cacheData.getDataId(), cacheData.getGroup(),                                diamondConfigure.getReceiveWaitTime(), true);                    if (null == configInfo) {                        return;                    }                    if (null == subscriberListener) {                        log.warn("null == subscriberListener");                        return;                    }                    // 通知Listener                    popConfigInfo(cacheData, configInfo);                }                catch (Exception e) {                    log.error("向Diamond服务器索要配置信息的过程抛异常", e);                }            }        });    }

0 0