Neo4j与 java项目集成 采用 JAVA Driver连接（java驱动包）实现对数据操作

嵌入式开发模式，要求必须在关闭Neo4j的情况下操作，切必须在Neo4j所在的电脑本地才能运行嵌入式开发程序。嵌入式模式下，neo4j 是不能启动的，所以不能访问neo4j的图形界面。一般应用 使用 java driver 就可以， 嵌入式开发一般是用于对图数据进行底层操作、创建自定义组件。

import java.io.File

import java.io.IOException

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.factory.GraphDatabaseFactory

import org.neo4j.graphdb.Transaction

import org.neo4j.graphdb.index.Index

import org.neo4j.graphdb.traversal.Evaluators

import org.neo4j.graphdb.traversal.Traverser

import org.neo4j.graphdb.traversal.TraversalDescription

import org.neo4j.kernel.Traversal

import org.neo4j.kernel.impl.util.FileUtils

import org.neo4j.kernel.impl.util.StringLogger

import org.neo4j.cypher.ExecutionEngine

import org.neo4j.cypher.ExecutionResult

import org.neo4j.graphalgo.PathFinder

import org.neo4j.graphalgo.GraphAlgoFactory

public class Example {

// private static final String DB_PATH = "target/neo4jexample"

private static final String DB_PATH = "testgraph.db"

private static final String PRIMARY_KEY = "name"

private GraphDatabaseService graphDB

private Index<Node>nodeIndex

private long startNodeId

private static enum RelTypes implements RelationshipType {

NEO_NODE,

KNOWS,

CODED_BY

}

private void clearDB() {

try {

FileUtils.deleteRecursively(new File(DB_PATH))

}

catch(IOException e) {

throw new RuntimeException(e)

}

}

public void createDB() {

clearDB()

graphDB = new GraphDatabaseFactory().newEmbeddedDatabase(DB_PATH)

nodeIndex = graphDB.index().forNodes("nodes")

registerShutdownHook(graphDB)

Transaction tx = graphDB.beginTx()

try {

Node startNode = graphDB.createNode()

startNodeId = startNode.getId()

Node thomas = graphDB.createNode()

thomas.setProperty( "name", "Thomas Anderson" )

thomas.setProperty( "age", 29 )

nodeIndex.add(thomas, PRIMARY_KEY, thomas.getProperty("name"))

startNode.createRelationshipTo( thomas, RelTypes.NEO_NODE )

Node trinity = graphDB.createNode()

trinity.setProperty( "name", "Trinity" )

nodeIndex.add(trinity, PRIMARY_KEY, trinity.getProperty("name"))

Relationship rel = thomas.createRelationshipTo( trinity,

RelTypes.KNOWS )

rel.setProperty( "age", "3 days" )

Node morpheus = graphDB.createNode()

morpheus.setProperty( "name", "Morpheus" )

morpheus.setProperty( "rank", "Captain" )

morpheus.setProperty( "occupation", "Total badass" )

nodeIndex.add(morpheus, PRIMARY_KEY, morpheus.getProperty("name"))

thomas.createRelationshipTo( morpheus, RelTypes.KNOWS )

rel = morpheus.createRelationshipTo( trinity, RelTypes.KNOWS )

rel.setProperty( "age", "12 years" )

Node cypher = graphDB.createNode()

cypher.setProperty( "name", "Cypher" )

cypher.setProperty( "last name", "Reagan" )

nodeIndex.add(cypher, PRIMARY_KEY, cypher.getProperty("name"))

trinity.createRelationshipTo( cypher, RelTypes.KNOWS )

rel = morpheus.createRelationshipTo( cypher, RelTypes.KNOWS )

rel.setProperty( "disclosure", "public" )

Node smith = graphDB.createNode()

smith.setProperty( "name", "Agent Smith" )

smith.setProperty( "version", "1.0b" )

smith.setProperty( "language", "C++" )

nodeIndex.add(smith, PRIMARY_KEY, smith.getProperty("name"))

rel = cypher.createRelationshipTo( smith, RelTypes.KNOWS )

rel.setProperty( "disclosure", "secret" )

rel.setProperty( "age", "6 months" )

Node architect = graphDB.createNode()

architect.setProperty( "name", "The Architect" )

nodeIndex.add(architect, PRIMARY_KEY, architect.getProperty("name"))

smith.createRelationshipTo( architect, RelTypes.CODED_BY )

tx.success()

}

finally {

tx.finish()

}

}

public Traverser getFriends(final Node person) {

TraversalDescription td = Traversal.description()

.breadthFirst()

.relationships(RelTypes.KNOWS, Direction.OUTGOING)

.evaluator(Evaluators.excludeStartPosition())

return td.traverse(person)

}

public void printNodeFriends(Node node) {

// Node neo = graphDB.getNodeById(startNodeId)

// .getSingleRelationship(RelTypes.NEO_NODE, Direction.OUTGOING)

// .getEndNode()

int friendsNumbers = 0

System.out.println(node.getProperty(PRIMARY_KEY) + "'s friends:")

for(Path friendPath: getFriends(node)) {

System.out.println("At depth " + friendPath.length() + " =>"

+ friendPath.endNode().getProperty(PRIMARY_KEY))

friendsNumbers++

}

System.out.println("Number of friends found: " + friendsNumbers)

}

public void printCypherFriends(String name) {

graphDB = new GraphDatabaseFactory().newEmbeddedDatabase(DB_PATH)

ExecutionEngine engine = new ExecutionEngine(graphDB, StringLogger.logger(DB_PATH))

// ExecutionResult result = engine.execute(

// "start n=node:nodes(name=\"" + name + "\") "

// + "match n-[:KNOWS*..]->f "

// + "return distinct f, f.name")

ExecutionResult result = engine.execute("start n=node(500000) return n")

System.out.println(result.dumpToString())

}

public void printThomasFriends() {

printNodeFriends(nodeIndex.get(PRIMARY_KEY, "Thomas Anderson").getSingle())

}

public Iterable<Path>findShortestPath(Node node1, Node node2) {

PathFinder<Path>finder = GraphAlgoFactory.shortestPath(

Traversal.expanderForTypes(RelTypes.KNOWS, Direction.OUTGOING), 5)

Iterable<Path>paths = finder.findAllPaths(node1, node2)

return paths

}

public void printShortestPaths() {

Node node1 = nodeIndex.get(PRIMARY_KEY, "Thomas Anderson").getSingle()

Node node2 = nodeIndex.get(PRIMARY_KEY, "Agent Smith").getSingle()

for(Path shortestPath: findShortestPath(node1, node2)) {

System.out.println(shortestPath.toString())

}

}

private static void registerShutdownHook(final GraphDatabaseService graphDB) {

Runtime.getRuntime().addShutdownHook(new Thread() {

@Override

public void run() {

graphDB.shutdown()

}

})

}

private void shutdown() {

graphDB.shutdown()

}

/**

* @param args

*/

public static void main(String[] args) {

Example example = new Example()

// example.createDB()

long t1 = System.currentTimeMillis()

// example.printThomasFriends()

example.printCypherFriends("Thomas Anderson")

long t2 = System.currentTimeMillis()

System.out.print(t2-t1)

//example.printShortestPaths()

example.shutdown()

}

}

.getConnection("jdbc:neo4j://localhost:7474/") //创建连接

String query = "start n = node({1}) return n.name"

PreparedStatement stmt = null //采用预编译，和关系数据库不一样的是,参数需要使用{1},{2},而不是?

ResultSet rs = null

try {

stmt = con.prepareStatement(query)

stmt.setInt(1, 14)

rs = stmt.executeQuery()

System.out.println(rs.getRow())

while (rs.next()) {

System.out.println("a " + rs.getString("n.name"))

}

} catch (Exception e) {

throw e

} finally {

if (null != rs) {

rs.close()