streamalism.org

1. Áttekintés

Ez a cikk gyors és praktikus lesz bevezetés a Spring Data MongoDB-be.

Az alapokat áttekintjük a MongoTemplate továbbá MongoRepository gyakorlati példák segítségével illusztrálja az egyes műveleteket.

2. MongoTemplateés a MongoRepository

A MongoTemplateköveti a tavaszi sablonmintát, és készen áll az alap API-ra az alapul szolgáló perzisztens motorhoz.

A tárház a Spring Data-központú megközelítést követi, és rugalmasabb és összetettebb API-műveletekkel jár, az összes Spring Data-projekt jól ismert hozzáférési mintái alapján.

Mindkettő esetében a függőség meghatározásával kell kezdenünk - például a pom.xml, Maven-nel:

 org.springframework.data spring-data-mongodb 3.0.3.KÖZLEMÉNY 

Annak ellenőrzéséhez, hogy a könyvtár új verziója megjelent-e, kövesse itt a kiadásokat.

3. Konfiguráció a MongoTemplate

3.1. XML konfiguráció

Kezdjük a Mongo sablon egyszerű XML konfigurációjával:

Először meg kell határoznunk a gyár babot, amely felelős a Mongo példányok létrehozásáért.

Következő - meg kell határoznunk (és konfigurálnunk) a sablonbabot:

És végül meg kell határoznunk egy utófeldolgozót, amely lefordítja azokat MongoKivételek bedobták @Raktár kommentált osztályok:

3.2. Java konfiguráció

Most hozzunk létre egy hasonló konfigurációt a Java config segítségével a MongoDB konfiguráció alaposztályának kiterjesztésével AbstractMongoConfiguration:

@Configuration public class MongoConfig kiterjeszti az AbstractMongoClientConfiguration {@Orride védett karakterlánc getDatabaseName () {return "test"; } @Orride public MongoClient mongoClient () {ConnectionString connectionString = new ConnectionString ("mongodb: // localhost: 27017 / test"); MongoClientSettings mongoClientSettings = MongoClientSettings.builder () .applyConnectionString (connectionString) .build (); return MongoClients.create (mongoClientSettings); } @Orride public collection getMappingBasePackages () {return Collections.singleton ("com.baeldung"); }}

Megjegyzés: Nem kellett meghatároznunk MongoTemplate bab az előző konfigurációban, ahogy azt már definiálta a AbstractMongoClientConfiguration.

A konfigurációnkat a semmiből is használhatjuk anélkül, hogy kiterjesztenénk AbstractMongoClientConfiguration - alábbiak szerint:

@Configuration public class SimpleMongoConfig {@Bean public MongoClient mongo () {ConnectionString connectionString = new ConnectionString ("mongodb: // localhost: 27017 / test"); MongoClientSettings mongoClientSettings = MongoClientSettings.builder () .applyConnectionString (connectionString) .build (); return MongoClients.create (mongoClientSettings); } @Bean public MongoTemplate mongoTemplate () dobja a Kivételt {return new MongoTemplate (mongo (), "test"); }}

4. Konfiguráció a MongoRepository

4.1. XML konfiguráció

Az egyéni tárhelyek használata (a MongoRepository) - folytatnunk kell a konfigurációt a 3.1 szakaszból, és be kell állítanunk a tárakat:

4.2. Java konfiguráció

Ehhez hasonlóan a 3.2 szakaszban már létrehozott konfigurációra építünk, és új megjegyzéssel egészítjük ki a keveréket:

@EnableMongoRepositories (basePackages = "com.baeldung.repository") 

4.3. Hozzon létre egy adattárat

Most, a konfiguráció után, létre kell hoznunk egy adattárat - kibővítve a meglévőt MongoRepository felület:

nyilvános felület: a UserRepository kiterjeszti a MongoRepository-t {//}

Most ezt automatikusan bekapcsolhatjuk UserRepository és használja a műveleteket MongoRepository vagy egyéni műveleteket adhat hozzá.

5. Használata MongoTemplate

5.1. Helyezze be

Kezdjük a beszúrási művelettel; kezdjük egy üres adatbázissal is:

{ }

Ha új felhasználót illesztünk be:

Felhasználó felhasználó = új Felhasználó (); user.setName ("Jon"); mongoTemplate.insert (felhasználó, "felhasználó");

Az adatbázis a következőképpen fog kinézni:

{"_id": ObjectId ("55b4fda5830b550a8c2ca25a"), "_class": "com.baeldung.model.User", "name": "Jon"}

5.2. Mentés - Beszúrás

A mentés A művelet mentési vagy frissítési szemantikával rendelkezik: ha van egy azonosító, akkor frissítést hajt végre, ha nem, akkor beszúr.

Nézzük meg az első szemantikát - a betétet; itt van az adatbázis kezdeti állapota:

{ }

Amikor most mentés új felhasználó:

Felhasználó felhasználó = új Felhasználó (); user.setName ("Albert"); mongoTemplate.save (felhasználó, "felhasználó");

Az entitás be lesz illesztve az adatbázisba:

{"_id": ObjectId ("55b52bb7830b8c9b544b6ad5"), "_class": "com.baeldung.model.User", "név": "Albert"}

Ezután ugyanezt a műveletet vizsgáljuk meg - mentés - frissítési szemantikával.

5.3. Mentés - frissítés

Most nézzük meg mentés frissítési szemantikával, meglévő entitáson működik:

{"_id": ObjectId ("55b52bb7830b8c9b544b6ad5"), "_class": "com.baeldung.model.User", "name": "Jack"}

Most, amikor mi mentés a meglévő felhasználó - frissítjük:

user = mongoTemplate.findOne (Query.query (Criteria.where ("név"). is ("Jack")), User.class); user.setName ("Jim"); mongoTemplate.save (felhasználó, "felhasználó");

Az adatbázis a következőképpen fog kinézni:

{"_id": ObjectId ("55b52bb7830b8c9b544b6ad5"), "_class": "com.baeldung.model.User", "name": "Jim"}

Amint láthatja, ebben a konkrét példában mentés szemantikáját használja frissítés, mert egy objektumot adott adattal használunk _id.

5.4. UpdateFirst

updateFirst frissíti a legelső, a lekérdezésnek megfelelő dokumentumot.

Kezdjük az adatbázis kezdeti állapotával:

[{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Alex"}, {"_id": ObjectId ("55b5ffa5511fee0e45ed614c"), "_class ":" com.baeldung.model.User "," name ":" Alex "}]

Amikor most futtatjuk a updateFirst:

Lekérdezés = új Lekérdezés (); query.addCriteria (Criteria.where ("név"). is ("Alex")); Update update = new Update (); update.set ("név", "James"); mongoTemplate.updateFirst (lekérdezés, frissítés, User.class);

Csak az első bejegyzés frissül:

[{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "James"}, {"_id": ObjectId ("55b5ffa5511fee0e45ed614c"), "_class ":" com.baeldung.model.User "," name ":" Alex "}]

5.5. UpdateMulti

UpdateMultifrissíti az összes dokumentumot, amely megfelel a megadott lekérdezésnek.

Először - itt van az adatbázis állapota, mielőtt elvégezné updateMulti:

[{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Eugen"}, {"_id": ObjectId ("55b5ffa5511fee0e45ed614c"), "_clcl" ":" com.baeldung.model.User "," name ":" Eugen "}] 

Most pedig futtassuk a updateMulti művelet:

Lekérdezés = új Lekérdezés (); query.addCriteria (Criteria.where ("név"). is ("Eugen")); Update update = new Update (); update.set ("név", "Victor"); mongoTemplate.updateMulti (lekérdezés, frissítés, User.class);

Mindkét meglévő objektum frissül az adatbázisban:

[{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Victor"}, {"_id": ObjectId ("55b5ffa5511fee0e45ed614c"), "_class ":" com.baeldung.model.User "," name ":" Victor "}]

5.6. FindAndModify

Ez a művelet úgy működik, mint updateMulti, de az objektum módosítása előtt adja vissza.

Először - az adatbázis állapota hívás előtt findAndModify:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Markus"} 

Nézzük meg a tényleges működési kódot:

Lekérdezés = új Lekérdezés (); query.addCriteria (Criteria.where ("név"). is ("Markus")); Update update = new Update (); update.set ("név", "Nick"); Felhasználói felhasználó = mongoTemplate.findAndModify (lekérdezés, frissítés, Felhasználó.osztály);

A visszatért felhasználói objektum értékei megegyeznek az adatbázis kezdeti állapotával.

Az adatbázis új állapota azonban a következő:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Nick"}

5.7. Upsert

A felfordítani művek működnek a megtalálja és módosítsa a szemantika létrehozását: ha a dokumentum egyezik, frissítse, különben hozzon létre egy új dokumentumot a lekérdezés és a frissítés objektum kombinálásával.

Kezdjük az adatbázis kezdeti állapotával:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Markus"}

Most - futtassuk a felfordítani:

Lekérdezés = új Lekérdezés (); query.addCriteria (Criteria.where ("név"). is ("Markus")); Update update = new Update (); update.set ("név", "Nick"); mongoTemplate.upsert (lekérdezés, frissítés, Felhasználó.osztály);

Itt van az adatbázis állapota a művelet után:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Nick"}

5.8. Eltávolítás

Az adatbázis állapota hívás előtt eltávolítani:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Benn"}

Most fussunk eltávolítani:

mongoTemplate.remove (felhasználó, "felhasználó");

Az eredmény a vártnak megfelelő lesz:

{ }

6. Használata MongoRepository

6.1. Helyezze be

Először - az adatbázis állapota az beillesztés:

{ }

Most, amikor új felhasználót illesztünk be:

Felhasználó felhasználó = új Felhasználó (); user.setName ("Jon"); userRepository.insert (felhasználó); 

Itt van az adatbázis végállapota:

{"_id": ObjectId ("55b4fda5830b550a8c2ca25a"), "_class": "com.baeldung.model.User", "name": "Jon"}

Vegye figyelembe, hogy a művelet ugyanúgy működik, mint a betét ban,-ben MongoTemplate API.

6.2. Mentés – Helyezze be

Hasonlóképpen - mentés ugyanúgy működik, mint a mentés művelet a MongoTemplate API.

Kezdjük azzal, hogy megnézzük a beszúrási szemantika a művelet; itt van az adatbázis kezdeti állapota:

{ }

Most - végrehajtjuk a mentés művelet:

Felhasználó felhasználó = új Felhasználó (); user.setName ("Aaron"); userRepository.save (felhasználó);

Ennek eredményeként a felhasználót felveszik az adatbázisba:

{"_id": ObjectId ("55b52bb7830b8c9b544b6ad5"), "_class": "com.baeldung.model.User", "name": "Aaron"}

Ismételje meg még egyszer, hogy ebben a példában mentés dolgozni valakivel betét szemantika, mert új objektumot illesztünk be.

6.3. Mentés – Frissítés

Nézzük most ugyanazt a műveletet, de ezzel szemantika frissítése.

Először - itt van az adatbázis állapota az új futtatása előtt mentés:

{"_id": ObjectId ("55b52bb7830b8c9b544b6ad5"), "_class": "com.baeldung.model.User", "name": "Jack" 81 * 6}

Most - végrehajtjuk a műveletet:

user = mongoTemplate.findOne (Query.query (Criteria.where ("név"). is ("Jack")), User.class); user.setName ("Jim"); userRepository.save (felhasználó);

Végül itt van az adatbázis állapota:

{"_id": ObjectId ("55b52bb7830b8c9b544b6ad5"), "_class": "com.baeldung.model.User", "name": "Jim"}

Ismételje meg még egyszer, hogy ebben a példában mentés dolgozni valakivel frissítés szemantika, mert egy létező objektumot használunk.

6.4. Töröl

Az adatbázis állapota hívás előtt töröl:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Benn"}

Fussunk töröl:

userRepository.delete (felhasználó); 

Az eredmény egyszerűen az lesz:

{ }

6.5. Találj egyet

Az adatbázis állapota, amikor találj egyet nak, nek hívják:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Chris"}

Most hajtsuk végre a találj egyet:

userRepository.findOne (user.getId ()) 

A meglévő adatokat visszaadó eredmény:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Chris"}

6.6. Létezik

Az adatbázis állapota hívás előtt létezik:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Harris"}

Most pedig fussunk létezik:

logikai isExists = userRepository.exists (user.getId ());

Ami természetesen visszatér igaz.

6.7. FindAll W ith Fajta

Az adatbázis állapota hívás előtt Találd meg mindet:

[{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Brendan"}, {"_id": ObjectId ("67b5ffa5511fee0e45ed614b"), "_clcl" ":" com.baeldung.model.User "," name ":" Adam "}]

Most fussunk Találd meg mindet val vel Fajta:

List users = userRepository.findAll (Sort.by (Sort.Direction.ASC, "név"));

Az eredmény az lesz név szerint rendezve növekvő sorrendben:

[{"_id": ObjectId ("67b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Adam"}, {"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class ":" com.baeldung.model.User "," name ":" Brendan "}]

6.8. FindAll W ith Lapozható

Az adatbázis állapota hívás előtt Találd meg mindet:

[{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Brendan"}, {"_id": ObjectId ("67b5ffa5511fee0e45ed614b"), "_clcl" ":" com.baeldung.model.User "," name ":" Adam "}]

Most hajtsuk végre Találd meg mindet lapozási kéréssel:

Lapozható pageableRequest = PageRequest.of (0, 1); Oldaloldal = userRepository.findAll (pageableRequest); Felhasználók listája = pages.getContent ();

A kapott felhasználók a lista csak egy felhasználó lesz:

{"_id": ObjectId ("55b5ffa5511fee0e45ed614b"), "_class": "com.baeldung.model.User", "name": "Brendan"}

7. Kommentárok

Végül nézzük át azokat az egyszerű kommentárokat is, amelyeket a Spring Data használ ezeknek az API-műveleteknek a vezérléséhez.

@Id private String azonosító;

A terepszint @Id az annotáció bármilyen típust díszíthet, beleértve a hosszú és húr.

Ha az értéke @Id mező nem null, az adatbázisban a jelenlegi állapotban van tárolva; különben az átalakító feltételezi, hogy egy ObjectId az adatbázisban (vagy ObjectId, String vagy BigInteger munka).

Következő - @Dokumentum:

@Document nyilvános osztály felhasználó {//}

Ez a felirat egyszerűen egy osztályt objektumként jelöl meg ezt fenn kell tartani az adatbázisban, lehetővé téve számunkra, hogy kiválasszuk a használni kívánt gyűjtemény nevét.

8. Következtetés

Ez a cikk gyors, de átfogó bevezetés volt a MongoDB és a Spring Data használatához, mind a MongoTemplate API, valamint az MongoRepository.

Mindezen példák és kódrészletek megvalósítása található át a Githubon.