Panduan Neo4J dengan Java

1. Pengenalan

Artikel ini adalah mengenai Neo4j - salah satu pangkalan data grafik yang paling matang dan lengkap di pasaran sekarang. Pangkalan data grafik mendekati tugas pemodelan data dengan pandangan bahawa banyak perkara dalam kehidupan menjadikan diri mereka diwakili sebagai kumpulan nod (V) dan hubungan di antara mereka yang disebut tepi (E).

2. Neo4j terbenam

Cara termudah untuk memulakan Neo4j adalah dengan menggunakan versi terbenam di mana Neo4j berjalan di JVM yang sama dengan aplikasi anda.

Pertama, kita perlu menambahkan pergantungan Maven:

 org.neo4j neo4j 3.4.6 

Anda boleh menyemak pautan ini untuk memuat turun versi terkini.

Seterusnya, mari buat kilang:

GraphDatabaseFactory graphDbFactory = new GraphDatabaseFactory();

Akhirnya, kami membuat pangkalan data terbenam:

GraphDatabaseService graphDb = graphDbFactory.newEmbeddedDatabase( new File("data/cars"));

Sekarang tindakan sebenar boleh bermula! Pertama, kita perlu membuat beberapa node dalam grafik kita dan untuk itu, kita perlu memulakan transaksi kerana Neo4j akan menolak operasi yang merosakkan kecuali transaksi telah dimulakan:

graphDb.beginTx();

Setelah urus niaga berlangsung, kita boleh mula menambahkan nod:

Node car = graphDb.createNode(Label.label("Car")); car.setProperty("make", "tesla"); car.setProperty("model", "model3"); Node owner = graphDb.createNode(Label.label("Person")); owner.setProperty("firstName", "baeldung"); owner.setProperty("lastName", "baeldung");

Di sini kami menambah nod kereta dengan ciri-ciri membuat dan model serta nod Orang dengan sifat-sifat firstName dan LASTNAME

Sekarang kita boleh menambah hubungan:

owner.createRelationshipTo(car, RelationshipType.withName("owner"));

Pernyataan di atas menambahkan kelebihan yang menghubungkan kedua-dua nod dengan label pemilik . Kami dapat mengesahkan hubungan ini dengan menjalankan pertanyaan yang ditulis dalam bahasa Cypher yang kuat dari Neo4j :

Result result = graphDb.execute( "MATCH (c:Car) <-[owner]- (p:Person) " + "WHERE c.make = 'tesla'" + "RETURN p.firstName, p.lastName");

Di sini kami meminta untuk mencari pemilik kereta untuk mana-mana kereta yang dibuat adalah tesla dan memberikan kami nama depan dan nama belakangnya. Tidak menghairankan, ini kembali: {p.firstName = baeldung, p.lastName = baeldung}

3. Bahasa Pertanyaan Cypher

Neo4j menyediakan bahasa pertanyaan yang sangat kuat dan intuitif yang menyokong pelbagai ciri yang diharapkan dari pangkalan data. Mari kita kaji bagaimana kita dapat mencapai standard membuat, mengambil, mengemas kini dan menghapus tugas.

3.1. Buat Node

Buat kata kunci boleh digunakan untuk membuat kedua-dua nod dan hubungan.

CREATE (self:Company {name:"Baeldung"}) RETURN self

Di sini kami telah mewujudkan syarikat dengan satu nama harta tanah . Definisi nod ditandai dengan tanda kurung dan sifatnya dilampirkan dalam pendakap kerinting. Dalam kes ini, diri adalah alias untuk nod dan Syarikat adalah label nod.

3.2. Buat Hubungan

Anda boleh membuat simpul dan hubungan dengan simpul itu dalam satu pertanyaan:

Result result = graphDb.execute( "CREATE (baeldung:Company {name:\"Baeldung\"}) " + "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" + "RETURN baeldung, tesla");

Di sini kami telah membuat node baeldung dan tesla dan menjalin hubungan pemilikan antara mereka. Menjalin hubungan dengan node yang ada sudah tentu juga boleh dilakukan.

3.3. Dapatkan Data

Kata kunci MATCH digunakan untuk mencari data dalam kombinasi dengan RETURN untuk mengawal titik data yang dikembalikan. The MANA fasal boleh digunakan untuk menapis hanya mereka nod yang mempunyai ciri-ciri yang kami kehendaki.

Marilah kita mengetahui nama syarikat yang memiliki tesla modelX:

Result result = graphDb.execute( "MATCH (company:Company)-[:owns]-> (car:Car)" + "WHERE car.make='tesla' and car.model='modelX'" + "RETURN company.name");

3.4. Kemas kini Nod

Kata kunci SET boleh digunakan untuk mengemas kini sifat atau label nod. Mari kita tambahkan jarak tempuh ke tesla kami:

Result result = graphDb.execute("MATCH (car:Car)" + "WHERE car.make='tesla'" + " SET car.milage=120" + " SET car :Car:Electro" + " SET car.model=NULL" + " RETURN car");

Di sini kami menambahkan harta baru yang disebut milage , mengubah label menjadi Car dan Electro dan akhirnya, kami memadam keseluruhan model model .

