Home > programmazione > Ammentos

Ammentos

luglio 6, 2007

logoammentos.gif

Nella storia dell’uomo ci son sempre state delle invenzioni che hanno cambiato radicalmente tutta la cultura e i modi di fare. Invenzioni che, una volta fatte, non se ne poteva piu’ fare a meno. Pensate al fuoco, alla ruota, al ferro, etc…

Se pur in misura molto inferiore, anche nel campo informatico ci son state parecchie invenzioni che hanno portato uno sconvolgimento nel modo di scrivere codice. Pensate al passaggio dalla programmazione binaria all’uso dei linguaggi di programmazione ad alto livello o al passaggio dalla programmazione procedurale a quella ad oggetti…

Se restringiamo il punto di vista alla programmazione con i database, Ammentos rappresenta di certo una evoluzione radicale nello sviluppo del software.

Togliamo il velo e scopriamo cosa si celi sotto questo nome all’apparenza strano.

Ammentos è un nuovo framework di persistenza,che seguo da diverso tempo e che promette davvero bene, creato da un unico sviluppatore Davide Deidda. I suoi punti di forza sono la semplicità, la leggerezza e la velocità.

Prima della venuta di Ammentos per operare con i database occorreva scrivere molto codice java e lavorare con istruzioni SQL, Connection, PreparedStatement,ResultSet etc. Ogni operazione che andava fatta con i dati doveva essere correlata di metodo per l’inserimento, l’aggiornamento e l’eventuale cancellazione dei dati. Questo portava una certa complessità nella crezione del codice.

Quale è il segreto di tale framework? Una caratteristica introdotta nel linguaggio Java a partire dalla versione 1.5 : le annotazioni.

Questo è un esempio di codice Java “tradizionale” :

8 class Person {
9
10 protected long id;
11 protected String name;
12 protected String surname;
13 protected int age;
14
15 protected void initdbconnection() {
16 try {
17 java.lang.Class.forName(<my jdbc driver>);
18 } catch (ClassNotFoundException ex) {
19 Logger.getLogger(global).log(Level.SEVERE, null, ex);
20 }
21 }
22
23 public Person(String name, String surname, int age) {
24 this.id = System.currentTimeMillis();
25 this.name = name;
26 this.surname = surname;
27 this.age = age;
28 initdbconnection();
29 }
30
31 public void save() {
32 java.sql.Connection conn = null;
33 try {
34 conn = java.sql.DriverManager.getConnection(jdbc:somejdbcvendor:other data needed by some jdbc vendor, myLogin, myPassword);
35 java.sql.PreparedStatement stmt = conn.prepareStatement(delete people where id = ?);
36 stmt.setLong(1, id);
37 stmt.setString(2, name);
38 stmt.setString(3, surname);
39 stmt.setInt(4, age);
40 stmt.executeUpdate();
41 } catch (SQLException ex) {
42 Logger.getLogger(global).log(Level.SEVERE, null, ex);
43 } finally {
44 try {
45 conn.close();
46 } catch (Exception e) {
47 }
48 }
49 }
50
51 public static Person load( long id ) {
52 Person res = null;
53 java.sql.Connection conn = null;
54 try {
55 conn = java.sql.DriverManager.getConnection(jdbc:somejdbcvendor:other data needed by some jdbc vendor, myLogin, myPassword);
56 java.sql.PreparedStatement stmt = conn.prepareStatement(select * from people where id = ?);
57 stmt.setLong(1, id);
58 ResultSet rs = stmt.executeQuery();
59 if ( rs.next() ) {
60 res.name = rs.getString( name );
61 res.surname = rs.getString( surname );
62 res.id = rs.getLong( id );
63 res.age = rs.getInt( age );
64 }
65 } catch (SQLException ex) {
66 Logger.getLogger(global).log(Level.SEVERE, null, ex);
67 } finally {
68 try {conn.close();} catch( Exception e ) {}
69 }
70 return res;
71 }
72
73 public void delete() {
74 java.sql.Connection conn = null;
75 try {
76 conn = java.sql.DriverManager.getConnection(jdbc:somejdbcvendor:other data needed by some jdbc vendor, myLogin, myPassword);
77 java.sql.PreparedStatement stmt = conn.prepareStatement(delete people where id = ?);
78 stmt.setLong(1, id);
79 stmt.executeUpdate();
80 } catch (SQLException ex) {
81 Logger.getLogger(global).log(Level.SEVERE, null, ex);
82 } finally {
83 try {conn.close();} catch( Exception e ) {}
84 }
85 }
86
87
88 }
Questa è una semplicissima classe che contiene i dati di una persona nome,cognome e età. Tramite questa classe è possibile inserire una nuova persona, caricarne una già esistente dal database o cancellarne una.

Ora vediamo lo stesso codice fatto con Ammentos:
12 @PersistentEntity(sourceDomain=people,targetDomain=people,primaryKey=id )

