Inleiding tot de OrientDB Java API's

1. Overzicht

OrientDB is een open source Multi-Model NoSQL-databasetechnologie die is ontworpen om te werken met de Graph-, Document-, Key-Value-, GeoSpatial- en Reactive-modellen tijdens het beheren van query's met SQL-syntaxis.

In dit artikel behandelen we de installatie en gebruiken we de OrientDB Java API's.

2. Installatie

Ten eerste moeten we het binaire pakket installeren.

Laten we de laatste stabiele versie van OrientDB downloaden (2.2.x op het moment dat dit artikel werd geschreven).

Ten tweede moeten we het uitpakken en de inhoud naar een handige map verplaatsen (met ORIENTDB_HOME). Zorg ervoor dat u het bak map naar de omgevingsvariabelen voor eenvoudig gebruik via de opdrachtregel.

Ten slotte moeten we het orientdb.sh bestand in $ ORIENTDB_HOME / bin door de locatie in te vullen (ORIENTDB_HOME) van OrientDB-directory in de plaats van ORIENTDB_DIR en ook de systeemgebruiker die we zouden willen gebruiken in plaats van USER_YOU_WANT_ORIENTDB_RUN_WITH.

Nu hebben we een volledig werkende OrientDB. We kunnen de orientdb.sh script met opties:

  • begin: om de server te starten
  • toestand : om de status te controleren

  • hou op : om de server te stoppen

Houd er rekening mee dat beide begin en hou op acties vereisen het gebruikerswachtwoord (het wachtwoord dat we hebben ingesteld in het orientdb.sh het dossier).

Zodra de server is gestart, bezet deze poort 2480. Daarom hebben we er lokaal toegang toe URL:

Meer informatie over handmatige installatie vindt u hier.

Opmerking: OrientDB vereist Java-versie 1.7 of hoger.

Eerdere versies zijn hier beschikbaar.

3. OrientDB Java API's instellen

Met de OrientDB kunnen Java-ontwikkelaars met drie verschillende API's werken, zoals:

  • Graph API - grafische databases
  • Document API - documentgeoriënteerde databases
  • Object API - objecten die rechtstreeks zijn gebonden aan OrientDB Document

We kunnen al deze typen binnen een enkele codebase gebruiken door OrientDB te integreren en te gebruiken.

Laten we eens kijken naar enkele beschikbare potten die we kunnen opnemen in het klassenpad van het project:

  • orientdb-core - *. jar: brengt de kernbibliotheek
  • blauwdrukken-core - *. jar: om de kerncomponenten van de adapters te brengen
  • orientdb-graphdb - *. jar: geeft de Graph-database-API
  • orientdb-object - *. jar: levert de Object-database-API
  • orientdb-distributed - *. jar: biedt de gedistribueerde database-plug-in om met een servercluster te werken
  • orientdb-tools - *. jar: overhandigt het console-commando
  • orientdb-client - *. jar: biedt de externe client
  • orientdb-enterprise - *. jar: schakelt de protocol- en netwerkklassen in die door de client en server worden gedeeld

De twee laatste zijn alleen vereist als we onze gegevens op een externe server beheren.

Laten we beginnen met een Maven-project en de volgende afhankelijkheden gebruiken:

 com.orientechnologies orientdb-core 2.2.31 com.orientechnologies orientdb-graphdb 2.2.31 com.orientechnologies orientdb-object 2.2.31 com.tinkerpop.blueprints blauwdrukken-core 2.6.0 

Controleer de Maven Central-repository voor de nieuwste versies van OrientDB's Core, GraphDB, Object API's en de Blueprints-Core.

4. Gebruik

De OrientDB gebruikt de TinkerPop Blueprints-implementatie voor het werken met grafieken.

TinkerPop is een Graph Computing Framework dat vele manieren biedt om grafische databases te bouwen, waarbij elk van hen zijn eigen implementaties heeft:

  • Blauwdrukken
  • Buizen
  • Gremlin
  • Rexster
  • Zeiluitvoering

Bovendien maakt OrientDB het mogelijk om met de drie soorten schema's te werken, ongeacht het type API:

  • Schema-Full - de strikte modus is ingeschakeld, dus alle velden worden gespecificeerd tijdens het maken van een klasse
  • Schema-less - klassen worden gemaakt zonder specifieke eigenschap, dus we kunnen ze toevoegen zoals we willen; het is de standaardmodus
  • Schema-hybride - het is de mix van schema-volledig en schema-loos waar we een klasse kunnen maken met vooraf gedefinieerde velden, maar het record andere aangepaste velden laten definiëren

4.1. Graph API

Aangezien dit een op grafieken gebaseerde database is, worden gegevens weergegeven als een netwerk met hoekpunten (knooppunten) die onderling zijn verbonden door randen (bogen).

Laten we als eerste stap de gebruikersinterface gebruiken om een ​​Graph-database te maken met de naam BaeldungDB met een gebruiker beheerder en wachtwoord beheerder.

