neo4j-jersey分嵌入式和服务式连接图形数据库

原文载自：http://blog.csdn.net/yidian815/article/details/12887259

嵌入式：

引入neo4j依赖

        <dependency>
            <groupId>org.neo4j</groupId>
            <artifactId>neo4j</artifactId>
            <version>1.9.4</version>
        </dependency> 

创建一个neo4j.properties（数据库的配置文件）

# Default values for the low-level graph engine
#neostore.nodestore.db.mapped_memory=25M
#neostore.relationshipstore.db.mapped_memory=50M
#neostore.propertystore.db.mapped_memory=90M
#neostore.propertystore.db.strings.mapped_memory=130M
#neostore.propertystore.db.arrays.mapped_memory=130M  

# Autoindexing  

# Enable auto-indexing for nodes, default is false
#node_auto_indexing=true  

# The node property keys to be auto-indexed, if enabled
#node_keys_indexable=name,age  

# Enable auto-indexing for relationships, default is false
#relationship_auto_indexing=true  

# The relationship property keys to be auto-indexed, if enabled
#relationship_keys_indexable=name,age  

# Keep logical logs, needed for online backups to work
keep_logical_logs=true  

# Enable online backups to be taken from this database.
online_backup_enabled=true  

# Uncomment and specify these lines for running Neo4j in High Availability mode.
# ha.server_id is a unique integer for each instance of the Neo4j database in the cluster.
# (as opposed to the coordinator instance IDs)
# example: ha.server_id=1
#ha.server_id=  

# ha.coordinators is a comma-separated list (without spaces) of the host:port of where to
# find one or more of the Neo4j coordinator servers.
# Avoid localhost due to IP resolution issues on some systems.
# example: ha.coordinators=localhost:2181,1.2.3.4:4321
#ha.coordinators=localhost:2181  

# You can also, optionally, configure the ha.cluster_name. This is the name of the cluster this
# instance is supposed to join. Accepted characters are alphabetical, numerical, dot and dash.
# This configuration is useful if you have multiple Neo4j HA clusters managed by the same
# Coordinator cluster.
# Example: ha.cluster_name = my.neo4j.ha.cluster
#ha.cluster_name =  

# IP and port for this instance to bind to to communicate data with the
# other neo4j instances in the cluster. This is broadcasted to the other
# cluster members, so different members can have different communication ports.
# Optional if the members are on different machines so the IP is different for every member.
#ha.server = localhost:6001  

# The interval at which slaves will pull updates from the master. Comment out
# the option to disable periodic pulling of updates. Unit is seconds.
ha.pull_interval = 10  

# The session timeout for the zookeeper client. Lower values make new master
# election happen closer to the master loosing connection but also more sensitive
# to zookeeper quorum hiccups. If experiencing master switches without reason
# consider increasing this value. Unit is seconds
#ha.zk_session_timeout = 5  

# Amount of slaves the master will try to push a transaction to upon commit (default is 1).
# The master will optimistically continue and not fail the transaction even if it fails to
# reach the push factor. Setting this to 0 will increase write performance when writing
# through master but could potentially lead to branched data (or loss of transaction)
# if the master goes down.
#ha.tx_push_factor=1  

# Strategy the master will use when pushing data to slaves (if the push factor is greater than 0).
# There are two options available "fixed" (default) or "round_robin". Fixed will start by
# pushing to slaves ordered by server id (highest first) improving performance since the
# slaves only have to cache up one transaction at a time.
#ha.tx_push_strategy=fixed  

# Enable this to be able to upgrade a store from 1.4 -> 1.5 or 1.4 -> 1.6
#allow_store_upgrade=true  

# Enable this to specify a parser other than the default one. 1.5, 1.6, 1.7 are available
#cypher_parser_version=1.6  

java文件（neo4j示例文件修改而来）

package org.easypoint;  

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.Relationship;
import org.neo4j.graphdb.RelationshipType;
import org.neo4j.graphdb.Transaction;
import org.neo4j.graphdb.factory.GraphDatabaseFactory;
import org.neo4j.kernel.impl.util.FileUtils;  

public class Learn1
{
    private static final String DB_PATH = "target/neo4j-hello-db";
    String greeting;
    // START SNIPPET: vars
    GraphDatabaseService graphDb;
    Node firstNode;
    Node secondNode;
    Relationship relationship;
    // END SNIPPET: vars  

    // START SNIPPET: createReltype
    private static enum RelTypes implements RelationshipType
    {
        KNOWS
    }
    // END SNIPPET: createReltype  

    public static void main( final String[] args )
    {
        Learn1 hello = new Learn1();
        hello.createDb();
        hello.removeData();
        hello.shutDown();
    }  

