springboot neo4j

时间:2022-05-23 哦豁完蛋人气:0

neo4j是一个图形数据库，有一个做关系图谱的需求里面需要使用到图形数据库。

w3c教程：https://www.w3cschool.cn/neo4j/

中文版的数据库可以通过image属性显示图片，官网的动画效果是通过3D.js实现的；

pom导入配置

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-neo4j</artifactId>
        </dependency>
 <dependency>
            <groupId>org.neo4j</groupId>
            <artifactId>neo4j-ogm-http-driver</artifactId>
            <version>3.1.4</version>
        </dependency>

配置数据库：

#neo4j
spring.data.neo4j.username=neo4j
spring.data.neo4j.password=123
spring.data.neo4j.uri=http://192.168.100.106:7474
package com.koala.console.configuration;

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;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableNeo4jRepositories(basePackages = "com.koala.console.repository.neo4j")
@EnableTransactionManagement
public class Neo4jConfig {

    @Value("${blotUri}")
    private String uri;

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

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

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

    @Bean
    public SessionFactory sessionFactory() {
        org.neo4j.ogm.config.Configuration configuration = new org.neo4j.ogm.config.Configuration.Builder()
                .uri(databaseUrl)
                .credentials(userName, password)
                .build();
        return new SessionFactory(configuration, "com.koala.console.model.neo4j");
    }

    @Bean
    public Neo4jTransactionManager transactionManager() {
        return new Neo4jTransactionManager(sessionFactory());
    }


}

使用neo4j：

neo4j基本由两部分组成，节点和关系，关系用来指示两个节点的方向和关联属性：

节点bean：

package com.koala.console.model.neo4j;

import com.alibaba.fastjson.annotation.JSONField;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.google.common.collect.Lists;
import lombok.Data;
import org.neo4j.ogm.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@Data
@NodeEntity
public class FaceNode {

    public FaceNode() {
    }

    public FaceNode(String name) {
        this.objId = name;
    }

    @Id
    @GeneratedValue
    private Long id;

    /**
     * objId
     */
    private String objId;


    @JSONField(serialize = false)
    @JsonIgnore
    @Transient
    private String startName;
    @JSONField(serialize = false)
    @JsonIgnore
    @Transient
    private String endName;

    @Transient
    private Integer pathNum;

    @Transient
    private String intimacy;

    @Property(name = "scenes")
    private String scenes;

    @Property(name = "image")
    private String symbol;

    @Transient
    private Integer[] symbolSize = {60,60};

    @JSONField(serialize = false)
    @Transient
    private MultipartFile faceImg;
    @JSONField(serialize = false)
    @Transient
    private String startTime;

    @JSONField(serialize = false)
    @Transient
    private String endTime;



    @Relationship(type = "relation")
    private List<FaceNodePro> faceNodePros = Lists.newArrayList();

    private List<FaceNode>  children = Lists.newArrayList();

    public void addEndNode(FaceNode endNode, String title) {
        FaceNodePro pro = new FaceNodePro(title, this, endNode);
        this.faceNodePros.add(pro);
    }

    public void addStartNode(FaceNode startNode, String title) {
        FaceNodePro pro = new FaceNodePro(title, startNode, this);
        this.faceNodePros.add(pro);
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getObjId() {
        return objId;
    }

    public void setObjId(String objId) {
        this.objId = objId;
    }

    public String getSymbol() {
        return symbol;
    }

    public void setSymbol(String symbol) {
        this.symbol = symbol;
    }

    public List<FaceNodePro> getFaceNodePros() {
        return faceNodePros;
    }

    public void setFaceNodePros(List<FaceNodePro> faceNodePros) {
        this.faceNodePros = faceNodePros;
    }

    public String getStartName() {
        return startName;
    }

    public void setStartName(String startName) {
        this.startName = startName;
    }

    public String getEndName() {
        return endName;
    }

    public void setEndName(String endName) {
        this.endName = endName;
    }

    public MultipartFile getFaceImg() {
        return faceImg;
    }

    public void setFaceImg(MultipartFile faceImg) {
        this.faceImg = faceImg;
    }

    public String getStartTime() {
        return startTime;
    }

    public void setStartTime(String startTime) {
        this.startTime = startTime;
    }

    public String getEndTime() {
        return endTime;
    }

    public void setEndTime(String endTime) {
        this.endTime = endTime;
    }

    public String getScenes() {
        return scenes;
    }

    public void setScenes(String scenes) {
        this.scenes = scenes;
    }
}

关系bean：

package com.koala.console.model.neo4j;

import com.fasterxml.jackson.annotation.JsonBackReference;
import org.neo4j.ogm.annotation.*;

@RelationshipEntity(type = "relation")
public class FaceNodePro {

    public FaceNodePro() {
    }

    public FaceNodePro(String intimacy, FaceNode startNode, FaceNode endNode) {
        this.intimacy = intimacy;
        this.startNode = startNode;
        this.endNode = endNode;
    }

    @Id
    @GeneratedValue
    private Long nodeProId;

    /**
     * 亲密度
     */
    @Property
    private String intimacy;

    @JsonBackReference
    @StartNode
    private FaceNode startNode;

    @EndNode
    private FaceNode endNode;

    public Long getNodeProId() {
        return nodeProId;
    }

    public void setNodeProId(Long nodeProId) {
        this.nodeProId = nodeProId;
    }

    public String getIntimacy() {
        return intimacy;
    }

    public void setIntimacy(String intimacy) {
        this.intimacy = intimacy;
    }

    public FaceNode getStartNode() {
        return startNode;
    }

    public void setStartNode(FaceNode startNode) {
        this.startNode = startNode;
    }

    public FaceNode getEndNode() {
        return endNode;
    }

    public void setEndNode(FaceNode endNode) {
        this.endNode = endNode;
    }
}

Repository实现：

@Repository
public interface FaceNodeRepository extends Neo4jRepository<FaceNode, Long> {

    FaceNode findByObjId(@Param("objId") String objId);

    /**
     * 查询节点Node指定层级的图
     *
     * @param
     * @return
     */
    @Query(value = "MATCH n=(:FaceNode{objId:{objId}})-[*..6]->() RETURN n")
    List<FaceNode> findByHierarchical(@Param("objId") String objId);

}

剩下的使用都是很简单的事情。

我收集了一些会使用到的语句：

查询节点Node所有的关系
match(Node{name:'5c26219bd3e2dca5322110bb'})-[:PLAYED_IN]->(yf)return Node,yf
查询节点Node的2层关系图
MATCH n=(:Node{name:"5c262177d3e2dca5322110b3"})-[*..1]-() return n
两个陌生人之间的所有最短认识路径
MATCH n = allshortestPaths((小讯:朋友圈{姓名:"小讯"})-[*..6]-(小菲:朋友圈{姓名:"小菲"})) return n
查询节点Node指向的所有节点
MATCH (:Node { name: '5c262137d3e2dca5322110a7' })-->(movie)RETURN movie;
查询标签Node所有节点
match(n)--(m:Node)return n;
批量创建Node节点的朋友圈
MATCH (Node:Node {name:"4j2ap"})FOREACH (name in ["Johan","Rajesh","Anna","Julia","Andrew"] |CREATE (Node)-[:FRIEND]->(:Person {name:name}))
查询两个节点有向关系条数
match (:FaceNode{name:"gong"})-[r:PLAYED_IN]->(:FaceNode{name:"eza2e"})return count(r)

参考：

转载自：https://www.cxymm.net/article/sinat_21184471/87092034
版权声明：本文为博主原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/sinat_21184471/article/details/87092034

加载全部内容