Java und Datenbanken Nr. 1

Bis Sonntag sollte das Backbone unseres Projektes, die Datenbank in ihrer ersten Version stehen. Dazu wird die Oracle Datenbank auf dem Almighty verwendet. Dafür müssen vorher bis Freitag alle Entity Klassen mit allen ihren Attributen definiert worden sein.

Der Zugriff auf die Datenbank sollte eventuell über eine eigene Controller Klasse erfolgen..

Bis jetzt habe ich keine Ahnung wie man mit Java auf Oracle Datenbanken zugreift, damit werde ich mich bis Freitag beschäftigen.

Diagramm-Salat

Nach dem vierten Meeting am 6.5. ist etwas Licht in das Diagrammwirrwarr gekommen. Es wird angestrebt bis Freitag:

- Die Beziehungen in das Übersichtsklassendiagramm einfügen

- Sequenzdiagramm für drei Use Cases (inklusive dazugehörende Klassendiagramme)

- Komponenten und zugehöriges Deploymentdiagramm

fertigzustellen.

 

Der Prototyp ist schon in 14 Tagen(!!!) abzugeben, darum dürfen wir nicht zu lange für diese Diagramme brauchen und es sollten anschließend nicht mehr viele Änderungen notwendig sein.

 

Kommando retour!?

Monsterklassen

Ich hätte mir wohl bevor ich ans Werk gehe das Softwareentwicklungs-Tutorial genauer durchlesen sollen. Das Problem, das mir gerade beim Lesen gekommen ist, ist vielfältiger Natur:

  • Die meisten meiner Klassen sind zu komplex
  • Die Klassen sind nicht sauber nach Boudary-/Controller-&Entity-Klassen getrennt. Sehr häufig verrichtet eine einfache Entity-Klasse zusätzlich Aufgaben von Boundary- oder Controller-Klassen. So zum Beispiel die eigentlich als Entity-Klasse gedachte User-Klasse. Sie sollte eigentlich nur die Stammdaten, das Registrierungsdatum, etc. abspeichern, die toString()-methode als Abstrakte Methode versehen und als superklasse für die 3 anderen Entity-Klassen Sklave, Herr und Gott dienen. Mit der Zeit haben sich aber auch Funktionen dazugesellt, von denen ich mir anscheinend nicht vorstellen konnte, dass man sie in eine eigene Klasse kapseln könnte. Nun habe ich aber gerade Folgendes gelesen und das hat mich skeptisch bezüglich meinem Klassendiagramm gemacht:

Alle Funktionen die Sie besitzen haben unmittelbar mit den gespeicherten Daten zu tun (das schließt durchaus Datenmanipulation ein). Sobald aber andere Klassen gerufen werden müssen, ist die Funktion mit großer Sicherheit bei der Entity-Klasse falsch postiert. [...] Eine Funktion ‘getName’ gehört ganz klar zu ‘Mitarbeiter’. Auch ‘getTelefonNummerAsString’ ist OK, denn es werden nur die Informationen der Entity-Klasse in veränderter Form zurückgegeben. Eine Funktion ’setAnschrift’ kann OK sein, wenn nur die Anschrift geändert wird. Falls aber im Zuge der Anschriftsänderung auch die Personalabteilung über die Änderung benachrichtigt werden soll, ist es besser die Methode als ‘AendereAnschrift’ einer Control-Klasse zu geben, und die “Set”-Funktion für die Anschrift so einfach wie möglich zu halten.

  • Boundary-Klassen sind im Prinzip gar nicht vertreten. Vor allem, wenn man liest, dass kein Akteur das System ohne Boundary-Klassen benutzen kann, da dort die User-interkationen (GUI-Elemente, Formulardaten, Checkboxen etc.) gekapselt sind. Das müssen wir nachholen.

Was mir zum Verständnis auch noch etwas geholfen hat, war folgender Satz bezüglich Boundary-Klassen und ihr Verhältnis zu den anderen Klassen:

