Activitats

Definició de classes mitjançant ODL

L’objectiu d’aquesta activitat és veure com especificar classes usant el llenguatge ODL.

Genereu la declaració ODL de les classes del diagrama següent:

Figura

  1. class Zona(key nom) {
  2.  attribute String nom;
  3.  attribute integer habitants;
  4.  attribute float extensió;
  5. }
  6.  
  7. class Ciutat extends Zona {
  8.   attribute string pais;
  9.   relationship set<Districte> districtes;
  10. }
  11.  
  12. class Districte extends Zona {
  13.   attribute integer numDistricte;
  14.   relationship set<Carrer> carrers;
  15. }
  16.  
  17. class Coordenada {
  18.    attribute String longitud;
  19.    attribute String latitud;
  20. }
  21.  
  22. class Carrer {
  23.    attribute String nom;
  24.    attribute float longitud;
  25.    relationship <Coordenada> inici;
  26.    relationship <Coordenada> fi;
  27.    relationship Set<Intersecció> interseccions;
  28. }
  29.  
  30. class Intersecció {
  31.    attribute boolean semàfor;
  32.    relationship <Carrer> carrerIntersectat;
  33.    relationship <Coordenada> ubicació;
  34. }

Instal·lació i ús de db4o

L’objectiu d’aquesta activitat és veure com usar les llibreries de db4o per treballar amb BDOO mitjançant el vostre IDE.

Aneu a la pàgina de db4o i descarregueu les seves biblioteques i la documentació. Llegiu la documentació per veure de quina manera podeu usar les biblioteques per generar programes mitjançant el vostre IDE. Un cop fet, executeu el codi següent per veure que tot està correcte: 

  1. import com.db4o.*;
  2.  
  3. public class ProvaDB4O {
  4.  
  5.   private class Data {
  6.     private int dia;
  7.     private int mes;
  8.     private int any;
  9.  
  10.     public Data(int d, int m, int a) {
  11.       dia = d;
  12.       mes = m;
  13.       any = a;
  14.     }
  15.  
  16.     @Override
  17.     public String toString() {
  18.       return dia + "-" + mes + "-" + any;
  19.     }
  20.   }
  21.  
  22.   public void start() throws Exception {
  23.     ObjectContainer db = Db4oEmbedded.openFile("BDOOClients.db4o");
  24.     try {
  25.       Data d = new Data(23, 11, 2011);
  26.       db.store(d);
  27.       d = new Data(5, 9, 1975);
  28.       db.store(d);
  29.       d = new Data(4, 9, 1978);
  30.       db.store(d);
  31.  
  32.       System.out.println("Les dates del setembre són:");
  33.       d = new Data(0,9,0);
  34.       ObjectSet<Data> res = db.queryByExample(d);
  35.       while (res.hasNext()) {
  36.         System.out.println(res.next());
  37.       }
  38.  
  39.     } finally {
  40.       db.close();
  41.     }
  42.   }
  43.  
  44.   public static void main (String[] args) throws Exception {
  45.     ProvaDB4O prova = new ProvaDB4O();
  46.     prova.start();
  47.   }
  48.  
  49. }

Gestió de grups de treball d'estudiants mitjançant db4o

L’objectiu d’aquesta activitat és veure com gestionar la persistència d’objectes usant la BDOO db4o.

Es disposa de les dues classes Estudiant i GrupTreball, el codi de les quals es mostra tot seguit. A partir d’aquest codi, es desitja crear una aplicació que, mitjançant una BDOO db4o gestioni a quins grups de treball pertanyen diferents estudiants dins una escola. Donat un grup de treball, aquest pot tenir assignats diversos estudiants, però tot estudiant només té un (però sempre un) únic grup de treball. L’aplicació ha de poder fer el següent:

  • Donar d’alta un nou estudiant. A l’hora d’assignar-li un grup, si el nom indicat no existeix, es crea un nou grup. Si existeix, a l’estudiant se li assigna aquell grup.
  • Reassignar un estudiant a un altre grup de treball. Aquest grup ja ha d’existir. Si, en fer-ho, el grup antic queda sense membres, cal esborrar-lo de la BDOO.
  • Llistar tots els grups existents.
  • Llistar tots els estudiants (i a quin grup pertanyen).

