Inleiding tot Apache Cayenne ORM

1. Overzicht

Apache Cayenne is een open-sourcebibliotheek, gedistribueerd onder de Apache-licentie, en biedt functies zoals een modelleertool, object-relationele mapping oftewel ORM voor lokale persistentieactiviteiten en externe services.

In de volgende secties zullen we zien hoe u met een MySQL-database kunt omgaan met Apache Cayenne ORM.

2. Maven afhankelijkheden

Om te beginnen hoeven we alleen de volgende afhankelijkheden toe te voegen om Apache Cayenne en MySQL-connector te openen, het JDBC-stuurprogramma samen om toegang te krijgen tot onze intro_cayenne database:

 org.apache.cayenne cayenne-server 4.0.M5 mysql mysql-connector-java 5.1.44 runtime 

Laten we de Cayenne-modelleerplug-in configureren die zal worden gebruikt voor het ontwerpen of instellen van ons toewijzingsbestand dat fungeert als een brug tussen het databaseschema en het Java-object:

 org.apache.cayenne.plugins maven-cayenne-modeler-plugin 4.0.M5 

In plaats van handmatig een XML-toewijzingsbestand te bouwen (zelden gemaakt), wordt aanbevolen om de modeler te gebruiken, een behoorlijk geavanceerd hulpmiddel dat bij de Cayenne-distributie wordt geleverd.

Het is beschikbaar om te downloaden uit dit archief, afhankelijk van uw besturingssysteem, of gebruik gewoon de platformonafhankelijke versie (JAR) die daarboven als een Maven-plug-in is meegeleverd.

De Maven Central-repository bevat de nieuwste versies van Apache Cayenne, zijn modeler en MySQL Connector.

Laten we vervolgens ons project bouwen met de mvn installeren en start de modeler GUI met het commando mvn cayenne-modeler: run om als output dit scherm te krijgen:

3. Installatie

Om Apache Cayenne de juiste lokale database te laten opzoeken, hoeven we alleen zijn configuratiebestand in te vullen met de juiste driver, URL en een gebruiker in het bestand cayenne-project.xml gelegen in de middelen directory:

Hier kunnen we zien dat:

  • De lokale database heeft een naam intro_cayenne
  • Als het nog niet is gemaakt, doet Cayenne het voor ons
  • We maken verbinding met de gebruikersnaam wortel en wachtwoord wortel (verander het volgens de gebruikers geregistreerd in uw databasebeheersysteem)

Intern is het de XMLPoolingDataSourceFactory verantwoordelijk voor het laden van JDBC-verbindingsinformatie uit een XML-bron die is gekoppeld aan de DataNodeDescriptor.

Houd er rekening mee dat deze parameters betrekking hebben op het databasebeheersysteem en een JDBC-stuurprogramma, omdat deze bibliotheek veel verschillende databases kan ondersteunen.

Elk van hen heeft een adapter beschikbaar in deze gedetailleerde lijst. Merk op dat de volledige documentatie voor versie 4.0 nog niet beschikbaar is, dus verwijzen we hier naar de vorige versie.

4. Mapping en databaseontwerp

4.1. Modellering

Laten we nu op de "Open project", navigeer naar de bronnenmap van het project en kies het bestand cayenne-project.xml, de modelleur zal dit laten zien:

Hier, we hebben de keuze om ofwel onze mappingstructuur te creëren op basis van een bestaande databaseof om handmatig verder te gaan. Dit artikel behandelt degene die de modeler en de bestaande database gebruikt om in Cayenne te komen en snel te weten hoe het werkt.

Laten we eens kijken naar onze intro_cayenne database met een een te veel relatie tussen twee tabellen, aangezien een auteur veel artikelen kan publiceren of er eigenaar van kan zijn:

  • auteur: id (PK) en naam
  • artikel: id (PK), titel, inhoud, en author_id (FK)

Laten we nu naar "Hulpmiddelen> Database-schema opnieuw ontwikkelen“, En we zullen al onze kaartconfiguraties automatisch laten vullen. Vul op het promptscherm de gegevensbronconfiguratie in die daar beschikbaar is in het cayenne-project.xml bestand en klik op doorgaan:

Op het volgende scherm moeten we "Gebruik Java primitieve typen" als volgt aanvinken:

We moeten er ook voor zorgen com.baeldung.apachecayenne.persistent als Java-pakket en sla het op; we zullen zien dat het XML-configuratiebestand is bijgewerkt voor zijn standaardPakket eigenschap die overeenkomt met het Java-pakket:

In elke ObjEntity we moeten het pakket voor subklassen specificeren zoals weergegeven in de volgende afbeelding en klikken op de "sparen" opnieuw pictogram:

Nu op "Extra> Klassen genereren" menu, selecteer 'Standaard persistente objecten”Als het type; en op de "Klassen" tab controleer alle klassen en klik op "Genereren".

Laten we teruggaan naar de broncode om te zien dat onze persistente objecten met succes zijn gegenereerd _Article.java en _Author.java.

Merk op dat al deze configuraties in het bestand worden opgeslagen datamap.map.xml ook gelegen in de middelen map.

4.2. Mapping-structuur

