聊聊nacos NamingProxy的getServiceList

public class NamingProxy {
​
    private static final int DEFAULT_SERVER_PORT = 8848;
​
    private int serverPort = DEFAULT_SERVER_PORT;
​
    private String namespaceId;
​
    private String endpoint;
​
    private String nacosDomain;
​
    private List<String> serverList;
​
    private List<String> serversFromEndpoint = new ArrayList<String>();
​
    private long lastSrvRefTime = 0L;
​
    private long vipSrvRefInterMillis = TimeUnit.SECONDS.toMillis(30);
​
    private Properties properties;
​
    public NamingProxy(String namespaceId, String endpoint, String serverList) {
​
        this.namespaceId = namespaceId;
        this.endpoint = endpoint;
        if (StringUtils.isNotEmpty(serverList)) {
            this.serverList = Arrays.asList(serverList.split(","));
            if (this.serverList.size() == 1) {
                this.nacosDomain = serverList;
            }
        }
​
        initRefreshSrvIfNeed();
    }
​
    private void initRefreshSrvIfNeed() {
        if (StringUtils.isEmpty(endpoint)) {
            return;
        }
​
        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread t = new Thread(r);
                t.setName("com.alibaba.nacos.client.naming.serverlist.updater");
                t.setDaemon(true);
                return t;
            }
        });
​
        executorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                refreshSrvIfNeed();
            }
        }, 0, vipSrvRefInterMillis, TimeUnit.MILLISECONDS);
​
        refreshSrvIfNeed();
    }
​
    //......
​
    private void refreshSrvIfNeed() {
        try {
​
            if (!CollectionUtils.isEmpty(serverList)) {
                NAMING_LOGGER.debug("server list provided by user: " + serverList);
                return;
            }
​
            if (System.currentTimeMillis() - lastSrvRefTime < vipSrvRefInterMillis) {
                return;
            }
​
            List<String> list = getServerListFromEndpoint();
​
            if (CollectionUtils.isEmpty(list)) {
                throw new Exception("Can not acquire Nacos list");
            }
​
            if (!CollectionUtils.isEqualCollection(list, serversFromEndpoint)) {
                NAMING_LOGGER.info("[SERVER-LIST] server list is updated: " + list);
            }
​
            serversFromEndpoint = list;
            lastSrvRefTime = System.currentTimeMillis();
        } catch (Throwable e) {
            NAMING_LOGGER.warn("failed to update server list", e);
        }
    }
​
    public List<String> getServerListFromEndpoint() {
​
        try {
            String urlString = "http://" + endpoint + "/nacos/serverlist";
            List<String> headers = builderHeaders();
​
            HttpClient.HttpResult result = HttpClient.httpGet(urlString, headers, null, UtilAndComs.ENCODING);
            if (HttpURLConnection.HTTP_OK != result.code) {
                throw new IOException("Error while requesting: " + urlString + "'. Server returned: "
                    + result.code);
            }
​
            String content = result.content;
            List<String> list = new ArrayList<String>();
            for (String line : IoUtils.readLines(new StringReader(content))) {
                if (!line.trim().isEmpty()) {
                    list.add(line.trim());
                }
            }
​
            return list;
​
        } catch (Exception e) {
            e.printStackTrace();
        }
​
        return null;
    }
​
    //......
}

public class NamingProxy {
​
    private static final int DEFAULT_SERVER_PORT = 8848;
​
    private int serverPort = DEFAULT_SERVER_PORT;
​
    private String namespaceId;
​
    private String endpoint;
​
    private String nacosDomain;
​
    private List<String> serverList;
​
    private List<String> serversFromEndpoint = new ArrayList<String>();
​
    private long lastSrvRefTime = 0L;
​
    private long vipSrvRefInterMillis = TimeUnit.SECONDS.toMillis(30);
​
    private Properties properties;
​
    //......
​
    public ListView<String> getServiceList(int pageNo, int pageSize, String groupName) throws NacosException {
        return getServiceList(pageNo, pageSize, groupName, null);
    }
​
    public ListView<String> getServiceList(int pageNo, int pageSize, String groupName, AbstractSelector selector) throws NacosException {
​
        Map<String, String> params = new HashMap<String, String>(4);
        params.put("pageNo", String.valueOf(pageNo));
        params.put("pageSize", String.valueOf(pageSize));
        params.put(CommonParams.NAMESPACE_ID, namespaceId);
        params.put(CommonParams.GROUP_NAME, groupName);
​
        if (selector != null) {
            switch (SelectorType.valueOf(selector.getType())) {
                case none:
                    break;
                case label:
                    ExpressionSelector expressionSelector = (ExpressionSelector) selector;
                    params.put("selector", JSON.toJSONString(expressionSelector));
                    break;
                default:
                    break;
            }
        }
​
        String result = reqAPI(UtilAndComs.NACOS_URL_BASE + "/service/list", params);
​
        JSONObject json = JSON.parseObject(result);
        ListView<String> listView = new ListView<String>();
        listView.setCount(json.getInteger("count"));
        listView.setData(JSON.parseObject(json.getString("doms"), new TypeReference<List<String>>() {
        }));
​
        return listView;
    }
​
    public String reqAPI(String api, Map<String, String> params) throws NacosException {
​
        List<String> snapshot = serversFromEndpoint;
        if (!CollectionUtils.isEmpty(serverList)) {
            snapshot = serverList;
        }
​
        return reqAPI(api, params, snapshot);
    }
​
    public String reqAPI(String api, Map<String, String> params, List<String> servers) {
        return reqAPI(api, params, servers, HttpMethod.GET);
    }
​
    public String reqAPI(String api, Map<String, String> params, List<String> servers, String method) {
​
        params.put(CommonParams.NAMESPACE_ID, getNamespaceId());
​
        if (CollectionUtils.isEmpty(servers) && StringUtils.isEmpty(nacosDomain)) {
            throw new IllegalArgumentException("no server available");
        }
​
        Exception exception = new Exception();
​
        if (servers != null && !servers.isEmpty()) {
​
            Random random = new Random(System.currentTimeMillis());
            int index = random.nextInt(servers.size());
​
            for (int i = 0; i < servers.size(); i++) {
                String server = servers.get(index);
                try {
                    return callServer(api, params, server, method);
                } catch (NacosException e) {
                    exception = e;
                    NAMING_LOGGER.error("request {} failed.", server, e);
                } catch (Exception e) {
                    exception = e;
                    NAMING_LOGGER.error("request {} failed.", server, e);
                }
​
                index = (index + 1) % servers.size();
            }
​
            throw new IllegalStateException("failed to req API:" + api + " after all servers(" + servers + ") tried: "
                + exception.getMessage());
        }
​
        for (int i = 0; i < UtilAndComs.REQUEST_DOMAIN_RETRY_COUNT; i++) {
            try {
                return callServer(api, params, nacosDomain);
            } catch (Exception e) {
                exception = e;
                NAMING_LOGGER.error("[NA] req api:" + api + " failed, server(" + nacosDomain, e);
            }
        }
​
        throw new IllegalStateException("failed to req API:/api/" + api + " after all servers(" + servers + ") tried: "
            + exception.getMessage());
​
    }
                
    //......
}