初识 diamond client

@[T上一篇文章，我们简单的看了一下diamond server的功能及所做的事情，本篇我们看一下diamond client 所做的事情。

首先我们说明的是，应用系统想要获得diamond中的动态配置，需要设置监听器，当监听到diamond的数据发生改变的时候，就会通知监听器接收改变后的数据。所以应用程序需要做的就是设置diamond的监听器。

Diamond.java

static public void addListener(String dataId, String group, ManagerListener listener)
{
defaultEnv.addListeners(dataId, group, Arrays.asList(listener));
}
在使用这个方法时，会首先执行静态代码块的内容

static {
try {
initLog();
checkSnapshotValidity();
}
catch (Exception e)
{
e.printStackTrace();
throw new RuntimeException(e);
}
}
static private void checkSnapshotValidity()
{
List localServerlist = LocalConfigInfoProcessor.readServerlist(defaultEnv);
List apacheServerlist = defaultEnv.getServerUrls();
log.info("[apache-urls] " + apacheServerlist);
log.info("[cache-urls] " + localServerlist);
boolean isNotChange = apacheServerlist.equals(localServerlist); if (isNotChange) {
log.info(LogConstants.PREFFIX + “environment ok.”);
} else {
log.warn(LogConstants.PREFFIX + “environment changed. clear cache.”);
LocalConfigInfoProcessor.cleanAllSnapshot();
LocalConfigInfoProcessor.saveServerlist(defaultEnv, apacheServerlist);
}
}
在这里又静态导入了defaultEnv，所以导致了defaultEnv的初始化。

static public final DiamondEnv defaultEnv = new DiamondEnv(new ServerListManager());
DiamondEnv 的初始化需要ServerListManager的实例。

protected DiamondEnv(ServerListManager serverListMgr) {
{
initServerManager(serverListMgr); //初始化ServerListManager
cacheMap = new AtomicReference<Map<String, CacheData>>(new HashMap<String, CacheData>()); //初始化放CacheData的容器
worker = new ClientWorker(this); //初始化ClientWorker
}
看一下如何初始化的ServerListManager

public void initServerManager(ServerListManager _serverMgr)
{
_serverMgr.setEnv(this); //为ServerListManager 设置env
serverMgr = _serverMgr; //为DiamondEnv设置ServerListManager
serverMgr.start(); //ServerListManager 启动
agent = new ServerHttpAgent(serverMgr); //创建一个http的Client，用于同diamond server进行http的通信。
}
关键是serverMgr.start();

public synchronized void start()
{
if (isStarted || isFixed) { return; }
GetServerListTask getServersTask = new GetServerListTask(DiamondConfigure.singleton.getDiamondHttpUrl());
while (serverUrls.isEmpty()) {
getServersTask.run();
try {
Thread.sleep(1000L); }
catch (Exception e) {}
}
TimerService.scheduleWithFixedDelay(getServersTask, 0L, 30L,TimeUnit.SECONDS);
isStarted = true;
}
这里有一个定时的线程池每30s执行这个任务，这个任务就是去diamond服务器取服务器的ip列表。我们发现有一个DiamondConfigure.singleton.getDiamondHttpUrl()，所以我们需要在设置监听前要设置这个diamond的http url。这个很重要，要不然client起不来。
根据服务器上获取的ip列表与本地的进行比较，不一致的话

LocalConfigInfoProcessor.saveServerlist(name, serverUrls);
更新本地的ip列表，否则直接return。这是initServerManager所做的事情。我们再来看一下

worker = new ClientWorker(this);
这里面做的事情就比较多了。

ClientWorker(final DiamondEnv env) {
    this.env = env;   //ClientWorker中的env进行赋值
    executor = Executors.newScheduledThreadPool(1, new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("com.taobao.diamond.client.Worker."+ env.serverMgr.name);
            t.setDaemon(true);
            return t;
        }
    });

    executor.scheduleWithFixedDelay(new Runnable() {
        public void run() {
            try {
                checkLocalConfigInfo();
                checkServerConfigInfo();
            } catch (Throwable e) {
                log.error("[sub-error-rotate] rotate check error", e);
            }
        }
    }, 1L, 1L, TimeUnit.MILLISECONDS);
}

创建了一个定时的线程池，每隔1毫秒，进行checkLocalConfigInfo和checkServerConfigInfo，checkLocalConfigInfo是本地容灾文件的处理，
我们着重看一下checkServerConfigInfo。

static public void checkServerConfigInfo(DiamondEnv env) {
for (String groupKey : checkUpdateDataIds(env)) {
String dataId = GroupKey.parseKey(groupKey)[0];
String group = GroupKey.parseKey(groupKey)[1];
try {
String content = getServerConfig(env, dataId, group, 3000L);
CacheData cache = env.getCache(dataId, group);
cache.setContent(content);

            log.info("[data-received] dataId=" + dataId + ", group=" + group + ", md5="
                    + cache.getMd5() + ", content=" + ContentUtils.truncateContent(content));
        } catch (IOException ioe) {
            log.warn(ioe.toString(), ioe);
        }
    }

    checkListenerMd5(env);
}

checkUpdateDataIds 是将本地缓存的CacheData中的group,dataId和md5作为字符串拼接起来，作为参数，post到服务器上进行处理，根据group和dataId，查询到md5与传递过来的MD5进行比对，如果不一致，将不一致的group和dataId回传回来。

