Divide the MSB source codes into two repos

Change-Id: Ie76d545b214a8ce5191f215350a623e1529983d9
Issue-id: MSB-5
Signed-off-by: HuabingZhao <zhao.huabing@zte.com.cn>

12 files changed, 2135 insertions, 0 deletions

diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/CommonUtil.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/CommonUtil.java
new file mode 100644
index 0000000..2ad84a7
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/CommonUtil.java
@@ -0,0 +1,76 @@
+package org.onap.msb.apiroute.wrapper.util;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.apache.commons.lang3.StringUtils;
+
+public class CommonUtil {
+
+  public static final int SC_OK = 200;
+  
+  public static Object[] concat(Object[] a, Object[] b) {
+    Object[] c = new Object[a.length + b.length];
+    System.arraycopy(a, 0, c, 0, a.length);
+    System.arraycopy(b, 0, c, a.length, b.length);
+    return c;
+  }
+
+  public static boolean contain(String strArray, String str) {
+    String[] array = StringUtils.split(strArray, ",");
+    return contain(array, str);
+  }
+
+  public static boolean contain(String[] array, String str) {
+    for (int i = 0; i < array.length; i++) {
+      if (array[i].trim().equals(str)) {
+        return true;
+      }
+    }
+    return false;
+
+  }
+
+  public static boolean contain(String[] array, String value[]) {
+    for (int i = 0; i < array.length; i++) {
+      for (int n = 0; n < value.length; n++) {
+        if (array[i].equals(value[n])) {
+          return true;
+        }
+      }
+    }
+    return false;
+
+  }
+
+  /**
+   * @param <T>
+   * @Title getDiffrent
+   * @Description TODO(Extract the list1 and list2 different data sets)
+   * @param list1
+   * @param list2
+   * @return TODO（a new List in list2 but not in list1）
+   * @return List<String>
+   */
+  public static <T> Set<T> getDiffrent(Set<T> list1, Set<T> list2) {
+
+    HashSet<T> set_all = new HashSet<T>();
+
+    for (T t1 : list1) {
+      set_all.add(t1);
+    }
+
+
+    Set<T> diff = new HashSet<T>();
+
+    for (T t2 : list2) {
+      if (set_all.add(t2)) { // in list2 but not in list1
+        diff.add(t2);
+      }
+    }
+
+
+    return diff;
+  }
+
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/ConfigUtil.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/ConfigUtil.java
new file mode 100644
index 0000000..80f99f4
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/ConfigUtil.java
@@ -0,0 +1,446 @@
+package org.onap.msb.apiroute.wrapper.util;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+import org.onap.msb.apiroute.ApiRouteAppConfig;
+import org.onap.msb.apiroute.api.DiscoverInfo;
+import org.onap.msb.apiroute.wrapper.InitRouteServiceWrapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@SuppressWarnings("unchecked")
+public class ConfigUtil {
+  private final static ConfigUtil instance = new ConfigUtil();
+
+
+  private ConfigUtil() {}
+
+  public static ConfigUtil getInstance() {
+    return instance;
+  }
+  
+  private static final Logger LOGGER = LoggerFactory.getLogger(ConfigUtil.class);
+  
+  private String serverPort="80";
+  
+  private String IUI_ROOT_PATH="iui";  
+  
+  private  String API_ROOT_PATH="api"; 
+  
+  private String namespaceMatches="all";
+  
+  private String visualRangeMatches="0";
+  
+  private String nodeMetaQueryParam="";
+  
+  private String network_plane_typeMatches="";
+  
+  private String[] routeWay={"ip"};
+  
+  private Map<String,String> labelMapMatches;
+  
+  private DiscoverInfo discoverInfo=new DiscoverInfo();  
+  
+  private String consul_ip="";
+  
+  private  String metricsUrl = "http://127.0.0.1:8066/admin/metrics";
+  
+  public void initRootPath() {
+    String apiRootPathConfSource="Default";
+    String iuiRootPathConfSource="Default";
+    
+    try {
+      
+      URL urlRootPath =
+          ConfigUtil.class.getResource("/ext/initUrlRootPath/initUrlRootPath.json");
+      if (urlRootPath != null) {
+        String path = urlRootPath.getPath();
+
+        LOGGER.warn("read initUrlRootPath:" + path);
+
+        String fileContent = FileUtil.readFile(path);
+        ObjectMapper mapper = new ObjectMapper();
+      
+        Map<String, String> map = mapper.readValue(fileContent, HashMap.class);
+        if (map.get("iuiRootPath") != null) {
+          IUI_ROOT_PATH = map.get("iuiRootPath");
+          iuiRootPathConfSource="initUrlRootPath.json";
+        }
+        if (map.get("apiRootPath") != null) {
+          API_ROOT_PATH = map.get("apiRootPath");
+          apiRootPathConfSource="initUrlRootPath.json";
+        }
+       
+      }
+    } catch (IOException e) {
+      // TODO Auto-generated catch block
+      LOGGER.error("init UrlRootPath throw exception", e);
+    }
+    
+    LOGGER.warn("init IUI_ROOT_PATH from ["+iuiRootPathConfSource+"]:"+IUI_ROOT_PATH);
+    LOGGER.warn("init API_ROOT_PATH from ["+apiRootPathConfSource+"]:"+API_ROOT_PATH);
+
+  }
+  
+  public void initApiGatewayPort() {
+    
+    String env_APIGATEWAY_EXPOSE_PORT=System.getenv("APIGATEWAY_EXPOSE_PORT");
+    String httpExposePortConfSource="Default";
+    try {
+      // read initApiGatewayConfig
+      if (StringUtils.isBlank(env_APIGATEWAY_EXPOSE_PORT)) {
+        URL apiGatewayConfigPath =
+            ConfigUtil.class
+                .getResource("/ext/initApiGatewayConfig/initApiGatewayConfig.json");
+        if (apiGatewayConfigPath != null) {
+          String path = apiGatewayConfigPath.getPath();
+
+          LOGGER.warn("read initApiGatewayConfig:" + path);
+
+          String fileContent = FileUtil.readFile(path);
+          ObjectMapper mapper = new ObjectMapper();
+
+          Map<String, Object> labelMap = mapper.readValue(fileContent, Map.class);
+          if (labelMap.get("port") != null) {
+            serverPort = (String) labelMap.get("port");
+            httpExposePortConfSource="initApiGatewayConfig.json";
+          }
+        }
+      } else {
+           serverPort = env_APIGATEWAY_EXPOSE_PORT;
+           httpExposePortConfSource="env:APIGATEWAY_EXPOSE_PORT";
+      }
+      LOGGER.warn("init APIGATEWAY http publish Port from ["+httpExposePortConfSource+"]:"+serverPort);
+    } catch (Exception e) {
+      // TODO Auto-generated catch block
+      LOGGER.error(
+          "read  initApiGatewayConfig Files or env(APIGATEWAY_EXPOSE_PORT) throw exception", e);
+    }
+    
+   
+  }
+  
+  public void initConsulIp() {
+    String sys_consulIp=System.getenv("CONSUL_IP");
+    if (StringUtils.isNotBlank(sys_consulIp)) {
+      consul_ip=sys_consulIp;
+      LOGGER.warn("init consul_Ip  from [env:CONSUL_IP]:" + sys_consulIp);
+    }
+    else{
+      LOGGER.warn("init consul_Ip  from [env:CONSUL_IP] is blank");
+    }
+    
+
+  }
+  
+  public void initRouteNameSpaceMatches() {
+    String env_NAMESPACE=System.getenv("NAMESPACE");
+    String namespaceConfSource="Default";
+    try {
+      // read NAMESPACE
+      if (StringUtils.isBlank(env_NAMESPACE)) {
+        URL routeLabelsPath =
+            InitRouteServiceWrapper.class
+                .getResource("/ext/initRouteLabels/initRouteLabelsMatches.json");
+        if (routeLabelsPath != null) {
+          String path = routeLabelsPath.getPath();
+
+          String fileContent = FileUtil.readFile(path);
+          ObjectMapper mapper = new ObjectMapper();
+
+          Map<String, Object> labelMap = mapper.readValue(fileContent, Map.class);
+          if (labelMap.get("namespace") != null) {
+            namespaceMatches = (String) labelMap.get("namespace");
+            namespaceConfSource="initRouteLabelsMatches.json";
+          }
+        }
+      } else {
+        namespaceMatches =env_NAMESPACE;
+        namespaceConfSource="env:NAMESPACE";
+      }
+      LOGGER.warn("init namespace Filter from ["+namespaceConfSource+"]:" + namespaceMatches);
+    }
+    catch (Exception e) {
+      // TODO Auto-generated catch block
+      LOGGER.error("read  initRouteNameSpaceMatches Files or env(NAMESPACE) throw exception",
+          e);
+    }
+    
+  
+
+ }
+  /**
+   * @Title: initRouteLabelsMatches
+   * @Description: TODO(According to the environment variable or a JSON file configuration
+   *               initialization Route filter conditions)
+   * @return: void
+   */
+  public void initRouteLabelsMatches() {
+    String env_ROUTE_LABELS=System.getenv("ROUTE_LABELS");
+    String visualRangeConfSource="Default";
+    String networkPlaneConfSource="Default";
+    String labelConfSource="Default";
+    try {
+     
+      // read ROUTE_LABELS
+      if (StringUtils.isBlank(env_ROUTE_LABELS)) {
+        URL routeLabelsPath =
+            InitRouteServiceWrapper.class
+                .getResource("/ext/initRouteLabels/initRouteLabelsMatches.json");
+        if (routeLabelsPath != null) {
+          String path = routeLabelsPath.getPath();
+
+          String fileContent = FileUtil.readFile(path);
+          ObjectMapper mapper = new ObjectMapper();
+
+          Map<?, ?> labelMap = mapper.readValue(fileContent, Map.class);
+          if (labelMap.get("predefineLabels") != null) {
+            Map<String, String> predefineLabelMapMatches =
+                (Map<String, String>) labelMap.get("predefineLabels");
+            if (predefineLabelMapMatches.get("visualRange") != null) {
+              visualRangeMatches = predefineLabelMapMatches.get("visualRange");
+              visualRangeConfSource="initRouteLabelsMatches.json";
+            }
+            if (predefineLabelMapMatches.get("network_plane_type") != null) {
+              network_plane_typeMatches =
+                  predefineLabelMapMatches.get("network_plane_type");
+              networkPlaneConfSource="initRouteLabelsMatches.json";
+            }
+          }
+
+          if (labelMap.get("customLabels") != null) {
+            labelMapMatches = (Map<String, String>) labelMap.get("customLabels");
+            labelConfSource="initRouteLabelsMatches.json";
+          }
+
+        }
+      } else {
+        String[] env_routeLabels = StringUtils.split(env_ROUTE_LABELS, ",");
+        Map<String, String> labelMap = new HashMap<String, String>();
+
+        for (int i = 0; i < env_routeLabels.length; i++) {
+          String[] labels = StringUtils.split(env_routeLabels[i], ":");
+
+          if ("visualRange".equals(labels[0])) {
+            visualRangeMatches = labels[1];
+            visualRangeConfSource="env:ROUTE_LABELS";
+          } else if ("network_plane_type".equals(labels[0])) {
+            network_plane_typeMatches = labels[1];
+            networkPlaneConfSource="env:ROUTE_LABELS";
+          } else {
+            labelMap.put(labels[0], labels[1]);
+          }
+
+        }
+
+        labelConfSource="env:ROUTE_LABELS";
+        labelMapMatches = labelMap;
+
+      }
+      LOGGER.warn("init visualRange Filter from [ "+visualRangeConfSource+" ]:" + visualRangeMatches);
+      LOGGER.warn("init network_plane_type Filter from [ "+networkPlaneConfSource+" ]:" + network_plane_typeMatches);
+      LOGGER.warn("init customLabels Filter from [ "+labelConfSource+" ]:" + labelMapMatches);
+    } catch (IOException e) {
+      // TODO Auto-generated catch block
+      LOGGER.error(
+          "read  initRouteLabelsPathMatches Files or env(ROUTE_LABELS) throw exception",
+          e);
+    }
+  }
+  
+  public void initRouteWay() {
+    String env_ROUTE_WAY=System.getenv("ROUTE_WAY");
+    try {
+      // read NAMESPACE
+      if (StringUtils.isBlank(env_ROUTE_WAY)) {
+        URL routeLabelsPath =
+            InitRouteServiceWrapper.class.getResource("/ext/initRouteWay/initRouteWay.json");
+        if (routeLabelsPath != null) {
+          String path = routeLabelsPath.getPath();
+
+          String fileContent = FileUtil.readFile(path);
+          ObjectMapper mapper = new ObjectMapper();
+
+          Map<String, Object> routeWayMap = mapper.readValue(fileContent, Map.class);
+          String routeWayFromConfig=(String)routeWayMap.get("routeWay");
+          if (StringUtils.isNotBlank(routeWayFromConfig)) {
+            routeWay =
+                StringUtils.split(routeWayFromConfig, RouteUtil.SPLIT_LINE);
+            LOGGER.warn("init RouteWay from [initRouteWay.json]:" + routeWayFromConfig);
+          }
+        }
+      } else {
+        routeWay = StringUtils.split(env_ROUTE_WAY, RouteUtil.SPLIT_LINE);
+        LOGGER.warn("read initRouteWay from [env:ROUTE_WAY]:" + env_ROUTE_WAY);
+      }
+      
+
+  
+
+
+    } catch (Exception e) {
+      // TODO Auto-generated catch block
+      LOGGER.error("read  initRouteWay Files or env(ROUTE_WAY) throw exception", e);
+    }
+  }
+
+  
+  public void initDiscoverInfo(ApiRouteAppConfig configuration){
+    DiscoverInfo config_discoverInfo = configuration.getDiscoverInfo();
+
+
+    discoverInfo.setEnabled(config_discoverInfo.isEnabled());
+
+    String discoverInfoConfSource="yaml config";
+
+    if (config_discoverInfo.isEnabled()) {
+      
+     String discoverIP;
+     String env_SDCLIENT_IP=System.getenv("SDCLIENT_IP");
+    
+        if (StringUtils.isBlank(env_SDCLIENT_IP)) {
+          // yml
+          discoverIP = config_discoverInfo.getIp();
+        } else {
+          discoverIP = env_SDCLIENT_IP;
+          discoverInfoConfSource="env:SDCLIENT_IP";
+        }
+
+       discoverInfo.setIp(discoverIP.trim());
+       discoverInfo.setPort(config_discoverInfo.getPort());
+    }
+    
+    LOGGER.warn("init DiscoverInfo from ["+discoverInfoConfSource+"]--" + discoverInfo.toString()+" Enabled:"+discoverInfo.isEnabled());
+  }
+  
+	public void initNodeMetaQueryParam() {
+		// judge consul register node:caltalog
+		String env_CONSUL_REGISTER_MODE = System.getenv("CONSUL_REGISTER_MODE");
+
+		if (env_CONSUL_REGISTER_MODE == null
+				|| !env_CONSUL_REGISTER_MODE.trim().equals("catalog")) {
+			nodeMetaQueryParam = "";
+			return;
+		}
+
+		// visual range
+		String nodemeta_visualrange = nodemeta_visualrange(visualRangeMatches);
+
+		LOGGER.warn("calc nodemeta_visualrange from [" + visualRangeMatches
+				+ "]:" + nodemeta_visualrange);
+
+		nodeMetaQueryParam = nodemeta_visualrange;
+
+		// name space
+		String nodemeta_namespace = nodemeta_namespace(namespaceMatches);
+		LOGGER.warn("calc nodemeta_namespace from [" + namespaceMatches + "]:"
+				+ nodemeta_namespace);
+
+		if (!nodeMetaQueryParam.isEmpty() && !nodemeta_namespace.isEmpty()) {
+			nodeMetaQueryParam += "&";
+		}
+		nodeMetaQueryParam += nodemeta_namespace;
+
+		/*
+		 * // nodemeta = (!nodemeta_visualrange.isEmpty() && !nodemeta_namespace
+		 * .isEmpty()) ? nodemeta_visualrange + "&" + nodemeta_namespace :
+		 * nodemeta_visualrange + nodemeta_namespace;
+		 */
+
+	}
+
+	private String nodemeta_visualrange(final String visualRangeMatches) {
+
+		if (visualRangeMatches == null || visualRangeMatches.isEmpty()) {
+			return "";
+		}
+
+		// external:0
+		if (visualRangeMatches.trim().equals("0")) {
+			return "node-meta=external:true";
+		}
+
+		// internal:1
+		if (visualRangeMatches.trim().equals("1")) {
+			return "node-meta=internal:true";
+		}
+
+		return "";
+	}
+	
+
+	private String nodemeta_namespace(final String namespaceMatches) {
+
+		// exclude null,"",all,&,|,!
+		if (namespaceMatches == null || namespaceMatches.isEmpty()
+				|| namespaceMatches.contains("all")
+				|| namespaceMatches.contains("&")
+				|| namespaceMatches.contains("|")
+				|| namespaceMatches.contains("!")) {
+			return "";
+		}
+
+		return "node-meta=ns:" + namespaceMatches;
+	}
+  
+  public String getServerPort() {
+    return serverPort;
+  }
+
+  public String getIUI_ROOT_PATH() {
+    return IUI_ROOT_PATH;
+  }
+
+  public String getAPI_ROOT_PATH() {
+    return API_ROOT_PATH;
+  }
+
+  public String getNamespaceMatches() {
+    return namespaceMatches;
+  }
+
+  public String getVisualRangeMatches() {
+    return visualRangeMatches;
+  }
+
+  public String getNetwork_plane_typeMatches() {
+    return network_plane_typeMatches;
+  }
+  
+  public String[] getRouteWay() {
+    return routeWay.clone();
+  }
+
+  public Map<String, String> getLabelMapMatches() {
+    return labelMapMatches;
+  }
+
+  public DiscoverInfo getDiscoverInfo() {
+    return discoverInfo;
+  }
+
+  public String getMetricsUrl() {
+    return metricsUrl;
+  }
+
+  public void setMetricsUrl(String metricsUrl) {
+    this.metricsUrl = metricsUrl;
+  }
+
+	public String getNodeMetaQueryParam() {
+		return nodeMetaQueryParam;
+	}
+
+  public String getConsul_ip() {
+    return consul_ip;
+  }
+
+
+
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/FileUtil.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/FileUtil.java
new file mode 100644
index 0000000..1e89f82
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/FileUtil.java
@@ -0,0 +1,78 @@
+/**
+ * Copyright 2016 ZTE, Inc. and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.msb.apiroute.wrapper.util;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public final class FileUtil {
+
+    /**
+     * Read all the files under a folder
+     */
+    public static File[] readFileFolder(String filepath) throws FileNotFoundException, IOException {
+        File file = new File(filepath);
+        if (file.isDirectory()) {
+            File[] filelist = file.listFiles();
+            return filelist;
+        }
+       
+        return null;
+    }
+
+    public static String readFile(String Path) throws IOException{
+        BufferedReader reader = null;
+        StringBuffer fileContent = new StringBuffer();
+        try {
+            FileInputStream fileInputStream = new FileInputStream(Path);
+            InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
+            reader = new BufferedReader(inputStreamReader);
+            String tempString = null;
+            while ((tempString = reader.readLine()) != null) {
+                fileContent.append(tempString);
+            }
+            reader.close();
+        } catch (IOException e) {
+            throw e;
+        } finally {
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (IOException e) {
+                    throw e;
+                }
+            }
+        }
+        return fileContent.toString();
+    }
+    
+    /**
+     * Read all the files under a folder
+     */
+    public static String[] readfile(String filepath) throws FileNotFoundException, IOException {
+        File file = new File(filepath);
+        if (file.isDirectory()) {
+            String[] filelist = file.list();
+            return filelist;
+        }
+        return null;
+    }
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/HttpClientUtil.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/HttpClientUtil.java
new file mode 100644
index 0000000..eb5ed1e
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/HttpClientUtil.java
@@ -0,0 +1,117 @@
+package org.onap.msb.apiroute.wrapper.util;
+
+import java.io.IOException;
+
+import org.apache.http.client.ClientProtocolException;
+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.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class HttpClientUtil {
+
+  private static final Logger logger = LoggerFactory.getLogger(HttpClientUtil.class);
+  
+  private static int connectionTimeOut = 2*1000;
+  
+
+  public static String httpGet(String url){
+    String result = null;
+    CloseableHttpClient httpClient = HttpClients.createDefault();
+    HttpGet httpGet = new HttpGet(url);
+    httpGet.addHeader("Content-type", "application/json; charset=utf-8");
+    httpGet.setHeader("Accept", "application/json");
+    try {
+      CloseableHttpResponse res = httpClient.execute(httpGet);
+      result = EntityUtils.toString(res.getEntity());
+      if (res.getStatusLine().getStatusCode() != CommonUtil.SC_OK) {
+        logger.error(result);
+      }
+      res.close();
+    } catch (ClientProtocolException e) {
+      logger.error(url + ":httpGetWithJSON connect faild");
+    } catch (IOException e) {
+      logger.error( url + ":httpGetWithJSON connect faild");
+    } finally {
+      try {
+        httpClient.close();
+      } catch (IOException e) {
+        logger.error(url + ":close  httpClient faild");
+      }
+    }
+
+    return result;
+
+  }
+  
+  public static HttpGetResult httpGetStatusAndBody(String url){
+	    HttpGetResult result= new HttpGetResult();
+	    String body = null;
+	    CloseableHttpClient httpClient = HttpClients.createDefault();
+	    HttpGet httpGet = new HttpGet(url);
+	    httpGet.addHeader("Content-type", "application/json; charset=utf-8");
+	    httpGet.setHeader("Accept", "application/json");
+	    
+	    RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(connectionTimeOut).build();
+	    httpGet.setConfig(requestConfig);
+	    
+	    try {
+	      CloseableHttpResponse res = httpClient.execute(httpGet);
+	      body = EntityUtils.toString(res.getEntity());
+	      if (res.getStatusLine().getStatusCode() != CommonUtil.SC_OK) {
+	        logger.error(body);
+	      }
+	      result.setBody(body);
+	      result.setStatusCode(res.getStatusLine().getStatusCode());
+	      res.close();
+	    } catch (ClientProtocolException e) {
+	      logger.error(url + ":httpGetWithJSON connect faild",e);
+	    } catch (IOException e) {
+	      logger.error( url + ":httpGetWithJSON connect faild",e);
+	    } finally {
+	      try {
+	        httpClient.close();
+	      } catch (IOException e) {
+	        logger.error(url + ":close  httpClient faild");
+	      }
+	    }
+
+	    return result;
+
+	  }
+
+  public static int httpGetStatus(String url)  throws Exception{
+    int iStatus=500;
+    CloseableHttpClient httpClient = HttpClients.createDefault();
+
+
+    HttpGet httpGet = new HttpGet(url);
+    RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(10000).setConnectTimeout(10000).build();//设置请求和传输超时时间
+    httpGet.setConfig(requestConfig);
+    httpGet.addHeader("Content-type", "application/json; charset=utf-8");
+    httpGet.setHeader("Accept", "application/json");
+    try {
+      CloseableHttpResponse res = httpClient.execute(httpGet);
+    
+      iStatus=res.getStatusLine().getStatusCode();
+      res.close();
+    } catch (ClientProtocolException e) {
+      logger.error(url + " httpGet connect faild:"+e.getMessage());
+    } catch (IOException e) {
+      logger.error(url + " httpGet connect faild:"+e.getMessage());
+    } finally {
+      try {
+        httpClient.close();
+      } catch (IOException e) {
+        logger.error(url + " httpGet close faild:"+e.getMessage());
+      }
+    }
+
+    return iStatus;
+
+  }
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/HttpGetResult.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/HttpGetResult.java
new file mode 100644
index 0000000..5b943e3
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/HttpGetResult.java
@@ -0,0 +1,19 @@
+package org.onap.msb.apiroute.wrapper.util;
+
+public class HttpGetResult {
+	private int statusCode;
+	private String body;
+	public int getStatusCode() {
+		return statusCode;
+	}
+	public void setStatusCode(int statusCode) {
+		this.statusCode = statusCode;
+	}
+	public String getBody() {
+		return body;
+	}
+	public void setBody(String body) {
+		this.body = body;
+	}
+	
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/Jackson.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/Jackson.java
new file mode 100644
index 0000000..20b60d4
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/Jackson.java
@@ -0,0 +1,28 @@
+package org.onap.msb.apiroute.wrapper.util;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.guava.GuavaModule;
+import com.fasterxml.jackson.datatype.jdk7.Jdk7Module;
+import com.fasterxml.jackson.datatype.joda.JodaModule;
+
+public class Jackson {
+    //use static singleton, make sure to reuse!
+    public static final ObjectMapper MAPPER = newObjectMapper();
+
+    private Jackson() {
+        /* singleton */
+    }
+
+    private static ObjectMapper newObjectMapper() {
+        final ObjectMapper mapper = new ObjectMapper();
+        return configure(mapper);
+    }
+
+    private static ObjectMapper configure(ObjectMapper mapper) {
+        mapper.registerModule(new GuavaModule());
+        mapper.registerModule(new JodaModule());
+        mapper.registerModule(new Jdk7Module());
+
+        return mapper;
+    }
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/JacksonJsonUtil.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/JacksonJsonUtil.java
new file mode 100644
index 0000000..4a7f50e
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/JacksonJsonUtil.java
@@ -0,0 +1,110 @@
+/**
+ * Copyright 2016 ZTE, Inc. and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.msb.apiroute.wrapper.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+
+
+public class JacksonJsonUtil {
+
+  private static final Logger logger = LoggerFactory.getLogger(JacksonJsonUtil.class);
+
+  private volatile static ObjectMapper mapper = null;
+
+  private static ObjectMapper getMapperInstance() {
+    if (mapper == null) {
+      synchronized (JacksonJsonUtil.class) {
+        if (mapper == null) {
+          mapper = new ObjectMapper();
+        }
+      }
+    }
+    return mapper;
+  }
+
+  /**
+   * from java object to json
+   * 
+   * @param obj
+   * @return json
+   * @throws Exception
+   */
+  public static String beanToJson(Object obj) throws Exception {
+      String json = null;
+
+      ObjectMapper objectMapper = getMapperInstance();
+      objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
+      json = objectMapper.writeValueAsString(obj);
+    
+      return json;
+  }
+
+
+
+  /**
+   * from json to java object
+   * 
+   * @param json
+   * @param cls
+   * @return
+   * @throws Exception
+   */
+  public static Object jsonToBean(String json, Class<?> cls) throws Exception {
+    Object vo = null;
+    try {
+      ObjectMapper objectMapper = getMapperInstance();
+      objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
+      vo = objectMapper.readValue(json, cls);
+
+    } catch (Exception e) {
+      logger.error(cls + " JsonTobean faild");
+      throw new Exception(cls + " JsonTobean faild");
+    }
+    return vo;
+  }
+
+  /**
+   * from json to java List
+   * 
+   * @param json
+   * @return
+   * @throws Exception
+   */
+
+  public static <T> T jsonToListBean(String json, TypeReference<T> valueTypeRef) {
+    try {
+
+      ObjectMapper objectMapper = getMapperInstance();
+
+
+      return objectMapper.readValue(json, valueTypeRef);
+
+    } catch (Exception e) {
+      String errorMsg = " JsonTobean faild:" + e.getMessage();
+      logger.error(errorMsg);
+    }
+    return null;
+  }
+
+
+
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/JedisUtil.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/JedisUtil.java
new file mode 100644
index 0000000..ac9421b
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/JedisUtil.java
@@ -0,0 +1,208 @@
+/**
+ * Copyright 2016 ZTE, Inc. and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.msb.apiroute.wrapper.util;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.util.PropertyResourceBundle;
+import java.util.ResourceBundle;
+
+import org.apache.commons.lang3.StringUtils;
+import org.onap.msb.apiroute.wrapper.InitRouteServiceWrapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+import redis.clients.jedis.JedisPoolConfig;
+
+
+
+public class JedisUtil {
+  private static final Logger LOGGER = LoggerFactory.getLogger(JedisUtil.class);
+  private static String host = "127.0.0.1";
+  private static int port = 6379;
+  private static int connectionTimeout = 2000;
+  private static int DEFAULT_DB_INDEX = 0;
+
+  private volatile static JedisPool jedisPool = null;
+
+
+  public static String propertiesName = "redis.properties";
+  private static final String LINE_SEPARATOR = System.getProperty("line.separator");
+
+
+  private JedisUtil() {
+    // private constructor
+
+  }
+
+  private synchronized static JedisPool initialPool() throws IOException {
+
+    JedisPoolConfig config = new JedisPoolConfig();
+    config.setMaxTotal(50);
+    config.setMaxIdle(30);
+    config.setMaxWaitMillis(5000);
+    config.setTestOnBorrow(false);
+    config.setTestOnReturn(true);
+
+    URL urlPath = JedisUtil.class.getResource("/ext/redisConf/redis.properties");
+    if (urlPath != null) {
+      String propertiesPath = urlPath.getPath();
+
+
+      File propertiesFile = new File(propertiesPath);
+
+      if (propertiesFile.exists()) {
+
+
+        BufferedInputStream inputStream =
+            new BufferedInputStream(new FileInputStream(propertiesPath));
+        ResourceBundle bundle = new PropertyResourceBundle(inputStream);
+
+        if (bundle == null) {
+          throw new IllegalArgumentException("[redis.properties] is not found!");
+        }
+
+
+        // Set up the connection pool basic information
+        String strHost = bundle.getString("redis.host");
+        if (StringUtils.isNotEmpty(strHost)) {
+          host = strHost;
+        }
+
+        // redis port: first read from env
+        if (StringUtils.isNotBlank(System.getenv("APIGATEWAY_REDIS_PORT"))) {
+          port = Integer.parseInt(System.getenv("APIGATEWAY_REDIS_PORT"));
+        } else {
+          String strPort = bundle.getString("redis.port");
+          if (StringUtils.isNotEmpty(strPort)) {
+            port = Integer.parseInt(strPort);
+          }
+        }
+
+
+        String strTimeout = bundle.getString("redis.connectionTimeout");
+        if (StringUtils.isNotEmpty(strTimeout)) {
+          connectionTimeout = Integer.parseInt(strTimeout);
+        }
+
+
+        String strDbIndex = bundle.getString("redis.db_index");
+        if (StringUtils.isNotEmpty(strDbIndex)) {
+          DEFAULT_DB_INDEX = Integer.parseInt(strDbIndex);
+        }
+
+        String strMaxTotal = bundle.getString("redis.pool.maxTotal");
+        if (StringUtils.isNotEmpty(strMaxTotal)) {
+          config.setMaxTotal(Integer.parseInt(strMaxTotal));
+        }
+
+        String strMaxIdle = bundle.getString("redis.pool.maxIdle");
+        if (StringUtils.isNotEmpty(strMaxIdle)) {
+          config.setMaxIdle(Integer.parseInt(strMaxIdle));
+        }
+
+        String strMaxWaitMillis = bundle.getString("redis.pool.maxWaitMillis");
+        if (StringUtils.isNotEmpty(strMaxWaitMillis)) {
+          config.setMaxWaitMillis(Long.parseLong(strMaxWaitMillis));
+        }
+
+        String strTestOnBorrow = bundle.getString("redis.pool.testOnBorrow");
+        if (StringUtils.isNotEmpty(strTestOnBorrow)) {
+          config.setTestOnBorrow(Boolean.valueOf(strTestOnBorrow));
+        }
+
+        String strTestOnReturn = bundle.getString("redis.pool.testOnReturn");
+        if (StringUtils.isNotEmpty(strTestOnReturn)) {
+          config.setTestOnReturn(Boolean.valueOf(strTestOnReturn));
+        }
+
+      }
+    }
+
+    StringBuffer redisinfo = new StringBuffer();
+    redisinfo.append("------redis.properties------").append(LINE_SEPARATOR);
+    redisinfo.append("redis.host: ").append(host).append(":").append(port).append(LINE_SEPARATOR);
+    redisinfo.append("redis.connectionTimeout: ").append(connectionTimeout).append(LINE_SEPARATOR);
+    redisinfo.append("redis.pool.maxTotal: ").append(config.getMaxTotal()).append(LINE_SEPARATOR);
+    redisinfo.append("redis.pool.maxIdle: ").append(config.getMaxIdle()).append(LINE_SEPARATOR);
+    redisinfo.append("redis.pool.maxWaitMillis: ").append(config.getMaxWaitMillis())
+        .append(LINE_SEPARATOR);
+    redisinfo.append("redis.pool.testOnBorrow: ").append(config.getTestOnBorrow())
+        .append(LINE_SEPARATOR);
+    redisinfo.append("redis.pool.testOnReturn: ").append(config.getTestOnReturn())
+        .append(LINE_SEPARATOR);
+
+
+    LOGGER.info(redisinfo.toString());
+    return new JedisPool(config, host, port, connectionTimeout);
+
+  }
+
+  /**
+   * From the connection pool to obtain jedis instance, use the default database index number 0
+   * 
+   * @return
+   * @throws Exception
+   */
+  public static Jedis borrowJedisInstance() throws Exception {
+    return borrowJedisInstance(DEFAULT_DB_INDEX);
+  }
+
+  /**
+   * From the connection pool to obtain jedis instance, using the specified database index number
+   * 
+   * @return
+   * @throws Exception
+   */
+
+  public static Jedis borrowJedisInstance(final int dbIndex) throws Exception {
+    if (jedisPool == null) {
+      synchronized (JedisUtil.class) {
+        if (jedisPool == null) {         
+            jedisPool = initialPool();         
+        }
+      }
+    }
+    Jedis resource = jedisPool.getResource();
+
+    if (resource == null) {
+      throw new Exception("fetch from jedis pool failed,null object!");
+    }
+
+    resource.select(dbIndex);
+    return resource;
+
+  }
+
+  /**
+   * returned to the pool jedis instance
+   * 
+   * @param jedis
+   */
+  public static void returnJedisInstance(final Jedis jedis) {
+    if (jedis != null) {
+      jedis.close();
+    }
+  }
+
+
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/MicroServiceUtil.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/MicroServiceUtil.java
new file mode 100644
index 0000000..1081579
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/MicroServiceUtil.java
@@ -0,0 +1,78 @@
+/**
+ * Copyright 2016 ZTE, Inc. and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.msb.apiroute.wrapper.util;
+
+import org.apache.commons.lang3.StringUtils;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.regex.Pattern;
+
+
+public class MicroServiceUtil {
+    public static final String PREFIX_PATH = "discover:microservices";
+    
+    private static final Pattern SERVICE_KEY_REGEX_PATTERN =
+            Pattern.compile("discover:microservices:(?<servicename>[^:]+)(:(?<version>[^:]*))");
+
+   
+    public static String getPrefixedKey(String... paths) {
+        StringBuffer sb = new StringBuffer();
+        
+        sb.append(PREFIX_PATH);
+       
+        for (int i = 0; i < paths.length; i++) {
+            sb.append(":");
+            sb.append(paths[i]);
+        }
+        return sb.toString();
+    }
+    
+   
+    public static String getServiceKey(String serviceName, String version) {
+        return getPrefixedKey(serviceName, version);
+    }
+
+    public static Pattern getServiceKeyRegexPattern(){
+        return SERVICE_KEY_REGEX_PATTERN;
+    }
+   
+    
+
+    public static String getRealIp(HttpServletRequest request) {
+        String ip = request.getHeader("X-Forwarded-For");
+        if (StringUtils.isNotEmpty(ip) && !"unKnown".equalsIgnoreCase(ip)) {
+            // After the reverse proxy can have multiple IP value for many times, the first IP is the real IP
+            int index = ip.indexOf(",");
+            if (index != -1) {
+                return ip.substring(0, index);
+            } else {
+                return ip;
+            }
+        }
+        ip = request.getHeader("X-Real-IP");
+
+        if (StringUtils.isNotEmpty(ip) && !"unKnown".equalsIgnoreCase(ip)) {
+            return ip;
+        }
+        
+
+        return request.getRemoteAddr();
+
+    }
+
+
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/RegExpTestUtil.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/RegExpTestUtil.java
new file mode 100644
index 0000000..0edcfda
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/RegExpTestUtil.java
@@ -0,0 +1,115 @@
+/**
+ * Copyright 2016 ZTE, Inc. and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onap.msb.apiroute.wrapper.util;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class RegExpTestUtil {
+  
+ 
+  private final static String API_KEY_PATTERN ="/api/(?<servicename>[^/]+)(/(?<version>[^/]*)).*";
+  
+  private final static String IUI_KEY_PATTERN ="/iui/(?<servicename>[^/]+)/.*";
+    
+  public static boolean  hostRegExpTest(String host){
+      
+      String hostReg = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."  
+              +"(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."  
+              +"(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."  
+              +"(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)"
+              +":(\\d{1,5})$";   
+      return Pattern.matches(hostReg, host); 
+      
+  }
+  
+  public static boolean  ipRegExpTest(String ip){
+      
+      String hostReg = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."  
+              +"(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."  
+              +"(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."  
+              +"(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$";  
+      return Pattern.matches(hostReg, ip); 
+      
+  }
+  
+ public static boolean  portRegExpTest(String port){
+      
+      String hostReg = "^\\d{1,5}$";  
+      return Pattern.matches(hostReg, port); 
+      
+  }
+  
+public static boolean versionRegExpTest(String version){
+      
+      String versionReg = "^v\\d+(\\.\\d+)?$";  
+      return Pattern.matches(versionReg, version); 
+      
+  }
+
+public static boolean urlRegExpTest(String url){
+    if(url.equals("/")) return true;
+    
+    String urlReg = "^\\/.*((?!\\/).)$";  
+    return Pattern.matches(urlReg, url); 
+    
+}
+
+public static boolean apiRouteUrlRegExpTest(String url){
+    
+    String urlReg = "^\\/"+ConfigUtil.getInstance().getAPI_ROOT_PATH()+"\\/.*$";  
+    return Pattern.matches(urlReg, url); 
+    
+}
+
+public static boolean iuiRouteUrlRegExpTest(String url){
+    
+    String urlReg = "^\\/"+ConfigUtil.getInstance().getIUI_ROOT_PATH()+"\\/.*$";  
+    return Pattern.matches(urlReg, url); 
+    
+}
+
+public static String[] apiServiceNameMatch4URL(String url){
+  Pattern redisKeyPattern =Pattern.compile(API_KEY_PATTERN);
+  Matcher matcher = redisKeyPattern.matcher(url+"/");
+  if (matcher.matches()) {
+    String version;
+    if(versionRegExpTest(matcher.group("version"))){
+      version=matcher.group("version");
+    }
+    else{
+      version="";
+    }
+     return new String[]{matcher.group("servicename"),version}; 
+    }
+    else{
+      return null;
+    }
+}
+
+
+public static String iuiServiceNameMatch4URL(String url){
+  Pattern redisKeyPattern =Pattern.compile(IUI_KEY_PATTERN);
+  Matcher matcher = redisKeyPattern.matcher(url+"/");
+  if (matcher.matches()) {
+     return matcher.group("servicename"); 
+    }
+    else{
+      return null;
+    }
+}
+
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/RouteUtil.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/RouteUtil.java
new file mode 100644
index 0000000..331671f
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/RouteUtil.java
@@ -0,0 +1,345 @@
+/**
+ * Copyright 2016 ZTE, Inc. and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.msb.apiroute.wrapper.util;
+
+import org.apache.commons.lang3.StringUtils;
+import org.onap.msb.apiroute.api.MicroServiceFullInfo;
+import org.onap.msb.apiroute.api.Node;
+import org.onap.msb.apiroute.api.RouteInfo;
+import org.onap.msb.apiroute.api.RouteServer;
+import org.onap.msb.apiroute.api.exception.UnprocessableEntityException;
+
+
+public class RouteUtil {
+
+    
+    public static final int consulDeafultPort=8500;
+  
+	public static final String ROUTE_PATH="msb:routing";   
+	
+	public static final String ROUTE_PORT_PATH="msb:";  
+	
+	public static final String ROUTE_PATH_HOST="msb:host";   
+	
+	public static final String APIROUTE="api";  
+	
+	public static final String IUIROUTE="iui";  
+	
+	public static final String CUSTOMROUTE="custom";  
+	
+	public static final String HTTPS_PROTOCOL="https"; 
+	
+	public static final String CUSTOM_PORTAL="portal"; 
+	
+	
+    public static final String PROTOCOL_LIST="REST,HTTP,UI,MQ,FTP,SNMP,TCP,UDP"; 
+    
+    public static final String MSB_ROUTE_URL = "/api/microservices/v1/services";
+    
+    public static final String MSB_CHECK_URL = "/api/catalog/v1/service/router-all";
+    
+    public static final String visualRangeRange="0,1";
+    
+    public static final String controlRangeMatches="0,1,2";
+    
+    public static final String statusRangeMatches="0,1";
+    
+    public static final String useOwnUpstreamRangeMatches="0,1";
+    
+    public static final String ROUTEWAY_IP="ip";
+    
+    public static final String ROUTEWAY_DOMAIN="domain";
+    
+    public static final String SPLIT_LINE="|";
+    
+    public static final String PROTOCOL_REST="REST";
+    
+    public static final String PROTOCOL_UI="UI";
+    
+    public static final String PROTOCOL_HTTP="HTTP";
+    
+    public static final String FILTER_PROTOCOLS="REST,UI,HTTP";
+    
+    public static final int SERVICE_DATA_QUEUE_NUM=5;
+    
+    public static final int SERVICE_QUEUE_CAPACITY=100;
+    
+    public static final int SERVICE_LIST_QUEUE_CAPACITY=5;
+    
+    public static final int WATCH_SECOND=120;
+    
+    public static final String HEALTH_CHECK_PASSING="passing";
+    
+
+    
+	
+	/** 
+	* @Title: getPrefixedKey  
+	* @Description: TODO(Add base path prefix radis assembly path) 
+	* @param: @param serviceName
+	* @param: @param version
+	* @param: @param type
+	* @param: @return      
+	* @return: String    
+	*/
+	
+	public static String getPrefixedKey(String...paths){
+		StringBuffer sb= new StringBuffer();
+		
+		    if(paths[0].trim().equals("") || paths[0].equals(ConfigUtil.getInstance().getServerPort())){
+	            sb.append(ROUTE_PATH);
+	        }
+	        else{
+	           sb.append(ROUTE_PORT_PATH).append(paths[0]); 
+	        }
+	
+		for (int i = 1; i < paths.length; i++) {
+			sb.append(":");
+			sb.append(paths[i]);
+		}
+		return sb.toString();
+	}
+	
+	public static String getPrefixedKey4Host(String...paths){
+      StringBuffer sb= new StringBuffer();
+      
+      sb.append(ROUTE_PATH_HOST);
+         
+  
+      for (int i = 0; i < paths.length; i++) {
+          sb.append(":");
+          sb.append(paths[i]);
+      }
+      return sb.toString();
+  }
+	
+	
+	
+
+	public static void checkRouteWay(String routeWay){
+	    if(!CommonUtil.contain(ConfigUtil.getInstance().getRouteWay(),routeWay)){
+	      String errInfo = "routeWay does not support,must be ip or domain";
+	      throw new UnprocessableEntityException(errInfo);
+	    }
+	  }
+	
+	public static void checkServiceNameAndVersion(String serviceName,String version){
+	  if (StringUtils.isBlank(serviceName)) {
+	      throw new UnprocessableEntityException("serviceName  can't be empty");
+	    }
+
+	    if (StringUtils.isNotBlank(version)) {
+	      if (!RegExpTestUtil.versionRegExpTest(version)) {
+	        throw new UnprocessableEntityException("version  is not a valid  format");
+	      }
+	    }
+    }
+
+	public static void checkServiceStatus(String status){
+	  if (!CommonUtil.contain(statusRangeMatches, status)) {
+	      throw new UnprocessableEntityException(
+	          "save RouteInfo Status FAIL:status is wrong,value range:("
+	              + RouteUtil.statusRangeMatches + ")");
+	    }     
+    }
+	
+	  
+	  
+	  public static void checkRouterInfoFormat(RouteInfo routeInfo) {
+	    
+	    if (StringUtils.isBlank(routeInfo.getServiceName()) || routeInfo.getServers().length == 0) {
+	      throw new UnprocessableEntityException(
+	          "save RouteInfo FAIL: Some required fields are empty");
+	    }
+
+	    if (StringUtils.isNotBlank(routeInfo.getUrl())) {
+	      if (!RegExpTestUtil.urlRegExpTest(routeInfo.getUrl())) {
+	        throw new UnprocessableEntityException(
+	            "save RouteInfo FAIL:url is not a valid format(url must be begin with /)");
+
+	      }
+	    }
+
+	    if (!CommonUtil.contain(RouteUtil.visualRangeRange, routeInfo.getVisualRange())) {
+	      throw new UnprocessableEntityException(
+	          "save RouteInfo FAIL:VisualRange is wrong,value range:("
+	              + RouteUtil.visualRangeRange + ")");
+	    }
+
+	    if (!CommonUtil.contain(RouteUtil.controlRangeMatches, routeInfo.getControl())) {
+	      throw new UnprocessableEntityException(
+	          "save RouteInfo FAIL:control is wrong,value range:("
+	              + RouteUtil.controlRangeMatches + ")");
+	    }
+
+	    if (!CommonUtil.contain(RouteUtil.statusRangeMatches, routeInfo.getStatus())) {
+	      throw new UnprocessableEntityException(
+	          "save RouteInfo FAIL:status is wrong,value range:("
+	              + RouteUtil.statusRangeMatches + ")");
+	    }
+
+	    if (!CommonUtil.contain(RouteUtil.useOwnUpstreamRangeMatches, routeInfo.getUseOwnUpstream())) {
+	      throw new UnprocessableEntityException(
+	          "save RouteInfo FAIL:useOwnUpstream is wrong,value range:("
+	              + RouteUtil.useOwnUpstreamRangeMatches + ")");
+	    }
+
+	    // Check the service instance format
+	    RouteServer[] serverList = routeInfo.getServers();
+	    for (int i = 0; i < serverList.length; i++) {
+	      RouteServer server = serverList[i];
+	      if (!RegExpTestUtil.ipRegExpTest(server.getIp())) {
+	        throw new UnprocessableEntityException("save RouteInfo FAIL:IP(" + server.getIp()
+	            + ")is not a valid ip address");
+	      }
+
+	      if (!RegExpTestUtil.portRegExpTest(server.getPort())) {
+	        throw new UnprocessableEntityException("save RouteInfo FAIL:Port(" + server.getPort()
+	            + ")is not a valid Port address");
+	      }
+	    }
+	  }
+	  
+	  public static void checkMicroServiceInfoFormat(MicroServiceFullInfo microServiceInfo,String requestIP){
+	    // Check the service instance format
+	    if (StringUtils.isBlank(microServiceInfo.getServiceName())
+	        || StringUtils.isBlank(microServiceInfo.getProtocol())
+	        || microServiceInfo.getNodes().size() == 0) {
+	      throw new UnprocessableEntityException(
+	          "register MicroServiceInfo FAIL: Some required fields are empty");
+	    }
+
+	    for (Node node : microServiceInfo.getNodes()) {
+
+	      if (node.getIp() == null || node.getIp().isEmpty()) {
+	        node.setIp(requestIP);
+	      } else if (!RegExpTestUtil.ipRegExpTest(node.getIp())) {
+	        throw new UnprocessableEntityException("register MicroServiceInfo FAIL:IP(" + node.getIp()
+	            + ")is not a valid ip address");
+	      }
+
+	      if (!RegExpTestUtil.portRegExpTest(node.getPort())) {
+	        throw new UnprocessableEntityException("register MicroServiceInfo FAIL:Port("
+	            + node.getPort() + ")is not a valid Port address");
+	      }
+	    }
+
+	    if (StringUtils.isNotBlank(microServiceInfo.getVersion())) {
+	      if (!RegExpTestUtil.versionRegExpTest(microServiceInfo.getVersion())) {
+	        throw new UnprocessableEntityException(
+	            "register MicroServiceInfo FAIL:version is not a valid  format");
+
+	      }
+	    }
+
+	    if (StringUtils.isNotBlank(microServiceInfo.getUrl().trim())) {
+	      if (!RegExpTestUtil.urlRegExpTest(microServiceInfo.getUrl())) {
+	        throw new UnprocessableEntityException(
+	            "register MicroServiceInfo FAIL:url is not a valid format(url must be begin with /)");
+
+	      }
+	    }
+
+
+	    if (RouteUtil.PROTOCOL_LIST.indexOf(microServiceInfo.getProtocol().trim()) == -1) {
+	      throw new UnprocessableEntityException(
+	          "register MicroServiceInfo FAIL:Protocol is wrong,value range:("
+	              + RouteUtil.PROTOCOL_LIST + ")");
+	    }
+
+	  }
+	  
+
+	  public static String getAPIRedisPrefixedKey(String routeName, String version, String host,String publish_port,String routeWay){
+	    String redisPrefixedKey;
+	    if(ROUTEWAY_DOMAIN.equals(routeWay)){
+	      redisPrefixedKey= RouteUtil.getPrefixedKey4Host(host, APIROUTE, routeName, version);
+	    }
+	    else{
+	      redisPrefixedKey=RouteUtil.getPrefixedKey(publish_port, APIROUTE, routeName, version);
+	    }
+	    
+	    return redisPrefixedKey;
+	  }
+	  
+	  public static String getRedisPrefixedKey(String routeType,String routeName, String host,String publish_port,String routeWay){
+        String redisPrefixedKey;
+        if(ROUTEWAY_DOMAIN.equals(routeWay)){
+          redisPrefixedKey= RouteUtil.getPrefixedKey4Host(host, routeType, routeName);
+        }
+        else{
+          redisPrefixedKey=RouteUtil.getPrefixedKey(publish_port, routeType, routeName);
+        }
+        
+        return redisPrefixedKey;
+      }
+	  
+	  public static String getMutiRedisKey(String routeType,String routeWay){
+	    String redisKey;
+	    if(RouteUtil.ROUTEWAY_DOMAIN.equals(routeWay)){
+	         redisKey =
+	            RouteUtil.getPrefixedKey4Host("*", routeType, "*");
+	         
+	      }
+	      else{
+	        redisKey =
+	            RouteUtil.getPrefixedKey("[^h]*", routeType, "*");
+	       
+	      }
+	    
+	    return redisKey;
+	  }
+	
+	 /** 
+	  * @Title getRouteNameByns 
+	  * @Description TODO(根据服务名和命名空间拆分服务路由名) 
+	  * @param serviceName
+	  * @param namespace
+	  * @return      
+	  * @return String    
+	  */
+	public static String getRouteNameByns(String consul_serviceName,String namespace){
+	    String serviceName=consul_serviceName;
+	    if(StringUtils.isNotBlank(namespace)){
+	      if(consul_serviceName.endsWith("-"+namespace)){
+	          serviceName=consul_serviceName.substring(0,consul_serviceName.length()-namespace.length()-1);
+	        }  
+	    }    
+	    
+	    return serviceName;
+	  }
+	
+	public static String getVisualRangeByRouter(String visualRange){
+	  String[] rangs = StringUtils.split(visualRange, "|");
+	  if(rangs.length>1){
+	    String visualRangeMatches=ConfigUtil.getInstance().getVisualRangeMatches();
+	    if(StringUtils.split(visualRangeMatches, "|").length>1){
+	      return "0";
+	    }
+	    else{
+	      return visualRangeMatches;
+	    }
+	  }
+	  else{
+	    return visualRange;
+	  }
+	  
+	}
+
+ 
+
+}
diff --git a/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/ServiceFilter.java b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/ServiceFilter.java
new file mode 100644
index 0000000..49b7b49
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/util/ServiceFilter.java
@@ -0,0 +1,515 @@
+package org.onap.msb.apiroute.wrapper.util;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+import org.onap.msb.apiroute.api.MicroServiceFullInfo;
+import org.onap.msb.apiroute.api.Node;
+import org.onap.msb.apiroute.wrapper.consulextend.model.health.Service;
+import org.onap.msb.apiroute.wrapper.consulextend.model.health.ServiceHealth;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.orbitz.consul.model.health.HealthCheck;
+
+
+
+public class ServiceFilter {
+  private static ServiceFilter instance = new ServiceFilter();
+
+  private ServiceFilter() {}
+
+  public static ServiceFilter getInstance() {
+    return instance;
+  }
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(ServiceFilter.class);
+
+
+  /**
+   * Determine whether the service needs to send a notification TODO: filter according to the
+   * agreement, the only notice of agreement for REST \HTTP\ UI interface MSB - REST
+   * 
+   * @param protocol
+   * @return
+   */
+  public boolean isNeedNotifyByProtocol(String protocol) {
+    return CommonUtil.contain(RouteUtil.FILTER_PROTOCOLS, protocol.trim());
+  }
+
+  /**
+   * Determine whether the service needs to send a notification TODO: according to the visual range
+   * filter conditions Regular language: all 、 default 、 !default 、 A、 |A 、 A|B、 !A&!B
+   * 
+   * @param visualRange
+   * @return
+   */
+  public boolean isNeedNotifyByNameSpace(String nameSpace) {
+
+    String namespaceMatches = ConfigUtil.getInstance().getNamespaceMatches();
+    String[] namespaceArray = StringUtils.split(namespaceMatches, "|");
+
+    if (CommonUtil.contain(namespaceArray, "all")) {
+      return true;
+    }
+
+    if (CommonUtil.contain(namespaceArray, "default")) {
+      if (StringUtils.isEmpty(nameSpace) || "default".equals(nameSpace) ) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+    if (CommonUtil.contain(namespaceArray, "!default")) {
+      if (StringUtils.isNotEmpty(nameSpace) && !"default".equals(nameSpace)) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+    try {
+      String namespaceReg;
+      if (namespaceMatches.contains("!")) {
+        namespaceReg = "^" + namespaceMatches.replaceAll("!", "").replaceAll("&", "|") + "$";
+        return !Pattern.matches(namespaceReg, nameSpace);
+      } else {
+        namespaceReg = "^" + namespaceMatches + "$";
+        return Pattern.matches(namespaceReg, nameSpace);
+      }
+
+    } catch (Exception e) {
+      LOGGER.error(" Regular " + namespaceMatches + " throw exception:" + e.getMessage());
+      return false;
+    }
+  }
+
+  public boolean isNeedNotifyByVisualRange(String visualRange) {
+
+    String[] routeVisualRangeArray =
+        StringUtils.split(ConfigUtil.getInstance().getVisualRangeMatches(), "|");
+
+    String[] serviceVisualRangeArray = StringUtils.split(visualRange, "|");
+
+    if (CommonUtil.contain(serviceVisualRangeArray, routeVisualRangeArray)) {
+      return true;
+    }
+
+    return false;
+
+  }
+
+  public boolean isNeedNotifyByNetwork_plane_typeMatches(String network_plane_type) {
+
+    String network_plane_typeMatches = ConfigUtil.getInstance().getNetwork_plane_typeMatches();
+    if (StringUtils.isBlank(network_plane_typeMatches))
+      return true;
+
+    String[] routeNetwork_plane_typeArray = StringUtils.split(network_plane_typeMatches, "|");
+
+    String[] serviceVisualRangeArray = StringUtils.split(network_plane_type, "|");
+
+    if (CommonUtil.contain(serviceVisualRangeArray, routeNetwork_plane_typeArray)) {
+      return true;
+    }
+
+    return false;
+
+  }
+
+  /**
+   * Determine whether the service needs to send a notification TODO: according to the visual range
+   * filter conditions
+   * 
+   * @param visualRange
+   * @return
+   */
+  public boolean isNeedNotifyByRouteLabels(Map<String, String> labelMap) {
+
+    Map<String, String> labelMapMatches = ConfigUtil.getInstance().getLabelMapMatches();
+
+    if (labelMapMatches == null || labelMapMatches.isEmpty()) {
+      return true;
+    }
+
+    for (Map.Entry<String, String> entry : labelMapMatches.entrySet()) {
+      String key = entry.getKey();
+      String value = entry.getValue();
+
+      // Multiple values match
+
+      if (StringUtils.isBlank(labelMap.get(key))) {
+        continue;
+      }
+
+      String[] routeLalelsArray = StringUtils.split(value, "|");
+
+      String[] serviceLabelsArray = StringUtils.split(labelMap.get(key), "|");
+
+      if (CommonUtil.contain(routeLalelsArray, serviceLabelsArray)) {
+        return true;
+      }
+
+    }
+
+    return false;
+  }
+
+
+
+  /*
+   * public boolean isNeedNotifyByRoute(String protocol, String namespace, String visualRange,
+   * String network_plane_type, Map<String, String> labelMap) {
+   * 
+   * return isNeedNotifyByProtocol(protocol) && isNeedNotifyByNameSpace(namespace) &&
+   * isNeedNotifyByVisualRange(visualRange) && isNeedNotifyByRouteLabels(labelMap) &&
+   * isNeedNotifyByNetwork_plane_typeMatches(network_plane_type);
+   * 
+   * }
+   */
+
+  public boolean isFilterCheck(ServiceHealth health){
+    return isFilterHealthCheck(health.getChecks()) && isFilterService(health.getService().getTags());
+  }
+  
+  /**
+   * @Title isFilterHealthCheck
+   * @Description TODO(判断服务实例的健康检查信息，全部为passing表示健康检查有效)
+   * @param List<HealthCheck>
+   * @return boolean checkList示例——"Checks" : [{
+                "Node" : "server",
+                "CheckID" : "serfHealth",
+                "Name" : "Serf Health Status",
+                "Status" : "passing",
+                "Notes" : "",
+                "Output" : "Agent alive and reachable",
+                "ServiceID" : "",
+                "ServiceName" : "",
+                "CreateIndex" : 65536,
+                "ModifyIndex" : 65536
+            }, {
+                "Node" : "server",
+                "CheckID" : "service:_tcp_roundrobin_1_10.74.151.26_22",
+                "Name" : "Service 'tcp_roundrobin_1' check",
+                "Status" : "critical",
+                "Notes" : "",
+                "Output" : "dial tcp: missing port in address ok",
+                "ServiceID" : "_tcp_roundrobin_1_10.74.151.26_22",
+                "ServiceName" : "tcp_roundrobin_1",
+                "CreateIndex" : 75988,
+                "ModifyIndex" : 76173
+            }
+        ]
+   */
+  public  boolean isFilterHealthCheck(List<HealthCheck> checkList){
+    if(checkList.isEmpty()){
+      return true;
+    }
+    
+    for (HealthCheck check : checkList) {
+      if (!RouteUtil.HEALTH_CHECK_PASSING.equals(check.getStatus())) {
+        return false;
+      }
+    }
+    
+    return true;
+  }
+  
+  
+
+  /**
+   * @Title isFilterService
+   * @Description TODO(判断来自consul的服务信息是否需要过滤)
+   * @param List<String>
+   * @return boolean tagList示例—— [
+   *         "\"base\":{\"protocol\":\"REST\",\"is_manual\":\"true\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"
+   *         , "\"ns\":{\"namespace\":\"nsName\"}",
+   *         "\"labels\":{\"visualRange\":\"0\",\"network_plane_type\":\"net\",\"customLabel\":\"custom\"}"
+   *         ]
+   */
+  @SuppressWarnings("unchecked")
+  public boolean isFilterService(List<String> tagList) {
+
+    if (tagList == null || tagList.size() == 0)
+      return false;
+
+    String visualRange = "", network_plane_type = "", protocol = "", namespace = "";
+    
+    //针对多版本不同属性的tag会有多个，只要其中一个匹配即通过过滤,默认不通过
+    boolean visualRangeFilter=false,protocolFilter = false, namespaceFilter = false; 
+    boolean hasnamespace=false;
+
+    try {
+
+      for (String tag : tagList) {
+
+        // 提取基础属性tag
+        if (!protocolFilter && tag.startsWith("\"base\"")) {
+          String ms_base_json = tag.split("\"base\":")[1];
+
+          Map<String, String> baseMap =
+              (Map<String, String>) JacksonJsonUtil.jsonToBean(ms_base_json, Map.class);
+
+          if (baseMap.get("protocol") != null) {
+            protocol = baseMap.get("protocol");
+            if ("PORTAL".equalsIgnoreCase(protocol)) {
+              protocol = "HTTP";
+            }
+            
+            if (isNeedNotifyByProtocol(protocol)) {
+              protocolFilter=true;
+            }
+
+          }
+
+          
+
+          continue;
+        }
+
+        // 提取命名空间属性tag
+        if (!namespaceFilter && tag.startsWith("\"ns\"")) {
+          String ms_ns_json = tag.split("\"ns\":")[1];
+          Map<String, String> nsMap =
+              (Map<String, String>) JacksonJsonUtil.jsonToBean(ms_ns_json, Map.class);
+
+          if (nsMap.get("namespace") != null) {
+            namespace = nsMap.get("namespace");
+            hasnamespace=true;
+            
+            if (isNeedNotifyByNameSpace(namespace)) {
+              namespaceFilter=true;
+            }
+          }
+
+          
+          continue;
+        }
+
+        // 提取Label属性tag
+        if (tag.startsWith("\"labels\"")) {
+          String ms_labels_json = "{" + tag.split("\"labels\":\\{")[1];
+          // 自定义label标签属性
+          Map<String, String> labelMap =
+              (Map<String, String>) JacksonJsonUtil.jsonToBean(ms_labels_json, Map.class);
+
+       
+            
+            if (!visualRangeFilter && labelMap.get("visualRange") != null) {
+              visualRange = labelMap.get("visualRange");
+              labelMap.remove("visualRange"); // 自定义标签排除可见范围和网络平面
+        
+            if(isNeedNotifyByVisualRange(visualRange)){
+              visualRangeFilter=true;
+            }
+          }  
+          
+
+          if (labelMap.get("network_plane_type") != null) {
+            network_plane_type = labelMap.get("network_plane_type");
+            labelMap.remove("network_plane_type");
+          }
+          if (!isNeedNotifyByNetwork_plane_typeMatches(network_plane_type)) {
+            return false;
+          }
+
+          if (!isNeedNotifyByRouteLabels(labelMap)) {
+            return false;
+          }
+
+          continue;
+        }
+
+      }
+
+      //针对无命名空间的服务判断是否过滤
+      if (!hasnamespace && isNeedNotifyByNameSpace(namespace)) {
+        namespaceFilter=true;
+      }
+
+      return visualRangeFilter && protocolFilter && namespaceFilter;
+
+
+    } catch (Exception e) {
+      LOGGER.error(" read tag  throw exception", e);
+      return false;
+    }
+
+
+  }
+  
+
+
+  @SuppressWarnings("unchecked")
+  public Map<String, MicroServiceFullInfo> transMicroServiceInfoFromConsul(
+      List<ServiceHealth> serviceNodeList) {
+    // 同名多版本服务MAP
+    Map<String, MicroServiceFullInfo> microServiceInfo4version =
+        new HashMap<String, MicroServiceFullInfo>();
+
+
+    for (ServiceHealth serviceNode : serviceNodeList) {
+
+      MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo();
+      String url = "";
+      String version = "", visualRange = "", protocol = "", lb_policy = "", namespace =
+          "", host = "", path = "", publish_port = "";
+      boolean enable_ssl = false;
+
+      HashSet<Node> nodes = new HashSet<Node>();
+
+      Service service = serviceNode.getService();
+      String serviceName = service.getService();
+
+      try {
+        List<String> tagList = service.getTags();
+
+        for (String tag : tagList) {
+
+          if (tag.startsWith("\"base\"")) {
+            String ms_base_json = tag.split("\"base\":")[1];
+
+
+            Map<String, String> baseMap =
+                (Map<String, String>) JacksonJsonUtil.jsonToBean(ms_base_json, Map.class);
+            if (baseMap.get("url") != null) {
+              url = baseMap.get("url");
+            }
+
+            if (baseMap.get("version") != null) {
+              version = baseMap.get("version");
+            }
+
+            if (baseMap.get("protocol") != null) {
+              protocol = baseMap.get("protocol");
+            }
+
+            if (baseMap.get("host") != null) {
+              host = baseMap.get("host");
+            }
+
+            if (baseMap.get("path") != null) {
+              path = baseMap.get("path");
+            }
+
+            if (baseMap.get("publish_port") != null) {
+              publish_port = baseMap.get("publish_port");
+            }
+
+
+            if (baseMap.get("enable_ssl") != null) {
+              enable_ssl = Boolean.valueOf(baseMap.get("enable_ssl"));
+            }
+
+            continue;
+          }
+
+
+
+          if (tag.startsWith("\"ns\"")) {
+            String ms_ns_json = tag.split("\"ns\":")[1];
+            Map<String, String> nsMap =
+                (Map<String, String>) JacksonJsonUtil.jsonToBean(ms_ns_json, Map.class);
+
+            if (nsMap.get("namespace") != null) {
+              namespace = nsMap.get("namespace");
+            }
+
+            continue;
+          }
+
+          if (tag.startsWith("\"labels\"")) {
+            String ms_labels_json = "{" + tag.split("\"labels\":\\{")[1];
+            Map<String, String> labelMap =
+                (Map<String, String>) JacksonJsonUtil.jsonToBean(ms_labels_json, Map.class);
+
+
+            if (labelMap.get("visualRange") != null) {
+              visualRange = labelMap.get("visualRange");
+            }
+
+            /*if (labelMap.get("network_plane_type") != null) {
+              network_plane_type = labelMap.get("network_plane_type");
+            }*/
+
+            continue;
+          }
+
+          if (tag.startsWith("\"lb\"")) {
+            String ms_lb_json = tag.split("\"lb\":")[1];
+            Map<String, String> lbMap =
+                (Map<String, String>) JacksonJsonUtil.jsonToBean(ms_lb_json, Map.class);
+
+            if (lbMap.get("lb_policy") != null) {
+              lb_policy = lbMap.get("lb_policy");
+            }
+            continue;
+          }
+
+        }
+
+
+
+      } catch (Exception e) {
+        LOGGER.error(serviceName + " read tag  throw exception", e);
+      }
+
+      if (!microServiceInfo4version.containsKey(version)) {
+
+        if ("PORTAL".equalsIgnoreCase(protocol)) {
+          protocol = "HTTP";
+          microServiceInfo.setCustom(RouteUtil.CUSTOM_PORTAL);
+        }
+
+        microServiceInfo.setProtocol(protocol);
+        microServiceInfo.setUrl(url);
+        microServiceInfo.setServiceName(serviceName);
+        microServiceInfo.setLb_policy(lb_policy);
+        microServiceInfo.setVisualRange(visualRange);
+
+        microServiceInfo.setEnable_ssl(enable_ssl);
+        microServiceInfo.setVersion(version);
+        microServiceInfo.setNamespace(namespace);
+        microServiceInfo.setHost(host);
+        microServiceInfo.setPath(path);
+        //系统间apigateway 保存publish_port
+        if ("0".equals(ConfigUtil.getInstance().getVisualRangeMatches())) {
+          microServiceInfo.setPublish_port(publish_port);
+        }
+
+        nodes.add(new Node(service.getAddress(), String.valueOf(service.getPort())));
+        microServiceInfo.setNodes(nodes);
+
+        microServiceInfo4version.put(version, microServiceInfo);
+      } else {
+
+        Set<Node> newNodes = microServiceInfo4version.get(version).getNodes();
+        // 默认node是注册信息的IP和port
+        newNodes.add(new Node(service.getAddress(), String.valueOf(service.getPort())));
+
+        // 同名多版本同步
+        microServiceInfo4version.get(version).setNodes(newNodes);
+
+      }
+
+
+      /*
+       * // 健康检查信息 List<Check> checks = value.getChecks(); node.setStatus("passing"); for (Check
+       * check : checks) { if (!"passing".equals(check.getStatus())) {
+       * node.setStatus(check.getStatus()); break; } }
+       */
+
+
+
+    }
+
+    return microServiceInfo4version;
+
+  }
+
+}