Es considera que els noms dels grups i dels estudiants són únics al sistema. No hi pot haver noms repetits. En base a la descripció, també cal remarcar que l’única manera de crear grups nous és afegint-hi nous estudiants.

Per dur a terme aquesta tasca, el codi font d’aquestes dues classes no es pot modificar en absolut. 

  1. public class Estudiant {
  2.   private String nom;
  3.   private GrupTreball grup;
  4.  
  5.   public Estudiant (String n, GrupTreball gt) {
  6.     nom = n;
  7.     grup = gt;
  8.     grup.sumaEstudiant();
  9.   }
  10.  
  11.   public String getNom() {
  12.     return nom;
  13.   }
  14.  
  15.   public GrupTreball getGrupTreball() {
  16.     return grup;
  17.   }
  18.  
  19.   public void reassignaGrup(GrupTreball gt) {
  20.     if (grup != gt) {
  21.       grup.restaEstudiant();      
  22.       grup = gt;
  23.       grup.sumaEstudiant();
  24.     }
  25.  
  26.   }
  27.  
  28.   @Override
  29.   public String toString() {
  30.     return nom + " -> " + grup;
  31.   }
  32.  
  33. }
  1. public class GrupTreball {
  2.   private String nom;
  3.   private String tema;
  4.   private int numEstudiants = 0;
  5.  
  6.   public GrupTreball(String n, String tm) {
  7.     nom = n;
  8.     tema = tm;
  9.   }
  10.  
  11.   public void sumaEstudiant() {
  12.     numEstudiants++;
  13.   }
  14.  
  15.   public void restaEstudiant() {
  16.     numEstudiants--;
  17.   }
  18.  
  19.   public int getNumEstudiants() {
  20.     return numEstudiants;
  21.   }
  22.  
  23.   @Override
  24.   public String toString() {
  25.     return nom + " - " + tema;
  26.   }
  27.  
  28. }

  1. import java.util.*;
  2. import com.db4o.*;
  3. import com.db4o.config.EmbeddedConfiguration;
  4. import com.db4o.query.Predicate;
  5.  
  6. public class GestionarTreballs {
  7.  
  8.   public void start() {
  9.     EmbeddedConfiguration config = Db4oEmbedded.newConfiguration();
  10.     config.common().objectClass(Estudiant.class).cascadeOnUpdate(true);
  11.     ObjectContainer db = Db4oEmbedded.openFile("BDOOClientsEx3.db4o");
  12.  
  13.     boolean executar = true;
  14.  
  15.     while (executar) {
  16.       System.out.println("[1] Alta de nou estudiant.");
  17.       System.out.println("[2] Reassignar el grup d'un estudiant.");
  18.       System.out.println("[3] Llistar Estudiants.");
  19.       System.out.println("[4] Llistar Grups.");
  20.       System.out.println("[0] Sortir.");
  21.       switch(llegirEnter("Tria una opció")) {
  22.         case 0:
  23.           executar = false;
  24.           break;
  25.         case 1:
  26.           altaEstudiant(db);
  27.           break;
  28.         case 2:
  29.           reassignaGrup(db);
  30.           break;
  31.         case 3:
  32.           llistaEstudiants(db);
  33.           break;
  34.         case 4:
  35.           llistaGrups(db);
  36.           break;
  37.         default:
  38.           System.out.println("Opció incorrecta.");
  39.       }
  40.     }
  41.  
  42.     db.close();
  43.   }
  44.  
  45.   public void altaEstudiant(ObjectContainer db) {
  46.     final String nom = llegirText("Nom del nou estudiant");    
  47.  
  48.     Predicate p = new Predicate<Estudiant>() {
  49.       @Override
  50.       public boolean match(Estudiant e) {
  51.         //Codi per al criteri de cerca
  52.         return nom.equals(e.getNom());
  53.       }
  54.     };
  55.  
  56.     ObjectSet<Estudiant> estudiants = db.query(p);
  57.  
  58.     if (estudiants.size() > 0) {
  59.       System.out.println("Aquest estudiant ja existeix.");
  60.     } else {
  61.       String nomGrup = llegirText("Nom del seu grup");
  62.       GrupTreball tr = new GrupTreball(nomGrup, null);
  63.       ObjectSet<GrupTreball> grups = db.queryByExample(tr);
  64.       GrupTreball nouGrup = null;
  65.       if (grups.size() > 0) {
  66.         nouGrup = grups.next();
  67.         System.out.println("El nou estudiant s'ha afegit a un grup ja existent");
  68.       } else {
  69.         String tema = llegirText("Aquest grup és nou. Temàtica del grup? ");
  70.         nouGrup = new GrupTreball(nomGrup, tema);
  71.       }
  72.       Estudiant estudiant = new Estudiant(nom, nouGrup);
  73.       db.store(estudiant);
  74.     }
  75.   }
  76.  
  77.   public void reassignaGrup(ObjectContainer db) {
  78.     final String nom = llegirText("Nom del nou estudiant");
  79.  
  80.     Predicate p = new Predicate<Estudiant>() {
  81.       @Override
  82.       public boolean match(Estudiant e) {
  83.         //Codi per al criteri de cerca
  84.         return nom.equals(e.getNom());
  85.       }
  86.     };
  87.  
  88.     ObjectSet<Estudiant> estudiants = db.query(p);
  89.  
  90.  
  91.     if (estudiants.size() == 0) {
  92.       System.out.println("Aquest estudiant no existeix.");
  93.     } else {
  94.       Estudiant estudiant = estudiants.next();
  95.       String nomGrup = llegirText("Nom del seu nou grup");
  96.       GrupTreball tr = new GrupTreball(nomGrup, null);
  97.       ObjectSet<GrupTreball> grups = db.queryByExample(tr);
  98.       if (grups.size() == 0) {
  99.         System.out.println("Aquest grup no existeix.");
  100.       } else {
  101.         GrupTreball nouGrup = grups.next();
  102.         GrupTreball anticGrup = estudiant.getGrupTreball();
  103.         estudiant.reassignaGrup(nouGrup);
  104.         //Queda algú a l'antic grup?
  105.         if (anticGrup.getNumEstudiants() == 0) {
  106.           db.delete(anticGrup);
  107.         }
  108.         db.store(estudiant);
  109.       }
  110.     }
  111.   }
  112.  
  113.   public void llistaEstudiants(ObjectContainer db) {
  114.     Predicate p = new Predicate<Estudiant>() {
  115.       @Override
  116.       public boolean match(Estudiant e) {
  117.         //Codi pel criteri de cerca
  118.         return true;
  119.       }
  120.     };
  121.  
  122.     ObjectSet<Estudiant> estudiants = db.query(p);
  123.  
  124.     while (estudiants.hasNext()) {
  125.       System.out.println(estudiants.next());
  126.     }
  127.   }
  128.  
  129.   public void llistaGrups(ObjectContainer db) {
  130.     GrupTreball e = new GrupTreball(null, null);
  131.     ObjectSet<GrupTreball> grups = db.queryByExample(e);
  132.     while (grups.hasNext()) {
  133.       System.out.println(grups.next());
  134.     }
  135.   }
  136.  
  137.   public String llegirText(String pregunta) {
  138.     Scanner in = new Scanner(System.in);
  139.     String res = null;
  140.     while (res == null) {
  141.       System.out.print(pregunta + ": ");
  142.       res = in.next();
  143.       if ("".equals(res))
  144.         res = null;
  145.       in.nextLine();
  146.     }
  147.     return res;
  148.   }
  149.  
  150.  public int llegirEnter(String pregunta) {
  151.     Scanner in = new Scanner(System.in);
  152.     int res = -1;
  153.     while (res == -1) {
  154.       System.out.print(pregunta + ": ");
  155.       try {
  156.         res = in.nextInt();
  157.       } catch (Exception ex) {
  158.         System.out.println("Entrada invàlida.");
  159.       }
  160.       in.nextLine();
  161.     }
  162.     return res;
  163.   }
  164.  
  165.   public static void main (String[] args) {
  166.     GestionarTreballs programa = new GestionarTreballs();
  167.     programa.start();
  168.   }
  169. }

