Hur man använder Spring Boot med MongoDB

Spring Boot är ett Java-baserat ramverk med öppen källkod för att skapa mikrotjänster, vilket gör att utvecklare kan distribuera och utveckla tjänster oberoende. Varje tjänst som körs har sin process, och uppnår därmed den lätta modellen som stöder affärsapplikationer. Mikrotjänster har flera fördelar:enkel skalbarhet, minimal konfiguration, kortare produktionstid, containerkompatibilitet och enkel utveckling.

Spring boot ger en bra plattform för utvecklare att bygga fristående och produktionsklara fjäderapplikationer som du bara kan köra; sålunda kan man komma igång med minimala konfigurationer utan att behöva en hel fjäderkonfiguration.

Till exempel är hantering av beroendehantering komplex för stora projekt; Spring Boot löser alltså denna svårighet genom att tillhandahålla en uppsättning beroenden för utvecklarens bekvämlighet. Spring Boot-applikationen skannar alla bönor och paketdeklarationer när applikationen initieras; Dessutom inkluderar Spring Boot-applikationskommentaren komponentskanning, automatisk konfiguration och fjäderstartskonfiguration.

Funktioner hos Spring Boot

Nedan är några av standardfunktionerna för fjädersko:

1. Den konfigurerar automatiskt Spring- och tredjepartsbiblioteken när det är möjligt
2. Det ger uppfattningsvis "starter"-beroenden för att förenkla din byggkonfiguration
3. Den har inga krav på XML-konfiguration och ingen kodgenerering
4. Dessutom erbjuder den produktionsklara funktioner som externiserade konfigurationsmått och hälsokontroller
5. Den har en inbäddad Tomcat, Undertow direkt eller Jetty; så det finns inget behov av att distribuera WAR-filer
6. Det skapar också fristående Spring-applikationer

Fördelar med Spring Boot för utvecklare

1. Det ökar produktiviteten
2. Det gör det enkelt att utveckla och förstå vårens applikationer
3. Det minskar tidsutvecklingen.

 Mål för vårkängan

Den är utformad för att:

1. Utveckla produktionsfärdiga fjäderapplikationer på ett enklare sätt
2. Undvik komplex XML-konfiguration på våren
3. Minska utvecklingstiden och kör applikationen självständigt
4. Erbjud ett enklare sätt att komma igång med applikationen.

Spring Boot är mer att föredra på grund av funktionerna och fördelarna som den ger som:

1. Tillhandahållande av en kraftfull batchbearbetning och hantering av REST-slutpunkter
2. Tillhandahållande av ett mer flexibelt sätt att konfigurera datatransaktioner, Java Beans j och XML-konfigurationer.
3. Erbjuder anteckningsbaserade på vårapplikationer
4. Förenklar beroendehantering, den inkluderar en inbäddad Servlet Container
5. Inga manuella konfigurationer behövs eftersom allt i Spring Boot är automatiskt konfigurerat

MongoDB är ett källtillgängligt, plattformsoberoende, dokumentorienterat databasprogram. Det är en dokumentdatabas som ger hög skalbarhet och flexibilitet för program. Dessutom erbjuder det användarna snabba frågor och indexering, vilket i det långa loppet ökar dess prestanda.

MongoDB är klassificerat som ett NoSQL-databasprogram och använder JSON-liknande dokument med valfria och flexibla scheman. Denna databas har utvecklats av MongoDB Inc., ett amerikanskt företag som utvecklar och tillhandahåller kommersiellt stöd för den källtillgängliga databasen. MongoDB är licensierad under Server-Side Public License (SSPL).

MongoDB har haft en kontinuerlig förbättring av sina funktioner på grund av pågående versionsutveckling till exempel;

Snabba och enkla fristående appar kan skapas med hjälp av Spring Boot (som vi kommer att se senare). Som ett resultat av sin enkla användning har MongoDB blivit den mest populära NoSQL-databasen. Snabb, säker, pålitlig och behöver minimal utvecklingstid kan skapas genom att kombinera Spring Boot och MongoDB.

Den här artikeln visar hur du använder Spring Data MongoDB API för att kombinera Spring Boot med MongoDB.

Hur man använder Spring Boot med MongoDB

Spring Boot är ett mikrotjänstbaserat webbramverk som är automatiskt konfigurerat och kan tillhandahålla inbyggda säkerhets- och databasåtkomstfunktioner. Således kan Spring boot snabbt skapa en fristående applikation utan konfigurationsändringar. Å andra sidan är MongoDB den mest populära NoSQL-databasen eftersom den enkelt kan lagra och hämta data. Att kombinera Spring Boot och MongoDB resulterar i säkra, snabba, pålitliga applikationer som kräver minimal utvecklingstid.

Spring Boot skapar snabba produktionsfärdiga applikationer. MongoDB och Spring Boot interagerar med Mongo Template-klassen och Mongo Repository-gränssnittet.

• Mongo-mall — den implementerar en uppsättning färdiga att använda API:er. Ett bra val för operationer som uppdateringar, bland annat; dessutom erbjuder Mongo Template mer förfinad kontroll över anpassade frågor.
• Mongo Repository används för grundläggande frågor som involverar många dokumentfält som att visa dokument och skapa data.

Spring Boot MongoDB-konfiguration som använder båda metoderna kräver bara några rader kod.

Spring Boot är ett applikationsramverk för Java-webbapplikationer baserat på MVC-ramverket (Model-View-Controller). Dess beroendeinjektion hanterar funktioner som databassäkerhet, åtkomst och initiering, vilket gör att utvecklare kan fokusera på affärslogiken. Det är också byggt ovanpå Spring-ramverket, främst för REST API:er och kräver väldigt få konfigurationer. Den har fyra lager:

Presentationslagret — Vydelen av MVC-ramverket hanterar front-end.

Affärslagret är kontrollenheten där all affärslogik och validering görs.

Peristenslager — Detta lager översätter affärsobjekten till databasobjekt.

Databaslager — Själva CRUD-operationerna (Skapa, Läs, Uppdatera, Ta bort).

MongoDB är en snabb databas som kan hantera enorma mängder organiserad och ostrukturerad data, vilket gör den idealisk för webbapplikationer. MongoDB lagrar data som binära JSON-objekt, vilket förenklar datahämtning. Spring-ramverket innehåller robusta kopplingar som möjliggör effektiv databasoperation med MongoDB.

Vi är enbart bekymrade över lagren Persistence och Database i denna Spring Boot med MongoDB-exempelhandledning. Vi kommer att köra vår mjukvara genom en integrerad utvecklingsmiljö (IDE) för att bibehålla en stark tonvikt på CRUD-verksamhet. För att ansluta Spring Boot och MongoDB lägger vi till Spring Boot MongoDB-konfigurationer.

Vad vi kommer att konstruera i det här exemplet

Låt oss utveckla en fiktiv användares inköpslista. Vi kommer att utföra följande procedurer:

1. Vi definierar en livsmedelsvara Plain Old Java Object (POJO) med ett ID, ett namn, en kvantitet och en kategori i vår vårapplikation.
2. Därefter utför vi skapande, läser, uppdaterar och tar bort (CRUD) åtgärder via MongoRepositorys offentliga gränssnitt.
3. Slutligen visar vi en annan metod för att modifiera dokument genom att använda klassen MongoTemplate.

Förutsättningar

Vi kräver:

• Cluster MongoDB Atlas (om du inte redan har ett konto, registrera dig gratis innan du går vidare till nästa fas).
• Vårinitializr
• Java 1.8
• Maven (installera Maven genom att gå till "Hjälp -> sedan Installera ny programvara" i Eclipse).
• En integrerad utvecklingsmiljö (IDE) kommer att importera de väsentliga biblioteken och beroenden. Eclipse kommer att användas för denna projektillustration.

För att börja, skapa ett Spring Boot-projekt med följande inställningar med Spring Initializr:

Välj Maven Project med Java (8) som programmeringsspråk och Spring Boot 2.5.3 som version. Lägg dessutom till Spring Web och Spring Data MongoDB-beroenden. Spring Web integrerar Apache Tomcat-servern, Spring MVC och REST i din applikation, för att centralisera hanteringen av alla vanliga beroenden.

Vi använder Spring Data MongoDB-beroendet för att komma åt data från vårt MongoDB Atlas-kluster i den här applikationen.

Ange metadata för projektet (som illustreras ovan) och välj alternativet JAR. Spring Initializr hanterar filskapandet av pom.xml medan Maven laddar ner de nödvändiga beroendena via pom.xml.

Detta slutför våra förberedelser för inställningarna. Efter det kan vi klicka på knappen Generera för att generera alla filer som krävs för att bootstrap Spring Boot-projektet. Efter det börjar webbläsaren ladda ner en ZIP-fil automatiskt.

Efter att ha laddat ner ZIP-filen, packa upp projektet. Öppna projektet från IDE. Du kan se ett exempel på en projektstruktur som liknar denna:

Som vi kan se är beroenden vi lagt till inkluderade i pom.xml-filen som artifactId:

Det är dags att fylla underkatalogen src/main/java med innehåll.

Implementering av MongoDB-modellen

Klassen POJO eller GroceryItem fungerar som vår modell här.

Skapa ett paket med namnet "com.example.mdbspringboot.model" och inkludera klassen GroceryItem.java i det.

Anteckningen @Document används för att specificera samlingsnamnet som modellen kommer att använda. MongoDB kommer att skapa samlingen om den inte redan finns.

Vi kan generera getters och setters för den här koden genom att använda alternativet Eclipse Source -> Generate Getters and Setters. Använd först @Id-anteckningen för att ange primärnyckeln _id för MongoDB-dokumentet. MongoDB kommer automatiskt att producera ett _id-fält när dokumentet skapas om vi inte anger något.

Implementering av MongoDB API i Spring Boot

Förvaret är där API:et implementeras. Den fungerar som en brygga mellan databasen och modellen och ger tillgång till alla CRUD-aktiviteter.

Skapa ett paket med namnet "com.example.mdbspringboot.repository" för att innehålla alla repository-filer.

Vi skapar ett publikt gränssnitt för ItemRepository som utökar MongoRepository-gränssnittet.

Det första tillvägagångssättet, findItemByName, kräver ett frågeargument som anger fältet som frågan ska filtreras på. Detta specificeras med anteckningen @Query. Den andra tekniken utnyttjar kategorifältet för att hämta alla objekt som tillhör en specifik kategori. Vi vill bara ha namn och nummer på fältet som projiceras i frågesvaret; därför sätter vi dessa fält till 1. Vi använder metoden count() igen i dess nuvarande tillstånd.

Exempel på MongoDB med Spring Boot CRUD

Vi är nu redo att utveckla vår vårapplikation och testa metoderna.

För att länka till MongoDB Atlas definierar vi anslutningssträngen i src/main/resources-mappens application.properties-fil. Klustrets anslutningssträng kan nås i Atlas UI. Ingen annan fil krävs för att inkludera anslutningsrelaterad kod. Spring Boot hanterar databasanslutningen å våra vägnar.

Dessutom anger vi databasnamnet här – MongoDB skapar ett om det inte finns.

Vi använder inte kontrollen eller vyn i detta Spring Boot MongoDB-exempel. Istället använder vi en CommandLineRunner för att se utdata på konsolen.

Skapa huvudklassen MdbSpringBootApplication.java i rotpaketet com.example.mdbspringboot:

För att köra vårapplikationen använder vår klass MdbSpringBootApplication CommandLineRunner-gränssnittet. ItemRepository är Autowired, vilket innebär att Spring kommer att upptäcka det automatiskt. @SpringBootApplication-kommentaren används för att initiera applikationskontexten. Dessutom aktiverar vi Mongo Repositories med @EnableMongoRepositories. Vårt projekts struktur bör nu likna följande:

Låt oss nu lägga till förvarsoperationerna till huvudklassen, som kommer att användas för CRUD-operationer:

Skapa en MongoDB Spring Boot-operation

Vi kommer att använda spara-funktionen för att skapa nya dokument. Vi kan komma åt sparmetoden via klassen SimpleMongoRepository, som använder MongoRepository-protokollet. Vårt ItemRepository-gränssnitt utökar MongoRepositorys ItemRepository-gränssnitt.

