neo4j官方表示性能良好,支持上亿级别数量的节点，但是成熟的资料不多。
1、在安装的过程中对jdk有一定的要求,我所安装的neo4j版本就要求jdk是1.7的。
2、对于neo4j的使用有两种方式：一种是嵌入式方式，另一种是提供了Rest访问的
服务器模式。
一、 Rest方式操作Neo4j:
这里应用了Jersey,通过Jersey客户端API调用rest风格的Web服务，这样就不用
关闭neo4j的服务,进行相关数据的增删改查了。
final String SERVER_ROOT_URI = "http://10.0.11.144:7474/db/data/";
1、查询
String cypherUri = SERVER_ROOT_URI + "cypher";
String queryStr = "start n = node(*) return n.source_id"; //查询所有的source_id属性。
JSONObject jsObject = new JSONObject();
jsObject.put("query", queryStr);
WebResource resource = Client.create().resource( cypherUri );
ClientResponse response = resource.accept( MediaType.APPLICATION_JSON_TYPE )
.type( MediaType.APPLICATION_JSON_TYPE ) .entity( jsObject.toString() ).post( ClientResponse.class );
String returnStr=String.format( "POST [%s] to [%s], status code [%d], RETURNED DATA: "+ System.getProperty( "line.separator" ) + "%s", queryStr, cypherUri, response.getStatus(), response.getEntity( String.class ) ) ;
String resultData=returnStr.split("RETURNED DATA:")[1];
JSONObject resultObj = JSONObject.fromObject(resultData);
String resultStr = resultObj.getString("data");
if(null != resultStr && !"".equals(resultStr)){
resultStr = resultStr.replace("[", "").replace("]", "").replace("\"", "");
}else{
resultStr = "";
}
response.close();
return resultStr;
2、删除
neo4j的删除，必须先删除其relationship，再删除其节点,否则删除失败！
这里根据source_id = 123进行删除节点，同时也可以进行批量删除：where n.source_id = 123 OR n.source_id = 124 OR n.source_id = 156。
但是应注意：因为是rest方式进行删除,这些参数不能拼接的太长，否则会报错.一般控制在几十个左右。
String cypherUri = SERVER_ROOT_URI + "cypher";
String queryStr = "START n=node(*) where n.source_id= 123 match n-[r]-() delete n,r;";
JSONObject jsObject = new JSONObject();
jsObject.put("query", queryStr);
WebResource resource = Client.create().resource( cypherUri );
ClientResponse response = resource.accept( MediaType.APPLICATION_JSON_TYPE )
.type( MediaType.APPLICATION_JSON_TYPE ) .entity( jsObject.toString() ).post( ClientResponse.class );
String returnStr=String.format( "POST [%s] to [%s], status code [%d], RETURNED DATA: "+ System.getProperty( "line.separator" ) + "%s", queryStr, cypherUri, response.getStatus(), response.getEntity( String.class ) ) ;
response.close();
3、添加：
注意：在采用rest这种增量式的添加的时候,由于新增的数据与已经存在的一致,但是再次添加的时候,
neo4j仍然能够正常的添加进去,以为neo4j是根据自己维护节点的id的,所以在增加新的数据之前，很有必要
对数据是否已在neo4j中创建进行判断.
private URI createNode() {
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);
URI location = response.getLocation();
response.close();
return location;
}
//这是创建的新节点,返回的URI是什么呢？我们看一下获取已经存在的节点的URI
private URI getNodesURI(String exits) { //exits是neo4j中的节点的id.
String nodeEntryPointUri = SERVER_ROOT_URI + "node/" + exits.replace("\"", "");
URI location = URI.create(nodeEntryPointUri);
return location;
}
1、利用上面创建新节点的方法创建两个节点.
URI nodes = createNode();
URI nodeo = createNode();
2、为这两个节点增加source_id属性.
addProperty(nodes,"source_id",99);
addProperty(nodeo,"source_id",100);
方法addProperty的具体实现如下：
private void addProperty(URI nodeUri, String propertyName, int 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);
response.close();
}
3、创建好了两个节点并为其增加了属性，那么如何为他们添加关联关系呢.
/**
* 增加neo4j的两个节点之间的关系.
* @param startNode 起始节点的URI
* @param endNode 指向节点的URI
* @param relationshipType 关系类型：一般为来自关系型数据库的数字.
* @param jsonAttributes "{ \"from\" : " + "\"" + sid + "\",\" until\" : " + "\"" + oid + "\"}"
* 其中：sid为起始节点的neo4j的id,oid为指向节点的neo4j的id.
* @return
* @throws URISyntaxException
*/
private URI addRelationship(URI startNode, URI endNode, String relationshipType,
String jsonAttributes) throws URISyntaxException {
URI fromUri = new URI(startNode.toString() + "/relationships");
String relationshipJson = generateJsonRelationship(endNode,relationshipType, jsonAttributes);
WebResource resource = Client.create().resource(fromUri);
ClientResponse response = resource.accept(MediaType.APPLICATION_JSON)
.type(MediaType.APPLICATION_JSON).entity(relationshipJson)
.post(ClientResponse.class);
final URI location = response.getLocation();
response.close();
return location;
}
4、获取节点nodes和节点nodeo之间的关系
URI relationshipUri = addRelationship(nodes, nodeo, String.valueOf(p), "{ \"from\" : " + "\"" + sid + "\",\" until\" : " + "\"" + oid + "\"}");
5、为关系relationshipUri添加"rel_sounce_id"属性
String relationshipId = "123";
addMetadataToProperty(relationshipUri, "rel_source_id", relationshipId);
具体的实现方法如下：
private void addMetadataToProperty(URI relationshipUri, String name,String value) throws URISyntaxException {
URI propertyUri = new URI(relationshipUri.toString() + "/properties");
String entity = toJsonNameValuePairCollection(name, value);
WebResource resource = Client.create().resource(propertyUri);
ClientResponse response = resource.accept(MediaType.APPLICATION_JSON)
.type(MediaType.APPLICATION_JSON).entity(entity)
.put(ClientResponse.class);
response.close();
}
4、更新(略)
由此可见，无论是增删还是改查,rest都是通过执行Cypher语言来操作neo4j数据库的,我们来介绍一下什么是Cypher语言：
1、通过Cypher创建节点：注意每个node，系统会自动建立一个唯一的id，不可修改的。
create n={name:'Motion',ID:'M001'} return n; //这里的ID是节点的一个属性.
2、创建关系：
start n=node(14),m=node(20) create m-[r:KNOWS]-n return r;
3、查询：
按系统的id查询： start n = node(20) return n;
查询所有节点的name: start n = node(*) return n.name;
根据属性查找： start n = node(*) where n.name = '王新红' return n;
按照关系查找：
1、查询所有与起始节点关联的信息
START n=node(14) MATCH (n)–[r]-(x) RETURN n,x (没有任何指向)
START n=node(14) MATCH (n)–[r]->(x) RETURN n,x (从n节点指向x节点)
START n=node(14) MATCH (n)<–[r]-(x) RETURN n,x (从x节点指向n节点)
2、查询定向关系
START n=node(14) MATCH (n)<-[r]-() RETURN r (查询所有指向n节点的relationship)
START n=node(14) MATCH (n)-[r]->() RETURN r (查询所有n节点指出的relationship)
3、路径远近查询
START n=node(14) MATCH (n)<–[r]-(x)<-[*1..3]-y RETURN n,x,y (查询所有指向n几点并且路径为2到4的关系)
start a=node(14),b=node(2472) match p=a-[*0..4]-b return p; (查询节点14和节点2472之间路径关系为0到4的所有节点)
分页查询： start n=node(*) return n skip 18 limit 3 //每次skip相当于第几页,limit相当于每页多少条。
4、修改：
start a = node(*) where a.name="a" set a.name="A" return a,a.name ;
start n=node(0) set n.name="Root",n.ID="001" ;
5、删除：
删除所有的节点和关系：start n = node(*) match n-[r]-() delete n,r;
6、同事查询多个节点
start a = node(0),b = node(1) return a,b
二、嵌入式方式操作neo4j(利用一段程序了解其API)
private void copyInfoFromFactToNeo4j(){
GraphDatabaseService graphDB = new GraphDatabaseFactory().newEmbeddedDatabase(DPATH);
registerShutdownHook(graphDB); //发生意外的时候关闭,释放锁.
try {
Connection con = connectDB();
String sql = "select * from ont_fact o where o.neo4jRelationshipID is null and p in (select distinct id from ont_element where element_type=5) and p not in (46, 32,82,57,54,49,24,100,93,96,106)";
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(sql);
int i = 0;
while (rs.next()) {
//封装jdbc获取的关系型数据库的信息.
Statement pst = con.createStatement();
int id = rs.getInt("id");
int s = rs.getInt("s");
int p = rs.getInt("p");
int o = rs.getInt("o");
int neo4jRelationId = rs.getInt("neo4jRelationshipID");
//neo4j开启事务
Transaction tx = graphDB.beginTx();
try {
Index<Node> nodeIndex = graphDB.index().forNodes("nodes");
Index<Relationship> relIndex = graphDB.index().forRelationships("relationships");
//根据属性获取节点
Node node1 = getNode(graphDB, s);
Node node2 = getNode(graphDB, o);
//创建关系,并设置关系属性.
RelationshipType reltype = DynamicRelationshipType.withName(p + "");
//创建节点之间的relationship关系
Relationship rel = node1.createRelationshipTo(node2,reltype);
rel.setProperty("rel_source_id", id);
relIndex.add(rel, "rel_source_id", id);
//同步关系型数据库数据,使得图数据库与关系型数据库数据一致.
String updatesql = "update [ont_fact] set neo4jRelationshipID='"
+ rel.getId() + "' where id=" + id;
pst.executeUpdate(updatesql);
tx.success();
} finally {
tx.finish();
}
}
rs.close();
st.close();
con.close();
graphDB.shutdown();
} catch (Exception e) {
e.printStackTrace();
}
}
private void registerShutdownHook(final GraphDatabaseService graphDB2) {
Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
graphDB2.shutdown();
}
});
}
//获取节点
public Node getNode(GraphDatabaseService graphDB, int obj) {
Node node;
Transaction tx = graphDB.beginTx();
try {
nodeIndex = graphDB.index().forNodes("nodes");
IndexHits<Node> node_results = nodeIndex.query("source_id", obj);
// System.out.println(node_results.size());
if (node_results.size() > 0) {
System.out.println("节点【" + obj + "】确实存在...");
node = node_results.getSingle();
} else {
//如果不存在,则创建并添加节点属性信息.
node = graphDB.createNode();
// long NodeId = node.getId();
node.setProperty("source_id", obj);
nodeIndex.add(node, PRIMARY_KEY, node.getProperty("source_id"));
}
tx.success();
} finally {
tx.finish();
}
return node;
}
总结：Neo4j对外提供两种方式，其中的嵌入式方式处理数据快，但是不能实现在线的备份和更新,必须先停掉neo4j服务。而rest方式则解决这一不足,但是处理数据的效率相对低下.