Neo4j使用例子

最新推荐文章于 2024-11-12 16:01:12 发布
最新推荐文章于 2024-11-12 16:01:12 发布
阅读量117 收藏
点赞数
分类专栏： java 文章标签： neo4j

准备开发一个任务调度系统，其中使用Neo4j来保存和查询任务之间的依赖关系，

整理了一个服务类，记录一下。

使用的Neo4j版本为：2.1.3

 

服务类：

 

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.log4j.Logger;
import org.neo4j.graphdb.Direction;
import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.Node;
import org.neo4j.graphdb.Path;
import org.neo4j.graphdb.Relationship;
import org.neo4j.graphdb.RelationshipType;
import org.neo4j.graphdb.Transaction;
import org.neo4j.graphdb.factory.GraphDatabaseFactory;
import org.neo4j.graphdb.index.Index;
import org.neo4j.graphdb.traversal.Evaluators;
import org.neo4j.graphdb.traversal.PathEvaluator;
import org.neo4j.graphdb.traversal.TraversalDescription;
import org.neo4j.graphdb.traversal.Traverser;
import org.neo4j.kernel.impl.util.FileUtils;

/**
 * Neo4j服务类
 * @author lxw
 *
 */
public class Neo4jService implements Runnable {
	
	private static Logger log = Logger.getLogger(Neo4jService.class);
	
	private final String DB_PATH = "neo4jdb/skynet-neo4j.db";
	
	private GraphDatabaseService db;
	private Index<Node> index = null;
	
	public static final String INDEX_ID_KEY = "idx_id";
	public static final String JOB_ID_KEY = "job_id";
	
	private boolean running = true;
	
	

	private enum RelTypes implements RelationshipType{
        KNOWS,
    }
	
	public Neo4jService() {	
		init();
	}
	
	public void init() {
		clearDB();
		db = new GraphDatabaseFactory().newEmbeddedDatabase(DB_PATH);
		registerShutdownHook();
		Transaction tx = db.beginTx();
		try {
			this.index = db.index().forNodes("jobNodes");
			tx.success();
		} catch (Exception e) {
			log.error(e);
			log.error("init() error.."); 
		} finally {
			tx.close();
		}
	}
	
	//添加节点
	public boolean addNode(int job_id) {
		Transaction tx = db.beginTx();
		try {
			Node jobNode = db.createNode();
			jobNode.setProperty(JOB_ID_KEY, job_id);
			this.index.add(jobNode, INDEX_ID_KEY, job_id);
			tx.success();
			log.info("addNode: [" + job_id + "].");
		} catch (Exception e) {
			log.error(e);
			log.error("addNode() error ..");
			return false;
		} finally {
			tx.close();
		}
		return true;
	}
	
	/**
	 * 删除节点依赖
	 * @param parent_job_id
	 * @param son_job_id
	 * @return
	 */
	public boolean deleteNodeRelationShip(int parent_job_id,int son_job_id) {
		Transaction tx = db.beginTx();
		try {
			Node parentJobNode = getNodeByJob(parent_job_id);
			Node sonJobNode = getNodeByJob(son_job_id);
			Iterable<Relationship> relationships = parentJobNode.getRelationships(RelTypes.KNOWS, Direction.OUTGOING);
			for(Relationship r : relationships) {
				if(r.getEndNode().equals(sonJobNode)) {
					r.delete();
				}
			}
			tx.success();
			log.info("deleteNodeRelationShip: [" + parent_job_id + "," + son_job_id + "].");
		} catch (Exception e) {
			log.error(e);
			log.error("deleteNodeRelationShip() error .. paren_job_id is [" + parent_job_id 
					+ "], son_job_id is [" + son_job_id + "]."); 
		} finally {
			tx.close();
		}
		return false;
	}
	
	//删除节点
	public boolean deleteNode(int job_id) {		
		Transaction tx = db.beginTx();
		try {
			Node jobNode = getNodeByJob(job_id);
			jobNode.delete();
			tx.success();
			log.info("deleteNode: [" + job_id + "].");
		} catch (Exception e) {
			log.error(e);
			log.error("deleteNode() error ..");
			return false;
		} finally {
			tx.close();
		}
		return true;
	}
	
