獲取Eureka服務列表的各種場景

一、第一類服務注冊到eureka中，獲取服務列表

1、基於SpringClientFactory獲取服務列表

/**
 * <一句話功能簡述>
 * <功能詳細描述>
 *
 * @author hyf
 * @version [版本號, 2019/7/2]
 * @see [相關類/方法]
 * @since [產品/模塊版本]
 */
@RestController
public class DeptController_Consumer {

    @Resource
    private SpringClientFactory factory;

    @RequestMapping(value = "/getAllServers")
    public Object getAllServers(){
        //指定服務名
        ILoadBalancer lb =  factory.getLoadBalancer("MICROSERVICECLOUD");
        List<Server> allServers = lb.getAllServers();
        List<Server> upServers = lb.getReachableServers();
        return  allServers;
    }

}

 

2、基於DiscoveryClient 獲取服務列表

@RestController
public class TestController {
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @RequestMapping("getServicesList")
    @ResponseBody
    public Object getServicesList() {
        List<List<ServiceInstance>> servicesList = new ArrayList<>();
        //獲取服務名稱
        List<String> serviceNames = discoveryClient.getServices();
        for (String serviceName : serviceNames) {
            //獲取服務中的實例列表
            List<ServiceInstance> serviceInstances = discoveryClient.getInstances(serviceName);
            servicesList.add(serviceInstances);
        }
        return servicesList;
    }
}

二、基於eureka的restAPI，解析xml獲取，該方式比較麻煩，但也是最靈活的，只需要知道eureka地址就可以獲取，不要注冊到eureka中

1、前期准備，解析xml的工具類我使用的是hutool工具包

       <dependency>
            <groupId>com.xiaoleilu</groupId>
            <artifactId>hutool-all</artifactId>
            <version>3.0.1</version>
        </dependency>

2、需要使用到HttpClientUtils

package com.feihong.springcloud.util;

import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.util.Map;

import javax.net.ssl.SSLContext;

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;

/**
 * <httpClient 工具類> <功能詳細描述>
 *
 * @see [相關類/方法]
 * @since [產品/模塊版本]
 */


public final class HttpClientUtils {

    private static LogUtil log = LogUtil.getLogger(HttpClientUtils.class);


    /**
     * 連接池初始化
     */
    private static PoolingHttpClientConnectionManager cm = null;

    /**
     * 初始化httpclient 連接池
     */
    static {
        LayeredConnectionSocketFactory sslsf = null;
        try {
            sslsf = new SSLConnectionSocketFactory(SSLContext.getDefault());
        } catch (NoSuchAlgorithmException e) {
            log.info(e.getMessage());
        }
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("https", sslsf)
                .register("http", new PlainConnectionSocketFactory())
                .build();
        cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        cm.setMaxTotal(200);
        cm.setDefaultMaxPerRoute(2);
    }

    private HttpClientUtils() {
    }

    /**
     * <配置httpclient> <功能詳細描述>
     *
     * @param timeout 請求超時時間
     * @return CloseableHttpClient
     * @see [類、類#方法、類#成員]
     */

    private static CloseableHttpClient getHttpClient(Integer timeout) {
        RequestConfig requestConfig = RequestConfig.custom().
                // 設置連接超時時間
                        setConnectionRequestTimeout(timeout).
                // 設置請求超時時間
                        setConnectTimeout(timeout).
                // 設置響應超時時間
                        setSocketTimeout(timeout).build();
        // 超時重試，服務器丟失連接重試
        HttpRequestRetryHandlerImpl retry = new HttpRequestRetryHandlerImpl();
        return HttpClients.custom()
                .setDefaultRequestConfig(requestConfig)
                .setRetryHandler(retry)
                .setConnectionManager(cm)
                .setConnectionManagerShared(true)
                .build();
    }