13 class Person {

14 @PersistentField( automatic=true )

15 protected long id;

16 @PersistentField

17 protected String name;

18 @PersistentField

19 protected String surname;

20 @PersistentField

21 protected int age;

22

23 protected void initdbconnection() {

24 Ammentos.setDataSource( <my data source> );

25 }

26

27 public Person(String name, String surname, int age) {

28 this.name = name;

29 this.surname = surname;

30 this.age = age;

31 initdbconnection();

32 }

33

34 public void save() throws PersistenceException {

35 Ammentos.save(this);

36 }

37

38 public static Person load( long id ) throws PersistenceException {

39 return Ammentos.load( Person.class, id);

40 }

41

42 public void delete() throws PersistenceException {

43 Ammentos.delete( this );

44 }

45 }

46
Strabiliante non trovate?

Come vedete con Ammentos non dobbiamo piu’ preoccuparci delle istruzioni per operare direttamente con il database. Tutte le operazioni delicate di apertura e chiusura delle connessioni svaniscono nel nulla impedendoci così di introdurre errori inatessi nel codice (come la saturazione delle connessioni del database a causa della dimenticanza di chiuderne una).

In questo nuovo approccio, basta annotare la classe da persistere con
@PersistentEntity(sourceDomain=people,targetDomain=people,primaryKey=id)


Dove sourceDomain e targetDomain rappresentano la tabella sul database in cui devono essere recuperati e salvati i dati. Il parametro primaryKey indica quale sia il campo da usare come chiave primaria.

Poi basta semplicemente annotare ogni singolo campo che deve essere memorizzato sul database con @PersistentField ed il gioco è fatto.

In questo modo è molto semplice anche aggiungere un campo persistente. Basta dichiararlo e annotarlo. Prima invece andava modificato ogni singolo metodo di salvataggio,cancellazione e modifica in modo che tenesse conto anche di questo nuovo campo.

Per salvare i dati basta semplicemente usare Ammentos.save(<oggetto>) e per caricarli Ammentos.load( <classe dell’oggetto>, <chiave> ); tutto davvero alla portata dei bambini!

Ma oltre a queste cose Ammentos offre molto di piu’

  • Gestione delle transazioni
  • Avanzato meccanismo di querying
  • Caching dei dati
  • Gestione gerarchie di oggetti
  • Liste/Mappe persistenti
  • tanto tanto di più…

Per una guida completa di ammentos (vi assicuro che vi bastano 10 minuti per capire bene come funziona ed essere operativi) vi rimando a questo link mentre se volete scaricarlo lo potete fare da qui

Sono sicuro che se lo provate poi non potrete piu’ farne a meno….

Daniele



		
Categorie:programmazione
  1. Michelone
    luglio 6, 2007 alle 1:39 pm

    Davvero fico questo Ammentos🙂 Lo devo provare!

  2. luglio 6, 2007 alle 2:03 pm

    wow😐

  3. dev
    ottobre 13, 2007 alle 6:20 pm

    Ho uitlizzato ammentos ne l corso di un progetto.
    L’idea è interessante ma ancora a livello embrionale..

    -Non supporta tipologie di query con attibuti tipo count(*), per cui basterebbe insere un attributo statico count nella dichiarazione della classe

    – mi è stato difficoltoso risalire all’effettivo sql che inviava al database, quindi molto del tempo risparmiati in sviluppo è stato perso in ore e ore di debug alla cieca..

    – non ho trovato modo di effettuare query con ricerca full-text, requisito fondamentale nella maggior parte di applicativi di navigazione contenuti

    Alla fine nella mia applicazione ho utilizzate comunque sia un 50% di metodi utilizzando Ammentos e un 50% utilizzando codice ‘tradizionale’ nel package che si interfacciavano con la base dati.

    Il mio giudizio finale è che Ammentos è ancora lontano dall’essere il prodotto giusto per lo sviluppo di progetti non molto piccoli

  4. ottobre 15, 2007 alle 8:39 am

    @dev
    Ciao Dev,

    Io utilizzo ammentos da un pò di tempo e posso dirti che solo un punto dei tuo tre è vero: La questione del count.

    Per quanto riguarda gli altri 2 punti.
    – Per vedere le query basta aumentare il livello di debug. Da codice basta che tu inserisca una riga del tipo Logger.getLogger( “ammentos” ).setLevel( Level.FINEST ); Ovviamente non potrai vedere le query complete dei valori dei parametri perchè Ammentos utilizza i preparedstatement e anche scrivendo tu a mano il codice non riusciresti comunque a vedere tali informazioni.Però riuscirai a vedere le istruzioni sql che sta utilizzando.

    -Le query fulltext le puoi fare lo stesso in modo molto semplice. Basta inserire questo codice:
    SqlQueryFilter sqlqf = new SqlQueryFilter( “testo like ?” );
    sqlqf.setString( “%cercami%” );
    Ammentos.load( TuaClasse.class, sqlqf );

    Per la questione del count, posso dirti che Davide (il creatore di Ammentos) è una persona super-disponibile e ascolta molto gli utilizzatori del suo framework. Se provi a chiederglielo penso che riesca a trovarti una soluzione. Puoi contattarlo direttamente dal suo sito http://ammentos.biobytes.it/

  1. No trackbacks yet.
I commenti sono chiusi.
%d blogger cliccano Mi Piace per questo: