一、第一类服务注册到eureka中，获取服务列表

1、基于SpringClientFactory获取服务列表

  1. /**
  2.  * <一句话功能简述>
  3.  * <功能详细描述>
  4.  *
  5.  * @author hyf
  6.  * @version [版本号, 2019/7/2]
  7.  * @see [相关类/方法]
  8.  * @since [产品/模块版本]
  9.  */
  10. @RestController
  11. public class DeptController_Consumer {
  12.  
  13.     @Resource
  14.     private SpringClientFactory factory;
  15.  
  16.     @RequestMapping(value = "/getAllServers")
  17.     public Object getAllServers(){
  18.         //指定服务名
  19.         ILoadBalancer lb =  factory.getLoadBalancer("MICROSERVICECLOUD");
  20.         List<Server> allServers = lb.getAllServers();
  21.         List<Server> upServers = lb.getReachableServers();
  22.         return  allServers;
  23.     }
  24.  
  25. }

2、基于DiscoveryClient 获取服务列表

  1. @RestController
  2. public class TestController {
  3.     @Autowired
  4.     private DiscoveryClient discoveryClient;
  5.  
  6.     @RequestMapping("getServicesList")
  7.     @ResponseBody
  8.     public Object getServicesList() {
  9.         List<List<ServiceInstance>> servicesList = new ArrayList<>();
  10.         //获取服务名称
  11.         List<String> serviceNames = discoveryClient.getServices();
  12.         for (String serviceName : serviceNames) {
  13.             //获取服务中的实例列表
  14.             List<ServiceInstance> serviceInstances = discoveryClient.getInstances(serviceName);
  15.             servicesList.add(serviceInstances);
  16.         }
  17.         return servicesList;
  18.     }
  19. }

二、基于eureka的restAPI，解析xml获取，该方式比较麻烦，但也是最灵活的，只需要知道eureka地址就可以获取，不要注册到eureka中

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

  1.        <dependency>
  2.             <groupId>com.xiaoleilu</groupId>
  3.             <artifactId>hutool-all</artifactId>
  4.             <version>3.0.1</version>
  5.         </dependency>