    /**
     * http post <功能詳細描述>
     *
     * @param url     請求的url
     * @param timeout 請求響應的時間
     * @param param   請求的參數
     * @param header  請求頭
     * @return string
     * @see [類、類#方法、類#成員]
     */
    private static String httpPost(String url, Integer timeout, Map<String, String> param, Map<String, String> header) {
        String msg = "";
        // 獲取客戶端連接對象
        CloseableHttpClient httpClient = getHttpClient(timeout);

        if(StringUtils.isBlank(url)){
            throw new RuntimeException("url can not be null");
        }

        HttpPost httpPost = new HttpPost(url);
        StringBuilder stringBuilder = new StringBuilder("");
        if (null != param) {
            for (Map.Entry<String, String> entry : param.entrySet()) {
                stringBuilder.append(entry.getKey());
                stringBuilder.append('=');
                stringBuilder.append(entry.getValue());
                stringBuilder.append('&');
            }
            stringBuilder = stringBuilder.deleteCharAt(stringBuilder.length() - 1);
        }

        CloseableHttpResponse response = null;
        try {
            StringEntity entityParam = new StringEntity(stringBuilder.toString());
            httpPost.setEntity(entityParam);
            for (Map.Entry<String, String> entry : header.entrySet()) {
                httpPost.addHeader(entry.getKey(), entry.getValue());
            }
            // 執行請求
            response = httpClient.execute(httpPost);
            // 獲得響應的實體對象
            HttpEntity entity = response.getEntity();
            msg = EntityUtils.toString(entity, "UTF-8");

        } catch (Exception e) {
            log.info("user httpPost request error", e);
        } finally {
            try {
                doClose(httpClient, response);
            } catch (IOException e) {
                log.error("httpPost close error", e);
            }
        }
        return msg;
    }

    public static String httpGet(String url, Integer timeout, Map<String, String> map, Map<String, String> header) {
        String msg = "";
        CloseableHttpClient httpClient = getHttpClient(timeout);
        CloseableHttpResponse response = null;
        try {
            // 聲明URIBuilder
            URIBuilder uriBuilder = new URIBuilder(url);

            // 判斷參數map是否為非空
            if (map != null) {
                // 遍歷參數
                for (Map.Entry<String, String> entry : map.entrySet()) {
                    // 設置參數
                    uriBuilder.setParameter(entry.getKey(), entry.getValue());
                }
            }
            // 2 創建httpGet對象，相當於設置url請求地址
            HttpGet httpGet = new HttpGet(uriBuilder.build());

            // 3 使用HttpClient執行httpGet，相當於按回車，發起請求
            response = httpClient.execute(httpGet);

            // 4 解析結果，封裝返回對象httpResult，相當於顯示相應的結果
            // 狀態碼
            // response.getStatusLine().getStatusCode();
            // 響應體，字符串，如果response.getEntity()為空，下面這個代碼會報錯,所以解析之前要做非空的判斷
            HttpEntity entity = response.getEntity();
            msg = EntityUtils.toString(entity, "UTF-8");
        } catch (Exception e) {
            log.error("user httpGet request error", e);
        } finally {
            try {
                doClose(httpClient, response);
            } catch (IOException e) {
                log.error("httpGet close error", e);
            }
        }
        // 返回
        return msg;
    }

    /**
     * 對資源進行關閉
     *
     * @param httpClient httpClient
     * @param response   response
     */
    private static void doClose(CloseableHttpClient httpClient, CloseableHttpResponse response)
            throws IOException {
        if (response != null) {
            response.close();
        }
        if (httpClient != null) {
            httpClient.close();
        }
    }
}

package com.feihong.springcloud.util;

import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import org.apache.http.NoHttpResponseException;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.protocol.HttpContext;
import org.slf4j.Logger;

/**
 * httpclient請求重試策略 httpclient請求重試策略配置類
 *
 * @see [相關類/方法]
 * @since [產品/模塊版本]
 */

public class HttpRequestRetryHandlerImpl implements HttpRequestRetryHandler {

    private LogUtil log = LogUtil.getLogger(HttpRequestRetryHandlerImpl.class);

    private static final Integer COUNT = 3;

