. Anforderungen
3.1. Problemstellung
3.1.1. Spezifiche Problembeschreibung
3.1.2. Festlegung von Restriktionen
3.2. Nicht-funktionale Anforderungen
3.2.1. Systembezogene Anforderungen
3.2.2. Prozessspezifische Anforderungen
3.2.3. Qualitative Anforderungen
3.3. Funktionale Anforderungen
3.3.1. Die Spieldaten
3.3.2. Die Services/Dienst-Suche
3.3.3. Die JavaSpace-Server-Initialisierung
3.3.4. Die Benutzerschnittstellen
3.3.5. Die Funktionalität der Anwendung
3.3.6. Die Entwicklung und Integration der Spiele
4. Entwurf
4.1. Der Spieldaten Entwurf
4.2. Auffinden der Dienste
4.2.1. Die Klasse ‚ServiceFinder’
4.2.2. Die Klasse ‚ServiceFinderListener’
4.2.3. Klassendiagramm des ‚ServiceFinder’
4.3. Initialisierung des JavaSpace-Servers
4.3.1. Die Klasse ‚JSInit’
4.3.2. Anlegen der Spiel-ID
4.3.3. Anlegen der Spieltypen
4.3.4. Klassendiagramm der JS-Initialisierung
4.3.5. Ablauf der JS-Initialisierung
4.4. Entwurf der Benutzerschnittstelle
4.4.1. Die Client-Oberfläche
4.4.2. Die Oberfläche der Spielerstellung
4.5. Entwurf der Funktionalität
4.5.1. Die Spielerstellung
4.5.2. Der Spielbeitritt
4.5.3. Der Warteraum
4.5.4. Ein Spiel verlassen
4.6. Entwurf der Spielliste
4.6.1. Die Listen-Struktur
4.7. Die Spielerprüfung
4.8. Klassendiagramm des Basissystems
4.9. Entwurf der Spielintegration
4.9.1. Analyse der Spiele
4.9.2. Signaturentwurf der Status-Klasse
4.9.3. Signaturentwurf der Spiele
4.9.4. Entwurf der Spiele
4.9.5. Die Oberfläche der Spiele
4.9.6. Gesamtsystem der Spielintegration
4.9.7. Der Spielablauf
5. Implementierung
5.1. Die Implementierung der Funktionalität
5.1.1. Die Spielerstellungs-Funktion
5.1.2. Die Spielbeitritts-Funktion
5.1.3. Die Warteraum-Funktion
5.1.4. Die Spielverlassen-Funktion
5.1.5. Die Funktion der Spielliste
5.2. Besonderheiten und Probleme der Implementierung
5.2.1. Die Oberflächen
5.2.2. Die dynamische Objekt-Erzeugung
5.2.3. Abbruch von Threads
5.2.4. Funktion der Spielerüberprüfung
5.2.5. Funktion des Spielablaufs
5.3. Verwendete Werkzeuge
6. Bedienung und Installation
6.1. Installation Spieler
6.2. Installation Spielentwickler
6.2.1. Die Dateien der Spielentwickler
6.3. Integration eines neuen Spiels
6.3.1. Aspekte der Implementierung
6.3.2. Aktualisieren des JavaSpace-Servers
Inhaltsverzeichnis
1. Einleitung
1.1. Zielbestimmung
1.1.1. Zielsetzung
1.1.2. Kriterien die der Client erfüllen muss
1.1.3. Kriterien die der Client erfüllen kann
1.1.4. Abgrenzungskriterien zu anderen Produkten
1.2. Einsatz
1.2.1. Benutzer und Zielgruppe des Produkts
1.2.2. Einsatzgebiet und Betriebsbedingungen
2. Benötigtes Vorwissen
2.1. Der Geist aus der Flasche (JINI)
2.1.1. Die drei Grundpfeiler
2.1.2. Discovery
2.1.3. Registrierung
2.1.4. Nutzung eines Services
2.2. Das Leasing Prinzip
2.2.1. Was ist Leasing?
2.2.2. Vorteile von Leasing
2.3. JavaSpaces
2.3.1. Die wichtigsten Methoden im Überblick
2.3.2. Das Entry
2.3.3. Idee der Synchronisation
2.4. Weitere wichtige Dienste
3. Anforderungen
3.1. Problemstellung
3.1.1. Spezifiche Problembeschreibung
3.1.2. Festlegung von Restriktionen
3.2. Nicht-funktionale Anforderungen
3.2.1. Systembezogene Anforderungen
3.2.2. Prozessspezifische Anforderungen
3.2.3. Qualitative Anforderungen
3.3. Funktionale Anforderungen
3.3.1. Die Spieldaten
3.3.2. Die Services/Dienst-Suche
3.3.3. Die JavaSpace-Server-Initialisierung
3.3.4. Die Benutzerschnittstellen
3.3.5. Die Funktionalität der Anwendung
3.3.6. Die Entwicklung und Integration der Spiele
4. Entwurf
4.1. Der Spieldaten Entwurf
4.2. Auffinden der Dienste
4.2.1. Die Klasse ‚ServiceFinder’
4.2.2. Die Klasse ‚ServiceFinderListener’
4.2.3. Klassendiagramm des ‚ServiceFinder’
4.3. Initialisierung des JavaSpace-Servers
4.3.1. Die Klasse ‚JSInit’
4.3.2. Anlegen der Spiel-ID
4.3.3. Anlegen der Spieltypen
4.3.4. Klassendiagramm der JS-Initialisierung
4.3.5. Ablauf der JS-Initialisierung
4.4. Entwurf der Benutzerschnittstelle
4.4.1. Die Client-Oberfläche
4.4.2. Die Oberfläche der Spielerstellung
4.5. Entwurf der Funktionalität
4.5.1. Die Spielerstellung
4.5.2. Der Spielbeitritt
4.5.3. Der Warteraum
4.5.4. Ein Spiel verlassen
4.6. Entwurf der Spielliste
4.6.1. Die Listen-Struktur
4.7. Die Spielerprüfung
4.8. Klassendiagramm des Basissystems
4.9. Entwurf der Spielintegration
4.9.1. Analyse der Spiele
4.9.2. Signaturentwurf der Status-Klasse
4.9.3. Signaturentwurf der Spiele
4.9.4. Entwurf der Spiele
4.9.5. Die Oberfläche der Spiele
4.9.6. Gesamtsystem der Spielintegration
4.9.7. Der Spielablauf
5. Implementierung
5.1. Die Implementierung der Funktionalität
5.1.1. Die Spielerstellungs-Funktion
5.1.2. Die Spielbeitritts-Funktion
5.1.3. Die Warteraum-Funktion
5.1.4. Die Spielverlassen-Funktion
5.1.5. Die Funktion der Spielliste
5.2.Besonderheiten und Probleme der Implementierung
5.2.1. Die Oberflächen
5.2.2. Die dynamische Objekt-Erzeugung
5.2.3. Abbruch von Threads
5.2.4. Funktion der Spielerüberprüfung
5.2.5. Funktion des Spielablaufs
5.3.Verwendete Werkzeuge
6. Bedienung und Installation
6.1. Installation Spieler
6.2. Installation Spielentwickler
6.2.1. Die Dateien der Spielentwickler
6.3.Integration eines neuen Spiels
6.3.1. Aspekte der Implementierung
6.3.2. Aktualisieren des JavaSpace-Servers
Zielsetzung und Themen
Die Projektarbeit fokussiert sich auf die Entwicklung einer verteilten Anwendung, die Mehrpersonen-Spiele über ein Netzwerk verwaltet, wobei der Schwerpunkt auf der effizienten Kommunikation und dem Datentransport via Jini und JavaSpaces liegt. Ziel ist die Realisierung einer Client-Architektur, welche eine dynamische Integration neuer Spieltypen ohne Client-Updates ermöglicht.
- Verteilte Client-Server-Architektur auf Basis von Jini und JavaSpaces
- Dynamische Integration und Instanziierung von Spielkomponenten
- Synchronisation und Zustandsverwaltung durch JavaSpace-Operations
- Abstraktion durch Interface-basierte Spielintegration
Auszug aus dem Buch
4.5.1 Die Spielerstellung
Zur Spielerstellung dient die Methode ‚erstellen()’, welche als Argument die maximale Anzahl der Spieler und den Spielernamen bekommt. Die Daten werden von der Klasse ‚ErstellenGUI’ (s.h. Punkt 4.4.2), welche die Eingabemaske der Daten repräsentiert, geliefert. Aus diesem Grund bekommt die Klasse ‚ErstellenGUI’ auch eine Referenz auf einen ‚Spieler’, um dessen Methode nutzen zu können (s.h. Abb. 4.5-2).
Betätigt man nun den Button zur Erstellung, wird in der Klasse ‚SpielClient’ ein neues ‚ErstellenGUI’ Objekt erzeugt. Wie aus Abbildung 4.5-2 hervorgeht, bekommt der dafür vorgesehene Konstruktor einen Spieler und die Benutzerschnittstelle als Referenz übergeben.
SpielClient legt neues ErstellenGUI Objekt an
ErstellenGUI bekommt Referenz auf einen Spieler und ‚dieses’ Objekt
Aus diesem Grund erweitert sich die Klasse ‚ErstellenGUI’ um die Variable ‚spieler’, welche die Referenz zu diesem beinhaltet. In Abbildung 4.5-3 wird der eigentliche Ablauf der Erstellung mit Hilfe eines Sequenzdiagramms beschrieben.
Zusammenfassung der Kapitel
1. Einleitung: Definiert die Zielsetzung einer verteilten Anwendung zur Verwaltung von Mehrpersonenspielen unter Verwendung von Jini und JavaSpaces.
2. Benötigtes Vorwissen: Erläutert die Grundlagen von Jini-Komponenten wie Lookup-Diensten, Leasing-Mechanismen und die Funktionsweise von JavaSpaces.
3. Anforderungen: Spezifiziert die funktionalen und nicht-funktionalen Anforderungen an den Client, insbesondere hinsichtlich Dynamik und Spielintegration.
4. Entwurf: Beschreibt die technische Konzeption inklusive der Klassenstrukturen für Dienste, JavaSpace-Initialisierung und Benutzerschnittstellen.
5. Implementierung: Detailliert die praktische Umsetzung der Kernfunktionen wie Spielerstellung, Beitritt und Spielablauf-Synchronisation.
6. Bedienung und Installation: Bietet eine Anleitung zur Einrichtung der Umgebung für Spieler und Spielentwickler sowie zur Integration neuer Spiele.
Schlüsselwörter
Jini, JavaSpaces, Verteilte Systeme, Mehrpersonenspiele, Dynamisches Klassenladen, Java, Interface, Synchronisation, Java-Client, Software-Architektur, Leasing-Prinzip, Spielintegration, Netzwerkprogrammierung, Lookup-Service, Middleware.
Häufig gestellte Fragen
Worum geht es in dieser Arbeit grundsätzlich?
Die Arbeit befasst sich mit der Entwicklung eines verteilten Client-Systems, das Mehrpersonenspiele über Netzwerke verwaltet und durch Jini- und JavaSpaces-Technologien realisiert wird.
Was sind die zentralen Themenfelder?
Die zentralen Themen umfassen verteilte Systeme, Jini-Netzwerkinfrastruktur, JavaSpaces für die Prozess-Synchronisation sowie objektorientierte Entwurfsmuster für die dynamische Softwareerweiterung.
Was ist das primäre Ziel oder die Forschungsfrage?
Das Hauptziel ist der Entwurf eines Spiel-Clients, der neue Spieltypen "dynamisch" einbinden kann, ohne dass Anwender manuelle Client-Updates durchführen müssen.
Welche wissenschaftliche Methode wird verwendet?
Es wird ein systematischer Software-Entwicklungsprozess genutzt, der mit einer Anforderungsanalyse beginnt, gefolgt von einem objektorientierten Entwurf, der in Implementierung und Integration mündet.
Was wird im Hauptteil behandelt?
Der Hauptteil gliedert sich in Entwurfs- und Implementierungsphasen, in denen die Systemarchitektur, das Auffinden von Diensten und die logische Struktur der Spielintegration detailliert dargestellt werden.
Welche Schlüsselwörter charakterisieren die Arbeit?
Die Arbeit lässt sich primär über die Begriffe Jini, JavaSpaces, dynamisches Klassenladen, verteilte Systeme und Spielintegration charakterisieren.
Wie wird das Problem der dynamischen Einbindung neuer Spiele gelöst?
Die Lösung erfolgt durch die Kombination von Java-Interfaces und dem dynamischen Laden von .class-Dateien via Webserver, was zur Laufzeit eine Instanziierung von Spielobjekten ermöglicht.
Welche Rolle spielen die "Leases" in diesem System?
Leases dienen als Mechanismus zur Selbstheilung des Systems; sie verhindern "Service-Leichen" und stellen sicher, dass das System auf Ausfälle (wie Abstürze einzelner Clients) robust reagieren kann.
- Quote paper
- Dirk Hen (Author), 2003, Entwurf und Implementierung eines Systems für Mehrpersonenspiele mit JINI und JavaSpaces, Munich, GRIN Verlag, https://www.grin.com/document/10222
