MVC (Model View Controller)
in die gui (View) machste erstmal den normalen aufbau.
dann schreibs du für die textfelder jewweils eine settext methode in die gui z.B
dann hast du einen "controller" den du sogesehen als Listener machst, also er wartet auf die buttonklicks und reagiert darauf.
dein Model (da liegen die daten) ist einfach nur deine datenbank.
der controller muss daher auf die datenbank zugreifen können.
bei buttonklick kriegt der controller es dann mit.
darauf holt er sich was aus der datenbank und nutzt dann die settext methoden um das textfeld zu füllen.
so würde ich es nach deiner beschriebung jetzt machen.
richtiges mvc wurde uns in der uni aber bischen anders erklärt, da ist die view wirklich nur darstellung, der controller vermitteln zum model, was die view so macht (Daten ändern etc) und die View ist ein "Observer" und das Model "Observable".
durch sowas wie notifyObservers() sagt das model dann hey meine daten haben sich geändert und die gui aktualisiert sich. beispiel hab ich auch noch irgendwo, ich such mal und editier es dann rein
Edit:: ok hab doch keins mehr xd ich bastel dir schnell ein kleines verständliches beispiel zu mvc
Unser Model
Java:
import java.util.Observable;
import java.util.Vector;
//Überwachte daten
public class Model extends Observable{
private Vector<String> namen = new Vector<String>();
public void addName(String name)
{
this.namen.add(name);
//hier setzen wir ein flag das sich etwas geändert hat, dann benachrichtigen wir die überwacher.
//ist ein flag gesetzt, wird deren update methode aufgerufen
this.setChanged();
this.notifyObservers();
}
public void deleteName(String name)
{
if(namen.contains(name))
this.namen.remove(name);
this.setChanged();
this.notifyObservers();
}
//damit sich die view auch irgendwie mit den namen updaten kann
public Vector<String> getNames()
{
return namen;
}
}
unser controller
Java:
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
//einfacher listener aufbau, leitet sogesehen von view zum model
public class Controller implements ActionListener{
private View view;
private Model model;
public Controller(View v, Model m)
{
this.view=v;
this.model=m;
for(JButton b : view.getComponentsForController())
{
b.addActionListener(this);
}
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(e.getActionCommand().equals("add"))
model.addName(view.getTextAtField());
else if(e.getActionCommand().equals("delete"))
model.deleteName(view.getTextAtField());
}
}
unsere view
Java:
import java.awt.Component;
import java.util.*;
import javax.swing.*;
//Observer implementieren um das Model zu überwachen
public class View extends JFrame implements Observer{
//Unser Model, wir erstellen es einfach, normal wäre ein verweis auf was vorhandenes (z.B. Datenbank)
private Model model = new Model();
private JTextField text;
private JButton add,delete;
private JScrollPane scroll;
private JTextArea data;
private JLabel label;
public View()
{
super("MVC Test");
init();
//Wichtig, damit wir model überwachen können
model.addObserver(this);
this.setVisible(true);
Controller c = new Controller(this,model);
}
//gui aufbau
public void init()
{
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(null);
setBounds(200,200,190,300);
text=new JTextField();
text.setBounds(10,10,150,30);
getContentPane().add(text);
add = new JButton("Add");
add.setActionCommand("add");
add.setBounds(10,50,70,30);
getContentPane().add(add);
delete=new JButton("Delete");
delete.setActionCommand("delete");
delete.setBounds(90,50,70,30);
getContentPane().add(delete);
label = new JLabel("<html><u><b>Data:</u></b></html>");
label.setBounds(75,80,50,30);
getContentPane().add(label);
data=new JTextArea();
data.setEditable(false);
scroll = new JScrollPane(data);
scroll.setBounds(10,110,155,120);
getContentPane().add(scroll);
}
//gebe componenten zurück, die den controller als listener brauchen.
//alternativ auch eine funktion in controller, die einen componenten bekommt,
//worauf der controller sich danach selbst als listener einträgt
public JButton[] getComponentsForController()
{
return new JButton[] {this.add,this.delete};
}
//damit der controller an die daten aus dem textfeld kommen kann
public String getTextAtField()
{
return text.getText();
}
//unsere methode aus dem interface oberserver, sie wird ausgeführt wenn ein "obervable" notify aufruft
@Override
public void update(Observable o, Object arg) {
// TODO Auto-generated method stub
//daten leeren
this.data.setText("");
//daten neu einlesen
for(String s : model.getNames())
{
this.data.append(s+"\n");
}
}
public static void main(String[] args)
{
View v = new View();
}
}
Ziel dabei ist es, die View "austauschbar" zu machen. d.h. alles muss möglichst "unabhängig sein", hab ich jetz glaub ich auch ncht zu 100%, aber am ende, wenn alles perfekt ist, soll es möglich sein, an die stelle der View einfach irgendeine andere View tun zu können, also "austauschbare" komponenten möglich zu machen.
deswegen sollte z.B. der Controller auch auf keinsten fall irgendwie auf das textfeld oder ähnliches selber zugreifen, sondern die gui sollte methoden bieten, die den inhalt des textfeldes wiedergeben.
selbiges mit den Button, wollte eigentlich über nen Component[] iterieren aber da ging das ganze mit dem actionlistener irgendwie nicht, deswegen einfach jetzt mit jbuttons gemacht
wie das ganze jetzt aber mit datenbanküberwachung aussieht, weiß ich nicht genau.
könntes den controller als "reinen vermittler nehmen".
Habe nicht so ganz verstanden was du erreichen willst, bzw wie genau der ablauf da nun ist, mit button klicks und daraus wird irgendwas neues mit icon etc erstellt ... etwas Code wäre gut
so wie ichs verstanden habe:
button wird geklickt, controller sendet irgendeine abfrage, kriegt was zurück, gibt das der gui.
was die gui nun damit macht ist ihre sache (also sollte das erstellen klar da rein, denn, gui soll austauschbar sein, und eine andere gui könnte mit den gleichen daten [icon bliblablub] etwas ganz anderes erstellen
)
Edit2:: Kritik von anderen dazu ist auch erwünscht
Wollte mich langsam vortasten.