[N]iemand kann direkt auf sie Zugreifen. Alle Aktionen von außen werden von Boundary-Klassen aufgenommen, an Control-Klassen weitergeleitet und erst dann an die Entity-Klassen übergeben. Entity-Klassen sind meist auch sehr allgemein gehalten. Spezielle Funktionalitäten werden (wie oben gezeigt) an Control-Klassen übergeben.

Pointiert gesagt: Die meisten meiner identifizierten Klassen sind ein Gemisch von allen drei Klassentypen, und genau das ist es ja, was man nicht haben will. Man will ja, zwecks Übersichtlichkeit und Wiederverwendbarkeit überschaubare, kleine Klassen, um den sogenannten “Big Ball of Mud” zu verhindern, was heißt: das System leicht verstehbar, wartbar, veränderbar zu machen und die Komplexität in den Griff zu bekommen. Da müssen wir wohl nochmal ran.

Konsequenzen:

Was heißt das nun für uns?

Gottseidank haben wir es mit einem iterativen und inkrementellen SWE-Prozess zu tun, der es ja gerade ermöglichen soll, Fehler dieser oder anderer Art leicht zu beheben, da man noch nicht das komplette System entwickelt hat.

Da wir gleich ein Meeting haben, müssen wir uns überlegen, wie wir mit der vorliegenden Version umgehen wollen. Das Überblicks-Klassendiagramm und das halbe Sequenzdiagramm, das ich erstellt habe, sind zumindest die Dokumentation dafür, dass gearbeitet wurde. Die Frage ist nur, was wir heute in der Übung vorstellen werden?

Das einfachste wäre, das Sequenzdiagramm zu vervollständigen (+ die anderen Diagramme dazuzuzeichnen) und bei der Vorstellung den Hinweis zu geben , dass wir draufgekommen sind, dass die Klassen zu monströs sind und wir das überarbeiten werden.

Das aufwändigere wäre, alles von 0 auf neu zu machen und die verschiedenen Klassentypen gleich zu berücksichtigen, wobei sich die Frage stellt, ob wir das bis zum Beginn der Übung (wir haben ca. 2,5 Stunden) schaffen?

Ich optiere für die einfachere Lösung, zumal unsere Motivation (aufgrund der mangelnden Bierspenden) ohnehin im Keller ist ^^ und Stress außerdem ungesund ist.

Erste Gehversuche mit JSP und Servlets [Part3]

  • So, nun gehts endlich in den Code.

Habe heute eine nette Site gefunden, mit deren Hilfe + meinem alten JSP-Tutorial habe ich mein erstes JSP erstellt:

Grundlegende Einführung: http://www.torsten-horn.de/techdocs/index.htm#JSP

Mein erstes JSP-Anleitung: http://www.torsten-horn.de/techdocs/jee-tomcat-sysdeo.htm#JSP

Einführung in JSP-Syntax:

Dadurch hab ich mal ein erstes JSP erstellt (siehe Repository Revision 41). Und darauf hab ich versucht, das HelloServlet.java in ein JSP umzuwandeln. Das Ergebnis findet sich in derselben Revision unter HelloJSP2.jsp.

Damit man das versteht, ein paar Erläuterungen zur JSP-Syntax:

  • Expressions: Der Ausdruck wird ausgewertet und erscheint als String im HTML-Code (Kein Semikolon).

<%= counter++ %>

  • Skriptlets: JAVA-Code

<%

//Hier steht Code (auch Kommentare wie man sieht)

if (!AKA.haveBier()) AKA.motivation(”wenig”);

%>

  • Deklarationen: Das ist, soweit ich verstehe, sowas wie ein STATIC, wird also nur einmal aufgerufen. Zum Initialisieren von Variablen, etc. (Semikolon am Schluss ned vergessen!).