	//添加节点依赖
	public boolean addNodeRelationShip(int parent_job_id,int son_job_id) {
		Transaction tx = db.beginTx();
		try {
			Node parentJobNode = getNodeByJob(parent_job_id);
			Node sonJobNode = getNodeByJob(son_job_id);
			parentJobNode.createRelationshipTo(sonJobNode, RelTypes.KNOWS);
			tx.success();
			log.info("addNodeRelationShip: [" + parent_job_id + "," + son_job_id + "].");
		} catch (Exception e) {
			log.error(e);
			log.error("addNodeRelationShip() error .. paren_job_id is [" + parent_job_id 
					+ "], son_job_id is [" + son_job_id + "]."); 
		} finally {
			tx.close();
		}
		return false;
	}
	
	//获取节点的子任务，包括自身
	public List<Integer> getJobSons (int job_id,int depth) {
		List<Integer> jobSons = new ArrayList<Integer>();
		PathEvaluator<?> path = null;
		if(depth == 0 || depth == -1) {
			path = Evaluators.excludeStartPosition();
		} else {
			path = Evaluators.toDepth(depth);
		}
		Node jobNode = getNodeByJob(job_id);
		
		if(null != jobNode) {
			Transaction tx = db.beginTx();
			try {
				TraversalDescription td = db.traversalDescription()
		                .breadthFirst()
		                .relationships( RelTypes.KNOWS, Direction.OUTGOING )
		                .evaluator(path);
				Traverser t = td.traverse(jobNode);
				
				for(Path p : t) {
					log.info("level:" + p.length());
					log.info("id:" + p.endNode().getProperty(JOB_ID_KEY));
					jobSons.add((Integer) p.endNode().getProperty(JOB_ID_KEY));
				}
				tx.success();
			} catch (Exception e) {
				log.error(e);
				log.error("getJobSons error .. job_id is [" + job_id + "]");
			} finally {
				tx.close();
			}
		}
		return jobSons;
	}
	
	
	//获取节点的父任务，包括自身
	public List<Integer> getJobParents (int job_id,int depth) {
		List<Integer> jobParents = new ArrayList<Integer>();
		PathEvaluator<?> path = null;
		if(depth == 0 || depth == -1) {
			path = Evaluators.excludeStartPosition();
		} else {
			path = Evaluators.toDepth(depth);
		}
		Node jobNode = getNodeByJob(job_id);
		
		if(null != jobNode) {
			Transaction tx = db.beginTx();
			try {
				TraversalDescription td = db.traversalDescription()
		                .breadthFirst()
		                .relationships( RelTypes.KNOWS, Direction.INCOMING )
		                .evaluator(path);
				Traverser t = td.traverse(jobNode);
				
				for(Path p : t) {
					log.info("level:" + p.length());
					log.info("id:" + p.endNode().getProperty(JOB_ID_KEY));
					jobParents.add((Integer) p.endNode().getProperty(JOB_ID_KEY));
				}
				tx.success();
			} catch (Exception e) {
				log.error(e);
				log.error("getJobParents error .. job_id is [" + job_id + "]");
			} finally {
				tx.close();
			}
		}
		return jobParents;
	}
	
	
	//获取节点的一级父任务,不包括自身
	public List<Integer> getJobFirstParents (int job_id) {
		List<Integer> jobParents = new ArrayList<Integer>();
		PathEvaluator<?> path = Evaluators.atDepth(1);
		Node jobNode = getNodeByJob(job_id);
		
		if(null != jobNode) {
			Transaction tx = db.beginTx();
			try {
				TraversalDescription td = db.traversalDescription()
		                .breadthFirst()
		                .relationships( RelTypes.KNOWS, Direction.INCOMING )
		                .evaluator(path);
				Traverser t = td.traverse(jobNode);
				
				for(Path p : t) {
					log.info("level:" + p.length());
					log.info("id:" + p.endNode().getProperty(JOB_ID_KEY));
					jobParents.add((Integer) p.endNode().getProperty(JOB_ID_KEY));
				}
				tx.success();
			} catch (Exception e) {
				log.error(e);
				log.error("getJobFirstParents error .. job_id is [" + job_id + "]");
			} finally {
				tx.close();
			}
		}
		return jobParents;
	}
	
	//获取节点的一级子任务，不包括自身
	public List<Integer> getJobFirstSons (int job_id) {
		List<Integer> jobSons = new ArrayList<Integer>();
		PathEvaluator<?> path = Evaluators.atDepth(1);
		Node jobNode = getNodeByJob(job_id);
		
		if(null != jobNode) {
			Transaction tx = db.beginTx();
			try {
				TraversalDescription td = db.traversalDescription()
		                .breadthFirst()
		                .relationships( RelTypes.KNOWS, Direction.OUTGOING )
		                .evaluator(path);
				Traverser t = td.traverse(jobNode);
				
				for(Path p : t) {
					log.info("level:" + p.length());
					log.info("id:" + p.endNode().getProperty(JOB_ID_KEY));
					jobSons.add((Integer) p.endNode().getProperty(JOB_ID_KEY));
				}
				tx.success();
			} catch (Exception e) {
				log.error(e);
				log.error("getJobFirstParents error .. job_id is [" + job_id + "]");
			} finally {
				tx.close();
			}
		}
		return jobSons;
	}
	
