DAM-M3-UF6. Persistència a bases de dades OO
torna M3 - Programació
Introducció
Hi ha múltiples maneres de gestionar la persistència des de Java, alguns exemples:
| BBDD Relacionals | SQL incrustat (Embedded) | Per exemple SQLJ | Utilitza directament SQL
Molt eficient. Poc usat i amb poc suport (Per exemple Eclipse no) |
| |
Intermediari (Driver) | Exemples:
JDBC ODBC |
Les interfícies són lleugeres, aporten mètodes d'utilitat per facilitar la gestió de les tasques més comuns |
| |
Eines específiques | Eines d'alt nivell:
Hibernate API de Persistència Java |
Afegeixen gran abstracció respecte la base de dades, i per tant independència de la tecnologia.
En general requereixen d'un procés previ de configuració |
| BBDD OO | Llibreries específiques per a cada SGBD OO | ||
En general depèn del tipus de base de dades, les més comuns les BBDD Relacionals.
Bases de dades OO
Aquests tipus de BBDD emmagatzemen objectes (atributs i mètodes). La persistència és doncs molt més directa, no existeixen les limitacions de les BBDD Relacionals. Des del punt de vista del programador és molt més senzill treballar amb aquest tipus de base de dades (Si es programa amb objectes).
Per contra existeixen poques BBDD OO al mercat, en general no s'utilitzen i conceptualment són difícils d'entendre (com s'emmagatzemen les dades? i els mètodes?...)
Cada objecte guardat s'identifica per un OID (Object Identifier), independent de les dades que conté.
ODBMS : Object Database Management System
http://en.wikipedia.org/wiki/Object_database
http://en.wikipedia.org/wiki/Comparison_of_object_database_management_systems
db4o - Database 4(for) Objects
db4o és un exemple de les múltiples BBDD OO del mercat
Algunes de les seves característiques són:
- De codi obert sota llicència GPL, orientat a Java
- Senzill d'utilitzar i amb bon rendiment,
- La base de dades és un únic fitxer
- Només cal importar una llibreria "db4o-8.0.....-all-java5.jar"
OME (Object Manager Enterprise)
El propi gestor incorpora una utilitat (Plugin per Eclipse) que permet explorar els objectes de la base de dades
Vista OME:
- db4o browser: mostra les classes i els atributs (Botó dret: View All Objects)
- Property View: Propietats de la BBDD, de les classes i dels objecte (OID), permet crear índexs
- Build Query: Crear consultes, arrossegant des del Browser
- Query Results: Mostrar resultat de les consultes i modificar valors
Menú OME
- Connectar i desconnectar de la Base de dades
Els exemples que es treballen a continuació són extrets de la documentació de db4o
Connectar i desconnectar
La connexió es molt simple, només cal indicar el fitxer.
Això genera un objecte ObjectContainer que representa la BBDD.
Per tancar la connexió es crida el mètode close().
private static final String BBDDFITXER = "DB4Oexemple";
public static void main(String[] args) {
new File(BBDDFITXER).delete(); // Obliga a crear nova BBDD cada vegada (Opcional)
ObjectContainer db = Db4oEmbedded.openFile(Db4oEmbedded.newConfiguration(), BBDDFITXER);
try {
// Treballar amb la BBDD
} finally {
db.close();
}
}
Classe Exemple Inicial
public class Pilot {
private String name;
private int points;
public Pilot(String name,int points) {
this.name=name;
this.points=points;
}
public int getPoints() {
return points;
}
public void addPoints(int points) {
this.points+=points;
}
public String getName() {
return name;
}
public String toString() {
return name+"/"+points;
}
}
Operacions ABM
La inserció i la modificació es realitzen a través del mètode store(object).
// Desar objectes
Pilot pilot1 = new Pilot("Michael Schumacher", 100);
db.store(pilot1);
Pilot pilot2 = new Pilot("Rubens Barrichello", 99);
db.store(pilot2);
Per modificar un objecte només cal cridar a store(object) després de fer els canvis
pilot1.addPoints(20);
db.store(pilot1);
La eliminació amb el mètode delete(object), més endavant veurem que aquí hi ha certes consideracions a tenir en compte.
db.delete(pilot2);
Consultes
El gestor db4o permet tres tipus de consultes
- Query By Example (QBE).
- Native Queries (NQ). Opció recomanada, interface principal de consulta.
- SODA Query API.
Query By Example (QBE)
Es basa en crear un objecte propotip que s'utilitza d'exemple per a la consulta.
A partir del prototip s'obtenen els objectes que tenen els mateixos valors, per indicar "qualsevol" s'utilitzen els valors per defecte del tipus de l'atribut: 0 - enters, null - objectes, etc..
El resultat es retorna en un ObjectSet (Conjunt) que implementa les interfaces java.util.Collection<T>, java.lang.Iterable<T>, java.util.List<T>
Pilot proto = new Pilot(null, 0); // Tots
ObjectSet<Pilot> result = db.queryByExample(proto);
System.out.println(result.size());
for (Pilot p : result) {
System.out.println(p);
}
proto = new Pilot("Michael Schumacher", 0); // Pilots amb nom "Michael Schumacher"
result = db.queryByExample(proto);
System.out.println(result.size());
Iterator<Pilot> it = result.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
Native Queries (NQ)
Aquesta és la opció recomanada a la documentació.
Els Inconvenients de QBE són:
- No es poden utilitzar expressions complexes AND, OR, NOT, >, <, == etc...
- No es poden posar condicions sobre els valors 0, null, etc... perquè s'interpreten com "qualsevol"
- Es necessari un constructor per a indicar les condicions sobre els atributs
Les consultes NQ:
- Permeten expressions complexes
- S'escriuen en el propi llenguatge (Java)
- Si es possible utilitzen els índexs definits
Les restriccions es creen a partir d'un predicat : Classe Abstracte Predicate
Aquesta classe només inclou el mètode abstracte match(candidat) que retorna l'expressió a avaluar sobre un objecte candidat
A l'exemple següent es mostra com fer una consulta amb anonymous inner classes, en general això no és una bona pràctica perquè no permet reutilitzar codi i és poc clar. Tot i això hi ha situacions on és útil.
List <Pilot> pilots1 = db.query(new Predicate<Pilot>() {
public boolean match(Pilot pilot) {
return pilot.getPoints() == 100;
}
});
També es pot extendre la classe Predicate i sobreescriure el mètode match(candidate)
class PilotHundredPoints extends Predicate<Pilot> {
public boolean match(Pilot pilot) {
return pilot.getPoints() == 100;
}
}
List <Pilot> pilots2 = db.query(new PilotHundredPoints());
A partir d'aquí es poden fer les consultes tant complexes com calgui
List <Pilot> pilots3 = db.query(new Predicate<Pilot>() {
public boolean match(Pilot pilot) {
return pilot.getPoints() > 99
&& pilot.getPoints() < 199
|| pilot.getName().equals("Rubens Barrichello");
}
});
SODA Query API
SODA és l'API de baix nivell per a consultes. Per exemple internament les consultes NQ es transformen en SODA per optimitzar-les abans d'executar-les.
Utilitza strings per identificar els noms dels camps sobre els que posar restriccions
El gestor construeix un graf (arbre) de la consulta amb els nodes i les restriccions
- node --> Múltiples classes, una classe o un atribut d'una classe
- constrain --> Afegeix una restricció al node
- descend --> retorna un node descendent en el graf
// Tots els objectes
Query query=db.query(); // Crea SODA query
query.constrain(Pilot.class); // Afegeix restricció
ObjectSet<Pilot> res = query.execute();
// Tots els objectes amb un valor d'atribut concret
Query query2=db.query();
query.constrain(Pilot.class);
// Afegeix restricció sobre el node descendent (en aquest cas un atribut de tipus primitiu)
query.descend("name").constrain("Michael Schumacher");
ObjectSet<Pilot> res2=query.execute();
També permet afegir tot tipus de restriccions: AND, OR, NOT, etc...
// Negació
query.descend("name").constrain("Michael Schumacher").not();
// AND
query.constrain(Pilot.class);
Constraint constr=query.descend("name").constrain("Michael Schumacher");
query.descend("points").constrain(99).and(constr);
// OR
query.descend("points").constrain(99).or(constr);
// Més greater, equal, endsWith ...
query.descend("points").constrain(99).greater();
Alhora que ordenar el resultat
// Ordre dels resultats
query.descend("name").orderAscending();
query.descend("name").orderDescending();
Associacions
Què passa quan tenim objectes associats? com es gestiona?
Afegim la següent classe als exemples
public class Car {
private String model;
private Pilot pilot;
public Car(String model) {
this.model=model;
this.pilot=null;
}
public Pilot getPilot() {
return pilot;
}
public void setPilot(Pilot pilot) {
this.pilot = pilot;
}
public String getModel() {
return model;
}
public String toString() {
return model+"["+pilot+"]";
}
}
Les insercions funcionen igual.
Si es desen objectes, implícitament també es desen els objectes associats.
Car car1 = new Car("Ferrari");
Pilot pilot3 = new Pilot("Michael Schumacher", 100);
car1.setPilot(pilot3);
db.store(car1); // Desa també el pilot
Les consultes també es treballen de la mateixa forma
final String pilotName = "Rubens Barrichello";
List<Car> results = db.query(new Predicate<Car>() {
public boolean match(Car car) {
return car.getPilot().getName().equals(pilotName);
}
});
És interessant veure que es poden posar restriccions navegant d'un objecte a un altre associat, p.e. del cat --> pilot
Què passa si un cotxe no té pilot?
Amb el següent exemple es pot veure que que dins del mètode es genera una excepció si un cotxe no té pilot, però aquesta excepció la controla internament el gestor i no arriba a l'usuari.
El resultat simplement és que el candidat en qüestió no s'inclou en el resultat de la consulta.
Car car1 = new Car("Ferrari");
//car1.setPilot(pilot);
db.store(car1);
List<Car> cars = db.query(new Predicate<Car>() {
public boolean match(Car car) {
boolean res = false;
try {
res = car.getPilot().getName().equals("Rubens Barrichello");
} catch (Exception e) {
System.out.println("-Excepcio-");
}
return res;
}
});
Modificacions. Profunditat
Per gestionar la persistència d'objectes existents a la base de dades, cal indicar a db4o un paràmetre anomenat profunditat (depth).
Per defecte la profunditat és 1, això vol dir que es desa l'objecte i les seves dades primitives, però no els objectes associats.
Per contra és pot establir la profunditat fins a tot el sistema indicat el paràmetre cascadeOnUpdate(true). Evidentment penalitzant en el rendiment del programa.
EmbeddedConfiguration config = Db4oEmbedded.newConfiguration();
config.common().objectClass(Car.class).cascadeOnUpdate(true);
ObjectContainer db = Db4oEmbedded.openFile(config, BBDDFITXER);
Eliminacions. Recursivitat
De manera similar a les modificacions, les eliminacions no afectes als objectes associats en la configuració per defecte (p.e. Esborrar un cotxe no esborra el Pilot)
Però es pot establir que per una classe s'esborrin tots els objectes associats indicat el paràmetre cascadeOnDelete(true)
EmbeddedConfiguration config = Db4oEmbedded.newConfiguration();
config.common().objectClass(Car.class).cascadeOnDelete(true);
ObjectContainer db = Db4oEmbedded.openFile(config, BBDDFITXER);
Cal vigilar en tot cas perquè db4o no valida si els objectes que s'esborren estan referenciats per altres objectes del sistema,
EmbeddedConfiguration config = Db4oEmbedded.newConfiguration();
config.common().objectClass(Car.class).cascadeOnDelete(true);
ObjectContainer db = Db4oEmbedded.openFile(config, BBDDFITXER);
// Esborra tot
ObjectSet result=db.queryByExample(new Object());
while(result.hasNext()) {
db.delete(result.next());
}
Pilot pilot = new Pilot("Michael Schumacher", 100);
Car car1 = new Car("Ferrari");
Car car2 = new Car("BMW");
car1.setPilot(pilot);
car2.setPilot(pilot);
db.store(car1);
db.store(car2);
db.delete(car2);
List<Car> cars = db.query(new Predicate<Car>() {
public boolean match(Car car) {
return true;
}
});
for (Car c : cars) {
System.out.println(c); // Mostra el cotxe car1
}
// Mostra Ferrari[Michael Schumacher/100] pq encara està a memòria
db.close();
db = Db4oEmbedded.openFile(Db4oEmbedded.newConfiguration(), BBDDFITXER);
cars = db.query(new Predicate<Car>() {
public boolean match(Car car) {
return true;
}
});
for (Car c : cars) {
System.out.println(c);
}
// Mostra Ferrari[null] el pilot s'havia esborrat
db.close();
Herència
Per a les classes d'exemple utilitzarem un sensor genèric que afegirem al cotxe, i 3 sensors concrets: de temperatura, aigua i pressió.
Aquests sensor representa que prenen mesures en un moment concret.
El cotxe té un historial de mesures, i té un mètode snapshot() que pren algunes mesures en un moment donat a través d'aquests sensors.