    /**
     * 實現HttpRequestRetryHandler {@inheritDoc}
     */
    @Override
    public boolean retryRequest(IOException exception, int i, HttpContext httpContext) {
        // 重試次數最大為3次
        if (i >= COUNT) {
            return false;
        }
        if (exception instanceof NoHttpResponseException) {//沒有響應，重試
            return true;
        } else if (exception instanceof ConnectTimeoutException) {//連接超時，重試
            return true;
        } else if (exception instanceof SocketTimeoutException) {//連接或讀取超時，重試
            return true;
        } else if (exception instanceof SSLHandshakeException) {//本地證書異常
            return false;
        } else if (exception instanceof InterruptedIOException) {//被中斷
            return false;
        } else if (exception instanceof UnknownHostException) {//找不到服務器
            return false;
        } else if (exception instanceof SSLException) {//SSL異常
            return false;
        } else {
            //自己新增log
            log.error("HttpRequestRetryHandlerImpl",exception);
            return false;
        }
    }

}

3、日志打印工具類

package com.feihong.springcloud.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;

/**
 * 日志處理工具類
 *
 * // 方法名|操作人（接口填null）|操作碼|操作描述|業務關鍵信息|異常信息(不需要異常信息就不填)
 * logger.error("getMenuFunctionList|{}|{}|角色名稱已存在|roleId = {},roleName = {}|exception = {}",
 *         SessionUtil.getCurrentUserName(), OperateLogConstants.SYS_ROLE_MODIFY, sysRoleVO.getId(),
 *         sysRoleVO.getRoleName(), CommonUtil.getExceptionMessage(e));
 *
 * @author llx
 *
 */
public final class LogUtil implements Logger {

    private Logger log;

    public static LogUtil getLogger(Class<?> clazz) {
        return new LogUtil(clazz);
    }

    private LogUtil(Class<?> clazz) {
        // 私有構造函數
        log = LoggerFactory.getLogger(clazz);
    }

    @Override
    public String getName() {
        return log.getName();
    }

    @Override
    public boolean isTraceEnabled() {
        return log.isTraceEnabled();
    }

    @Override
    public void trace(String s) {
        if (log.isTraceEnabled()) {
            log.trace(s);
        }
    }

    @Override
    public void trace(String s, Object o) {
        if (log.isTraceEnabled()) {
            log.trace(s, o);
        }
    }

    @Override
    public void trace(String s, Object o, Object o1) {
        if (log.isTraceEnabled()) {
            log.trace(s, o, o1);
        }
    }

    @Override
    public void trace(String s, Object... objects) {
        if (log.isTraceEnabled()) {
            log.trace(s, objects);
        }
    }

    @Override
    public void trace(String s, Throwable throwable) {
        if (log.isTraceEnabled()) {
            log.trace(s, throwable);
        }
    }

    @Override
    public boolean isTraceEnabled(Marker marker) {
        return log.isTraceEnabled(marker);
    }

    @Override
    public void trace(Marker marker, String s) {
        if (log.isTraceEnabled()) {
            log.trace(marker, s);
        }
    }

    @Override
    public void trace(Marker marker, String s, Object o) {
        if (log.isTraceEnabled()) {
            log.trace(marker, s, o);
        }
    }

    @Override
    public void trace(Marker marker, String s, Object o, Object o1) {
        if (log.isTraceEnabled()) {
            log.trace(marker, s, o, o1);
        }
    }

    @Override
    public void trace(Marker marker, String s, Object... objects) {
        if (log.isTraceEnabled()) {
            log.trace(marker, s, objects);
        }
    }

    @Override
    public void trace(Marker marker, String s, Throwable throwable) {
        if (log.isTraceEnabled()) {
            log.trace(marker, s, throwable);
        }
    }

    @Override
    public boolean isDebugEnabled() {
        return log.isDebugEnabled();
    }

    @Override
    public void debug(String s) {
        if (log.isDebugEnabled()) {
            log.debug(s);
        }
    }

    @Override
    public void debug(String s, Object o) {
        if (log.isDebugEnabled()) {
            log.debug(s, o);
        }
    }