<%! int counter = 0; %>

  • Kommentare: unischtbar mittels JSP-Syntax (oder in Scriptlets als JAVA-Kommentare):

<%-- Ich bin ein unnützes Kommentar --%>

Im Quellcode sichtbar ganz normal mittels HTML-Syntax:

<!– Ich bin ein unnützes und sogar auffälliges Kommentar –!>

  • Direktiven: das ist ein umfangreicheres Thema. Für das Verständnis meines JSPs aber noch nicht wirklich notwendig, außer vielleicht die page-Direktive mit dem Attribut import: Dass damit benötigte Klassen oder Pakete importiert werden, kann man sich aber denken.

<%@ page import=”java.util.*” %>

Verlinken zu Servlets / anderen JSPs

Dazu einfach den Code der HelloJSP2.jsp von Revision 42 ansehen; ist - hoffe ich -selbsterklärend.

Ausblick: JAVA Beans und JSTL

Das nächste Mal, werde ich versuchen mit Beans und mit der JSP Standard Tag Library zu arbeiten. Mit Beans kann man Formulardaten einfach kapseln und dann von überall im Code darauf zugreifen. MIt der JSTL kann man die Trennung von Code und Darstellung erreichen (also quasi der Heilige Gral unseres Vorhabens - warum komm ich eigentlich immer auf religiöse Terminologie?).

Dazu möchte ich gleich mal einige Links festhalten:

Danach sollten wir uns überlegen, ob wir ein Framework wie Struts oder Java Server Faces verwenden wollen, angeblich kann man damit gut arbeiten, wenn man erstmal mit dem Framework vertraut ist.

Zu blöd, dass wir nächsten Dienstag schon alle grundsätzlichen UML-Diagramme zeichnen müssen. Denn damit man das weiß, sollte man eine Ahnung haben, wie man Boundary - Controller und Entity-Klassen auch Code-mäßig unterscheidet, also wie man das Model-View-Controller-Prinzip in Code umsetzen kann. Das ist die grundsätzliche Prolematik: Es beißt sich die Schlange in den eigenen Schwanz.

Bilder und GoogleCode - funktioniert nicht

Hallo!

Wir haben so ein tolles Logo (DANKE Conny), aber es lässt sich nicht via SVN hinaufladen.
Habe dazu TortoiseSVN benutzt. Es hat schon funktioniert, und es ist auch da, allerdings nicht so wie es sollte.

So sieht es aus aber so sollte es aussehen:

Ich habe so den leisen Verdacht, dass Google nur Plain Text files mag.
Zumindest schaut das so aus:

… also weitersuchen…

Hier noch was für die Verlinkung - wie es genau geht weis ich noch nicht, aber allerdings dürfte es egal sein, wie die Struktur der Applikation aufgebaut ist. Siehe hier.

Wenn ich mehr weis, schreibe ich es dazu!

LG Gerhard

Klassendiagramm [Klappe - die Zweite]

Nachdem ich gestern mit dem UML-Casetool nicht sehr viel Glück hatte, versuchte ich hetue ein anderes Tool:

Omondo UML Editor 2008

Man staune - die Synchronistation von JAVA-Code und UML Klassendiagramm funktioniert auf den ersten Blick einwandfrei. Dieses Bild sollte fürs erste reichen:

Klassendiagramm

Mit dieser Hilfe können wir in Zukunft Klassen-&Sequenzdiagramme erstellen und ohne Mehraufwand Vorbereitungen für den Prototypen treffen. Die Abgabe nächsten Dienstag soll ja Klassen-&Sequenzdigramme für das Code-Design enthalten.

Klassendigramm die Erste

Grüße,

