SpringBoot结合Neo4j自定义cypherSql的方法

前言

SpringBoot引入neo4j

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-neo4j</artifactId>
        </dependency>   
<spring.boot.version>2.2.11.RELEASE</spring.boot.version>

大多数时候Neo4j结合springboot都是按照实体类的映射,进行对象形式的创建节点,导致了节点属性的不可配性。结合这种问题,结合目前开发经验,可以使用neo4j 框架的session 进行原生cypherSql的执行。所以结合使用session进行动态可配等思路,建立一个Neo4jUtil..

Neo4jUtil作用

SpringBoot结合neo4j,自定义封装cypherSql进行操作。实际就是使用neo4j的Session.执行一些cypherSql操作,然后封装了一些方法供大家在既可以使用springboot的对象化操作方式的前提创建节点或者关系,也可以自定义继续封装一些特殊需求的方法,避免大家造轮子。

相关代码

application.yml

spring:
    data:
        neo4j:
          uri: bolt://127.0.0.1:7688
          username: neo4j
          password: neo4j

config

package com.troy.keeper.modules.desk.config;

import org.neo4j.ogm.session.SessionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories;
import org.springframework.data.neo4j.transaction.Neo4jTransactionManager;

@Configuration
@EnableNeo4jRepositories("com.troy.keeper.desc.repository") // 声明neo4j repository存放地址
public class Neo4jConfig {

    @Value("${spring.data.neo4j.uri}")
    private String uri;
    @Value("${spring.data.neo4j.username}")
    private String userName;
    @Value("${spring.data.neo4j.password}")
    private String password;

    @Bean
    public org.neo4j.ogm.config.Configuration getConfiguration() {
        org.neo4j.ogm.config.Configuration configuration = new org.neo4j.ogm.config.Configuration.Builder().uri(uri).connectionPoolSize(100).credentials(userName, password).withBasePackages("com.troy.keeper.desc.repository").build();
        return configuration;
    }

    @Bean
    public SessionFactory sessionFactory() {
        return new SessionFactory(getConfiguration());
    }

    @Bean("neo4jTransaction")
    public Neo4jTransactionManager neo4jTransactionManager(SessionFactory sessionFactory) {
        return new Neo4jTransactionManager(sessionFactory);
    }
}

Entity

Neo4jBasicNode

//节点实体类
package com.troy.keeper.modules.desk.entity.neo4j;

import lombok.Data;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
 * neo4j 节点实体类
 * @author YangBM
 */
@Data
public class Neo4jBasicNode implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * id
     */
    private Long id;

    /**
     * 标签
     */
    private List<String> labels;

    /**
     * 标签属性
     */
    private Map<String, Object> property;

}

Neo4jBaiscRelation

//关系实体类
package com.troy.keeper.modules.desk.entity.neo4j;

import lombok.Data;

import java.io.Serializable;
import java.util.Map;

/**
 * 关系
 */
@Data
public class Neo4jBaiscRelation implements Serializable {

    private static final long serialVersionUID = 1L;
    /**
     * id
     */
    private Long id;

    /**
     * 标签
     */
    private String type;

    /**
     * 标签属性
     */
    private Map<String, Object> property;
}

Neo4jQueryRelation

//查询关系的时候返回的对象封装的实体类
package com.troy.keeper.modules.desk.entity.neo4j;

import lombok.Data;

import java.io.Serializable;
import java.util.Map;

/**
 * 关系
 * @author YangBM
 */
@Data
public class Neo4jQueryRelation implements Serializable {

    private static final long serialVersionUID = 1L;
    /**
     * 开始节点id
     */
    private Long start;
    /**
     * 结束节点id
     */
    private Long end;
    /**
     * 关系类型
     */
    private String type;
    /**
     * id
     */
    private Long id;

    /**
     * 标签属性
     */
    private Map<String, Object> property;
}

VO

Neo4jBasicRelationReturnVO

package com.troy.keeper.modules.desk.vo.neo4j;