Zoals we in de volgende afbeelding zien, is de grafiek is geselecteerd als databasetype, dus bijgevolg zijn de gegevens ervan toegankelijk in het GRAFIEK Tab:

Laten we nu verbinding maken met de gewenste database, wetende dat de ORIENTDB_HOME is een omgevingsvariabele die overeenkomt met de installatiemap van OrientDB:

@BeforeClass openbare statische leegte setup () {String orientDBFolder = System.getenv ("ORIENTDB_HOME"); graph = new OrientGraphNoTx ("plocal:" + orientDBFolder + "/ databases / BaeldungDB", "admin", "admin"); }

Laten we het Artikel, Schrijver, en Editor klassen - terwijl ze laten zien hoe validatie aan hun velden kan worden toegevoegd:

@BeforeClass openbare statische leegte init () {graph.createVertexType ("Artikel"); OrientVertexType writerType = graph.createVertexType ("Writer"); writerType.setStrictMode (true); writerType.createProperty ("voornaam", OType.STRING); // ... OrientVertexType authorType = graph.createVertexType ("Auteur", "Schrijver"); authorType.createProperty ("level", OType.INTEGER) .setMax ("3"); OrientVertexType editorType = graph.createVertexType ("Editor", "Writer"); editorType.createProperty ("level", OType.INTEGER) .setMin ("3"); Vertex vEditor = graph.addVertex ("class: Editor"); vEditor.setProperty ("voornaam", "Maxim"); // ... Vertex vAuthor = graph.addVertex ("class: Author"); vAuthor.setProperty ("voornaam", "Jerome"); // ... Vertex vArticle = graph.addVertex ("class: Article"); vArticle.setProperty ("titel", "Inleiding tot ..."); // ... graph.addEdge (null, vAuthor, vEditor, "has"); graph.addEdge (null, vAuthor, vArticle, "schreef"); }

In het bovenstaande codefragment hebben we een eenvoudige weergave gemaakt van onze eenvoudige database waarin:

  • Artikel is de schema-loze klasse die artikelen bevat
  • auteur is een superklasse vol schema die de nodige informatie over de schrijver bevat
  • auteur is een subtype van Schrijver dat bevat zijn details
  • Editor is een schema-loos subtype van auteur dat de details van de editor bevat
  • achternaam veld is niet ingevuld in de opgeslagen auteur, maar verschijnt nog steeds in de volgende grafiek
  • we hebben een relatie tussen alle klassen: een Schrijver kan schrijven Artikel en moet een Editor
  • Vertex vertegenwoordigt een entiteit met enkele velden
  • Rand is een entiteit die twee verbindt Hoekpunten

Houd er rekening mee dat door te proberen een andere eigenschap toe te voegen aan een object van een volledige klasse, we eindigen met de OValidationException.

Nadat we met OrientDB studio verbinding hebben gemaakt met onze database, zien we de grafische weergave van onze gegevens:

Laten we eens kijken hoe we het aantal records (hoekpunten) van de database kunnen krijgen:

lange grootte = graph.countVertices ();

Laten we nu het aantal laten zien Schrijver (auteur en redacteur) voorwerpen:

@Test openbare leegte gegevenBaeldungDB_checkWeHaveTwoWriters () {long size = graph.countVertices ("Writer"); assertEquals (2, grootte); }

In de volgende stap kunnen we alles vinden auteur‘S gegevens, met behulp van de volgende verklaring:

Iterable writers = graph.getVerticesOfClass ("Writer");

Laten we tot slot alles opvragen Editor‘S met niveau 7; hier hebben we er maar één die overeenkomt met:

@Test openbare leegte gegevenBaeldungDB_getEditorWithLevelSeven () {String onlyEditor = ""; voor (Vertex v: graph.getVertices ("Editor.level", 7)) {onlyEditor = v.getProperty ("firstName"). toString (); } assertEquals ("Maxim", onlyEditor); }

De klassenaam wordt altijd gespecificeerd om bij het aanvragen naar een specifiek punt te zoeken. We kunnen hier meer informatie vinden.

4.2. Document API

De volgende optie is om het documentmodel van OrientDB te gebruiken. Dit legt gegevensmanipulatie bloot via een eenvoudig record met informatie die is opgeslagen in velden waar het type tekst, afbeelding of een binaire vorm kan zijn.

Laten we de gebruikersinterface opnieuw gebruiken om een ​​database met de naam te maken BaeldungDBTwee, maar nu met een document als type:

Opmerking: op dezelfde manier kan deze API ook worden gebruikt in schema-full, schema-loze of schema-hybride modus.

De databaseverbinding blijft eenvoudig omdat we alleen een ODatabaseDocumentTx object, geef de database-URL en de gegevens van de databasegebruiker op:

@BeforeClass openbare statische leegte setup () {String orientDBFolder = System.getenv ("ORIENTDB_HOME"); db = nieuwe ODatabaseDocumentTx ("plocal:" + orientDBFolder + "/ databases / BaeldungDBTwo") .open ("admin", "admin"); }

Laten we beginnen met het opslaan van een eenvoudig document dat een Schrijver informatie.

Hier kunnen we zien dat de klas automatisch is aangemaakt:

@Test openbare leegte gegevenDB_whenSavingDocument_thenClassIsAutoCreated () {ODocument doc = nieuw ODocument ("Auteur"); doc.field ("naam", "Paul"); doc.save (); assertEquals ("Auteur", doc.getSchemaClass (). getName ()); }

Dienovereenkomstig, om het aantal te tellen Auteurs, we kunnen gebruiken:

long size = db.countClass ("Auteur");

Laten we documenten opnieuw opvragen met behulp van een veldwaarde om te zoeken naar de Schrijver‘S objecten met niveau 7:

@Test openbare leegte gegevenDB_whenSavingAuthors_thenWeGetOnesWithLevelSeven () {voor (ODocument auteur: db.browseClass ("Auteur")) author.delete (); ODocument authorOne = nieuw ODocument ("Auteur"); authorOne.field ("firstName", "Leo"); authorOne.field ("niveau", 7); authorOne.save (); ODocument authorTwo = nieuw ODocument ("Auteur"); authorTwo.field ("voornaam", "Lucien"); authorTwo.field ("niveau", 9); authorTwo.save (); Lijstresultaat = db.query (nieuwe OSQLSynchQuery ("select * from Author where level = 7")); assertEquals (1, result.size ()); }

Evenzo om alle records van Schrijver klasse, kunnen we gebruiken:

voor (ODocument auteur: db.browseClass ("Auteur")) {author.delete (); }

Op de OrientDB studio's BLADEREN Tab we kunnen een vraag stellen om al onze Schrijver's objecten:

4.3. Object-API

OrientDB heeft niet het objecttype database. De Object-API vertrouwt dus op een documentdatabase.

In het type Object API blijven alle andere concepten hetzelfde met slechts één toevoeging - bindend aan POJO.

Laten we beginnen door verbinding te maken met het BaeldungDBThree door de OObjectDatabaseTx klasse:

@BeforeClass openbare statische leegte setup () {String orientDBFolder = System.getenv ("ORIENTDB_HOME"); db = nieuwe OObjectDatabaseTx ("plocal:" + orientDBFolder + "/ databases / BaeldungDBThree") .open ("admin", "admin"); }

Vervolgens door aan te nemen dat de Schrijver is de POJO die wordt gebruikt om een Schrijver gegevens, we moeten deze registreren:

db.getEntityManager (). registerEntityClass (Author.class);

Schrijver heeft getters en setters voor de volgende velden:

  • Voornaam
  • achternaam
  • niveau

Laten we een Schrijver met meerregelige instructies als we een no-arg constructor hebben erkend:

Auteur author = db.newInstance (Author.class); author.setFirstName ("Luke"); author.setLastName ("Sky"); author.setLevel (9); db.save (auteur);

Aan de andere kant, als we een andere constructor hebben die de Voornaam, achternaam, en niveau van de Schrijver respectievelijk de instantiatie is slechts één regel:

Auteur author = db.newInstance (Author.class, "Luke", "Sky", 9); db.save (auteur);

De volgende regels worden gebruikt om door alle records van de klasse Author te bladeren en deze te verwijderen:

voor (Auteur auteur: db.browseClass (Auteur.class)) {db.delete (auteur); }

Om alle auteurs te tellen, hoeven we alleen de klasse en de database-instantie op te geven zonder een SQL-query te hoeven schrijven:

lange auteursCount = db.countClass (Author.class);

Op dezelfde manier ondervragen we auteurs met niveau 7 zoals zo:

@Test openbare leegte gegevenDB_whenSavingAuthors_thenWeGetOnesWithLevelSeven () {voor (Auteur auteur: db.browseClass (Author.class)) {db.delete (auteur); } Author authorOne = db.newInstance (Author.class, "Leo", "Marta", 7); db.save (authorOne); Auteur authorTwo = db.newInstance (Author.class, "Lucien", "Aurelien", 9); db.save (authorTwo); Lijstresultaat = db.query (nieuwe OSQLSynchQuery ("select * from Author where level = 7")); assertEquals (1, result.size ()); }

Ten slotte is dit de officiële gids die enkele geavanceerde Object API-toepassingen introduceert.

5. Conclusie

In dit artikel hebben we gezien hoe we OrientDB kunnen gebruiken als een databasebeheersysteem met zijn Java API's. We hebben ook geleerd hoe we validatie aan de velden kunnen toevoegen en enkele eenvoudige vragen kunnen schrijven.

Zoals altijd is de broncode voor dit artikel te vinden op GitHub.


$config[zx-auto] not found$config[zx-overlay] not found