Möchte heute versuchen, erste Ansätze zum Code-Design von reticulum verfertigen, d.h.: einen ersten Entwurf eines Klassendiagramms zu erstellen. Da das SlimeUML Code->Diagramm, Diagramm->Code-Funktionalitäten nicht so drauf hat (und zusätzlich auch kein Sequenzdiagramm enthält), versuche ich mal ein anderes UML-Tool. Man hat ja in diesem Fall die Qual der Wahl (vgl.: http://www.eclipseplugincentral.com/Web_Links-index-req-viewcatlink-cid-19.html ).

Habe mich für Topcased UML Editor entschieden (Bewertung, Screenshots, Beschreibung und Ermüdung waren die Entscheidungskriterien). Update-Site für direkte Eclipse-Plugin-Installation gibt es hier: http://topcased-mm.gforge.enseeiht.fr/release/update-site3.3/

Leider braucht man einen Haufen Dependencies, die man sich mühevoll aus der Plugin-Site Europa Discovery heraussuchen muss. Und der Download dauert ewiiig. La-la-la… Man stelle sich den Download mit einer 56K-Leitung vor (= immer positiv denken ^^).

Bis man da zum Diagramm-zeichnen kommt, hat man schon wieder vergessen, was man eigentlich zeichnen wollte. Da hofft wartender Student nur noch, dass das Tool zumindest brauchbar ist.

Die Vision

Während ich auf die Fertigstellung des Downloads warte, halte ich mein Big-Picture des Code-Designs kurz fest:

Man hat zunächst einmal die Klasse User als Superklasse der Klassen Gott, Herr und Sklave.

In der User-Klasse sind Basis-Attribute über die Identität des Benutzers, sein Registrierungsdatum, sein Nickname usw. gespeichert. Darüber hinaus verweist die Klasse User auf andere User-Klassen (man könnte dazu ein User-Array erstellen: User[] relatum; - sofern der Syntax stimmt ). Was hier leider noch nicht definiert ist, ist die Art der Beziehung. Man müste daher eine eigene Klasse Beziehung erstellen, die einerseits das Referenzobjekt (=Relatum) erstellt und andererseits die Art der Beziehung (ist Freund von, ist Arbeitskollege von, ist Angestellter von,… = Relator) festlegt. Diese Beziehung kommt anstelle der einfachen User-Referenz innerhalb der User-Klasse. Textuelle Beschreibungen sind einfach zu umständlich, um diese Dinge verständlich und schnell darzustellen - Gottseidank ist nun die Installation abgeschlossen.

Nur kurz noch zur Motivation: Durch die kurz skizzierten Klassen wird es möglich, dass einem beliebigerm User eine Menge von verschiedenartigen Kontakten (zu Göttern, Herren oder Sklaven) zugeordnet werden kann.

Mit dem Serialisierungskonzept von Java könnte es dann vielleicht möglich werden, dies alles persistent zu speichern (entweder in einer Datenbank oder als XML).

Einstieg in Klassendiagramme

Nachdem die Installation nun abgeschlossen ist, erstelle ich mit New Document / Topcased ein neues UML-Klassendiagramm: reticulum_iteration1.uml (siehe auch SVN-Code-Repository, dort wo auch generalclasses.cdx zu finden ist). Außerdem wechsle ich in die Perspektive Topcased-Modelling.

So - nun hab ich einmal ein paar Grundkonzepte erstellt. Nun stellt sich die Frage, wie man zu diesem Diagramm den entsprechenden Code generiert. Nach einiger Recherche in der Doku zeigt sich, dass anscheinend doch keine Code-Generierung möglich ist :( Man kann, wie ich das gezeigt habe, detaillierter als in SlimeUML Klassendiagramme erstellen, doch wie die Code-Generierung steht, wird mir heute wohl ein Rätsel bleiben. Bin zu müde, für weitere Recherchen.

Operation gelungen - Patient tot.

gn8
AKA

Erste Gehversuche mit JSP und Servlets [Part2]

Ich möchte wieder einige Ergebnisse meiner Recherchen präsentieren, die heute eher allgemeiner Art sind. Es wird zuerst um die Unterscheidung zwischen Servlets und Java Server Pages gehen. Anschließend stelle ich mir die Frage, welche Architektur-Muster es gibt, welche für uns wichtig sind. Wichtig heißt in diesem Zusammenhang:

  • Die Architektur soll genauso abstrakt sein , wie es unser Projekt erfordert. Es hilft nichts, wenn wir die halbe Zeit brauchen, das Architektur-Muster zu verstehen, während die Funktionalitäten, um die es ja beim Programmieren immer noch geht, zuweit in den Hintergrund gelangen. Eine tolle Trennung von bspsw. Programmlogik und Design hilft uns nichts, wenn wir ewig brauchen, sie zu verstehen.
  • Die Architektur soll es uns erlauben, bestimmte Code-Segmente wiederzuverwenden.
  • Die Architektur sollte es einfach machen, das Design relativ unabhängig von der Programmlogik zu machen. Zumindest sollte die Kopplung so lose sein, dass man ohne viel Mehraufwand das Design ändern kann und dass man ohne die Programmlogik in allen Einzelheiten zu verstehen Dinge am Design ändern kann.

Zum Schluss werde ich noch ein Argument bringen, warum Bierspenden von Seiten des LV-Leiters (= des Auftraggebers) unsere Motivation erhöhen können. Zunächst zu Servlets und JSPs.

Der Nachteil von Servlets - Die Wendung zu JSPs

Das folgende Argument, warum man sich mit JSPs beschäftigen und nicht nur rein Servlets machen sollte, habe ich wieder (wie nahezu alles in diesem Teil incl. der Grafiken) im JSP-Tutorial gefunden und sieht folgendermaßen aus:

[Bei Servlets] ist die Verwendung mehrerer out.println()-Statements zur Generierung der HTML-Antwortseite extrem aufwändig und nicht sehr übersichtlich. [...] Die Trennung zwischen Webdesign und Programmierung der dynamischen Inhaltsanforderungen ist [bei Servlets] nicht sauber möglich.
An dieser Stelle setzen nun die JSPs ein, die genau diese Trennung versprechen einzulösen. Dazu werden reine HTML-Seiten genommen und um spezifische Tags und JSP-Angaben erweitert.3 Diese JSP-Seiten werden nun genommen und im Laufe ihres [...] Lebenszyklus in Servlets umgewandelt, die dann bei HTTP-Anfragen zur Ausführung kommen.

Einfach gesagt kann man bei JSPs in HTML-Code Java-Code einbinden, während man bei Servlets umständlich mit out.println()-Befehlen den HTML-Code genereieren muss. Server Pages bringen Einiges an Übersichtlichkeit und das ist eigentlich auch die Kritik am Servlet-Only-Architekturmodell 1, das ich jetzt erklären will.

Model 1: Servlet-only

Ablauf bei JSP/Servlets

Das markante an diesem Modell:

  • für fast jede Seite gibt es eine JSP oder ein Servlet
  • Links zu anderen Seiten der Applikation sind meistens “hard-coded” (also statisch vorgegeben)
  • Die Geschäftslogik ist von den JSPs/Servlets getrennt, wird aber von ihnen aus aufgerufen.

JSP-Tutorial betont:

Für einfachere Anwendungen ist das Model1 auch heute noch völlig ausreichend.

Doch das Problem, das man halt noch immer hat ist:

  • Trotz Trennung zwischen View-basiertem Code (JSPs/Servlets) und Geschäftslogik gibt es bei Servlets immer noch das Problem, dass man HTML-Output hat, den man nur mit unschönen out.println()-Aufrufen erzeugen kann. Das schaut besch***en aus und ist auch schwer zu warten, weil man die Übersicht verliert.

Model 1: JSP-basiert

Hier hat man es wieder mit einer seitenzentrierten Architektur zu tun - das heißt, dass es pro Seite ein JSP gibt. Was JSPs nun zulassen:

Zumeist [..] läuft der Prozess so, dass die Webseiten von der Designerin kommen und von der Programmiererin anschließend der Programm-Code in die Seite eingebettet wird. Anstelle von HTML-Ausgaben im Java-Code hat man nun Java-Code in HTML eingebettet.

Da aber nun der Designer sowenig Details wie möglich vom Programmcode sehen will, musste man sich überlegen, wie man diesen verstecken konnte. Hier kommen Beans, Custom Tags und die Expression Language ins Spiel:

Damit wurde der Java-Anteil (wenn man denn vernünftigen Gebrauch von Custom Tags machte) erheblich gesenkt.

Model 2: Abwandlung von MVC für die Eigenheiten des HTTP-Protokolls

TODO: Evt. Kurz auf Struts und JavaServer Faces eingehen

Das Grundprinzip lässt sich folgendermaßen kurz erklären:

  • Controller = Dispatcher-Servlet: Nimmt alle Anfragen und Eingaben des Nutzers entgegen und verteilt diese dann - je nach Art der Anfrage - an sog. Handler-Servlets.
  • Handler-Servlet: liest die Daten der Anfrage/Eingabe aus dem Request aus und wandelt sie in die richtigen Datentypen für das Modell.
  • Modell beherbergt die Applikationslogik und den aktuellen Zustand. (Benachrichtigungen an Observer-Objekte, normalerweise Views, können beim HTTP-Protokoll nicht erfolgen)
  • View gibt den aktuellen Zustand des Modells wieder und stellt diese dar.

Struts und JavaServer Faces sind Ausprägungen dieser Architektur. Es wird genau beschrieben, wie diese beiden Frameworks arbeiten, auf den ersten Blick ist es aber doch recht komplex und man fragt sich, ob wir das in unserem Projekt brauchen oder ob nicht ein JSP-basiertes Model 1 ausreicht?

Doch das ist noch nicht alles - jetzt kommt erst die Pointe, die ich in diesem JSP-Tutorial-Kapitel über Architekturprinzipien erfahren habe: Architektur ist nicht alles…

Wie frisch gewaschene Handtücher Projekte optimieren

Natürlich ist eine gute Architektur toll, doch sie ist nicht alles, um Projekte erfolgreich bewältigen zu können. Man braucht auch ein tolles Team, das sich untereinander versteht und das sich motiviert fühlt, das Projekt anzupacken:

Wenn die Chemie im Team und zwischen dem Team und seiner Umgebung nicht stimmt, ist ein Projekt auch mit einer durchdachten Architektur kaum zu retten.[...] Wer nun denkt, dass dies lediglich Kleinigkeiten seien, der sollte sich mal mit den Problemen vertraut machen, die Microsoft sich durch die Kürzung der Benefits eingehandelt hat. Bekannt wurde hierbei vor allem der Towel-Service: Das erneute kostenlose Waschen von Handtüchern in den Microsoft-Umkleidekabinen wurde auf einer Mitarbeiterversammlung bei der Vorstellung diverser Neuigkeiten am stärksten gefeiert. Hier geht es um die implizit mit solchen Maßnahmen ausgedrückte Wertschätzung, bzw. die mit dem Streichen oder Schaffen solcher kleinen Maßnahmen verbundene Veränderung der Wertschätzung. Die psychologische Wirkung, die durch die Schaffung einer angenehmen Arbeitsumgebung und kleiner Anreize, erzielt wird, sollte nicht unterschätzt werden. Wenn die weichen Faktoren nicht stimmen, hat man ein gravierenderes Problem, als wenn die Architektur nicht ganz sauber eingehalten wird.

Wer motivierte Studenten und gute Projekte haben will, sollte sich analog zu Microsoft Anreize überlegen. Wir wären schon mit einer kleinen alkoholischen Spende zufrieden. ;)

Das nächste mal wird weniger auf Geschwafel - mehr auf Ausprobieren der Möglichkeiten von JSP+Servlets gezielt.

Erste Gehversuche mit JSP und Servlets [Part1]

Die Vorsehung

Ich werde mich in den nächsten Tagen mit den Möglichkeiten von JSP und Servlets beschäftigen. Wichtig ist mir dabei folgendes:

  • den Code möglichst übersichtlich halten
  • Trennung von Applikationslogik und Darstellung (damit die Designentscheidungen die ich treffe, leicht geändert werden können)
  • Die Wiederverwendung von Code, das wird wohl heißen: Code in Klassen kapseln und möglichst allgemein schreiben.

Eine Spur: Java Beans

Soweit ich gesehen habe, wird es dabei auch notwendig sein, sich mit Java Beans zu beschäftigen. Dabei geht es um Folgendes: Oft ist es…

[...]wünschenswert, mittels Introspektion und Reflection Informationen zu beteiligten Objekten ermitteln zu können. Damit dies gelingen kann, ist eine Namens-Konvention unerlässlich, um bspw. Arbeits-Methoden von Methoden unterscheiden zu können, die den Zugriff auf gekapselte Attribute ermöglichen.

Mit Namenskonvention ist scheinbar gemeint, setAttribute() und getAttribute()-Methoden immer mit der gleichen Bezeichnung zu verwenden. Das heißt set und get stehen immer vorne und danach kommt, der erste Buchstabe wird groß geschrieben, der Attributname, der entweder gelesen (get) oder geschrieben (set) wird. Also Datenkapselung mit Namenskonventionen.

Go Hardcore: Grundlegendes zu JSP/Beans

Erste Anlaufstelle ist (von dort ist auch das obige Zitat): http://www.jsptutorial.org wo die Dinge, die ich brauche (JSP, Servlets, Beans) ziemlich ausführlich beschrieben werden.

Es gibt anscheinend bestimmte Entwicklungsmodelle. Es wird von Modell1 und Modell2 gesprochen, wobei Modell 1 nur aus Servlets besteht und Modell2 dürfte eine für Web-Applikationen abgewandelte Version von MVC (Model View Controller) sein (vgl dazu: http://www.jsptutorial.org/content/architecture ).

Sprachverwirrung: MVC oder B-C-E ?

Achja, was mir noch ganz brauchbar erscheint, ist die Unterscheidung zwischen den 3 Arten von Klassen (aka: Klassen von Klassen oO), die in der UE vom Herrn Engelbrecht erwähnt wurden. Ich bin gerade auf die Suche gegangen, und habe gerade noch etwas darüber gefunden. Offiziell heißt es: das B-C-E-Prinzip

B-C-E steht für Boundary, Control und Entity und beschreibt die 3 Klassentypen die es gibt. (Natürlich gibt es verschiedene Ansätze welche Klassen es in einer SW gibt, und welche Funktionen sie haben. Doch das B-C-E Prinzip ist leicht verständlich und gut umsetzbar.) Man nennt dies auch das Model-View-Controler-Prinzip, was letztlich das selbe ist.

Quelle: http://wiki.delphigl.com/index.php/Tutorial_Softwareentwicklung2#Das_B-C-E_Prinzip

Aha, also im Prinzip MVC, hätte man ruhig auch gleich sagen können. Kurz erklärt (was ich mir in der UE mitgeschrieben habe) - den Link muss ich mir noch genau durchlesen:

  • einfache Entitätsklassen: Beherbergen im Prinzip nur Attribute, die man mit getAttribut() lesen und mit setAttribut() schreiben kann.
  • Boundary-Klassen: Hier gehts um Formulare, User-Interaktionen, etc.
  • Controller-Klassen: Diese dürften die eigentliche Programmlogik beinhalten - Abläufe regeln.

So, das wars für heute. Mal sehen, vielleicht kann ich das nächste mal schon irgend einen Code zum Laufen bringen und auch wissen, was ich da tue.

NACHTRAG: Schau mir gerade die Folien des Unified Process an. Auf Folie 11 wird das BCE-Prinzip auch kurz erklärt (+ Darstellung der Notation dieser Analyseklassen).

Wie Beziehungsgraphen darstellen?

Ich habe mir vor ca. ner Woche mal die Frage gestellt, wie man denn Beziehungsgraphen am Besten operationalisierbar macht, sodass man sie dynamisch erstellen kann. Dabei bin ich auf einen netten Thread in www.tutorials.de gestoßen, der ein paar Impulse liefert, wie es gehen könnte:

Relevant in diesem Thread sind vor allem folgende Postings:

Gerade im Bereich von Social Networking Sites wie openbc / xing oder neuerdings auch das studivz findet sich eine interessante Funktionalität: Die Visualisierung des Pfades innerhalb eines Bekanntheitsgraphen der aufzeigt über welche Personen eine Person eine gewisse andere Person kennt.

Hierzu bin ich gerade über einen Interessanten Artikel gestolpert der diese Problematik (Edge list model of a non-tree graph) anhand eines Airline / Flughafen / Flugplan Szenarios erklärt.
http://www.artfulsoftware.com/mysqlb…qled1ch20.html

ein kleines Beispiel zum Aufbau eines Bekanntheitsgraphen in Oracle 10g mithilfe der neuen hierarchischen Abfragemöglichkeiten
in Oracle 10g -> http://www.oracle.com/technology/ora…ectby_10g.html

Das ist die Sache mit dem CONNECTBY in Oracle, das wir auch schon in Datenbanksysteme letztes Semester gehabt haben. Ich denke, dadurch, dass am Almighty eh noch immer Oracle läuft, wäre das eine interessante Sache, die man sich im Detail ansehen müsste.

Die Frage “Wer kennt wen über wen?” ist nüchtern betrachtet, nichts anderes als ein extrem einfacher Pathfinding Algorithmus. Das schöne daran ist, dass übliche Parameter wie “Wegekosten” o.ä. wegfallen und nur die Anzahl der Knoten bis zum Ziel entscheidend für die kürzeste Strecke sind. Daher eignet sich hier das rekursive SQL (”connect by”) von Oracle sehr gut.

♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥ • ♥

Das nurmal, damit es für uns alle zugänglich ist. Zuerst sollten wir uns aber eh den eher trivialeren Dingen widmen, was uns sicherlich auch genügend Zeit kostet:

1. Grundstruktur über Servlets/JSP aufbauen (am besten schön gekapselt, sodass wir Code-Segmente, die wir öfter brauchen werden, wiederverwenden können). Außerdem soll der HTML-Code keine Design-Entscheidungen vorwegnehmen - Das soll wie besprochen alles über CSS gehen.

2. Wie connected man vermitetls Java auf eine Datenbank? Gerhard, du hast da heute was erwähnt - mir war dieses Paket bekannt, hab aber den Namen vergessen (mag jetzt ned nachschauen)

3. Welche Tables sind Relevant? Wir brauchen ein nettes Datenbankschema, das die Möglichkeit zulässt, CONNECTBY-Abfragen zu stellen. Was dafür notwendig ist, müssen wir uns ansehen.

All diese Fragen sollten wir gemäß dem “inkrementellen und iterativen Prozess” zunächst mal nur bezogen auf unsere Use-Cases (Bewertungen abgeben, Qualfikationen hinzufügen, Bewertungsgraphen anzeigen) anwenden und implementieren. Natürlich müssen wir damit rechnen, dass wir den Prototyp dann ändern werden.

So das wars - ich geh ins Bett. Cornelia bessert sofort die falschen Interpunktionen aus, sollte sie welche finden. :P

P.s.: Wann kommen eigentlich endlich die Bierspenden? Wir haben festgestellt, dass wir auch Grenzfälle wie Desperados annehmen.