import com.troy.keeper.modules.desk.entity.neo4j.Neo4jBasicNode;
import com.troy.keeper.modules.desk.entity.neo4j.Neo4jQueryRelation;
import lombok.Data;

import java.io.Serializable;

/**
 * 基础返回关系VO
 * 关系
 * @author YangBM
 */
@Data
public class Neo4jBasicRelationReturnVO implements Serializable {
    private static final long serialVersionUID = 1L;

    private Neo4jBasicNode start;
    private Neo4jQueryRelation relationship;
    private Neo4jBasicNode end;
}

RelationVO

package com.troy.keeper.modules.desk.vo.neo4j;

import lombok.Data;

/**
 * 将关系的实体类,转换换成cypherSql需要字符串类型的vo
 * Util里面会用到
 * @author YangBM
 */
@Data
public class RelationVO {
    /**
     * 关系名称
     */
    private String relationLabelName;
    /**
     * 开始标签名称
     */
    private String startLabelName;

    /**
     * 开始节点条件
     */
    private String startNodeProperties;
    /**
     * 关系的属性
     */
    private String relationProperties;
    /**
     * 结束节点条件
     */
    private String endNodeProperties;
    /**
     * 结束标签名称
     */
    private String endLabelName;
    /**
     * 查询层级
     */
    private String level;
}

Util

Neo4jUtil

package com.troy.keeper.modules.desk.util;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.troy.keeper.core.tool.utils.BeanUtil;
import com.troy.keeper.core.tool.utils.Func;
import com.troy.keeper.modules.desk.dto.neo4j.Neo4jSaveRelationDTO;
import com.troy.keeper.modules.desk.dto.neo4j.RelationDTO;
import com.troy.keeper.modules.desk.entity.neo4j.Neo4jBaiscRelation;
import com.troy.keeper.modules.desk.entity.neo4j.Neo4jBasicNode;
import com.troy.keeper.modules.desk.entity.neo4j.Neo4jQueryRelation;
import com.troy.keeper.modules.desk.vo.neo4j.Neo4jBasicRelationReturnVO;
import com.troy.keeper.modules.desk.vo.neo4j.RelationVO;
import lombok.SneakyThrows;
import org.apache.commons.collections.IteratorUtils;
import org.apache.commons.lang3.StringUtils;
import org.neo4j.driver.internal.InternalPath;
import org.neo4j.driver.types.Node;
import org.neo4j.driver.types.Relationship;
import org.neo4j.ogm.model.Property;
import org.neo4j.ogm.model.Result;
import org.neo4j.ogm.response.model.NodeModel;
import org.neo4j.ogm.session.Session;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.*;

/**
 * @author YangBM
 * Neo4J工具类
 */
@Component
public class Neo4jUtil {

    /**
     * init map序列号
     */
    private static final ObjectMapper mapper = new ObjectMapper();

