Archivi tag: Tutorial

MongoDB , JavaDriver e Full Text Search

Con le nuove versioni di MongoDB, è stata portata alla luce, anche sul driver java ,la possibilità di avere indici testuali su cui effettuare ricerche.

Per definire l’indice ed eseguire una ricerca:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 MongoClient mongo = new MongoClient("localhost",27017);
 DB db = mongo.getDB("persons");
 DBCollection table = db.getCollection("personCollection");
 //creo un indice full text sulla "colonna" name dell'oggetto Person
 table.createIndex(new BasicDBObject("name","text"));
 BasicDBObject search= new BasicDBObject("$search","valori da ricercare separati da spazio");
 BasicDBObject textSearch = new BasicDBObject("$text",search);
 DBCursor cursor = tablefind(textSearch);
 personList = new ArrayList<Person>();
       
 while (cursor.hasNext()){
  DBObject obj = cursor.next();
  Person pers = (new Gson()).fromJson(obj.toString(), Person.class);
  personList.add(pers);
 }

Fare attenzione alla versione che si usa di MongoDB perché nelle versioni precedenti la full text search non era abilitata di default.

Interessante la possibilità di ottenere come risultato l’item con il più alto numero di match di parole chiave inserite:

1
2
3
4
  BasicDBObject search= new BasicDBObject("$search","valori da ricercare separati da spazio");
  BasicDBObject textSearch = new BasicDBObject("$text",search);
  BasicDBObject score= new BasicDBObject("score", new BasicDBObject("$meta", "textScore"));
  bestItem= coll.findOne(textSearch, score);

MongoDB e Java Driver,esempi vari

Iniziamo a giocare con MongoDB tramite il java driver.
Consiglio il download della versione 2.12.3 o successive (fate attenzione che i downloads della libreria non sono in ordine numerico, e quindi si rischia spesso di scaricarne una vecchia).
Altra libreria utile per le conversioni da pojo a stringa, la libreria Google gson, versione 2-2-4.

Una volta messo il jar nel classpath della nostra applicazione, e fatto partire il nostro server database mongodb, stabiliamo la connessione, al server e otteniamo il riferimento al database che vogliamo usare, in questo caso il db “person”. Ottenuto il DB, possiamo accedere alla collection dei nostri futuri oggetti da persistere (se la collection non esiste, viene creata in questa fase).

1
2
3
MongoClient mongo = new MongoClient("localhost",27017);
DB db = mongo.getDB("persons");
DBCollection table = db.getCollection("personCollection");

Realizziamo un pojo classico per la gestione dell’entità “Person” da persistere su MongoDB.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.io.Serializable;

public class Person implements Serializable{

    private static final long serialVersionUID = -8413862529676269210L;
    private String id = java.util.UUID.randomUUID().toString();
    private String name;
    private String lastname;
    private Integer age;
   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getLastname() {
        return lastname;
    }
    public void setLastname(String lastname) {
        this.lastname = lastname;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
   
    public String getId() {
        return id;
    }
   
    public void setId(String id) {
        this.id = id;
    }
   
   
}

In questo esempio generiamo un UUID come id dell’oggetto, ma potremmo usare l’hashcode.

Per effettuare una insert sulla collection di cui sopra:

1
2
3
4
5
6
7
8
9
10
//istanza dell'oggetto Person da inserire
Person persona = new Person();
persona.setName("cesare");
//utilizziamo JSon per la conversione automatica da pojo a BasicDBObject

Gson gson = new Gson();
BasicDBObject personDBO =(BasicDBObject) JSON.parse(gson.toJson(persona));

//table è la DBCollection indicata nel primo esempio
table.insert(personDBO );

Col nuovo driver è possibile usare operazioni batch in automatico passando all’insert un array

1
2
3
4
5
6
7
8
List<DBObject> dbObjList = new ArrayList<DBObject>();
for(int i =0;i<100;i++){
 Person p = new Person();
 p.setName("test"+i);
 BasicDBObject pDB=(BasicDBObject) JSON.parse(gson.toJson(p));
 dbObjList.add(pDB);
}
table.insert(dbObjList);

Per la modifica di un oggetto in una collection (per definizione con MongoDB parliamo in realtà di documenti), è possibile effettuare direttamente il replace dell’oggetto con una nuova istanza.

1
2
3
4
5
6
7
 //creo un dbObject per eseguire la find di un elemento che abbia la chiave name uguale a 'test1':
 BasicDBObject personOriginal = new BasicDBObject().append("name", "test1");
 
 //e sostituirlo con questo nuovo oggetto
 BasicDBObject personNew = new BasicDBObject().append("name","nuovotest1").append("lastname","kiraya");

 table.update(personOriginal,personNew);

Per rimuovere un elemento dalla collection,è possibile indicare un criterio di ricerca oppure un DBObject specifico da eliminare:

1
2
3
 BasicDBObject personQuery = new BasicDBObject().append("name","nuovotest1");
 BasicDBObject personDB = table.findOne(personQuery);
 table.remove(personDB);

Per svuotare completamente una collection, è possibile eseguirne il drop:

1
 table.drop();

Oppure usare un BasicDBObject “byExample” che non contenga dati, il che sta a significare una rimozione senza nessun particolare criterio di filtro (e quindi tutti):

1
table.remove(new BasicDBObject());

E’ possibile filtrare i dati in diversi modi, utilizzando le query byExample, utilizzando il QueryBuilder oppure tramire Regular Expressions.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//by example il contenuto deve matchare completamente
DBCursor cursor = table.find(new BasicDBObject("name","test1"));
while (cursor.hasNext()){
  DBObject obj = cursor.next();
  Person pers = (new Gson()).fromJson(obj.toString(), Person.class);
  System.out.println(pers.getName());
}

//tramite regexp utilizzando un pattern per simulare una like %nome%
BasicDBObject filter= new BasicDBObject();
filter.append("name", Pattern.compile("nuovo"));
filter.append("lastname",Pattern.compile("kira"));
cursor = table.find(filter);
while (cursor.hasNext()){
  DBObject obj = cursor.next();
  Person pers = (new Gson()).fromJson(obj.toString(), Person.class);
  System.out.println(pers.getName());
}

Per estrarre tutti gli elementi di una collection basta eseguire un find senza parametri:

1
DBCursor cursor = table.find();

MongoDB come servizio con Windows 7

Iniziando a giocare con il document database MongoDB, ho riscontrato subito difficoltà nel definirlo come processo di Windows, su Windows 7.
La procedura è relativamente semplice.
Alcuni passaggi sulla documentazione ufficiale, non sono validi per Windows 7, o per lo meno non descrivono la problematica del file di configurazione (non funzionante) in caso di servizio di Windows.

Una volta installato dall’installer mongoDB, aprire una shell (cmd) come amministratore, e creare delle cartelle per i db e per i log

1
2
 mkdir c:\data\db
 mkdir c:\data\log

fatto questo sempre dalla shell, eseguire il comando per la registrazione manuale del servizio:

1
sc.exe create MongoDB binPath= ""C:\Program Files\MongoDB 2.6 Standard\bin\mongod.exe" --service --rest --master --logpath=c:\data\log\mongo.log --dbpath=c:\data\db" DisplayName= "MongoDB 2.6 Standard" start= "auto"

da questo momento in poi, avendo forzato le variabili per il logpath e il dbpath(e non avendole definite su file config, come consiglia la documentazione ufficiale), il servizio è in grado di partire in automatico.