Java
Pattern MVC
Model – View - Controller
Design Pattern – da Wikipedia
Un design pattern può essere definito "una
soluzione progettuale generale a un problema
ricorrente".
Il termine fu inizialmente introdotto in architettura
in un celebre saggio di Christopher Alexander; in
seguito, proprio l'opera di Alexander ispirò la
nascita di un settore dell'ingegneria del software
dedicato all'applicazione del concetto di design
pattern alle architetture software, soprattutto
object-oriented.
Oggi, l'espressione design pattern viene usata
principalmente con riferimento a questo particolare
contesto.
MVC – da Wikipedia
Model-View-Controller (MVC, talvolta tradotto in italiano
Modello-Vista-Controllore) è il nome di un design pattern
fondamentale nello sviluppo di interfacce grafiche di sistemi
software object-oriented. Originariamente impiegato dal
linguaggio Smalltalk, il pattern è stato esplicitamente o
implicitamente sposato da mumerose tecnologie moderne,
come framework basati su Java (Swing, JSF e Struts), su
Objective C o su .NET.
A causa della crescente diffusione di tecnologie basate su MVC
nel contesto di framework o piattaforma middleware per
applicazioni Web, l'espressione framework MVC o sistema MVC
sta entrando nell'uso anche per indicare specificatamente
questa categoria di sistemi (che comprende per esempio
Struts, Spring e Tapestry).
MVC – da Wikipedia
Model è il cuore dell'applicazione. Definisce i dati e le operazioni che
possono essere eseguiti su essi. Fornisce delle funzioni per l'accesso e
l'aggiornamento. Può inoltre avere la responsabilità di notificare ai
componenti della View eventuali aggiornamenti verificatisi in seguito
a richieste del Controller, al fine di permettere alle View di presentare
agli occhi degli utenti dati sempre aggiornati.
View è l'interfaccia (grafica, GUI, ma anche no) con cui l'utente
interagisce.
Il controller ha la responsabilità di trasformare le interazioni
dell'utente della View in azioni eseguite dal Model. Ma il Controller
non rappresenta un semplice "ponte" tra View e Model. Realizzando
la mappatura tra input dell'utente e processi eseguiti dal Model e
selezionando la schermate della View richieste, il Controller
implementa la logica di controllo dell'applicazione.
Pattern MVC
Model
View
Controller
MVC – Model
public class Model {
int x[] = new int[10]; // lista degli elementi
int current=0; // elemento attivo
int delta=5; // di quanto cambia la x ogni volta
public Model() {
for (int e = 0; e < 10; e++) {
x[e] = 100; // posizione iniziale
}
}
void increaseCurrent() {x[current]+=delta;}
void decreaseCurrent() {x[current]-=delta;}
void setCurrent(int c) {current=c; }
int getCurrent() {return current;}
int[] getX() {return x;}
}
MVC – View 1
public class View1 extends JPanel {
Model model=null;
public View1(Model m) {
model=m;
}
public void paintComponent(Graphics g) {
Dimension d=this.getSize();
g.setColor(Color.YELLOW);
g.fillRect(0,0,d.width,d.height);
g.setColor(Color.BLUE);
int [] x=model.getX();
for (int i=0;i<x.length; i++) {
int y=10+i*27;
g.fillOval(x[i]-3,y-3,6,6);
}
}
}
MVC – View 2 – parte 1
public class View2 extends JPanel {
Model model=null;
JLabel[] s=null;
public View2(Model m) {
model=m;
s=new JLabel[10];
this.setLayout(new GridLayout(10,1));
for (int i=0;i<10;i++) {
s[i]=new JLabel();
this.add(s[i]);
}
}
MVC – View 2 – parte 2
public void paintComponent(Graphics g) {
int [] x=model.getX();
int selected=model.getCurrent();
for (int i=0;i<x.length;i++) {
String h="<HTML><CENTER><B>";
if (i==selected) h=h+"<FONT COLOR=\"RED\">";
s[i].setText(h+x[i]);
}
Dimension d=this.getSize();
g.setColor(Color.ORANGE);
g.fillRect(0, 0, d.width, d.height);
}
}
MVC – Controller – parte 2
public class Controller implements KeyListener {
Model model;
JFrame f;
public Controller(Model m, JFrame f) {
model=m;
this.f=f;
}
public void keyPressed(KeyEvent e) { }
public void keyReleased(KeyEvent e) { }
public void keyTyped(KeyEvent e) {
char c=e.getKeyChar();
switch (c) {
case '+' : model.increaseCurrent(); break;
case '-' : model.decreaseCurrent(); break;
default:
System.out.println(c);
if ('0'<=c && c<='9') model.setCurrent(c-'0');
else Toolkit.getDefaultToolkit().beep();
}
f.repaint();
} }
MVC – finestra –a parte 1
public class Finestra extends JFrame {
JPanel contentPane;
View1 view1 = null;
View2 view2 = null;
//Overridden so we can exit when window is closed
protected void processWindowEvent(WindowEvent e) {
super.processWindowEvent(e);
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
System.exit(0);
}
}
C’e’ poi la solita classe
che contiene il main e
che crea la finestra
MVC – finestra – parte 2
public Finestra() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
Model m=new Model();
View1 view1=new View1(m);
View2 view2=new View2(m);
this.addKeyListener(new Controller(m, this));
contentPane = (JPanel) this.getContentPane();
contentPane.setLayout(new GridLayout(1,2));
this.setSize(new Dimension(400, 300));
this.setTitle("Frame Title");
contentPane.add(view1, null);
contentPane.add(view2, null);
}
}
Java
Pattern Singleton
Come fare perchè una classe possa
avere solo
una unica istanza condivisa?
Singleton - Esempio –1/2
class Arbitro {
static Arbitro instance= null;
private Arbitro() {
String s = "";
}
public static Arbitro getArbitro() {
if (instance ==null) instance=new Arbitro();
return instance;
}
public void fischia() {
//...
}
}
Singleton - Esempio – 2/2
package myPackage;
public class Simple {
public static void main(String a[]) {
new Simple();
}
Simple() {
//Arbitro a=new Arbitro();
Arbitro b=Arbitro.getArbitro();
Arbitro c=Arbitro.getArbitro();
System.out.println(b==c);
}
}
Java
Serialization
Il problema della persistenza
Persistenza dei dati
quando l’applicazione non è running:
salvataggio della struttura interna di un oggetto.
E’ un problema ricorsivo!
Serializzazione: trasformazione di oggetti in
“stream di dati” (seriali).
Il JDK prevede delle API per la serializzazione,
e la maggior parte delle sue classi sono serializzabili.
persistenza selettiva
Le variabili dichiarate
transient
non vengono serializzate.
Supporto di JDK alla persistenza
ObjectOutputStream: converte oggetti dalla
rappresentazione
in memoria a quella serializzata.
ObjectInputStream: converte oggetti dalla
rappresentazione
serializzata a quella in memoria.
Serializable: interfaccia senza metodi che marca una classe
come seralizzabile.
Externalizable: interfaccia con metodi (sottoclasse di
Serializable) che fornisce maggior controllo sul processo di
serializzazione.
ObjectInputValidation: interfaccia per verificare la corretta
decodifica di un oggetto.
Principali Metodi di ObjectOutputstream
ObjectOutputStream(OutputStream) costruttore
writeObject(Object) serializza Object
close()
flush()
reset()
writeInt(int)
writeFloat(float)
writeDouble(double)
Principali Metodi di ObjectInputstream
ObjectInputStream(InputStream) costruttore
Object readObject() deserializza Object
available()
dice quanti bytes ci sono da leggere
int readInt()
float writeFloat()
double writeDouble()
Esempio –Writer 1/2
package serialDemo;
import java.io.*;
import java.util.*;
public class Writer {
HashMap hm=new HashMap();
public Writer() {
System.out.println("WRITER-------------------------");
for (int k=1;k<=10;k+=2) {
String key=new String("a"+k);
Integer ik=new Integer(k);
hm.put(key,ik);
}
System.out.println(hm.size());
Iterator i=hm.keySet().iterator();
while (i.hasNext()) {
Object o=i.next();
System.out.println(o.toString()+"#"+
hm.get(o).toString());
}
Esempio –Writer 2/2
FileOutputStream ofs=null;
ObjectOutputStream oos=null;
try {
ofs=new FileOutputStream("serializedStream.txt");
oos=new ObjectOutputStream(ofs);
oos.writeObject(hm);
}
catch (IOException ex) { ex.printStackTrace();
}
}
//--------------------------------------------public static void main(String[] args) {
Writer writer = new Writer();
}
}
Esempio –Reader 1/2
package serialDemo;
import java.io.*;
import java.util.*;
public class Reader {
HashMap hm=null;
//-----------------------------------------public static void main(String[] args) {
Reader reader = new Reader();
}
Esempio –Reader 2/2
public Reader() {
System.out.println("READER -------------------------");
FileInputStream ofs=null;
ObjectInputStream oos=null;
try {
ofs=new FileInputStream("serialiazidStream.txt");
oos=new ObjectInputStream(ofs);
hm=(HashMap)oos.readObject();
}
catch (ClassNotFoundException ex) {
ex.printStackTrace();
}catch (IOException ex) { ex.printStackTrace();
}
System.out.println(hm.size());
Iterator i=hm.keySet().iterator();
while (i.hasNext()) {
Object o=i.next();
System.out.println(o.toString()+" #“
+hm.get(o).toString());
}
}
Java
Ripasso
Polimorfismo – ripasso
abstract class OP {
int f(int a,int b);
}
class Somma extends OP {
int f(int a,int b){
return a+b;
}
}
class Sottrazione extends OP {
int f(int a,int b){
return a-b;
}
}
Polimorfismo - ripasso
class Test {
public static void main(String[] a) {
new Test;
}
public Test() {
OP o;
...
if (i!=0) o=new Somma();
else o=new Sottrazione();
...
System.out.println(o.f(3,2));
}
}
Qual’è l’output ?