2、需要使用到HttpClientUtils

  1. package com.feihong.springcloud.util;
  2.  
  3. import java.io.IOException;
  4. import java.security.NoSuchAlgorithmException;
  5. import java.util.Map;
  6.  
  7. import javax.net.ssl.SSLContext;
  8.  
  9. import org.apache.commons.lang.StringUtils;
  10. import org.apache.http.HttpEntity;
  11. import org.apache.http.client.config.RequestConfig;
  12. import org.apache.http.client.methods.CloseableHttpResponse;
  13. import org.apache.http.client.methods.HttpGet;
  14. import org.apache.http.client.methods.HttpPost;
  15. import org.apache.http.client.utils.URIBuilder;
  16. import org.apache.http.config.Registry;
  17. import org.apache.http.config.RegistryBuilder;
  18. import org.apache.http.conn.socket.ConnectionSocketFactory;
  19. import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
  20. import org.apache.http.conn.socket.PlainConnectionSocketFactory;
  21. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
  22. import org.apache.http.entity.StringEntity;
  23. import org.apache.http.impl.client.CloseableHttpClient;
  24. import org.apache.http.impl.client.HttpClients;
  25. import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
  26. import org.apache.http.util.EntityUtils;
  27.  
  28. /**
  29.  * <httpClient 工具类> <功能详细描述>
  30.  *
  31.  * @see [相关类/方法]
  32.  * @since [产品/模块版本]
  33.  */
  34.  
  35. public final class HttpClientUtils {
  36.  
  37.     private static LogUtil log = LogUtil.getLogger(HttpClientUtils.class);
  38.  
  39.     /**
  40.      * 连接池初始化
  41.      */
  42.     private static PoolingHttpClientConnectionManager cm = null;
  43.  
  44.     /**
  45.      * 初始化httpclient 连接池
  46.      */
  47.     static {
  48.         LayeredConnectionSocketFactory sslsf = null;
  49.         try {
  50.             sslsf = new SSLConnectionSocketFactory(SSLContext.getDefault());
  51.         } catch (NoSuchAlgorithmException e) {
  52.             log.info(e.getMessage());
  53.         }
  54.         Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
  55.                 .register("https", sslsf)
  56.                 .register("http", new PlainConnectionSocketFactory())
  57.                 .build();
  58.         cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
  59.         cm.setMaxTotal(200);
  60.         cm.setDefaultMaxPerRoute(2);
  61.     }
  62.  
  63.     private HttpClientUtils() {
  64.     }
  65.  
  66.     /**
  67.      * <配置httpclient> <功能详细描述>
  68.      *
  69.      * @param timeout 请求超时时间
  70.      * @return CloseableHttpClient
  71.      * @see [类、类#方法、类#成员]
  72.      */
  73.  
  74.     private static CloseableHttpClient getHttpClient(Integer timeout) {
  75.         RequestConfig requestConfig = RequestConfig.custom().
  76.                 // 设置连接超时时间
  77.                         setConnectionRequestTimeout(timeout).
  78.                 // 设置请求超时时间
  79.                         setConnectTimeout(timeout).
  80.                 // 设置响应超时时间
  81.                         setSocketTimeout(timeout).build();
  82.         // 超时重试，服务器丢失连接重试
  83.         HttpRequestRetryHandlerImpl retry = new HttpRequestRetryHandlerImpl();
  84.         return HttpClients.custom()
  85.                 .setDefaultRequestConfig(requestConfig)
  86.                 .setRetryHandler(retry)
  87.                 .setConnectionManager(cm)
  88.                 .setConnectionManagerShared(true)
  89.                 .build();
  90.     }
  91.  
  92.     /**
  93.      * http post <功能详细描述>
  94.      *
  95.      * @param url     请求的url
  96.      * @param timeout 请求响应的时间
  97.      * @param param   请求的参数
  98.      * @param header  请求头
  99.      * @return string
  100.      * @see [类、类#方法、类#成员]
  101.      */
  102.     private static String httpPost(String url, Integer timeout, Map<String, String> param, Map<String, String> header) {
  103.         String msg = "";
  104.         // 获取客户端连接对象
  105.         CloseableHttpClient httpClient = getHttpClient(timeout);
  106.  
  107.         if(StringUtils.isBlank(url)){
  108.             throw new RuntimeException("url can not be null");
  109.         }
  110.  
  111.         HttpPost httpPost = new HttpPost(url);
  112.         StringBuilder stringBuilder = new StringBuilder("");
  113.         if (null != param) {
  114.             for (Map.Entry<String, String> entry : param.entrySet()) {
  115.                 stringBuilder.append(entry.getKey());
  116.                 stringBuilder.append('=');
  117.                 stringBuilder.append(entry.getValue());
  118.                 stringBuilder.append('&');
  119.             }
  120.             stringBuilder = stringBuilder.deleteCharAt(stringBuilder.length() - 1);
  121.         }
  122.  
  123.         CloseableHttpResponse response = null;
  124.         try {
  125.             StringEntity entityParam = new StringEntity(stringBuilder.toString());
  126.             httpPost.setEntity(entityParam);
  127.             for (Map.Entry<String, String> entry : header.entrySet()) {
  128.                 httpPost.addHeader(entry.getKey(), entry.getValue());
  129.             }
  130.             // 执行请求
  131.             response = httpClient.execute(httpPost);
  132.             // 获得响应的实体对象
  133.             HttpEntity entity = response.getEntity();
  134.             msg = EntityUtils.toString(entity, "UTF-8");
  135.  
  136.         } catch (Exception e) {
  137.             log.info("user httpPost request error", e);
  138.         } finally {
  139.             try {
  140.                 doClose(httpClient, response);
  141.             } catch (IOException e) {
  142.                 log.error("httpPost close error", e);
  143.             }
  144.         }
  145.         return msg;
  146.     }
  147.  
  148.     public static String httpGet(String url, Integer timeout, Map<String, String> map, Map<String, String> header) {
  149.         String msg = "";
  150.         CloseableHttpClient httpClient = getHttpClient(timeout);
  151.         CloseableHttpResponse response = null;
  152.         try {
  153.             // 声明URIBuilder
  154.             URIBuilder uriBuilder = new URIBuilder(url);
  155.  
  156.             // 判断参数map是否为非空
  157.             if (map != null) {
  158.                 // 遍历参数
  159.                 for (Map.Entry<String, String> entry : map.entrySet()) {
  160.                     // 设置参数
  161.                     uriBuilder.setParameter(entry.getKey(), entry.getValue());
  162.                 }
  163.             }
  164.             // 2 创建httpGet对象，相当于设置url请求地址
  165.             HttpGet httpGet = new HttpGet(uriBuilder.build());
  166.  
  167.             // 3 使用HttpClient执行httpGet，相当于按回车，发起请求
  168.             response = httpClient.execute(httpGet);
  169.  
  170.             // 4 解析结果，封装返回对象httpResult，相当于显示相应的结果
  171.             // 状态码
  172.             // response.getStatusLine().getStatusCode();
  173.             // 响应体，字符串，如果response.getEntity()为空，下面这个代码会报错,所以解析之前要做非空的判断
  174.             HttpEntity entity = response.getEntity();
  175.             msg = EntityUtils.toString(entity, "UTF-8");
  176.         } catch (Exception e) {
  177.             log.error("user httpGet request error", e);
  178.         } finally {
  179.             try {
  180.                 doClose(httpClient, response);
  181.             } catch (IOException e) {
  182.                 log.error("httpGet close error", e);
  183.             }
  184.         }
  185.         // 返回
  186.         return msg;
  187.     }
  188.  
  189.     /**
  190.      * 对资源进行关闭
  191.      *
  192.      * @param httpClient httpClient
  193.      * @param response   response
  194.      */
  195.     private static void doClose(CloseableHttpClient httpClient, CloseableHttpResponse response)
  196.             throws IOException {
  197.         if (response != null) {
  198.             response.close();
  199.         }
  200.         if (httpClient != null) {
  201.             httpClient.close();
  202.         }
  203.     }
  204. }
  1. package com.feihong.springcloud.util;
  2.  
  3. import java.io.IOException;
  4. import java.io.InterruptedIOException;
  5. import java.net.SocketTimeoutException;
  6. import java.net.UnknownHostException;
  7. import javax.net.ssl.SSLException;
  8. import javax.net.ssl.SSLHandshakeException;
  9. import org.apache.http.NoHttpResponseException;
  10. import org.apache.http.client.HttpRequestRetryHandler;
  11. import org.apache.http.conn.ConnectTimeoutException;
  12. import org.apache.http.protocol.HttpContext;
  13. import org.slf4j.Logger;
  14.  
  15. /**
  16.  * httpclient请求重试策略 httpclient请求重试策略配置类
  17.  *
  18.  * @see [相关类/方法]
  19.  * @since [产品/模块版本]
  20.  */
  21.  
  22. public class HttpRequestRetryHandlerImpl implements HttpRequestRetryHandler {
  23.  
  24.     private LogUtil log = LogUtil.getLogger(HttpRequestRetryHandlerImpl.class);
  25.  
  26.     private static final Integer COUNT = 3;
  27.  
  28.     /**
  29.      * 实现HttpRequestRetryHandler {@inheritDoc}
  30.      */
  31.     @Override
  32.     public boolean retryRequest(IOException exception, int i, HttpContext httpContext) {
  33.         // 重试次数最大为3次
  34.         if (i >= COUNT) {
  35.             return false;
  36.         }
  37.         if (exception instanceof NoHttpResponseException) {//没有响应，重试
  38.             return true;
  39.         } else if (exception instanceof ConnectTimeoutException) {//连接超时，重试
  40.             return true;
  41.         } else if (exception instanceof SocketTimeoutException) {//连接或读取超时，重试
  42.             return true;
  43.         } else if (exception instanceof SSLHandshakeException) {//本地证书异常
  44.             return false;
  45.         } else if (exception instanceof InterruptedIOException) {//被中断
  46.             return false;
  47.         } else if (exception instanceof UnknownHostException) {//找不到服务器
  48.             return false;
  49.         } else if (exception instanceof SSLException) {//SSL异常
  50.             return false;
  51.         } else {
  52.             //自己新增log
  53.             log.error("HttpRequestRetryHandlerImpl",exception);
  54.             return false;
  55.         }
  56.     }
  57.  
  58. }

3、日志打印工具类

  1. package com.feihong.springcloud.util;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.slf4j.Marker;
  6.  
  7. /**
  8.  * 日志处理工具类
  9.  *
  10.  * // 方法名|操作人（接口填null）|操作码|操作描述|业务关键信息|异常信息(不需要异常信息就不填)
  11.  * logger.error("getMenuFunctionList|{}|{}|角色名称已存在|roleId = {},roleName = {}|exception = {}",
  12.  *         SessionUtil.getCurrentUserName(), OperateLogConstants.SYS_ROLE_MODIFY, sysRoleVO.getId(),
  13.  *         sysRoleVO.getRoleName(), CommonUtil.getExceptionMessage(e));
  14.  *
  15.  * @author llx
  16.  *
  17.  */
  18. public final class LogUtil implements Logger {
  19.  
  20.     private Logger log;
  21.  
  22.     public static LogUtil getLogger(Class<?> clazz) {
  23.         return new LogUtil(clazz);
  24.     }
  25.  
  26.     private LogUtil(Class<?> clazz) {
  27.         // 私有构造函数
  28.         log = LoggerFactory.getLogger(clazz);
  29.     }
  30.  
  31.     @Override
  32.     public String getName() {
  33.         return log.getName();
  34.     }
  35.  
  36.     @Override
  37.     public boolean isTraceEnabled() {
  38.         return log.isTraceEnabled();
  39.     }
  40.  
  41.     @Override
  42.     public void trace(String s) {
  43.         if (log.isTraceEnabled()) {
  44.             log.trace(s);
  45.         }
  46.     }
  47.  
  48.     @Override
  49.     public void trace(String s, Object o) {
  50.         if (log.isTraceEnabled()) {
  51.             log.trace(s, o);
  52.         }
  53.     }
  54.  
  55.     @Override
  56.     public void trace(String s, Object o, Object o1) {
  57.         if (log.isTraceEnabled()) {
  58.             log.trace(s, o, o1);
  59.         }
  60.     }
  61.  
  62.     @Override
  63.     public void trace(String s, Object... objects) {
  64.         if (log.isTraceEnabled()) {
  65.             log.trace(s, objects);
  66.         }
  67.     }
  68.  
  69.     @Override
  70.     public void trace(String s, Throwable throwable) {
  71.         if (log.isTraceEnabled()) {
  72.             log.trace(s, throwable);
  73.         }
  74.     }
  75.  
  76.     @Override
  77.     public boolean isTraceEnabled(Marker marker) {
  78.         return log.isTraceEnabled(marker);
  79.     }
  80.  
  81.     @Override
  82.     public void trace(Marker marker, String s) {
  83.         if (log.isTraceEnabled()) {
  84.             log.trace(marker, s);
  85.         }
  86.     }
  87.  
  88.     @Override
  89.     public void trace(Marker marker, String s, Object o) {
  90.         if (log.isTraceEnabled()) {
  91.             log.trace(marker, s, o);
  92.         }
  93.     }
  94.  
  95.     @Override
  96.     public void trace(Marker marker, String s, Object o, Object o1) {
  97.         if (log.isTraceEnabled()) {
  98.             log.trace(marker, s, o, o1);
  99.         }
  100.     }
  101.  
  102.     @Override
  103.     public void trace(Marker marker, String s, Object... objects) {
  104.         if (log.isTraceEnabled()) {
  105.             log.trace(marker, s, objects);
  106.         }
  107.     }
  108.  
  109.     @Override
  110.     public void trace(Marker marker, String s, Throwable throwable) {
  111.         if (log.isTraceEnabled()) {
  112.             log.trace(marker, s, throwable);
  113.         }
  114.     }
  115.  
  116.     @Override
  117.     public boolean isDebugEnabled() {
  118.         return log.isDebugEnabled();
  119.     }
  120.  
  121.     @Override
  122.     public void debug(String s) {
  123.         if (log.isDebugEnabled()) {
  124.             log.debug(s);
  125.         }
  126.     }
  127.  
  128.     @Override
  129.     public void debug(String s, Object o) {
  130.         if (log.isDebugEnabled()) {
  131.             log.debug(s, o);
  132.         }
  133.     }
  134.  
  135.     @Override
  136.     public void debug(String s, Object o, Object o1) {
  137.         if (log.isDebugEnabled()) {
  138.             log.debug(s, o, o1);
  139.         }
  140.     }
  141.  
  142.     @Override
  143.     public void debug(String s, Object... objects) {
  144.         if (log.isDebugEnabled()) {
  145.             log.debug(s, objects);
  146.         }
  147.     }
  148.  
  149.     @Override
  150.     public void debug(String s, Throwable throwable) {
  151.         if (log.isDebugEnabled()) {
  152.             log.debug(s, throwable);
  153.         }
  154.     }
  155.  
  156.     @Override
  157.     public boolean isDebugEnabled(Marker marker) {
  158.         return log.isDebugEnabled(marker);
  159.     }
  160.  
  161.     @Override
  162.     public void debug(Marker marker, String s) {
  163.         if (log.isDebugEnabled()) {
  164.             log.debug(marker, s);
  165.         }
  166.     }
  167.  
  168.     @Override
  169.     public void debug(Marker marker, String s, Object o) {
  170.         if (log.isDebugEnabled()) {
  171.             log.debug(marker, s, o);
  172.         }
  173.     }
  174.  
  175.     @Override
  176.     public void debug(Marker marker, String s, Object o, Object o1) {
  177.         if (log.isDebugEnabled()) {
  178.             log.debug(marker, s, o, o1);
  179.         }
  180.     }
  181.  
  182.     @Override
  183.     public void debug(Marker marker, String s, Object... objects) {
  184.         if (log.isDebugEnabled()) {
  185.             log.debug(marker, s, objects);
  186.         }
  187.     }
  188.  
  189.     @Override
  190.     public void debug(Marker marker, String s, Throwable throwable) {
  191.         if (log.isDebugEnabled()) {
  192.             log.debug(marker, s, throwable);
  193.         }
  194.     }
  195.  
  196.     @Override
  197.     public boolean isInfoEnabled() {
  198.         return log.isInfoEnabled();
  199.     }
  200.  
  201.     @Override
  202.     public void info(String s) {
  203.         if (log.isInfoEnabled()) {
  204.             log.info(s);
  205.         }
  206.     }
  207.  
  208.     @Override
  209.     public void info(String s, Object o) {
  210.         if (log.isInfoEnabled()) {
  211.             log.info(s, o);
  212.         }
  213.     }
  214.  
  215.     @Override
  216.     public void info(String s, Object o, Object o1) {
  217.         if (log.isInfoEnabled()) {
  218.             log.info(s, o, o1);
  219.         }
  220.     }
  221.  
  222.     @Override
  223.     public void info(String s, Object... objects) {
  224.         if (log.isInfoEnabled()) {
  225.             log.info(s, objects);
  226.         }
  227.     }
  228.  
  229.     @Override
  230.     public void info(String s, Throwable throwable) {
  231.         if (log.isInfoEnabled()) {
  232.             log.info(s, throwable);
  233.         }
  234.     }
  235.  
  236.     @Override
  237.     public boolean isInfoEnabled(Marker marker) {
  238.         return log.isInfoEnabled(marker);
  239.     }
  240.  
  241.     @Override
  242.     public void info(Marker marker, String s) {
  243.         if (log.isInfoEnabled()) {
  244.             log.info(marker, s);
  245.         }
  246.     }
  247.  
  248.     @Override
  249.     public void info(Marker marker, String s, Object o) {
  250.         if (log.isInfoEnabled()) {
  251.             log.info(marker, s, o);
  252.         }
  253.     }
  254.  
  255.     @Override
  256.     public void info(Marker marker, String s, Object o, Object o1) {
  257.         if (log.isInfoEnabled()) {
  258.             log.info(marker, s, o, o1);
  259.         }
  260.     }
  261.  
  262.     @Override
  263.     public void info(Marker marker, String s, Object... objects) {
  264.         if (log.isInfoEnabled()) {
  265.             log.info(marker, s, objects);
  266.         }
  267.     }
  268.  
  269.     @Override
  270.     public void info(Marker marker, String s, Throwable throwable) {
  271.         if (log.isInfoEnabled()) {
  272.             log.info(marker, s, throwable);
  273.         }
  274.     }
  275.  
  276.     @Override
  277.     public boolean isWarnEnabled() {
  278.         return log.isWarnEnabled();
  279.     }
  280.  
  281.     @Override
  282.     public void warn(String s) {
  283.         if (log.isWarnEnabled()) {
  284.             log.warn(s);
  285.         }
  286.     }
  287.  
  288.     @Override
  289.     public void warn(String s, Object o) {
  290.         if (log.isWarnEnabled()) {
  291.             log.warn(s, o);
  292.         }
  293.     }
  294.  
  295.     @Override
  296.     public void warn(String s, Object... objects) {
  297.         if (log.isWarnEnabled()) {
  298.             log.warn(s, objects);
  299.         }
  300.     }
  301.  
  302.     @Override
  303.     public void warn(String s, Object o, Object o1) {
  304.         if (log.isWarnEnabled()) {
  305.             log.warn(s, o, o1);
  306.         }
  307.     }
  308.  
  309.     @Override
  310.     public void warn(String s, Throwable throwable) {
  311.         if (log.isWarnEnabled()) {
  312.             log.warn(s, throwable);
  313.         }
  314.     }
  315.  
  316.     @Override
  317.     public boolean isWarnEnabled(Marker marker) {
  318.         return log.isWarnEnabled(marker);
  319.     }
  320.  
  321.     @Override
  322.     public void warn(Marker marker, String s) {
  323.         if (log.isWarnEnabled()) {
  324.             log.warn(marker, s);
  325.         }
  326.     }
  327.  
  328.     @Override
  329.     public void warn(Marker marker, String s, Object o) {
  330.         if (log.isWarnEnabled()) {
  331.             log.warn(marker, s, o);
  332.         }
  333.     }
  334.  
  335.     @Override
  336.     public void warn(Marker marker, String s, Object o, Object o1) {
  337.         if (log.isWarnEnabled()) {
  338.             log.warn(marker, s, o, o1);
  339.         }
  340.     }
  341.  
  342.     @Override
  343.     public void warn(Marker marker, String s, Object... objects) {
  344.         if (log.isWarnEnabled()) {
  345.             log.warn(marker, s, objects);
  346.         }
  347.     }
  348.  
  349.     @Override
  350.     public void warn(Marker marker, String s, Throwable throwable) {
  351.         if (log.isWarnEnabled()) {
  352.             log.warn(marker, s, throwable);
  353.         }
  354.     }
  355.  
  356.     @Override
  357.     public boolean isErrorEnabled() {
  358.         return log.isErrorEnabled();
  359.     }
  360.  
  361.     @Override
  362.     public void error(String s) {
  363.         if (log.isErrorEnabled()) {
  364.             log.error(s);
  365.         }
  366.     }
  367.  
  368.     @Override
  369.     public void error(String s, Object o) {
  370.         if (log.isErrorEnabled()) {
  371.             log.error(s, o);
  372.         }
  373.     }
  374.  
  375.     @Override
  376.     public void error(String s, Object o, Object o1) {
  377.         if (log.isErrorEnabled()) {
  378.             log.error(s, o, o1);
  379.         }
  380.     }
  381.  
  382.     @Override
  383.     public void error(String s, Object... objects) {
  384.         if (log.isErrorEnabled()) {
  385.             log.error(s, objects);
  386.         }
  387.     }
  388.  
  389.     @Override
  390.     public void error(String s, Throwable throwable) {
  391.         if (log.isErrorEnabled()) {
  392.             log.error(s, throwable);
  393.         }
  394.     }
  395.  
  396.     @Override
  397.     public boolean isErrorEnabled(Marker marker) {
  398.         return log.isErrorEnabled(marker);
  399.     }
  400.  
  401.     @Override
  402.     public void error(Marker marker, String s) {
  403.         if (log.isErrorEnabled()) {
  404.             log.error(marker, s);
  405.         }
  406.     }
  407.  
  408.     @Override
  409.     public void error(Marker marker, String s, Object o) {
  410.         if (log.isErrorEnabled()) {
  411.             log.error(marker, s, o);
  412.         }
  413.     }
  414.  
  415.     @Override
  416.     public void error(Marker marker, String s, Object o, Object o1) {
  417.         if (log.isErrorEnabled()) {
  418.             log.error(marker, s, o, o1);
  419.         }
  420.     }
  421.  
  422.     @Override
  423.     public void error(Marker marker, String s, Object... objects) {
  424.         if (log.isErrorEnabled()) {
  425.             log.error(marker, s, objects);
  426.         }
  427.     }
  428.  
  429.     @Override
  430.     public void error(Marker marker, String s, Throwable throwable) {
  431.         if (log.isErrorEnabled()) {
  432.             log.error(marker, s, throwable);
  433.         }
  434.     }
  435. }

4、解析XML常量类

  1. package com.feihong.springcloud.util;
  2.  
  3. /**
  4.  * <一句话功能简述>
  5.  * <功能详细描述>
  6.  *
  7.  * @author hyf
  8.  * @version [版本号, 2021/1/6]
  9.  * @see [相关类/方法]
  10.  * @since [产品/模块版本]
  11.  */
  12. public class ParseXmlConstant {
  13.  
  14.     private ParseXmlConstant(){}
  15.  
  16.     public static final String APPLICATIONS = "applications";
  17.  
  18.     public static final String APPLICATION = "application";
  19.  
  20.     public static final String NAME = "name";
  21.  
  22.     public static final String HOST_NAME = "hostName";
  23.  
  24.     public static final String CONTENT = "content";
  25.  
  26.     public static final String PORT = "port";
  27.  
  28.     public static final String HOME_PAGE_URL = "homePageUrl";
  29.  
  30.     public static final String SERVICE_ID = "serviceId";
  31.  
  32.     public static final String INSTANCE = "instance";
  33.  
  34. }

5、响应实体类

  1. package com.feihong.springcloud.util;
  2.  
  3. /**
  4.  * 返回结果通用对象
  5.  *
  6.  * @param <T> 结果类型
  7.  * @author llx
  8.  */
  9. public class JsonResult<T> {
  10.     private int code;
  11.  
  12.     private String message;
  13.  
  14.     private T data;
  15.  
  16.     /**
  17.      * 成功返回json结果
  18.      *
  19.      * @param data 业务对象
  20.      * @return json结果
  21.      */
  22.     public static <T> JsonResult<T> successResult(T data) {
  23.         JsonResult<T> jsonResult = new JsonResult<>();
  24.         jsonResult.setCode(ExceptionConstants.PARAM_SUCCESS);
  25.         jsonResult.setMessage(
  26.                 ExceptionConstants.getDefaultMessageMap().get(ExceptionConstants.PARAM_SUCCESS));
  27.         jsonResult.setData(data);
  28.         return jsonResult;
  29.     }
  30.  
  31.     /**
  32.      * 成功返回json结果
  33.      *
  34.      * @param data 业务对象
  35.      * @return json结果
  36.      */
  37.     public static <T> JsonResult<T> successResult(int code, String message, T data) {
  38.         JsonResult<T> jsonResult = new JsonResult<>();
  39.         jsonResult.setCode(code);
  40.         jsonResult.setMessage(message);
  41.         jsonResult.setData(data);
  42.         return jsonResult;
  43.     }
  44.  
  45.     /**
  46.      * 失败返回json结果
  47.      *
  48.      * @param code    业务吗
  49.      * @param message 返回消息
  50.      * @return json结果
  51.      */
  52.     public static <T> JsonResult<T> errorResult(int code, String message) {
  53.         JsonResult<T> jsonResult = new JsonResult<>();
  54.         jsonResult.setCode(code);
  55.         jsonResult.setMessage(message);
  56.         return jsonResult;
  57.     }
  58.  
  59.     /**
  60.      * 失败返回json结果
  61.      *
  62.      * @param code 业务异常码,需要通过异常码匹配到异常信息
  63.      * @param <T>
  64.      * @return
  65.      */
  66.     public static <T> JsonResult<T> errorResult(int code) {
  67.         JsonResult<T> jsonResult = new JsonResult<>();
  68.         jsonResult.setCode(code);
  69.         jsonResult.setMessage(ExceptionConstants.getMessage(code));
  70.         return jsonResult;
  71.     }
  72.  
  73.     /**
  74.      * 失败返回json结果
  75.      *
  76.      * @param code    业务吗
  77.      * @param message 返回消息
  78.      * @param data    响应的业务数据
  79.      * @return json结果
  80.      */
  81.     public static <T> JsonResult<T> errorResult(int code, String message, T data) {
  82.         JsonResult<T> jsonResult = new JsonResult<>();
  83.         jsonResult.setCode(code);
  84.         jsonResult.setMessage(message);
  85.         jsonResult.setData(data);
  86.         return jsonResult;
  87.     }
  88.  
  89.     public int getCode() {
  90.         return code;
  91.     }
  92.  
  93.     public void setCode(int code) {
  94.         this.code = code;
  95.     }
  96.  
  97.     public String getMessage() {
  98.         return message;
  99.     }
  100.  
  101.     public void setMessage(String message) {
  102.         this.message = message;
  103.     }
  104.  
  105.     public T getData() {
  106.         return data;
  107.     }
  108.  
  109.     public void setData(T data) {
  110.         this.data = data;
  111.     }
  112.  
  113.     @Override
  114.     public String toString() {
  115.         return "JsonResult{"
  116.                 + "code=" + code
  117.                 + ", message='" + message + '\''
  118.                 + ", data=" + data + '}';
  119.     }
  120. }
  1. package com.feihong.springcloud.controller.vo;
  2.  
  3. /**
  4.  * <一句话功能简述>
  5.  * <功能详细描述>
  6.  *
  7.  * @author hyf
  8.  * @version [版本号, 2021/1/6]
  9.  * @see [相关类/方法]
  10.  * @since [产品/模块版本]
  11.  */
  12. public class EurekaServiceListVo {
  13.  
  14.     private String serviceId;
  15.  
  16.     private String host;
  17.  
  18.     private String homePageUrl;
  19.  
  20.     private Integer port;
  21.  
  22.     public String getServiceId() {
  23.         return serviceId;
  24.     }
  25.  
  26.     public void setServiceId(String serviceId) {
  27.         this.serviceId = serviceId;
  28.     }
  29.  
  30.     public String getHost() {
  31.         return host;
  32.     }
  33.  
  34.     public void setHost(String host) {
  35.         this.host = host;
  36.     }
  37.  
  38.     public String getHomePageUrl() {
  39.         return homePageUrl;
  40.     }
  41.  
  42.     public void setHomePageUrl(String homePageUrl) {
  43.         this.homePageUrl = homePageUrl;
  44.     }
  45.  
  46.     public Integer getPort() {
  47.         return port;
  48.     }
  49.  
  50.     public void setPort(Integer port) {
  51.         this.port = port;
  52.     }
  53. }