    static {
        mapper.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, false);
    }

    @SneakyThrows
    public static String propertiesMapToPropertiesStr(Map<String,Object> map) {
        map.entrySet().removeIf(entry -> Func.isEmpty(entry.getValue()));
        return mapper.writeValueAsString(map);
    }

    @Resource
    private Session session;

    public Session getSession() {
        return this.session;
    }

    /**
     * 获取所有的标签名称
     *
     * @return
     */
    public List<String> getAllLabelName() {
        String cypherSql = "match (n) return distinct labels(n) as name";
        Result query = session.query(cypherSql, new HashMap<>());
        ArrayList<String> labelNames = new ArrayList<>();
        for (Map<String, Object> map : query.queryResults()) {
            String[] names = (String[]) map.get("name");
            for (String name : names) {
                labelNames.add(name);
            }

        }
        return labelNames;
    }

    /**
     * 获取所有的关系名称
     *
     * @return
     */
    public List<String> getAllRelationName() {
        String cypherSql = "MATCH ()-[r]-() RETURN distinct type(r) as name";
        Result query = session.query(cypherSql, new HashMap<>());
        ArrayList<String> relationNames = new ArrayList<>();
        for (Map<String, Object> map : query.queryResults()) {
            relationNames.add(map.get("name").toString());
        }
        return relationNames;
    }

    /**
     * 按条件查询节点
     *
     * @param node
     * @return 返回节点集合
     */
    public List<Neo4jBasicNode> queryNode(Neo4jBasicNode node) {
        String cypherSql = "";
        if (Func.isNotEmpty(node.getId())) {
            cypherSql = String.format("MATCH (n) where id(n)=%s return n", node.getId());
        } else {
            String labels = "";
            if (Func.isNotEmpty(node.getLabels())) {
                labels = ":`" + String.join("`:`", node.getLabels()) + "`";
            }
            String property = "";
            if (Func.isNotEmpty(node.getProperty())) {
                property = Neo4jUtil.propertiesMapToPropertiesStr(node.getProperty());
            }
            cypherSql = String.format("match(n%s%s) return n", labels, property);
        }
        Result query = session.query(cypherSql, new HashMap<>());
        ArrayList<Neo4jBasicNode> nodeList = new ArrayList<>();
        Iterable<Map<String, Object>> maps = query.queryResults();
        for (Map<String, Object> map : maps) {
            NodeModel queryNode = (NodeModel) map.get("n");
            Neo4jBasicNode startNodeVo = new Neo4jBasicNode();
            startNodeVo.setId(queryNode.getId());
            startNodeVo.setLabels(Arrays.asList(queryNode.getLabels()));
            List<Property<String, Object>> propertyList = queryNode.getPropertyList();
            HashMap<String, Object> proMap = new HashMap<>();
            for (Property<String, Object> stringObjectProperty : propertyList) {
                if (proMap.containsKey(stringObjectProperty.getKey())) {
                    throw new RuntimeException("数据重复");
                }
                proMap.put(stringObjectProperty.getKey(), stringObjectProperty.getValue());
            }
            startNodeVo.setProperty(proMap);
            nodeList.add(startNodeVo);
        }
        session.clear();
        return nodeList;
    }

    /**
     * 创建节点
     *
     * @param node  节点
     * @param nodup 是否去重。 true去重 false不去重
     * @return
     */
    public boolean createNode(Neo4jBasicNode node, Boolean nodup) {
        String labels = "";

        if (Func.isNotEmpty(node.getLabels())) {
            labels = ":`" + String.join("`:`", node.getLabels()) + "`";
        }
        String property = "";
        if (Func.isNotEmpty(node.getProperty())) {
            property = Neo4jUtil.propertiesMapToPropertiesStr(node.getProperty());
        }
        String cypherSql = String.format("%s(%s%s)", nodup ? "MERGE" : "create", labels, property);
        Result query = session.query(cypherSql, new HashMap<>());
        session.clear();
        return query.queryStatistics().getNodesCreated() > 0;
    }

    /**
     * 创建节点(不去重)
     *
     * @param node 节点
     * @param
     * @return
     */
    public boolean createNode(Neo4jBasicNode node) {
        return this.createNode(node, false);
    }

    /**
     * 创建节点,(去重增强型)
     * 创建节点,如果节点存在,先把它删除,在重新创建
     * 这个方法的目的是因为 createNode方法所谓的去重,是指如果 ,已有节点A,需要创建的节点B,如果A的属性个数大于B的属性且属性对应的值一模一样,就会创建一个新的A。所以现在的方式是对B新增A中B缺少的属性
     * @param node
     * @return
     */
    public boolean recreateNode(Neo4jBasicNode node){
        List<String> saveLabels = node.getLabels();
        Map<String, Object> saveProperty = node.getProperty();
        Set<String> savePropertyKeySet = saveProperty.keySet();
        //查询用属性查询节点是不是存在。
        //存在比较标签的lable1是不是一样。不一样就这个查询到的节点(少了就新增标签,多了就删除标签)
        Neo4jBasicNode queryNode= BeanUtil.copy(node,Neo4jBasicNode.class);
        queryNode.setLabels(null);
        List<Neo4jBasicNode> queryNodeList = this.queryNode(queryNode);

        if (queryNodeList.isEmpty()){
            return createNode(node,true);
        }

        for (Neo4jBasicNode neo4jBasicNode : queryNodeList) {
            //处理标签
            List<String> queryLabels = neo4jBasicNode.getLabels();
            ArrayList<String> addLabels = new ArrayList<>();
            for (String saveLabel : saveLabels) {
                if (!queryLabels.contains(saveLabel)){
                    //新增标签
                    addLabels.add(saveLabel);
                }
            }
            String addLabelStr=addLabels.isEmpty()?"":("e:"+String.join(":",addLabels));

            //处理属性
            Map<String, Object> queryProperty = neo4jBasicNode.getProperty();
            Set<String> queryPropertyKeySet = queryProperty.keySet();

            HashMap<String, Object> addPropertyMap = new HashMap<>();
            for (String savePropertyKey: savePropertyKeySet) {
                if (!queryPropertyKeySet.contains(savePropertyKey)){
                    addPropertyMap.put(savePropertyKey,saveProperty.get(savePropertyKey));
                }
            }
            String addPropertyStr=addPropertyMap.isEmpty()?"":(",e+="+ Neo4jUtil.propertiesMapToPropertiesStr(addPropertyMap));
            if(StringUtils.isAllEmpty(addPropertyStr,addPropertyStr)){

                return true;
            }

            String addLabelCypherSql =String.format("MERGE (e) with e where id(e)=%s set %s %s return count(e) as count",neo4jBasicNode.getId(),addLabelStr,addPropertyStr);
            Result query = session.query(addLabelCypherSql, new HashMap<>());
            System.out.println("跟新了:"+neo4jBasicNode.getId());

            session.clear();
        }
        //创建不重复节点
        return true;
    };

    /**
     * 批量创建节点(存在的节点将会被重复创建)
     *
     * @param nodeList 节点的list集合
     * @return 创建成功条数
     *
     */
    public Long batchCreateNode(List<Neo4jBasicNode> nodeList) {
        return this.batchCreateNode(nodeList, false);
    }

    /**
     * 批量创建节点
     *
     * @param nodeList 节点的list集合
     * @param nodup    是否去重。 true去重(存在的节点将不会被创建) false不去重
     * @return 创建成功条数
     */
    public Long batchCreateNode(List<Neo4jBasicNode> nodeList, Boolean nodup) {

        ArrayList<Neo4jBasicNode> addNode = new ArrayList<>();
        //验证
        for (Neo4jBasicNode neo4jBasicNode : nodeList) {
            if ((!nodup) || this.queryNode(neo4jBasicNode).size() == 0) {
                addNode.add(neo4jBasicNode);
            }

        }
        String cypherSql = "create";
        ArrayList<String> content = new ArrayList<>();
        for (Neo4jBasicNode node : addNode) {
            String labels = "";
            if (Func.isNotEmpty(node.getLabels())) {
                labels = ":`" + String.join("`:`", node.getLabels()) + "`";
            }
            String property = "";
            if (Func.isNotEmpty(node.getProperty())) {
                property = Neo4jUtil.propertiesMapToPropertiesStr(node.getProperty());
            }
            content.add(String.format("(%s%s)", labels, property));
        }
        cypherSql += String.join(",", content);
        if (content.size() == 0) {
            return 0L;
        }
        Result query = session.query(cypherSql, new HashMap<>());
        session.clear();
        return Long.valueOf(query.queryStatistics().getNodesCreated());

    }

    /**
     * 删除节点和相关关系
     *
     * @param node        节点条件
     * @param delRelation true 删除节点相关的关系;false 只删除不存在关系的,存在关系的节点将不会被删除关系
     * @return
     */
    public Integer delNode(Neo4jBasicNode node, boolean delRelation) {
        String cypherSql = "";
        if (Func.isNotEmpty(node.getId())) {
            cypherSql = String.format("MATCH (n) where id(n)=%s ", node.getId());
        } else {
            String labels = "";
            if (Func.isNotEmpty(node.getLabels())) {
                labels = ":`" + String.join("`:`", node.getLabels()) + "`";
            }
            String property = "";
            if (Func.isNotEmpty(node.getProperty())) {
                property = Neo4jUtil.propertiesMapToPropertiesStr(node.getProperty());
            }
            cypherSql = String.format("match(n%s%s) ", labels, property);
        }
        if (delRelation) {
            cypherSql += "DETACH DELETE n";
        } else {
            //删除不存在关系的节点
            cypherSql += " where not exists((n)-[]-()) DELETE n";

        }
        Result query = session.query(cypherSql, new HashMap<>());
        session.clear();
        return query.queryStatistics().getNodesDeleted();
    }

    /**
     * 删除节点和相关关系
     * 只删除不存在关系的,存在关系的节点将不会被删除关系
     *
     * @param node 节点条件 有关系的节点不会删除
     * @return
     */
    public Integer delNode(Neo4jBasicNode node) {
        return this.delNode(node, false);
    }

    public int queryNodeCreateRelation(Neo4jBasicNode start, Neo4jBasicNode end, Neo4jBaiscRelation relation) {
        Neo4jSaveRelationDTO dto = new Neo4jSaveRelationDTO();
        dto.setStart(start);
        dto.setEnd(end);
        dto.setRelationship(relation);
        return queryNodeCreateRelation(dto);
    }

    /**
     * 查询节点然后创建关系
     * 创建关系(查询开始节点和结束节点然后创造关系)
     * 注意:开始节点和结束节点以及创建的关系参数一定要存在!
     * 关系如果存在,不会重复创建
     * 因为需要返回创建条数 当前方法未做条件判断
     *
     * @param saveRelation 关系构造类
     * @return 返回创建关系的个数
     */
    public int queryNodeCreateRelation(Neo4jSaveRelationDTO saveRelation) {
        //开始节点和结束节点验证

        String cypherSql = "";
        String startLable = "";
        if (Func.isNotEmpty(saveRelation.getStart().getLabels())) {
            startLable = ":`" + String.join("`:`", saveRelation.getStart().getLabels()) + "`";
        }
        String startProperty = "";
        if (Func.isNotEmpty(saveRelation.getStart().getProperty())) {
            startProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getStart().getProperty());
        }

        String endLable = "";
        if (Func.isNotEmpty(saveRelation.getEnd().getLabels())) {
            endLable = ":`" + String.join("`:`", saveRelation.getEnd().getLabels()) + "`";
        }
        String endProperty = "";
        if (Func.isNotEmpty(saveRelation.getEnd().getProperty())) {
            endProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getEnd().getProperty());
        }
        String startWhere = "";
        if (Func.isNotEmpty(saveRelation.getStart().getId())) {
            startWhere += " where id(start)=" + saveRelation.getStart().getId();
            startLable = "";
            startProperty = "";
        }
        String endWhere = "";
        if (Func.isNotEmpty(saveRelation.getEnd().getId())) {
            endWhere += " where id(end)=" + saveRelation.getEnd().getId();
            endLable = "";
            endProperty = "";
        }

        String relationType = "";
        if (Func.isNotEmpty(saveRelation.getRelationship().getType())) {

            relationType = ":`" + saveRelation.getRelationship().getType() + "`";
        }
        if (Func.isEmpty(relationType)) {
            throw new RuntimeException("关系名称不能为空!");
        }
        String relationProperty = "";
        if (Func.isNotEmpty(saveRelation.getRelationship().getProperty())) {
            relationProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getRelationship().getProperty());
        }
        cypherSql = String.format("MATCH (start%s%s) %s with start MATCH (end%s%s) %s MERGE (start)-[rep%s%s]->(end)", startLable, startProperty, startWhere, endLable, endProperty, endWhere, relationType, relationProperty);
        Result query = session.query(cypherSql, new HashMap<>());
        session.clear();
        return query.queryStatistics().getRelationshipsCreated();
    }

    /**
     * 创建节点同时创建关系
     * 重复的不会被创建
     *
     * @param saveRelation
     * @return
     */
    public boolean creteNodeAndRelation(Neo4jSaveRelationDTO saveRelation) {
        String cypherSql = "";
        String startLable = "";
        if (Func.isNotEmpty(saveRelation.getStart().getLabels())) {
            startLable = ":`" + String.join("`:`", saveRelation.getStart().getLabels()) + "`";
        }
        String startProperty = "";
        if (Func.isNotEmpty(saveRelation.getStart().getProperty())) {
            startProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getStart().getProperty());
        }

        String endLable = "";
        if (Func.isNotEmpty(saveRelation.getEnd().getLabels())) {
            endLable = ":`" + String.join("`:`", saveRelation.getEnd().getLabels()) + "`";
        }
        String endProperty = "";
        if (Func.isNotEmpty(saveRelation.getEnd().getProperty())) {
            endProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getEnd().getProperty());
        }

        String relationType = "";
        if (Func.isNotEmpty(saveRelation.getRelationship().getType())) {
            relationType = ":`" + saveRelation.getRelationship().getType() + "`";
        }
        if (Func.isEmpty(relationType)) {
            throw new RuntimeException("关系名称不能为空!");
        }
        String relationProperty = "";
        if (Func.isNotEmpty(saveRelation.getRelationship().getProperty())) {
            relationProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getRelationship().getProperty());
        }
        cypherSql = String.format("MERGE (start%s%s)-[rep%s%s]->(end%s%s)", startLable, startProperty, relationType, relationProperty, endLable, endProperty);
        Result query = session.query(cypherSql, new HashMap<>());
        session.clear();
        return query.queryStatistics().getRelationshipsCreated() > 0;

    }

    /**
     * 查询关系
     *
     * @param relationDTO
     * @return
     */
    public List<Neo4jBasicRelationReturnVO> queryRelation(RelationDTO relationDTO) {
        RelationVO relationVO = formatRelation(relationDTO);

        //拼接sql
        String cypherSql = String.format("MATCH p=(a%s%s)-[r%s%s]->(b%s%s)-[*0..%s]->() RETURN p", relationVO.getStartLabelName(), relationVO.getStartNodeProperties(), relationVO.getRelationLabelName(), relationVO.getRelationProperties(), relationVO.getEndLabelName(), relationVO.getEndNodeProperties(), relationVO.getLevel());
        System.out.println(cypherSql);
        long startTime = System.currentTimeMillis();
        Result query = session.query(cypherSql, new HashMap<>());
        System.out.println(String.format("耗时%d秒", System.currentTimeMillis() - startTime));

        Iterable<Map<String, Object>> maps = query.queryResults();
        ArrayList<Neo4jBasicRelationReturnVO> returnList = new ArrayList<>();
        for (Map<String, Object> map : maps) {
            InternalPath.SelfContainedSegment[] ps = (InternalPath.SelfContainedSegment[]) map.get("p");
            for (InternalPath.SelfContainedSegment p : ps) {
                returnList.add(changeToNeo4jBasicRelationReturnVO(p));
            }
        }
        session.clear();
        return returnList;
    }
    /**
     * 格式化
     *
     * @param relationDTO
     * @return
     */
    public RelationVO formatRelation(RelationDTO relationDTO) {
        RelationVO relationVO = new RelationVO();

        //验证

        if (Func.isNotEmpty(relationDTO.getRelationLabelName())) {
            relationVO.setRelationLabelName(":`" + relationDTO.getRelationLabelName()+"`");
        } else {
            relationVO.setRelationLabelName("");
        }
        if (Func.isNotEmpty(relationDTO.getStartLabelName())) {
            relationVO.setStartLabelName(":`" + relationDTO.getStartLabelName()+"`");
        } else {
            relationVO.setStartLabelName("");
        }
        if (Func.isNotEmpty(relationDTO.getEndLabelName())) {
            relationVO.setEndLabelName(":`" + relationDTO.getEndLabelName()+"`");
        } else {
            relationVO.setEndLabelName("");
        }
        if (Func.isNotEmpty(relationDTO.getStartNodeProperties())) {
            relationVO.setStartNodeProperties(Neo4jUtil.propertiesMapToPropertiesStr(relationDTO.getStartNodeProperties()));
        } else {
            relationVO.setStartNodeProperties("");
        }

        if (Func.isNotEmpty(relationDTO.getRelationProperties())) {
            relationVO.setRelationProperties(Neo4jUtil.propertiesMapToPropertiesStr(relationDTO.getRelationProperties()));
        } else {
            relationVO.setRelationProperties("");
        }

        if (Func.isNotEmpty(relationDTO.getEndNodeProperties())) {
            relationVO.setEndNodeProperties(Neo4jUtil.propertiesMapToPropertiesStr(relationDTO.getEndNodeProperties()));
        } else {
            relationVO.setEndNodeProperties("");
        }
        if (Func.isNotEmpty(relationDTO.getLevel())) {
            relationVO.setLevel(relationDTO.getLevel().toString());
        } else {
            relationVO.setLevel("");
        }

        return relationVO;
    }

    /**
     * 转化neo4j默认查询的参数为自定返回类型
     *
     * @param selfContainedSegment
     * @return Neo4jBasicRelationReturn
     */
    public Neo4jBasicRelationReturnVO changeToNeo4jBasicRelationReturnVO(InternalPath.SelfContainedSegment selfContainedSegment) {
        Neo4jBasicRelationReturnVO neo4JBasicRelationReturnVO = new Neo4jBasicRelationReturnVO();
        //start
        Node start = selfContainedSegment.start();
        Neo4jBasicNode startNodeVo = new Neo4jBasicNode();
        startNodeVo.setId(start.id());
        startNodeVo.setLabels(IteratorUtils.toList(start.labels().iterator()));
        startNodeVo.setProperty(start.asMap());
        neo4JBasicRelationReturnVO.setStart(startNodeVo);
        //end
        Node end = selfContainedSegment.end();
        Neo4jBasicNode endNodeVo = new Neo4jBasicNode();
        endNodeVo.setId(end.id());
        endNodeVo.setLabels(IteratorUtils.toList(end.labels().iterator()));
        endNodeVo.setProperty(end.asMap());
        neo4JBasicRelationReturnVO.setEnd(endNodeVo);
        //relationship
        Neo4jQueryRelation neo4JQueryRelation = new Neo4jQueryRelation();
        Relationship relationship = selfContainedSegment.relationship();
        neo4JQueryRelation.setStart(relationship.startNodeId());
        neo4JQueryRelation.setEnd(relationship.endNodeId());
        neo4JQueryRelation.setId(relationship.id());
        neo4JQueryRelation.setType(relationship.type());
        neo4JQueryRelation.setProperty(relationship.asMap());
        neo4JBasicRelationReturnVO.setRelationship(neo4JQueryRelation);
        return neo4JBasicRelationReturnVO;
    }

}

到此这篇关于SpringBoot结合Neo4j自定义cypherSql的文章就介绍到这了,更多相关SpringBoot自定义cypherSql内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

时间: 2021-11-24

springBoot 与neo4j的简单整合示例

Neo4j简介 Neo4j是基于java语言实现的世界领先的图形数据库, 是一个高性能的图形存储,具有成熟和强大的数据库所需的所有功能,如友好的查询语言(Cypher)和ACID事务.对于许多应用程序,与关系数据库相比,Neo4j提供了数量级的性能优势.主要应用于图检索和关系计算.其优点在于: 节点没上线(3.0以后去掉了限制) 扩展性很好,支持集群和企业版 数据ETL有丰富的工具支持,自带GUI 良好的WebUI 更加详细的介绍参考:https://neo4j.com/docs/getting

springboot与redis的简单整合实例

前言 Redis是一个缓存.消息代理和功能丰富的键值存储.StringBoot提供了基本的自动配置.本文记录一下springboot与redis的简单整合实例 官方文档:https://docs.spring.io/spring-boot/docs/2.1.0.RELEASE/reference/htmlsingle/ 前期准备 首先我们要有一个Redis服务,由于我没有Linux环境,为了方便搭建项目,直接在Windows下安装,参考这篇博客:Windows下安装Redis服务 安装步骤:一直