Sparningsmetoden accepterar en parameter av typen GroceryItem. Det här avsnittet kommer att bygga fem matvaror (dokument) och sedan använda sparafunktionen för att lagra dem i MongoDB.

Spring Boot MongoDB läsoperationer

Vi genomför fyra distinkta läsoperationer i denna applikation:

Använd funktionen findAll() för att hämta alla dokument (matvaror).

Funktionen findItemByName returnerar ett enstaka objekt (dokument) baserat på dess namnfält.

Hämta en lista över objekt organiserade efter kategori.

Beräkna det totala antalet objekt.

Vi kan designa en hjälpfunktion för att formatera resultatet av läsoperationer:

MongoDB Spring Boot-uppdatering

Anta att vi ändrar oss och föredrar termen "munchies" framför "snacks" på vår inköpslista. Vi skulle behöva uppdatera alla dokument som innehåller kategorin "snacks". För att åstadkomma detta måste vi först hämta alla papper som tillhör kategorin "snacks", ändra kategorin till "munchies" och sedan spara alla dokument.

MongoDB Spring Boot borttagningsåtgärd

Istället för att ändra en kategori eller vara, kanske vi vill ta bort en matvara från vår lista. Genom att använda den fördefinierade deleteById-funktionen kan vi ta bort matvaran med ett specifikt ID.

Vi skulle kunna använda groceryItemRepo.deleteAll(); funktion för att ta bort alla objekt. Att ta bort alla dokument i samlingen kommer inte att radera dem.

Sammanställning av CRUD-operationerna

Efter det kommer vi att implementera CommandLineRunner. För att anropa de föregående metoderna, använd metoden run():

System.out-satserna används för att förbättra utseendet på utdata.

När programvaran körs förväntas följande utdata:

MongoDB Spring Boots uppdateringsfunktion i kombination med MongoTemplate

Dessutom kan vi använda MongoTemplate-klassen för att utföra uppdateringsåtgärder på ett specifikt fält. Det inkluderar org.springframework.data.mongodb.core.query-paketets standardfunktionalitet. Vi behöver inte skriva en stor mängd kod, och uppdateringen kan utföras med en enda databasfråga. MongoTemplate kan också användas för mer komplicerade processer såsom aggregering (som inte omfattas av denna guide).

Ett anpassat arkiv måste skapas innan du använder en klass som heter MongoTemplate. Det är här frågan för uppdateringen kommer att byggas.

Tillåt mig att demonstrera hur man konstruerar en metod som uppdaterar kvantiteten av en stormarknadsvara.

Konstruera ett gränssnitt CustomItemRepository:

Vi kan utöka gränssnittet med så många metoder som behövs och tillhandahålla exempel i klassen CustomItemRepositoryImpl:

Spring kommer att importera objektberoendena eftersom MongoTemplate är @Autowired. Dessutom gör @Component-kommentaren det möjligt för Spring att upptäcka CustomItemRepository-gränssnittet.

Följande steg är att anropa den här funktionen från vår huvudklass. Precis som med groceryItemRepo måste vi definiera vår customRepo enligt följande:

Skapa sedan följande metod i huvudklassen som anropar vår customRepo-funktion:

Lägg till följande metod till körningsmetoden så att den anropas när programmet körs:

Du bör få följande resultat:

Som tidigare sagt kunde vi utföra ändringen i en enda databastransaktion istället för MongoRepository, vilket krävde tre åtgärder:sök, ställ in och spara. MongoTemplate innehåller även metoden updateMulti() som låter dig uppdatera flera dokument samtidigt.

Slutsats

Vi visade i den här artikeln hur enkelt det är att integrera MongoDB med Spring Boot. Ingen annan kod krävs för att ansluta till MongoDB Atlas. MongoDB Atlas tillhandahåller ett lättanvänt gränssnitt för att lagra och komma åt data från vilken plats som helst. Om du har slutfört denna enkla handledning tror vi att du nu förstår hur du använder Spring Boot med MongoDB. Om du stöter på några problem, kontakta via kommentarsektionen för hjälp. Tack för att du läste.