Gestió de clients i encàrrecs mitjançant db4o

L’objectiu d’aquesta activitat és veure com gestionar la persistència d’objectes usant la BDOO db4o.

Feu un programa que gestioni els objectes d’una base de dades de clients d’acord al diagrama següent:

Figura

El programa ha de poder donar les opcions següents:

  • Afegir un nou tipus de producte.
  • Afegir un nou client.
  • Afegir un nou encàrrec a un client; l’encàrrec pot contenir més d’un tipus de producte associat.
  • Llistar tots els tipus de producte al sistema.
  • Llistar les dades d’un client i tots els seus encàrrecs fins ara.

Els tipus de producte i els clients s’identifiquen de manera única pel nom (només pot haver-hi un únic objecte amb un nom donat). Per a aquest exercici no cal que gestioneu la persistència d’actualitzacions entre diferents execucions. 

  1. public class TipusProducte {
  2.   private String nom;
  3.   private float preu;
  4.  
  5.   public TipusProducte(String n, float p) {
  6.     nom = n;
  7.     preu = p;
  8.   }
  9.  
  10.   @Override
  11.   public String toString() {
  12.     return  nom + ":" + preu;
  13.   }
  14. }
public class Quantitat {
  private TipusProducte tipusProducte;
  private int nre;

  public Quantitat(TipusProducte tp, int n) {
    tipusProducte = tp;
    nre = n;
  }

