Bestellungsverwaltung nach MVC-Standard

[Vokabulator]

Hallo!

Ich würde gerne, um die MVC-Denkweise zu lernen, ein kleines, rudimentäres Bestellungsverwaltungssystem programmieren, also GUI und Anbindung an DB, dann soll man eine Bestellung erfassen können, Produkte hinzufügen, Kunden verwalten und Rechnungen stellen und solche Dinge. Nix Großes, wenn das einfach ein bissen funzt, reichts.

Wie gestalte ich das nach MVC?

So wie ich es verstehe, wäre das Model die Klasse, die sich um die Verbindung zur Datenbank kümmert, also
- Datensätze lesen
- DB updaten
- Verbindung herstellen
- usw.

Der View wäre die grafische Oberfläche

Und der Controller verbindet view und model. D. h. ich würde im controller quasi die ganzen eventhändler handhaben, die dann die Datensätze auf der GUI anzeigen? D. h. ich lese einen Datensatz durch das Model, übergebe die Sachen an den Controller und der Controller übergibt es an den View? D. h. konkret, ich bekäme Datensätze aus der DB, die würde ich als Strings an den Controller übergeben und der Controller würde z. B. den Eventhandler zum updaten einer JTextArea beinhalten. Und umgekehrt zum Lesen der JTextArea.

Verstehe ich das so richtig?

 

[JavaMeister]

Implementiere das mal, was du da so "unkonkret" beschreibst, dann kann man drüber schauen.

Jegliche theorie zum MVC findest du im Wiki, Google. Eine million Beispiele. Und auch hier im Forum.

 

[Bartertown]

Ja das entspricht dem Datenbankprojekt des Java-Kurses denn ich gemacht habe.
Allerdings das MVC - Pattern kann hier nicht als Paradigma für die ganze Anwendung gelten.
Der View ist klar, das ist z.B. die Bestellverwaltung, der Controller ist z.B. ist der implementierte ActionListener, somit ist View und Controller sinnvollerweise gemixt.

Das Model stellt in einer Datenbankanwendung einfach eine Relation dar: Kunde , Bestellung , Person , Artikel... Die Rede ist hier auch von object relational mapping.
Bei einer Rich-Client Architektur hat jede Client-Anwendung ein DB-Management, bei einer Thin-Client ist der DB-Manager eine Server-Applikation.
Soweit ich das bisher begreife entspricht diese Datenbankverwaltung einem Command-Pattern.

Somit hättest du als View und Controller z.B.die JFrames, als Model die ganzen modellierten Datensätze und eine Klasse z.B. DB-Manager.
Aber der beschriebene Observer-Mechanismus mit dem updaten von Textfeldern denke ich ist bei so einer Anwendung nicht der Zweck, es geht eher um das updaten der (Datenbank)Modelle!
Um das MVC in reinster Form anzuwenden und zu verstehen wäre vielleicht ein kleines Grafikspiel geeigneter?

 

[dzim]

Mit Modell bezeichnet man allgemein nur die Klassen zur "Datenhaltung". Also bei dir wäre das z.B. der Kunde. Die Anbindung an die DB wird IMHO meist über den Controller gesteuert, wobei die eigentliche DB-Anbindung hüfig über sog. DAOs zustande kommt (Data Access Object). Mir fällt es tatsächlich oft schwer View und Control zu trennen, wenn ich das UI per Code erstelle (SWT oder Swing), dagegen ist es mit JavaFX oder Android relativ einfach möglich, da die die GUI "deklarativ" erstellt wird - also in separaten Dateien im XML-Format.

Ausgehend von JavaFX (wie man hier im Forum lesen kann mein Favorit unter den Java-basierten Desktop-UI-Frameworks ;-) ), würde deine Struktur wäre also ungefähr so aussehen:

Datenzugriff:
package.dao.DAOInterface (wirklich ein Interface)
package.dao.JDBCDAOImpl (die JDBC-Implementierung des o.g. Interfaces)
[offen: Wie hole ich mir ein DAOInterface-Objekt. Alter Ansatz und von manchen verpönt wäre eine Factory. Alternativ via DI (Dependency Injection) á la Guice, Eclipse e4-DI, Spring-DI, ... Für den Anfang eines kleinen Projekts aber genügt immer noch IMHO eine Factory-Klasse (bitte googlen)]

Model:
package.model.Customer
package.model.Product
package.model.[...]

View:
package.ui.layout."Main.fxml"
package.ui.layout."Dialog.fxml"
package.ui.layout.[...] <-- so viele, wie du halt brauchst, ich würde versuchen auch hier eine Trennung nach Funktionalität vorzunehmen

Control:
package.ui.MainController
package.ui.DialogController
package.ui.[...] <-- pro View ein Controller

Bevor du loslegst, musst du dir also Gedanken machen, welche Daten du holen willst (Model) und woher (DAO-Implementierung) und wie du sie darstellen möchtest (View). Darüber hinaus muss natürlich auch das UI irgendwie auf die Eingaben eines Users reagieren - das Programm also mit Logik befüllt werden (Controller).

Klar soweit?

 

[Vokabulator]

