1.Neo4j数据库的两种方式

Neo4j可以以两种方式运行：

• Java应用程序中的嵌入式数据库
• 通过REST的独立服务器

不管哪一种方式，这个选择不会影响查询和使用数据库的方式。 它是由应用程序的性质（无论是独立服务器还是客户端服务器），性能，监视和数据安全性驱动的架构选择。

1.1Neo4j Server（服务器式数据库）

Neo4j Server是互操作性，安全性和监控的最佳选择。 实际上，REST接口允许所有现代平台和编程语言与它进行互操作。 此外，作为独立应用程序，它比嵌入式配置更安全（客户端中的潜在故障不会影响服务器），并且更易于监控。 如果我们选择使用这种模式，我们的应用程序将充当Neo4j服务器的客户端。

上一篇博文中介绍的安装Neo4j，其实就是服务器式数据库。

要连接到Neo4j服务器，您必须使用REST API，以便您可以使用任何编程语言的REST库访问数据库。 尽管可以使用任何可以发送HTTP请求的编程语言，但您也可以使用包装REST调用的多种语言和平台编写的联机库，例如Python，.NET，PHP，Ruby，Node.js等。

1.2An embedded database（内嵌式数据库）

嵌入式Neo4j数据库是性能的最佳选择。 它运行在相同的客户端应用程序的进程托管它并将数据存储在给定的路径中。 从而，必须以编程方式创建嵌入式数据库。 我们选择嵌入式数据库出于以下原因：

• 当我们使用Java作为我们项目的编程语言时
• 当我们的应用程序是独立的

2.程序代码

2.1配置文件

两种方式的连接都使用的是Maven项目，配置文件如下，注意配置文件是包括两种方式都需要的jar包。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
  <modelVersion>4.0.0</modelVersion> 
 
  <groupId>com.neo4j</groupId> 
  <artifactId>conn</artifactId> 
  <version>0.0.1-SNAPSHOT</version> 
  <packaging>jar</packaging> 
 
  <name>conn</name> 
  <url>http://maven.apache.org</url> 
 
  <properties> 
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
  </properties> 
 
  <dependencies> 
    <dependency> 
      <groupId>junit</groupId> 
      <artifactId>junit</artifactId> 
      <version>3.8.1</version> 
      <scope>test</scope> 
    </dependency> 
    <dependency> 
    <!-- 服务器开发需要的jar包 --> 
      <groupId>org.neo4j.driver</groupId> 
      <artifactId>neo4j-java-driver</artifactId> 
      <version>1.5.0</version> 
    </dependency> 
    <dependency> 
    <!-- 嵌入式开发需要的jar包 --> 
        <groupId>org.neo4j</groupId> 
        <artifactId>neo4j</artifactId> 
        <version>3.3.4</version> 
    </dependency> 
  </dependencies> 
   <repositories> 
    <repository> 
        <id>neo4j</id> 
        <url>http://m2.neo4j.org/content/repositories/releases/</url> 
        <releases> 
            <enabled>true</enabled> 
        </releases> 
    </repository> 
  </repositories>  
 
</project> 

   
    

2.2服务器开发的代码

注意，使用服务器开发的方式，Neo4j必须是开启的状态

package com.neo4j.conn; 
 
import org.neo4j.driver.v1.*; 
import static org.neo4j.driver.v1.Values.parameters; 
 
/** 
 * Hello world! 
 * 
 */ 
public class App  
{ 
    public static void main( String[] args ) 
    { 
        Driver driver = GraphDatabase.driver( "bolt://localhost:7687", AuthTokens.basic( "neo4j", "" ) ); 
        Session session = driver.session(); 
        session.run( "CREATE (a:Person {name: {name}, title: {title}})", 
                parameters( "name", "Arthur001", "title", "King001" ) ); 
 
        StatementResult result = session.run( "MATCH (a:Person) WHERE a.name = {name} " + 
                                              "RETURN a.name AS name, a.title AS title", 
                parameters( "name", "Arthur001" ) ); 
        while ( result.hasNext() ) 
        { 
            Record record = result.next(); 
            System.out.println( record.get( "title" ).asString() + " " + record.get( "name" ).asString() ); 
        } 
        session.close(); 
        driver.close(); 
    } 
} 

   
    

2.3嵌入式开发

package com.neo4j.conn; 
import java.io.File; 
import java.util.HashMap; 
import java.util.Map; 
 
import org.neo4j.cypher.internal.javacompat.ExecutionEngine; 
import org.neo4j.graphdb.*; 
import org.neo4j.graphdb.factory.*; 
public class Test1 { 
    public static void main(String[] args) { 
        // TODO Auto-generated method stub 
        GraphDatabaseService graphDb = new GraphDatabaseFactory().newEmbeddedDatabase(new File("Data/Test")); 
        System.out.println("Database Load!"); 
        //开启事务 
        try (Transaction tx = graphDb.beginTx()) { 
            // Perform DB operations 
            Node steve = graphDb.createNode(Labels.USER); 
            steve.setProperty("name", "Steve"); 
            Node linda = graphDb.createNode(Labels.USER); 
            linda.setProperty("name", "Linda"); 
            steve.createRelationshipTo( linda, RelationshipTypes.IS_FRIEND_OF ); 
            System.out.println("created node name is" + steve.getProperty("name")); 
            tx.success(); 
        } 
        //查询数据库 
        String query ="match (n:USER) return n.name as name"; 
        Map<String, Object >parameters = new HashMap<String, Object>(); 
         try ( Result result = graphDb.execute( query, parameters ) ) 
         { 
             while ( result.hasNext() ) 
             { 
                 Map<String, Object> row = result.next(); 
                 for ( String key : result.columns() ) 
                 { 
                     System.out.printf( "%s = %s%n", key, row.get( key ) ); 
                 } 
             } 
         } 
 
         registerShutdownHook(graphDb); 
         System.out.println("Database Shutdown!"); 
 
    } 
    //设置标签，但是必须继承于接口label 
    public enum Labels implements Label { 
        USER, 
        MOVIE; 
    } 
 
    public enum RelationshipTypes implements RelationshipType { 
        IS_FRIEND_OF, 
        HAS_SEEN; 
    } 
 
 
    private static void registerShutdownHook(final GraphDatabaseService graphDb){ 
        Runtime.getRuntime().addShutdownHook(new Thread(){ 
            @Override 
            public void run(){ 
                graphDb.shutdown(); 
            } 
        }); 
    } 
 
} 

   
    

2.4小结

这个只是快速入门了，代码很简单，如果想知道更详细的介绍，请看我后续的博文。

3.参考

Learing Cypher