  @Override
  public String toString() {
    return tipusProducte.toString() + " - " + nre;
  }

}
  1. import java.util.*;
  2.  
  3. public class Client {
  4.   private String nom;
  5.   private String aPostal;
  6.   private String aMail;
  7.   private String telefon;
  8.   private List<Encarrec> liComandes = new LinkedList<Encarrec>();
  9.  
  10.   public Client(String n, String ap, String am, String t) {
  11.     nom = n;
  12.     aPostal = ap;
  13.     aMail = am;
  14.     telefon = t;
  15.   }
  16.  
  17.   public String getNom() {
  18.     return nom;
  19.   }
  20.  
  21.   public String getAPostal() {
  22.     return aPostal;
  23.   }
  24.  
  25.   public String getAMail() {
  26.     return aMail;
  27.   }
  28.  
  29.   public String getTelefon() {
  30.     return telefon;
  31.   }
  32.  
  33.   public int getNreComandes() {
  34.     return liComandes.size();
  35.   }
  36.  
  37.   public void addComanda(Encarrec e) {
  38.     liComandes.add(e);
  39.   }
  40.  
  41.   public List<Encarrec> getComandes() {
  42.     return liComandes;
  43.   }
  44.  
  45.   @Override
  46.   public String toString() {
  47.     String res = nom + " : " + aPostal + " : (" + aMail +
  48.            ", " + telefon + ")\n";
  49.     Iterator<Encarrec> it = liComandes.iterator();
  50.     while (it.hasNext()) {
  51.       Encarrec e = it.next();
  52.       res += e.toString() + "\n";
  53.      }
  54.     return res;
  55.   }
  56.  
  57. }
  1. import java.util.*;
  2.  
  3.  
  4. public class Encarrec {
  5.  
  6.   private Date data;
  7.   private List<Quantitat> productes = new LinkedList();
  8.  
  9.   public Encarrec () {
  10.     data = new Date();
  11.   }
  12.  
  13.   public void addProductes(TipusProducte tp, int n) {
  14.     productes.add(new Quantitat(tp, n));
  15.   }
  16.  
  17.   @Override
  18.   public String toString() {
  19.     String res = "Data = " + data + ":\n" ;
  20.     Iterator<Quantitat> it = productes.iterator();
  21.     while (it.hasNext()) {
  22.       res += it.next().toString() + "\n";
  23.     }
  24.     return res;
  25.   }
  26. }
  1. import java.util.*;
  2. import com.db4o.*;
  3. import com.db4o.config.EmbeddedConfiguration;
  4.  
  5. public class GestionarClients {
  6.  
  7.   public void start() {
  8.     EmbeddedConfiguration config = Db4oEmbedded.newConfiguration();
  9.     config.common().objectClass(Client.class).cascadeOnUpdate(true);
  10.     config.common().objectClass(Encarrec.class).cascadeOnUpdate(true);
  11.     config.common().objectClass(Quantitat.class).cascadeOnUpdate(true);
  12.     config.common().objectClass(TipusProducte.class).cascadeOnUpdate(true);
  13.     ObjectContainer db = Db4oEmbedded.openFile("BDOOClientsEx4.db4o");
  14.  
  15.     boolean executar = true;
  16.  
  17.     while (executar) {
  18.       System.out.println("[1] Afegir Tipus de Producte.");
  19.       System.out.println("[2] Afegir Client.");
  20.       System.out.println("[3] Afegir Encàrrec.");
  21.       System.out.println("[4] Llistar tipus de productes a la BDOO.");
  22.       System.out.println("[5] Mostrar client i els seus encàrrecs.");
  23.       System.out.println("[0] Sortir.");
  24.       switch(llegirEnter("Tria una opció")) {
  25.         case 0:
  26.           executar = false;
  27.           break;
  28.         case 1:
  29.           afegirProducte(db);
  30.           break;
  31.         case 2:
  32.           afegirClient(db);
  33.           break;
  34.         case 3:
  35.           afegirEncarrec(db);
  36.           break;
  37.         case 4:
  38.           llistarProductes(db);
  39.           break;
  40.         case 5:
  41.           llistarClient(db);
  42.           break;
  43.         default:
  44.           System.out.println("Opció incorrecta.");
  45.       }
  46.     }
  47.     db.close();
  48.   }
  49.  
  50.   public void afegirProducte(ObjectContainer db) {
  51.     String nom = llegirText("Nom del Producte");
  52.     //Cal cercar primer si ja existeix a la BDOO, o se'n crearà una còpia!
  53.     TipusProducte p = new TipusProducte(nom, 0);
  54.     ObjectSet<TipusProducte> prods = db.queryByExample(p);
  55.     if (prods.size() > 0) {
  56.       System.out.println("Aquest tipus de producte ja existeix.");  
  57.     } else {    
  58.       float preu = llegirReal("Preu");
  59.       p = new TipusProducte(nom, preu);
  60.       db.store(p);
  61.       System.out.println("Producte emmagatzemat");
  62.     }
  63.   }
  64.  
  65.   public void afegirClient(ObjectContainer db) {
  66.     String nom = llegirText("Nom del Client");
  67.     //Cal cercar primer si ja existeix a la BDOO, o es crearà una còpia!
  68.     Client c = new Client(nom, null, null, null);
  69.     ObjectSet<Client> clis = db.queryByExample(c);
  70.     if (clis.size() > 0) {
  71.       System.out.println("Aquest client ja existeix.");
  72.     } else {
  73.       String ap = llegirText("Adreça");
  74.       String am = llegirText("E-Mail");
  75.       String tl = llegirText("Telefon");
  76.       c = new Client(nom, ap, am, tl);
  77.       db.store(c);
  78.       System.out.println("Client emmagatzemat");
  79.     }
  80.   }
  81.  
  82.   public void afegirEncarrec(ObjectContainer db) {
  83.     String nom = llegirText("Nom del Client");
  84.     //Cal cercar si el client existeix
  85.     Client c = new Client(nom, null, null, null);
  86.     ObjectSet<Client> clis = db.queryByExample(c);
  87.     if (clis.size() == 0) {
  88.       System.out.println("Aquest client no existeix.");
  89.     } else {
  90.       Client client = clis.next();
  91.       boolean afegir = true;
  92.       Encarrec encarrec = new Encarrec();
  93.       while (afegir) {        
  94.         nom = llegirText("Nom del Producte (escriu \"fi\" per acabar)");
  95.         if ("fi".equals(nom)) {
  96.           afegir = false;
  97.         } else {
  98.           TipusProducte p = new TipusProducte(nom, 0);
  99.           ObjectSet<TipusProducte> prods = db.queryByExample(p);
  100.           if (prods.size() == 0) {
  101.             System.out.println("Aquest producte no existeix.");
  102.           } else {
  103.             TipusProducte prod = prods.next();
  104.             int nre = llegirEnter("Quantiat");
  105.             encarrec.addProductes(prod, nre);
  106.           }
  107.         }
  108.       }
  109.       client.addComanda(encarrec);
  110.       db.store(client);
  111.       System.out.println("Encàrrec emmagatzemat");
  112.     }
  113.   }
  114.  
  115.   public void llistarProductes(ObjectContainer db) {
  116.     TipusProducte p = new TipusProducte(null, 0);
  117.     ObjectSet<TipusProducte> prods = db.queryByExample(p);
  118.     System.out.println("Llista de tipus de productes:");
  119.     while (prods.hasNext()) {
  120.       System.out.println(prods.next());  
  121.     }
  122.   }
  123.  
  124.   public void llistarClient(ObjectContainer db) {
  125.     String nom = llegirText("Nom del Client");
  126.     //Cal cercar si el client existeix
  127.     Client c = new Client(nom, null, null, null);
  128.     ObjectSet<Client> clis = db.queryByExample(c);
  129.     if (clis.size() == 0) {
  130.       System.out.println("Aquest client no existeix.");
  131.     } else {
  132.       Client client = clis.next();
  133.       System.out.println(client);
  134.     }
  135.   }
  136.  
  137.   public String llegirText(String pregunta) {
  138.     Scanner in = new Scanner(System.in);
  139.     String res = null;
  140.     while (res == null) {
  141.       System.out.print(pregunta + ": ");
  142.       res = in.next();
  143.       if ("".equals(res))
  144.         res = null;
  145.       in.nextLine();
  146.     }
  147.     return res;
  148.   }
  149.  
  150.  public int llegirEnter(String pregunta) {
  151.     Scanner in = new Scanner(System.in);
  152.     int res = -1;
  153.     while (res == -1) {
  154.       System.out.print(pregunta + ": ");
  155.       try {
  156.         res = in.nextInt();
  157.       } catch (Exception ex) {
  158.         System.out.println("Entrada invàlida.");
  159.       }
  160.       in.nextLine();
  161.     }
  162.     return res;
  163.   }
  164.  
  165.  public float llegirReal(String pregunta) {
  166.     Scanner in = new Scanner(System.in);
  167.     float res = -1;
  168.     while (res == -1) {
  169.       System.out.print(pregunta + ": ");
  170.       try {
  171.         res = in.nextFloat();
  172.       } catch (Exception ex) {
  173.         System.out.println("Entrada invàlida.");
  174.       }
  175.       in.nextLine();
  176.     }
  177.     return res;
  178.   }
  179.  
  180.   public static void main (String[] args) {
  181.     GestionarClients programa = new GestionarClients();
  182.     programa.start();
  183.   }
  184.  
  185. }

Instal·lació i ús de JDO

L’objectiu d’aquesta activitat és veure com usar una BDDOO basada en JDO mitjançant el vostre IDE.

Aneu a la pàgina de la BDOO JDOInstruments i descarregueu les seves biblioteques i la documentació. Llegiu la documentació per veure de quina manera podeu usar les biblioteques per generar programes mitjançant el vostre IDE. Un cop fet, executeu correctament l’exemple proporcionat amb les llibreries (a la carpeta “linuxexample” o “windiowsexample”, segons el vostre sistema operatiu).

Anar a la pàgina anterior:
Aplicacions amb BD orientades a objectes
Anar a la pàgina següent:
Exercicis