Uh, okay, doch etwas komplizierter als ich dachte Aber gut, soll ja auch eine Herausforderung werden. Ich denke, ich werd mit Swing programmieren, einfach um da auch noch fitter zu werden.

Okay, ich denke, ich fange mal an und lass das Topic mal offen. Danke auf jeden Fall für eure Antworten!

 

[dzim]

Nur damit ich wieder das sage, was ich (so ähnlich) immer im Fall einer Entscheidung auf Swing sage:
"Swing ist tot, SWT stirbt - nutzt JavaFX! Das ist für die hippen Kids! Alles andere ist Old-School..."

Wenn Herausforderung, dann richtig!

Grüsse,
Daniel

 

[Vokabulator]

SO, anbei mal , was ich bisher fabriziert habe. Vielleicht hat ja noch jemand Lust, sich das zu Gemüte zu führen und ausgiebigst zu bemängeln: Main großes Problem ist nämlich, dass ich niemanden kenne, der JAVA kann und deswegen nie Feedback erhalte.

Beispiel-Model (package models):

@Entity
public class Produkte {
	
	@Id
	private int ID;
	private String bezeichnung;
	private int anzahl;
	private String Beschreibung;
	private int Preis;
	
	public Produkte() {
		
	}
	
	public Produkte(int id, String bezeichnung, int anzahl, String beschreibung, int preis) {
		this.ID = id;
		this.bezeichnung = bezeichnung;
		this.anzahl = anzahl;
		this.Beschreibung = beschreibung;
		this.Preis = preis;
	}
	
	public int getID() {
		return ID;
	}
	public void setID(int iD) {
		ID = iD;
	}
	public String getBezeichnung() {
		return bezeichnung;
	}
	public void setBezeichnung(String bezeichnung) {
		this.bezeichnung = bezeichnung;
	}
	public int getAnzahl() {
		return anzahl;
	}
	public void setAnzahl(int anzahl) {
		this.anzahl = anzahl;
	}
	public String getBeschreibung() {
		return Beschreibung;
	}
	public void setBeschreibung(String beschreibung) {
		Beschreibung = beschreibung;
	}
	public int getPreis() {
		return Preis;
	}
	public void setPreis(int preis) {
		Preis = preis;
	}
}

Beispiel DAO (package model):

public class ProdukteDAO {
    
    public void createProdukte(Produkte p, Session s ) {
        Transaction trans = s.beginTransaction();
        s.saveOrUpdate(p);
        trans.commit();
        } 
}

View bisher (package view)

public class MainGUI {

	private JFrame frame;
	private JMenuBar menubar;
	private JMenu dateimenu;
	private JMenu optionsmenu;
	private JToolBar toolbar;
	private JButton button_rechnung;
	private JButton button_bestellung;
	private JButton button_statistik;
	private ImageIcon rechnung_icon;
	private ImageIcon bestellung_icon;
	private ImageIcon statistik_icon;
	private JPanel pane;
	
	public MainGUI() {
		createGUI();
	}
	
	private void createGUI()  {
		frame = new JFrame();
		frame.setSize(1200, 700);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setLocationRelativeTo(null);
		frame.setResizable(false);
		frame.setLayout(new BorderLayout());
		createMenuBar();
		createToolBar();
		createLeftMenu();
		frame.setVisible(true);
	}
	
	private void createMenuBar() {
		menubar = new JMenuBar();
		dateimenu = new JMenu("Datei");
		optionsmenu = new JMenu("Optionen");
		menubar.add(dateimenu);
		menubar.add(optionsmenu);
		frame.setJMenuBar(menubar);
	}
	
	private void createToolBar() {
		toolbar = new JToolBar();
		toolbar.setSize(1200,80);
		createToolbarButtons();
		frame.add(toolbar,BorderLayout.NORTH);
	}
	
	private void createToolbarButtons() {
		rechnung_icon = new ImageIcon("rechnung.jpg");
		bestellung_icon = new ImageIcon("bestellung.gif");
		statistik_icon = new ImageIcon("statistik.jpg");
		
		button_rechnung = new JButton(rechnung_icon);
		button_bestellung = new JButton(bestellung_icon);
		button_statistik = new JButton(statistik_icon);
		
		toolbar.add(button_bestellung);
		toolbar.add(button_rechnung);
		toolbar.add(button_statistik);
		}
	
	private void createLeftMenu() {
		pane = new JPanel();
		pane.setSize(400, 620);
		pane.setBackground(Color.BLUE);
		JButton button = new JButton("Hallo");
		button.setSize(400, 80);
		pane.add(button);
		frame.add(pane,BorderLayout.WEST);
	}
}

Controller (package controller)

public class MainController {

	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {

			@Override
			public void run() {
				new MainGUI();
				Configuration configuration = new Configuration().configure();
				StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder()
						.applySettings(configuration.getProperties());
				SessionFactory factory = configuration
						.buildSessionFactory(builder.build());
				Session session = factory.openSession();
				Produkte produkte = new Produkte(1,"Decke",2,"Das ist eine Decke",20);
				ProdukteDAO produktedao = new ProdukteDAO();
				
				produktedao.createProdukte(produkte,session);
				
				session.close();
				factory.close();
			}
		});
	}
}