Skip to content

N
neo4jRelation
Commit 655fba8c by qiuchaofei
Options

提交哦同步元数据关系到neo4j的项目

parents
Showing with 1578 additions and 0 deletions
pom.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.keymobile</groupId>
<artifactId>MetadataRelation</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<properties>
<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<spring-boot.version>2.3.4.RELEASE</spring-boot.version>
</properties>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.5.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.5.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<version>2.0.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
<version>2.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
<version>2.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-client</artifactId>
<version>2.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-bom</artifactId>
<version>${spring-security.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>com.keymobile.auth</groupId>
<artifactId>common</artifactId>
<version>3.0.3-SNAPSHOT</version>
</dependency>
<!-- 添加neo4j的jar包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-neo4j</artifactId>
<version>2.1.9.RELEASE</version>
</dependency>
<dependency>
<groupId>org.neo4j</groupId>
<artifactId>neo4j-ogm-http-driver</artifactId>
<version>3.2.1</version>
</dependency>
<!-- add this dependency if you want to use the embedded driver -->
<dependency>
<groupId>org.neo4j</groupId>
<artifactId>neo4j-ogm-embedded-driver</artifactId>
<version>3.2.10</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
</dependencies>
<repositories>
<repository>
<id>nexus</id>
<url>http://139.198.127.28:18081/repository/maven-public/</url>
<name>keymobile</name>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
</project>
\ No newline at end of file
src/main/java/com/keymobile/metadata/metadataRelation/MetadataRelationApplication.java 0 → 100644
package com.keymobile.metadata.metadataRelation;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
@EnableFeignClients
@SpringBootApplication
public class MetadataRelationApplication {
public static void main(String[] args) {
// System.setProperty("es.set.netty.runtime.available.processors", "false");
SpringApplication.run(MetadataRelationApplication.class, args);
}
}
src/main/java/com/keymobile/metadata/metadataRelation/Swagger2Config.java 0 → 100644
package com.keymobile.metadata.metadataRelation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class Swagger2Config {
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.keymobile.metadata.metadataRelation"))
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("DATA MODEL RESTful APIs")
.description("Spring Boot Swagger2")
.termsOfServiceUrl("http://www.keymobile.com.cn/")
.contact("keymobile")
.version("1.0")
.build();
}
}
src/main/java/com/keymobile/metadata/metadataRelation/config/FeignClientConfig.java 0 → 100644
package com.keymobile.metadata.metadataRelation.config;
import feign.auth.BasicAuthRequestInterceptor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class FeignClientConfig {
@Value("${security.authUser}")
private String authUser;
@Value("${security.authPwd}")
private String authPwd;
@Bean
public BasicAuthRequestInterceptor getBasicAuthRequestInterceptor() {
return new BasicAuthRequestInterceptor(authUser, authPwd);
}
}
\ No newline at end of file
src/main/java/com/keymobile/metadata/metadataRelation/config/MongoDBConfig.java 0 → 100644
package com.keymobile.metadata.metadataRelation.config;
import com.mongodb.*;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.gridfs.GridFSBucket;
import com.mongodb.client.gridfs.GridFSBuckets;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.gridfs.GridFsTemplate;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class MongoDBConfig extends AbstractMongoConfiguration {
@Value("${mongodb.uri}")
private String host;
@Value("${mongodb.database}")
private String database;
@Value("${mongodb.username}")
private String user;
@Value("${mongodb.password}")
private String pswd;
@Value("${mongodb.maxConnectionIdleTime}")
private Integer maxConnectionIdleTime = 60000;
@Override
protected String getDatabaseName() {
return database;
}
@Bean
@Override
public MongoDbFactory mongoDbFactory() {
return new SimpleMongoDbFactory(this.mongoClient(), this.getDatabaseName());
}
@Bean
public GridFsTemplate gridFsTemplate() throws Exception {
return new GridFsTemplate(mongoDbFactory(), mappingMongoConverter());
}
@Bean
public GridFSBucket getGridFSBuckets() {
MongoDatabase db = mongoDbFactory().getDb();
return GridFSBuckets.create(db);
}
@Override
public MongoClient mongoClient() {
if (host.split(",").length > 1) {
String[] serverArray = host.split(",");
List<ServerAddress> serverList = new ArrayList<>();
for (String ipPort : serverArray) {
String[] ipAndPort = ipPort.split(":");
serverList.add(new ServerAddress(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
}
MongoClientOptions options = MongoClientOptions.builder()
.maxConnectionIdleTime(maxConnectionIdleTime)
.readPreference(ReadPreference.secondaryPreferred()).build();
MongoCredential credential = MongoCredential.createCredential(user, database, pswd.toCharArray());
return new MongoClient(serverList, credential, options);
} else {
String uri = String.format("mongodb://%s:%s@%s/%s", user, pswd, host, database);
MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
builder.maxConnectionIdleTime(maxConnectionIdleTime);
MongoClientURI clientURI = new MongoClientURI(uri, builder);
return new MongoClient(clientURI);
}
}
}
src/main/java/com/keymobile/metadata/metadataRelation/config/Neo4jConfig.java 0 → 100644
package com.keymobile.metadata.metadataRelation.config;
import org.springframework.context.annotation.Configuration;
@Configuration
public class Neo4jConfig {
}
src/main/java/com/keymobile/metadata/metadataRelation/config/SecurityConfig.java 0 → 100644
package com.keymobile.metadata.metadataRelation.config;
import com.keymobile.auth.common.security.CustomizedUserDetailService;
import org.apache.commons.codec.digest.DigestUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
@ComponentScan("com.keymobile.auth.common.security")
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private CustomizedUserDetailService customUserDetailService;
@Value("${security.permit}")
private boolean permit = true;
@Autowired
public void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(customUserDetailService).passwordEncoder(new SHA1PasswordEncoder());
}
@Override
protected void configure(HttpSecurity http) throws Exception {
if (permit)
http.httpBasic().and().authorizeRequests().anyRequest().permitAll();
else {
http.httpBasic().and().authorizeRequests().anyRequest().authenticated();
}
http.csrf().disable();
}
class SHA1PasswordEncoder implements PasswordEncoder {
@Override
public String encode(CharSequence charSequence) {
return DigestUtils.sha1Hex(charSequence.toString());
}
@Override
public boolean matches(CharSequence charSequence, String s) {
return DigestUtils.sha1Hex(charSequence.toString()).equals(s);
}
}
}
src/main/java/com/keymobile/metadata/metadataRelation/controller/MetaDataController.java 0 → 100644
package com.keymobile.metadata.metadataRelation.controller;
import com.keymobile.metadata.metadataRelation.pojo.BaseRelationship;
import com.keymobile.metadata.metadataRelation.pojo.MetaData;
import com.keymobile.metadata.metadataRelation.pojo.returnBean.Edge;
import com.keymobile.metadata.metadataRelation.pojo.returnBean.Node;
import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
import com.keymobile.metadata.metadataRelation.service.IBaseRelationshipService;
import com.keymobile.metadata.metadataRelation.service.IMetadataService;
import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RequestMapping(value = "api/metadata")
@RestController
@Api(value = "metadata", tags = "把metadata写入neo4j数据库")
public class MetaDataController {
@Autowired
private IMetadataService metadataService;
@Autowired
private IBaseRelationshipService baseRelationshipService;
/**
* 查询元数据，关系
*/
@RequestMapping(path = "/result", method = RequestMethod.GET)
public ReturnReslult getAllNodeAndRelation() {
ReturnReslult result = new ReturnReslult();
List<MetaData> metaDataList = metadataService.finAllMetaData();
Map<Long,Node> nodeMap = new HashMap<>();
for(MetaData metaData:metaDataList){
Node node = new Node();
node.setId(metaData.getMetadataId());
node.setName(metaData.getName());
result.getNodes().add(node);
nodeMap.put(metaData.getId(),node);
}
List<BaseRelationship> baseRelationshipList = baseRelationshipService.findAllRelation();
for(BaseRelationship baseRelationship:baseRelationshipList){
Edge edge = new Edge();
edge.setEdgeId(String.valueOf(baseRelationship.getId()));
Long startId = baseRelationship.getStart().getId();
Long endId = baseRelationship.getEnd().getId();
String startMetaId = "";
String endMEtaId ="";
if(nodeMap.containsKey(startId)){
startMetaId = nodeMap.get(startId).getId();
}
if(nodeMap.containsKey(endId)){
endMEtaId = nodeMap.get(endId).getId();
}
edge.setFromId(startMetaId);
edge.setToId(endMEtaId);
edge.setType(baseRelationship.getName());
result.getEdges().add(edge);
}
return result;
}
/**
* 查询元数据
*/
@RequestMapping(path = "/list", method = RequestMethod.GET)
public List<MetaData> getUserNodeList() {
return metadataService.finAllMetaData();
}
/**
* 添加元数据的接口
*/
@RequestMapping(path = "/addMetadata", method = RequestMethod.POST)
public MetaData addMetadata(@RequestBody MetaData metaData) {
System.out.println("这是写入元数据的方法。");
MetaData metaData1 = metadataService.addMetaData(metaData);
return metaData1;
}
/**
* 同步元数据关系的接口，从mongo读取关系，存入到neo4j中
* @return
*/
@RequestMapping(path = "/syschroRelationFromMongo", method = RequestMethod.GET)
public String syschroRelationFromMongo(){
String flag = "success";
metadataService.syschroRelationFromMongo();
return flag;
}
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/AllBaseEntity.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
import org.neo4j.ogm.annotation.GeneratedValue;
import org.neo4j.ogm.annotation.Id;
public class AllBaseEntity {
/**
* id 必须为Long类型，而且必须提供(节点和关系都需要)。且要加这个注解。
* id 由图数据库统一操作，所以不需要setter
*/
@Id
@GeneratedValue
private Long id;
public Long getId() {
return id;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
if (this.id == null) {
// For newly created entity, id will be null
return false;
}
AllBaseEntity entity = (AllBaseEntity) obj;
return this.id.equals(entity.id);
}
@Override
public int hashCode() {
return id == null ? super.hashCode() : id.hashCode();
}
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/BaseNode.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
public class BaseNode extends AllBaseEntity {
private String name; //名称
// @Relationship(type= NodeType.REF)
// private Set<BaseRelationship> relationships; //关系列表
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// public Set<BaseRelationship> getRelationships() {
// return relationships;
// }
//
// public void setRelationships(Set<BaseRelationship> relationships) {
// this.relationships = relationships;
// }
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/BaseRelationship.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
import org.neo4j.ogm.annotation.EndNode;
import org.neo4j.ogm.annotation.Property;
import org.neo4j.ogm.annotation.RelationshipEntity;
import org.neo4j.ogm.annotation.StartNode;
public class BaseRelationship <S extends BaseNode, E extends BaseNode> extends AllBaseEntity {
@Property
private String name; //关系名称
@StartNode
private S start;
@EndNode
private E end;
public BaseRelationship(){
}
public BaseRelationship(String name,S start,E end){
this.name =name;
this.start=start;
this.end=end;
}
@Override
public String toString() {
return "BaseRelationship{" +
"name='" + name + '\'' +
", start=" + start +
", end=" + end +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public S getStart() {
return start;
}
public void setStart(S start) {
this.start = start;
}
public E getEnd() {
return end;
}
public void setEnd(E end) {
this.end = end;
}
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/CompositionRelation.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
import org.neo4j.ogm.annotation.RelationshipEntity;
@RelationshipEntity(type = "Composition")
public class CompositionRelation extends BaseRelationship{
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/DependencyRelation.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
import org.neo4j.ogm.annotation.RelationshipEntity;
@RelationshipEntity(type = "Dependency")
public class DependencyRelation extends BaseRelationship{
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/ExecuteRelation.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
import org.neo4j.ogm.annotation.RelationshipEntity;
@RelationshipEntity(type = "Execute")
public class ExecuteRelation extends BaseRelationship{
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/InputRelation.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
import org.neo4j.ogm.annotation.RelationshipEntity;
@RelationshipEntity(type = "Input")
public class InputRelation extends BaseRelationship{
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/MetaData.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
import org.neo4j.ogm.annotation.NodeEntity;
import org.neo4j.ogm.annotation.Relationship;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@NodeEntity(label = "MetaData")
public class MetaData extends BaseNode {
public String getMetadataId() {
return metadataId;
}
public void setMetadataId(String metadataId) {
this.metadataId = metadataId;
}
//元数据id
private String metadataId;
//名称
private String node;
//路径，
private String path;
//描述，
private String description;
// 别名，
private String alias;
// 元数据类型
private String metaModel;
//关系
private String relation;
//其他属性
private String property;
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getAlias() {
return alias;
}
public void setAlias(String alias) {
this.alias = alias;
}
public String getMetaModel() {
return metaModel;
}
public void setMetaModel(String metaModel) {
this.metaModel = metaModel;
}
public void addRelation(DependencyRelation friendshipRelation){
if(this.dependencyRelationList == null){
dependencyRelationList = new ArrayList<DependencyRelation>();
}
dependencyRelationList.add(friendshipRelation);
}
public List<DependencyRelation> getDependencyRelationList() {
if(this.dependencyRelationList == null){
dependencyRelationList = new ArrayList<DependencyRelation>();
}
return dependencyRelationList;
}
public void setDependencyRelationList(List<DependencyRelation> dependencyRelationList) {
this.dependencyRelationList = dependencyRelationList;
}
@Relationship(type = "Dependency_RELATION")
private List<DependencyRelation> dependencyRelationList;
public List<DependencyRelation> getCompositionRelationList() {
if(this.compositionRelationList == null){
compositionRelationList = new ArrayList<DependencyRelation>();
}
return compositionRelationList;
}
public void setCompositionRelationList(List<DependencyRelation> compositionRelationList) {
this.compositionRelationList = compositionRelationList;
}
@Relationship(type = "Composition_RELATION")
private List<DependencyRelation> compositionRelationList ;
public String getNode() {
return node;
}
public void setNode(String node) {
this.node = node;
}
public String getRelation() {
return relation;
}
public void setRelation(String relation) {
this.relation = relation;
}
public String getProperty() {
return property;
}
public void setProperty(String property) {
this.property = property;
}
@Override
public String toString() {
return "MetaData{" +
"node='" + node + '\'' +
", path='" + path + '\'' +
", description='" + description + '\'' +
", alias='" + alias + '\'' +
", code='" + metaModel + '\'' +
", relation='" + relation + '\'' +
", property='" + property + '\'' +
", dependencyRelationList=" + dependencyRelationList +
", compositionRelationList=" + compositionRelationList +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (!super.equals(o)) return false;
MetaData metaData = (MetaData) o;
return Objects.equals(node, metaData.node) &&
Objects.equals(path, metaData.path) &&
Objects.equals(description, metaData.description) &&
Objects.equals(alias, metaData.alias) &&
Objects.equals(metaModel, metaData.metaModel) &&
Objects.equals(relation, metaData.relation) &&
Objects.equals(property, metaData.property) &&
Objects.equals(dependencyRelationList, metaData.dependencyRelationList) &&
Objects.equals(compositionRelationList, metaData.compositionRelationList);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), node, path, description, alias, metaModel, relation, property, dependencyRelationList, compositionRelationList);
}
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/OutputRelation.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
import org.neo4j.ogm.annotation.RelationshipEntity;
@RelationshipEntity(type = "Output")
public class OutputRelation extends BaseRelationship{
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/RelationMongo.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo;
public class RelationMongo {
private String id;
private String source;
private String target;
private String type;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getSource() {
return source;
}
public void setSource(String source) {
this.source = source;
}
public String getTarget() {
return target;
}
public void setTarget(String target) {
this.target = target;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/returnBean/Edge.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo.returnBean;
public class Edge {
private String edgeId;
private String fromId;
private String toId;
public String getEdgeId() {
return edgeId;
}
public void setEdgeId(String edgeId) {
this.edgeId = edgeId;
}
public String getFromId() {
return fromId;
}
public void setFromId(String fromId) {
this.fromId = fromId;
}
public String getToId() {
return toId;
}
public void setToId(String toId) {
this.toId = toId;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
private String type;
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/returnBean/Node.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo.returnBean;
public class Node {
String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
String name;
}
src/main/java/com/keymobile/metadata/metadataRelation/pojo/returnBean/ReturnReslult.java 0 → 100644
package com.keymobile.metadata.metadataRelation.pojo.returnBean;
import java.util.ArrayList;
import java.util.List;
public class ReturnReslult {
private List<Edge> edges= new ArrayList<>();
public List<Edge> getEdges() {
return edges;
}
public void setEdges(List<Edge> edges) {
this.edges = edges;
}
public List<Node> getNodes() {
return nodes;
}
public void setNodes(List<Node> nodes) {
this.nodes = nodes;
}
private List<Node> nodes = new ArrayList<>();
}
src/main/java/com/keymobile/metadata/metadataRelation/remote/MetadataRepoRemoteService.java 0 → 100644
package com.keymobile.metadata.metadataRelation.remote;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.Map;
@FeignClient(name = "MetadataRepo")
public interface MetadataRepoRemoteService {
@RequestMapping(value = "/rest/query/getParent", method = RequestMethod.GET)
Map<String, Object> getParent(@RequestParam("id") String id);
@RequestMapping(value = "/rest/metadata/get/{id}", method = RequestMethod.GET)
Map<String, Object> getMetadata(@PathVariable("id") String id);
}
src/main/java/com/keymobile/metadata/metadataRelation/respository/BaseRelationshipRepository.java 0 → 100644
package com.keymobile.metadata.metadataRelation.respository;
import com.keymobile.metadata.metadataRelation.pojo.*;
import org.springframework.data.neo4j.annotation.Query;
import org.springframework.data.neo4j.repository.Neo4jRepository;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface BaseRelationshipRepository extends Neo4jRepository<BaseRelationship,Long> {
List<BaseRelationship> findBaseRelationshipsByName(String name);
@Query("MATCH p=(n:BaseNode)-[r:Ref]->(m:BaseNode) WHERE r.name=$name and n.name=$startName and m.name=$endName RETURN r")
List<BaseRelationship> findRelationshipByAllName(@Param("name") String name, @Param("startName") String startName, @Param("endName") String endName);
@Query("MATCH p=(n:BaseNode)-->() WHERE n.name=$startName RETURN p")
List<BaseRelationship> findRelationshipByStartName(@Param("startName") String startName);
@Query("MATCH p=(n:BaseNode)-[r:Ref]->(m:BaseNode) WHERE r.name=$name and n.name=$startName RETURN r")
List<BaseRelationship> findRelationshipByStartNameAndName(@Param("name") String name, @Param("startName") String startName);
@Query("MATCH p=(n:BaseNode)-->() WHERE n.name=$startName RETURN p")
List<BaseNode> findBaseNodeByStartName(@Param("startName") String startName);
@Query("MATCH (n:MetaData{metadataId: $startId}),(n1:MetaData{metadataId: $endId}),p=(n)-[]-(n1) return p")
List<CompositionRelation> findCompositionRelationship(@Param("startId") String startId, @Param("endId") String endId);
@Query("MATCH (n:MetaData{metadataId: $startId}),(n1:MetaData{metadataId: $endId}),p=(n)-[]-(n1) return p")
List<InputRelation> findInputRelationship(@Param("startId") String startId, @Param("endId") String endId);
@Query("MATCH (n:MetaData{metadataId: $startId}),(n1:MetaData{metadataId: $endId}),p=(n)-[]-(n1) return p")
List<OutputRelation> findOutputRelationship(@Param("startId") String startId, @Param("endId") String endId);
@Query("MATCH (n:MetaData{metadataId: $startId}),(n1:MetaData{metadataId: $endId}),p=(n)-[]-(n1) return p")
List<ExecuteRelation> findExecuteRelationship(@Param("startId") String startId, @Param("endId") String endId);
/**
* 添加input关系
* @param sourceId
* @param targetId
* @return
*/
@Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Input]->(target) return p")
List<BaseRelationship> addInputRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
/**
* 添加output关系
* @param sourceId
* @param targetId
* @return
*/
@Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Output]->(target) return p")
List<BaseRelationship> addOutRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
/**
* 添加excute关系
* @param sourceId
* @param targetId
* @return
*/
@Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Execute]->(target) return p")
List<BaseRelationship> addExecuteRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
/**
* 添加组合关系
* @param sourceId
* @param targetId
* @return
*/
@Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Composition]->(target) return p")
List<BaseRelationship> addConpositionRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
}
src/main/java/com/keymobile/metadata/metadataRelation/respository/MetadataRepository.java 0 → 100644
package com.keymobile.metadata.metadataRelation.respository;
import com.keymobile.metadata.metadataRelation.pojo.MetaData;
import feign.Param;
import org.springframework.data.elasticsearch.annotations.Query;
import org.springframework.data.neo4j.repository.Neo4jRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface MetadataRepository extends Neo4jRepository<MetaData,Long> {
MetaData findMetadataByName(String name);
}
src/main/java/com/keymobile/metadata/metadataRelation/service/IBaseRelationshipService.java 0 → 100644
package com.keymobile.metadata.metadataRelation.service;
import com.keymobile.metadata.metadataRelation.pojo.BaseNode;
import com.keymobile.metadata.metadataRelation.pojo.BaseRelationship;
import java.util.List;
public interface IBaseRelationshipService {
/**
* 查找所有的关系
*/
List<BaseRelationship> findAllRelation();
/**
* @desc 添加关系
* @param relationship
*/
BaseRelationship addRelationship(BaseRelationship relationship);
/**
* @desc 添加关系
* @param name 关系名称
* @param startNode 开始节点
* @param endNode 结束节点
*/
BaseRelationship addRelationship(String name, BaseNode startNode, BaseNode endNode);
/**
* @desc 删除关系
* @param id
*/
boolean deleteRelationshipById(Long id);
/**
* @desc 获取关系 根据开始节点名称和关系名称
* @param name 关系名称
* @param startName 开始节点名称
* @param endName 结束节点名称
*/
List<BaseRelationship> findMetadataRelationshipByAllName(String name, String startName, String endName);
/**
* @desc 获取关系 根据节点名称和关系名称
* @param name 关系名称
* @param startName 开始节点名称
*/
List<BaseRelationship> findMetadataRelationshipByStartNameAndName(String name, String startName);
/**
* @desc 获取关系 根据节点名称和关系名称
* @param startName 开始节点名称
*/
List<BaseRelationship> findMetadataRelationshipByStartName(String startName);
/**
* @desc 根据节点名称,获取所有有关系的节点
* @param startName 开始节点名称
*/
List<BaseNode> findMetadataByStartName(String startName);
}
src/main/java/com/keymobile/metadata/metadataRelation/service/IMetadataService.java 0 → 100644
package com.keymobile.metadata.metadataRelation.service;
import com.keymobile.metadata.metadataRelation.pojo.BaseRelationship;
import com.keymobile.metadata.metadataRelation.pojo.MetaData;
import org.springframework.data.mongodb.core.query.Meta;
import java.util.List;
public interface IMetadataService {
List<MetaData> finAllMetaData();
/**
* 添加元数据对象
* @param metaData
*/
MetaData addMetaData(MetaData metaData);
/**
* @desc 根据名称添加元数据
* @param name
*/
MetaData addMetadataByName(String name);
void syschroRelationFromMongo();
/**
* 添加元数据对象
* @param id
*/
MetaData getMetaDataById(Long id);
/**
* @desc 根据名称获取元数据
* @param name
*/
MetaData getMetadataByName(String name);
/**
* @desc 根据ID删除人物节点
* @param id
*/
boolean deleteMetadata(Long id);
/**
* @desc 添加元数据的关系
* @param name 关系名称
* @param startName 开始节点名称
* @param endName 结束节点名称
* @return BaseRelationship
*/
BaseRelationship addMetadataRelationship(String name, String startName, String endName);
/**
* @desc 获取任务关系
* @param name 关系名称
* @param startName 开始节点名称
* @param endName 结束节点名称
*/
List<BaseRelationship> getMetadataRelationship(String name, String startName, String endName);
}
src/main/java/com/keymobile/metadata/metadataRelation/service/impl/BaseRelationshipServiceImpl.java 0 → 100644
package com.keymobile.metadata.metadataRelation.service.impl;
import com.keymobile.metadata.metadataRelation.pojo.BaseNode;
import com.keymobile.metadata.metadataRelation.pojo.BaseRelationship;
import com.keymobile.metadata.metadataRelation.respository.BaseRelationshipRepository;
import com.keymobile.metadata.metadataRelation.service.IBaseRelationshipService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class BaseRelationshipServiceImpl implements IBaseRelationshipService {
@Autowired
private BaseRelationshipRepository refRepository;
@Override
public List<BaseRelationship> findAllRelation() {
return (List<BaseRelationship>)refRepository.findAll();
}
@Override
public BaseRelationship addRelationship(BaseRelationship relationship) {
return refRepository.save(relationship);
}
@Override
public BaseRelationship addRelationship(String name, BaseNode startNode, BaseNode endNode) {
BaseRelationship relationship = new BaseRelationship(name,startNode,endNode);
return refRepository.save(relationship);
}
@Override
public boolean deleteRelationshipById(Long id) {
refRepository.deleteById(id);
return true;
}
@Override
public List<BaseRelationship> findMetadataRelationshipByAllName(String name, String startName, String endName) {
List<BaseRelationship> ships = refRepository.findRelationshipByAllName(name,startName,endName);
if(ships != null && ships.size()>0) {
return ships;
}
return null;
}
@Override
public List<BaseRelationship> findMetadataRelationshipByStartNameAndName(String name, String startName) {
List<BaseRelationship> ships = refRepository.findRelationshipByStartNameAndName(name,startName);
if(ships != null && ships.size()>0) {
return ships;
}
return null;
}
@Override
public List<BaseRelationship> findMetadataRelationshipByStartName(String startName) {
List<BaseRelationship> ships = refRepository.findRelationshipByStartName(startName);
if(ships != null && ships.size()>0) {
return ships;
}
return null;
}
@Override
public List<BaseNode> findMetadataByStartName(String startName) {
List<BaseNode> nodes = refRepository.findBaseNodeByStartName(startName);
if(nodes != null && nodes.size()>0) {
return nodes;
}
return null;
}
}
src/main/java/com/keymobile/metadata/metadataRelation/service/impl/MetadataServiceImpl.java 0 → 100644
package com.keymobile.metadata.metadataRelation.service.impl;
import com.keymobile.metadata.metadataRelation.pojo.*;
import com.keymobile.metadata.metadataRelation.remote.MetadataRepoRemoteService;
import com.keymobile.metadata.metadataRelation.respository.BaseRelationshipRepository;
import com.keymobile.metadata.metadataRelation.respository.MetadataRepository;
import com.keymobile.metadata.metadataRelation.service.IBaseRelationshipService;
import com.keymobile.metadata.metadataRelation.service.IMetadataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
public class MetadataServiceImpl implements IMetadataService {
@Autowired
private MetadataRepository metadataRepository;
@Autowired
private IBaseRelationshipService relationshipService;
@Autowired
private BaseRelationshipRepository baseRelationshipRepository;
@Autowired
private MongoDbServiceImpl mongoDbServiceImpl;
@Autowired
private MetadataRepoRemoteService metadataRepoRemoteService;
@Override
public List<MetaData> finAllMetaData() {
return (List<MetaData>)metadataRepository.findAll();
}
@Override
public MetaData addMetaData(MetaData metaData) {
try{
return metadataRepository.save(metaData);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
@Override
public MetaData addMetadataByName(String name) {
return null;
}
@Override
public void syschroRelationFromMongo() {
//先从mongo读取关系，写入neo4j
Map<String ,MetaData> metaDataMap = new HashMap<>();
List<RelationMongo> relationMongoList = mongoDbServiceImpl.findAll();
for(RelationMongo relationMongo:relationMongoList){
// 获取元数据属性
System.out.println(relationMongo.getId());
String sourceId = relationMongo.getSource();
String targetId = relationMongo.getTarget();
String type = relationMongo.getType();
if(!metaDataMap.containsKey(sourceId)){
//不存在源
MetaData metaData = new MetaData();
metaData.setMetadataId(sourceId);
Map<String, Object> attriuteMap = metadataRepoRemoteService.getMetadata(sourceId);
String name = (String) attriuteMap.get("name");
metaData.setName(name);
metaDataMap.put(sourceId,metaData);
MetaData metadata = metadataRepository.findMetadataByName(name);
if(metadata !=null){
}else{
metadataRepository.save(metaData);
}
if(sourceId.startsWith("Column=") || sourceId.startsWith("Header=") ){
Map<String, Object> parentAlttriuteMap = metadataRepoRemoteService.getParent(sourceId);
String parentId = (String) parentAlttriuteMap.get("_id");
if(!metaDataMap.containsKey(parentId)){
//不存在，先创建父节点
MetaData parentData = new MetaData();
parentData.setMetadataId(parentId);
String parentName = (String) parentAlttriuteMap.get("name");
MetaData parentMetadata = metadataRepository.findMetadataByName(parentName);
parentData.setName(parentName);
if(parentMetadata !=null){
}else{
metadataRepository.save(parentData);
}
// metadataRepository.save(parentData);
metaDataMap.put(parentId,parentData);
}
List<CompositionRelation> relationship = baseRelationshipRepository.findCompositionRelationship(parentId, sourceId);
if(relationship==null || relationship.size()==0){
baseRelationshipRepository.addConpositionRelation(parentId,sourceId);
}
}
}
if(!metaDataMap.containsKey(targetId)){
//不存在目标
MetaData metaData = new MetaData();
metaData.setMetadataId(targetId);
Map<String, Object> attriuteMap = metadataRepoRemoteService.getMetadata(targetId);
String name = (String) attriuteMap.get("name");
metaData.setName(name);
metaDataMap.put(targetId,metaData);
MetaData neo4jData = metadataRepository.findMetadataByName(name);
if(neo4jData !=null){
}else{
metadataRepository.save(metaData);
}
if(targetId.startsWith("Column=") || targetId.startsWith("Header=") ){
Map<String, Object> parentAlttriuteMap = metadataRepoRemoteService.getParent(targetId);
String parentId = (String) parentAlttriuteMap.get("_id");
if(!metaDataMap.containsKey(parentId)){
//不存在，先创建父节点
MetaData parentData = new MetaData();
parentData.setMetadataId(parentId);
String parentName = (String) parentAlttriuteMap.get("name");
parentData.setName(parentName);
MetaData parentMetadata = metadataRepository.findMetadataByName(parentName);
if(parentMetadata !=null){
}else{
metadataRepository.save(parentData);
}
metaDataMap.put(parentId,parentData);
}
List<CompositionRelation> relationship = baseRelationshipRepository.findCompositionRelationship(parentId, targetId);
if(relationship==null || relationship.size()==0){
baseRelationshipRepository.addConpositionRelation(parentId,targetId);
}
}
}
if("input".equalsIgnoreCase(type)){
List<InputRelation> relationship = baseRelationshipRepository.findInputRelationship(sourceId,targetId);
if(relationship == null || relationship.size()==0){
baseRelationshipRepository.addInputRelation(sourceId,targetId);
}
}else if("output".equalsIgnoreCase(type)){
List<OutputRelation> relationship = baseRelationshipRepository.findOutputRelationship(sourceId,targetId);
if(relationship == null || relationship.size()==0){
baseRelationshipRepository.addOutRelation(sourceId,targetId);
}
}else if("execute".equalsIgnoreCase(type)) {
List<ExecuteRelation> relationship = baseRelationshipRepository.findExecuteRelationship(sourceId,targetId);
if(relationship == null || relationship.size()==0){
baseRelationshipRepository.addExecuteRelation(sourceId,targetId);
}
}
}
}
@Override
public MetaData getMetaDataById(Long id) {
return null;
}
@Override
public MetaData getMetadataByName(String name) {
return null;
}
@Override
public boolean deleteMetadata(Long id) {
return false;
}
@Override
public BaseRelationship addMetadataRelationship(String name, String startName, String endName) {
//获取人物节点
MetaData startMetadata = getMetadataByName(startName);
MetaData endMetadata = getMetadataByName(endName);
/**
* 添加关系有如下几种情况：
* 1.元数据节点全部存在:
* 1.1关系存在
* 1.2关系不存在
* 2.开始元数据节点存在，结束元数据节点不存在
* 3.开始元数据节点不存在，结束元数据节点存在
* 4.元数据节点均不存在
*/
if(startMetadata != null && endMetadata != null) { // 1.元数据节点全部存在
List<BaseRelationship> relationship = relationshipService.findMetadataRelationshipByAllName(name,startName,endName);
if(relationship != null) {
return relationship.get(0);
}
}else if(startMetadata != null && endMetadata == null) { //2.开始元数据节点存在，结束元数据节点不存在
endMetadata = addMetadataByName(endName);
}else if(startMetadata == null && endMetadata != null) { //3.开始元数据节点不存在，结束元数据节点存在
startMetadata = addMetadataByName(startName);
}else if(startMetadata == null && endMetadata == null) { //4.元数据节点均不存在
startMetadata = addMetadataByName(startName);
endMetadata = addMetadataByName(endName);
}
BaseRelationship relationship = relationshipService.addRelationship(name,startMetadata,endMetadata);
//更新开始节点关系
// Set<BaseRelationship> relationships = startMetadata.getRelationships();
// if(relationships == null) {
// relationships = new HashSet<>();
// }
// relationships.add(relationship);
// startMetadata.setRelationships(relationships);
// metadataRepository.save(startMetadata);
return relationship;
}
@Override
public List<BaseRelationship> getMetadataRelationship(String name, String startName, String endName) {
return null;
}
}
src/main/java/com/keymobile/metadata/metadataRelation/service/impl/MongoDbServiceImpl.java 0 → 100644
package com.keymobile.metadata.metadataRelation.service.impl;
import com.keymobile.metadata.metadataRelation.pojo.RelationMongo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class MongoDbServiceImpl {
private static final Logger logger = LoggerFactory.getLogger(MongoDbServiceImpl.class);
@Autowired
private MongoTemplate mongoTemplate;
/**
* 查询所有
*
* @return
*/
public List<RelationMongo> findAll() {
logger.info("--------------------->[MongoDB find start]");
try {
return mongoTemplate.findAll(RelationMongo.class,"md_relational");
}catch (Exception e){
e.printStackTrace();
return null;
}
}
}
src/main/resources/application.yml 0 → 100644
server:
port: 8289
spring:
application:
name: metadataRelation
data:
neo4j:
uri: http://127.0.0.1:7474
username: neo4j
password: yuanyao
main:
allow-bean-definition-overriding: true
datasource:
url: jdbc:mysql://192.168.0.192:3306/p0?autoReconnect=true&useUnicode=true&characterEncoding=utf-8
username: p_test
password: p_test
initialization-mode: always
continue-on-error: true
hikari:
maximum-pool-size: 5
redis:
host: 192.168.0.100
port: 6379
eureka:
client:
registerWithEureka: true
region: default
registryFetchIntervalSeconds: 5
serviceUrl:
defaultZone: http://192.168.0.111:8081/eureka/
security:
permit: false
authUser: root
authPwd: pwd
mongodb:
database: szsedev
uri: 192.168.0.192
username: szse
password: szse
maxConnectionIdleTime: 10000
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment