Panduan untuk Neo4J dengan Java

1. Perkenalan

Artikel ini tentang Neo4j - salah satu database grafik paling matang dan berfitur lengkap yang ada di pasaran saat ini. Database grafik mendekati tugas pemodelan data dengan pandangan bahwa banyak hal dalam kehidupan dapat direpresentasikan sebagai kumpulan node (V) dan koneksi di antara mereka yang disebut edge (E).

2. Neo4j yang tertanam

Cara termudah untuk memulai dengan Neo4j adalah dengan menggunakan versi tertanam di mana Neo4j berjalan di JVM yang sama dengan aplikasi Anda.

Pertama, kita perlu menambahkan dependensi Maven:

 org.neo4j neo4j 3.4.6 

Anda dapat memeriksa tautan ini untuk mengunduh versi terbaru.

Selanjutnya, mari buat pabrik:

GraphDatabaseFactory graphDbFactory = new GraphDatabaseFactory();

Akhirnya, kami membuat database tertanam:

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

Sekarang aksi nyata bisa dimulai! Pertama, kita perlu membuat beberapa node di grafik kita dan untuk itu, kita perlu memulai transaksi karena Neo4j akan menolak operasi destruktif apa pun kecuali transaksi telah dimulai:

graphDb.beginTx();

Setelah kami memiliki transaksi yang sedang berlangsung, kami dapat mulai menambahkan node:

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 menambahkan node Car dengan properti make dan model serta node Person dengan properti firstName dan lastName

Sekarang kita bisa menambahkan hubungan:

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

Pernyataan di atas menambahkan tepi yang menghubungkan dua node dengan label pemilik . Kami dapat memverifikasi hubungan ini dengan menjalankan kueri yang ditulis dalam bahasa Cypher Neo4j yang kuat :

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

Di sini kami meminta untuk menemukan pemilik mobil untuk setiap mobil yang mereknya tesla dan mengembalikan nama depan dan nama belakangnya kepada kami. Tidak mengherankan, ini mengembalikan: {p.firstName = baeldung, p.lastName = baeldung}

3. Bahasa Query Cypher

Neo4j menyediakan bahasa kueri yang sangat kuat dan cukup intuitif yang mendukung berbagai fitur yang diharapkan dari database. Mari kita periksa bagaimana kita dapat mencapai standar membuat, mengambil, memperbarui dan menghapus tugas.

3.1. Buat Node

Buat kata kunci dapat digunakan untuk membuat node dan hubungan.

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

Di sini kami telah membuat perusahaan dengan satu nama properti . Definisi node ditandai dengan tanda kurung dan propertinya diapit oleh kurung kurawal. Dalam hal ini, self adalah alias untuk node dan Perusahaan adalah label node.

3.2. Buat Hubungan

Dimungkinkan untuk membuat node dan hubungan ke node itu semua dalam satu kueri:

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 membangun hubungan kepemilikan di antara mereka. Membuat hubungan ke node yang sudah ada, tentu saja, juga memungkinkan.

3.3. Ambil Data

Kata kunci MATCH digunakan untuk menemukan data yang dikombinasikan dengan RETURN untuk mengontrol titik data mana yang dikembalikan. The MANA klausa dapat dimanfaatkan untuk menyaring hanya mereka node yang memiliki sifat-sifat yang kita inginkan.

Mari kita cari tahu nama perusahaan 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. Perbarui Node

Kata kunci SET dapat digunakan untuk memperbarui properti atau label node. Mari kita tambahkan jarak tempuh ke tesla kita:

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 properti baru yang disebut milage , mengubah label menjadi Mobil dan Elektro, dan terakhir, kami menghapus properti model sekaligus.

3.5. Hapus Node

DELETE kata kunci dapat digunakan untuk penghapusan permanen node atau hubungan dari grafik:

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

Di sini kami menghapus perusahaan bernama Baeldung.

3.6. Pengikatan Parameter

Dalam contoh di atas, kami memiliki nilai parameter hard-code yang bukan merupakan praktik terbaik. Untungnya, Neo4j menyediakan fasilitas untuk mengikat variabel ke kueri:

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. Driver Java

Sejauh ini kami telah melihat interaksi dengan instans Neo4j yang disematkan , namun, kemungkinan besar untuk produksi, kami ingin menjalankan server yang berdiri sendiri dan menghubungkannya melalui driver yang disediakan. Pertama, kita perlu menambahkan dependensi lain di maven pom.xml kita :

 org.neo4j.driver neo4j-java-driver 1.6.2 

Anda dapat mengikuti tautan ini untuk memeriksa versi terbaru dari driver ini.

Sekarang kita dapat membuat koneksi:

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

Kemudian, buat sesi:

Session session = driver.session();

Akhirnya, kami dapat menjalankan beberapa kueri:

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

Setelah kita selesai dengan semua pekerjaan kita, kita perlu menutup sesi dan pengemudi:

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

5. Pengemudi 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 membahas beberapa dasar database berorientasi grafik Neo4j.

Seperti biasa, kode dalam artikel ini tersedia di Github.