    @Override
    public void debug(String s, Object o, Object o1) {
        if (log.isDebugEnabled()) {
            log.debug(s, o, o1);
        }
    }

    @Override
    public void debug(String s, Object... objects) {
        if (log.isDebugEnabled()) {
            log.debug(s, objects);
        }
    }

    @Override
    public void debug(String s, Throwable throwable) {
        if (log.isDebugEnabled()) {
            log.debug(s, throwable);
        }
    }

    @Override
    public boolean isDebugEnabled(Marker marker) {
        return log.isDebugEnabled(marker);
    }

    @Override
    public void debug(Marker marker, String s) {
        if (log.isDebugEnabled()) {
            log.debug(marker, s);
        }
    }

    @Override
    public void debug(Marker marker, String s, Object o) {
        if (log.isDebugEnabled()) {
            log.debug(marker, s, o);
        }
    }

    @Override
    public void debug(Marker marker, String s, Object o, Object o1) {
        if (log.isDebugEnabled()) {
            log.debug(marker, s, o, o1);
        }
    }

    @Override
    public void debug(Marker marker, String s, Object... objects) {
        if (log.isDebugEnabled()) {
            log.debug(marker, s, objects);
        }
    }

    @Override
    public void debug(Marker marker, String s, Throwable throwable) {
        if (log.isDebugEnabled()) {
            log.debug(marker, s, throwable);
        }
    }

    @Override
    public boolean isInfoEnabled() {
        return log.isInfoEnabled();
    }

    @Override
    public void info(String s) {
        if (log.isInfoEnabled()) {
            log.info(s);
        }
    }

    @Override
    public void info(String s, Object o) {
        if (log.isInfoEnabled()) {
            log.info(s, o);
        }
    }

    @Override
    public void info(String s, Object o, Object o1) {
        if (log.isInfoEnabled()) {
            log.info(s, o, o1);
        }
    }

    @Override
    public void info(String s, Object... objects) {
        if (log.isInfoEnabled()) {
            log.info(s, objects);
        }
    }

    @Override
    public void info(String s, Throwable throwable) {
        if (log.isInfoEnabled()) {
            log.info(s, throwable);
        }
    }

    @Override
    public boolean isInfoEnabled(Marker marker) {
        return log.isInfoEnabled(marker);
    }

    @Override
    public void info(Marker marker, String s) {
        if (log.isInfoEnabled()) {
            log.info(marker, s);
        }
    }

    @Override
    public void info(Marker marker, String s, Object o) {
        if (log.isInfoEnabled()) {
            log.info(marker, s, o);
        }
    }

    @Override
    public void info(Marker marker, String s, Object o, Object o1) {
        if (log.isInfoEnabled()) {
            log.info(marker, s, o, o1);
        }
    }

    @Override
    public void info(Marker marker, String s, Object... objects) {
        if (log.isInfoEnabled()) {
            log.info(marker, s, objects);
        }
    }

    @Override
    public void info(Marker marker, String s, Throwable throwable) {
        if (log.isInfoEnabled()) {
            log.info(marker, s, throwable);
        }
    }

    @Override
    public boolean isWarnEnabled() {
        return log.isWarnEnabled();
    }

    @Override
    public void warn(String s) {
        if (log.isWarnEnabled()) {
            log.warn(s);
        }
    }

    @Override
    public void warn(String s, Object o) {
        if (log.isWarnEnabled()) {
            log.warn(s, o);
        }
    }

    @Override
    public void warn(String s, Object... objects) {
        if (log.isWarnEnabled()) {
            log.warn(s, objects);
        }
    }

    @Override
    public void warn(String s, Object o, Object o1) {
        if (log.isWarnEnabled()) {
            log.warn(s, o, o1);
        }
    }

    @Override
    public void warn(String s, Throwable throwable) {
        if (log.isWarnEnabled()) {
            log.warn(s, throwable);
        }
    }

    @Override
    public boolean isWarnEnabled(Marker marker) {
        return log.isWarnEnabled(marker);
    }