6、核心代码类

  1. package com.feihong.springcloud.service;
  2.  
  3. import com.feihong.springcloud.controller.vo.EurekaServiceListVo;
  4. import com.feihong.springcloud.util.HttpClientUtils;
  5. import com.feihong.springcloud.util.JsonResult;
  6. import com.feihong.springcloud.util.LogUtil;
  7. import com.feihong.springcloud.util.ParseXmlConstant;
  8. import com.xiaoleilu.hutool.json.JSONArray;
  9. import com.xiaoleilu.hutool.json.JSONObject;
  10. import com.xiaoleilu.hutool.json.XML;
  11. import org.apache.commons.lang.StringUtils;
  12. import org.springframework.stereotype.Service;
  13.  
  14. import java.util.ArrayList;
  15. import java.util.Collections;
  16. import java.util.List;
  17.  
  18. /**
  19.  * <一句话功能简述>
  20.  * <功能详细描述>
  21.  *
  22.  * @author hyf
  23.  * @version [版本号, 2021/1/6]
  24.  * @see [相关类/方法]
  25.  * @since [产品/模块版本]
  26.  */
  27. @Service
  28. public class EurekaServiceList {
  29.  
  30.     private static LogUtil log = LogUtil.getLogger(EurekaServiceList.class);
  31.  
  32.     public JsonResult<List<EurekaServiceListVo>> getInstanceList(String url, String instanceName) {
  33.  
  34.         log.info("获取eureka服务列表数据开始|入参：{}", url);
  35.         String clientResult = HttpClientUtils.httpGet(url, 10, null, null);
  36.         log.info("获取eureka服务列表数据结束|出参：{}", clientResult);
  37.         List<EurekaServiceListVo> serviceListVoList = Collections.emptyList();
  38.         if (StringUtils.isEmpty(instanceName)) {
  39.             serviceListVoList = parseResponseResult(clientResult);
  40.         } else {
  41.             serviceListVoList = parseResponseResult(clientResult, instanceName);
  42.         }
  43.  
  44.         return JsonResult.successResult(serviceListVoList);
  45.     }
  46.  
  47.     private List<EurekaServiceListVo> parseResponseResult(String responseResult, String instanceName) {
  48.         JSONObject jsonObject = XML.toJSONObject(responseResult);
  49.         if (StringUtils.isEmpty(responseResult)) {
  50.             return Collections.emptyList();
  51.         }
  52.         JSONObject applications = jsonObject.getJSONObject(ParseXmlConstant.APPLICATIONS);
  53.         List<EurekaServiceListVo> instanceList = new ArrayList<>();
  54.  
  55.         if (applications.get(ParseXmlConstant.APPLICATION) instanceof JSONArray) {
  56.             //多个应用
  57.             handleMultiApplication(applications, instanceName, instanceList);
  58.         } else {
  59.             //单个应用
  60.             instanceList = handleSingleApplication(applications, instanceName);
  61.         }
  62.         return instanceList;
  63.     }
  64.  
  65.     private void handleMultiApplication(JSONObject applications, String targetName,
  66.                                         List<EurekaServiceListVo> instanceList) {
  67.         JSONArray serviceInstance = applications.getJSONArray(ParseXmlConstant.APPLICATION);
  68.         for (Object o : serviceInstance) {
  69.             JSONObject application = (JSONObject) o;
  70.             String appName = application.getStr(ParseXmlConstant.NAME);
  71.             if (StringUtils.isEmpty(appName) || !targetName.trim().equals(appName.trim())) {
  72.                 continue;
  73.             }
  74.             add(application, instanceList, targetName);
  75.         }
  76.     }
  77.  
  78.     private List<EurekaServiceListVo> handleSingleApplication(JSONObject applications, String targetName) {
  79.         List<EurekaServiceListVo> instanceList = new ArrayList<>();
  80.         JSONObject application = applications.getJSONObject("application");
  81.         String appName = application.getStr(ParseXmlConstant.NAME);
  82.         if (StringUtils.isEmpty(appName) || !targetName.trim().equals(appName.trim())) {
  83.             return Collections.emptyList();
  84.         }
  85.         add(application, instanceList, targetName);
  86.         return instanceList;
  87.     }
  88.  
  89.     private List<EurekaServiceListVo> parseResponseResult(String responseResult) {
  90.         JSONObject jsonObject = XML.toJSONObject(responseResult);
  91.         if (StringUtils.isEmpty(responseResult)) {
  92.             return Collections.emptyList();
  93.         }
  94.         List<EurekaServiceListVo> instanceList = new ArrayList<>();
  95.         JSONObject applications = jsonObject.getJSONObject(ParseXmlConstant.APPLICATIONS);
  96.  
  97.         if (applications.get(ParseXmlConstant.APPLICATION) instanceof JSONArray) {
  98.             JSONArray serviceInstance = applications.getJSONArray(ParseXmlConstant.APPLICATION);
  99.             for (Object o : serviceInstance) {
  100.                 JSONObject application = (JSONObject) o;
  101.                 String appName = application.getStr(ParseXmlConstant.NAME);
  102.                 add(application, instanceList, appName);
  103.             }
  104.         } else {
  105.             JSONObject application = applications.getJSONObject(ParseXmlConstant.APPLICATION);
  106.             String appName = application.getStr(ParseXmlConstant.NAME);
  107.             add(application, instanceList, appName);
  108.         }
  109.         return instanceList;
  110.     }
  111.  
  112.     private void add(JSONObject application, List<EurekaServiceListVo> instanceList, String appName) {
  113.         if (application.get(ParseXmlConstant.INSTANCE) instanceof JSONObject) {
  114.             EurekaServiceListVo serviceListVo = handle(application.getJSONObject(ParseXmlConstant.INSTANCE), appName);
  115.             instanceList.add(serviceListVo);
  116.         } else {
  117.             JSONArray instanceArray = application.getJSONArray(ParseXmlConstant.INSTANCE);
  118.             for (Object o : instanceArray) {
  119.                 EurekaServiceListVo serviceListVo = handle((JSONObject) o, appName);
  120.                 instanceList.add(serviceListVo);
  121.             }
  122.         }
  123.     }
  124.  
  125.     private EurekaServiceListVo handle(JSONObject instance, String appName) {
  126.         EurekaServiceListVo serviceListVo = new EurekaServiceListVo();
  127.         serviceListVo.setPort(instance.getJSONObject(ParseXmlConstant.PORT).getInt(ParseXmlConstant.CONTENT));
  128.         serviceListVo.setHomePageUrl(instance.getStr(ParseXmlConstant.HOME_PAGE_URL));
  129.         serviceListVo.setHost(instance.getStr(ParseXmlConstant.HOST_NAME));
  130.         serviceListVo.setServiceId(appName);
  131.         return serviceListVo;
  132.     }
  133.  
  134. }