	//根据job_id获取Node
	public Node getNodeByJob(int job_id) {
		Node node = null;
		Transaction tx = db.beginTx();
		try {
			node = this.index.get(INDEX_ID_KEY,job_id).getSingle();
			tx.success();
		} catch (Exception e) {
			log.error(e);
			log.error("getNodeByJob() error, job_id is [" + job_id + "].");
		} finally {
			tx.close();
		}
		return node;
	}
	
	private void registerShutdownHook() {
        // Registers a shutdown hook for the Neo4j instance so that it
        // shuts down nicely when the VM exits (even if you "Ctrl-C" the
        // running example before it's completed)
        Runtime.getRuntime()
                .addShutdownHook( new Thread()
                {
                    @Override
                    public void run()
                    {
                    	log.info("neo4j shutdown hook ... ");
                        db.shutdown();
                    }
                } );
    }
	
	private void clearDB() {  
        try {  
            FileUtils.deleteRecursively(new File(DB_PATH));  
        }  
        catch(IOException e) {  
            throw new RuntimeException(e);  
        }  
    }

	@Override
	public void run() {
		while (running) {
			log.info(new Date() + " ### Neo4jService 运行正常！");
			try {
				Thread.sleep(20000);
			} catch (InterruptedException e) {
				log.error(e);
			}
		}
	}  
	
	public void setRunning(boolean running) {
		this.running = running;
	}
	
	
}

 

 

测试类：

 

import java.util.List;


public class TestNeo4j {
	public static void main(String[] args) {
		Neo4jService nj = new Neo4jService();
		Thread t = new Thread(nj,"Neo4jThread");
		t.start();
		nj.addNode(0);
		nj.addNode(1);
		nj.addNode(2);
		nj.addNode(3);
		nj.addNode(4);
		nj.addNode(5);
		nj.addNode(6);
		nj.addNode(7);
		nj.addNode(8);
		nj.addNode(9);
		nj.addNode(10);
		
		
		nj.addNodeRelationShip(0,1);
		nj.addNodeRelationShip(0,2);
		nj.addNodeRelationShip(0,3);
		nj.addNodeRelationShip(1,4);
		nj.addNodeRelationShip(1,5);
		nj.addNodeRelationShip(1,6);
		
		nj.addNodeRelationShip(2,7);
		nj.addNodeRelationShip(2,9);
		
		nj.addNodeRelationShip(3,8);
		nj.addNodeRelationShip(3,10);
		
		nj.addNodeRelationShip(8,9);
		nj.addNodeRelationShip(10,9);
		
		List<Integer> sons = nj.getJobFirstParents(9);
		for(Integer i : sons) {
			System.out.println(i);
		}
		
		nj.deleteNodeRelationShip(2, 9);
		
		sons = nj.getJobFirstParents(9);
		System.out.println("after delete 2--9");
		for(Integer i : sons) {
			System.out.println(i);
		}
		
		nj.setRunning(false);
		
		
	}
}

 

任务的依赖关系如图：



 

 

测试输出：

 

14/09/11 15:39:03 INFO neo4j.Neo4jService: Thu Sep 11 15:39:03 CST 2014 ### Neo4jService 运行正常！
14/09/11 15:39:03 INFO neo4j.Neo4jService: addNode: [0].
14/09/11 15:39:03 INFO neo4j.Neo4jService: addNode: [1].
14/09/11 15:39:03 INFO neo4j.Neo4jService: addNode: [2].
14/09/11 15:39:03 INFO neo4j.Neo4jService: addNode: [3].
14/09/11 15:39:03 INFO neo4j.Neo4jService: addNode: [4].
14/09/11 15:39:03 INFO neo4j.Neo4jService: addNode: [5].
14/09/11 15:39:03 INFO neo4j.Neo4jService: addNode: [6].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNode: [7].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNode: [8].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNode: [9].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNode: [10].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [0,1].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [0,2].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [0,3].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [1,4].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [1,5].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [1,6].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [2,7].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [2,9].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [3,8].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [3,10].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [8,9].
14/09/11 15:39:04 INFO neo4j.Neo4jService: addNodeRelationShip: [10,9].
14/09/11 15:39:04 INFO neo4j.Neo4jService: level:1
14/09/11 15:39:04 INFO neo4j.Neo4jService: id:2
14/09/11 15:39:04 INFO neo4j.Neo4jService: level:1
14/09/11 15:39:04 INFO neo4j.Neo4jService: id:8
14/09/11 15:39:04 INFO neo4j.Neo4jService: level:1
14/09/11 15:39:04 INFO neo4j.Neo4jService: id:10
2
8
10
14/09/11 15:39:04 INFO neo4j.Neo4jService: deleteNodeRelationShip: [2,9].
14/09/11 15:39:04 INFO neo4j.Neo4jService: level:1
14/09/11 15:39:04 INFO neo4j.Neo4jService: id:10
14/09/11 15:39:04 INFO neo4j.Neo4jService: level:1
14/09/11 15:39:04 INFO neo4j.Neo4jService: id:8
after delete 2--9
10
8
14/09/11 15:39:23 INFO neo4j.Neo4jService: neo4j shutdown hook ...

 