    void createDb()
    {
        clearDb();
        // START SNIPPET: startDb
        graphDb = new GraphDatabaseFactory()
                .newEmbeddedDatabaseBuilder( "target/database/learn1" )
                .loadPropertiesFromFile(Learn1.class.getResource("/").getPath()+"neo4j.properties" )
                .newGraphDatabase();  

        registerShutdownHook( graphDb );
        // END SNIPPET: startDb  

        // START SNIPPET: transaction
        Transaction tx = graphDb.beginTx();
        try
        {
            // Updating operations go here
            // END SNIPPET: transaction
            // START SNIPPET: addData
            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 " );
            // END SNIPPET: addData  

            // START SNIPPET: readData
            System.out.print( firstNode.getProperty( "message" ) );
            System.out.print( relationship.getProperty( "message" ) );
            System.out.print( secondNode.getProperty( "message" ) );
            // END SNIPPET: readData  

            greeting = ( (String) firstNode.getProperty( "message" ) )
                    + ( (String) relationship.getProperty( "message" ) )
                    + ( (String) secondNode.getProperty( "message" ) );  

            // START SNIPPET: transaction
            tx.success();
        }
        finally
        {
            tx.finish();
        }
        // END SNIPPET: transaction
    }  

    private void clearDb()
    {
        try
        {
            FileUtils.deleteRecursively( new File( DB_PATH ) );
        }
        catch ( IOException e )
        {
            throw new RuntimeException( e );
        }
    }  

    void removeData()
    {
        Transaction tx = graphDb.beginTx();
        try
        {
            // START SNIPPET: removingData
            // let's remove the data
            firstNode.getSingleRelationship( RelTypes.KNOWS, Direction.OUTGOING ).delete();
            firstNode.delete();
            secondNode.delete();
            // END SNIPPET: removingData  

            tx.success();
        }
        finally
        {
            tx.finish();
        }
    }  

    void shutDown()
    {
        System.out.println();
        System.out.println( "Shutting down database ..." );
        // START SNIPPET: shutdownServer
        graphDb.shutdown();
        // END SNIPPET: shutdownServer
    }  

    // START SNIPPET: shutdownHook
    private static void registerShutdownHook( final GraphDatabaseService 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 application).
        Runtime.getRuntime().addShutdownHook( new Thread()
        {
            @Override
            public void run()
            {
                graphDb.shutdown();
            }
        } );
    }
    // END SNIPPET: shutdownHook
}  

运行java文件，可以看到在target/database/下创建了一个learn1的数据库。

从java代码我们也可以看出，neo4j数据库主要依靠node,relationship和property来存储数据，利用relationship将各个node链接起来。

服务式：

1.简单暴力连接（使用jdbc）：http://www.cnblogs.com/hwaggLee/p/5956541.html

2.使用JERSEY

添加依赖jar

<dependency>
           <groupId>com.sun.jersey</groupId>
           <artifactId>jersey-project</artifactId>
           <version>1.17</version>
       </dependency>  

       <dependency>
           <groupId>com.sun.jersey</groupId>
           <artifactId>jersey-server</artifactId>
           <version>1.17</version>
       </dependency>  

       <dependency>
           <groupId>com.sun.jersey</groupId>
           <artifactId>jersey-client</artifactId>
           <version>1.17</version>
       </dependency>  

       <dependency>
           <groupId>com.sun.jersey</groupId>
           <artifactId>jersey-core</artifactId>
           <version>1.17</version>
       </dependency>  

       <dependency>
           <groupId>com.sun.jersey</groupId>
           <artifactId>jersey-json</artifactId>
           <version>1.17</version>
       </dependency> 

新建java类Learn1Rest

package org.easypoint;  

import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.Client;
import java.net.URI;
import javax.ws.rs.core.MediaType;
/**
 * 服务式neo4j连接
 */
public class Learn1Rest {
    public static void main(String args[]){
        Learn1Rest lr = new Learn1Rest();
        URI firstNode = lr.createNode();
        lr.addProperty( firstNode, "name", "Joe Strummer" );
        URI secondNode = lr.createNode();
        lr.addProperty( secondNode, "band", "The Clash" );  

    }  

    public URI createNode(){
       String SERVER_ROOT_URI = "http://61.xxx.xxx.xx:7474/db/data/";
       final String nodeEntryPointUri = SERVER_ROOT_URI + "node";
       WebResource resource = Client.create().resource(nodeEntryPointUri);  

       ClientResponse response = resource.accept( MediaType.APPLICATION_JSON )
               .type(MediaType.APPLICATION_JSON)
               .entity("{}")
               .post(ClientResponse.class);
       final URI location = response.getLocation();
       System.out.println( String.format("POST to [%s], status code [%d], location header [%s]",
               nodeEntryPointUri, response.getStatus(), location.toString() ) );
       response.close();
       return location;  

   }  

    public void addProperty(URI nodeUri,String propertyName, String  propertyValue){
        String propertyUri = nodeUri.toString() + "/properties/" + propertyName;
        WebResource resource = Client.create()
                .resource( propertyUri );
        ClientResponse response = resource.accept( MediaType.APPLICATION_JSON )
                .type( MediaType.APPLICATION_JSON )
                .entity( "\"" + propertyValue + "\"" )
                .put( ClientResponse.class );
        System.out.println( String.format( "PUT to [%s], status code [%d]",
                propertyUri, response.getStatus() ) );
        response.close();  

    }
}  

执行成功

数据库查询：