获取Eureka服务列表的各种场景的更多相关文章

  1. 使用 http 请求方式获取 eureka server的服务信息

    对于一些系统不能接入 eureka server,又需要访问接入eureka server 的服务. 方法一:直接调用服务的地址是一种实现方式,弊端就是地址是写死的,万一服务地址变更则访问不到. 方法 ...

  2. 微信小程序获取用户信息“授权失败”场景的处理

    很多的时候我们在处理小程序功能的时候需要用户获取用户信息,但是呢为了信息安全,用户不授权导致授权失败场景:但是小程序第二次不在启动授权信息弹层,为了用户体验,可以用以下方式处理: function i ...

  3. 通过LoadBalancerClient获取所有服务列表的IP

    说明:LoadBalanced采用轮训的方式请求服务提供者,但是如果针对某些业务需要精确到某个服务提供者或者遍历所有的服务提供者,那么可以通过LoadBalancerClient去获得. 参考: ht ...

  4. 深入理解Eureka - Eureka Client获取注册信息机制

    深入理解Eureka - Eureka Client获取注册信息机 Eureka Client提供了定时获取注册信息的机制.Eureka Client获取注册信息的所有逻辑都在DiscoveryCli ...

  5. SpringCloud入门1-服务注册与发现(Eureka)

    前言 Oracle转让Java,各种动态语言的曝光率上升,Java工程师的未来在哪里?我觉得Spring Cloud让未来有无限可能.拖了半年之久的Spring Cloud学习就从今天开始了.中文教材 ...

  6. SpringCloud学习1-服务注册与发现(Eureka)

    由于样式兼容性问题,本文后半部分被截断,可到个人博客找到本文: https://blog.rmiao.top/springcloud-eureka/ 前言 Oracle转让Java,各种动态语言的曝光 ...

  7. 跟我学SpringCloud | 第二篇：注册中心Eureka

    Eureka是Netflix开源的一款提供服务注册和发现的产品,它提供了完整的Service Registry和Service Discovery实现.也是springcloud体系中最重要最核心的组 ...

  8. 服务注册组件——Eureka高可用集群搭建

    服务注册组件--Eureka高可用集群搭建 什么是Eureka? 服务注册组件:将微服务注册到Eureka中. 为什么需要服务注册? 微服务开发重点在一个"微"字,大型应用拆分成微 ...

  9. SpringCloud（二）- 服务注册与发现Eureka

    离上一篇微服务的基本概念已经过去了几个月,在写那篇博客之前,自己还并未真正的使用微服务架构,很多理解还存在概念上.后面换了公司,新公司既用了SpringCloud也用了Dubbo+Zookeeper, ...

