第 4 章 在 Java 应用中使用 Neo4j

1

2

3

4

5

6

7

8

9

10

11

12

<project>

...

<dependencies>

<dependency>

<groupId>org.neo4j</groupId>

<artifactId>neo4j</artifactId>

<version>1.8</version>

</dependency>

...

</dependencies>

...

</project>

1

2

3

4

5

6

7

8

9

10

11

<ivysettings>

<settingsdefaultResolver="main"/>

<resolvers>

<chainname="main">

<filesystemname="local">

<artifactpattern="${ivy.settings.dir}/repository/[artifact]-[revision].[ext]"/>

</filesystem>

<ibiblioname="maven_central"root="http://repo1.maven.org/maven2/"m2compatible="true"/>

</chain>

</resolvers>

</ivysettings>

1

2

3

4

5

6

7

..

<dependencies>

..

<dependencyorg="org.neo4j"name="neo4j"rev="1.8"/>

..

</dependencies>

..

1

2

3

4

5

6

7

8

defneo4jVersion = "1.8"

apply plugin: 'java'

repositories {

mavenCentral()

}

dependencies {

compile "org.neo4j:neo4j:${neo4jVersion}"

}

1

2

graphDb = newGraphDatabaseFactory().newEmbeddedDatabase( DB_PATH );

registerShutdownHook( graphDb );

注意

EmbeddedGraphDatabase实例可以在多个线程中共享。然而你不能创建多个实例来指向同一个数据库。

1

graphDb.shutdown();

1

2

3

4

5

6

7

8

9

10

11

12

13

14

privatestaticvoidregisterShutdownHook( finalGraphDatabaseService graphDb )

{

// 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( newThread()

{

@Override

publicvoidrun()

{

graphDb.shutdown();

}

} );

}

1

2

3

4

GraphDatabaseService graphDb = newGraphDatabaseFactory().

newEmbeddedDatabaseBuilder( "target/database/location").

loadPropertiesFromFile( pathToConfig + "neo4j.properties").

newGraphDatabase();

提示

范例源代码下载地址： EmbeddedNeo4j.java

1

2

3

4

privatestaticenumRelTypes implementsRelationshipType

{

KNOWS

}

1

2

3

4

GraphDatabaseService graphDb;

Node firstNode;

Node secondNode;

Relationship relationship;

1

2

graphDb = newGraphDatabaseFactory().newEmbeddedDatabase( DB_PATH );

registerShutdownHook( graphDb );

1

2

3

4

5

6

7

8

9

10

Transaction tx = graphDb.beginTx();

try

{

// Updating operations go here

tx.success();

}

finally

{

tx.finish();

}

1

2

3

4

5

6

7

firstNode = graphDb.createNode();

firstNode.setProperty( "message", "Hello, ");

secondNode = graphDb.createNode();

secondNode.setProperty( "message", "World!");

relationship = firstNode.createRelationshipTo( secondNode, RelTypes.KNOWS );

relationship.setProperty( "message", "brave Neo4j ");

1

2

3

System.out.print( firstNode.getProperty( "message") );

System.out.print( relationship.getProperty( "message") );

System.out.print( secondNode.getProperty( "message") );

1

2

3

4

// let's remove the data

firstNode.getSingleRelationship( RelTypes.KNOWS, Direction.OUTGOING ).delete();

firstNode.delete();

secondNode.delete();

1

graphDb.shutdown();

提示

范例中的源代码下载地址： EmbeddedNeo4jWithIndexing.java

1

2

3

4

5

privatestaticenumRelTypes implementsRelationshipType

{

USERS_REFERENCE,

USER

}

1

2

3

4

5

6

7

8

9

10

11

12

privatestaticString idToUserName( finalintid )

{

return"user"+ id + "@neo4j.org";

}

privatestaticNode createAndIndexUser( finalString username )

{

Node node = graphDb.createNode();

node.setProperty( USERNAME_KEY, username );

nodeIndex.add( node, USERNAME_KEY, username );

returnnode;

}

1

2

3

graphDb = newGraphDatabaseFactory().newEmbeddedDatabase( DB_PATH );

nodeIndex = graphDb.index().forNodes( "nodes");

registerShutdownHook();

1

2

3

4

5

6

7

8

9

10

11

12

13

14

Transaction tx = graphDb.beginTx();

try