    @Override
    public void warn(Marker marker, String s) {
        if (log.isWarnEnabled()) {
            log.warn(marker, s);
        }
    }

    @Override
    public void warn(Marker marker, String s, Object o) {
        if (log.isWarnEnabled()) {
            log.warn(marker, s, o);
        }
    }

    @Override
    public void warn(Marker marker, String s, Object o, Object o1) {
        if (log.isWarnEnabled()) {
            log.warn(marker, s, o, o1);
        }
    }

    @Override
    public void warn(Marker marker, String s, Object... objects) {
        if (log.isWarnEnabled()) {
            log.warn(marker, s, objects);
        }
    }

    @Override
    public void warn(Marker marker, String s, Throwable throwable) {
        if (log.isWarnEnabled()) {
            log.warn(marker, s, throwable);
        }
    }

    @Override
    public boolean isErrorEnabled() {
        return log.isErrorEnabled();
    }

    @Override
    public void error(String s) {
        if (log.isErrorEnabled()) {
            log.error(s);
        }
    }

    @Override
    public void error(String s, Object o) {
        if (log.isErrorEnabled()) {
            log.error(s, o);
        }
    }

    @Override
    public void error(String s, Object o, Object o1) {
        if (log.isErrorEnabled()) {
            log.error(s, o, o1);
        }
    }

    @Override
    public void error(String s, Object... objects) {
        if (log.isErrorEnabled()) {
            log.error(s, objects);
        }
    }

    @Override
    public void error(String s, Throwable throwable) {
        if (log.isErrorEnabled()) {
            log.error(s, throwable);
        }
    }

    @Override
    public boolean isErrorEnabled(Marker marker) {
        return log.isErrorEnabled(marker);
    }

    @Override
    public void error(Marker marker, String s) {
        if (log.isErrorEnabled()) {
            log.error(marker, s);
        }
    }

    @Override
    public void error(Marker marker, String s, Object o) {
        if (log.isErrorEnabled()) {
            log.error(marker, s, o);
        }
    }

    @Override
    public void error(Marker marker, String s, Object o, Object o1) {
        if (log.isErrorEnabled()) {
            log.error(marker, s, o, o1);
        }
    }

    @Override
    public void error(Marker marker, String s, Object... objects) {
        if (log.isErrorEnabled()) {
            log.error(marker, s, objects);
        }
    }

    @Override
    public void error(Marker marker, String s, Throwable throwable) {
        if (log.isErrorEnabled()) {
            log.error(marker, s, throwable);
        }
    }
}

4、解析XML常量類

package com.feihong.springcloud.util;

/**
 * <一句話功能簡述>
 * <功能詳細描述>
 *
 * @author hyf
 * @version [版本號, 2021/1/6]
 * @see [相關類/方法]
 * @since [產品/模塊版本]
 */
public class ParseXmlConstant {

    private ParseXmlConstant(){}

    public static final String APPLICATIONS = "applications";

    public static final String APPLICATION = "application";

    public static final String NAME = "name";

    public static final String HOST_NAME = "hostName";

    public static final String CONTENT = "content";

    public static final String PORT = "port";

    public static final String HOME_PAGE_URL = "homePageUrl";

    public static final String SERVICE_ID = "serviceId";

    public static final String INSTANCE = "instance";


}

5、響應實體類

package com.feihong.springcloud.util;

/**
 * 返回結果通用對象
 *
 * @param <T> 結果類型
 * @author llx
 */
public class JsonResult<T> {
    private int code;

    private String message;

    private T data;

    /**
     * 成功返回json結果
     *
     * @param data 業務對象
     * @return json結果
     */
    public static <T> JsonResult<T> successResult(T data) {
        JsonResult<T> jsonResult = new JsonResult<>();
        jsonResult.setCode(ExceptionConstants.PARAM_SUCCESS);
        jsonResult.setMessage(
                ExceptionConstants.getDefaultMessageMap().get(ExceptionConstants.PARAM_SUCCESS));
        jsonResult.setData(data);
        return jsonResult;
    }

