streamalism.org

1. Áttekintés

Ez az oktatóanyag a Spring Data MongoDB néhány alapvető jellemzőjét - indexelés, gyakori kommentárok és konverterek - tárja fel.

2. Indexek

2.1. @Teljes

Ez az annotáció indexeltként jelöli a mezőt a MongoDB-ben:

@QueryEntity @Document public class Felhasználó {@Indexed private String név; ...}

Most, hogy a név mező indexelve van - nézzük meg a MongoDB indexeit:

db.user.getIndexes ();

Íme az adatbázis-szint:

[{"v": 1, "kulcs": {"_id": 1}, "név": "_id_", "ns": "test.user"}, {"v": 1, "kulcs": {"név": 1}, "név": "név", "ns": "test.user"}]

Mint láthatja, két indexünk van - az egyik az _id - amely alapértelmezés szerint a @Id annotáció és a második a miénk név terület.

2.2. Hozzon létre indexet programszerűen

Indexet programozottan is létrehozhatunk:

mongoOps.indexOps (Felhasználó.osztály). užtikrintiIndex (új Index (). on ("név", Direction.ASC)); 

Most létrehoztunk egy indexet a mezőhöz név és az eredmény ugyanaz lesz, mint az előző részben.

2.3. Összetett indexek

A MongoDB az összetett indexeket támogatja, ahol egyetlen indexstruktúra több mezőre is hivatkozásokat tartalmaz.

Nézzünk meg egy gyors példát az összetett indexek használatával:

@QueryEntity @Document @CompoundIndexes ({@CompoundIndex (name = "email_age", def = "{'email.id': 1, 'age': 1}")}}) nyilvános osztály felhasználó {//}

Összetett indexet hoztunk létre a email és kor mezők. Nézzük meg most a tényleges indexeket:

{"v": 1, "kulcs": {"email.id": 1, "age": 1}, "name": "email_age", "ns": "test.user"} 

Vegye figyelembe, hogy a DBRef mező nem jelölhető meg @Index - ez a mező csak egy összetett index része lehet.

3. Gyakori kommentárok

3.1 @ Átmeneti

Ahogy az várható volt, ez az egyszerű megjegyzés kizárja a mező fennmaradását az adatbázisban:

public class Felhasználó {@Transient private Integer yearOfBirth;

 // standard getter és setter}

Helyezzük be a felhasználót a beállítási mezővel születési év:

Felhasználó felhasználó = új Felhasználó (); user.setName ("Alex"); user.setYearOfBirth (1985); mongoTemplate.insert (felhasználó); 

Ha megnézzük az adatbázis állapotát, akkor azt látjuk, hogy az iktatott születési év nem lett mentve:

{"_id": ObjectId ("55d8b30f758fd3c9f374499b"), "name": "Alex", "age": null}

Tehát, ha lekérdezzük és ellenőrizzük:

mongoTemplate.findOne (Query.query (Criteria.where ("név"). is ("Alex")), User.class) .getYearOfBirth ()

Az eredmény az lesz nulla.

3.2. @Terület

@Terület jelzi a JSON dokumentum mezőjének kulcsát:

@Field ("email") privát EmailAddress emailAddress; 

Most email cím a kulcs segítségével az adatbázisba kerül email:

Felhasználó felhasználó = új Felhasználó (); user.setName ("Brendan"); EmailAddress emailAddress = új EmailAddress (); emailAddress.setValue ("[e-mail védett]"); user.setEmailAddress (emailAddress); mongoTemplate.insert (felhasználó); 

És az adatbázis állapota:

{"_id": ObjectId ("55d076d80bad441ed114419d"), "name": "Brendan", "age": null, "email": {"value": "[email protected]"}}

3.3. @PersistenceConstructor és @Érték

@PersistenceConstructor a perzisztencia-logika által használt elsődleges konstruktort jelöli meg egy konstruktort is, amely csomag védett is. A konstruktor argumentumait név szerint hozzárendelik a lekérdezett kulcsértékekhez DBObject.

Nézzük meg ezt a konstruktort Felhasználó osztály:

@PersistenceConstructor public User (Karakterlánc neve, @Value ("# root.age?: 0") Egész életkor, EmailAddress emailAddress) {this.név = név; ez.kor = életkor; this.emailAddress = emailAddress; } 

Figyelje meg a szokásos rugó használatát @Érték annotáció itt. Ennek a kommentárnak a segítségével használhatjuk a Spring Expressions használatával a kulcs adatbázisból kinyert értékét, mielőtt azt egy tartományi objektum létrehozására használnánk. Ez itt egy nagyon erős és nagyon hasznos funkció.

Példánkban, ha kor nincs beállítva, amire be lesz állítva 0 alapértelmezés szerint.

Most nézzük meg, hogyan működik:

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

Adatbázisunk a következőket fogja kinézni:

{"_id": ObjectId ("55d074ca0bad45f744a71318"), "name": "Alex", "age": null}

Így a kor mező az nulla, de amikor lekérdezzük a dokumentumot és lekérjük kor:

mongoTemplate.findOne (Query.query (Criteria.where ("név"). is ("Alex")), User.class) .getAge ();

Az eredmény 0 lesz.

4. Átalakítók

Vessünk egy pillantást a Spring Data MongoDB egy másik nagyon hasznos szolgáltatására - átalakítókra, és konkrétan a MongoConverter.

Ez az összes Java-típus leképezésének kezelésére szolgál DBObjects amikor ezeket az objektumokat tárolja és lekérdezi.

Két lehetőségünk van - akár dolgozhatunk is MappingMongoConverter - vagy SimpleMongoConverter a korábbi verziókban (ezt a Spring Data MongoDB M3 elavulttá tette, és a funkcionalitása átkerült MappingMongoConverter).

Vagy írhatunk saját átalakítót is. Ehhez végre kell hajtanunk a Átalakító felületen regisztrálja a megvalósítást MongoConfig.

Nézzük egy gyors példa. Amint az itt látható JSON-kimenetből láthattad, az adatbázisban mentett összes objektumnak megvan a mezője _osztály amely automatikusan mentésre kerül. Ha azonban a kitartás során ki akarjuk hagyni az adott mezőt, akkor ezt megtehetjük a MappingMongoConverter.

Először - itt van az egyéni átalakító megvalósítása:

@Component public class UserWriterConverter implementálja a Converter {@Override public DBObject convert (User user) {DBObject dbObject = new BasicDBObject (); dbObject.put ("név", user.getName ()); dbObject.put ("kor", user.getAge ()); if (user.getEmailAddress ()! = null) {DBObject emailDbObject = új BasicDBObject (); emailDbObject.put ("érték", user.getEmailAddress (). getValue ()); dbObject.put ("email", emailDbObject); } dbObject.removeField ("_ class"); return dbObject; }}

Figyeljük meg, hogyan érhetjük el könnyen a kitartás célját _osztály konkrétan a mező közvetlen eltávolításával itt.

Most regisztrálnunk kell az egyéni átalakítót:

privát lista konverterek = új ArrayList(); @Orride public MongoCustomConversions customConversions () {converters.add (new UserWriterConverter ()); új MongoCustomConversions (konverterek) visszaküldése; }

Természetesen ugyanazt az eredményt érhetjük el az XML konfigurációval is, ha szükségünk van rá:

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

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

Az adatbázis eredményül kapott dokumentum már nem tartalmazza az osztály adatait:

{"_id": ObjectId ("55cf09790bad4394db84b853"), "name": "Chris", "age": null}

5. Következtetés

Ebben az oktatóanyagban bemutattuk a Spring Data MongoDB használatának néhány alapkoncepcióját - indexelés, gyakori kommentárok és konverterek.

Mindezen példák és kódrészletek megvalósítása ban található github projektem.