{

// Create users sub reference node

Node usersReferenceNode = graphDb.createNode();

graphDb.getReferenceNode().createRelationshipTo(

usersReferenceNode, RelTypes.USERS_REFERENCE );

// Create some users and index their names with the IndexService

for( intid = 0; id < 100; id++ )

{

Node userNode = createAndIndexUser( idToUserName( id ) );

usersReferenceNode.createRelationshipTo( userNode,

RelTypes.USER );

}

1

2

3

4

5

intidToFind = 45;

Node foundUser = nodeIndex.get( USERNAME_KEY,

idToUserName( idToFind ) ).getSingle();

System.out.println( "The username of user "+ idToFind + " is "

+ foundUser.getProperty( USERNAME_KEY ) );

1

2

3

4

5

6

7

8

9

10

11

12

13

14

<project>

...

<dependencies>

<dependency>

<groupId>org.neo4j</groupId>

<artifactId>neo4j-kernel</artifactId>

<version>${neo4j-version}</version>

<type>test-jar</type>

<scope>test</scope>

</dependency>

...

</dependencies>

...

</project>

提示

范例源代码下载地址： Neo4jBasicTest.java

1

2

3

4

5

@Before

publicvoidprepareTestDatabase()

{

graphDb = newTestGraphDatabaseFactory().newImpermanentDatabaseBuilder().newGraphDatabase();

}

1

2

3

4

5

@After

publicvoiddestroyTestDatabase()

{

graphDb.shutdown();

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

Transaction tx = graphDb.beginTx();

Node n = null;

try

{

n = graphDb.createNode();

n.setProperty( "name", "Nancy");

tx.success();

}

catch( Exception e )

{

tx.failure();

}

finally

{

tx.finish();

}

// The node should have an id greater than 0, which is the id of the

// reference node.

assertThat( n.getId(), is( greaterThan( 0l ) ) );

// Retrieve a node by using the id of the created node. The id's and

// property should match.

Node foundNode = graphDb.getNodeById( n.getId() );

assertThat( foundNode.getId(), is( n.getId() ) );

assertThat( (String) foundNode.getProperty( "name"), is( "Nancy") );

1

2

3

4

5

Map<String, String> config = newHashMap<String, String>();

config.put( "neostore.nodestore.db.mapped_memory", "10M");

config.put( "string_block_size", "60");

config.put( "array_block_size", "300");

GraphDatabaseService db = newImpermanentGraphDatabase( config );

提示

范例源代码下载地址： NewMatrix.java

1

2

3

4

5

6

7

8

9

privatestaticTraverser getFriends(

finalNode person )

{

TraversalDescription td = Traversal.description()

.breadthFirst()

.relationships( RelTypes.KNOWS, Direction.OUTGOING )

.evaluator( Evaluators.excludeStartPosition() );

returntd.traverse( person );

}

1

2

3

4

5

6

7

8

9

10

11

intnumberOfFriends = 0;

String output = neoNode.getProperty( "name") + "'s friends:\n";

Traverser friendsTraverser = getFriends( neoNode );

for( Path friendPath : friendsTraverser )

{

output += "At depth "+ friendPath.length() + " => "

+ friendPath.endNode()

.getProperty( "name") + "\n";

numberOfFriends++;

}

output += "Number of friends found: "+ numberOfFriends + "\n";

1

2

3

4

5

6

Thomas Anderson's friends:

At depth 1=> Trinity

At depth 1=> Morpheus

At depth 2=> Cypher

At depth 3=> Agent Smith

找到朋友的数量: 4

1

2

3

4

5

6

7

8

9

10

privatestaticTraverser findHackers( finalNode startNode )

{

TraversalDescription td = Traversal.description()

.breadthFirst()

.relationships( RelTypes.CODED_BY, Direction.OUTGOING )

.relationships( RelTypes.KNOWS, Direction.OUTGOING )

.evaluator(

Evaluators.includeWhereLastRelationshipTypeIs( RelTypes.CODED_BY ) );

returntd.traverse( startNode );

}

1

2

3

4

5

6

7

8

9

10

11

String output = "Hackers:\n";

intnumberOfHackers = 0;

Traverser traverser = findHackers( getNeoNode() );

for( Path hackerPath : traverser )

{

output += "At depth "+ hackerPath.length() + " => "

+ hackerPath.endNode()

.getProperty( "name") + "\n";

numberOfHackers++;

}

output += "Number of hackers found: "+ numberOfHackers + "\n";

1

2

3

Hackers:

At depth 4=> The Architect

找到hackers的数量: 1

提示

范例源代码下载地址： OrderedPath.java

1

2

3

4

5

6

7

8

Node A = db.createNode();

Node B = db.createNode();

Node C = db.createNode();

Node D = db.createNode();

A.createRelationshipTo( B, REL1 );

B.createRelationshipTo( C, REL2 );

C.createRelationshipTo( D, REL3 );

A.createRelationshipTo( C, REL2 );

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

finalArrayList<RelationshipType> orderedPathContext = newArrayList<RelationshipType>();

orderedPathContext.add( REL1 );

orderedPathContext.add( withName( "REL2") );

orderedPathContext.add( withName( "REL3") );

TraversalDescription td = Traversal.description()

.evaluator( newEvaluator()

{

@Override

publicEvaluation evaluate( finalPath path )

{

if( path.length() == 0)

{

returnEvaluation.EXCLUDE_AND_CONTINUE;

}

RelationshipType expectedType = orderedPathContext.get( path.length() - 1);

booleanisExpectedType = path.lastRelationship()

.isType( expectedType );

booleanincluded = path.length() == orderedPathContext.size()

&& isExpectedType;

booleancontinued = path.length() < orderedPathContext.size()

&& isExpectedType;

returnEvaluation.of( included, continued );

}

} );

1

2

3

4

5

6

Traverser traverser = td.traverse( A );

PathPrinter pathPrinter = newPathPrinter( "name");

for( Path path : traverser )

{

output += Traversal.pathToString( path, pathPrinter );

}

1

(A)--[REL1]-->(B)--[REL2]-->(C)--[REL3]-->(D)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

staticclassPathPrinter implementsTraversal.PathDescriptor<Path>

{

privatefinalString nodePropertyKey;

publicPathPrinter( String nodePropertyKey )

{

this.nodePropertyKey = nodePropertyKey;

}

@Override

publicString nodeRepresentation( Path path, Node node )

{

return"("+ node.getProperty( nodePropertyKey, "") + ")";

}

@Override

publicString relationshipRepresentation( Path path, Node from,

Relationship relationship )

{

String prefix = "--", suffix = "--";

if( from.equals( relationship.getEndNode() ) )

{

prefix = "<--";

}

else

{

suffix = "-->";

}

returnprefix + "["+ relationship.getType().name() + "]"+ suffix;

}

}

注意

下面的范例使用了一个已经废弃的遍历API。它与新的遍历查询API共享底层实现，所以它们的性能是一样的。比较起来它提供的功能非常有限。

提示

范例源代码下载地址： Matrix.java

1

2

3

4

5

6

7

privatestaticTraverser getFriends( finalNode person )

{

returnperson.traverse( Order.BREADTH_FIRST,

StopEvaluator.END_OF_GRAPH,

ReturnableEvaluator.ALL_BUT_START_NODE, RelTypes.KNOWS,

Direction.OUTGOING );

}

1

2

3

4

5

6

7

8

9

10

11

12

intnumberOfFriends = 0;

String output = neoNode.getProperty( "name") + "'s friends:\n";

Traverser friendsTraverser = getFriends( neoNode );

for( Node friendNode : friendsTraverser )

{

output += "At depth "+

friendsTraverser.currentPosition().depth() +

" => "+

friendNode.getProperty( "name") + "\n";

numberOfFriends++;

}

output += "Number of friends found: "+ numberOfFriends + "\n";

1

2

3

4

5

6

Thomas Anderson 的朋友们:

At depth 1=> Trinity

At depth 1=> Morpheus

At depth 2=> Cypher

At depth 3=> Agent Smith

一共找到朋友数量: 4

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

privatestaticTraverser findHackers( finalNode startNode )

{

returnstartNode.traverse( Order.BREADTH_FIRST,

StopEvaluator.END_OF_GRAPH, newReturnableEvaluator()

{

@Override

publicbooleanisReturnableNode(

finalTraversalPosition currentPos )

{

return!currentPos.isStartNode()

&& currentPos.lastRelationshipTraversed()

.isType( RelTypes.CODED_BY );

}

}, RelTypes.CODED_BY, Direction.OUTGOING, RelTypes.KNOWS,

Direction.OUTGOING );

}

1

2

3

4

5

6

7

8

9

10

11

12

String output = "Hackers:\n";

intnumberOfHackers = 0;

Traverser traverser = findHackers( getNeoNode() );

for( Node hackerNode : traverser )

{

output += "At depth "+

traverser.currentPosition().depth() +

" => "+

hackerNode.getProperty( "name") + "\n";

numberOfHackers++;

}

output += "Number of hackers found: "+ numberOfHackers + "\n";

1

2

3

Hackers:

At depth 4=> The Architect

找到hackers的数量: 1

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

finalNode target = data.get().get( "Principal1");

TraversalDescription td = Traversal.description()

.uniqueness( Uniqueness.NODE_PATH )

.evaluator( newEvaluator()

{

@Override

publicEvaluation evaluate( Path path )

{

if( path.endNode().equals( target ) )

{

returnEvaluation.INCLUDE_AND_PRUNE;

}

returnEvaluation.EXCLUDE_AND_CONTINUE;

}

} );

Traverser results = td.traverse( start );

1

2

(3)--[descendant,0]-->(1)<--[owns,3]--(5)

(3)--[descendant,2]-->(4)<--[owns,5]--(5)

提示

TraversalDescription对象是不变的，因此我们必须使用一个新的实例来返回新的uniqueness设置。

1

2

TraversalDescription nodeGlobalTd = td.uniqueness( Uniqueness.NODE_GLOBAL );

results = nodeGlobalTd.traverse( start );

1

(3)--[descendant,0]-->(1)<--[owns,3]--(5)

提示

范例源代码下载地址： socnet

1

2

3

TraversalDescription traversal = Traversal.description().

depthFirst().

relationships( NEXT );

1

2

3

4

5

6

7

8

9

10

11

12

13

14

PositionedIterator<StatusUpdate> first = statuses.get(0);

StatusUpdate returnVal = first.current();

if( !first.hasNext() )

{

statuses.remove( 0);

}

else

{

first.next();

sort();

}

returnreturnVal;

提示

范例源代码下载地址： Person.java

1

2

3

4

5

6

7

8

9

10

11

privatefinalNode underlyingNode;

Person( Node personNode )

{

this.underlyingNode = personNode;

}

protectedNode getUnderlyingNode()

{

returnunderlyingNode;

}

1

2

3

4

publicString getName()

{

return(String)underlyingNode.getProperty( NAME );

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

@Override

publicinthashCode()

{

returnunderlyingNode.hashCode();

}

@Override

publicbooleanequals( Object o )

{

returno instanceofPerson &&

underlyingNode.equals( ( (Person)o ).getUnderlyingNode() );

}

@Override

publicString toString()

{

return"Person["+ getName() + "]";

}

提示

范例源代码下载地址： PathFindingExamplesTest.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

Node startNode = graphDb.createNode();

Node middleNode1 = graphDb.createNode();

Node middleNode2 = graphDb.createNode();

Node middleNode3 = graphDb.createNode();

Node endNode = graphDb.createNode();

createRelationshipsBetween( startNode, middleNode1, endNode );

createRelationshipsBetween( startNode, middleNode2, middleNode3, endNode );

// Will find the shortest path between startNode and endNode via

// "MY_TYPE" relationships (in OUTGOING direction), like f.ex:

//

// (startNode)-->(middleNode1)-->(endNode)

//

PathFinder<Path> finder = GraphAlgoFactory.shortestPath(

Traversal.expanderForTypes( ExampleTypes.MY_TYPE, Direction.OUTGOING ), 15);

Iterable<Path> paths = finder.findAllPaths( startNode, endNode );

1

2

3

4

5

6

7

PathFinder<WeightedPath> finder = GraphAlgoFactory.dijkstra(

Traversal.expanderForTypes( ExampleTypes.MY_TYPE, Direction.BOTH ), "cost");

WeightedPath path = finder.findSinglePath( nodeA, nodeB );

// Get the weight for the found path

path.weight();

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

Node nodeA = createNode( "name", "A", "x", 0d, "y", 0d );

Node nodeB = createNode( "name", "B", "x", 7d, "y", 0d );

Node nodeC = createNode( "name", "C", "x", 2d, "y", 1d );

Relationship relAB = createRelationship( nodeA, nodeC, "length", 2d );

Relationship relBC = createRelationship( nodeC, nodeB, "length", 3d );

Relationship relAC = createRelationship( nodeA, nodeB, "length", 10d );

EstimateEvaluator<Double> estimateEvaluator = newEstimateEvaluator<Double>()

{

publicDouble getCost( finalNode node, finalNode goal )

{

doubledx = (Double) node.getProperty( "x") - (Double) goal.getProperty( "x");

doubledy = (Double) node.getProperty( "y") - (Double) goal.getProperty( "y");

doubleresult = Math.sqrt( Math.pow( dx, 2) + Math.pow( dy, 2) );

returnresult;

}

};

PathFinder<WeightedPath> astar = GraphAlgoFactory.aStar(

Traversal.expanderForAllTypes(),

CommonEvaluators.doubleCostEvaluator( "length"), estimateEvaluator );

WeightedPath path = astar.findSinglePath( nodeA, nodeB );

提示

范例源代码下载地址： JmxTest.java

1

2

3

4

5

6

7

8

privatestaticDate getStartTimeFromManagementBean(

GraphDatabaseService graphDbService )

{

GraphDatabaseAPI graphDb = (GraphDatabaseAPI) graphDbService;

Kernel kernel = graphDb.getSingleManagementBean( Kernel.class);

Date startTime = kernel.getKernelStartTime();

returnstartTime;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

4

publicclassNeo4jActivator implementsBundleActivator

{

privatestaticGraphDatabaseService db;

privateServiceRegistration serviceRegistration;

privateServiceRegistration indexServiceRegistration;

@Override

publicvoidstart( BundleContext context ) throwsException

{

//the cache providers

ArrayList<CacheProvider> cacheList = newArrayList<CacheProvider>();

cacheList.add( newSoftCacheProvider() );

//the index providers

IndexProvider lucene = newLuceneIndexProvider();

ArrayList<IndexProvider> provs = newArrayList<IndexProvider>();

provs.add( lucene );

ListIndexIterable providers = newListIndexIterable();

providers.setIndexProviders( provs );

//the database setup

GraphDatabaseFactory gdbf = newGraphDatabaseFactory();

gdbf.setIndexProviders( providers );

gdbf.setCacheProviders( cacheList );

db = gdbf.newEmbeddedDatabase( "target/db");

//the OSGi registration

serviceRegistration = context.registerService(

GraphDatabaseService.class.getName(), db, newHashtable<String,String>() );

System.out.println( "registered "+ serviceRegistration.getReference() );

indexServiceRegistration = context.registerService(

Index.class.getName(), db.index().forNodes( "nodes"),

newHashtable<String,String>() );

Transaction tx = db.beginTx();

try

{

Node firstNode = db.createNode();

Node secondNode = db.createNode();

Relationship relationship = firstNode.createRelationshipTo(

secondNode, DynamicRelationshipType.withName( "KNOWS") );

firstNode.setProperty( "message", "Hello, ");

secondNode.setProperty( "message", "world!");

relationship.setProperty( "message", "brave Neo4j ");

db.index().forNodes( "nodes").add( firstNode, "message", "Hello");

tx.success();

}

catch( Exception e )

{

e.printStackTrace();

thrownewRuntimeException( e );

}

finally

{

tx.finish();

}

}

@Override

publicvoidstop( BundleContext context ) throwsException

{

serviceRegistration.unregister();

indexServiceRegistration.unregister();

db.shutdown();

}

}

提示

源代码下载地址： JavaQuery.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

GraphDatabaseService db = newGraphDatabaseFactory().newEmbeddedDatabase( DB_PATH );

// add some data first

Transaction tx = db.beginTx();

try

{

Node refNode = db.getReferenceNode();

refNode.setProperty( "name", "reference node");

tx.success();

}

finally

{

tx.finish();

}

// let's execute a query now

ExecutionEngine engine = newExecutionEngine( db );

ExecutionResult result = engine.execute( "start n=node(0) return n, n.name");

System.out.println( result );

1

2

3

4

5

6

7

+---------------------------------------------------+

| n | n.name |

+---------------------------------------------------+

| Node[0]{name:"reference node"} | "reference node"|

+---------------------------------------------------+

1row

0ms

1

2

List<String> columns = result.columns();

System.out.println( columns );

1

[n, n.name]

1

2

3

4

5

6

7

8

Iterator<Node> n_column = result.columnAs( "n");

for( Node node : IteratorUtil.asIterable( n_column ) )

{

// note: we're grabbing the name property from the node,

// not from the n.name in this case.

nodeResult = node + ": "+ node.getProperty( "name");

System.out.println( nodeResult );

}

1

Node[0]: reference node

1

2

3

4

5

6

7

8

9

for( Map<String, Object> row : result )

{

for( Entry<String, Object> column : row.entrySet() )

{

rows += column.getKey() + ": "+ column.getValue() + "; ";

}

rows += "\n";

}

System.out.println( rows );

1

n.name: reference node; n: Node[0];