3.5. Padamkan Nod

DELETE kata kunci boleh digunakan untuk penghapusan nod atau hubungan secara kekal dari grafik:

graphDb.execute("MATCH (company:Company)" + " WHERE company.name='Baeldung'" + " DELETE company");

Di sini kami memadamkan sebuah syarikat bernama Baeldung.

3.6. Pengikat Parameter

Dalam contoh di atas, kami mempunyai nilai parameter berkod keras yang bukan amalan terbaik. Nasib baik, Neo4j menyediakan kemudahan untuk mengikat pemboleh ubah untuk pertanyaan:

Map params = new HashMap(); params.put("name", "baeldung"); params.put("make", "tesla"); params.put("model", "modelS"); Result result = graphDb.execute("CREATE (baeldung:Company {name:$name}) " + "-[:owns]-> (tesla:Car {make: $make, model: $model})" + "RETURN baeldung, tesla", params);

4. Pemacu Java

Sejauh ini kami melihat berinteraksi dengan contoh Neo4j yang tersemat , namun, kemungkinan besar untuk pengeluaran, kami ingin menjalankan pelayan yang berdiri sendiri dan menyambungkannya melalui pemacu yang disediakan. Pertama, kita perlu menambahkan lagi kebergantungan dalam pom.xml maven kita :

 org.neo4j.driver neo4j-java-driver 1.6.2 

Anda boleh mengikuti pautan ini untuk memeriksa versi terkini pemacu ini.

Sekarang kita dapat membuat sambungan:

Driver driver = GraphDatabase.driver( "bolt://localhost:7687", AuthTokens.basic("neo4j", "12345"));

Kemudian, buat sesi:

Session session = driver.session();

Akhirnya, kami dapat menjalankan beberapa pertanyaan:

session.run("CREATE (baeldung:Company {name:\"Baeldung\"}) " + "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" + "RETURN baeldung, tesla");

Sebaik sahaja kita selesai dengan semua kerja kita, kita perlu menutup kedua sesi dan pemacu:

session.close(); driver.close();

5. Pemandu JDBC

It is also possible to interact with Neo4j via a JDBC driver. Yet another dependency for our pom.xml:

 org.neo4j neo4j-jdbc-driver 3.4.0 

You can follow this link to download the latest version of this driver.

Next, let's establish a JDBC connection:

Connection con = DriverManager.getConnection( "jdbc:neo4j:bolt://localhost/?user=neo4j,password=12345,scheme=basic");

Here con is a regular JDBC connection which can be used for creating and executing statements or prepared statements:

try (Statement stmt = con. stmt.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " + "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" + "RETURN baeldung, tesla") ResultSet rs = stmt.executeQuery( "MATCH (company:Company)-[:owns]-> (car:Car)" + "WHERE car.make='tesla' and car.model='modelX'" + "RETURN company.name"); while (rs.next()) { rs.getString("company.name"); } }

6. Object-Graph-Mapping

Object-Graph-Mapping or OGM is a technique which enables us to use our domain POJOs as entities in the Neo4j database. Let us examine how this works. The first step, as usually, we add new dependencies to our pom.xml:

 org.neo4j neo4j-ogm-core 3.1.2   org.neo4j neo4j-ogm-embedded-driver 3.1.2 

You can check the OGM Core Link and OGM Embedded Driver Link to check for the latest versions of these libraries.

Second, we annotate our POJO's with OGM annotations:

@NodeEntity public class Company { private Long id; private String name; @Relationship(type="owns") private Car car; } @NodeEntity public class Car { private Long id; private String make; @Relationship(direction = "INCOMING") private Company company; }

@NodeEntity informs Neo4j that this object will need to be represented by a node in the resulting graph. @Relationship communicates the need to create a relationship with a node representing the related type. In this case, a company owns a car.

Please note that Neo4j requires each entity to have a primary key, with a field named id being picked up by default. An alternatively named field could be used by annotating it with @Id @GeneratedValue.

Then, we need to create a configuration that will be used to bootstrap Neo4j‘s OGM. For simplicity, let us use an embedded in-memory only database:

Configuration conf = new Configuration.Builder().build();

After that, we initialize SessionFactory with the configuration we created and a package name in which our annotated POJO's reside:

SessionFactory factory = new SessionFactory(conf, "com.baeldung.graph");

Finally, we can create a Session and begin using it:

Session session = factory.openSession(); Car tesla = new Car("tesla", "modelS"); Company baeldung = new Company("baeldung"); baeldung.setCar(tesla); session.save(baeldung);

Here we initiated a session, created our POJO's and asked OGM session to persist them. Neo4j OGM runtime transparently converted objects to a set of Cypher queries which created appropriate nodes and edges in the database.

If this process seems familiar, that is because it is! That is precisely how JPA works, the only difference being whether object gets translated into rows that are persisted to an RDBMS, or a series of nodes and edges persisted to a graph database.

7. Conclusion

Artikel ini melihat beberapa asas pangkalan data berorientasikan grafik Neo4j.

Seperti biasa, kod dalam penulisan ini tersedia di Github.