添加接口，同时找出表与字段的关系

src/main/java/com/keymobile/metadata/metadataRelation/controller/DataRelationAnalyController.java

 package com.keymobile.metadata.metadataRelation.controller;
 
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnNode;
+import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 import com.keymobile.metadata.metadataRelation.service.DataRelationAnalyService;
 import com.keymobile.metadata.metadataRelation.service.ITableService;
 import io.swagger.annotations.Api;
@@ -27,6 +28,15 @@ public class DataRelationAnalyController {
     @Autowired
     private ITableService tableService;
 
+    @ApiOperation(tags = "", value = "获取指定表的上下游关系及其字段的上下游关系。")
+    @RequestMapping(path = "/getTableAndColumnRelation", method = RequestMethod.GET)
+    public ReturnReslult getTableAndColumnRelation(String tableId) {
+        logger.info("获取指定表的上下游关系及其字段的上下游关系。tableId="+tableId);
+
+        return tableService.getTableAndColumnRelation(tableId);
+    }
+
+
     @ApiOperation(tags = "", value = "查找指定schema下面的孤立点。")
     @RequestMapping(path = "/getIsolatedNode", method = RequestMethod.GET)
     public Map<String, ReturnNode> getIsolatedNode(String parentId) {

src/main/java/com/keymobile/metadata/metadataRelation/service/ITableService.java

@@ -27,4 +27,5 @@ public interface ITableService {
 
     Map<String ,ReturnNode> getParentByChildId(String child);
 
+    ReturnReslult getTableAndColumnRelation(String tableId);
 }

src/main/java/com/keymobile/metadata/metadataRelation/service/impl/TableServiceImpl.java

@@ -450,6 +450,194 @@ public class TableServiceImpl implements ITableService {
         return parentMap;
     }
 
+    @Override
+    public ReturnReslult getTableAndColumnRelation(String tableId) {
+        ReturnReslult returnReslult = new ReturnReslult();
+
+        Map<String,ReturnNode> returnNodeMap = new HashMap<>();
+        Map<String,ReturnEdge> returnEdgeMap = new HashMap<>();
+        Neo4jConfig neo4jConfig = new Neo4jConfig();
+        Driver neo4jConnection = neo4jConfig.getNeo4jConnection();
+        Session session = neo4jConnection.session();
+
+        //先找出 表的前后关系，再找出表的字段，然后找出字段的前后关系，
+        String targetTablecypher = "match (n:Neo4jTable{metadataId:\""+ tableId +"\"})-[r1:流向]->(n1)-[r0:TempRelation*0..]->(m2)-[r:流向]->(m1) return m1";
+        String sourceTablecypher = "match (n:Neo4jTable{metadataId:\""+ tableId +"\"})<-[r1:流向]-(n1)<-[r0:TempRelation*0..]-(m2)<-[r:流向]-(m1) return m1";
+
+        StatementResult sourceTableResult = session.run(sourceTablecypher);
+        // 先找出目标表
+        while(sourceTableResult.hasNext()){
+            Record record = sourceTableResult.next();
+            List<Value> values = record.values();
+            for (Value value : values) {
+                if(value.type().name().equals("NODE")){
+                    Node node = value.asNode();
+
+                    Map<String, Object> stringObjectMap = node.asMap();
+                    MetaData metaData = new MetaData();
+                    Neo4jTool.transMap2Bean(stringObjectMap, metaData);
+                    if(metaData.getMetadataId() == null ){
+                        metaData.setMetadataId("System="+metaData.getName());
+                    }
+                    ReturnNode returnNode = new ReturnNode();
+                    returnNode.setId(metaData.getMetadataId());
+                    returnNode.setName(metaData.getName());
+                    returnNode.setCnName(metaData.getCnName());
+                    returnNode.setDataPath(metaData.getPath());
+                    returnNodeMap.put(returnNode.getId(),returnNode);
+
+                    ReturnEdge returnEdge = new ReturnEdge();
+                    String edgeId =returnNode.getId() +"_"+ tableId;
+                    returnEdge.setFromId(returnNode.getId());
+                    returnEdge.setToId(tableId );
+                    returnEdge.setType("流向");
+                    returnEdgeMap.put(edgeId,returnEdge);
+                }
+            }
+        }
+
+        StatementResult targetTablecResult = session.run(targetTablecypher);
+        // 先找出目标表
+        while(targetTablecResult.hasNext()){
+            Record record = targetTablecResult.next();
+            List<Value> values = record.values();
+            for (Value value : values) {
+                if(value.type().name().equals("NODE")){
+                    Node node = value.asNode();
+
+                    Map<String, Object> stringObjectMap = node.asMap();
+                    MetaData metaData = new MetaData();
+                    Neo4jTool.transMap2Bean(stringObjectMap, metaData);
+                    if(metaData.getMetadataId() == null ){
+                        metaData.setMetadataId("System="+metaData.getName());
+                    }
+                    ReturnNode returnNode = new ReturnNode();
+                    returnNode.setId(metaData.getMetadataId());
+                    returnNode.setName(metaData.getName());
+                    returnNode.setCnName(metaData.getCnName());
+                    returnNode.setDataPath(metaData.getPath());
+                    returnNodeMap.put(returnNode.getId(),returnNode);
+
+                    ReturnEdge returnEdge = new ReturnEdge();
+                    String edgeId = tableId+"_"+returnNode.getId();
+                    returnEdge.setFromId(tableId);
+                    returnEdge.setToId(returnNode.getId());
+                    returnEdge.setType("流向");
+                    returnEdgeMap.put(edgeId,returnEdge);
+                }
+            }
+        }
+
+        List<Neo4jColumn> neo4jColumns = neo4jTableRepository.getColumnByTableId(tableId);
+        for(Neo4jColumn neo4jColumn:neo4jColumns){
+            String currentColumnId = neo4jColumn.getMetadataId();
+
+            String targetColumncypher = "match (m:Neo4jColumn{metadataId:\""+currentColumnId+"\"})-[r1:流向]->(n1)-[r0:TempRelation*0..]->(m2)-[r:流向]->(m1) return m1";
+            String sourceColumncypher = "match (m:Neo4jColumn{metadataId:\""+currentColumnId+"\"})<-[r1:流向]-(n1)<-[r0:TempRelation*0..]-(m2)<-[r:流向]-(m1) return m1";
+
+            StatementResult targetColumnResult = session.run(targetColumncypher);
+            while(targetColumnResult.hasNext()){
+                Record record = targetColumnResult.next();
+                List<Value> values = record.values();
+                for (Value value : values) {
+                    if(value.type().name().equals("NODE")){
+                        Node node = value.asNode();
+
+                        Map<String, Object> stringObjectMap = node.asMap();
+                        MetaData metaData = new MetaData();
+                        Neo4jTool.transMap2Bean(stringObjectMap, metaData);
+                        if(metaData.getMetadataId() == null ){
+                            metaData.setMetadataId("System="+metaData.getName());
+                        }
+                        ReturnNode returnNode = new ReturnNode();
+                        returnNode.setId(metaData.getMetadataId());
+                        returnNode.setName(metaData.getName());
+                        returnNode.setCnName(metaData.getCnName());
+                        returnNode.setDataPath(metaData.getPath());
+                        returnNodeMap.put(returnNode.getId(),returnNode);
+
+                        ReturnEdge returnEdge = new ReturnEdge();
+                        String edgeId = tableId+"_"+returnNode.getId();
+                        returnEdge.setFromId(currentColumnId);
+                        returnEdge.setToId(returnNode.getId());
+                        returnEdge.setType("流向");
+                        returnEdgeMap.put(edgeId,returnEdge);
+                    }
+                }
+            }
+            StatementResult sourceColumnResult = session.run(sourceColumncypher);
+            while(sourceColumnResult.hasNext()){
+                Record record = sourceColumnResult.next();
+                List<Value> values = record.values();
+                for (Value value : values) {
+                    if(value.type().name().equals("NODE")){
+                        Node node = value.asNode();
+
+                        Map<String, Object> stringObjectMap = node.asMap();
+                        MetaData metaData = new MetaData();
+                        Neo4jTool.transMap2Bean(stringObjectMap, metaData);
+                        if(metaData.getMetadataId() == null ){
+                            metaData.setMetadataId("System="+metaData.getName());
+                        }
+                        ReturnNode returnNode = new ReturnNode();
+                        returnNode.setId(metaData.getMetadataId());
+                        returnNode.setName(metaData.getName());
+                        returnNode.setCnName(metaData.getCnName());
+                        returnNode.setDataPath(metaData.getPath());
+                        returnNodeMap.put(returnNode.getId(),returnNode);
+
+                        ReturnEdge returnEdge = new ReturnEdge();
+                        String edgeId =returnNode.getId() +"_"+tableId;
+                        returnEdge.setFromId(returnNode.getId() );
+                        returnEdge.setToId(currentColumnId);
+                        returnEdge.setType("流向");
+                        returnEdgeMap.put(edgeId,returnEdge);
+                    }
+                }
+            }
+        }
+
+        Map<String,ReturnNode> noRelationColumns = new HashMap<>();
+
+        for(Object obj:returnNodeMap.keySet()){
+
+            String currentTableId = (String)obj;
+
+            List<Neo4jColumn> currentNeo4jColumns = neo4jTableRepository.getColumnByTableId(currentTableId);
+            for(Neo4jColumn currentNeo4jColumn:currentNeo4jColumns){
+                String columnId = currentNeo4jColumn.getMetadataId();
+                if(!returnNodeMap.containsKey(columnId)){
+
+                    ReturnNode returnNode = new ReturnNode();
+                    returnNode.setId(currentNeo4jColumn.getMetadataId());
+                    returnNode.setName(currentNeo4jColumn.getName());
+                    returnNode.setCnName(currentNeo4jColumn.getCnName());
+                    noRelationColumns.put(columnId ,returnNode);
+                }
+                ReturnEdge returnEdge = new ReturnEdge();
+                String edgeId = currentTableId+"_"+columnId;
+                returnEdge.setFromId(currentTableId);
+                returnEdge.setToId(columnId);
+                returnEdge.setType("Composition");
+                returnEdgeMap.put(edgeId,returnEdge);
+            }
+        }
+        for(Object obj:returnNodeMap.keySet()){
+            ReturnNode returnNode = returnNodeMap.get(obj);
+            returnReslult.getNodes().add(returnNode);
+        }
+        for(Object obj:noRelationColumns.keySet()){
+            ReturnNode returnNode = noRelationColumns.get(obj);
+            returnReslult.getNodes().add(returnNode);
+        }
+        for(Object obj:returnEdgeMap.keySet()){
+            ReturnEdge returnEdge = returnEdgeMap.get(obj);
+            returnReslult.getEdges().add(returnEdge);
+        }
+
+        return returnReslult;
+    }
+
     private void getTargetRelationAboutTables(String metadataId, List<Neo4jTable> targetTableList) {
         List<BaseNode> targetNodeList = new ArrayList<>();
         if(metadataId.startsWith("ETLScript=")){