正常来说 neo4j是用来图存储的，neo4j企业版 的性能远远高于 社区版，毕竟是收费的，不过 只要下载到就可以使用了，我已经用上了，非常棒。
spark 是用来 做 图计算的，Graphx,其实 spark 和Neo4j 有交叉点，在图论算法上都可以用上，
我们在使用 neo4j 和 spark 结合的时候
1.首先 如果你的neo4j 是需要账号密码登录的话，你就应该 在项目中配置一下，
两三种方式
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{SQLContext, SparkSession}
import org.apache.spark.sql.types.{StringType, StructField, StructType}
import org.apache.spark.{SparkConf, SparkContext}
import org.neo4j.spark.Neo4j
import org.neo4j.spark._
import collection.JavaConversions._
val spark=SparkSession.builder().appName("play")
.master("local[*]")
.config("spark.neo4j.bolt.url", "bolt://localhost:7687")
.config("spark.neo4j.bolt.user", "neo4j")
.config("spark.neo4j.bolt.password", "hortmt")
.getOrCreate()
import spark.implicits._
val neo=Neo4j(spark.sparkContext)
//这个是使用sparkSession配置
下一个是使用 sparkConf配置
val conf = new SparkConf().setAppName("neoej")
.setMaster("local[*]")
.set("spark.neo4j.bolt.url", "bolt://localhost:7687")
.set("spark.neo4j.bolt.user", "neo4j")
.set("spark.neo4j.bolt.password", "hortmt")
val sc =new SparkContext(conf)
val neo=Neo4j(sc)
3 另外还有一种是通过 Neo4jConfig 来做配置
val sparkSession = SparkSession.builder()
.master("local[*]")
.appName("LoadDataToNeo4j")
.getOrCreate();
val sc = sparkSession.sparkContext
val config = Neo4jConfig("localhost:","neo4j",Option("root"))
Neo4j(sc).cypher("CREATE (c:Client {id:1230}) return c").loadRdd
sparkSession.close()
- 我们最常见的就是 把 neo4j 的node 转化为 spark 里的rdd 或者 dataframe 或者 graph ，其中 rdd 又分为 四种 ，普通rdd ，noderdd ，rowrdd，relrdd
在整这个的时候首先 遇到两个障碍 ，第一是转化 ，第二是把 图的属性 提取出来变成 一个case class ，
比如我现在有一份 csv格式的 用户通话记录，header 里有五个属性
{.user,.other,.direction,.duration,.timestamp}) ，大概有 一万条记录
首先我先把 这个加载存储到 neo4j,注意 这个csv文件最好放在 neo 安装根目录下的import目录下，否则加载会出错，或者通过 http 下载 加载也可以
参考
https://raw.githubusercontent.com/data-commons/prep-buddy/b2e307f5f5261124ef2a97c4ff9225019804d864/data/calls.csv
https://raw.githubusercontent.com/data-commons/prep-buddy/b2e307f5f5261124ef2a97c4ff9225019804d864/data/calls_with_header.csv
LOAD CSV WITH HEADERS FROM "file:///calls_with_header.csv" AS line
create (:person {user:line.user, other:line.other, direction:line.direction, duration:line.duration, timestamp:line.timestamp})
然后为这些节点创建关系 ，通过 拨打电话 呼叫 被叫 错过 来创建relationship
match (from:person),(to:person) where (from.other=to.user and from.direction="Outgoing")
merge (from)-[r:rel{direction:from.direction,duration:from.duration,timestamp:from.timestamp}]->(to)
match (from:person),(to:person) where (from.user=to.other and from.direction="Incoming")
merge (from)-[r:rel{duration:from.direction,duration:from.duration,timestamp:from.timestamp}]->(to)
单单创建关系 企业版比社区版至少要快五倍，
现在 Neo 里面有数据了 ，我们取数据就可以。
大家可以看到，我们的节点其实就是一个 person的实例，那我们在转化为rdd的时候 ，我们希望 rdd 其实wrapper的是person class ，所以我们首先建了一个case class
case class Person(user: String,other:String,direction:String,duration:String,timestamp:String)
然后我们的 执行Neo 的cypher语句
val rawGraphnode=neo.cypher("MATCH (n:person)where (n.duration <>0) RETURN n{.user,.other,.direction,.duration,.timestamp}").loadNodeRdds
其实 loadRowRdd 也是可以的
val rawGraphnode=neo.cypher("MATCH (n:person)where (n.duration <>0) RETURN n{.user,.other,.direction,.duration,.timestamp}").loadRowRdd
通过调试和出错 结果发现 rdd里row 放的其实不是person对象，而是
java.util.Collections.UnmodifiableMap，可笑的是 这个类还是 一个私有类，不过通过发现它继承了 java的 java.util.Map
我们需要把它强制转化为java 的 map ,注意scala的map 是不可以直接转化的
我们先是 尝试了多遍 ，尤其是看输出
rawGraphnode.foreach(xd=>{
val ne= xd(0).asInstanceOf[java.util.Map[String,String]]
val pe= new Person(ne("user"),ne("other"),ne("direction"),ne("duration"),ne("timestamp"))
println(pe.user+"&&"+pe.other+"&&"+pe.direction+"&&"+pe.duration+"&&"+pe.timestamp)
})
当我们发现 转化是正常的，然后再转化为 RDD[Person]
val personRDD:RDD[Person]= rawGraphnode.map(row=>
{
val rawMap= row(0).asInstanceOf[java.util.Map[String,String]]
val pe= new Person(rawMap("user"),rawMap("other"),rawMap("direction"),rawMap("duration"),rawMap("timestamp"))
pe
}
)
这里面其实最重要的是 map 转化为case class ，这里面其实有很多种优雅的方式实现 ，不过我用的是最笨的，不过我这个也不太容易出错 。
大家参考
https://stackoverflow.com/questions/20684572/scala-convert-map-to-case-class
不过 如果大家使用上 as 语法后，其实就灭有 那么困难了
val rawGraphnode=neo.cypher("MATCH (n:person)where (n.duration <>0) RETURN n.user as user,n.other as other,n.direction as direction,n.duration as duration,n.timestamp as timestamp").loadRowRdd
rawGraphnode.take(10).foreach(println(_))
下面的重点是 把 neo4j的节点 转化为 Dataframe 和 graph 的尝试 ，分两种
第一种可以很好按照 schme 的要求保留具体属性 来创建 Dataframe
val schme:StructType=StructType(Seq(
StructField("user",StringType,nullable = false),
StructField("other",StringType,nullable = false),
StructField("direction",StringType,nullable = true),
StructField("duration",StringType,nullable = true),
StructField("timestamp",StringType,nullable = true)
)
)
val rawGNDF= spark.createDataFrame(rawGraphnode,schme)
rawGNDF.printSchema()
第二种等于是根据 case class 的属性来的，但是 nullable 会都为true
val dfs= spark.createDataFrame(personRDD)
dfs.printSchema()
关于 spark sql row 对象与case class 的转化 ，大家可以看这里
https://stackoverflow.com/questions/28166555/how-to-convert-row-of-a-scala-dataframe-into-case-class-most-efficiently
想直接转DataFrame 其实还是有阻碍的,单个属性可以，多个属性就报废了，schema的语法是 （fieldName,fieldtype),其中type 支持 String double long boolean ,如果是object integer float 他们会自动转化
val rawGraphnode=neo.cypher("MATCH (n:person)where (n.duration <>0) RETURN n{.user,.other,.direction,.duration,.timestamp}")
.loadDataFrame(schema = ("user","String"),("other","double"),("direction","string"),("duration","integer"),("timestamp","boolean"))
后来我发现 其实是可以的，就是 需要再 查询语句中使用 as 语法，这样就转化成功了
val rawGraphnode=neo.cypher("MATCH (n:person)where (n.duration <>0) RETURN n.user as user,n.other as other,n.direction as direction,n.duration as duration,n.timestamp as timestamp")
.loadDataFrame(schema = ("user","object"),("other","object"),("direction","string"),("duration","String"),("timestamp","String"))
rawGraphnode.printSchema()
rawGraphnode.show(10)
使用上 as 以后 转化为 rowRDD 也非常方便 省力，唯一的缺点就是 structType 都是 string
val rawGraphnode=neo.cypher("MATCH (n:person)where (n.duration <>0) RETURN n.user as user,n.other as other,n.direction as direction,n.duration as duration,n.timestamp as timestamp").loadRowRdd
val dddf=rawGraphnode.first()
println(dddf.schema)
之后的转化为case class 也比较顺手
rawGraphnode.foreach(xd=>
{
val pe=new Person(xd.getAs[String]("user"),xd.getAs[String]("other"),xd.getAs[String]("direction"),xd.getAs[String]("duration"),xd.getAs("timestamp"))
println(pe.user+"&&"+pe.other+"&&"+pe.direction+"&&"+pe.duration+"&&"+pe.timestamp)
})
转化为 RDD版的case Class 也非常方便
val perRDD:RDD[Person]=rawGraphnode.map(xd=>{
val pe=new Person(xd.getAs[String]("user"),xd.getAs[String]("other"),xd.getAs[String]("direction"),xd.getAs[String]("duration"),xd.getAs("timestamp"))
pe
})
perRDD.take(10).foreach(println(_))
然后我们 尝试造图
val neo4j: Neo4j = Neo4j(sc=spark.sparkContext).rels(relquery)
val graph: Graph[Long, String] = neo4j.loadGraph[Long,String]
println(graph.vertices.count())
打印 11015 ，正确，
推荐一个 GitHub的项目
https://github.com/luhm2017/graphx-analysis
git clone https://github.com/luhm2017/graphx-analysis.git