    /**
     * 成功返回json結果
     *
     * @param data 業務對象
     * @return json結果
     */
    public static <T> JsonResult<T> successResult(int code, String message, T data) {
        JsonResult<T> jsonResult = new JsonResult<>();
        jsonResult.setCode(code);
        jsonResult.setMessage(message);
        jsonResult.setData(data);
        return jsonResult;
    }

    /**
     * 失敗返回json結果
     *
     * @param code    業務嗎
     * @param message 返回消息
     * @return json結果
     */
    public static <T> JsonResult<T> errorResult(int code, String message) {
        JsonResult<T> jsonResult = new JsonResult<>();
        jsonResult.setCode(code);
        jsonResult.setMessage(message);
        return jsonResult;
    }

    /**
     * 失敗返回json結果
     *
     * @param code 業務異常碼,需要通過異常碼匹配到異常信息
     * @param <T>
     * @return
     */
    public static <T> JsonResult<T> errorResult(int code) {
        JsonResult<T> jsonResult = new JsonResult<>();
        jsonResult.setCode(code);
        jsonResult.setMessage(ExceptionConstants.getMessage(code));
        return jsonResult;
    }

    /**
     * 失敗返回json結果
     *
     * @param code    業務嗎
     * @param message 返回消息
     * @param data    響應的業務數據
     * @return json結果
     */
    public static <T> JsonResult<T> errorResult(int code, String message, T data) {
        JsonResult<T> jsonResult = new JsonResult<>();
        jsonResult.setCode(code);
        jsonResult.setMessage(message);
        jsonResult.setData(data);
        return jsonResult;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "JsonResult{"
                + "code=" + code
                + ", message='" + message + '\''
                + ", data=" + data + '}';
    }
}

package com.feihong.springcloud.controller.vo;

/**
 * <一句話功能簡述>
 * <功能詳細描述>
 *
 * @author hyf
 * @version [版本號, 2021/1/6]
 * @see [相關類/方法]
 * @since [產品/模塊版本]
 */
public class EurekaServiceListVo {

    private String serviceId;

    private String host;

    private String homePageUrl;

    private Integer port;

    public String getServiceId() {
        return serviceId;
    }

    public void setServiceId(String serviceId) {
        this.serviceId = serviceId;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public String getHomePageUrl() {
        return homePageUrl;
    }

    public void setHomePageUrl(String homePageUrl) {
        this.homePageUrl = homePageUrl;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }
}

6、核心代碼類

package com.feihong.springcloud.service;

import com.feihong.springcloud.controller.vo.EurekaServiceListVo;
import com.feihong.springcloud.util.HttpClientUtils;
import com.feihong.springcloud.util.JsonResult;
import com.feihong.springcloud.util.LogUtil;
import com.feihong.springcloud.util.ParseXmlConstant;
import com.xiaoleilu.hutool.json.JSONArray;
import com.xiaoleilu.hutool.json.JSONObject;
import com.xiaoleilu.hutool.json.XML;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * <一句話功能簡述>
 * <功能詳細描述>
 *
 * @author hyf
 * @version [版本號, 2021/1/6]
 * @see [相關類/方法]
 * @since [產品/模塊版本]
 */
@Service
public class EurekaServiceList {

    private static LogUtil log = LogUtil.getLogger(EurekaServiceList.class);

    public JsonResult<List<EurekaServiceListVo>> getInstanceList(String url, String instanceName) {

        log.info("獲取eureka服務列表數據開始|入參：{}", url);
        String clientResult = HttpClientUtils.httpGet(url, 10, null, null);
        log.info("獲取eureka服務列表數據結束|出參：{}", clientResult);
        List<EurekaServiceListVo> serviceListVoList = Collections.emptyList();
        if (StringUtils.isEmpty(instanceName)) {
            serviceListVoList = parseResponseResult(clientResult);
        } else {
            serviceListVoList = parseResponseResult(clientResult, instanceName);
        }

        return JsonResult.successResult(serviceListVoList);
    }

    private List<EurekaServiceListVo> parseResponseResult(String responseResult, String instanceName) {
        JSONObject jsonObject = XML.toJSONObject(responseResult);
        if (StringUtils.isEmpty(responseResult)) {
            return Collections.emptyList();
        }
        JSONObject applications = jsonObject.getJSONObject(ParseXmlConstant.APPLICATIONS);
        List<EurekaServiceListVo> instanceList = new ArrayList<>();

        if (applications.get(ParseXmlConstant.APPLICATION) instanceof JSONArray) {
            //多個應用
            handleMultiApplication(applications, instanceName, instanceList);
        } else {
            //單個應用
            instanceList = handleSingleApplication(applications, instanceName);
        }
        return instanceList;
    }

    private void handleMultiApplication(JSONObject applications, String targetName,
                                        List<EurekaServiceListVo> instanceList) {
        JSONArray serviceInstance = applications.getJSONArray(ParseXmlConstant.APPLICATION);
        for (Object o : serviceInstance) {
            JSONObject application = (JSONObject) o;
            String appName = application.getStr(ParseXmlConstant.NAME);
            if (StringUtils.isEmpty(appName) || !targetName.trim().equals(appName.trim())) {
                continue;
            }
            add(application, instanceList, targetName);
        }
    }

    private List<EurekaServiceListVo> handleSingleApplication(JSONObject applications, String targetName) {
        List<EurekaServiceListVo> instanceList = new ArrayList<>();
        JSONObject application = applications.getJSONObject("application");
        String appName = application.getStr(ParseXmlConstant.NAME);
        if (StringUtils.isEmpty(appName) || !targetName.trim().equals(appName.trim())) {
            return Collections.emptyList();
        }
        add(application, instanceList, targetName);
        return instanceList;
    }


    private List<EurekaServiceListVo> parseResponseResult(String responseResult) {
        JSONObject jsonObject = XML.toJSONObject(responseResult);
        if (StringUtils.isEmpty(responseResult)) {
            return Collections.emptyList();
        }
        List<EurekaServiceListVo> instanceList = new ArrayList<>();
        JSONObject applications = jsonObject.getJSONObject(ParseXmlConstant.APPLICATIONS);

        if (applications.get(ParseXmlConstant.APPLICATION) instanceof JSONArray) {
            JSONArray serviceInstance = applications.getJSONArray(ParseXmlConstant.APPLICATION);
            for (Object o : serviceInstance) {
                JSONObject application = (JSONObject) o;
                String appName = application.getStr(ParseXmlConstant.NAME);
                add(application, instanceList, appName);
            }
        } else {
            JSONObject application = applications.getJSONObject(ParseXmlConstant.APPLICATION);
            String appName = application.getStr(ParseXmlConstant.NAME);
            add(application, instanceList, appName);
        }
        return instanceList;
    }


    private void add(JSONObject application, List<EurekaServiceListVo> instanceList, String appName) {
        if (application.get(ParseXmlConstant.INSTANCE) instanceof JSONObject) {
            EurekaServiceListVo serviceListVo = handle(application.getJSONObject(ParseXmlConstant.INSTANCE), appName);
            instanceList.add(serviceListVo);
        } else {
            JSONArray instanceArray = application.getJSONArray(ParseXmlConstant.INSTANCE);
            for (Object o : instanceArray) {
                EurekaServiceListVo serviceListVo = handle((JSONObject) o, appName);
                instanceList.add(serviceListVo);
            }
        }
    }

    private EurekaServiceListVo handle(JSONObject instance, String appName) {
        EurekaServiceListVo serviceListVo = new EurekaServiceListVo();
        serviceListVo.setPort(instance.getJSONObject(ParseXmlConstant.PORT).getInt(ParseXmlConstant.CONTENT));
        serviceListVo.setHomePageUrl(instance.getStr(ParseXmlConstant.HOME_PAGE_URL));
        serviceListVo.setHost(instance.getStr(ParseXmlConstant.HOST_NAME));
        serviceListVo.setServiceId(appName);
        return serviceListVo;
    }

}