springboot2.0 --neo4j

- 日理万妓 2022-03-20 10:46 208阅读 0赞

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

w3c教程：[https://www.w3cschool.cn/neo4j/][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.w3cschool.cn_neo4j]: https://www.w3cschool.cn/neo4j/