Het gegenereerde XML-toewijzingsbestand dat in de bronnenmap wordt weergegeven, gebruikt enkele unieke tags ten opzichte van Apache Cayenne:

  • DataNode () - het model van de database, de inhoud ervan alle informatie die nodig is om verbinding te maken met een database (de naam van de database, het stuurprogramma en de gebruikersgegevens)
  • Gegevenskaart () - het is een container van hardnekkige entiteiten met hun relaties
  • DbAttribute () - vertegenwoordigt een kolom in een databasetabel
  • DbEntity () - het model van een enkele databasetabel of -view, het kan DbAttributes en relaties hebben
  • ObjEntity () - het model van een enkele persistente Java-klasse; gemaakt van ObjAttributes die overeenkomen met entiteitsklasse-eigenschappen en ObjRelationships die eigenschappen zijn die het type van een andere entiteit hebben
  • Insluitbaar () - het model van een Java-klasse die fungeert als een eigenschap van een ObjEntity, maar overeenkomt met meerdere kolommen in de database
  • Procedure() - om de opgeslagen procedure in de database te registreren
  • Zoekopdracht () - het model van een query, gebruikt om de query in het configuratiebestand in kaart te brengen zonder te vergeten dat we het ook in de code kunnen doen

Hier zijn de volledige details.

5. Cayenne API

De enige resterende stap is om de Cayenne API te gebruiken om onze databasebewerkingen uit te voeren met behulp van gegenereerde klassen, wetende dat het subclassificeren van onze permanente klassen slechts een best practice is om het model later aan te passen.

5.1. Een object maken

Hier slaan we gewoon een Schrijver object en controleer later of er slechts één record van dit type in de database is:

@Test openbare leegte whenInsert_thenWeGetOneRecordInTheDatabase () {Auteur author = context.newObject (Author.class); author.setName ("Paul"); context.commitChanges (); lange records = ObjectSelect.dataRowQuery (Author.class) .selectCount (context); assertEquals (1, records); }

5.2. Een object lezen

Na het opslaan van een Schrijver, we kiezen het gewoon onder andere via een eenvoudige zoekopdracht door een bepaalde eigenschap:

@Test openbare leegte whenInsert_andQueryByFirstName_thenWeGetTheAuthor () {Author author = context.newObject (Author.class); author.setName ("Paul"); context.commitChanges (); Auteur verwachtAuthor = ObjectSelect.query (Author.class) .where (Author.NAME.eq ("Paul")) .selectOne (context); assertEquals ("Paul", verwachtAuthor.getName ()); }

5.3. Alle records van een klas ophalen

We gaan twee auteurs redden en een verzameling auteurobjecten ophalen om te controleren of er slechts deze twee zijn opgeslagen:

@Test openbare leegte whenInsert_andQueryAll_thenWeGetTwoAuthors () {Auteur firstAuthor = context.newObject (Author.class); firstAuthor.setName ("Paul"); Auteur secondAuthor = context.newObject (Author.class); secondAuthor.setName ("Ludovic"); context.commitChanges (); Lijst auteurs = ObjectSelect .query (Author.class) .select (context); assertEquals (2, auteurs.size ()); }

5.4. Een object bijwerken

Het updateproces is ook eenvoudig, maar we moeten eerst het gewenste object hebben voordat we de eigenschappen ervan wijzigen en toepassen op de database:

@Test openbare leegte whenUpdating_thenWeGetAnUpatedeAuthor () {Auteur author = context.newObject (Author.class); author.setName ("Paul"); context.commitChanges (); Auteur verwachtAuthor = ObjectSelect.query (Author.class) .where (Author.NAME.eq ("Paul")) .selectOne (context); verwachteAuthor.setName ("Garcia"); context.commitChanges (); assertEquals (author.getName (), verwachteAuthor.getName ()); }

5.5. Een object bevestigen

We kunnen een artikel aan een auteur toewijzen:

@Test openbare leegte whenAttachingToArticle_thenTheRelationIsMade () {Auteur auteur = context.newObject (Author.class); author.setName ("Paul"); Article article = context.newObject (Article.class); article.setTitle ("Mijn posttitel"); article.setContent ("De inhoud"); article.setAuthor (auteur); context.commitChanges (); Auteur verwachtAuthor = ObjectSelect.query (Author.class) .where (Author.NAME.eq ("Smith")) .selectOne (context); Artikel verwachteartikel = (verwachteAuthor.getArticles ()). Get (0); assertEquals (article.getTitle (), verwachtArticle.getTitle ()); }

5.6. Een object verwijderen

Het verwijderen van een opgeslagen object verwijdert het volledig uit de database, daarna zullen we zien nul als resultaat van de vraag:

@Test openbare leegte whenDeleting_thenWeLostHisDetails () {Auteur author = context.newObject (Author.class); author.setName ("Paul"); context.commitChanges (); Auteur opgeslagenAuthor = ObjectSelect.query (Author.class) .where (Author.NAME.eq ("Paul")) .selectOne (context); if (savedAuthor! = null) {context.deleteObjects (auteur); context.commitChanges (); } Auteur verwachtAuthor = ObjectSelect.query (Author.class) .where (Author.NAME.eq ("Paul")) .selectOne (context); assertNull (verwachteAuthor); }

5.7. Verwijder alle records van een klas

Het is ook mogelijk om alle records van een tabel te verwijderen metSQLTemplate, hier doen we dit na elke testmethode om altijd een lege database te hebben voordat elke test wordt gestart:

@After public void deleteAllRecords () {SQLTemplate deleteArticles = nieuwe SQLTemplate (Article.class, "delete from article"); SQLTemplate deleteAuthors = nieuwe SQLTemplate (Author.class, "delete from author"); context.performGenericQuery (deleteArticles); context.performGenericQuery (deleteAuthors); }

6. Conclusie

In deze tutorial hebben we ons gericht op het gebruik van Apache Cayenne ORM om eenvoudig te demonstreren hoe CRUD-bewerkingen kunnen worden uitgevoerd met een een te veel relatie.

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