随机推荐

  1. 数据库SQL查询作业

    --设有三个关系 --S(S#,SNAME,AGE,SEX) --SC(S#,C#,GRADE) --C(C#,CNAME,TEACHER) --(1)检索LIU老师所授课程的课程号.课程名 sele ...

  2. 文件查找工具 find 详解（附：生产示例）

    1. 文件查找:在文件系统上查找符合条件的文件 命令 解释 which 查看可执行文件的位置,只能寻找执行文件,并在PATH变量里面寻找 whereis 查看文件的位置:只能查二进制文件,说明文档,源 ...

  3. elementui 表格格式化

    <el-table-column prop="userType" label="角色" width="180" :formatter= ...

  4. 结对编程_stage1

    项目 内容 这个作业属于哪个课程 2021春季软件工程(罗杰 任健) 这个作业的要求在哪里 结对项目-第一阶段 我在这个课程的目标是 从实践中学习软件工程相关知识(结构化分析和设计方法.敏捷开发方法. ...

  5. OO第四单元总结及学期总结

    目录 OO第四单元总结及学期总结 第四单元三次作业架构设计 第十三次作业 第十四次作业 第十五次作业 四个单元中架构设计及OO方法理解的演进 第一单元 第二单元 第三单元 第四单元 四个单元中测试理解 ...

  6. 字符串转成KB，MB, GB

    import java.text.DecimalFormat; public class SizeUtil { public static String GetImageSize(String ima ...

  7. https如何使用python+flask来实现

    摘要:一般http中存在请求信息明文传输,容易被窃听截取:数据的完整性未校验,容易被篡改:没有验证对方身份,存在冒充危险.面对这些问题,怎么破? 一.为什么要用https 一般http中存在如下问题: ...

  8. 痞子衡嵌入式：实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形（无缓存）

    大家好,我是痞子衡,是正经搞技术的痞子.今天痞子衡给大家介绍的是实抓Flash信号波形来看i.MXRT的FlexSPI外设下AHB读访问情形. 上一篇文章 <i.MXRT中FlexSPI外设对A ...

  9. 【手打】coredns单台使用

    目录: coredns介绍 coredns安装 corendns配置 coredns介绍 CoreDNS 其实就是一个 DNS 服务,而 DNS 作为一种常见的服务发现手段,所以很多开源项目以及工程师 ...

  10. 路由器逆向分析------MIPS系统网络的配置(QEMU)

    本文博客地址:http://blog.csdn.net/qq1084283172/article/details/69378333 MIPS系统网络的配置  使用QEMU 模拟正在运行的MIPS系统并 ...