SpringMVC简单整合Angular2的示例

本文介绍了SpringMVC简单整合Angular2的示例,分享给大家,具体如下: angular使用的是官方的快速开始的例子 将文件全部拷贝到springmvc的项目中,拷贝过程中可能出现文件路径太长而失败,那就先对整个文件压缩,然后拷贝压缩过后的文件,然后解压缩即可.目录结构如下,我是拷贝到angular目录下的 spring配置文件设置路径 然后再html页面中如angular官方所示,引入文件 这里面需要对这些文件的路径进行配置 主要是systemjs.config文件中需要修改两个地方

SpringBoot+MybatisPlus+代码生成器整合示例

项目目录结构: pom文件: <?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.or

Springboot几种任务的整合方法

这篇文章主要介绍了Springboot几种任务的整合方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一 异步任务 启动类 @MapperScan("com.topcheer.*.*.dao") @SpringBootApplication @EnableCaching @EnableRabbit @EnableAsync public class Oss6Application { public static void main(

Springboot项目与vue项目整合打包的实现方式

我的环境 * JDK 1.8  * maven 3.6.0  * node环境 1.为什么需要前后端项目开发时分离,部署时合并? 在一些公司,部署实施人员的技术无法和互联网公司的运维团队相比,由于各种不定的环境也无法做到自动构建,容器化部署等.因此在这种情况下尽量减少部署时的服务软件需求,打出的包数量也尽量少.针对这种情况这里采用的在开发中做到前后端独立开发,打包时在后端springboot打包发布时将前端的构建输出一起打入,最后只需部署springboot的项目即可,无需再安装nginx服务器

SpringBoot获取配置文件的简单实现方法

前言 在讲SpringBoot 获取配置文件之前我们需要对SpringBoot 的项目有一个整体的了解,如何创建SpringBoot 项目,项目结构等等知识点,我在这里就不一一讲述了,没有学过的小伙伴可以自己在网上找一些资料进行学习,很简单的. 下面让我们开始今天的内容讲解吧. 一.SpringBoot 全局配置文件的加载顺序 在SpringBoot 当中,全局配置文件有两种不同的格式,一个是我们常见的properties, 一种是yml. 这两种格式的文件其实也没什么太大的区别,使用的时候按照

JSP实现的简单分页示例

本文实例讲述了JSP实现的简单分页示例.分享给大家供大家参考,具体如下: <%@ page language="java" import="java.util.*" contentType="text/html; charset=gbk"%> <%@ page import="com.yx.page.db.*"%> <%@ page import="java.sql.*" %&

jQuery简单入门示例之用户校验demo示例

本文实例讲述了jQuery简单入门示例之用户校验.分享给大家供大家参考,具体如下: jQuery在小编的世界中,也就是JavaScript和查询(Query),即是辅助JavaScript开发的库,百度百科对JQuery的介绍比较详细,小伙伴可以东东自己可耐的小爪子,上网进行搜索,说不定,有意外惊喜哦,今天这篇文章,小编简单的介绍一下JQuery的一些基本知识,然后小编在集合实例,讲解一下在具体的应用过程中,我们的JQuery又是如何在她的舞台熠熠生辉...... 通过JQuery的学习,我们可

js数字滑动时钟的简单实现(示例讲解)

废话不多说,直接上代码 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Document</title> <style type="text/css"> body,ul{margin:0;padding: 0;} .content{margin:100px auto;wid