liuxw0035
关注
专栏目录
Spark学习：ShutdownHookManager虚拟机关闭钩子管理器
weixin_30782331的博客
01-23 1557
　　Java程序经常也会遇到进程挂掉的情况，一些状态没有正确的保存下来，这时候就需要在JVM关掉的时候执行一些清理现场的代码。 　　JAVA中的ShutdownHook提供了比较好的方案。 　　JDK提供了Java.Runtime.addShutdownHook(Thread hook)方法，可以注册一个JVM关闭的钩子，这个钩子可以在一下几种场景中被调用： １.　程序正常退出 ２.　使用S...
Neo4j java api
top_wind_cloud的专栏
01-13 705
Neo4j Maven导入 &lt;dependency&gt; &lt;groupId&gt;org.neo4j&lt;/groupId&gt; &lt;artifactId&gt;neo4j&lt;/artifactId&gt; &lt;version&gt;3.5.0&lt;/version&gt; &lt;/dependency&gt; 使用嵌入数
Neo4j embedded例子
AHAU10的专栏
01-13 2241
直接从本地导入数据，相当于直接写文件了，速度非常快。 使用neo4j 3.1.0社区版 1.neo4j-community-3.1.0-unix.tar.gz 解压后修改相关配置# Bolt connector dbms.connector.bolt.enabled=true dbms.connector.bolt.tls_level=OPTIONAL dbms.connector.bolt.l
JS定时调用模型
剑胆琴心-.Net 学习笔记
09-17 642
 function  timerFunctionName( parameter ){         var  i = 0;         var max = 500;       //1、声明定时器函数或方法      var timerFunction = function(){             i += 10;             if( i >= max
neo4j 入门例子
hepei120的专栏
01-23 3185
下面的例子来自neo4j 自带samples，主要围绕【电影–演员–导演】展开的 执行完的效果是 CREATE (TheMatrix:Movie {title:'The Matrix', released:1999, tagline:'Welcome to the Real World'}) //创建一个节点:TheMatrix&amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;黑客帝国&amp;amp;amp;amp;amp;amp;amp;amp;amp;g
Neo4j中文使用手册以及例子
12-02
**Neo4j中文使用手册及例子** Neo4j是一款强大的图形数据库系统，它以其高效、灵活和直观的数据模型——图数据模型，深受开发者喜爱。在处理复杂的关系数据时，如社交网络、推荐系统、知识图谱等场景，Neo4j表现...
Neo4j中文使用手册以及例子.7z
08-01
"Neo4j中文使用手册以及例子.7z"这个压缩包显然包含了关于如何使用Neo4j的详细指导和实例，这对于开发者来说是一份非常宝贵的资源。 1. **图形数据库基础**：首先，了解图形数据库的基本概念是必要的。与传统的关系...
neo4j mybatis的例子
09-24
在这个例子中，我们将探讨如何在Java应用中使用MyBatis与Neo4j进行集成。 首先，我们需要下载必要的jar包。MyBatis本身以及 Neo4j JDBC 驱动是实现这个集成的关键组件。通过Maven，我们可以方便地把这些依赖添加到...
Java_使用Spring Data为JPA MongoDB Neo4j Redis的例子.zip
05-22
在Java开发中，Spring Data是一个强大的框架，它简化了数据访问层的实现，支持多种数据库技术，如JPA（Java Persistence API）、MongoDB、Neo4j和Redis。本压缩包包含的是一个使用Spring Data与这些数据库系统交互的...
neo4j 实战、实例、查询示例
sinstar1的博客
08-28 4996
检索节点 1. 查找名为 Tom Hanks 的人物 match (tom {name :"Tom Hanks"}) return tom 或者如下 match (tom2 {name :"Tom Hanks"}) return tom2 tom换成tom2，请自行酝酿他们的区别 tom或tom2是类似于mysql的别名 2. 随机查找10个人物的人名 match (...
neo4j 试用笔记
cmzx344的专栏
05-26 208
Neo4j是一种图数据库，他是可嵌入的，拥有完全的jpa引擎，他的数据以图结构存储在硬盘中，而不是表的形式。Neo4j属于NoSQL数据库中很独特的一种，它由节点nodes 节点关系和节点与关系中的属性property组成。 节点node：就像是一个对象实例，有唯一的ID 节点关系：是两个节点的连接，也就是边 属性property：是字符串类型的key/Object值对，Node与Relat...
DataWorks 如何设置调度依赖
weixin_34244102的博客
10-23 3214
DataWorks 新版本在配置任务依赖的时候，是根据本节点输出名称作为关联项来给任务间设置依赖关系的，那我们应该如何配置任务的输入输出呢。 如何配置任务的本节点输入 本节点输入有两种配法，一种是使用代码自动解析功能，解析出任务的依赖；另一种是手动输入任务依赖（手动输入父节点的本节点输出名称）。敲黑板：手动输入上游节点时，输入的是父节点本节点输出名称，如...
neo4j java_使用java操作Neo4j数据库
weixin_29040367的博客
02-19 819
1.引言这里的Java操作Neo数据库使用的是嵌入式模式，Neo4j可分为嵌入式模式和服务端模式，两者的区别可以查看方案(https://blog.csdn.net/regan_hoo/article/details/78771888)也可以查看《Neo4j实战 》这本书的第10章，上面有详细讲解(需要电子版的可以找我)。我们构造一个案件的场景。比如一个案件中有多个嫌疑人，有的嫌疑人参与了多个案件...
【AI日记】24.11.08 Knowledge Graphs for RAG （知识图谱，Neo4j，Cypher）
虾米记的博客
11-08 372
学习 Neo4j 图数据库和 Cypher 查询语言，学习如何构建知识图谱，学习知识图谱如何用于增强 RAG
Py2Neo 库将 Json 文件导入 Neo4J
最新发布
sagima_sdu的博客
11-12 212
在Python中，利用Py2Neo库可以将JSON数据导入Neo4j图数据库，从而构建知识图谱。Py2Neo是一个Python库，用于与Neo4j图数据库交互。以下是如何使用Py2Neo。
计算机毕业设计Python+Neo4j中华古诗词可视化 古诗词智能问答系统 古诗词数据分析 古诗词情感分析 PyTorch Tensorflow LSTM
全网粉丝10W+、全栈领域优质创作者、掘金、阿里云等社区博客专家、专注于全栈领域和毕业项目实战
11-09 955
计算机毕业设计Python+Neo4j中华古诗词可视化 古诗词智能问答系统 古诗词数据分析 古诗词情感分析 PyTorch Tensorflow LSTM
知识图谱，语义分析，全文检索，neo4j，elaticsearch，知识库平台（java，vue）
2301_79994950的博客
11-11 352
一款全源码，可二开，可基于云部署、私有部署的企业级知识库云平台，一款让企业知识变为实打实的数字财富的系统，应用在需要进行文档整理、分类、归集、检索、分析的场景。后端技术栈：springboot，activiti（工作流引擎），ElasticSearch，redis，neo4j（知识图谱）助力企业知识资产有效沉淀和利用，避免随文档负责人变动而重复制作，无纸化数字管理更加科学与绿色，为企业健康发展赋能。文章拟写，提交，审阅，发布，全过程审核机制。
PYTHON构建neo4j简单例子
04-17
好的，我可以回答你关于Python构建neo4j的问题。首先，你需要安装Python和neo4j的驱动程序。然后，你可以使用Python的`py2neo`库来连接并操作neo4j数据库。以下是一个Python构建neo4j的简单例子： ```python from py2neo import Graph, Node, Relationship # 连接neo4j数据库 graph = Graph("bolt://localhost:7687", auth=("username", "password")) # 创建节点 person = Node("Person", name="John") language = Node("Language", name="Python") # 创建关系 knows = Relationship(person, "KNOWS", language) # 保存到数据库 graph.create(person) graph.create(language) graph.create(knows) ``` 以上代码将创建一个名为`Person`的节点和一个名为`Language`的节点，并创建一个`KNOWS`的关系将它们连接起来。注意，这只是一个简单的例子，你可以根据自己的需求进行操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值