/**
* 从DiamondServer获取值变化了的DataID列表。返回的对象里只有dataId和group是有效的。 保证不返回NULL。
/
static List checkUpdateDataIds(DiamondEnv env) {
/
if (MockServer.isTestMode()) {
List updateList = new ArrayList();
//与DiamondEnv的模拟数据源比较，得出数据变化列表
for(CacheData cacheData : env.getAllCacheDataSnapshot()){
CacheData mockServerData = env.getMockCache(cacheData.dataId, cacheData.group);
if(mockServerData == null || !mockServerData.getMd5().equals(cacheData.getMd5()))
updateList.add(GroupKey.getKey(cacheData.dataId, cacheData.group));
}
return updateList;
} */
if (MockServer.isTestMode()) {
// 避免 test mode cpu% 过高
try {
Thread.sleep(3000l);
} catch (InterruptedException e) {}
List updateList = new ArrayList();
for(CacheData cacheData : env.getAllCacheDataSnapshot()){
if(!CacheData.getMd5String(MockServer.getConfigInfo(cacheData.dataId, cacheData.group, env))
.equals(cacheData.getMd5())) {
updateList.add(GroupKey.getKey(cacheData.dataId, cacheData.group));
}
}
return updateList;
}

    String probeUpdateString = getProbeUpdateString(env);
    List<String> params = Arrays.asList(Constants.PROBE_MODIFY_REQUEST, probeUpdateString);
    long timeout = TimeUnit.SECONDS.toMillis(30L);

    List<String> headers = Arrays.asList("longPullingTimeout", "" + timeout);

    if (StringUtils.isBlank(probeUpdateString)) {
        return Collections.emptyList();
    }

    try {
        HttpResult result = env.agent.httpPost("/config.co", headers, params, Constants.ENCODE,
                timeout);

        if (HttpURLConnection.HTTP_OK == result.code) {
            return parseUpdateDataIdResponse(result.content);
        } else {
            log.warn("[check-update] get changed dataId error, HTTP State: " + result.code);
        }
    } catch (IOException e) {
        log.warn("[check-update] get changed dataId exception, " + e.toString());
    }
    return Collections.emptyList();
}

那么回传回来的group和dataId说明是有变化的，随后再请求服务器中的数据（最新的数据），放入本地的snapshot文件再放入放入CacheData

String content = getServerConfig(env, dataId, group, 3000L);
CacheData cache = env.getCache(dataId, group);
cache.setContent(content);

/**
* 对于404响应码，返回NULL.
*
* @throws IOException
*/
static String getServerConfig(DiamondEnv env, String dataId, String group, long readTimeout)
throws IOException {
if (StringUtils.isBlank(group)) {
group = Constants.DEFAULT_GROUP;
}

    if (MockServer.isTestMode()) {
        return MockServer.getConfigInfo(dataId, group, env);
    }

    HttpResult result = null;
    try {
        List<String> params = Arrays.asList("dataId", dataId, "group", group);
        result = env.agent.httpGet("/config.co", null, params, Constants.ENCODE, readTimeout);
    } catch (IOException e) {
        log.warn("[sub-server] get server config exception, dataId=" + dataId + ", group="
                + group + ", " + e.toString());
        throw e;
    }

    switch (result.code) {
    case HttpURLConnection.HTTP_OK:
        // if (env == defaultEnv) {
        LocalConfigInfoProcessor.saveSnapshot(env, dataId, group, result.content);
        // }
        return result.content;
    case HttpURLConnection.HTTP_NOT_FOUND:
        // if (env == defaultEnv) {
        LocalConfigInfoProcessor.saveSnapshot(env, dataId, group, null);
        // }
        return null;
    case HttpURLConnection.HTTP_CONFLICT: {
        log.warn("[sub-server-error] data being modified");
        throw new IOException("data being modified");
    }
    default: {
        log.warn("[sub-server-error] error code " + result.code);
        throw new IOException("http code: " + result.code);
    }
    }
}

CacheData处理完了，在处理监听器。

static void checkListenerMd5(DiamondEnv env) {
    for (CacheData cacheData : env.getAllCacheDataSnapshot()) {
        cacheData.checkListenerMd5();
    }
}
void checkListenerMd5() {
    for (ManagerListenerWrap wrap : listeners) {
        if (!md5.equals(wrap.lastCallMd5)) {
            safeNotifyListener(dataId, group, content, md5, wrap);
        }
}
static void safeNotifyListener(final String dataId, final String group, final String content,
        final String md5, ManagerListenerWrap listenerWrap) {
    final ManagerListener listener = listenerWrap.listener;
    listenerWrap.lastCallMd5 = md5;

    Runnable job = new Runnable() {
        public void run() {
            try {
                listener.receiveConfigInfo(content);
                log.info("[notify-ok] " + dataId + ", " + group + ", md5=" + md5
                        + ", listener=" + listener);
            } catch (Throwable t) {
                log.error("[notify-error] " + dataId + ", " + group + ", md5=" + md5
                        + ", listener=" + listener.toString(), t);
            }
        }
    };

    try {
        if (null != listener.getExecutor()) {
            listener.getExecutor().execute(job);
        } else {
            job.run();
        }
    } catch (Throwable t) {
        log.error("[notify-error] " + dataId + ", " + group + ", md5=" + md5 + ", listener="
                + listener.toString(), t);
    }
}OC](这里写自定义目录标题)

每次调用safeNotifyListener时都会开启一个线程（有线程池用线程池），将改变后的内容传递给监听器进行处理。