Diplomarbeit Konzeption und Realisierung einer - sebis

Transcription

Technische Universität München
Fakultät für Informatik
Lehrstuhl für Software Engineering betrieblicher Informationssysteme
Prof. Dr. Florian Matthes
Diplomarbeit
Konzeption und Realisierung einer social bookmarking Erweiterung für ein
Wissensmanagementsystem
Andreas Halberkamp
Aufgabensteller:
Prof. Dr. Florian Matthes
Betreut durch:
Sheng Wei
Abgegeben am:
15.11.2005
Erklärung zur Diplomarbeit
Ich versichere, dass ich diese Diplomarbeit selbständig verfasst und nur die angegeben Quellen und Hilfsmittel verwendet habe.
______________________
(Andreas Halberkamp)
II
Inhaltsverzeichnis
1
Einleitung..........................................................................................................................8
1.1
1.2
1.3
2
Anforderungen an die social bookmarking Erweiterung ..........................................16
2.1
2.2
2.3
3
Vorgehensweise .........................................................................................................9
Aufbau der Arbeit.....................................................................................................10
Ergebnisse der Marktstudie (Funktionsanalyse) .....................................................11
Generelle Anforderungen ........................................................................................16
Anforderungen an den Bookmarkaccount (private Schicht)....................................18
Anforderungen an die öffentliche Schicht der Erweiterung ....................................19
Realisierungstechnologien.............................................................................................21
3.1
Architektur des Infoasset Brokers............................................................................21
3.1.1
Funktionalität und Eigenschaften von Handlern .............................................22
3.1.2
Eigenschaften der Services ..............................................................................23
3.2
Asynchronous Javascript and XML (AJAX) ............................................................26
3.3
Content Syndication und Feeds ...............................................................................27
3.3.1
RSS 0.91 ..........................................................................................................28
3.3.2
RSS 1.0 ............................................................................................................29
3.3.3
ATOM..............................................................................................................30
4
Modellierung der Erweiterung .....................................................................................32
4.1
Modell der Erweiterung...........................................................................................32
4.2
Umsetzung des Modells ...........................................................................................35
4.2.1
Allgemeine Darstellung der Bookmarks..........................................................35
4.2.2
Benutzerschicht: Der Bookmarkaccount .........................................................37
4.2.3
Bookmarklogs..................................................................................................39
4.2.4
Öffentliche Schicht der Erweiterung ...............................................................40
4.2.5
Erweiterung der Struktur des Infoasset Brokers ..............................................42
5
Implementierung der Erweiterung ..............................................................................44
5.1
Datenstrukturen der Erweiterung............................................................................44
5.1.1
Das Asset „Weblog“ ........................................................................................44
5.1.2
Das Asset „BookmarkEntry“ ...........................................................................45
5.1.3
Das Asset „Tag“...............................................................................................46
5.1.4
Das Asset „Bsubscription“...............................................................................47
5.2
Implementierung des Bookmarkaccounts der Erweiterung.....................................48
5.2.1
Bookmarks einfügen ........................................................................................48
5.2.1.1 Suggestionsfunktion.....................................................................................48
5.2.1.2 Verarbeitung der Formulareingaben............................................................50
5.2.2
Übersichtsseite des Bookmarkaccounts...........................................................53
5.2.2.1 Generierung der Übersichtsseite..................................................................53
5.2.2.2 Kommentarfunktion.....................................................................................58
5.2.2.3 Funktionen der Übersichtsseite....................................................................59
5.2.2.4 Tagspezifische Seiten der Übersicht............................................................62
5.2.3
Abonnementverwaltung: Inbox .......................................................................63
5.2.4
Funktion: „Tags umbenennen“ ........................................................................66
III
5.3
Implementierung des Bookmarklogs........................................................................67
5.3.1
Die Content Syndication Schnittstelle .............................................................69
5.3.1.1 RSS 1.0 Template ........................................................................................69
5.3.1.2 RSS 0.92 Template ......................................................................................71
5.3.1.3 ATOM 1.0 Template....................................................................................72
5.3.1.4 ATOM 0.3 Feed...........................................................................................73
5.3.2
Bookmarklogverzeichnis .................................................................................74
5.4
Implementierung der öffentlichen Schicht der Erweiterung....................................76
5.4.1
Öffentliche Übersichtsseite der Erweiterung...................................................77
5.4.1.1 Erstellung der Übersichtsseite .....................................................................77
5.4.1.2 Zugriffsmöglichkeiten auf die tagspezifischen Seiten.................................79
5.4.2
Implementierung der Importschnittstelle.........................................................80
5.4.2.1 Import externer Bookmarks .........................................................................81
5.4.2.2 Darstellung der importierten Bookmarks ....................................................83
5.4.2.3 Kommentarfunktion.....................................................................................85
5.5
Implementierung weiterer Funktionen.....................................................................86
5.5.1
Funktion: „Quick save“ ...................................................................................86
5.5.2
Funktion: „Quick Info“....................................................................................87
5.5.3
Erweiterung der Startseite des Infoasset Brokers ............................................88
5.6
Webservices .............................................................................................................89
5.6.1
Webservice: Export von Bookmarklisten ........................................................91
5.6.2
Webservice: Export von Taglisten...................................................................93
5.6.3
Webservice: Import von Bookmarks ...............................................................93
6
Ausblick ..........................................................................................................................96
7
Schlusswort.....................................................................................................................98
8
Literaturverzeichnis ......................................................................................................99
8.1
8.2
9
Monographien..........................................................................................................99
Internet - Dokumente ...............................................................................................99
Anhang..........................................................................................................................100
9.1
Funktionsübersicht.................................................................................................100
9.1.1
Bookmarklog anlegen ....................................................................................100
9.1.2
Funktionen des Bookmarkaccounts ...............................................................101
9.1.2.1 Bookmarks einfügen ..................................................................................101
9.1.2.2 Die Übersichtsseite ....................................................................................102
9.1.2.3 Abonnementfunktion - die Inbox...............................................................104
9.1.2.4 Funktion „Tags umbenennen“ ...................................................................105
9.1.3
Der Bookmarklog ..........................................................................................105
9.1.4
Funktionen der öffentlichen Schicht..............................................................106
9.1.4.1 Die öffentliche Übersichtsseite..................................................................107
9.1.4.2 Das Bookmarklogverzeichnis ....................................................................108
9.1.5
Sonstige Funktionen ......................................................................................109
9.1.5.1 Erweiterung der Startseite..........................................................................109
9.1.5.2 Das Bookmarklet „Quick save“.................................................................110
9.1.5.3 Die Funktion „Quick info“ ........................................................................110
9.1.5.4 Die Webservices ........................................................................................110
9.2
Der Featurevergleich.............................................................................................113
IV
Abbildungsverzeichnis
Abb. 1: Projektphasen ( Quelle: eigene Darstellung ) .............................................................10
Abb. 2:Diagrammarten der Freitextsuche ( Quelle: eigene Darstellung ) ...............................14
Abb. 3: Diagramm: unterstützte Feedformate ( Quelle: eigene Darstellung ).........................14
Abb. 4: AJAX web application model ( Quelle: [Gar05]).......................................................16
Abb. 5: Client-Server Architektur des Infoasset Brokers (Quelle: [Leh05])...........................21
Abb. 6.: AssociationSchemas: ManyToMany-Association und OneToMany-Association
(Quelle:[Leh05]) ..............................................................................................................24
Abb. 7: Struktur einer Query ( Quelle: eigene Darstellung )...................................................25
Abb. 8: Klassische und AJAX-basierte Client-Server Kommunikation (Quelle: [Gar05]) ....27
Abb. 9: Struktur eines „RSS 0.91“ Feeds (Quelle: [Ham03]) .................................................28
Abb. 10: Struktur eines "RSS 1.0" Feeds (Quelle: [HAM03]) ................................................29
Abb. 11: Modell der Erweiterung ( Quelle: eigene Darstellung ) ...........................................32
Abb. 12: Darstellung eines Bookmarks ( Quelle: eigene Darstellung )...................................36
Abb. 13: Übersichtsseite des Bookmarkaccounts ( Quelle: eigene Dargstellung) .................37
Abb. 14: Der Bookmarklog (Abbildung: Eigene Darstellung)...............................................39
Abb. 15: Die Startseite der öffentlichen Schicht der Erweiterung (Quelle: eigene
Darstellung) .....................................................................................................................41
Abb. 16: Die "Suggestionsfunktion" ( Quelle: eigene Darstellung ) .......................................49
Abb. 17: Query: Abfrage der Vorschläge ( Quelle: eigene Darstellung ) ...............................50
Abb. 18: Hilfsfunktion: „isValid“ ( Quelle: eigene Darstellung ) ...........................................51
Abb. 19: Hilfsfunktion: "convertToHTML“ ( Quelle: eigene Darstellung ) ...........................52
Abb. 20: Die Funktion "getpage"( Quelle: eigene Darstellung ) .............................................54
Abb. 21: Die Funktion "createIndex" ( Quelle: eigene Darstellung )......................................56
Abb. 22: Die Kommentarliste ( Quelle: eigene Darstellung ) .................................................58
Abb. 23: Das Bearbeitungsformular ( Quelle: eigene Darstellung )........................................59
Abb. 24: Schematische Darstellung der Schnittstelle des Webservices ( Quelle: eigene
Darstellung ) ....................................................................................................................61
Abb. 25: Die Funktion "getRelatedTagsofaTag" ( Quelle: eigene Darstellung ) ....................62
Abb. 26: die Funktion "getlatestbookmarksofasubscription"( Quelle: eigene Darstellung )...64
Abb. 27: Struktur eines RSS 1.0 Templates ( Quelle: eigene Darstellung )............................71
Abb. 28: Struktur eines RSS 0.92 Templates ( Quelle: eigene Darstellung )..........................72
Abb. 29: Struktur eines Atom 1.0 Templates ( Quelle: eigene Darstellung )..........................73
Abb. 30: Funktion: Einlesen des Feeds ( Quelle: [ABD05])...................................................74
Abb. 31: Ausgabe des umgewandelten Feeds (Quelle: vgl. [ABD05] )..................................74
V
Abb. 32: Die Funktion "getallBookmarkslogs"( Quelle: eigene Darstellung ) .......................76
Abb. 33: Die Funktion "getpopulartags"( Quelle: eigene Darstellung )..................................78
Abb. 34: Graphische Darstellung eines RDF-Tripels ( Quelle: eigene Darstellung ) .............82
Abb. 35: Struktur einer RDQL-Anfage ( Quelle: eigene Darstellung )...................................82
Abb. 36: Query mit verschiedenen Where-Klauseln( Quelle: eigene Darstellung) ................83
Abb. 37: Query: Abfrage der verwandten Tags ( Quelle: eigene Darstellung ) ......................85
Abb. 38: Fehlermeldung bei einen fehlgeschlagenen Request ( Quelle: eigene Darstellung )91
Abb. 39:Antwortdokument eines Webservices ( Quelle: eigene Darstellung ).......................92
Abb. 40: Formular: "neues Weblog anlegen" ( Quelle: eigene Darstellung ) .......................101
Abb. 41: Darstellung eines Bookmarks ( Quelle: eigene Darstellung)..................................102
Abb. 42: Die Inbox ( Quelle: Eigene Darstellung ) ...............................................................105
Abb. 43: URL der tagspezifischen Seiten ( Quelle: eigene Darstellung ) .............................107
Abb. 44: Das Bookmarklogverzeichnis ( Quelle: Eigene Darstellung).................................108
Abb. 45: Die Webservices der Erweiterung ( Quelle: eigene Darstellung )..........................111
Abb. 46: Antwortdokument eines Webservices ( Quelle: eigene Darstellung )....................111
VI
Tabellenverzeichnis
Tab. 1: Queryconditions ( Quelle: eigene Darstellung )..........................................................25
Tab. 2: Wertebereich der Eigenschaft "Typ"( Quelle: eigene Darstellung ) ...........................47
Tab. 3: Die Events der Suggestionsfunktion ( Quelle: eigene Darstellung)............................49
Tab. 4: Typen des Exportfeeds ( Quelle: eigene Darstellung )................................................80
Tab. 5: Webservices der Erweiterung ( Quelle: eigene Darstellung ) .....................................90
Tab. 6: Bedeutungen der Formularfelder ( Quelle: eigene Darstellung) ...............................102
Tab. 7: Die Abonnementtypen ( Quelle: eigene Darstellung) ...............................................104
Abkürzungsverzeichnis
AJAX
API
DOM
HTML
http
LDAP
RDF
RDQL
REST
ROME
RSS
URI
URL
XHTML
XML
asynchronous javascript and XML
application program interface
data object model
hypertext markup language
hypertext transfer protocol
lightweight directory access protocol
resource description framework
RDF query language
repesentation state transfer
rss and atom utilities
RDF site summary
uniform resource identifier
uniform resource locator
extensible hypertext markup language
extensible markup language
VII
1
Einleitung
Im Rahmen dieser Diplomarbeit wird eine „social bookmarking“ Erweiterung für ein Wissensmanagementsystem konzipiert und realisiert. Bei dem Wissensmanagementsystem handelt es sich um den Infoasset Broker, der von der Infoasset AG in Zusammenarbeit mit dem
Lehrstuhl für Software Engineering Betrieblicher Informationssysteme (sebis) entwickelt
wurde. Dieses webbasierte System organisiert den unternehmensweiten Wissensworkflow,
indem es die verschiedenen Teilgebiete des Wissensmanagements, wie das Dokumentenoder das Skillmanagement, und vielseitige Communityfunktionen unterstützt. Durch die Vernetzung der unterschiedlichen Wissensquellen, die im folgendem als „Assets“ bezeichnet
werden, können diese effizient strukturiert und geordnet werden, so dass den Mitarbeitern
eine einheitliche Sicht auf das oftmals heterogene Wissen eines Unternehmens bereitgestellt
wird (vgl. [MAT05]). Dadurch wird vor allem das Teamwork, bei dem Wissen über verschiedene Organisationseinheiten hinweg ausgetauscht wird, erleichtert.
Wie schon erwähnt wurde, war ist das Ziel der Diplomarbeit, eine social bookmarking Erweiterung zu entwickeln und dadurch die „Community“ Funktionen des Infoasset Brokers zu
erweitern. Ein social bookmarking System ermöglicht es den Anwendern einerseits eigene
Bookmarks zu definieren und anderseits diese mit den anderen Anwendern des Systems auszutauschen. Bei der Definition von Bookmarks können die Anwender ihre Bookmarks kategorisieren. Anhand der Kategorisierung erstellt die Anwendung verschiedene Verknüpfungen
zwischen diesen und erleichtert den Anwendern so das Auffinden von Bookmarks, die in
einem thematischen Zusammenhang stehen.
Die Kategorisierung basiert vor allem auf Tags, welche Schlüsselwörter darstellen, mit denen
der Anwender seine Bookmarks thematisieren kann. Dabei sollten Tags frei wählbar sein,
damit jedem Anwender eine individuelle Charakterisierung seiner Bookmarks ermöglicht
wird. Dennoch kann der Prozess der individuellen Thematisierung der Bookmarks durch das
Vorschlagen von bereits verwendeten Tags unterstützt werden, damit den Anwendern eine in
sich stimmige Kategorisierung ihrer Bookmarks erleichtert wird.
Der „Austausch von Bookmarks“ zwischen den Anwendern wird des Weiteren durch diverse
Abonnementfunktionen unterstützt. Mittels dieser Funktionen können die Anwender tagspezifische oder personenspezifische Bookmarks abonnieren. Nachdem ein Anwender ein solches Abonnement abgeschlossen hat, wird er automatisch benachrichtigt, sobald ein Bookmark, das diesem entspricht, in die Anwendung eingefügt wird.
8
Neben diesen Grundfunktionalitäten gibt es noch eine Reihe weiterer Anforderungen die an
die Implementierung eines solchen Systems gestellt werden. Auf sie wird in Kapitel 2 eingegangen.
Nachdem in der Einleitung der Kontext und die Zielsetzung der Diplomarbeit erläutert wurden, wird nun die Vorgehensweise, die für die Erstellung dieser Arbeit angewandt wurde,
vorgestellt.
1.1
Vorgehensweise
Die Vorgehensweise bei der Bearbeitung des Diplomarbeitsthemas kann man in drei Schritte
untergliedern:
•
Einarbeitung in das Thema
•
Konzeption und Implementierung der social bookmarking Erweiterung
•
Verfassen der schriftlichen Ausarbeitung
Bei der Einarbeitung in das Thema mussten zwei Aspekte berücksichtigt werden. Einerseits mussten die Anforderungen an die Implementierung definiert werden, andererseits
mussten diese Anforderungen an die bestehende Implementierung und die Konzepte des Infoasset Brokers angepasst werden. Darum war eine zur Anforderungsanalyse parallele Einarbeitung in die Implementierung des Brokers notwendig. In dieser Projektphase wurde zunächst eine Marktstudie, in der die Funktionalität von sieben bekannten social bookmarking
Anwendungen analysiert wurde, durchgeführt. Anhand einer Analyse der in Kapitel 1.3 zusammengefasst dargestellten Ergebnisse der Marktstudie wurden die Anforderungen an die
Erweiterung definiert, auf denen der Konzeption des Systems basiert.
In der Konzeptionsphase wurden zum einen die Anforderungen an die bestehende Umgebung des Infoasset Brokers angepasst und zum anderen das Systemdesign, auf welchem die
Erweiterung basiert, entworfen. Um das Systemdesign zu visualisieren, wurden - neben einem UML-Diagramm, in dem das Modell der Erweiterung abgebildet wurde - „Screenshots“
des Infoasset Brokers erstellt und die zu implementierenden Funktionalitäten in diese eingefügt. Mit der gewählten Art der Darstellung der Modellierung wurde die Kommunikation
über die Modellierung sehr erleichtert, da diese Darstellungsweise sehr eingängig ist.
Die an die Konzeptionsphase anschließende Implementierung des Systems basierte großteils auf dem „vertikalen Prototyping“, das besagt, dass die verschiedenen Komponenten
9
eines Systems jeweils nacheinander über alle Schichten hinweg realisiert werden [BÖH04].
Somit konnten schon während der Implementierung an Teilkomponenten des Systems Funktionstests durchgeführt werden, und die daraus resultierenden Erfahrungen für die weiteren
Implementierungsschritte verwendet werden.
In der letzten Phase der Diplomarbeit wurde die vorliegende Ausarbeitung verfasst, auf dessen Gliederung im nächsten Kapitel eingegangen wird.
Abb. 1: Projektphasen ( Quelle: eigene Darstellung )
1.2
Aufbau der Arbeit
Im ersten Kapitel dieser Arbeit werden sowohl die Zielsetzung und der Kontext der Diplomarbeit als auch die Vorgehensweise, die bei der Bearbeitung des Diplomarbeitthemas verfolgt wurde, erläutert.
Daran anschließend werden im zweiten Kapitel die Anforderungen an die Erweiterung, die
in allgemeine und spezifische Anforderungen untergliedert sind, vorgestellt.
Basierend auf den Anforderungen werden im dritten und vierten Kapitel zum einen die
Technologien, die für die Umsetzung der Anforderungen verwendet wurden, und zum anderen das Systemdesign beschrieben.
Im fünften Kapitel der Ausarbeitung wird die konkrete Implementierung des Systems erläutert. Dabei werden vor allem die verschiedenen Datenstrukturen und Algorithmen, die für die
Realisierung der social bookmarking Erweiterung verwendet wurden, erläutert. Schließlich
wird in den Kapiteln Sechs und Sieben die Ausarbeitung mit einem Ausblick auf mögliche
10
Weiterentwicklungen der Implementierung und einer Zusammenfassung der Ergebnisse der
Diplomarbeit abgeschlossen.
1.3
Ergebnisse der Marktstudie (Funktionsanalyse)
Auf der Basis der Ergebnisse der Marktstudie wurden die Anforderungen an die Implementierung der social bookmarking Erweiterung definiert. Dabei wurde darauf geachtet, dass
sowohl die standardisierten Funktionen, die von den meisten Systemen angeboten werden,
als auch spezielle Funktionen, mit denen sich die Erweiterung von den anderen System abgrenzen könnte, in das Pflichtenheft aufgenommen wurden.
Im Rahmen der Marktstudie wurden die Eigenschaften und die Funktionalitäten, welche verschiedenen Kategorien zugeordnet werden können, der folgenden social bookmarking Anbieter analysiert:
•
Del.icio.us
•
Simpy
•
Furl
•
Blogmark
•
Connectea
•
Spurl
•
Linkroll
In der Kategorie Startseite wurde untersucht, welche Elemente auf den Startseiten der verschiedenen Anwendungen dargestellt werden. Dabei stellte sich heraus, dass eine Übersicht
über aktuelle Bookmarks bei allen Anwendungen auf der Startseite angezeigt wurde. Vier
weitere Systeme stellten populäre Tags auf ihren Startseiten dar, wobei diejenigen Tags als
populär gelten, die von vielen verschiedenen Anwendern definiert wurden. Schließlich stellten zwei Systemen auf ihren Startseiten ihre aktivsten Anwender vor. Dass diese Information
nur von wenigen Systemen ausgegeben wird, kann dadurch begründet werden, dass die Aussagekraft dieser Information über die Eigenschaften der Bookmarks und somit deren Nutzen
für die Endanwender relativ gering ist.
Des Weiteren wurde untersucht, welche Eigenschaften zu einem Bookmark gespeichert
werden können und wie die Bookmarks in den verschiedenen Anwendungen dargestellt werden. In allen Anwendungen können die Anwender den Bookmarks einen Titel, Tags und eine
Beschreibung zuordnen, wobei in manchen Systemen noch ein alternativer Titel zu dem
Bookmark hinzugefügt werden kann. Dadurch haben die Anwender die Möglichkeit, den
Bookmarks sowohl einen offiziellen Seitentitel als auch einen selbst gewählten Titel zuzuordnen. In einer Anwendung können die Anwender darüber hinaus zwei verschiedene Be-
11
schreibungen zu ihren Bookmarks hinzufügen. Dabei wird zwischen der offiziellen Beschreibung, die jeder Anwender sehen darf und dem persönlichen Kommentar, der nur dem jeweiligen Eigentümer des Bookmarks angezeigt wird, unterschieden.
Generell wird die Trennung zwischen „privaten“ und „öffentlichen“ Bookmarks durch
vier Anwendungen unterstützt. Mittels dieses Features können die Anwender selbst entscheiden, ob ihre Bookmarks öffentlich oder nur in ihrem persönlichen Account angezeigt werden
sollen. Die Möglichkeit private Bookmarks zu definieren ist besonders für die Anwender von
Vorteil, die Bookmarks zu Seiten mit sensiblen Inhalten - z.B. „Online Banking“ - in diesen
Systemen speichern wollen.
In allen Systemen umfasst die Darstellung der Bookmarks deren Titel, deren Beschreibung
und deren Tags, wobei die Bookmarktitel auf die Ressourcen, die von den jeweiligen Bookmarks beschrieben werden, verweisen. Daneben wird von drei Anwendungen die Anzahl der
Bookmarks, welche mit der gleichen URL wie der jeweils angezeigte Bookmark verknüpft
sind, ausgegeben. Diese drei Anwender bieten des Weiteren eine Kommentarfunktion an, mit
der die Anwender diese Bookmarks aufrufen können. Dadurch wird es den Anwendern ermöglicht beispielsweise auf alle Kommentare, welche über die Bookmarks einer URL zugeordnet wurden, direkt zuzugreifen.
In der Kategorie „Sichtweisen auf den Bookmarkbestand“ wurde untersucht in welchem
Kontext die verschiedenen Bookmarks dargestellt werden können. Dabei stellte sich heraus,
dass die meisten Anwendungen - neben der Übersicht über die aktuellen Bookmarks - zwei
verschiedene Sichtweisen auf ihren Bookmarkbestand anbieten: Die personspezifische und
die tagspezifische Sicht. In der personspezifischen Sicht werden die Bookmarks eines bestimmten Anwenders angezeigt. Bei der tagspezifischen Sicht werden die Bookmarks, die
mit einem bestimmten Tag verknüpft sind, dargestellt. Der direkte Zugriff auf die verschiedenen Übersichtsseiten über bestimmte URLs wird durch vier Anwendungen ermöglicht. Die
URLs sind dabei so aufgebaut, dass die Anwender den Namen der Person oder den Tag, deren Bookmarks angezeigt werden sollen, direkt an diese anhängen können und dadurch die
entsprechenden Übersichtsseiten aufrufen können.
In einer weiteren Kategorie wurden die Funktionen der verschiedenen Systeme untersucht.
Die Grundfunktionalitäten
•
einfügen
•
bearbeiten
•
löschen
12
von Bookmarks wurden von allen Systemen angeboten, wobei diese für die Funktion „Einfügen“ neben dem „normalen Einfügeformular“ einen Bookmarklet anbieten. Das „Bookmarklet“ ist ein „aktiver“ Link zu den social bookmarking Anwendungen, welchen die Anwender in ihre Browser integrieren können. Mittels dieses Bookmarklets können die Anwender die URL der Seite, auf welcher sie sich gerade befinden, in einen Bookmark speichern,
ohne dass sie ihr social bookmarking System direkt öffnen müssen.
Fünf Systeme unterstützen neben der generellen Bearbeitungsfunktion die gesonderte Umbenennung von Tags. Durch die Umbenennung von Tags können beispielsweise Tags aufgespaltet werden, was bedeutet, dass ein Tag durch zwei neue Tags ersetzt werden kann. Durch
diese Aufspaltung können die Anwender die Kategorisierung von bestimmten Bookmarks
verfeinern oder verändern.
Innerhalb der Anwendungen wird der Austausch von Bookmarks einerseits durch die Kopierfunktion und andererseits durch eine Abonnentenfunktion unterstützt. Die Kopierfunktion, welche von fünf Anwendungen angeboten wird, ermöglicht es jedem Anwender, Bookmarks von anderen Anwendern in seinen persönlichen Account zu kopieren. Dagegen können
die Anwender mit der „Abonnentenfunktion“ bestimmte Bookmarks abonnieren. Dies bedeutet, dass die Anwender auf Wunsch automatisch informiert werden, wenn ein Bookmark eines bestimmten Typs in das System eingefügt wird. Diese Abonnementfunktion wird von
vier Systemen unterstützt.
Die Suchoptionen, die von den verschiedenen Systemen angeboten werden, können generell
in zwei Klassen unterteilt werden: Die Kategoriesuche und die Freitextsuche. Durch die Kategoriesuche können die Anwender nach Bookmarks einer bestimmten vordefinierten Kategorie suchen. Ein Beispiel hierfür wäre die Liste der populären Tags, die von manchen Systemen auf deren Startseite ausgegeben wird. Aus der Liste kann der Anwender nun einen
populären Tag auswählen und sich alle Bookmarks, die mit diesen verknüpft sind, anzeigen
lassen. Daneben werden noch Kategoriesuchen für neue Tags, aktive Anwender oder personspezifische Tags von den verschiedenen Systemen angeboten.
Mit der Freitextsuche kann der Bookmarkbestand eines Systems nach einem frei gewählten
Stichwort durchsucht werden. Die Arten der Freitextsuche der verschiedenen Systeme können, wie im folgendem Diagramm dargestellt wird, vor allem anhand der Eigenschaften der
Bookmarks, die bei der Freitextsuche berücksichtigt werden können, voneinander abgegrenzt
werden.
13
1
4
nach Titeln
3
nach Beschreibung
nach Tag
nach Personen
4
Abb. 2:Diagrammarten der Freitextsuche ( Quelle: eigene Darstellung )
Aus diesem Diagramm geht hervor, das von den meisten Systemen eine Freitextsuche innerhalb der Titel und der Beschreibungen der Bookmarks unterstützt wird, wohingegen die Freitextsuche nach Tags oder nach Personen von wesentlich weniger Systemen angeboten wird.
Dies kann dadurch erklärt werden, dass der Zugriff auf tagspezifische oder personenspezifische Bookmarks entweder durch eine Kategoriesuche oder durch spezifische URLs ermöglicht wird.
Schließlich wurden noch die Schnittstellen, die von den verschiedenen social bookmarking
Anwendungen angeboten werden, untersucht. Dabei stellte sich heraus, dass alle Anwendungen Newsfeeds als generelle Exportschnittstelle unterstützen (siehe Abb.2 ).:
Atom 0.3; 28,60%
Atom 0.3
RSS 0.91; 14,30%
RSS 0.91
RSS1.0; 57,10%
RSS1.0
RSS 2.0; 57,10%
RSS 2.0
0,00%
10,00%
20,00%
30,00%
40,00%
50,00%
60,00%
Abb. 3: Diagramm: unterstützte Feedformate ( Quelle: eigene Darstellung )
14
Wie in diesem Diagramm dargestellt wird, werden von den verschiedenen Anwendungen vier
unterschiedliche Feedformate unterstützt, wobei die meisten Anwendungen die Formate
„RSS 1,0“ und „RSS 2.0“ anbieten. Des Weiteren ist auffällig, dass das Feedformat „Atom
0,3“ nur 28,60% der Anwendungen und die neueste Atomversion „Atom 1.0“ von keiner
Anwendung unterstützt wird. Dies kann dadurch erklärt werden, dass „Atom“ noch eine relativ „junge“ Technologie gegenüber den weiter verbreiteten und etablierten RSS-Formaten ist
und die Entwickler der social bookmarking Anwendungen die RSS-Schnittstellen den Atomschnittstellen vorziehen. In zwei Anwendungen (Simpy und Spurl) werden mehrere verschiedene Feedformate angeboten, womit die Entscheidung, welches Feedformat für den Export
von Bookmarks verwendet wird, den Endanwendern überlassen wird.
Darüber hinaus ermöglichen fünf Anwendungen den Import von Bookmarks. Über die Importschnittstelle können die Anwender die Bookmarks, die in ihren Browser gespeichert wurden, mit ihrem social bookmarking Account synchronisieren. Die Importschnittstellen können vor allem mit den bekannten Browsern wie dem „Internet Explorer“, „Netscape“ und „
Firefox“ interagieren. Von zwei Systemen wird des Weiteren eine Schnittstelle zu dem Anbieter Del.icio.us angeboten. Mit dieser Schnittstelle wird es den Anwendern dieser Systeme
ermöglicht, ihre Bookmarks mit ihrem Del.icio.us-Account zu synchronisieren. Da die
Schnittstelle zu Del.icio.us die einzige anwendungsspezifische Schnittstelle ist, die von den
untersuchten Anwendungen angeboten wird, scheint Del.icio.us eine besondere Stellung unter den verschiedenen Anwendungen einzunehmen.
In diesem Kapitel wurden die zentralen Erkenntnisse, die durch die Marktstudie gewonnen
wurden, kurz vorgestellt1. Im folgenden Kapitel werden nun die Anforderungen an die social
bookmarking Erweiterung, die sowohl aus den Ergebnissen dieser Marktstudie als auch aus
den Gesprächen mit dem Aufgabensteller abgeleitet wurden, vorgestellt.
1
Im Anhang befindet sich eine Funktionsübersicht der Systeme, die in dieser Marktstudie erfasst wurden
15
2
Anforderungen an die social bookmarking Erweiterung
In diesem Kapitel werden die allgemeinen und die anwendungsspezifischen Anforderungen
an die Erweiterung erläutert. Die anwendungsspezifischen Anforderungen beziehen sich auf
die Funktionalität der zwei Schichten der Erweiterung. Die erste Schicht ist der Bookmarkaccount, in dem jeder Anwender seine persönlichen Bookmarks definieren und verwalten kann.
Dagegen können die Anwender in der öffentlichen Schicht zum einen den Bookmarkbestand
der Erweiterung durchsuchen und zum anderen ihre Bookmarks untereinander austauschen.
2.1
Generelle Anforderungen
Eine grundsätzliche Anforderung an die Erweiterung ist die Benutzerfreundlichkeit. Sie
trägt dazu bei, dass die Erweiterung schnell von den Anwendern akzeptiert wird und diese
nach einer relativ kurzen Einführungsphase in den Arbeitsalltag integriert wird. Um die Erweiterung benutzerfreundlich zu gestalten, wurden zwei zentrale Anforderungen definiert:
•
Implementierung von AJAX-basierten Funktionen.
•
Realisierung einer einheitlichen Oberfläche
AJAX (Asynchronous Javascript and XML) ist eine Kombination von den verschiedenen
webbasierten Technologien und ermöglicht eine asynchrone Client-Server Kommunikation.
Durch diese Art der Kommunikation, welche in der folgenden Abbildung dargestellt wird,
können Daten zwischen einem Server und einem HTML-Client ausgetauscht werden, ohne
dass der Client neu geladen werden muss.
Abb. 4: AJAX web application model ( Quelle: [Gar05])
16
Durch den Einsatz der AJAX-Technologie, die im Kapitel 3.2 näher erläutert wird, entfallen
somit die Ladezeiten der Webseiten, die durch die herkömmliche synchrone Kommunikation
entstehen würden. Demzufolge laufen AJAX-basierte Webanwendungen selbst auf Rechnern,
die nur über eine langsame Verbindung zum Internet verfügen, schneller und flüssiger als
herkömmliche Webanwendungen.
Durch die Realisierung einer einheitlichen Oberfläche, in der sich ähnliche Elemente oder
Funktionen immer an den gleichen oder ähnlichen Positionen befinden, wird die Ergonomie
der Anwendung erhöht. Diese Ergonomie trägt wiederum dazu bei, dass die Handhabung der
Erweiterung für die Anwender erleichtert wird, wodurch deren Einarbeitungsaufwand reduziert wird.
Des Weiteren sollte eine Schnittstelle zu dem social bookmarking System Del.icio.us2 realisiert werden, damit die Anwender der Erweiterung nicht nur auf intern gespeicherte Bookmarks, sondern auch auf die externen Bookmarks von Del.icio.us zugreifen können.
Hierdurch können die Anwender schon während der Einführungsphase, wenn erst wenige
interne Bookmarks in die Erweiterung eingefügt wurden, auf eine umfangreiche Bookmarkbibliothek zugreifen.
Neben der Importschnittstelle sollten Exportschnittstellen für die Erweiterung implementiert werden, um den Export von Bookmarks in Fremdsysteme zu ermöglichen. Dabei sollten
einerseits verschiedene Newsfeeds (siehe Kap. 3.3) implementiert werden, mit denen der
Export von Bookmarklisten durch XML-Dokumente realisiert werden kann. Andererseits
sollte der Export von Bookmarklisten bzw. Taglisten auch als Webservice (siehe Kap. 5.6)
umgesetzt werden, damit diese webbasierten Anwendungen zur Verfügung gestellt werden
können.
Nachdem in diesem Kapitel die generellen Anforderungen erläutert wurden, werden im folgenden Kapitel die Anforderungen an den Bookmarkaccount beschrieben.
2
http://del.icio.us
17
2.2
Anforderungen an den Bookmarkaccount (private Schicht)
Wie bereits zu Beginn des zweiten Kapitels erwähnt wurde, stellt der Bookmarkaccount die
Schicht dar, in der die verschiedenen Anwender ihre persönlichen Bookmarks speichern und
verwalten können.
Bei der Definition eines Bookmarks, sollten die Anwender diesem die folgenden Eigenschaften zuordnen können:
•
Titel des Bookmarks
•
URL des Bookmarks
•
Tags
•
Beschreibung des Bookmarks (optional)
•
Sichtbarkeit
Die zwei wichtigsten Elemente bei der Charakterisierung eines Bookmarks sind der Titel
sowie die URL der Ressource, auf die der Bookmark verweisen soll. Neben diesen Grundelementen sollten dem Bookmark Tags zugeordnet werden, damit dessen Kategorisierung
möglich ist. Außerdem sollte der Anwender noch eine kurze Beschreibung für den Bookmark
verfassen können und entscheiden dürfen, ob der Bookmark nur im Bookmarkaccount (privat) oder auch auf der öffentlichen Plattform der Erweiterung (public) angezeigt werden darf.
Neben dem Einfügen von Bookmarks sollte es den Anwendern möglich sein ihre Tags umzubenennen, damit sie zum Beispiel alle Bookmarks, die mit einem bestimmten Tag verknüpft sind, einem neuen Tag, der die Bookmarks besser beschreibt, zuordnen können. Diese
Funktion würde die konsistente Kategorisierung der Bookmarks für die Anwender unterstützen.
Des Weiteren sollte für den Bookmarkaccount eine Übersichtsseite realisiert werden, die alle
Bookmarks des jeweiligen Anwenders darstellt. Die Darstellung der Bookmarks sollte dabei
nicht nur die Informationen wie Titel, Beschreibung, Tags und den Namen des Anwenders
umfassen, sondern auch wiedergeben, wie viele andere Anwender einen Bookmark zu der
gleichen URL gespeichert haben und welche Kommentare sie diesem zugeordnet haben. Zusätzlich zu den Eigenschaften sollte jeder Bookmarkdarstellung eine Bearbeitungsfunktion
und eine Löschfunktion, sowie eine Funktion, mit Hilfe derer die Bookmarks nach
Del.icio.us exportiert werden können, zugeordnet werden.
18
Eine weitere Anforderung an den Bookmarkaccount ist die Realisierung von Abonnementfunktionen, die es den Anwendern ermöglichen bestimmte Bookmarks zu abonnieren. Die
Bookmarks, die den Abonnements des Anwenders entsprechen, sollten schließlich in der so
genannten „Inbox“ innerhalb des Bookmarkaccounts angezeigt werden.
Schließlich sollte es jedem Anwender ermöglicht werden, seine öffentlichen Bookmarks den
anderen Anwendern der Erweiterung zur Verfügung zu stellen. Diese Schnittstelle zwischen
dem Bookmarkaccount und der öffentlichen Schicht der Erweiterung sollte durch den so genannten Bookmarklog realisiert werden. Dieser sollte analog zu der Übersichtsseite des
Bookmarkaccounts aufgebaut werden, so dass in diesem neben den Bookmarks auch die
Tags eines Anwenders dargestellt werden können. Außerdem sollte für die Bookmarklogs
eine Exportschnittstelle realisiert werden. Diese Exportschnittstelle sollte es jedem Anwender
ermöglichen, einerseits einzelne Bookmarks durch eine Kopierfunktion in ihren persönlichen
Bookmarkaccount zu kopieren und andererseits Feeds, welche die Bookmarks des Bookmarklogs enthalten, anzufordern.
2.3
Anforderungen an die öffentliche Schicht der Erweiterung
Die öffentliche Schicht, auf die im Gegensatz zu den Bookmarkaccounts jeder Anwender
zugreifen kann, ermöglicht es den Anwendern, den gesamten Datenbestand der Erweiterung
zu durchsuchen. Für die öffentliche Plattform wurden folgende Anforderungen festgelegt:
•
Implementierung einer effizienten Darstellung des Datenbestandes der Erweiterung
•
Realisierung der Schnittstelle zu Del.icio.us
Um das Durchsuchen des Datenbestandes für die Anwender zu erleichtern, sollte dieser
auf verschiedene Weisen dargestellt werden können. Neben den Bookmarklog, in dem die
Bookmarks einer bestimmten Person dargestellt werden (siehe Kap.2.2), sollte eine Übersicht
über die aktuellen Bookmarks und eine tagsspezifische Sicht auf den Bookmarkbestand realisiert werden. Die Übersicht über die neuesten Bookmarks ist für die Anwendergruppen interessant, die regelmäßig die Erweiterung nutzen und sich über die Änderungen des Datenbestandes informieren wollen. Für Anwendergruppen, die Bookmarks zu einem bestimmten
Thema suchen, ist dagegen die tagspezifische Sicht, geeignet. Diese verschiedenen Sichtweisen auf den Datenbestand sollten eng miteinander verknüpft sein, so dass die Anwender je-
19
derzeit auf diese zugreifen und sich somit einen umfassenden Überblick über den Datenbestand verschaffen können.
Des Weiteren soll in der öffentlichen Plattform der Erweiterung eine Importschnittstelle zu
Del.icio.us implementiert werden. Dadurch wird der Datenbestand, auf den die Anwender
zugreifen können, erheblich erweitert. Die importierten Bookmarks sollten dabei auf die gleiche Art und Weise wie die internen Bookmarks dargestellt werden, damit die Einheitlichkeit
der Oberfläche der Erweiterung auch in dieser Importschnittstelle gewahrt bleibt. Schließlich
sollte vor allem den Bookmarks, die in der öffentlichen Schicht dargestellt werden, eine Kopierfunktion, mit der die Anwender Bookmarks aus dieser Plattform in ihren persönlichen
Bookmarkaccount kopieren können, zugeordnet werden.
Nachdem in diesem Kapitel die Anforderungen an die social bookmarking Erweiterung erläutert wurden, werden im folgenden Kapitel die Technologien vorgestellt, die für die Umsetzung der Anforderungen verwendet werden.
20
3
Realisierungstechnologien
Zu Beginn dieses Kapitels wird die Architektur des Infoasset Brokers, in welchen die social
bookmarking Erweiterung eingebettet wird, vorgestellt. Daran anschließend wird ein Überblick über die Technologien, welche für die Umsetzung der Anforderungen verwendet wurden, gegeben.
3.1
Architektur des Infoasset Brokers
Der Infoasset Broker ist eine Software, die auf einer Client-Server Architektur basiert, welche sich wie folgt darstellen lässt:
HTML-Client
HTML-Client
HTML-Client
HTML-Client
HT
ML-C
lient
W
ML-C
lient
HT
ML-C
lient
(optional)
Application
Server
infoAsset Broker
File Systems
Full Text Search
Engines
SQL-Data Base
(recommended)
Client
Content
Management System
Data Layer
(optional)
Abb. 5: Client-Server Architektur des Infoasset Brokers (Quelle: [Leh05])
Die Benutzerschnittstelle des Brokers wurde als HTML-Client realisiert, wodurch die Anwender über einen Browser und somit arbeitsplatzunabhängig auf diese Software zugreifen
können.
Die Erzeugung der HTML-Seiten, die durch den Client ausgegeben werden, basiert auf
Templates, welche neben HTML-Elementen und Javascripts auch Platzhalter enthalten können. Die Platzhalter stehen für variable Inhalte der HTML- Seiten, die durch Handler, in denen die Anwendungslogik implementiert wird, dynamisch substituiert werden können.
21
3.1.1 Funktionalität und Eigenschaften von Handlern
Handler sind Java-Klassen, in denen die Anwendungslogik des Infoasset Brokers implementiert wird. Diese empfangen somit die Requests des HTML-Clienten und verarbeiten diese.
Nach der Verarbeitung der Requests führen die Handler, je nachdem zu welcher Handlerklasse sie gehören, unterschiedliche Abschlussaktionen aus.
Visible Handler ersetzen, nachdem sie die Requestparameter empfangen und diese verarbeitet haben, die Platzhalter in dem Template, das mit dem entsprechenden Handler verknüpft
ist. Für die Ersetzung der Platzhalter können verschiedene Substitutionen verwendet werden.
Printsubstitutions ersetzen Platzhalter durch einen Text. Dieser Text kann mit HTML-
Tags formatiert werden oder nur aus HTML-Elementen bestehen, so dass durch die Ausführung der Substitutionen die Formatierung des Templates verändert werden kann.
Conditionalsubstitutions ersetzen bedingte Platzhalter in den Templates. Durch diese
Art der Platzhalter können bestimmte Elemente in den HTML-Dokumenten in Abhängigkeit
davon, ob eine bestimmte Bedingung wahr oder falsch ist, eingeblendet bzw. ausgeblendet
werden. Diese Bedingungen werden als reguläre Ausdrücke, welche während der Laufzeit
durch die Anwendungslogik ausgewertet werden, in den Conditionalsubstitutions
definiert.
Die Listsubstitutions ersetzen die Listenplatzhalter, innerhalb derer weitere Platzhalter
eingefügt werden können, die so oft substituiert werden, bis eine bestimmte Terminierungsbedingung erfüllt ist. Die Listsubstitutions definieren einerseits diese Terminierungsbedingung und andererseits die Substitutionen der Platzhalter, die sich innerhalb der Listeplatzhalter befinden. Für die Definition dieser Substitutionen können wiederum Printsubstitutions, Conditionalsubstitutions oder Listsubstitutions verwendet
werden.
Durch die Verwendung von Platzhaltern ist eine flexible Änderung bzw. die effiziente Erstellung von Templates möglich. So können verschiedene Elemente, die durch Platzhalter dargestellt werden, innerhalb eines Templates durch die Änderung der Reihenfolge der Platzhalter
verschoben oder durch das Entfernen der Platzhalter ausgeblendet werden. Des Weiteren
22
können bestimmte Elemente, die in einem Template mehrfach vorkommen sollen, jeweils
durch den gleichen Platzhalter dargestellt werden.
Die zweite Klasse von Handlern, die so genannten Invisiblehandler, verarbeitet Requests
und leitet diese an andere Handler weiter. Diese Handler können dazu genutzt werden, Requests, die nur den Systemzustand ändern, zu verarbeiten. So werden Invisiblehandler beispielsweise oft dazu verwendet, um Formulardaten zu verifizieren und diese anschließend in
die Datenbank einzutragen. Des Weiteren können mit den Invisiblehandlern die Eigenschaften von Requests untersucht werden und diese Requests somit - in Abhängigkeit von ihren
Eigenschaften - an den geeigneten Handler weitergeleitet werden. Diese Art der Requestverarbeitung wurde für die Realisierung der Webservices angewandt (siehe Kap 5.6).
Schließlich gibt es noch die Mischhandler, eine Mischform zwischen Visible- und Invisiblehandlern. Nach der Verarbeitung der Requests substituieren diese Handler die Platzhalter in
den Templates, welche mit dem Handler verknüpft sind, oder leiten den Request an andere
Handler weiter.
Jeder Handler kann für verschiedene Templates verwendet werden, so dass für gleichartige
Templates nur einmal eine fachliche Logik implementiert werden muss, die jeweils mit den
entsprechenden Templates verknüpft wird.
3.1.2 Eigenschaften der Services
Bei der Verarbeitung der HTTP-Requests greifen die Handler über Services auf die Assets
zu, welche die Entitäten des Infoasset Brokers innerhalb des Systems darstellen. Der Infoasset Broker kann zurzeit folgende Entitäten verwalten:
•
•
•
Dokumente
Gruppen
Verzeichnisse
•
•
•
Personen
Organisationseinheiten
Bookmarks
•
•
Projekte
Weblogs
Jede Entität wird auf einem bestimmten Assettyp abgebildet, welcher einerseits die Eigenschaften (Properties) der Entität darstellt und andererseits die Methoden (Assetmethoden)
enthält, über die auf die entsprechende Entität zugegriffen und diese manipuliert werden
kann. Die Assetmethoden sind vor allem get- und set-Methoden zum auslesen oder setzten
der Attribute eines Assets.
23
Die Eigenschaften eines Assets werden in einem so genannten Assetschema definiert, das
jeder Eigenschaft einen bestimmten Datentyp zuordnet. Der Infoasset Broker stellt hierfür
fünf Datentypen bereit:
•
Integer (Intproperty)
•
String (StringProperty)
•
DomainValue (DomainValueProperty)
•
CharStream (CharStreamProperty)
•
Date (DateProperty)
Für jeden Datentyp kann ein Defaultwert festgelegt werden, welcher der Eigenschaft zugeordnet wird, sobald eine Instanz des Assets, mit dem die Eigenschaft verknüpft ist, initialisiert wird.
Neben den Assetschemas können für jedes Asset noch AssociationSchemas, die die Beziehung zwischen dem Asset und den anderen Assets darstellen, definiert werden. Grundsätzlich
unterstützt der Infoasset Broker zwei unterschiedliche Beziehungstypen: Die „1 zu M“ Beziehung (OneToMany-AssociationSchema) und die „M zu N“ Beziehung (ManyToMany3
AssociationSchema). Das OneToMany-AssociationSchema besagt, dass eine Instanz
eines Assets mit vielen Instanzen eines anderen Assets in Beziehung stehen kann, wohingegen beim ManyToMany-AssociationSchema mehrere Instanzen eines Assets mehreren
Instanzen eines anderen Assettyps zugeordnet werden können. Ein Beispiel für eine „1 zu M“
Beziehung wäre die Verknüpfung zwischen Verzeichnissen und Dokumenten, da in einem
Verzeichnis mehrere Dokumente abgelegt werden können. Dagegen ist die Beziehung zwischen Projekt und Person ein Beispiel für eine „M zu N“ Beziehung, da einem Projekt sowohl mehrere Personen zugeordnet werden können, als auch eine Person an mehreren Projekten teilnehmen kann. Die zwei Beziehungstypen werden in folgender Graphik dargestellt:
Abb. 6.: AssociationSchemas: ManyToMany-Association und OneToMany-Association (Quelle:[Leh05])
3
Instanzen bedeutet in diesem Zusammenhang eine bestimmte Ausprägung eines Assets
24
Nachdem das Assetschema und das Associationschema, die zusammen eine Entität des Infoasset Brokers vollständig beschreiben, definiert wurden, werden diese in einem Datenspeicher abgebildet. .
Des Weiteren wurde eine Anfragesprache entwickelt, mit der die Instanzen einzelner Assets
effektiv abgefragt werden können. Die Basis jeder Anfrage bildet der Assetcontainer, in dem
sich alle Instanzen eines Assets befinden. Aus diesem können nun mittels Queries, deren
Struktur in der folgenden Abbildung dargestellt wird, bestimmte Instanzen abgefragt werden.
<Querycondition> (Container, <Property>, <Auswahlprädikat>)
Abb. 7: Struktur einer Query ( Quelle: eigene Darstellung )
Grundsätzlich kann mit jeder Query genau eine Eigenschaft (<Property>) der Instanzen eines
Containers abgefragt werden. Durch die Queryconditions wird der Wert einer Eigenschaft
mit einem Auswahlprädikat in Bezug gesetzt. Dabei kann zwischen fünf grundlegenden Queryconditions unterschieden werden:
QueryContains
QueryBegins
QueryEqual/QueryUnequal
QueryLess/ QueryGreater
Überprüft, ob der Wert einer Eigenschaft
den im Auswahlprädikat angegeben Wert
enthält.
mit dem Wert des Auswahlprädikats anfängt.
mit dem Wert des Auswahlprädikats übereinstimmt (bzw. nicht übereinstimmt).
kleiner (bzw. Größer) als der Wert des
Auswahlprädikats ist.
Tab. 1: Queryconditions ( Quelle: eigene Darstellung )
Verschiedene Queries können mit den Operatoren „QueryAnd“ und „QueryOr“ verknüpft
werden, um komplexe Anfragen über verschiedene Properties zu formulieren, oder mit dem
Operator „QueryNot“ verneint werden. Nach der Ausführung einer Query werden die Assetinstanzen, deren Eigenschaften den Auswahlprädikaten entsprechen, in einen Iterator ausgegeben. Die Sortierung der Instanzen innerhalb des Iterators kann in einem so genannten Querysortingcriterion bestimmt werden, wobei in diesem angegeben wird nach welcher Eigenschaft und in welcher Reihenfolge (absteigend oder aufsteigend) die Instanzen sortiert werden sollen.
25
3.2
Asynchronous Javascript and XML (AJAX)
Wie schon in der Anforderungsanalyse kurz beschrieben, ist AJAX ein Konzept, das verschiedene Technologien vereint, um eine asynchrone Client-Server Kommunikation zu ermöglichen. Durch diese asynchrone Kommunikation können Daten zwischen dem Server und
dem Client ausgetauscht werden, ohne dass die clientseitige HTML-Seite, die die übermittelten Daten darstellt, neu geladen werden muss. Dies hat für die Anwender von AJAXbasierten Webanwendungen den Vorteil, dass sie zum Beispiel nachdem ein Formular abgeschickt wurde, nicht darauf warten müssen bis die Client-Server Kommunikation abgeschlossen ist und die Seite neu geladen wurde, sondern gleich auf derselben Seite weiterarbeiten
können. Die Verkürzung bzw. die Vermeidung von Ladezeiten macht sich besonders bei
Anwendern, die über eine langsame Internetverbindung verfügen, bemerkbar. AJAX kombiniert folgende Technologien miteinander:
•
HTML und CSS
•
Javascript
•
XMLHttpRequest
•
XML
•
DOM
Bei der Client-Server Kommunikation mittels AJAX sendet der Client, im Gegensatz zu der
klassischen Client-Server Kommunikation, kein HTTP-Request direkt an den Server, sondern
ruft eine Javascript-Funktion mit den entsprechenden Requestparametern auf. In dieser Funktion wird die fachliche Logik zur Verarbeitung des Requests implementiert. So wird im ersten Schritt der Verarbeitung überprüft, ob der Request lokal bearbeitet werden kann oder eine
Interaktion mit dem Server notwendig ist. Ist dies der Fall, so wird ein XMLHttpRequest
generiert, welcher die serverseitige Anwendungslogik mit den Parametern, die für die
Verarbeitung des Requests notwendig sind, aufruft. Die Anwendungslogik verarbeitet den
Request und bettet die Rückgabedaten in ein XML-Dokument ein, welches an das Javascript,
das den XMLHttpRequest generiert hat, übergeben wird. Mit Hilfe des data object models
(DOM) kann das Javascript nun das übermittelte XML-Dokument parsen und verarbeiten.
Bei dieser Verarbeitung werden die relevanten Daten aus dem XML-Dokument extrahiert
und schließlich in das HTML-Dokument, in dem der Request initialisiert wurde, eingebettet.
26
Die folgende Graphik stellt diese AJAX-basierte Kommunikation im Vergleich zur klassischen Kommunikation dar:
Abb. 8: Klassische und AJAX-basierte Client-Server Kommunikation (Quelle: [Gar05])
Bekannte Beispiele für Webanwendungen, in denen AJAX-Funktionen realisiert wurden,
sind „Google suggest“4und “Google Maps“5 . Im fünften Kapitel wird dargestellt, in welchen
Funktionen der Erweiterung AJAX verwendet wurde.
3.3
Content Syndication und Feeds
Eine wichtige Anforderung an die Implementierung der social bookmarking Erweiterung war
die Realisierung von Schnittstellen, über die Bookmarks exportiert werden können (siehe
Kap. 2.1). Dabei sollte neben den Webservices eine Exportschnittstelle auf Basis des Content
Syndication Konzeptes realisiert werden. „Content syndication makes part or all site´s content available for use by other services“[Ham03]. Wie in diesem Zitat erläutert wird, ermöglicht „Content Syndication” den Export von Webseiteninhalten. Für diesen Export werden die
Inhalte von Webseiten in XML-Dokumenten strukturiert und in einer maschinenlesbaren
Form dargestellt, die von den entsprechenden Webseiten als so genannte Feeds von den Anwendern angefordert werden können.
Für die Implementierung der Content Syndication Schnittstelle der Erweiterung wurden die
drei Feedformate RSS 0.91, RSS 1.0 und Atom verwendet.
4
5
http://www.google.com/webhp?complete=1&hl=en
http:/maps.google.com/
27
3.3.1
RSS 0.91
Die Entwicklung der Feedtechnologie basiert auf RDF, welches von Ramanathan V. Guha in
Zusammenarbeit mit Tim Bray entwickelt wurde. In RDF wurde ein Vokabular für XMLDokumente definiert, das die Beschreibung von Informationen innerhalb des World Wide
Webs ermöglicht (vgl. [HAM03]).
Das erste auf RDF basierende Feedformat, das „RDF site summary“ (RSS 0.90), wurde von
Netscape entwickelt, um Überschriften und URLs von externen Seiten auf der neu entwickelten Plattform „ My Netscape Network“ anzeigen zu können. Obwohl RSS 0.90 in dieser Anwendung (My Netscape Networt) erfolgreich eingesetzt wurde, wurde RSS 0.90 schon bald
durch RSS 0.91 ersetzt, da dieses Feedformat für die Enduser zu kompliziert zu sein schien.
Die Spezifikation von RSS 0.91, welches zu den bekanntesten Feedformaten gehört, umfasst
sowohl Elemente des RSS 0.90 Formats als auch Elemente des „ScriptingNews Formats“,
welches von „Userland Software“ entwickelt wurde.
Jeder RSS 0.91 Feed besteht aus einem Channel, der bis zu 15 „Items“ erhält, in denen jeweils die Informationen eines bestimmten Informationstyps dargestellt werden. Dabei kann
generell, wie in folgender Abbildung dargestellt wird, zwischen den Informationstypen Fließtext (textinput), Bild(Image) und sonstige Information (Item) unterschieden werden.
Abb. 9: Struktur eines „RSS 0.91“ Feeds (Quelle: [Ham03])
Wie dieser Abbildung zu entnehmen ist, können dem „Channel“ Metainformationen über die
Webseite, die den Feed anbietet, zugeordnet werden. Zum Beispiel kann in den Attributen
28
„skipdays“ und „skiphours“ der Zeitraum festgelegt werden, im dem der Feed von Feedaggregatoren angefordert werden darf (vgl. [WIN05]).
3.3.2 RSS 1.0
Ein weiteres weit verbreitetes Feedformat ist RSS 1.0, welches komplexer und somit mächtiger ist als RSS 0.91. Doch der Hauptunterschied zwischen den Formaten ist, dass RSS 1.0
auf der RDF-Spezifikation basiert und den Einsatz von Namespaces für die Definition der
Eigenschaften des Feeds ermöglicht. Somit können zur Erstellung von RSS 1.0 Feeds sowohl
standardisierte als auch frei definierte Namespaces verwendet werden. Zur Zeit sind über 14
standardisierte Namespaces (vgl. [Ham03]) für die Erstellung von RSS 1.0 Dokumenten verfügbar, die beliebig kombiniert werden können.
Da in unterschiedlichen Namespaces gleiche Elemente enthalten sein können, ist es möglich,
verschiedenartigen Informationsobjekten ähnliche Elemente zuzuordnen, die dennoch anhand
ihrer Zugehörigkeit zu Namespaces differenzierbar sind. Neben der Trennung von verschiedenen Eigenschaften können Namespaces ebenfalls Eigenschaften gruppieren, indem zum
Beispiel für jeden Informationstyp, der in einem Feed beschrieben wird, ein individueller
Namespace definiert wird.
Des Weiteren existiert, wie in der folgenden Abbildung zu sehen ist, ein RSS 1.0 Namespace,
der die Grundstruktur eines RSS 1.0 Feeds darstellt.
Abb. 10: Struktur eines "RSS 1.0" Feeds (Quelle: [HAM03])
29
3.3.3 ATOM
Nach der Veröffentlichung der ersten RSS-Spezifikation wurden zahlreiche verschiedene
Versionen dieser Spezifikation definiert und publiziert, die parallel verwendet wurden. Diese
Entwicklung führte dazu, dass bald kein einheitlicher technologischer Standard für „Content
Syndication“ mehr existierte. Aus diesem Grund wurde eine neue, von RSS unabhängige
Feedversion namens „Atom“ entwickelt, welche die Vorteile der verschiedenen RSSVersionen vereinen sollte. Die Einführung dieses Formats wurde vor allem durch die Industrievereinigung „Atom Enable Alliance“ unterstützt und vorangetrieben.
Atom-Feeds sind, ebenfalls wie RSS-Feeds, strukturierte XML-Dokumente, in denen die
Eigenschaften der verschiedenen Informationsobjekte in „Entries“ beschrieben werden. Zur
Beschreibung dieser Eigenschaften können zum einen der standardisierte Namespace des
Atomformats, der von dem „World Wide Web Consortium (W3C)“ bereitgestellt wird, und
zum anderen auch externe Namespaces verwendet werden. Dadurch ist es –wie in folgendem
Zitat erläutert - möglich, Module der RSS 1.0- bzw. der RSS 2.0–Spezifikation in Atom zu
verwenden: „Elements from other namespaces may be included pretty much anywhere. This
means that most RSS 1.0 and RSS 2.0 modules may be used in Atom” [Ato04].
Die Spezifikation der aktuellen Version 1.0 des Atomformats besagt, dass alle „Entries“ in
einem „Feed“-Objekt eingebettet werden müssen. Diesem Objekt werden Elemente zur Beschreibung der Metadaten der Ressource, die durch diesen Feed dargestellt werden soll, zugeordnet. Für diese Beschreibung gibt es drei Elemente, die bei der Erstellung eines FeedObjektes definiert werden müssen, und eine Reihe von optionalen Elementen. Dem FeedObjekt müssen eine URI, mit welcher der Feed eindeutig identifiziert werden kann, ein Titel,
der den Inhalt des Feeds kurz beschreibt, und ein Datum, das angibt wann der Feed zum letzten Mal aktualisiert wurde, zugeordnet werden. Optional sind dagegen beispielsweise die
Elemente “category“, in welcher das Themengebiet des Feeds angegeben werden kann und
„author“, in das der Name des jeweiligen Autors eingefügt werden kann.
Nach der Definition des Feed-Objektes, können diesem die Entries, in denen letztendlich die
Eigenschaften der Informationsobjekte definiert werden, hinzugefügt werden. Den Entries
können nun, neben den verpflichtenden Elementen „id“, „title“ und „update“, weitere
Elemente zur Beschreibung dieser Informationsobjekte zugeordnet werden. Beispielweise
bietet Atom im Unterschied zu RSS zwei verschiedene Elemente zur Beschreibung des Informationsobjekts an: „content“ und „summary”. In das Element „content“ kann die
30
komplette Beschreibung des Informationsobjektes eingefügt werden, wohingegen dem Element
„summary“ nur eine Zusammenfassung dieser Beschreibung zugeordnet werden kann. Des
Weiteren können die Elemente title, „summary“, „content“ und „rights“6 nicht nur reinen Fließtext, sondern auch Textpassagen, die mit HTML-, XHTML- oder XML-tags formatiert wurden, enthalten. Die Formatierung des Textes muss dabei in dem „Type“-Attribut des
entsprechenden Elementes angegeben werden.
Die Unterstützung verschiedener Textformate wurde in keinem RSS-Format umgesetzt, wodurch Atom vor allem zur Erstellung von textbasierten Feeds geeignet ist.
Im Kapitel 5.3.1 wird beschrieben, wie die Content Syndication Schnittstelle für die Erweiterung realisiert wurde und wie die Bookmarks, die exportiert werden sollen, in den vorgestellten Feedformaten darstellt werden können.
6
In dieses Element können „Copyright“-Angaben eingefügt werden
31
4
Modellierung der Erweiterung
Basierend auf den Technologien, die im letzten Kapitel vorgestellt wurden, wird in diesem
Kapitel die Modellierung der Erweiterung und somit die Umsetzung der Anforderungen an
diese dargestellt. Die konkrete Realisierung des Modells wird anschließend im fünften Kapitel erläutert.
4.1
Modell der Erweiterung
Die social bookmarking Erweiterung wurde auf Basis des schon bestehenden Assettyps
“Weblog” entwickelt. Dieser Assettyp ermöglicht es dem Anwender, zum Beispiel eigene
Texteinträge, Feedsammlungen oder das eigene Benutzerprofil auf individuell gestalteten
Seiten im Infoasset Broker zu veröffentlichen. Die Weblogs haben zwei Schichten. Eine Benutzerschicht, in der angemeldete Anwender Einträge in den Weblog einfügen oder sie editieren können und eine öffentliche Schicht, in der die Anwender ihre Weblogeinträge veröffentlichen können. Da das Konzept der zwei verschiedenen Benutzerschichten auch für die
social bookmarking Erweiterung angewandt werden kann, war es nahe liegend, dieses für die
Realisierung der Erweiterung zu übernehmen und es an die speziellen Anforderungen der
Erweiterung anzupassen. Das folgende Diagramm stellt das Modell der Erweiterung dar:
Abb. 11: Modell der Erweiterung ( Quelle: eigene Darstellung )
32
Wie diesem Diagramm zu entnehmen ist kann jedem Anwender (Person) ein Weblog, der im
weiteren Textverlauf „Bookmarklog“ genannt wird, zugeordnet werden. Der Bookmarklog
enthält alle Bookmarks eines Anwenders, die durch Tags kategorisiert werden können.
Neben den Bookmarks werden dem Bookmarklog die Abonnements, die dessen Eigentümer
abgeschlossen hat, zugeordnet. Wenn ein Bookmark eines solchen Abonnements in das System einfügt wird, wird ein Ereignis ausgelöst und der entsprechende Bookmark im Bookmarklog des Abonnenten angezeigt.
Nachdem die Beziehungen, welche die Objekte zueinander haben, kurz dargestellt wurden,
werden nun die Eigenschaften dieser Objekte näher erläutert:
Der Anwender (Person) kann auf zwei verschiedene Arten mit der social bookmarking Erweiterung interagieren. Einerseits kann er in seinem persönlichen Bookmarkaccount seine
Bookmarks verwalten und andererseits in der öffentlichen Schicht den Bookmarkbestand der
Erweiterung durchsuchen.
Im Bookmarkaccount kann der Anwender neue Bookmarks definieren, bestehende Bookmarks bearbeiten bzw. löschen oder sie über eine Exportschnittstelle nach Del.icio.us exportieren. Außerdem werden in dieser Schicht die aktuellsten Bookmarks seiner Abonnements
angezeigt.
In der öffentlichen Schicht der Erweiterung können die Anwender sowohl auf interne als
auch auf externe Bookmarks zugreifen und diese durchsuchen. Interne Bookmarks sind
Bookmarks, die von den verschiedenen Anwendern direkt in die Erweiterung eingefügt wurden. Dagegen werden die externen Bookmarks über eine Importschnittstelle von dem social
bookmarking Anbieter Del.icio.us in die Erweiterung importiert.
Dem Bookmarklog können zwei unterschiedliche Bedeutungen zugeordnet werden. Einerseits ist dieser ein Objekt des Modells und andererseits stellt er eine Komponente der social
bookmarking Erweiterung dar.
Der Bookmarklog als Objekttyp des Modells verknüpft jeweils die Bookmarks und die Abonnements mit deren jeweiligen Eigentümern (siehe Abb. 11). Darüber hinaus werden in
diesem die Einstellungen gespeichert, welche die Anwender für ihren jeweiligen Bookmarkaccount festlegen. Die Eigenschaften des Bookmarklogs als Objekttyp werden in dem Kapitel 5.1.1 näher beschrieben.
Dagegen ermöglicht die Systemkomponente „Bookmarklog“ jedem Anwender seine Bookmarks öffentlich darzustellen, so dass die anderen Anwender der social bookmarking Erwei-
33
terung auf die Bookmarks des jeweiligen Anwenders zugreifen können. Durch die Bookmarklogs wird somit die personenspezifische Sicht auf den internen Bookmarkbestand der
Erweiterung realisiert. Die Systemkomponente „Bookmarklog“ wird im Kapitel 4.2.4 näher
beschrieben.
In Bookmarks können sowohl die URLs verschiedener Webressourcen als auch die verschiedenen Entitäten des Infoasset Brokers, die ebenfalls mittels eindeutiger URLs adressiert
werden können, gespeichert und beschrieben werden. Bei der Definition von Bookmarks
müssen diesen, wie schon im Kapitel 2.2 beschrieben, folgende Attribute zugeordnet werden:
Title, URL, Tags, Beschreibung und Sichtbarkeit. Im Titel wird die Ressource, die in dem
Bookmark gespeichert werden soll, kurz beschrieben und dem Attribut „URL“ die Adresse
dieser Ressource zugeordnet. Bei der Wahl des Titels ist es in den meisten Fällen empfehlenswert, den tatsächlichen Titel der Webressource zu übernehmen. Des Weiteren kann dem
Bookmark ein Kommentar („Beschreibung“) hinzugefügt und dessen Sichtbarkeit bestimmt
werden. Die Sichtbarkeit gibt an, ob ein Bookmark nur in dem Bookmarkaccount (privat)
dessen Eigentümers oder in der öffentlichen Plattform (öffentlich) angezeigt werden darf. Die
Tags werden in einem gesonderten Abschnitt dargestellt, da diese keine direkten Eigenschaften der Bookmarks sind, sondern eigenständige Objekte des Modells darstellen, die mit den
Bookmarks verknüpft werden (siehe Abb. 11).
Generell ist es möglich für eine Ressource mehrere Bookmarks zu definieren, damit diese in
unterschiedlichen Kontexten - beispielsweise mit verschiedenen Beschreibungen - dargestellt
werden kann.
Tags sind Schlüsselwörter, welche den Bookmarks verschiedene Themen zuordnen und diese
somit kategorisieren. Da jeder Bookmark mit beliebig vielen Tags verknüpft werden kann,
können durch die Analyse der Tagkombinationen, die den verschiedenen Bookmarks zugeordnet wurden, Beziehungen zwischen den Tags definiert werden. So kann, wenn zwei unterschiedliche Tags gemeinsam mehreren Bookmarks zugeordnet wurden, darauf geschlossen
werden, dass sich die Bedeutungen dieser Tags überschneiden. Die Tags, die eine solche Bedeutungsüberschneidung aufweisen, werden im weiteren Textverlauf „verwandte Tags“ genannt.
34
Abonnements unterstützen den Anwender dabei, die für ihn interessanten Bookmarks aus
der Menge der Bookmarks herauszufiltern. Wenn ein Anwender einen bestimmten Bookmarktyp abonniert, wird er automatisch benachrichtigt, sobald ein Bookmark, der dem abonnierten Bookmarktyp entspricht, in die Erweiterung eingefügt wird. Grundsätzlich kann zwischen drei Abonnementtypen unterschieden werden:
•
tagspezifische Abonnements
•
personenspezifische Abonnements
•
tagund personenspezifische Abonnements
Bei tagspezifischen Abonnements wird der Anwender informiert, sobald ein Bookmark, dem
ein bestimmter Tag zugeordnet wurde, eingefügt wird. Wenn ein Anwender über die neuen
Bookmarks eines bestimmten Anwenders informiert werden will, so muss er dies in einem
personspezifischen Abonnement angeben. Das personenund tagspezifische Abonnement
stellt schließlich eine Mischform der beiden vorgestellten Abonnementtypen dar und informiert den Anwender, wenn eine bestimmte Person einen Bookmark, der mit einem speziellen
Tag verknüpft ist, einfügt. Die Bookmarks, die einem Abonnement entsprechen, werden in
dem Bookmarkaccount des jeweiligen Abonnenten angezeigt.
4.2
Umsetzung des Modells
Nachdem die unterschiedlichen Objekte des Modells und deren Beziehungen untereinander
dargestellt wurden, wird im nächsten Kapitel die Umsetzung des Modells erläutert.
4.2.1 Allgemeine Darstellung der Bookmarks
Die zentrale Aufgabe bei der Umsetzung des Modells ist es, eine geeignete Form für die Darstellung der Bookmarks zu definieren. Zum einem sollte diese Darstellung übersichtlich sein
und die grundlegenden Eigenschaften der Bookmarks enthalten. Zum anderen sollte sie die
Vernetzung von verschiedenen Bookmarks unterstützen und für jede Sicht auf den Bookmarkbestand einheitlich sein. Deshalb wurde für die Bookmarks folgende Darstellung gewählt:
35
Abb. 12: Darstellung eines Bookmarks ( Quelle: eigene Darstellung )
Wie der Grafik zu entnehmen ist, erstreckt sich die Darstellung eines Bookmarks über vier
„Zeilen“. In der ersten Zeile wird das Datum des Tages angegeben, an welchem der Bookmark eingefügt wurde. So sieht der Anwender gleich, ob es sich um einen aktuellen Bookmark handelt oder ob dieser schon länger existiert. Dem Datum folgt der Titel des Bookmarks, der mit der Ressource verlinkt ist, deren URL in den Bookmark gespeichert ist. Daran
anschließend wird der Kommentar ausgegeben, mit dem der Eigentümer den Bookmark beschrieben hat. Die letzte Zeile enthält die Tags, die dem Bookmark zugeordnet wurden, den
Namen des Bookmark-Eigentümers und Anzahl der Personen, die ebenfalls einen Bookmark
für die Ressource, mit welcher der dargestellte Bookmark verknüpft ist, definiert haben. Die
Angabe dieser Anzahl ist eine Art qualitative Bewertung der Bookmarks, da, falls eine Ressource von vielen Anwendern gespeichert wird, darauf geschlossen werden kann, dass diese
Ressource einen interessanten Inhalt hat. Diese Bewertung ist im weitesten Sinne mit dem
„PageRank“ Mechanismus der Suchmaschine „Google“ vergleichbar, der die Ressourcen
anhand der Anzahl der Links, die auf diese Seite verweisen, bewertet (vgl. [GOO05]).
Zu beachten ist, dass die drei Informationen der letzten Zeile als Links dargestellt werden,
welche die verschiedenen Sichten auf den Bookmarkbestand mit dem jeweils dargestellten
Bookmark vernetzen. Die Tags verweisen auf tagspezifische Seiten, die alle Bookmarks, die
mit den angezeigten Tags verknüpft sind, enthalten. Der Benutzername verweist auf den
Bookmarklog des Eigentümers des jeweiligen Bookmarks. Die Darstellung der Anzahl der
Anwender, die ebenfalls einen Bookmark zu derselben Ressource gespeichert haben, ist mit
einer Kommentarfunktion verknüpft. Diese Kommentarfunktion gibt die Beschreibungen
aller Bookmarks aus, die mit derselben Ressource wie der jeweils dargestellte Bookmark
assoziiert sind.
Die in diesem Abschnitt vorgestellte Darstellung der Bookmarks ist für alle Komponenten
der Erweiterung einheitlich, kann aber in den verschiedenen Komponenten durch weitere
Funktionen ergänzt werden.
Nachdem die allgemeine Darstellung der Bookmarks erläutert wurde, wird nun die Umsetzung der verschiedenen Schichten der Erweiterung beschrieben.
36
4.2.2 Benutzerschicht: Der Bookmarkaccount
Die Bookmarkaccounts, auf die jeweils nur deren jeweilige Eigentümer zugreifen dürfen,
stellen den Anwendern vier grundlegende Funktionen bereit:
•
Einfügen bzw. editieren von Bookmarks
•
Übersicht über die Bookmarks des Anwenders
•
Verwaltung der Abonnements
•
Bearbeiten der Tags
Beim Einfügen eines Bookmarks kann der Anwender die Eigenschaften des Bookmarks in
ein Formular eingeben. Nachdem er alle Eigenschaften des Bookmarks festgelegt und das
Formular abgeschickt hat, wird von der fachlichen Logik überprüft, ob die eingegebene URL
gültig ist. Konnte die Gültigkeit der URL bestätigt werden, so wird der Bookmark in das System eingefügt. Dabei werden neben den eingegeben Daten, das Einfügedatum und der Name
des Eigentümers automatisch zu der Bookmarkdefinition hinzugefügt. Die eingefügten
Bookmarks werden auf der Übersichtsseite des Bookmarkaccount, die in der nachfolgenden
Abbildung dargestellt wird, angezeigt.
Abb. 13: Übersichtsseite des Bookmarkaccounts ( Quelle: eigene Dargstellung)
37
Auf der Übersichtsseite des Bookmarkaccounts werden sowohl die privaten als auch die
öffentlichen Bookmarks des jeweiligen Anwenders dargestellt. Zu der Darstellungsform der
Bookmarks, die im vorigen Kapitel beschrieben wurde, werden in dieser Ansicht noch vier
weitere Attribute hinzugefügt. Drei dieser Attribute haben eine funktionale Bedeutung: Bearbeiten, löschen und exportieren von Bookmarks. Über die Attribute „bearbeiten“ und „löschen“ werden Bearbeitungsfunktionen mit der Übersichtsseite verknüpft. Das ExportAttribut ermöglicht es dem Anwender seine Bookmarks nach Del.icio.us zu exportieren. Da
der Export von Bookmarks nur für die Anwender möglich ist, die über einen Account bei
Del.icio.us verfügen, kann die Exportfunktion auf der „Einstellungsseite“ des Bookmarkaccounts aktiviert oder deaktiviert werden. Das vierte Attribut stellt die „Sichtbarkeit“ der verschiedenen Bookmarks dar und zeigt an, ob ein Bookmark privat oder öffentlich ist.
Neben den Bookmarks werden auf der Übersichtsseite die Tags, die von dem Anwender definiert worden sind, angezeigt. Diese Tags verweisen auf die tagspezifischen Seiten, die sowohl alle Bookmarks des jeweiligen Tags als auch dessen verwandte Tags enthalten.
In der Inbox (siehe Anhang, Abb. 42) werden die aktuellen Bookmarks angezeigt, welche
mindestens einem Abonnement entsprechen. Damit in dieser immer nur die aktuellsten
Bookmarks des Abonnements dargestellt werden, wird die Inbox so realisiert, dass immer nur
diejenigen Bookmarks in der Inbox angezeigt werden, die seit dem letzten Zugriff an einem
vorherigen Tag auf diese, in das System gespeichert wurden. Da die Inbox wegen der täglichen Aktualisierung kein dauerhafter Speicher für Bookmarks ist, wird von dieser eine Kopierfunktion bereitgestellt, mit Hilfe derer die Anwender die angezeigten Bookmarks in ihren
eigenen Bookmarkaccount kopieren können.
Des Weiteren werden in der Inbox die verschiedenen Abonnements, die ein Benutzer abgeschlossen hat, geordnet nach den Abonnementtypen angezeigt. Diese sind jeweils mit der
Quelle des Abonnements verlinkt.
Mit der Funktion „Tags bearbeiten“ können Tags umbenannt werden. Durch die Umbenennung von Tags können alle Bookmarks, die mit einem bestimmten Tag verknüpft sind, einem
neuen Tag zugeordnet werden. Dadurch können alle Bookmarks eines Themas einem neuen
Thema zugeordnet werden, welches beispielsweise die Bookmarks treffender beschreibt.
38
Auf der Einstellungsseite des Bookmarkaccounts kann festgelegt werden, ob der Bookmarklog des Anwenders, der im Folgenden beschrieben wird, Newsfeeds anbieten soll. Bei
der Aktivierung von Newsfeeds, können Anwender bis zu vier Feedformate auswählen, die
schließlich von ihren Bookmarklogs bereitgestellt werden: RSS 0.91, RSS 1.0, Atom 0.3 und
Atom 1.0.
4.2.3 Bookmarklogs
Die Bookmarklogs (siehe Abb. 14) stellen jeweils die öffentlichen Bookmarks und Tags
einer bestimmten Person dar und bilden die Schnittstellen zwischen den Bookmarkaccounts
und der öffentlichen Schicht des Infoasset Brokers. Die in den Bookmarklogs dargestellten
Tags verweisen auf die tagspezifischen Seiten, die alle tagspezifischen Bookmarks des jeweiligen Eigentümers des Bookmarklogs enthalten. Somit können in den verschiedenen Bookmarklogs einerseits die personspezifischen und andererseits die person- und tagspezifischen
Bookmarks dargestellt werden.
Die Anwender können mittels einer Kopierfunktion die angezeigten Bookmarks in ihren eigenen Bookmarkaccount kopieren oder durch die Abonnementfunktion sowohl die personenspezifischen Bookmarks als auch die personenund tagspezifischen Bookmarks, die in dem
jeweiligen Bookmarklog dargestellt werden, abonnieren.
Des Weiteren kann jeder Anwender - wie schon erwähnt - Feeds für seinen Bookmarklog
anbieten. Diese enthalten die Bookmarks, die in den jeweiligen Bookmarklogs dargestellt
werden. Somit können ebenfalls personenspezifische oder tagund personenspezifische
Bookmarks durch Feeds exportiert werden.
Abb. 14: Der Bookmarklog (Abbildung: Eigene Darstellung)
39
4.2.4
Öffentliche Schicht der Erweiterung
Die öffentliche Schicht der Erweiterung stellt alle Bookmarks des Systems dar und fungiert
somit als eine Bookmarksammlung des Infoasset Brokers, in der sowohl angemeldete als
auch anonyme Anwender nach interessanten Bookmarks suchen können.
Angemeldete Anwender, die einen Bookmarkaccount haben, können Bookmarks aus dieser
Schicht in ihren eigenen Account kopieren und ihre Bookmarks in dem Bookmarklog, der im
letzten Kapitel vorgestellt wurde, veröffentlichen. Dadurch wird dem „sozialen Aspekt“ eines
solchen Systems Rechnung getragen.
Die Startseite (siehe Abb. 15) der öffentlichen Schicht enthält alle Bookmarks, die erst
kürzlich in das System einfügt worden sind. Somit können sich die Anwender auf einen Blick
informieren, ob neue Bookmarks eingefügt worden sind oder ob sich der Bookmarkbestand
der Erweiterung seit dem letzten Aufruf dieser Seite nicht geändert hat. Dies erleichtert es
den Anwendern, einen Überblick über den aktuellen Bookmarkbestand des Systems auch
über einen längeren Zeitraum hinweg zu wahren. Außerdem werden auf der Startseite die
Tags, die von vielen Anwendern der Erweiterung genutzt werden (populäre Tags), angezeigt.
Durch die Angabe der populären Tags wird ersichtlich, zu welchen Themen sich gerade viele
Bookmarks in der Erweiterung befinden und für welche Themen sich die Anwender momentan interessieren.
Die populären Tags verweisen jeweils auf die tagspezifischen Seiten der öffentlichen Übersicht. Analog zu den tagspezifischen Seiten des Bookmarkaccounts werden auf diesen Seiten
die mit den gewählten Tags verwandten Tags ausgegeben. Außerdem bieten die tagspezifischen Seiten eine Funktion an, mit welcher die Bookmarks dieser Seite abonniert werden
können (tagspezifisches Abonnement).
Um auf eine bestimmte tagspezifische Seite zugreifen zu können, bietet die Erweiterung neben der Liste der populären Tags - noch zwei weitere Möglichkeiten an. Einerseits kann
über eine Freitextsuche nach tagspezifischen Seiten gesucht und andererseits direkt über
eine bestimmte URL auf eine tagspezifische Seite zugegriffen werden.
Mit dieser URL können die tagspezifischen Seiten geladen werden, ohne dass die komplette
Oberfläche des Infoasset Brokers geladen werden muss und sich die Anwender dann bis zu
der entsprechenden Seite „durchklicken“ müssen. Dadurch wird ein effizienter Zugriff auf
die tagspezifischen Bookmarks ermöglicht.
40
Abb. 15: Die Startseite der öffentlichen Schicht der Erweiterung (Quelle: eigene Darstellung)
Neben den internen Bookmarks werden in der öffentlichen Schicht auch die externen Bookmarks des social bookmarking Anbieters Del.icio.us dargestellt, der die Bookmarks auf die
gleiche Weise wie die social bookmarking Erweiterung des Infoasset Brokers verwaltet und
kategorisiert. Aus diesem Grund können die externen Bookmarks, die über ein RSS-Feed in
die Erweiterung importiert werden, auf die gleiche Weise wie die internen Bookmarks innerhalb der Erweiterung dargestellt werden, wodurch die Einheitlichkeit der Benutzoberfläche
auch in dieser Übersicht gewahrt bleibt.
Der Vorteil der Integration externer Bookmarks ist, dass die Anwender bereits in der Einführungsphase der Erweiterung, wenn erst wenige Bookmarks direkt in diese eingefügt worden
sind, auf einen sehr großen Datensatz von externen Bookmarks zugreifen können. Des Weiteren können die Anwender, die einen Account bei Del.icio.us haben, auf die Bookmarks dieses Accounts zugreifen (personenspezifische Bookmarks) ohne die Umgebung des Infoasset
Brokers verlassen zu müssen.
Neben den Übersichten über Bookmarks, stellt die öffentliche Schicht einen Index bereit,
über den die Anwender auf alle Bookmarklogs des Infoasset Brokers zugreifen können. Dieser Index enthält neben den Titeln und den Namen der Eigentümer auch die Aktualisierungsdaten der verschiedenen Bookmarklogs. Dadurch können die Anwender auf einen Blick erkennen, welche Bookmarklogs neue Informationen enthalten und welche nicht mehr gepflegt
werden.
41
4.2.5 Erweiterung der Struktur des Infoasset Brokers
Es gibt drei grundlegende strukturelle Erweiterungen des Infoasset Brokers, die in diesem
Kapitel vorgestellt werden:
•
Erweiterung der Startseite
•
Einfügen eines Bookmarklets
•
Einfügen eines „Kommentarbuttons“
Die Startseite des Infoasset Brokers enthält aktuelle Informationen über dessen Systemzustand. Beispiele dafür sind Dokumente oder Nachrichten, die erst kürzlich in den Infoasset
Broker eingefügt wurden. Folglich kann sich der Anwender auf dieser Seite einen kurzen
Überblick über aktuelle Änderungen des Infoasset Brokers verschaffen. Zusätzlich sind alle
Nachrichten mit ihrer ursprünglichen „Quelle“ verlinkt, so dass der Anwender direkt auf diese zugreifen kann, um so detaillierte Informationen über die verschiedenen Kurznachrichten
zu erhalten.
Um die social bookmarking Erweiterung ebenfalls mit der Startseite zu verknüpfen, werden
auf dieser zum einen die zehn aktuellsten Bookmarks und zum anderen die zehn populärsten
Tags ausgegeben. Die Darstellung der Bookmarks ist dabei wesentlich kompakter als die der
social bookmarking Erweiterung (siehe Kapitel 4.2.1). Die kompakte Darstellung enthält
lediglich den Titel, der auf die Ressource des Bookmarks verweist, den Namen des Bookmarkeigentümers, der auf dessen Bookmarklog verweist, und das Einfügedatum des Bookmarks.
Die zehn populärsten Tags werden in absteigender Reihenfolge angezeigt und verweisen auf
die jeweiligen Seiten der öffentlichen Schicht der Erweiterung. Die unterschiedliche Popularität der verschiedenen Tags innerhalb dieser Liste wird anhand der Schriftgröße, mit der
diese dargestellt werden, visualisiert.
Neben den Änderungen an der Nachrichtenseite wird ein Bookmarklet in den Infoasset Broker eingefügt, mit dem die Anwender für jede beliebige Entität des Infoasset Brokers einen
Bookmark definieren können.
Wenn ein Anwender die Seite, auf der er sich gerade befindet, speichern will, muss dieser das
Bookmarklet „anklicken“. Dadurch wird das Einfügeformular, dessen URL-Eingabefeld mit
der URL der Ressource, die gespeichert werden soll, vorbelegt ist, seines Bookmarkaccounts
42
geöffnet. In diesem Formular kann der Anwender einen Bookmark für die Entität definieren
und diesen anschließend speichern.
Schließlich wird noch ein „Kommentarbutton“ zum Infoasset Broker hinzugefügt, mit dem
jeder Anwender Kommentare zu jeder Entität des Systems aufrufen kann. In diesem Fall sind
die Kommentare einer Entität die Beschreibungen der Bookmarks, die für diese Entität definiert wurden.
Nachdem in diesem Kapitel das Modell der Erweiterung beschrieben und dessen Umsetzung
erläutert wurde, wird im nächsten Kapitel die konkrete Implementierung dieser Erweiterung
vorgestellt.
43
5
Implementierung der Erweiterung
Dieses Kapitel befasst sich mit der Implementierung der Erweiterung. In Abschnitt 5.1 dieses
Kapitels werden die Datenstrukturen, mit denen die Objekte des Modells realisiert wurden,
vorgestellt. Darauf aufbauend wird die konkrete Implementierung der verschiedenen Schichten der Erweiterung und somit die konkrete Umsetzung des Modells dargestellt. Dabei wird
vor allem auf die besonderen Algorithmen und die Eigenschaften der Implementierung eingegangen.
5.1
Datenstrukturen der Erweiterung
Für die Realisierung der Erweiterung mussten sowohl bestehende Datenstrukturen, die im
folgenden Asset genannt werden, erweitert als auch neue Datenstrukturen zu der Anwendung
hinzugefügt werden. Die Definition der Datenstrukturen erfolgt in Services, die jeweils aus
zwei Interfaces und aus zwei konkreten Klassen, die die Funktionalitäten der Interfaces implementieren, bestehen. In einem Interface werden sowohl die „Properties“ und die „AssociationSchemas“ des Assets definiert als auch die Methodensignaturen der Funktionen, in denen
beispielsweise Queries (siehe Kap. 3.1.2) für die Abfrage von Assetinstanzen realisiert werden können, deklariert. In dem anderen Interface werden dagegen die get- bzw. set-Methoden
und weitere Methoden zur Manipulation von jeweils einer Instanz eines Assettyps definiert.
Die verschiedenen Interfacemethoden werden, wie am Anfang des Abschnittes erwähnt, in
konkreten Klassen implementiert. Über die Interfaces können die Handler, in denen die fachliche Logik der Erweiterung implementiert wird, auf die Eigenschaften und die Methoden der
Assets zugreifen.
Im Folgenden werden die Datenstrukturen beschrieben, mit denen die Objekte des Modells
(siehe Abb. 11) innerhalb des Infoasset Brokers dargestellt werden.
5.1.1 Das Asset „Weblog“
Wie schon im Kapitel 4.1 erläutert wurde, basiert die social bookmarking Erweiterung auf
dem Assettyp „Weblog“. Dieses Asset verknüpft die Bookmarks, die in diese Anwendung
eingefügt werden, mit deren Eigentümer und ist somit die physische Darstellung des Modellobjekts „Bookmarklog“. Da dieser Assettyp nicht nur für die Realisierung der social bookmarking Erweiterung, sondern auch für die Weblog Erweiterung des Infoasset Broker ver-
44
wendet wird, hat dieser sowohl Eigenschaften, die von der social bookmarking Erweiterung
genutzt werden, als auch Eigenschaften, welche für die Erweiterung nicht relevant sind. Um
für eine Instanz dieses Assettyps feststellen zu können, ob sie einen Weblog oder einen
Bookmarklog darstellt, wurde die Eigenschaft „isBookmarklog“ definiert. Dieser Eigenschaft
wird der numerische Wert „1“ zugeordnet, wenn es sich bei der Instanz um einen Bookmarklog handelt, ansonsten hat sie den Wert „0“. Des Weiteren sind folgende Eigenschaften
des Asset für die Realisierung der Erweiterung von Bedeutung.
•
Description
•
Exportfeeds
•
ExportToDelicious
•
Lastpublished
•
Owner
•
WeblogTitle
•
lastpublished
Der WeblogTitle ordnet dem Bookmarklog einen Titel zu, der von dem jeweiligen Eigentümer, dessen eindeutige ID in der Eigenschaft „Owner“ gespeichert wird, frei gewählt werden
darf. Des Weiteren kann dem Bookmarklog ein kurzer Kommentar („Description“) hinzugefügt werden, in dem beispielsweise beschrieben werden kann, welche Art von Bookmarks in
dem Bookmarklog gesammelt werden.
Sobald ein Bookmark in den Bookmarklog eingefügt oder bearbeit wird, wird das Aktualisierungsdatum des Bookmarkslogs, welches in der Eigenschaft „lastpublished“ gespeichert
wird, aktualisiert.
Die Eigenschaft „ExportToDelicious“ und die „exportfeeds“-Eigenschaften (ExportRss1.0,
ExportRss0.3, ExportAtom0.3, ExportAtom1.0) enthalten die Exporteinstellungen des
Bookmarklogs. In der Eigenschaft „ExportsToDelicious“ wird gespeichert, ob der Eigentümer des jeweiligen Bookmarklogs die „Exportfunktion“ seines Bookmarkaccount aktiviert
hat oder nicht. Die „exportfeeds“-Eigenschaften geben dagegen an, welche Feeds von dem
jeweiligen Bookmarklog angeboten werden soll. Die restlichen Eigenschaften des Assettyps
„Weblog“ haben für Bookmarklogs keine Relevanz.
5.1.2 Das Asset „BookmarkEntry“
In diesem Assettyp werden die Bookmarks, die in die Erweiterung eingefügt werden, gespeichert. Da jeder Bookmark genau einer Person und einem Bookmarklog zugeordnet werden
kann, steht der Assettyp mit den Assets „Person“ und „Weblog“ jeweils in einer „1 zu N“
Beziehung („OneToMany- Association“). Daneben existiert eine „N zu M“ Beziehung
45
(„ManytoMany Association“) zwischen Bookmarks und Tags, da sowohl mehrere Bookmarks einem Tag als auch mehrere Tags einem Bookmark zugeordnet werden können. Neben diesen Beziehungen wurden für das Asset folgende Eigenschaften definiert:
•
Title
•
URL
•
Published
•
View
•
Description
In diesen Eigenschaften werden die in Kapitel 4.2.2 erläuterten Attribute eines Bookmarks
gespeichert. Die Eigenschaften „Title“, „URL“ und „Description“ speichern die Titel, die
URLs und die Beschreibungen der Bookmarks, die Eigenschaft „Published“ das Einfügedatum und „view“ die Sichtbarkeit des Bookmarks. Wird der zuletzt genannten Eigenschaft der
Wert „1“ zugeordnet, so bedeutet dies, dass der Bookmark „privat“ ist, ansonsten wird dieser
der Defaultwert „0“ zugeordnet. Da alle Eigenschaften der Bookmarks von den Anwendern
frei gewählt werden dürfen, kann jeder Bookmark nur durch die vom System automatisch
generierte ID eindeutig identifiziert werden.
5.1.3 Das Asset „Tag“
Tags sind Schlüsselwörter, die den Bookmarks verschiedene Themen zuordnen. Da einem
Bookmark mehrere Tags zugeordnet werden können, ist der Assettyp, wie schon im vorherigen Abschnitt beschrieben, mit dem Assettyp „BookmarksEntry“ über eine „ManyToManyAssociation“ verknüpft. Daneben besteht noch eine 1 zu N Beziehung zwischen Tag und Person, mit der jeder Tag eindeutig einer Person zugeordnet werden kann. Das Thema, das die
Tags darstellen (=Tagthema), werden in der Eigenschaft „Value“ gespeichert.
Bei der Implementierung der Erweiterung wurde zwischen zwei Arten des Zugriffes auf tagspezifische Bookmarks unterschieden. Wenn alle Bookmarks einer Person, die einem Tag
zugeordnet wurden, ermittelt werden sollen, können über eine Query alle Bookmarks abgefragt werden, die genau einem Tag-Objekt zugeordnet sind, da jedes Tag-Objekt personenspezifisch ist. Sollen jedoch die Bookmarks aller Personen, die mit einem bestimmten Tagthema verknüpft sind, ermittelt werden, so müssen zuerst alle Instanzen des Asset „Tag“,
denen dieses Tagthema zugeordnet ist, abgefragt werden und dann für jede dieser Instanzen
die entsprechenden Bookmarks ermittelt werden.
46
Die direkte Verknüpfung zwischen den Objekten „Tag“ und „Person“ hat den Vorteil, dass
die Verbindung zwischen diesen beiden Assets nachvollziehbar bleibt und somit das personspezifische und konsistente Umbenennen von Tags möglich ist.
5.1.4 Das Asset „Bsubscription“
In diesem Assettyp werden die verschiedenen Abonnements der Anwender der social bookmarking Erweiterung gespeichert. Wie schon erwähnt wurde, gibt es drei Abonnementtypen:
die personenspezifischen-, die tagspezifischen- und die tagund personenspezifischen Abonnements. Der Abonnementtyp wird in der Eigenschaft „Typ“ gespeichert, welcher folgende
numerischen Werte zugeordnet werden können:
Wert der Eigenschaft „Typ“: Bedeutung
0
tagspezifisches Abonnement
1
personenspezifisches Abonnement
2
Tag- und personenspezifisches Abonnement
Tab. 2: Wertebereich der Eigenschaft "Typ"( Quelle: eigene Darstellung )
Die Eigenschaft „Subscription“ speichert das tatsächliche Abonnement. In diese Eigenschaft
wird, wenn es sich um ein personenspezifisches Abonnement handelt, die ID der Person, deren Bookmarks abonniert wurden, eingefügt. Bei einem tagspezifischen Abonnement wird in
dieser Eigenschaft das Tagthema gespeichert. Wenn schließlich ein personenund tagspezifischen Abonnement erzeugt werden soll, wird die ID der Instanz des abonnierten Tags der
Eigenschaft zugeordnet, da diese Instanz den abonnierten Tagwert mit einer bestimmten Person verknüpft (siehe Kap. 5.1.3).
In den Eigenschaften „Lastsession“ und „Currentsession“ werden die Daten des letzten bzw.
der gegenwärtigen Zugriffes auf die Inbox des jeweiligen Anwenders gespeichert. Diese zwei
Daten wurden für die Implementierung des Algorithmus, welcher die tägliche Aktualisierung
der Inbox ermöglicht, genutzt. (siehe Kap. 5.2.3).
Nach der Vorstellung der Datenstrukturen, auf welchen die Objekte des Modells der Erweiterung abgebildet werden, wird in den folgenden Kapiteln die konkrete Implementierung des
Modells erläutert.
47
5.2
Implementierung des Bookmarkaccounts der Erweiterung
Jeder Anwender der social bookmarking Erweiterung kann in seinem persönlichen Bookmark- account neue Bookmarks definieren und diese verwalten. Dafür wurden verschiedene
Funktionalitäten, die im Folgenden vorgestellt werden, realisiert.
5.2.1
Bookmarks einfügen
Die Anwender können mit der Funktion „neuer Eintrag“ Bookmarks in ihren Bookmarkaccount einfügen. Diese Funktion wurde mit einem Webformular realisiert, in das die Anwender die Eigenschaften des Bookmarks, den sie einfügen wollen, eingeben können. Die Eigenschaften Titel, URL und die Tags des Bookmarks können in Textfelder eingegeben werden
und für die Beschreibung des Bookmarks wurde eine „Textarea“, also ein mehrzeiliges Textfeld, in das auch längere Texte eingefügt werden können, definiert. Des Weiteren enthält das
Webformular zwei Radiobuttons, mit denen der Anwender festlegen kann, ob der Bookmark,
der eingefügt werden soll, öffentlich oder privat sein soll.
Mit dem Eingabefeld, in das die Tags eingefügt werden, wurde eine AJAX-basierte Suggestionsfunktion, die im folgenden Abschnitt erläutert wird, verknüpft.
5.2.1.1 Suggestionsfunktion
Die Suggestionsfunktion erkennt den Text, der von den Anwendern in das Textfeld, welches
mit dieser Funktion verknüpft ist, eingegeben wird, und gibt dementsprechend eine Liste mit
Vorschlägen für die Fertigstellung des Textes aus. Der Anwender kann aus dieser Liste nun
einen Vorschlag auswählen, der daraufhin automatisch in das Textfeld eingefügt wird.
Durch die Realisierung einer Suggestionsfunktion für das Tag-Eingabefeld, kann der Anwender bei der Eingabe der Tags direkt sehen, welche Tags schon von den anderen Anwendern definiert wurden und diese für die Kategorisierung seines Bookmarks verwenden. Diese
Funktion gibt den Anwendern somit einen Anreiz, bestehende Tags wieder zu verwenden,
wodurch die Kategorisierung ähnlicher Bookmarks homogener wird. Außerdem können
durch die „Suggestionfunktion“ Texte schneller eingegeben werden, da lediglich die ersten
Buchstaben eines Begriffes eingegeben werden müssen und dieser schließlich durch die Auswahl des entsprechenden Vorschlages automatisch fertig gestellt wird. Die folgende Abbildung stellt eine „Suggestionfunktion“ dar:
48
Abb. 16: Die "Suggestionsfunktion" ( Quelle: eigene Darstellung )
Das Textfeld (Suggestionsfeld), das mit der Suggestionsfunktion verknüpft ist, löst, sobald
dieses aktiviert wird, einen Event aus (Event: onfocus), wodurch ein Javascript ausgeführt
wird, das die „Suggestionfunktion“ für dieses Textfeld initialisiert. Bei der Initialisierung
werden die verschiedenen Eventhandler erzeugt, die ausgeführt werden, sobald jemand ein
Zeichen in das Suggestionsfeld eingibt. Die folgende Tabelle gibt die Zuordnung der Eventhandler zu den verschiedenen Zeichen (Tasten) wieder:
Taste
Bedeutung
Zeichentasten (a…z, 1….10)
Keydown (Keycode=38)
Neue Vorschläge werden ausgegeben
Die Markierung der Vorschläge („oranger
Balken“, siehe Abb. 16) wird nach unten
verschoben.
Die Markierung der Vorschläge wird nach
oben verschoben.
Der markierte Vorschlag wird in das Suggestionsfeld eingefügt
Die Vorschlagsliste wird ausgeblendet
KeyUp (Keycode=40)
Tab (Keycode=9)
Esc (Keydode= 27)
Tab. 3: Die Events der Suggestionsfunktion ( Quelle: eigene Darstellung)
Wie dieser Tabelle zu entnehmen ist, wird durch das Drücken einer „Zeichentaste“ ein Event
ausgelöst, welches die Generierung einer Vorschlagsliste anstößt. Bei dieser Generierung
wird im ersten Schritt die Zeichenkette aus dem Suggestionsfeld ausgelesen und aus dieser
durch die Funktion „Split()“ deren letztes „Wort“, für das die Vorschläge ausgegeben werden
sollen, extrahiert. Dieses „Wort“ wird nun durch einen XMLHttpRequest an einen Handler
übertragen.
Der Handler erzeugt nun ein Dokument, welches die Tags, die als Vorschläge für die Ergänzung des übermittelten Worts ausgegeben werden sollen, enthält. Die entsprechenden Tags
werden durch die Funktion „suggesttags()“ ermittelt, in der folgende zwei Queries ausgeführt werden:
49
QueryBegins(container, asValue ,wort.trim().toLowerCase());
QueryBegins(container, asValue ,wort.trim().toUpperCase());
Abb. 17: Query: Abfrage der Vorschläge ( Quelle: eigene Darstellung )
Diese Queries fragen die Tags ab, deren Tagwerte mit dem vom Javascript übergebenen Teilwort beginnen. Damit die Vorschläge unabhängig von der Groß- und Kleinschreibung des
übergebenen Teilwortes durch die Funktion „suggesttags()“ermittelt werden können,
werden
einerseits
die
Tags,
die
mit
dem
kleingeschriebenen
Teilwort
(wort.trim().toLowerCase()) beginnen und andererseits die Tags, die mit dem groß-
geschriebenen Teilwort (wort.trim().toUpperCase()) beginnen, durch die Queries
abgefragt. Nachdem die Queries ausgeführt wurden, gibt die Funktion „suggesttags()“
die abgefragten Tags zurück. Diese werden nun von dem Handler durch eine Listsubstitution in das Antwortdokument eingebettet. Am Ende dieser Substitution liegen die ver-
schiedenen Tags, jeweils durch Strichpunkte getrennt, in diesem Dokument vor. Über das
„responseText“-Objekt kann nun das Dokument an das Javascript, welches den
XMLHttpRequest initialisiert hat, übermittelt und von diesen verarbeitet werden. Das Javascript extrahiert die einzelnen Tags aus dem Antwortdokument und fügt diese in eine „Aufzählungsliste“ ein, die schließlich unterhalb des „Suggestionsfeld“ in das HTML-Dokument eingebettet wird. Die Einbettung erfolgt dadurch, dass ein Platzhalter, der sich im Quelltext des
Einfügeformulars unterhalb des „Suggestionsfeld“ befindet, durch die Aufzählungsliste ersetzt wird.
Die Anwender können nun mittels der Funktionstasten „Keyup“ und „Keydown“ durch die
angezeigte Vorschlagliste navigieren und mit der Tabulatortaste einen Vorschlag auswählen,
der schließlich in das Suggestionsfeld eingefügt wird. Die Auswahlbestätigung wurde mit der
„Tab-Taste“ anstatt der „Enter-Taste“ verknüpft, da diese schon für das Abschicken des
Formulars verwendet wird.
5.2.1.2 Verarbeitung der Formulareingaben
Nachdem der Anwender den Bookmark definiert und das Formular abgeschickt hat, werden
die Benutzereingaben durch einen Handler verarbeitet. Am Anfang dieser Verarbeitung wird
überprüft, ob alle Textfelder ausgefüllt wurden. Dies erfolgt durch einen einfachen Stringvergleich7 mit einer leeren Zeichenkette. Wurde ein Textfeld nicht ausgefüllt, wird die Ver-
7
Funktion : „CompareTo()“
50
arbeitung der Eingaben abgebrochen und eine Fehlermeldung ausgegeben. Sind dagegen alle
Eingaben korrekt, wird mit Hilfe der folgenden Funktion (siehe Abb. 18) die Gültigkeit der
URL überprüft:
public boolean isValid(String URL) {
isValid=false;
try{URL url = new URL(URL);
HttpURLConnection conn = (HttpURLConnection)
url.openConnection();
conn.setRequestMethod("HEAD");
conn.setUseCaches(false);
if (conn.getResponseCode() == HttpURLConnection.HTTP_OK)
{isValid=true;
return isValid;}
else { return isValid;}}
Catch(Exception e){
return isValid;} }
Abb. 18: Hilfsfunktion: „isValid“ ( Quelle: eigene Darstellung )
Diese Hilfsfunktion versucht eine HTTP-Verbindung zu der Ressource, auf welche die URL,
die an diese Funktion übergeben wird, verweist, aufzubauen und den „Header“ dieser Ressource zu laden. Konnte eine Verbindung zu dieser Ressource aufgebaut werden, wird der
Responsecode „200“ der Funktion übergeben. Wenn dies der Fall ist, gibt die Funktion „isValid“ den bool´schen Wert „True“ zurück und ein Bookmarkeintrag mit den eingegebenen
Eigenschaften kann erstellt werden. Ansonsten wird die Verarbeitung der Formulardaten abgebrochen und eine Fehlermeldung ausgegeben.
Bei der Erstellung eines Bookmarkeintrags wird eine neue Instanz des Assettyps „BookmarkEntry“ erzeugt. Diesem werden sowohl die eingegebenen Eigenschaften als auch die Eigenschaften „Einfügedatum“ und „Eigentümer“, die automatisch durch das System erzeugt werden, zugeordnet. Um aber eine einwandfreie Darstellung der Bookmarks im Infoasset Broker
zu gewährleisten, werden die deutschen Umlaute in den eingegebenen Eigenschaften, bevor
sie dem neuen Bookmarkeintrag zugeordnet werden, durch die Funktion „ConvertToHTML“
umgewandelt..
51
public String convertToHTML(String property)
int length = property.length();
StringBuilder b = new StringBuilder(length);
for (int i = 0; i < length; i++) {
char c =zk.charAt(i);
if (c == 'ö') {b.append("oe");}
else if (c == 'ä') {b.append("ae");}
else if (c == 'ü') {b.append("ue");}
else if (c == 'Ä') {b.append("Ae");}
else if (c == 'Ü') {b.append("Ue");}
else if (c == 'Ö') {b.append("Oe");}
else {b.append(c);}}
String ns=b.toString();
return ns;}
Abb. 19: Hilfsfunktion: "convertToHTML“ ( Quelle: eigene Darstellung )
Die abgebildete Funktion konvertiert mit Hilfe eines „StringBuilders“ die Zeichenkette,
welche an die Funktion übergeben wird, in eine neue Zeichenkette. Bei der Konvertierung
wird jedes Element der „originalen“ Zeichenkette überprüft, ob es ein Umlaut ist. Ist dies der
Fall, so wird der neuen Zeichenkette der umgewandelte Umlaut, also z. B. statt ein „ä“ ein
„ae“, hinzugefügt. Ansonsten wird der neuen Zeichenkette das „originale“ Element zugeordnet. Nachdem alle Elemente in die neue Zeichenkette eingefügt und somit alle Umlaute umgewandelt wurden, wird diese von der Hilfsfunktion zurückgegeben.
Neben den Eigenschaften, die dem Bookmarkeintrag direkt zugeordnet werden können, müssen noch die Tags, die in getrennten Assets gespeichert werden (siehe Kap. 5.1.3 ), mit dem
Bookmarkeintrag verknüpft werden. Dabei muss für jeden eingegebenen Tag entweder ein
neues Asset erstellt und dieser mit dem Bookmarkeintrag verknüpft werden oder, falls ein
Asset für diesen schon existiert, nur eine Beziehung zwischen diesem und dem Bookmarkeintrag definiert werden.
Um die Tags, die in einer Zeichenkette an die fachliche Logik übergeben werden, einzeln
verarbeiten zu können, muss diese Zeichenkette durch die Funktion „Split“ aufgespaltet werden. Diese Funktion spaltet die Zeichenkette jeweils bei den Leerzeichen, welche die Tags
innerhalb der Zeichenkette voneinander trennen, auf und fügt deren Teilelemente in ein Array ein. Über das Array kann nun der Handler auf die einzelnen Tags zugreifen und diese auf
die im vorigen Abschnitt beschriebene Art dem Bookmarkeintrag zuordnen.
Nachdem der Bookmark erzeugt und mit den Tags verknüpft wurde, muss noch die Funktion
„commit()“ ausgeführt werden, die das Datum der letzten Änderung des Bookmarklogs, mit
dem das eingefügte Bookmark verknüpft ist, aktualisiert. Schließlich wird noch eine Bestäti-
52
gungsmeldung ausgegeben, die dem Anwender mitteilt, dass der Bookmark erfolgreich eingefügt wurde.
5.2.2 Übersichtsseite des Bookmarkaccounts
Auf der Übersichtsseite des Bookmarkaccounts werden sowohl die privaten als auch die öffentlichen Bookmarks des jeweiligen Eigentümers ausgegeben. Neben der reinen Darstellung
der Bookmarks werden auf dieser Seite Funktionen zur Bearbeitung, zum Löschen und zum
Export der Bookmarks angeboten. Die Bearbeitungsfunktion, auf die später näher eingegangen wird, wurde auf der Basis von AJAX realisiert. Durch die asynchrone Client-Server
Kommunikation, die durch AJAX ermöglicht wird, können Bookmarks bearbeitet werden,
ohne dass, nachdem das entsprechende Bearbeitungsformular abgeschickt wurde, die
komplette Übersichtsseite neu geladen werden muss. Doch der zentrale Aspekt bei Realisierung dieser Übersichtsseite war es, die Darstellung der Bookmarks effektiv umzusetzen.
Diese wurde daher so realisiert, dass darauf höchstens 10 Bookmarks gleichzeitig angezeigt
werden. Sollen dennoch mehr als 10 Bookmarks auf der Übersichtseite dargestellt werden,
werden Indexseiten generiert, die jeweils 10 Bookmarks enthalten und durch einen Index
miteinander verknüpft werden. Über diesen Index können die Anwender auf die verschiedenen Indexseiten zugreifen.
5.2.2.1
Generierung der Übersichtsseite
Auf der Übersichtsseite werden entweder alle Bookmarks des Anwenders oder dessen tagspezifischen Bookmarks chronologisch sortiert angezeigt. Welche Bookmarks auf dieser Seite ausgegeben werden, hängt von den Requestparametern ab, die an den Handler, der diese
Seite generiert, übergeben werden. Wird nur Bookmarklogid übergeben, werden alle Bookmarks des Anwenders dargestellt, ansonsten werden, wenn neben der Bookmarklogid auch
eine TagId übergeben wird, nur die tagspezifischen Bookmarks in der Übersicht angezeigt. In
Abhängigkeit dieser Requestparameter können durch die Funktionen „getallBookmarksOfWeblog()“ oder „getAllbookmarksofaTag()“ die entsprechenden Bookmarks er-
mittelt werden.
In der Funktion „getallBookmarksofWeblog()“ wurde eine Query realisiert, die alle
Instanzen des Assettyps „BookmarkEntry“, die mit einem bestimmten Bookmarklog verknüpft sind, abfragt. Da die Query die Bookmarks sortiert nach dem Einfügedatum zurück-
53
geben soll, wurde dieser ein „QuerySortingCriterion“ zugeordnet, welches die entsprechende Sortierung festlegt. Nach Ausführung der Query werden Bookmarks, die dem Anfrageprädikat entsprechen, von der Funktion „getallBookmarksofWeblog()“ in einen Iterator zurückgegeben.
Die Implementierung der Funktion „getAllbookmarksofaTag()“, welche die tagspezifischen Bookmarks einer Person zurückgibt, basiert nicht auf einer Query, da die Tags keine
direkten Eigenschaften von Bookmarks sind, sondern über eine „n zu M“ Beziehung mit diesen verknüpft sind. Aus diesem Grund muss für die Abfrage von tagspezifischen Bookmarks
die Funktion „getAssociatedAssets()“ verwendet werden. Diese Funktion ermittelt
alle Instanzen eines Assets, die mit einer bestimmten Instanz eines anderen Assets assoziiert
sind und gibt diese in einen Iterator zurück. In diesem Fall können somit durch diese Funktion die Bookmarks, die mit einem bestimmten Tag verknüpft sind, ausgelesen werden. Die
ausgelesenen Bookmarks werden schließlich durch die Funktion „getAllbookmarksofTag()“, in einen Iterator zurückgegeben.
Da die beiden vorgestellten Funktionen die ermittelten Bookmarks jeweils in einen Iterator
zurückgeben, können die Bookmarks, unabhängig von welcher Funktion diese ermittelt wurden, auf die gleiche Art und Weise durch den Handler verarbeitet werden.
Nachdem die Bookmarks abgefragt wurden, muss deren Anzahl ermittelt werden, damit festgestellt werden kann, ob alle Bookmarks auf einer Seite dargestellt werden können oder die
Übersichtsseite in mehrere Indexseiten untergliedert werden muss. Wenn Indexseiten erzeugt
werden müssen, werden mit der Funktion „getpage“ diejenigen Bookmarks ausgewählt, die
auf der aktuellen Indexseite ausgegeben werden sollen. Welche Bookmarks ausgewählt werden, hängt von der Indexnummer ab, die an den Handler, der die Indexseite erstellt, übertragen wurde. In der folgenden Abbildung wird die Funktion „getpage()“ dargestellt, der die
Indexnummer und der Iterator mit den Bookmarks, die durch die Funktion „getAllbookmarksofaTag()“ oder „getallBookmarksOfWeblog()“ ermittelt wurden, übergeben
wird.
public Iterator getpage(int Indexnummer, Iterator Bookmarks){
if (Indexnummer >10){
for(int w=0;w< Indexnummer-10;w++){
Bookmarks.next();}}
Vektor v=new Vektor();
int step=0;
while(step<10 && Bookmarks.hasNext()){
v.add((BookmarkEntry) Bookmarks.next());
step=step+1;}}
return v.Iterator();
}
Abb. 20: Die Funktion "getpage"( Quelle: eigene Darstellung )
54
Die abgebildete Funktion legt in Abhängigkeit von der Indexnummer I das Intervall [ I-10: I]
innerhalb des Iterators fest, aus dem diejenigen Bookmarks ausgelesen werden, die auf der
aktuellen Indexseite angezeigt werden sollen. Da der Iterator keine Funktion anbietet, mit der
auf eine bestimmte Indexposition innerhalb des Iterators zugegriffen werden kann, muss solange die Iteratorfunktion „next()“ aufgerufen werden, bis der Pointer des Iterators auf die
untere Grenze (I-10) des Intervalls I zeigt (siehe Abb. 17/ „if 1“). Danach können iterativ die
folgenden zehn Bookmarks aus dem Iterator ausgelesen werden und in einen Vektor eingefügt werden.
Falls aber die letzte Indexseite der Übersicht generiert wird und somit die letzten Bookmarks
des Iterators abgefragt werden sollen, kann es sein, dass sich in diesem Intervall weniger als
zehn Bookmarks befinden. Um dies zu überprüfen, wurde der Bedingung der While-Schleife,
in der die Bookmarks iterativ ausgelesen werden, die Funktion „hasNext()“ des Iterators
hinzugefügt. Die Funktion „hasNext()“ bricht die While-Schleife ab, sobald kein Element
mehr aus dem Iterator ausgelesen werden kann.
Nachdem alle Bookmarks des Intervalls I in den Vektor eingefügt worden sind, wird dieser in
einen Iterator, der von der Funktion „getpage()“ schließlich zurückgegeben wird, umgewandelt. Nach Ausführung dieser Funktion befinden sich somit die 10 Bookmarks, die in der
aktuellen Indexseite der Übersicht dargestellt werden sollen, in einem Iterator.
Des Weiteren muss für die Indexseite ein Index, der diese mit den anderen Indexseiten verknüpft, erzeugt werden. Über den Index können die Anwender durch das „Anklicken“ der
Seitenzahlen, die als Links dargestellt werden, zu den verschiedenen Indexseiten der Übersicht gelangen. Den Links wird zum einem die blogid (bzw. tagid) zugeordnet, mit der die
Bookmarks, die in der Übersicht dargestellt werden sollen, abgefragt werden können. Zum
anderem wird den Links die Indexnummer I zugeordnet, mit der die Teilmenge der Bookmarks, welche die jeweilige Indexseite ausgeben soll, bestimmt werden kann.
Die im folgendem dargestellte Funktion erzeugt den Index:
55
public void createIndex(int numberofbookmarks){
index+="Seite: ";
int i=numberofbookmarks;
int se=10;
while(i>0){
if(se==<current index>
index+=se/10+" ";}
else{
index+="<ahref='AdministrationView.htm?
blogid="+blogid+"&tag="tagid"&seite="seite"
class='txtlink11'>"+se/10+"</a> ";}
se=se+10;
i=i-10; }
}
Abb. 21: Die Funktion "createIndex" ( Quelle: eigene Darstellung )
Die Funktion „createIndex(int numberofbookmarks)“ erstellt den Index, indem sie
iterativ jeweils eine neue Seitenzahl zu diesem hinzufügt, bis keine weitere Seitenzahl dem
Index zugeordnet werden muss. Dies ist der Fall, wenn für jede Indexseite, die benötigt wird,
um die Bookmarks in der Übersicht dazustellen, sich eine entsprechende Seitenzahl in dem
Index befindet.
Diese Funktionalität wird realisiert, indem in einer While-Schleife von der Gesamtzahl der
Bookmarks iterativ jeweils 10, also die Anzahl der Bookmarks, die höchstens auf einer Indexseite dargestellt werden, subtrahiert wird. Bei jeder dieser Iterationen wird eine neue Seitenzahl zu dem Index hinzugefügt, bis das Ergebnis der Subtraktion kleiner oder gleich Null
ist und somit die Iteration abgebrochen wird. Wenn dabei die Seitenzahl der aktuellen Indexseite in den Index eingefügt werden soll, wird diese im Gegensatz zu den anderen Elementen
des Indexes nicht als Link dargestellt. Somit hat diese Seitenzahl eine andere Formatierung
als die restlichen Seitenzahlen, wodurch der Anwender sofort sehen kann, auf welcher Indexseite er sich befindet. Nachdem der Index generiert und von der Funktion „createIndex()“ in einen String zurückgegeben wurde, kann dieser durch eine Printsubstitution in das Template, welches schließlich die Indexseite anzeigt, eingefügt werden.
Die 10 Bookmarks, die in der Indexseite dargestellt werden sollen, werden dagegen durch
eine Listsubstitution in das Template eingebettet. Listsubstitutions können sowohl in sichtbaren als auch in Mischhandlern definiert werden und ersetzen die Listenplatzhalter in Templates. Listenplatzhalter definieren, wie schon im Kapitel 3.1.1 erläutert, in den
Templates Bereiche, in die weitere Platzhalter eingefügt werden können. Diese Platzhalter
werden dann iterativ solange substituiert, bis eine Abbruchbedingung, die in der Listsubstitution definiert wird, erfüllt wird. Mit Listsubstitutions können somit Listen
56
erzeugt werden, die gleichartige Objekte, wie in diesem Fall Bookmarks, enthalten. Bei der
Definition von Listsubstitutions müssen folgenden Funktionen definiert werden:
•
start ()
•
hasNext ()
•
next ()
•
init ()
In der Funktion „start()“ wird in den meisten Fällen ein Iterator angegeben, der iterativ
durchlaufen wird und mit dessen Elementen die Platzhalter innerhalb des Listenplatzhalters
substituiert werden. In der Funktion „hasNext()“ wird die Abbruchbedingung festgelegt,
die bei jeder Iteration ausgewertet wird. Wenn die Abbruchbedingung nicht erfüllt ist, wird
mit der Funktion „next()“ der Pointer des Iterators Iauf das nächste Listelement gesetzt.
Schließlich werden in der Funktion „init“ die Substitutionen der verschieden Platzhalter definiert
Für die Definition der Listsubstitution der Bookmarkliste wird der Funktion „Start“ der
Iterator, der durch die Funktion „getpage()“ erzeugt wurde, zugeordnet und in die Funktionen „hasNext()“ und „Next()“ die Funktionen „hasNext“ und „Next()“ des Iterators
eingefügt. Danach können in der Funktion „init()“ die Substitutionen, welche die Platzhalter des Templates durch die Eigenschaften der verschiedenen Bookmarks ersetzen, definiert
werden. Durch „Printsubstitutions“ können die Eigenschaften Titel, Eigentümername
und die Tags des Bookmarks in das Template eingebettet werden. Da die Bookmarkbeschreibung optional ist, muss durch eine „Conditionalsubstitution“ für jeden Bookmark
überprüft werden, ob diesem eine Beschreibung zugeordnet wurde. Wenn dies der Fall ist,
wird die Beschreibung, ebenfalls wie die restlichen Eigenschaften des Bookmarks, durch eine
Printsubstitution in das Template eingefügt, ansonsten wird diese Substitution nicht
ausgeführt.
Neben den Eigenschaften des Bookmarks wird, wie im Kapitel 4.2.1 beschrieben, für jeden
Bookmark die Anzahl der Bookmarks angezeigt, die auf die gleiche Ressource verweisen,
wie der jeweils angezeigte Bookmark. Falls mehrere Anwender einen Bookmark zu dieser
Ressource definiert haben, wird die entsprechende Anwenderanzahl als Link dargestellt, die
zu einer Kommentarfunktion verweist. Die Kommentarfunktion zeigt die Beschreibungen
aller Bookmarks an, die mit der gleichen URL verknüpft sind wie der Bookmark, für den die
Kommentare angefordert wurden.
57
5.2.2.2
Kommentarfunktion
Die Kommentarfunktion basiert auf der AJAX-Technologie, wodurch die Übersichtsseite
weder neu geladen werden muss noch ein Popup-Fenster geöffnet wird, wenn diese Funktion
aufgerufen wird.
Wenn ein Anwender die Kommentare eines Bookmarks aufrufen will und somit die Kommentarfunktion aufruft, wird ein Javascript aktiviert, welches einerseits die Kommentare des
Bookmarks über ein XMLHttpRequest von der serverseitigen Logik abfragt und andererseits
diese in das HTML-Dokument, in dem das Javascript aufgerufen wurde, einbettet.
Mit dem XMLHttpRequest wird die URL des Bookmarks, für den die Kommentare angezeigt
werden sollen, an die serverseitige Logik übertragen, welche die Funktion “getBookmarkofanURL()“ aufruft. In dieser Funktion wird eine Query ausgeführt, die alle Bookmarks ab-
fragt, die mit der URL, die an diese Funktion übergeben wird, verknüpft sind. Nachdem die
ermittelten Bookmarks von der Funktion zurückgegeben wurden, werden deren Beschreibungen jeweils in das Antwortdokument eingebettet. Nachdem alle Beschreibungen eingefügt
wurden, liegen diese hintereinander angeordnet und jeweils durch Strichpunkte voneinander
getrennt in dem Antwortdokument vor.
Das Javascript, dem das Antwortdokument übergeben wird, kann nun auf die einzelnen Beschreibungen zugreifen, indem es diese durch die Funktion „Split()“ jeweils an den Strichpunkten von einander trennt. Aus den einzelnen Kommentaren erstellt das Javascript schließlich eine Aufzählungsliste, die in der folgenden Abbildung dargestellt wird, und bettet diese
in die Übersichtsseite unterhalb des Bookmarks, für den die Kommentare angefordert wurden, ein.
Abb. 22: Die Kommentarliste ( Quelle: eigene Darstellung )
Wie dieser Abbildung zu entnehmen ist, wird in dieser Liste jeder Kommentar mit dem Namen dessen Autors verknüpft. Die Namen der Autoren verweisen auf deren Bookmarklogs,
wodurch wiederum zwei verschiedene Informationsquellen über Bookmarks (Kommentarliste und Bookmarklog) miteinander vernetzt werden.
58
5.2.2.3
Funktionen der Übersichtsseite
Neben den Eigenschaften der Bookmarks und der Kommentarfunktion wird jeder Bookmarkdarstellung eine Bearbeitungsfunktion, eine Löschfunktion und eine Exportfunktion
zugeordnet, deren Realisierung im Folgenden dargestellt wird.
Wenn ein Anwender die Bearbeitungsfunktion eines Bookmarks aufruft, wird ein Javascript
ausgeführt, welches einen XMLHttpRequest initialisiert, das wiederum die ID des zu bearbeitenden Bookmarks an die serverseitige Logik übergibt. Nach der Aktivierung der serverseitigen Logik fragt diese mit der Methode „getBookmark()“ den Bookmark, der mit der
übergebenen ID verknüpft ist, aus der Datenquelle ab und erstellt im Antwortdokument das
entsprechende Bearbeitungsformular. Dabei werden dessen Eingabefelder mit den Eigenschaften des zu bearbeitenden Bookmarks vorbelegt(siehe Abb. 23).
Abb. 23: Das Bearbeitungsformular ( Quelle: eigene Darstellung )
Wie in dieser Abbildung zu sehen ist, wurde das Formular so gestaltet, dass die Anordnung
seiner Elemente vergleichbar mit der Darstellung der Eigenschaften eines Bookmarks (vgl.
Abb. 12) ist. Durch diese Anordnung der Formularfelder kann der Anwender allein durch die
Positionierung der einzelnen Formularfelder auf deren Bedeutung schließen. Des Weiteren
wird das Formular innerhalb der Übersichtsliste an der Position angezeigt, an der normalerweise der Bookmark, der bearbeitet wird, dargestellt wird. Aus diesem Grund ist es ebenfalls
wichtig, dass das Formular auf ähnliche Art wie die Bookmarkdarstellung formatiert wird,
damit die homogene Oberfläche der Übersichtseite durch das Einfügen des Bearbeitungsformulars weitestgehend nicht unterbrochen wird
59
Das Javascript, dem das Antwortdokument übergeben wird, kann das Formular aus diesem
auslesen und die Darstellung des Bookmarks, das bearbeitet werden soll, durch dieses ersetzen. Nach der Einbettung des Formulars, kann der Anwender den Bookmark bearbeiten.
Wenn der Anwender die Bearbeitung des Bookmarks abgeschlossen und das Formular abschicken will, wird durch ein Javascript überprüft, ob alle Formularfelder ausgefüllt wurden.
Wenn ein Feld außer dem Beschreibungsfeld8 nicht ausgefüllt wurde, wird eine Fehlermeldung ausgegeben, die den Anwender auf die Unvollständigkeit des Formulars hinweist. Ansonsten wird ein XMLHttpRequest erzeugt, mit dem die Formularparameter an die serverseitige Logik übertragen werden. Diese verarbeitet die Formularparameter, indem sie dem
Bookmarkeintrag, der bearbeitet wurde, die übertragenen Werte zuordnet. Dabei erfolgt die
Zuordnung der „neuen“ Tags zu den Bookmarkeintrag in zwei Schritten. Im ersten Schritt
werden alle Verknüpfungen zwischen den alten Tags und dem Bookmarkeintrag gelöscht und
gleichzeitig überprüft, ob diese Tags noch mit weiteren Bookmarks verknüpft sind. Wenn
dies nicht der Fall ist, werden diese ebenfalls gelöscht, da Tags existenzabhängig von den
Bookmarks sind. Im zweiten Schritt wird der Bookmarkeintrag mit den neuen Tags verknüpft, wobei, falls ein neuer Tag noch nicht im System existiert, eine entsprechende Instanz
des Assettyps „Tag“ erzeugt wird (vgl. Kap. 5.2.1.2).
Nachdem der Bookmark aktualisiert wurde, wird durch die fachliche Logik ein HTMLFragment, das die Darstellung des aktualisierten Bookmarks enthält, erstellt und über ein
Antwortdokument an ein Javascript übergeben. Das Javascript, dem das Antwortdokument
übergeben wird, kann nun das Bearbeitungsformular des Bookmarks wieder durch dessen
Darstellung ersetzen. Da die Übermittlung der Formularparameter und der Darstellung des
Bookmarks AJAX-basiert erfolgt, kann der Bookmark asynchron zu dem normalen
Programmablauf aktualisiert werden. Somit muss nach dem Abschicken des Bearbeitungsformulars die Übersichtsseite nicht neu geladen werden. Dies trägt zur Benutzerfreundlichkeit der Erweiterung bei.
Wenn der Anwender einen Bookmark löschen will und die entsprechende Funktion aufruft,
wird eine Seite ausgegeben, auf der der Anwender bestätigen muss, dass der ausgewählte
Bookmark wirklich gelöscht werden soll. Wird dies bestätigt, wird die Bookmark-ID des zu
löschenden Bookmarks an die fachliche Logik übertragen und der entsprechende Bookmarkeintrag aus der Datenquelle gelöscht. Außerdem müssen dessen Verknüpfungen zu den As8
Die Eigenschaft „Beschreibung“ ist für alle Bookmarks optional.
60
sets „Weblog“, „Person“ und „Tags“ (siehe Kap. 5.1.2) entfernt werden, damit das Löschen
eines Bookmarks keinen inkonsistenten Systemzustand hervorruft. Nachdem die Beziehung
zu den Tags gelöscht wurde, muss überprüft werden, ob diese noch mit weiteren Bookmarks
verknüpft sind. Wenn dies nicht der Fall ist, werden die Tags wegen ihrer Existenzabhängigkeit zu den Bookmarks ebenfalls gelöscht.
Schließlich wird der Bookmarkdarstellung noch die optionale Funktion „exportieren“ zugeordnet, die die Anwender über die Einstellungsseite ihrer Bookmarkaccounts aktivieren oder
deaktivieren können. Diese Funktion ermöglicht den Anwendern, einzelne Bookmarks aus
der Erweiterung nach Del.icio.us exportieren.
Der Export von Bookmarks wird mittels des Webservices, der von Del.icio.us angeboten
wird, realisiert. Die Schnittstelle des Webservices, der auf der REST-Architektur basiert,
wird in der folgenden Abbildung dargestellt.
http://del.icio.us/api/posts/add?&url=<url>&description=<Title>&extended=<Beschreibung>&tags=<Tags>
Abb. 24: Schematische Darstellung der Schnittstelle des Webservices ( Quelle: eigene Darstellung )
Wie in dieser Abbildung dargestellt wird, können über die Schnittstelle die zentralen Eigenschaften eines Bookmarks (Titel, URL, Beschreibung und Tags) nach Del.icio.us exportiert
werden.
Nach Aufruf dieses Webservices wird der Anwender aufgefordert, die Benutzerkennung des
Accounts anzugeben, in den der Bookmark eingefügt werden soll, damit eine sichere Verbindung zu Del.icio.us hergestellt werden kann. Nachdem die eingegebenen Benutzerdaten erfolgreich verifiziert wurden und somit diese Verbindung aufgebaut werden kann, wird der
Webservice ausgeführt und der Bookmark in den entsprechenden Account eingefügt.
Um die Exportfunktion in die Übersichtsseite einzubetten, muss jeder Bookmarkdarstellung
ein Link zugeordnet werden, der die URL des Werbservices, an die die Eigenschaften des
jeweiligen Bookmarks angehängt sind, darstellt. Wenn ein Anwender diesen Link anklickt,
wird der Webservice für den entsprechenden Bookmark ausgeführt und dieser nach
Del.icio.us exportiert.
61
5.2.2.4
Tagspezifische Seiten der Übersicht
Neben der Bookmarkliste wird auf der Übersichtsseite eine Liste, die alle Tags des Anwenders enthält, ausgegeben. Da die Instanzen des Asset „Tag“ personenspezifisch sind, können
die Tags einer Person durch eine einfache Query ermittelt werden, die alle Instanzen des Asset „Tags“ abfragt, die mit einer bestimmten Person assoziiert sind. Diese Query wurde in der
Funktion „getTagsOfaPerson()“ realisiert, welche die ausgelesenen Tags als Iterator zurückgibt. Durch diese Funktion kann der Handler, der die Übersichtsseite erzeugt, nun die
Elemente für die Tagliste abfragen und jene durch eine „Listsubstitution“ in das entsprechende Template einbetten. Die Elemente dieser Tagliste werden jeweils als Links realisiert, die zu den tagspezifischen Übersichtsseiten verweisen.
Die tagspezifischen Seiten enthalten die gleichen Elemente wie die allgemeine Übersichtsseite und zeigen zusätzlich noch eine Liste der verwandten Tags des Tags, dessen Bookmarks
auf der jeweiligen Seite dargestellt werden, an. Die Elemente dieser Liste können mit der
Funktion „getRelatedTagsofTag()“, die in der folgenden Abbildung dargestellt wird,
ermittelt werden.
public Iterator getRelatedTagsofTag(String tagid) {
Vektor v = new Vektor();
Iterator bi= servces.getBookmarks().
getAllbookmarksofaTag(services.getTags().
getTag(tagid));
while (bi.hasNext()) {
BookmarkEntry bookmark = (BookmarkEntry) bi.next();
if (bookmark != null) {// if1
Iterator it = bookmark.getTags();
while (it.hasNext()) {
Tag tag = (Tag) it.next();
if (tag != null) {
int nu=Numberofcommonbookmarks(services.
getTags().getTag(tagid).getValue()
,tag.getValue());
if (!v.contains((tag.getValue().trim())) &&
nu>2) {
.add((String) tag.getValue());}}}}}
v.remove(services.getTags().getTag(tagid).getValue());
return v.Iterator();}
Abb. 25: Die Funktion "getRelatedTagsofaTag" ( Quelle: eigene Darstellung )
Die Funktion „getRelatedTagsofTag()“ ermittelt alle verwandten Tags eines Tags t,
indem diese im ersten Schritt die Menge b der Bookmarks abfragt, die mit t verknüpft sind.
Da alle Tags, die mit den Bookmarks der Menge b verknüpft sind, mit t verwandt sein könnten, muss nun für jeden dieser Tags überprüft werden, ob dieser noch einen weiteren gemeinsamen Bookmark mit t hat (siehe Definition: Verwandte Tags, Kap. 4.2). Somit werden itera62
tiv die Tags von jedem Bookmark der Menge b mit der Funktion „getTags()“ abgefragt
und für jeden Tag die Anzahl der Bookmarks ermittelt, die er gemeinsam mit dem Tag t hat
(Funktion: Numberofcommonbookmarks()). Wenn ein Tag mehr als zwei gemeinsame
Bookmarks mit t hat, ist dieser mit t verwandt und wird in einen Vektor eingefügt.
Da es aber sein kann, dass bestimmte Tags mehreren Bookmarks der Menge b zugeordnet
sind und somit deren Verwandtschaft zu t mehrmals ermittelt wird, muss, bevor ein neuer
Tag in den Vektor eingefügt wird, festgestellt werden, ob sich dieser schon in dem Vektor
befindet. Nachdem der Algorithmus ausgeführt wurde, liegen alle verwandten Tags von t in
einem Vektor vor. Dieser wird schließlich in einen Iterator umgewandelt, der von der Funktion „getRelatedTagsofTag()“ zurückgegeben wird.
Die verwandten Tags können nun durch eine Listsubstitution in das Template, welches
die tagspezifische Übersichtsseite schließlich ausgibt, eingebettet werden.
Nachdem in diesem Kapitel die Umsetzung der Übersichtsseite des Bookmarkaccounts erläutert wurde, wird anschließend die Abonnementverwaltung, die in der so genannten „Inbox“
realisiert wurde, beschrieben.
5.2.3
Abonnementverwaltung: Inbox
In der Inbox werden die aktuellen Bookmarks der Abonnements eines Anwenders ausgegeben. Diese wird täglich aktualisiert, was bedeutet, dass in ihr die Bookmarks höchstens einen
Tag lang angezeigt werden und sie somit nur einen temporären Speicher für die Bookmarks
darstellt. Innerhalb der Inbox werden die Bookmarks auf die gleiche Art dargestellt wie in
der Übersichtsseite (siehe Kap. 5.2.2) mit dem Unterschied, dass statt einer „Bearbeitungs-„
bzw. „Löschfunktion“ eine „Kopierfunktion“ jedem Bookmark zugeordnet wird. Des Weiteren werden die verschiedenen Abonnements eines Anwenders, sortiert nach deren „Abonnementarten“, in der Inbox dargestellt.
Die zentrale Aufgabe bei der Implementierung dieser Inbox war der Entwurf eines Algorithmus, mit dem die aktuellsten Bookmarks der verschiedenen Abonnementarten ermittelt und
schließlich in der Inbox angezeigt werden können. Dieser Algorithmus wurde so realisiert,
dass er alle Bookmarks aller Abonnements ermittelt, die seit dem letzten Zugriff auf die Inbox an einem vorherigen Tag in das System eingefügt wurden. Durch den Algorithmus, der
in der folgenden Abbildung dargestellt wird, werden somit die aktuellen Bookmarks der A-
63
bonnements jeweils einen Tag lang in der Inbox angezeigt und bei einem Zugriff auf die Inbox an einen darauf folgenden Tag wieder aus dieser gelöscht.
public Iterator getlatestbookmarksofasubscription (String bid,Date
sessiondate) {
Vektor bv = new Vektor();
Iterator bookmarks;
Iterator subscriptions = services.getSubscriptions()
.getallsubscriptionsfaBookmarklog(bid);
while (subscriptions.hasNext()) {
subscription sub = (subscription) subscriptions.next();
if (sub != null) {
sub.Updatelastdate(sessiondate);
if(sub.getTyp()==0){
bookmarks=services.getBookmarks().
getAllCurrentbookmarksofaTagname
(sub.getSubscription().trim(), sub.getLastSession());}
else if(sub.getTyp()==1){
bookmarks=services.getBookmarks().
getAllCurrentpublicBookmarksofPerson
(sub.getSubscription(), sub.getLastSession());}
else{bookmarks = services.getBookmarks().
getAllCurrentpublicBookmarksofatag(sub.getSubscription(),
sub.getLastSession());}
while (bookmarks.hasNext()) {
BookmarkEntry bookmark = (BookmarkEntry) boomarks.next();
if (bookmark != null && !bv.contains((BookmarkEntry)
bookmark)) {
bv.add((BookmarkEntry) bookmark); }}}}
return bv.Iterator();}
Abb. 26: die Funktion "getlatestbookmarksofasubscription"( Quelle: eigene Darstellung )
Die Funktion „getlatestbookmarksofasubscription“ gibt einen Iterator zurück, der
alle Bookmarks enthält, die in der Inbox ausgegeben werden sollen. Zunächst werden durch
die Funktion alle Abonnements des Anwenders, der auf die Inbox zugreift, abgefragt. Da die
Abonnements indirekt über den Bookmarklog mit deren Eigentümer verknüpft sind (siehe
„Modell der Erweiterung“, Abb. 11), wird nicht die PersonID, sondern die ID des Bookmarklogs des Abonnenten an diese Funktion übergeben. Nachdem die Abonnements ermittelt
wurden, müssen iterativ deren aktuellen Bookmarks abgefragt werden. Dabei wird zuerst die
Eigenschaft „LastSession“, die jedem Abonnement zugeordnet ist (siehe Kap. 5.1.4 ), durch
die Hilfsfunktion „.Updatelastdate ()“ aktualisiert. Diese Funktion ordnet, wenn auf die
Inbox zum ersten Mal an einen bestimmten Tag zugegriffen wird, das Datum des letzten
Zugriffes auf die Inbox (z.B. das Datum von gestern) der Eigenschaft „Lastsession“ zu, ansonsten bleibt diese unverändert. Dadurch wird erreicht, dass die Bookmarks immer einen
Tag lang in der Inbox angezeigt werden, auch wenn der Anwender mehrmals täglich auf die64
se zugreift. Nachdem das Aktualisierungsdatum festgelegt wurde, werden nun nacheinander
die aktuellen Bookmarks der verschiedenen Abonnements ausgelesen. Da für jeden Abonnementtyp eine spezielle Funktion zur Ermittlung der Bookmarks realisiert wurde, muss,
bevor die Bookmarks für ein bestimmtes Abonnement abgefragt werden, dessen Typ bestimmt werden.
Handelt es sich um ein tagspezifisches Abonnement (Typ= 0), werden die aktuellen Bookmarks durch die Funktion „getAllCurrentbookmarksofaTagname()”, an die der abonnierte Tagwert übergeben wird, ermittelt. Der Tagwert kann dabei aus der Eigenschaft
„Subscription“ des Assettyps „Bsubscription“, welcher die Abonnements physisch speichert,
ausgelesen werden.
Bei personenspezifischen Abonnements (Typ=1) wird dagegen in dieser Eigenschaft die ID
der Person gespeichert, dessen Bookmarks abonniert wurden. Anhand der ID können nun die
aktuellen Bookmarks mittels der Funktion „getAllCurrentpublicBookmarksofPerson
()“ angefordert werden.
Den Eigenschaften „Subscription“ der Instanzen des Assets „Bsubscription“, die ein tagund personenspezifisches Abonnement enthalten, müssen nur die ID der Taginstanzen, die
dem abonnierten Tags entsprechen, zugeordnet werden, da diese Instanzen personspezifisch
sind. Um auf die aktuellen Bookmarks eines solchen Abonnementtyps zugreifen zu können,
müssen somit lediglich die Bookmarks abgefragt werden, die mit dem Tag verknüpft sind,
dessen ID in dem entsprechenden Abonnementeintrag gespeichert wurde. Diese Funktionalität wurde in der Funktion "getAllCurrentpublicBookmarksofatag()" realisiert.
Nachdem die aktuellen Bookmarks eines Abonnements abgefragt wurden, müssen sie in einen Vektor, der diese mit den Bookmarks der anderen Abonnements vereint, eingefügt werden. Da es aber sein kann, dass ein Bookmark verschiedenen Abonnements zugeordnet ist,
muss, bevor ein neuer Bookmark in den Vektor eingefügt wird, überprüft werden, ob sich
dieser schon in den Vektor befindet.
Nachdem die aktuellen Bookmarks von allen Abonnements eines Anwenders in den Vektor
eingefügt wurden, wird dieser in einen Iterator, der schließlich von der Funktion
„getlatestbookmarksofasubscription()“ zurückgegeben wird, umgewandelt.
Die ermittelten Bookmarks können nun durch eine „Listsubstitution“ in das Template,
das die Inbox anzeigt, eingefügt werden. Dabei wird jedem Bookmark eine „Kopierfunktion“
zugeordnet, mit der die Anwender die abonnierten Bookmarks aus der Inbox in ihre eigenen
Bookmarkaccounts kopieren können. Wenn ein Anwender einen Bookmark kopieren will
und die Kopierfunktion aufruft, wird das Einfügeformular seines Bookmarkaccounts geöff-
65
net, dessen Felder mit den Eigenschaften dieses Bookmarks vorbelegt sind. In diesem Formular kann der Anwender die Eigenschaften des Bookmarks nun beliebig bearbeiten und diesen
anschließend speichern (vgl. Kap. 5.2.1)
Neben den Bookmarks werden die verschiedenen Abonnements eines Anwenders sortiert
nach Abonnementtypen in der Inbox dargestellt. Die Elemente der verschiedenen Abonnementlisten werden jeweils als Links dargestellt, die zu den „Quellen“ der verschiedenen Abonnements verweisen. Die tagspezifischen Abonnements verweisen jeweils zu der tagspezifischen Seite, die alle Bookmarks enthält, die mit dem jeweiligen abonnierten Tag verknüpft
sind. Dagegen verweisen die personenspezifischen Abonnements auf die Bookmarklogs der
Anwender, deren Bookmarks abonniert wurden. Die tagund personenspezifischen Abonnements sind schließlich jeweils mit der entsprechenden tagspezifischen Seite des Bookmarklogs des Anwenders, dessen Bookmark abonniert wurden, verknüpft.
Jedem Abonnement wird jeweils eine Funktion zugeordnet, mit der sich der Anwender von
den verschiedenen Abonnements abmelden kann. Wenn ein Abonnement gelöscht werden
soll und diese Funktion ausgeführt wird, wird die dem Abonnement entsprechende Instanz
des Assettyps „Bsubscription“ aus der Datenquelle gelöscht.
5.2.4
Funktion: „Tags umbenennen“
Der Bookmarkaccount bietet eine Funktion an, mit der Tags konsistent umbenannt werden
können. Durch die Umbenennung eines Tags kann jeder Bookmark, der mit diesem Tag verknüpft ist, einem neuen Themengebiet zugeordnet werden.
Wenn diese Funktion aufgerufen wird, öffnet sich ein Formular, in dem der Anwender aus
einer Auswahlliste den Tag, den er umbenennen will, auswählen und in ein Textfeld den neuen Wert des Tags eingeben kann. Dem Textfeld wurde die im Kapitel 5.2.1.1 vorgestellte
Suggestionfunktion, die die Benutzereingaben erkennt und Vorschläge für deren Fertigstellung ausgibt, zugeordnet. Dadurch kann der Anwender beispielsweise bei der Eingabe des
neuen Tagnamen direkt sehen, welche Tags schon von anderen Anwendern definiert wurden
und einen von diesen für die Umbenennung seines Tags übernehmen. Nachdem der Anwender das Formular abgeschickt hat, wird von der fachlichen Logik überprüft, ob beide Formularfelder ausgefüllt wurden. Ist dies nicht der Fall, wird eine Fehlermeldung ausgegeben.
Ansonsten wird durch die Funktion „getTagbyName“ die Instanz, in der das Tag, das umbenannt werden soll, gespeichert ist, ermittelt und dieser der neue Tagname zugeordnet. Da die
66
Instanz über eine „N zu M“ Beziehung mit den Bookmarks verknüpft ist, ist die Umbenennung des Tags über diese Bookmarks konsistent.
In dem folgenden Kapitel wird die Realisierung des Bookmarklogs, der die Bookmarks einer
bestimmten Person öffentlich darstellt und somit eine Art Schnittstelle zwischen der privaten
und der öffentlichen Schicht der Erweiterung ist, vorgestellt.
5.3
Implementierung des Bookmarklogs
Die Bookmarklogs enthalten jeweils alle öffentlichen Bookmarks eines Anwenders und
stellen somit die personenspezifische Sicht auf den Bookmarkbestand der öffentlichen
Schicht der social bookmarking Erweiterung dar. Innerhalb der Bookmarklogs können sowohl alle Bookmarks, die nach deren Einfügedatum sortiert sind, als auch die tagspezifischen
Bookmarks einer Person angezeigt werden. Die verschiedenen Übersichten werden auf die
gleiche Weise erzeugt wie die Übersicht in dem Bookmarkaccount (siehe Kap, 5.2.2), jedoch
mit dem Unterschied, dass nur die öffentlichen Bookmarks einer Person in das Template, das
die Bookmarklogs anzeigt, eingebettet werden. Diese Bookmarks können durch die Funktionen „getallPublicBookmarksOfaPerson()” beziehungsweise mit der Funktion „getAllPublicBookmarksofaTag()“, die alle tagspezifischen Bookmarks einer Person zu-
rückgibt, ermittelt werden.
In den Bookmarklogs wird der Bookmarkdarstellung eine Kopierfunktion zugeordnet, mit
der die verschiedenen Anwender die anzeigten Bookmarks in ihre eigenen Bookmarkaccounts kopieren können. Da aber auch Anwender, die keine Bookmarks kopieren dürfen wie
z. B. unangemeldete Anwender, auf die Bookmarklogs zugreifen können, muss die Kopierfunktion dynamisch ein- und ausgeblendet werden können. Aus diesem Grund wird die
Funktion in einen bedingten Platzhalter eingebettet, dem eine Conditionalsubstitution
zugeordnet wird, welche die drei folgenden Bedingungen definiert und auswertet:
•
Der Anwender ist angemeldet
•
Der Anwender hat einen Bookmarkaccount
•
Der Anwender ist nicht der Eigentümer des Bookmarklogs
Wenn diese drei Bedingungen erfüllt sind, darf der Anwender, der auf den Bookmarklog zugreift, Bookmarks kopieren und die Kopierfunktion wird angezeigt.
67
Neben den Bookmarks werden die Tags, die von dem jeweiligen Eigentümer des Bookmarklogs definiert wurden, dargestellt. Diese Tags verweisen zu den tagspezifischen Seiten
des Bookmarklogs, auf denen analog zu den tagspezifischen Seiten des Bookmarkaccounts,
die tagspezifischen Bookmarks und die verwandten Tags des jeweiligen Tags angezeigt werden. Die verwandten Tags werden durch die Funktion „getRelatedTagsofTag“, die im Kapitel
Fehler! Verweisquelle konnte nicht gefunden werden. beschrieben wurde, ermittelt.
Auf jeder Seite des Bookmarklogs befindet sich ferner eine Funktion, mit der ein Anwender
die Bookmarks, die ihm angezeigt werden, abonnieren kann. Befindet sich der Anwender
auf der „generellen“ Seite des Bookmarklogs, auf der alle Bookmarks einer Person angezeigt
werden, so kann er ein personenspezifisches Abonnement abschließen. Wenn er dagegen eine
tagspezifische Seite des Bookmarklogs aufruft, kann er die auf dieser Seite angezeigten tagspezifischen Bookmarks abonnieren (tagund personspezifisches Abonnement). Nachdem
der Anwender die Abonnementfunktion aufgerufen hat, erzeugt die fachliche Logik, die in
den SubscriptionsHandler implementiert wurde, eine Instanz des Assets „Bsubscription“ (siehe Kap. 5.1.4). Dieser wird in Abhängigkeit der Requestparameter, die an den Handler übertragen werden, ein bestimmter Abonnementtyp zugeordnet. Wenn der Handler eine Personen-ID erhält, wird ein personenspezifisches Abonnement erstellt und der Eigenschaft „Typ“
dieser Instanz der Wert „null“ zugeordnet. Wird dem Handler dagegen die ID einer Taginstanz übergeben, wird ein tagund personenspezifisches Abonnement erzeugt und die Eigenschaft „Typ“ dieser Instanz auf „2“gesetzt (vgl. Tab. 2).
Des Weiteren wird dieser Instanz das Erstellungsdatum des Abonnements hinzugefügt.
Nachdem ein Anwender die Abonnementfunktion ausgeführt hat, wird diese auf der Seite,
die mit dem eingefügten Abonnement verknüpft ist, dem Anwender nicht mehr angezeigt.
Somit kann zu einem ausgeschlossen werden, dass ein Anwender zweimal das gleiche Abonnement abschließt und zum anderen kann der Anwender gleich sehen, welche Abonnements
er schon abgeschlossen hat.
Neben den Übersichten über die Bookmarks einer Person wurde für die Bookmarklogs eine
Content Syndication Schnittstelle, die im folgendem vorgestellt wird, realisiert.
68
5.3.1 Die Content Syndication Schnittstelle
Die Content Syndication Schnittstelle ermöglicht den Anwendern, Feeds für ihre Bookmarklogs bereitzustellen, mit denen die Bookmarks ihrer Bookmarklogs exportiert werden
können. Um diese Schnittstelle möglichst allgemein zu gestalten, wurden vier verschiedene
Feedformate für diese realisiert:
•
•
RSS 1.0
Atom 1.0
•
•
RSS 0.92
Atom 0.3
Da jeder Anwender selbst bestimmen sollte, welche Feeds auf seinem Bookmarklog angeboten werden sollen, können die Anwender über die Einstellungsseite ihres Bookmarkaccounts
die einzelnen Feeds aktivieren bzw. deaktivieren. Die entsprechenden Einstellungen werden
in den Eigenschaften „ExportRss092“, „ExportRss10“, „ExportAtom03“, „ExportRss10“ der
Instanz der Asset „Weblog“ eingefügt, in der die Konfiguration des Bookmarklogs des jeweiligen Eigentümers gespeichert ist. Da Bookmarklogs standardmäßig keinen Feed exportieren,
haben diese Eigenschaften den Defaultwert „0“. Wird ein bestimmter Feed aktiviert, wird der
Wert der entsprechenden Eigenschaft auf „1“ gesetzt. Diese Eigenschaften werden bei der
Generierung der Bookmarklogs durch eine „ConditionalSubstitution “ abgefragt und falls ein
bestimmter Feed von den Bookmarklogs angeboten werden soll, wird eine entsprechende
Exportfunktion in diese eingebettet.
Wenn die Anwender die Exportfunktion aufrufen und somit einen Feed anfordern, wird dessen Generierung angestoßen. Die Erzeugung der Feedversionen RSS 1.0, RSS 0.92 und Atom
1.0 erfolgt wie bei der Generierung von HTML-Seiten mittels eines Templates, dessen Platzhalter durch einen Handler dynamisch ersetzt wird. Somit wurde für jeden dieser drei Feedetypen jeweils ein XML-Template erstellt, welches die Struktur des jeweiligen Feedtyps enthält.
5.3.1.1 RSS 1.0 Template
Der RSS 1.0 Feed der Erweiterung hat die gleiche Struktur wie der Feed, der von Del.icio.us
angeboten wird, damit dieser zu den Anwendungen, die bereits den Feed von Del.icio.us lesen und verarbeiten können, kompatibel ist.
Am Anfang dieses Feedtemplates werden die Namespaces, die für die Darstellung der Attribute verwendet werden, deklariert. Obwohl für die Darstellung der Bookmarks nur die Attri-
69
bute der Namespaces „Dublincore“ und „RDF“ verwendet werden, wurden noch weitere
Namespaces definiert, die bei eventuellen Erweiterungen des Feedtemplates verwendet werden können.
Danach wird der Channel definiert, der die eigentlichen Informationen des Feeds enthält. Im
Channel, dessen „about-Attribut“ die Url des Bookmarklogs, der den Feed anbietet, zugeordnet wird, werden allgemeine Metainformationen über den Feed angegeben. Als Titel
des Channels wird der Name des Bookmarklogs verwendet und in das Attribut „Link“ wird
nochmals die URL des Bookmarklogs eingefügt. Nachdem die Metadaten dem Channel zugeordnet wurden, wird der Inhalt des Channels innerhalb des „items“ Elements zusammengefasst dargestellt. Dieses Element umfasst eine Liste (rdf:li) mit den Referenzen zu den
verschiedenen „item“-Elementen, in denen schließlich die Bookmarks beschrieben werden.
Da jedes “item“-Element jeweils über die URL des Bookmarks, der in diesem beschrieben
wird, identifiziert und referenziert wird, muss diese URL dem „about“ Attribut des jeweiligen Items hinzugefügt werden.
Innerhalb eines Items werden nun die verschiedenen Eigenschaften eines Bookmarks beschrieben. Dabei kann, wie der Abbildung 23 zu entnehmen ist, jede Eigenschaft des Bookmarks einem bestimmten Element des „Dublin Core“- oder des „RDF“- Namespace zugeordnet werden. Der Eigentümer, das Einfügedatum und die Tags eines Bookmarks werden den
„Dublin Core“ Elementen „dc:creator“, „dc:date“ und „dc:subject.“ zugeordnet.
Dagegen werden der Titel, die URL und die Beschreibung des Bookmarks durch die „RDF“
Elemente „title“, „link“ und „description“ beschrieben. Das Template für den RSS
1.0 Feed wird in der folgenden Abbildung dargestellt:
70
<?xml version="1.0" encoding="UTF-8" ?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns="http://purl.org/rss/1.0/"
xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/"
xmlns:dc=“http://purl.org/dc/elements/1.1/“
xmlns:syn="http://purl.org/rss/1.0/modules/syndication/"
xmlns:admin="http://webns.net/mvcb/">
<channel rdf:about="http://$host$/socialbookmarking/$weblogtitle$">
<title>Bookmarks von $user$ </title>
<link>http://$host$/socialbookmarking/$weblogtitle$</link>
<description />
0<items>
<rdf:Seq>
$[bookmarks b$
<rdf:li rdf:resource="$b.url$" />
$bookmarks]$
</rdf:Seq>
</items>
</channel>
$[bookmarks b$
<item rdf:about="$b.url$">
<title>$b.title$</title>
<link>$b.url$</link>
<dc:creator>$b.buser$</dc:creator>
<dc:date>$b.date$</dc:date>
<dc:subject>$b.tags$</dc:subject>
$[b.hasdescription$
<description>$b.description$</description>
$b.hasdescription]$
</item>
$bookmarks b]$
</rdf:RDF>
Abb. 27: Struktur eines RSS 1.0 Templates ( Quelle: eigene Darstellung )
5.3.1.2 RSS 0.92 Template
In RSS 0.92 –Feeds können, wie im Kapitel 3.3.1 beschrieben wurde, keine externen Namespaces verwendet werden. Aus diesen Grund können in diesem Feedformat die Bookmarks nur mit den Elementen „Title“, “link“, “category“9 und „description“ des
RSS-Namespaces beschrieben werden. Neben den Bookmarks werden als Metadaten das
Erstellungsdatum des Feeds, der Bookmarklogtitel, die URL des Bookmarklogs und der Name des Eigentümers des Bookmarklogs in den Feed eingefügt. Die folgende Abbildung stellt
das Template für die Generierung eines RSS 0.92 Feeds dar:
9
In diesem Element werden die Tags des Bookmarks dargestellt.
71
?xml version="1.0" encoding="UTF-8"?>
<rss version="0.92">
<channel>
<title>$Bookmarklogtitle$</title>
<link>$host$/socialbookmarking/bookarmarklog?
blogid=$blogid$</link>
<managingEditor>$name$</managingEditor>
<lastBuildDate>$date$</lastBuildDate>
$[entries e$
<item>
<title>$e.btitle$</title>
<link>$e.burl$</link>
<category>$e.btags$</category>
$[e.hasdescription$
<description>$e.bdescription$</description>
$hasdescription]$
</item>
$entries]$
</channel>
</rss>
Abb. 28: Struktur eines RSS 0.92 Templates ( Quelle: eigene Darstellung )
5.3.1.3 ATOM 1.0 Template
Neben den RSS-Templates wurde ein Template für einen Atom 1.0 Feed erstellt. In das Feedtemplate werden die Bookmarks als „entries“ eingefügt, denen eindeutige IDs zugeordnet
werden müssen. Als entryids werden in diesem Fall die Bookmarkids, welche das System
automatisch den verschiedenen Bookmarks zuordnet und die eindeutig sind, verwendet.
Die Eigenschaften der Bookmarks können durch die Elemente der „ATOM“- und „Dublin
Core“-Namespaces dargestellt werden, wobei aber nur die Eigenschaft „Beschreibung“ des
Bookmarks einem Element des „Dublin Core“ Namespaces zugeordnet werden muss. Die
restlichen Eigenschaften der Bookmarks können dagegen mit den Elementen des AtomNamespaces dargestellt werden. Des Weiteren werden der Titel des Feeds („title“), der
Eigentümer des Bookmarklogs („author“) und das Erstellungsdatum („Updated“) als Metadaten in den Feed eingefügt. Die URL des Bookmarklogs, der den Feed anbietet, fungiert
als Feed-ID, die laut der ATOM-Spezifikation eindeutig sein muss (vgl. [ATO04]. Im folgendem wird die Struktur des Atom 1.0 Templates abgebildet.
72
<?xml version="1.0" encoding="utf-8"?>
<Feed xmlns=http://www.w3.org/2005/Atom“
xmlns:dc="http://purl.org/dc/elements/1.1/" version="1.0">
<title>$Bookmarklogtitle$</title>
<updated>$date$</updated>
<author>
<name>$name$</name>
</author>
<id>$host$/socialbookmarking/bookarmarklog?blog=$blogid$</id>
$[entries e$
<entry>
<id>$e.bookmarkid$</id>
<title>$e.btitle$</title>
<link rel="alternate" href="$e.burl$"/>
<dc:subject>$e.btags$</dc:subject>
<updated>$e.bdate$</updated>
$[e.hasdescription$
<content type="text">$e.bdescription$</content>
$e.hasdescription]$
<author>
<name>$e.buser$</name>
</author>
</entry>
$entries]$
</Feed>
Abb. 29: Struktur eines Atom 1.0 Templates ( Quelle: eigene Darstellung )
Wenn ein Anwender eine der drei vorstehend beschriebenen Feedarten anfordert, wird ein
Handler aufgerufen, der die Platzhalter in den vorgestellten Feedtemplates substituiert. Dabei
werden <item>-Elemente der RSS-Feeds bzw. die Entries bei Atomfeeds iterativ durch eine
Listsubstitution, die höchstens 10 der aktuellsten Bookmarks ausgibt, erzeugt. Durch
die Begrenzung der Anzahl der Bookmarks, die in den Feed ausgegeben werden, wird die
Generierung eines übersichtlichen Feed, der effektiv weiterverarbeitet werden kann, ermöglicht. Nachdem die Platzhalter substituiert wurden, wird der Atom 1.0- bzw. der RSS 1.0
Feeds dem Anwender angezeigt oder, wenn es sich um einen RSS 0.92 Feed handelt, dieser
zum „Download“ angeboten.
5.3.1.4 ATOM 0.3 Feed
Die Generierung eines Atom 0.3 Feeds basiert nicht auf XML-Template, sondern erfolgt
durch Umwandlung des RSS 1.0 Feeds. Die Umwandlung kann mit den Methoden durchgeführt werden, welche von der ROME- Bibliothek bereitgestellt werden. Diese Methoden ermöglichen sowohl das Einlesen von Feeds als auch deren Umwandlung. Beim Einlesen der
Feeds werden diese automatisch erkannt und mit jeweils geeigneten Parser verarbeitet. Der
73
Algorithmus, der für die Umwandlung des RSS 1.0 Feeds und somit für die Erstellung des
ATOM 0.3 Feeds verwendet wird, umfasst drei grundlegende Schritte.
Im ersten Schritt liest ein „SyndFeedInput“-Objekt den Feed ein und leitet diesen zum richtigen Parser weiter, der diesen verarbeitet:
SyndFeedInput input = new SyndFeedInput();
SyndFeed Feed = input.build(new XmlReader(feedUrl));
Abb. 30: Funktion: Einlesen des Feeds ( Quelle: [ABD05])
Im zweiten Schritt wird durch „Feed.setFeedType()“ das Format, in das der Feed mit den
folgenden Funktionen umgewandelt werden soll, festgelegt.
SyndFeedOutput output = new SyndFeedOutput();
FeedString=output.outputString(Feed)
Abb. 31: Ausgabe des umgewandelten Feeds (Quelle: vgl. [ABD05] )
Schließlich wird im dritten Schritt der transformierte Feed, in diesem Fall ein ATOM 0.3Feed, als ein „String“-Objekt ausgegeben. Dieses „String“-Objekt kann nun durch
„Printsubstitution“ in das Template, das den Feed den Anwendern anzeigt, eingebettet
werden.
Diese Umwandlung von Feeds hat den Nachteil, dass der dadurch erzeugte Feed nicht direkt
wartbar bzw. erweiterbar ist, sondern nur indirekt durch die Modifizierung des Quellfeeds
überarbeitet werden kann. Des Weiteren wurden bei der Umwandlung öfters fehlerhafte
Feeds, deren Elementen zum Beispiel falsche Werte zugeordnet wurden, erzeugt. Aus diesen
Gründen wurde der Umwandlungsalgorithmus nur zu Testzwecken für die Erstellung des
ATOM 0.3 Feeds verwendet.
5.3.2 Bookmarklogverzeichnis
Für die Anwender des Infoasset Brokers gibt es zwei Möglichkeiten auf einen Bookmarklog
einer bestimmten Person zuzugreifen. Zu einem kann jeder Anwender über die Bookmarkdarstellung auf die Bookmarklogs zugreifen( vgl. Kap. 4.2.1). Zum anderen wird der Zugriff
auf die verschiedenen Bookmarklogs durch ein Bookmarklogverzeichnis ermöglicht.
Das Bookmarklogverzeichnis enthält alle Bookmarklogtitel, die jeweils mit den entsprechenden Bookmarklogs verlinkt sind. Damit die Suche nach bestimmten Bookmarklogs innerhalb
des Verzeichnisses erleichtert wird, wurden dessen Einträge alphabetisch untergliedert. Dies
74
bedeutet, dass das Verzeichnis aus mehreren Unterseiten besteht, welche jeweils die Bookmarklogtitel auflisten, die mit dem gleichen Buchstaben beginnen. Innerhalb des Bookmarklogverzeichnisses kann der Anwender über einen Index auf die verschiedenen Unterseiten zugreifen.
Wenn ein Anwender einen Buchstaben des alphabetischen Indexes „anklickt“ und somit eine
Unterseite des Verzeichnisses aufruft, wird ein Handler, der die entsprechende Seite generiert, ausgeführt. Der Handler ermittelt mit der Funktion „getallBookmarkslogs()“(siehe
Abb. 32) alle Bookmarklogs, deren Titel mit dem Buchstaben, der als Requestparameter an
den Handler übergeben wurde, beginnen und bettet die Titel, die Eigentümernamen und die
Aktualisierungsdaten der abgefragten Bookmarklogs in die angeforderte Unterseite ein.
Mit der Funktion „getallBookmarkslogs ()“ können, falls dieser eine leere Zeichenkette übergeben wird, alle Bookmarklogs oder ansonsten alle Bookmarklogs, deren Titel mit
dieser Zeichenkette beginnen, ermittelt werden.
Wenn demnach eine leere Zeichenkette an die Funktion übergeben wird, wird nur eine Query
ausgeführt, die alle Instanzen des Assets „Weblog“, die einen Bookmarklog darstellen, zurückgibt.
Ist die Zeichenkette aber nicht leer, wird neben dieser Query noch eine weitere Query definiert, die alle Instanzen des Assettyps „Weblog“ abfragt, deren Titel mit dem übergebenen
String beginnen. Da die Schnittmenge der Ergebnismengen dieser beiden Queries die ge-
suchten Bookmarklogs enthält, werden diese durch die Querycondition „QueryAnd“ miteinander verknüpft.
Unabhängig davon, welche Bookmarklogs abgefragt werden, wird den Queries ein „Querysortingcriterion“ zugeordnet, welches festlegt, dass die Bookmarklogs sortiert nach deren
Aktualisierungsdaten zurückgeben werden sollen. Nachdem die entsprechende Query ausgeführt wurde, liegen die ermittelten Bookmarklogs in einem Iterator vor, der von der Funktion
„getallBookmarkslogs()“ zurückgegeben wird. Die folgende Abbildung stellt diese
Funktion dar:
75
public Iterator getallBookmarkslogs (String letter){
Query q;
if(letter.compareTo("")==0){
q = new QueryEquals(container, asIsBookmarkBlog , 1);}
else{
Query q1 = new QueryEquals(container,asIsBookmarkBlog,1);
Query q2 = new QueryBegins(container, asWeblogTitle
,letter.trim().toLowerCase());
Query q3 = new QueryBegins(container, asWeblogTitle
,letter.trim().toUpperCase());
Query q4 = new QueryOr(q2, q3);
q = new QueryAnd(q1, q4);}
QuerySortingCriterion[] qscsort = new QuerySortingCritrion[1];
qscsort[0] = new QuerySortingCriterion(container,
asLastPub lished, QuerySortingCrite
rion.DESCENDING);
Iterator it = container.queryContent(q, qscsort);
return new WrapperIterator(it) {
public Object wrap(Object o) {
Content cg = ((QueryResult) o).content;
return getAsset(cg);
}
};}}
Abb. 32: Die Funktion "getallBookmarkslogs"( Quelle: eigene Darstellung )
Nachdem der Handler mit dieser Funktion die Bookmarklogs abgefragt hat, wird nun mittels
einer „Listsubstitution“ die angeforderte Unterseite des Verzeichnisses erzeugt. Dabei
werden neben dem Titel auch die Eigentümer und die Aktualisierungsdaten der Bookmarklogs ausgegeben. Durch die Ausgabe der Aktualisierungsdaten und die Sortierung der
Bookmarklogs nach diesen Daten kann der Anwender auf einen Blick sehen, wann die verschiedenen Bookmarklogs zum letzten Mal aktualisiert wurden.
Nachdem in diesem Kapitel die Implementierung der Bookmarklogs und im Zusammenhang
mit dieser das Bookmarklogverzeichnis, das der öffentlichen Schicht der social bookmarking
Erweiterung zugeordnet werden kann, vorgestellt wurde, wird im folgenden Kapitel die Realisierung der restlichen Funktionen der öffentlichen Schicht erläutert.
5.4
Implementierung der öffentlichen Schicht der Erweiterung
Neben dem Bookmarklogverzeichnis umfasst die öffentliche Schicht der Erweiterung zwei
weitere zentrale Komponenten: Die Übersicht über den gesamten Bookmarkbestand des Systems und die Schnittstelle zu del.icio.us.
76
5.4.1 Öffentliche Übersichtsseite der Erweiterung
Auf der öffentlichen Übersichtsseite der Erweiterung können sowohl die 10 aktuellsten
Bookmarks der Erweiterung als auch tagspezifische Bookmarks angezeigt werden. Daneben
wird auf dieser eine Liste mit den populärsten Tags des Systems angezeigt sowie eine Freitextsuche angeboten, mit der die Anwender nach bestimmten tagspezifischen Seiten suchen
können. Die Darstellung der Bookmarks in dieser Schicht wurde analog zu der Bookmarkdarstellung in den Bookmarklogs realisiert.
5.4.1.1 Erstellung der Übersichtsseite
Der Handler, der die Übersichtseite erzeugt, kann die 10 aktuellsten Bookmarks mit der
Funktion „getallpublicBookmarks()“ abfragen. In dieser Funktion werden entweder
alle öffentlichen Bookmarks oder, falls der der Bool´sche Wert „True“ an diese übergeben
wird, die zehn aktuellsten Bookmarks des Systems abgefragt und diese sortiert nach deren
Einfügedaten in einem Iterator ausgegeben. Die Ermittlung der öffentlichen Bookmark erfolgt.
Zur Generierung der auf der Übersichtsseite angezeigten Liste der populärsten Tags wurde
die Tatsache, dass die Instanzen des Assettyps „tag“ personenspezifisch sind, genutzt. Wegen
dieser Eigenschaft werden für gleiche Tags, die von verschiedenen Anwendern definiert
wurden, jeweils unterschiedliche Instanzen erzeugt. Damit kann von der Anzahl der Instanzen, die einem bestimmten Tag zugeordnet sind, auf die Zahl der Anwender, welche den Tag
definiert haben, geschlossen werden. Auf dieser Folgerung basiert die im Folgenden dargestellte Funktion „getpopulartags()“, welche die populärsten Tags des Systems ermittelt.
77
public Iterator getpopulartags(){
Vektor pt=new Vektor();
Iterator tn=services.getTags().getTagnames();
while(tn.hasNext()){
String tagname=(String)tn.next();// Der Tag t
if(tagname!=null){
int tused=services.getTags().
Numberofusedtag(tagname);
if(pt.isEmpty()){
pt.add((String)tagname);}
else for(int i=0;i<pt.size();i++){
if(services.getTags().Numberofusedtag
((String)pt.lastElement())>tused){
pt.add((String)tagname);
i=pt.size();}
else if(tused>=services.getTags().
^
Numberofusedtag((String)pt.
elementAt(i))){
pt.add(i,(String)tagname);
i=pt.size();}
}}}
return pt.Iterator();
}
Abb. 33: Die Funktion "getpopulartags"( Quelle: eigene Darstellung )
Der Rückgabewert dieses Algorithmus ist ein „Iterator“, der alle Tags des Systems sortiert
nach deren Popularität enthält. Im ersten Schritt werden alle Tags, die sich in der Erweiterung
befinden, mit der Methode „getTagnames()“ abgefragt. Danach wird für jeden Tag t mit
der Methode „Numberofusedtag()“ die Anzahl der Instanzen bestimmt, denen dieser Tag
zugeordnet wurde. Basierend auf dieser Anzahl wird der Tag t an einer bestimmten Indexposition eines Vektors eingefügt. Dabei muss zwischen drei verschiedenen Fällen unterschieden
werden.
Ist der Vektor leer, kann der Tag t an der ersten Indexposition eingefügt werden. Wurde dem
Tag t weniger Instanzen zugeordnet als der Tag, der sich auf der letzten Indexposition des
Vektors befindet, wird der Tag t an den Vektor angehängt. Ansonsten wird der Vektor iterativ durchlaufen und bei jeder Indexposition überprüft, ob der Tag t mit mehr Instanzen verknüpft ist als der Tag der jeweiligen Indexposition. Wenn dies der Fall ist, so wird dieser an
der aktuellen Indexposition eingefügt. Nachdem alle Tags sortiert in den Vektor eingefügt
wurden, wird dieser in einen Iterator, der schließlich von der Funktion „getpopulartags
()“ zurückgegeben wird, umgewandelt.
Mittels dieser Funktion kann der Handler, der die Übersichtsseite generiert, auf die populärsten Tags des Systems zugreifen und diese zusammen mit den aktuellen Bookmarks, die durch
die Funktion „getallpublicBookmarks()“ abgefragt wurden, in die Übersichtsseite einbetten. Die populären Tags verweisen auf die tagspezifischen Seiten mit den öffentlichen
Bookmarks, die mit diesen Tags verknüpft sind.
78
Beim Aufruf einer tagspezifischen Seite wird nicht - wie bei der Übersichtsseite des Bookmarkaccounts - die TagID an den entsprechenden Handler übertragen, sondern ein Tagwert.
Mit diesem werden zuerst alle Instanzen des Assettyps „Tags“, in denen dieser Tagwert gespeichert ist, abgefragt und dann die Bookmarks, die den jeweiligen Instanzen zugeordnet
wurden, ermittelt. Das ist notwendig, da in den tagspezifischen Seiten nicht nur die Bookmarks eines bestimmten Tagobjektes, sondern die Bookmarks aller Taginstanzen, die mit
einen bestimmten Tagwert verknüpft sind, angezeigt werden sollen. Die beschriebene Vorgehensweise zu Ermittlung der tagspezifischen Bookmarks aller Personen wurde in der Funktion „getAllbookmarksofaTagname()“ realisiert. Die durch diese Funktion ermittelten
Bookmarks werden schließlich zusammen mit der Liste der populären Tags und Liste der
verwandten Tags auf der tagspezifischen Seite angezeigt.
5.4.1.2 Zugriffsmöglichkeiten auf die tagspezifischen Seiten
Generell wird der direkte Zugriff auf eine tagspezifische Seite der öffentlichen Schicht durch
eine Freitextsuche, die auf jeder Seite der öffentlichen Schicht angezeigt wird, oder über eine
spezifische URL ermöglicht.
Über die Freitextsuche kann jeder Anwender durch die Eingabe eines Tags nach der tagspezifischen Seite, die alle mit dem eingegebenen Tag Bookmarks enthält, suchen und direkt auf
diese zugreifen. Dem Eingabefeld der Freitextsuche wurde die „Suggestionsfunktion“ (siehe
Abb. 16) zugeordnet, damit der Anwender bei der Eingabe eines Tags sofort sehen kann,
welche Tags in dem System existieren und für welche Eingaben die Freitextsuche Ergebnisse
anzeigen kann. Nachdem der Suchbegriff eingegeben wurde und der Anwender die Suchanfrage bestätigt hat, wird die entsprechende tagspezifische Seite, auf die gleiche Weise wie bei
den „normalen“ Aufruf dieser Seite, generiert und ausgegeben.
Der direkte Zugriff auf tagspezifische Seiten über eine URL wird durch die Eigenschaft
der Handler ermöglicht mit verschiedenen URLs verknüpft werden zu können. Dadurch kann
der Handler mit einer bestimmten BasisURL assoziiert werden, an die beliebig viele Zeichen
angehängt werden können. Wenn dieser Handler nun aufgerufen wird, kann er auf die Daten,
die der BasisURL zugeordnet wurden, zugreifen und diese für die Verarbeitung des Request
verwenden.
79
Die tagspezifischen Seiten wurden mit die BasisURL „http://<host>:<port>/Tags“ verknüpft,
an welche die Anwender lediglich den Namen des Tags anhängen müssen, dessen Bookmarks auf der angeforderten Seite angezeigt werden sollen. Bei der Generierung der tagspezifischen Seiten kann der entsprechende Handler nun durch die documentId auf den angehängten Tag zugreifen und mit diesem die Bookmarks, die auf dieser Seite darstellt werden sollen,
aus der Datenquelle auslesen. Danach können die ermittelten Bookmarks zusammen mit den
populären und den verwandten Tags in das Template, das schließlich die tagspezifische Seite
ausgibt, eingebettet werden
5.4.2 Implementierung der Importschnittstelle
In der in der öffentlichen Schicht können neben den internen Bookmarks auch externe, von
Del.icio.us importierte Bookmarks dargestellt werden. Da in Del.icio.us den Bookmarks die
gleichen Eigenschaften zugeordnet werden wie den Bookmarks der social bookmarking Erweiterung des Infoasset Brokers, können die externen Bookmarks bis auf einige Abweichungen, auf die später noch eingegangen wird, genauso wie die internen Bookmarks in der Erweiterung dargestellt werden.
Die externen Bookmarks können durch RSS 1.0 Feeds, die von Del.icio.us angeboten werden, in die Erweiterung importiert werden. Wie der nachfolgenden Tabelle zu entnehmen ist,
bietet Del.icio.us verschiedene Feeds an, in denen die Bookmarks in verschiedenen Kontexten dargestellt werden, wodurch in der Importschnittstelle verschiedenen Sichten auf die externen Bookmarks realisiert werden konnten.
Feedtyp
Beschreibung
aktueller Feed
Dieser Feed enthält die Bookmarks, die erst kürzlich eingefügt wurden.( URL: del.icio.us/rss/)
Tagspezifischer Feed
Dieser Feed enthält alle Bookmarks, die einem bestimmten
Tag zugeordnet wurden. (URL: del.icio.us/rss/tag/<tag>)
Personenspezifischer
Feed
Dieser Feed umfasst die Bookmarks einer Person
(URL: del.icio.us/rss/<person>)
Tag- und personenspezi- Dieser Feed enthält tagspezifische Bookmarks einer Person
fischer
(URL: del.icio.us/rss/<person>/<tag>)
Feed
Urlspezifischer Feed
Dieser Feed umfasst die Bookmarks, die einer bestimmten
URL zugeordnet sind.
(URL: del.icio.us/rss/url?url=<URL>)
Tab. 4: Typen des Exportfeeds ( Quelle: eigene Darstellung )
80
Da die verschiedenen Exportfeeds höchstens die 30 aktuellsten Bookmarks der entsprechenden Kategorie enthalten, ist es nicht möglich, den ganzen Bookmarkbestand von Del.icio.us
in die Erweiterung zu importieren und dort darzustellen.
5.4.2.1 Import externer Bookmarks
Die Generierung der Importseite erfolgt wie bei den anderen Übersichtsseiten durch einen
Handler, der die Bookmarks in ein Template einbettet. Bei der Ermittlung der Bookmarks
kann der Handler allerdings nicht wie sonst auf interne Assets zugreifen, sondern muss die
erforderlichen Daten aus den Feeds, die von Del.icio.us angefordert werden, auslesen. Da
Feeds XML-Dokumente sind, müssen diese geparst werden, bevor der Handler auf deren
Inhalte zugreifen und diese verarbeiten kann. “Das Ergebnis eines vom Parser bearbeiteten
Dokumentes ist üblicherweise eine Datenstruktur, die durch andere XML-Werkzeuge oder
durch Java-APIs manipuliert und bearbeitet werden kann“ [MCL02]. Die XML-Werkzeuge,
mit denen die durch das Parsen erzeugte Datenstruktur bearbeitet wird, werden durch die
Jena-API bereitgestellt. Die Jena-API wurde speziell für das Parsen und die Verarbeitung von
RDF-basierten Dokumenten entwickelt und kann somit für die Verarbeitung der Feeds, die
von Del.icio.us angeboten werden, eingesetzt werden.
Durch das Parsen eines Feeds wird ein Graph erzeugt, der die verschiedenen Ressourcen eines Feeds als Tripel darstellt, welche jeweils aus den Elementen
•
Ressource
•
Property
•
Value
bestehen. Das Element Ressource enthält die Bezeichnung der Ressource, die in dem jeweiligen Tripel beschrieben wird. Der Ressource werden Properties zugeordnet, welche die Eigenschaften der Resource symbolisieren und mit denen die konkreten Ausprägungen der Eigenschaften durch das „Value“-Element verknüpft werden. Bei der graphischen Darstellung
eines Tripel, werden die Ressourcen als Ellipse, die Properties als Kanten und die Values als
Rechtecke dargestellt. In der folgenden Darstellung wird ein graphisches Tripel, das einen
Bookmark beschreibt, abgebildet.
81
Abb. 34: Graphische Darstellung eines RDF-Tripels ( Quelle: eigene Darstellung )
Nachdem alle Ressourcen eines Feeds als Tripel in den Graphen eingefügt worden sind, können nun bestimmte Informationen mit der Anfragesprache „RDQL“ aus dem Graphen abgefragt werden. Der Syntax von „RDQL“ ähnelt dem SQL-Syntax, da in dieser Anfragesprache
ebenfalls die Rückgabewerte der Anfrage in einer „Select-Klausel“ und die Anfragestatements in einer „Where-Klausel“ angegeben werden müssen. Doch die in SQL übliche „FromKlausel“ wird in RDQL nicht benötigt, da sich jede Query auf den Graphen des zuvor geparsten Feeds bezieht.
Die Anfragestatements der „Where-Klausel“ setzen sich jeweils aus den drei Elementen Resource, Property und Value zusammen, die den Elementen eines Tripels des Graphen entsprechen. Innerhalb eines Prädikats werden diejenigen Elemente durch einen Platzhalter,
welcher durch ein vorgestelltes Fragenzeichen markiert wird, ersetzt, die durch die Query
abgefragt werden sollen. Dadurch ist es möglich, jedes Element eines Tripels abzufragen. Die
in der folgenden Abbildung dargestellte Query gibt beispielsweise den Namen der Person
zurück, die einen Bookmark für die URL „http//www.google.de“ (vgl. Abb. 34 ) gespeichert
hat.
SELECT ?creator
WHERE (<http://www.google.de>,<dc:creator>,?creator)
USING dc FOR http://purl.org/dc/elements/1.1/"
Abb. 35: Struktur einer RDQL-Anfage ( Quelle: eigene Darstellung )
Die Klausel „USING“ definiert den Namespace der Property, die in der Where-Klausel verwendet wird. Die Zuordnung der Namespace zu den Properties ist notwendig, da es sein
82
kann, dass in einer Query mehrere verschiedene Properties mit dem gleichen Bezeichner, die
sich nur anhand ihrer Namespaces unterscheiden lassen, vorkommen können. Falls eine Query ein Ergebnis, welches von mehreren Bedingungen abhängt, oder mehrere Ergebnisse, wie
zum Beispiel das Datum und den Autor eines bestimmten Bookmarks, zurückgeben soll, können in einer Query auch mehrere Anfragestatements beziehungsweise Platzhalter definiert
werden (siehe Abb. 36).
SELECT ?creator, ?date
WHERE (<http://www.google.de>,<dc:creator>,?creator),
(<http://www.google.de>,<dc:date>,?date)
USING dc FOR <http://purl.org/dc/elements/1.1/">
Abb. 36: Query mit verschiedenen Where-Klauseln( Quelle: eigene Darstellung)
Mittels der Jena-API und RDQL können nun die RSS 1.0 Feeds, mit denen die Bookmarks
von Del.icio.us in den Infoasset Broker importiert werden, geparst und die relevanten Eigenschaften der Bookmarks aus diesen extrahiert werden.
5.4.2.2 Darstellung der importierten Bookmarks
Wenn ein Anwender eine Übersichtsseite der Importschnittstelle aufruft, wird ein Handler
aktiviert, der einen Bookmarkfeed von Del.icio.us anfordert. Welcher Feedtyp (siehe Tab. 4)
dabei gewählt wird, hängt von den Parametern ab, die an den Handler übergeben werden.
Nachdem der Feed angefordert wurde, kann dieser durch die Methoden der Jena-API geparst
werden und die Ressourcen des Feeds in einen RDF-Graph eingefügt werden. Aus diesem
Graph können nun in zwei Schritten die Eigenschaften der Bookmarks ausgelesen und dem
Handler zur Weiterverarbeitung zur Verfügung gestellt werden.
Im ersten Schritt werden durch die Funktion „getDeliciousBookmarks“ alle URLs aus dem
Feed ausgelesen, über die auf die Items, welche die Eigenschaften der Bookmarks enthalten,
zugegriffen werden kann. Die ausgelesenen URLs werden von dieser Funktion in einen Iterator zurückgegeben
Im zweiten Schritt wird mit diesen URLs iterativ auf die einzelnen Items des Feeds zugegriffen und deren Eigenschaften mit einer RQL-Query ausgelesen. Da in Del.icio.us die
Bookmarkeigenschaften „Beschreibung“ und „Tag“ nicht jeden Bookmark zugeordnet werden müssen, können die verschiedenen Items des Importfeeds unterschiedlich viele Eigenschaften enthalten. Aus diesem Grund muss für jedes Item ermittelt werden, welche Eigenschaften dieses enthält und eine entsprechende Query definiert werden. Mit einem so bestimmten Query werden die Eigenschaften eines Items und somit die Eigenschaften eines
83
Bookmarks ausgelesen und in einem „Resultbinding“ zurückgegeben. In dieser Datenstruktur
liegen die Eigenschaften als Wertpaare vor, sodass auf die einzelnen Eigenschaften über die
jeweils dazugehörigen Variablen zugegriffen werden kann
Die importierten Bookmarks müssen nun durch eine Listsubstitution in das Template,
das schließlich die Übersichtsseite der Importschnittstelle darstellt, eingebettet werden. Wie
in den vorigen Kapiteln schon ausgeführt wurde, müssen für Listsubstitutions die vier
Funktionen Start(), hasNext(), Next() und Init() definiert werden. Der Funktion
„Start“ wird in diesem Fall der Iterator mit den URLs übergeben, die durch die Funktion
„getDeliciousBookmarks()“ ermittelt wurden. Für jedes Element dieses Iterators ruft
die Funktion „Next“ die Hilfsfunktion „getBookmarks()“ auf. Diese Funktion liest die
Eigenschaften des Item-Elementes, das mit der URL, die der Funktion übergeben wird, verknüpft ist, aus dem importierten Feed aus und gibt diese in einem Resultbinding zurück. Dieses Resultbinding wird schließlich an die Funktion „init()“ übergeben, welche die Eigenschaften des Bookmarks in das Template einbettet.
In der Übersicht der Importschnittstelle können Seiten mit den aktuellen, den tagspezifischen, den personspezifischen oder den personenund tagspezifischen Bookmarks von
Del.icio.us dargestellt werden. Jede dieser Seiten wird mit der – im vorherigen Abschnitt
beschriebenen – Vorgehensweise erzeugt, wobei in Abhängigkeit davon, welche Bookmarks
diese Seite enthalten soll, jeweils unterschiedliche Feeds (siehe Tab. 4) geparst und verarbeitet werden müssen.
Auf den tagspezifischen Seiten der Importschnittstellen werden - analog zu den tagspezifischen Seiten der anderen Übersichtseiten der Erweiterung - neben den Bookmarks die verwandten Tags des selektierten Tags angezeigt. Da aber Del.icio.us die verwandten Tags eines
Tags nicht explizit in einen Feed exportiert, müssen diese Tags durch die Verarbeitung von
tagspezifischen Feeds ermittelt werden. Um dies zu vereinfachen und um den teilweise zeitaufwändigen Parsingprozess zu optimieren, wurde für diesen Fall die Definition der verwandten Tags leicht abgeändert. Die geänderte Definition besagt, dass zwei Tags miteinander
verwandt sind, wenn diese mindestens einen gemeinsamen Bookmark haben. Demnach sind
in einem tagspezifischen Feed des Tags t alle Tags, die mit mindestens einem Bookmark dieses Feeds verknüpft sind, mit t verwandt. Die verwandten Tags eines Tags t können somit
durch das Abfragen der Ausprägungen der dc:Subject Eigenschaften der verschiedenen
Items, welche die Tags der Bookmarks darstellen, eines tagspezifischen Feed ermittelt werden. Diese Abfrage wird durch folgende Query realisiert :
84
Select ?tags
WHERE (?y <http://purl.org/dc/elements/1.1/subject> ?tags)
Abb. 37: Query: Abfrage der verwandten Tags ( Quelle: eigene Darstellung )
Da es aber sein kann, dass manche Tags mehreren Bookmarks zugeordnet wurden und diese
bei der Ausführung der Query redundant in dessen Ergebnismenge eingefügt werden, müssen
die doppelten Tags aus dieser entfernt werden. Die Entfernung der doppelten Tags erfolgt
dadurch, dass die Tags iterativ aus der Ergebnismenge ausgelesen und in einen Vektor eingefügt werden, wenn diese sich noch nicht darin befinden. Nachdem alle Tags in diesen eingefügt wurden und somit alle redundanten Tags beseitigt wurden, wird dieser in einen Iterator
umgewandelt, der schließlich an die Listsubstitution, welche die Tagliste in das entsprechende Template einbettet, übergeben wird.
Auf den personenspezifischen Seiten werden neben den Bookmarks die personenspezifischen Tags ausgegeben. Diese Tags können durch die Abfrage der dc:subject Eigenschaften der Items eines personenspezifischen Feeds ermittelt werden. Somit können diese Tags
auf eine ähnliche Weise wie die verwandten Tags ermittelt werden (s.o.).
Die verschiedenen Seiten dieser Übersicht sollten ebenfalls wie bei den anderen Übersichtsseiten vor allem über die Bookmarkdarstellung miteinander verknüpft werden. Darum wird
jeder Bookmarkdarstellung sowohl der Eigentümername, der auf die personenspezifische
Seite der Exportschnittstelle verweist, als auch die Tags, die auf die tagsspezifischen Seiten
verweisen, zugeordnet.
Außerdem können die tagspezifischen Seiten über eine Freitext-Suche, mit der nach beliebigen Tags gesucht werden kann, aufgerufen werden. Dieser wurde ebenfalls - wie bei der Freitextsuche der Übersichtsseite der internen Bookmarks (siehe Kap. 5.4.1.2) - eine Suggestionsfunktion zugeordnet.
5.4.2.3 Kommentarfunktion
Jede Bookmarkdarstellung der Importschnittstelle ist mit einer Kommentarfunktion verknüpft. Diese Funktion wird nicht - wie bei den sonstigen Übersichten - durch die Angabe,
wie viele Anwender einen bestimmten Bookmark verwenden, den Bookmarkdarstellungen
hinzugefügt, sondern durch einen gesonderten Link. Diese Art der Verknüpfung der Kommentarfunktion mit der Bookmarkdarstellung wurde verwendet, da die Ermittlung der Anzahl
der Bookmarks, die für eine URL definiert wurden, aus folgenden Gründen nicht effizient
85
möglich war. Zum einen wird diese Anzahl nicht direkt in den Importfeeds angegeben. Zum
anderen könnte diese Anzahl durch das Zählen der Bookmarks, die sich in einem URLspezifischen Feed (siehe Tab. 4: Typen des Exportfeeds) befinden, ermittelt werden. Da aber
bei diesem Vorgehen für jeden Bookmark ein URL- spezifischer Feed geparst und dessen
Items gezählt werden müssten, würde sich die Ladezeiten der Übersichtsseiten über ein akzeptierbares Maß hinaus verlängern.
Die Erstellung und die Ausgabe der Kommentarliste zu einem Bookmark erfolgt auf die gleiche Weise wie bei den anderen Übersichtsseiten: Durch den Aufruf der Kommentarfunktion
wird ein AJAX-basiertes Javascript aktiviert, das in Interaktion mit der serverseitigen Logik
eine Kommentarliste erstellt und diese in die angezeigte HTML-Seite unterhalb des Bookmarks, für den die Kommentare angezeigt werden sollten, einbettet10. In diesem Fall können
die Kommentare zu einem Bookmark aus der Eigenschaft „Description“ der verschiedenen
Items eines URL-Spezifischen Feeds( siehe Tab. 5) ausgelesen werden.
Da der Import der Bookmarks durch Feeds erfolgt, die von einem externen Server angefordert werden, kann auf die Importschnittstelle nur zugegriffen werden, wenn eine Verbindung
zum Internet besteht.
5.5
Implementierung weiterer Funktionen
Neben den in den vorigen Kapiteln vorgestellten Funktionen wurden noch weitere Funktionen implementiert, die weder dem Bookmarkaccount noch der öffentlichen Schicht der Erweiterung eindeutig zugeordnet werden können. Die Funktionen ermöglichen es, einerseits
die social bookmarking Erweiterung enger mit der Umgebung des Infoasset Brokers zu verknüpfen und andererseits Bookmarks mittels Webservices zu exportieren bzw. zu importieren.
5.5.1
Funktion: „Quick save“
Mittels der Funktion „Quick save“ kann jeder Anwender jede beliebige Seite des Infoasset
Brokers in der Erweiterung speichern. Dadurch wird es den Anwendern ermöglicht, Bookmarks für die Seiten des Infoasset Brokers, die für sie relevant sind, zu definieren und in ihren Bookmarkaccounts zu speichern.
10
Die Generierung der Kommentarliste ist in Kapitel 5.2.2.2 detailliert beschrieben.
86
Die Funktion „Quick save“ wurde durch ein so genanntes Bookmarklet realisiert, das sich auf
der rechten Seite der Oberfläche des Infoasset Brokers befindet. Will ein Anwender die Seite,
auf der er sich gerade befindet, speichern, muss er lediglich das Bookmarklet anklicken, woraufhin sich das Einfügeformular seines Bookmarkaccounts öffnet. In diesem Formular, dessen URL-Feld mit der URL der Seite, die gespeichert werden soll, vorbelegt ist, kann er nun
den entsprechenden Bookmark definieren und anschließend speichern.
Die Oberfläche des Infoasset Brokers hat eine Frame-Struktur, die diese in verschiedene
Frames, die unterschiedliche Inhalte enthalten und jeweils durch eine eindeutige URL adressierbar sind, untergliedert. Drei dieser Frames, die nebeneinander positioniert sind, kann die
Funktionalität des Infoasset Brokers hauptsächlich zugeordnet werden. Im „linken Frame“
wird das Menü, aus dem der Anwender die verschiedenen Funktionen des Systems auswählen kann, angezeigt. Bei einem Funktionsaufruf wird die Seite, welche die Funktion darstellt,
im mittleren Frame angezeigt und im rechten Frame, in dem sich das Bookmarklet befindet,
werden weitere Funktionalitäten wie beispielsweise Suchfunktionen angeboten. Da die Inhalte des rechten und linken Frame statisch sind und die verschiedenen Funktionsseiten nur im
mittleren Frame dargestellt werden, muss, falls ein Anwender eine bestimmte Seite speichern
will, nur die URL des mittleren Frames einem Bookmark zugeordnet werden. Basierend auf
dieser Eigenschaft der Oberfläche wurde das Bookmarklet implementiert.
Nachdem ein Anwender das Bookmarklet angeklickt und somit die Funktion „Quick save“
aufgerufen hat, wird ein Javascript ausgeführt, welches auf das Frame-Objekt des mittleren
Frames zugreift und dessen URL ausliest. Diese URL wird an einen Handler übertragen, der
das Einfügeformular des Bookmarkaccounts, in dem der Bookmark gespeichert werden soll,
erzeugt. Bei der Erzeugung des Formulars, die im Kapitel 5.2.1 näher beschrieben wurde,
wird dessen URL-Eingabefeld mit der übergebenen URL vorbelegt. Nach der Ausgabe des
Formulars kann der Anwender den Bookmark für die ausgewählte Seite definieren und diesen abschließend speichern.
5.5.2 Funktion: „Quick Info“
Die Funktion „Quick Info“ ist sozusagen die Komplementärfunktion zu „Quick save“. Wenn
ein Anwender diese Funktion aufruft, so wird ein „Popup“-Fenster geöffnet, das alle Bookmarks anzeigt, welche für die Seite, auf der sich der Anwender momentan befindet, definiert
wurden. Dadurch kann sich der Anwender beispielsweise darüber informieren, welche
Kommentare durch die Bookmarks der aktuellen Seite zugeordnet wurden.
87
Bei der Ausführung dieser Funktion wird, wie bei „Quick save“ ein Javascript aufgerufen,
welches die URL des mittleren Frames ermittelt und diese an einen Handler übergibt. Der
Handler kann nun durch die Funktion „getBookmarkofanURL()“ die Bookmarks, die für
die übermittelte URL definiert wurden, auslesen und diese durch eine Listsubstitution
in das Template, welches das „Pop-up“ Fenster schließlich anzeigt, einfügen.
Die Bookmarks, die das „Pop-up“ Fenster darstellt, sind weder mit einer Kopierfunktion
noch mit einer Kommentarfunktion verknüpft, da diese legendlich als Kommentare zu einer
bestimmten Quelle fungieren sollen.
5.5.3 Erweiterung der Startseite des Infoasset Brokers
Um die social bookmarking Erweiterung mit der Startseite des Infoasset Brokers zu verknüpfen, wurden für diese Seite zwei Übersichten, die zum einen die 10 aktuellsten Bookmarks
und zum anderen die 10 populärsten Tags der Erweiterung enthalten, realisiert. Für die Implementierung dieser zwei Übersichten konnten die gleichen Funktionen verwendet werden
wie für die Generierung der Übersichtsseite der öffentlichen Schicht der Erweiterung (siehe
Kap 5.4.1), da auf dieser ebenfalls die zehn aktuellsten Bookmarks und die populären Tags
dargestellt werden. Somit können die aktuellen Bookmarks durch die Funktion „getallpublicBookmarks (boolean limit)“ und die populärsten Tags durch die Funktion
„getpopulartags“ (siehe Kap. 5.4.1) für die Übersichten ermittelt werden. Die Substitutionen,
welche die ermittelten Bookmarks bzw. Tags in die Übersichten einfügen, wurden in den
schon bestehenden Handler, der die Startseite des Infoasset Brokers erzeugt, definiert. .
Die Bookmarks werden auf der Startseite in einer gekürzten Form dargestellt. Dies bedeutet,
dass die Bookmarkdarstellungen lediglich aus dem Bookmarktitel, der zu dessen Verweisziel
verlinkt ist, dem Namen des jeweiligen Bookmarkeigentümers und dessen Einfügedatum
besteht. Diese Darstellungsart wurde gewählt, da auf der Startseite jeweils nur die wesentlichen Informationen über die verschiedenen Objekte des Infoasset Brokers dargestellt werden
sollen, damit sich die Anwender auf der Startseite einen gezielten Überblick über den Systemzustand verschaffen können. Sollte sich ein Anwender dennoch für Eigenschaften eines
Bookmarks näher interessieren, kann er direkt über einen Link, der sich oberhalb der Übersicht befindet, auf die Übersicht der öffentliche Schicht der social bookmarking Erweiterung,
in der die Bookmarks im vollen Umfang dargestellt werden, zugreifen.
88
5.6
Webservices
Webservices sind verteilte Anwendungen, die über die Kommunikationskanäle des Internets
(bzw. Intranet) Nachrichten austauschen können. Mit diesen Webservices konnte für die social bookmarking Erweiterung einerseits eine von der Feedtechnologie unabhängige Exportschnittstelle für Bookmarks bzw. Tags und andererseits eine Importschnittstelle für Bookmarks realisiert werden. Die Webservices wurden nicht für die Interaktion mit einem speziellen Clientsystem sondern als eine generelle Schnittstelle zu der Erweiterung entwickelt. Aus
diesem Grund mussten beim Entwurf der XML-Dokumente, welche die Nachrichten der
Webservices darstellen, keine besonderen Anforderungen berücksichtigt werden. Dennoch
wurde darauf geachtet, dass diese eine ähnliche Struktur wie die Dokumente des Webservices, der von Del.icio.us angeboten werden, aufweisen, damit die Webservices der Erweiterung leicht in Clientanwendungen, die schon mit Del.icio.us interagieren, integriert werden
können.
Die Implementierung der Webservices basiert auf der „Representational State Transfer“
(REST) Architektur. Der REST-Architektur liegt die zugrunde, dass jede beliebige Ressource, die mit einer eindeutigen URI identifizierbar ist, in einer maschinenlesbaren Form z. B.
XML-Dokument, dargestellt werden kann. Die Darstellung einer Ressource wird von einem
Server bereitgestellt und kann durch einen HTTP-Request von einem Client angefordert und
verarbeitet werden. Diese Client-Server Kommunikation hat laut Roy Fielding, der im Rahmen seiner Dissertation „Architectural Styles and the Design of Network-based Software Architectures“ die REST-Architektur entwickelt und beschrieben hat, folgende Merkmale (vgl.
[LAN02]):
•
Die Kommunikation findet zwischen einem Server und einem Client statt.
•
Jeder Request, mit der eine Ressource angefordert wird, ist gültig, damit dieser vom
Server verarbeitet werden kann.
•
Jede Ressource, die an der Kommunikation beteiligt ist, hat eine eindeutige URI.
•
Die Antwort (Darstellung einer Ressource) des Servers kann „gepuffert“ oder auch
„nicht gepuffert“ an den Client übermittelt werden.
•
Die Ressourcen, die durch den Server angeboten werden, sind durch eine fest definierte Schnittstelle erreichbar.
89
•
Gleichen Darstellungen einer Ressource können verschiedene URIs zugeordnet werden.
•
Die Darstellungen verschiedener Ressourcen können untereinander verlinkt werden.
Wenn die vorgestellten Bedingungen erfüllt sind, kann eine REST-basierte Client-Server
Kommunikation erfolgen und der Webservice, welcher durch einen Client angefordert wurde,
ausgeführt werden.
Für die social bookmarking Erweiterung wurden verschiedene Webservices, die in folgender
Tabelle dargestellt werden, zum Export (bzw. Import) von Bookmarks oder Tags, realisiert.
Typ des Webservices
Export von aktuellen
Bookmarks
Export von tagspezifische Bookmarks
Export von personenund tagspezifischen
Bookmarks
Export von populären
Tags
Export von personspezifischen Tags
Bookmarks einfügen
URL des Webservices
http://<host>:<port>/api/bookmarks
http://<host>:<port>/api/bookmarks?tag=<tag>
http://<host>:<port>/api/bookmarks?tag=<tag>&person=<Login>
http://<host>:<port>/api/tags
http://<host>:<port>/api/tags?person=<login>
http://<host>:<port>/api/add?person=<Login>
&passwort=<Passwort>
&titel=<Title>
&tag=<Tags>
&url=<Url>
&beschreibung=<Beschreibung>
&sichtbarkeit=<privat | public>
Tab. 5: Webservices der Erweiterung ( Quelle: eigene Darstellung )
Wie dieser Tabelle zu entnehmen ist, können die Clientsysteme über eine „BasisURL“
(http://<host>:<port>/api) auf die Webservices der Erweiterung zugreifen. Wenn ein Webservice angefordert und somit die BasisURL aufgerufen wird, wird der WebserviceHandler
aktiviert, der den eingehenden Request überprüft. Nachdem der Request erfolgreich verifiziert wurde, greift der WebserviceHandler über die „documentId“ auf die Zeichenkette, die
der „BasisURL“ angehängt wurde, zu. In Abhängigkeit des Inhaltes der Zeichenkette, leitet
der WebserviceHandler den Request an einen anderen Handler weiter, der schließlich den
90
angeforderten Webservice ausführt. Wurde der BasisURL das Wort „Bookmarks“11 angehängt, so wird eine bestimmte Bookmarkliste angefordert. Wenn dagegen die BasisURL mit
dem Wort „Tags“12 ergänzt wurde, wird eine Liste mit Tags abgefragt. Ansonsten soll, falls
die BasisURL das Wort „add“13 enthält, ein neuer Bookmark in das System eingefügt werden.
5.6.1 Webservice: Export von Bookmarklisten
Wenn eine Bookmarkliste angefordert wird, kann anhand der Parameter, die dem Request
zugeordnet wurden, festgestellt werden, welche Bookmarks diese enthalten soll:
•
Werden keine Parameter an den Handler übergeben, so wird eine Bookmarkliste mit
den 10 aktuellsten Tags ausgegeben
•
Wird der „Login“ einer Person mit diesem, Request übergeben, so wird eine Liste
mit allen Bookmarks dieser Person angefordert.
•
Wird sowohl der Login als auch ein Tag an diesen Request angehängt, so werden die
tagspezifischen Bookmarks dieser Person ausgegeben.
Wenn als Parameter ein Login einer Person an den Handler übergeben wird, so wird überprüft, ob dieser Login in dem System existiert und ob die Person, die mit diesem Login identifiziert werden kann, über einen Bookmarklog verfügt. Ist dies nicht der Fall, so wird die
Verarbeitung des Requests abgebrochen und ein XML-Formular, welches eine Fehlermeldung (siehe Abb. 38) enthält, als Antwort auf den Request ausgegeben.
Abb. 38: Fehlermeldung bei einen fehlgeschlagenen Request ( Quelle: eigene Darstellung )
11
DocumentId: api/Bookmaks
DocumentId: api/tags
13
DocumentId: api/add
12
91
Ansonsten wird der Request an den Handler14, der den Webservice für Bookmarks ausführt,
weitergeleitet. Für den Fall, das die tagspezifischen Bookmarks einer Person angefordert
wurden, überprüft der Handler, ob diese Person den Tag, dessen Bookmarks ausgegeben
werden sollen, definiert hat. Wird der entsprechende Tag nicht von dieser Person verwendet,
so gibt der Handler eine Fehlermeldung (vgl. Abb. 34) aus, ansonsten wird die Generierung
des XML-Dokumentes, welches die angeforderten Bookmarks enthält, angestoßen.
Bei der Erzeugung des Dokumentes werden alle Eigenschaften der Bookmarks, die auch bei
der Darstellung der Bookmarks auf den verschiedenen Übersichtsseiten ausgegeben werden,
in dieses eingebettet. Somit war es möglich, bei der Implementierung des Handlers auf bereits bestehende Funktionen zur Ermittlung der Bookmarks zurückzugreifen, die schon für
die Erstellung der verschiedenen Übersichtseiten verwendet wurden. Aus diesem Grund wird
an dieser Stelle nicht auf die Ermittlung der Bookmarks, welche in die Antwortdokumente
eingefügt werden sollen, eingegangen.
Die folgende Abbildung stellt beispielhaft ein XML-Dokument dar, welches durch diesen
Handler generiert und als Antwort auf einen angeforderten Webservice ausgegeben werden
kann.
Abb. 39:Antwortdokument eines Webservices ( Quelle: eigene Darstellung )
Wie in dieser Abbildung zu sehen ist, beginnt das Antwortdokument mit einem posts Tag,
in dem der Inhalt des Antwortdokumentes anhand verschiedener Attribute beschrieben wird.
Das „Type“- Attribut gibt an, welche Art von Bookmarks, in diesem Fall „tagspezifische
Bookmarks“, sich in diesem Dokument befinden und dem Attribut „Tag“ wird der Tag, mit
dem die Bookmarks des Dokumentes verknüpft sind, zugeordnet. Bei personenspezifischen
Dokumenten hat das posts Tag dagegen das Attribut „Person“, das den Name der Person,
dessen Bookmarks angefordert wurde, darstellt. Die einzelnen Bookmarks werden jeweils
durch post Tags, deren Attribute die Eigenschaften des jeweiligen Bookmarks enthalten, in
das Antwortdokument eingefügt. In den Attribut „others“ des post Tags wird Anzahl der
Bookmarks angegeben, welche auf die gleichen URL verweisen wie der in den jeweilige
postTag dargestellte Bookmark. Die anderen Attribute dieses Tags sind selbsterklärend und
benötigen deshalb keine näheren Erläuterungen.
14
xmlbookmarkhandler
92
Durch die Ausgabe des Antwortdokumentes wird die Ausführung des Webservices schließlich beendet.
5.6.2 Webservice: Export von Taglisten
Wie schon im Kapitel 5.6 beschrieben wurde, können nicht nur Bookmarks sondern auch
Tags durch die Webservices angefordert werden. Diese Webservices ermöglichen die Abfrage von populären oder personspezifischen Tags und werden durch den „XMLltaghandler“
realisiert. Wenn ein Request durch den Webservicehandler an diesen Handler weitergeleitet
wird, so wird anhand der übergebenen Requestparameter überprüft, welche Tagliste angefordert wurde. Wurden dem Request keine Parameter zugeordnet, so wird eine Liste mit den
populärsten erzeugt, ansonsten wird, wenn ein Benutzername einer Person mit dem Request
verknüpft ist, eine Liste mit den Tags dieser Person ausgegeben. Nachdem die Art des zu
erbringenden Webservices ermittelt wurde, wird das Antwortdokument erzeugt.
Soll eine Liste der populären Tags in das Antwortdokument eingefügt werden, so können
deren Elemente mit der Funktion „getpopularTags()“, die im Kapitel 5.4 vorgestellt
wurde, ermittelt werden. Ansonsten werden die Elemente für eine personspezifische Tagliste
mit der Funktion „getTagsOfaPerson“ aus der Datenquelle ausgelesen.
Die durch eine der beiden Funktionen ermittelten Tags werden nun in ein Template, welches
die Struktur des Antwortdokumentes des Webservices darstellt, eingebettet. Das Antwortdokument enthält ebenso wie das Antwortdokument, das von den „Bookmark Webservices“
generiert wird, die Tags posts und post. In dem posts Tag wird die Art des angeforderten
Webservices durch das Attribut „typ“ angegeben. Daneben wird, falls personenspezifische
Tags angefordert wurden, dem posts Tag das Attribut „Person“ zugeordnet, das mit dem
Namen der Person, dessen Tags sich in den Antwortdokument befinden, verknüpft ist.
Die verschiedenen Tags werden anschließend durch post Tag in das Antwortdokument eingebettet. Diesen Tags wird durch das Attribut „Number“ die Anzahl der Anwender, welche
den jeweils dargestellten Tag definiert haben, zugeordnet.
5.6.3 Webservice: Import von Bookmarks
Der Webservice „Bookmarks einfügen“ ermöglicht es den Anwendern, über die Befehlszeile
des Browsers Bookmarks in die Erweiterung einzufügen ohne den Infoasset Broker laden zu
müssen. Wenn ein Anwender diesen Webservice aufruft, muss er neben den Eigenschaften
93
des Bookmarks, den er einfügen will, auch sein Login und Passwort angeben, da nur autorisierte Anwender den Webservice nutzen dürfen.
Nachdem die Ausführung des Webservices angestoßen wurde, überprüft der WebserviceHandler, ob alle Eigenschaften, die für die Erzeugung eines Bookmarks definiert werden
müssen und die Benutzerdaten des Anwenders an entsprechenden Servicerequest angehängt
wurden. Ist dies der Fall, so wird der Request, an den „GetdigestHandler“ weitergeleitet, um
die eingegebenen Benutzerdaten zu verifizieren. Für diese Verifizierung wird ein zweiteiliger
Autorisierungsprozess ausgeführt, der auch für die Autorisierung eines Anwenders, der sich
beim Infoasset Broker anmelden will, verwendet wird. Im ersten Schritt des Autorisierungsprozesses wird mittels des „MD5“ Algorithmus des Anbieters „RSA Data Security“ das eingegebene Login und das Passwort zusammen mit einem Lizenzierungscode („nonce“) chiffriert und ein eindeutiger Schlüssel erzeugt. Danach wird im zweiten Schritt dieser Schlüssel
zusammen mit denn Login gegenüber dem „Lightweight Directory Access Protocol“ verifiziert. Ist diese Verifikation erfolgreich, so sind die Benutzerdaten gültig und der Bookmark
kann in das System eingefügt werden.
Da der „MD5“ Algorithmus in einem Javascript implementiert wurde, müssen die Benutzerdaten, die mit dem Servicerequest an den WebserviceHandler übergeben werden, wieder in
ein HTML-Dokument eingebettet werden, um die Chiffrierung dieser Daten zu ermöglichen.
Dies erfolgt mit dem „GetdiggestHandler“, an den der Request weitergeleitet wird. Der „GetdiggestHandler“ fügt die übergebenen Parameter zusammen mit dem Lizenzierungscode in
ein HTML-Dokument ein, welches lediglich die Javascriptfunktion „requestdigest“ mit den
Parametern, die in dieses eingebettet wurden, aufruft. Die Funktion „requestdigest“ aktiviert
den „MD5“-Algorithmus, welcher die Benutzerkennung chiffriert. Der dadurch erzeugte
Schlüssel wird anschließend zusammen mit der Benutzerkennung und den restlichen Parametern, die für die Definition des Bookmarks notwendig sind, an den „Addbookmarkhandler“
übergeben. Dieser Handler setzt die Verifizierung der Benutzerkennung fort, indem er den
Schlüssel, der durch den „MD5“- Algorithmus erzeugt wurde, gegenüber des „Lightweight
Directory Access Protocols“ verifiziert. Kann durch diese Überprüfung die Gültigkeit der
Benutzerdaten nicht bestätigt werden, so wird die Ausführung des Webservices abgebrochen
und ein Antwortdokument, das eine Fehlermeldung enthält (siehe Abb. 38), ausgegeben. Ansonsten wird der angeforderte Webservice ausgeführt und ein Bookmark mit den Eigenschaften, die mit dem Servicerequest verknüpft waren, erzeugt. Die Erzeugung des Bookmarks
erfolgt dabei analog zu der Erzeugung eines Bookmarks, der über das Formular des Bookmarkaccounts definiert wurde (siehe Kap. 5.2.1) .Nachdem der Bookmark erstellt wurde,
94
wird ein XML-Dokument, welche eine Bestätigungsmeldung enthält, ausgegeben und die
Ausführung des Webservices abgeschlossen.
Nachdem in diesen Kapiteln die konkrete Realisierung der social bookmarking Erweiterung
vorgestellt wurde, werden im nächsten Kapitel verschiedene Möglichkeiten zur Weiterentwicklung dieser Erweiterung vorgestellt.
95
6
Ausblick
Nachdem in den vorigen Kapiteln die Realisierung der social bookmarking Erweiterung beschrieben wurde, werden in diesem Kapitel Erweiterungsmöglichkeiten vorgestellt, mit denen die Funktionalität der Erweiterung optimiert oder erweitert werden kann.
Eine Weiterentwicklungsmöglichkeit wäre, dass Anwender nicht nur Bookmarks, sondern
auch Fotos oder sonstige Graphiken in der Erweiterung verwalten oder austauschen können.
Diese könnten auf die gleiche Art und Weise wie Bookmarks beschrieben und mit Tags kategorisiert werden, so dass die Erweiterung Beziehungen zwischen den Bildern herstellen und
diese automatisiert sortieren könnte. Dadurch wäre die Erweiterung imstande, Fotoalben automatisiert zu erstellen, die zum Beispiel die Bilder einer Reise chronologisch darstellen. Die
Sortierung der Bilder innerhalb der Fotoalben könnte durch die Anwender dann beliebig
überarbeitet werden, so dass diese nicht mehr nach den Daten der Aufnahmen, sondern nach
Themengebieten geordnet dargestellt werden (z.B. nach Städten bei einer Rundreise). Außerdem wäre es möglich, eine Importschnittstelle zu dem Fotosharing Anbieter „Flickr“15, der
einen Exportfeed für dessen Bilder anbietet, zu realisieren. Die importierten Bilder könnten
dann innerhalb des Infoasset Brokers dargestellt werden.
Daneben wäre eine Implementierung zusätzlicher anwendungsspezifischer Schnittstellen für
die social bookmarking Erweiterung sinnvoll. So könnte zum Beispiel eine Schnittstelle zu
der Desktopmanagementsoftware „Personal Brain“, die unter anderem auch Bookmarks verwaltet, für die Erweiterung entwickelt werden. Eine Ansatzmöglichkeit für die Realisierung
der Schnittstelle wäre der Zugriff auf die XML-Version dieser Software. Über diese könnten
nun die Bookmarks von „Personal Brain“ ausgelesen und schließlich in der social bookmarking Erweiterung des Infoasset Broker angezeigt werden.
Des Weiteren wäre vorstellbar, Tags, die in der Erweiterung der Kategorisierung der Bookmarks dienen, auch anderen Assets z.B. Dokumenten des Infoasset Brokers zuzuordnen. Dadurch könnten für jedes Asset automatisch die Bookmarks, die denselben Tags und somit
denselben Themengebieten wie dem Asset zugeordnet wurden, ermittelt werden. Diese ausgewählten Bookmarks könnten schließlich mit der Übersichtsseite des jeweiligen Assets verknüpft werden.
Die drei Erweiterungsmöglichkeiten sollen Anregungen dafür geben, in welche Richtungen
die in dieser Arbeit vorgestellte Erweiterung weiterentwickelt werden kann. Den zukünftigen
15
http://www.flickr.com/
96
Weiterentwicklungen sollten jedoch immer die Prinzipien des social bookmarkings, also die
Verwaltung und der Austausch von Ressourcen, zugrunde gelegt werden.
97
7
Schlusswort
Aufgabe und Ziel der vorliegenden Arbeit war, die social bookmarking Erweiterung des Infoasset Brokers zu konzipieren, zu modellieren und anschließend zu implementieren. Dabei
hat der Verfasser großen Wert darauf gelegt, die Zusammenhänge zwischen den drei Entwicklungsphasen zu verdeutlichen.
Im Rahmen der Beschreibung der Implementierung konnte herausgearbeitet werden, dass alle
Kernanforderungen an die social bookmarking Erweiterung erfolgreich umgesetzt worden
sind. Wie im vorstehenden Kapitel beschrieben, hat sich gezeigt, dass es verschiedene Weiterentwicklungsmöglichkeiten für die Erweiterung gibt.
Momentan ermöglicht die Erweiterung den Anwendern des Infoasset Brokers, ihre Bookmarks innerhalb des Infoasset Brokers zu speichern, zu verwalten und untereinander auszutauschen.
Beim Einfügen der Bookmarks werden diese mittels Tags kategorisiert, so dass sie auf verschiedene Arten miteinander vernetzt und in unterschiedlichen Kontexten auf den Übersichtsseiten der Erweiterung dargestellt werden können. Dadurch wird es den Anwendern
ermöglicht, den Bookmarkbestand der Erweiterung effektiv und zügig zu durchsuchen. Um
den Austausch der Bookmarks zwischen den Anwendern zu unterstützen, wurden einerseits
Kopierfunktionen realisiert, mit denen die Anwender einzelne Bookmarks in ihren Bookmarkaccount kopieren können und andererseits Abonnementfunktionen umgesetzt, welche die
Anwender über die Änderung des Bookmarkbestands der Erweiterung automatisch informieren. Des Weiteren wurden diverse Schnittstellen, mit denen die Erweiterung mit anderen
Anwendungen interagieren kann, implementiert. Somit können die Anwender die in die Erweiterung eingefügten Bookmarks auch in anderen Anwendungen nutzen oder von der Erweiterung aus über die Schnittstelle zu Del.icio.us auf externe Bookmarks zugreifen.
Abschließend kann gesagt werden, dass bei der Entwicklung der social bookmarking Erweiterung viele unterschiedliche Technologien verwendet und Konzepte entwickelt werden
mussten wurden, wodurch die Entwicklungsarbeit stets vielseitig und anspruchvoll war, aber
auch sehr interessant geblieben ist.
98
8
8.1
Literaturverzeichnis
Monographien
[HAM03]
HAMMERSLEY, Ben. Content Syndication with RSS. Sebastopol. O´Reilly. 2003
[LEH05]
LEHEL, Vanda; LEHMANN, Kathrin; BÜCHNER, Thomas. Einführung in den
Infoasset Broker.München.2005
[MCL02]
MCLAUGHLIN, Brett. Java&XML. 2. Auflage ( Deutsche Ausgabe). Köln.
O´Reilly. 2002
[BÖH04]
BÖHMANN, Tilo. Management des organisatorischen Wandels- LE 2. München.
2004
8.2
Internet - Dokumente
[ABD05]
ABDELNUR Alejandro. Using ROME to convert a syndication feed from one type to
another. http://wiki.java.net/bin/view/Javawsxml/Rome05TutorialFeedConverter.
2005
[ATO04]
ATOMENABLED. Atom Syndication Format – Introduction.
http://www.atomenabled.org/developers/syndication/.2004
[GAR05]
GARRET Jesse James. Ajax: A New Approach to Web Applications.
http://www.adaptivepath.com/publications/essays/archives/000385.php. 2005.
[GOO05] GOOGLE. Warum man Google benutzen sollte.
http://www.google.de/why_use.html.2005
[LAN02]
LANGHAM, Metthew: Der ganze REST- Eine Dissertation und die Folgen.
http://www.xmlmagazin.de/itr/online_artikel/show.php3?id=209&nodeid=69 .2002
[MAT05] MATTHES, NASTARAN: Der Infoasset Broker- Standardsoftware für das Wissensmanagement. http://www.infoasset.de/index.html. 2005
[WIN05]
WINER, Dave: RSS at Harvard Law- RSS 2.0 Specification,
http://blogs.law.harvard.edu/tech/rss. 2005
99
9
9.1
Anhang
Funktionsübersicht
In diesem Kapitel wird die Funktionalität der social bookmarking Erweiterung des Infoasset
Brokers erläutert. Die verschiedenen Funktionalitäten dieser Erweiterung werden zwei verschiedenen Schichten zugeordnet. In der privaten Schicht, die im weiteren Bookmarkaccount
genannt wird, können die Anwender der Erweiterung Bookmarks definieren und verwalten.
Der Bookmarkaccount ist ein zugriffsbeschränkter Bereich der Erweiterung, auf den nur dessen jeweiliger Eigentümer zugreifen darf. Die Anwender müssen sich deshalb, bevor sie auf
ihren Bookmarkaccount zugreifen können, beim System anmelden.
Die öffentliche Schicht der Erweiterung steht dagegen allen Anwendern, also sowohl anonymen als auch angemeldeten Anwendern, zur Verfügung. Diese Schicht stellt alle Bookmarks
des Infoasset Brokers dar und ermöglicht somit den Austausch dieser zwischen den Anwendern. Des Weiteren wurde in dieser Schicht eine Schnittstelle zu dem social bookmarking
Anbieter „del.icio.us16“ realisiert, mit der die Bookmarks von Del.icio.us in die Erweiterung
importiert und in dieser dargestellt werde können.
Im Folgenden werden die Funktionen der Erweiterung beschrieben und in kurzen Demovideos vorgestellt. Zum Abspielen der Demovideos kann der „Camtasia Player“, der sich auf
der beiliegenden CD befindet oder von der Camtasia-Homepage17 heruntergeladen werden
kann, verwendet werden.
9.1.1 Bookmarklog anlegen
Jeder Anwender, der einen Benutzeraccount beim Infoasset Broker hat, kann einen Bookmarklog, in dem er seine Bookmarks speichern kann, wie folgt anlegen:
1. Der Anwender öffnet sein Benutzerprofil.
(Mein profil > Meine Kontaktinformationen)
2.
Der Anwender wählt die Funktion „Neues Weblog anlegen“ aus, die sich oben
ooorechts über dessen Kontaktinformationen befindet, aus.
16
17
http://del.icio.us/
http://de.techsmith.com/download/studiodefault.asp?lid=DownloadCamtasiaStudio
100
3. Durch das Ausfüllen des ausgegebenen Formulars kann der Anwender nun einen Bookmarklog anlegen. Dabei muss beachtet werden, dass im Formularfeld „Art des Weblogs“
Bookmarklog angeben wird (siehe Abbildung)
Abb. 40: Formular: "neues Weblog anlegen" ( Quelle: eigene Darstellung )
Nachdem der Anwender den Bookmarklog angelegt hat, wird der Bookmarklogtitel im rechten Frame der Benutzeroberfläche des infoasset Brokers angezeigt. Durch Anklicken dieses
Titels gelangt der Anwender zu seinem Bookmarkaccount, in dem er Bookmarks in seinen
Bookmarklog einfügen und später seine Bookmarks verwalten kann.
9.1.2 Funktionen des Bookmarkaccounts
Jeder Anwender der social bookmarking Erweiterung kann in seinem persönlichen
Bookmarkaccount neue Bookmarks definieren und diese verwalten. Dafür wurden verschiedene Funktionalitäten, die im Folgenden vorgestellt werden, realisiert.
9.1.2.1 Bookmarks einfügen
Um einen Bookmark in den Bookmarklog einzufügen, muss der Anwender in seinem Bookmarkaccount die Funktion „neuer Eintrag“ aufrufen und in dem daraufhin angezeigten Formular die Eigenschaften des Bookmarks definieren. Die einzelnen Formularfelder haben dabei folgende Bedeutung:
101
Formularfeld
Bedeutung
Titel:
In diesem Feld wird der Titel des Bookmarks eingegeben. (Empfehlung: Der Titel sollte mit dem tatsächlichen Titel der Seite, auf die der
Bookmark verweist, übereinstimmen)
URL:
Die URL der Seite, auf die der Bookmark verweisen soll.
Tags:
Tags (engl. Kennzeichnung) sind Schlüsselwörter, die den Bookmarks
bestimmte Themengebieten zuordnen. Sie dienen somit der Kategorisierung der Bookmarks
Beschreibung: In diesem optionalen Attribut kann der Bookmark näher beschrieben
werden.
Sichtbarkeit
In diesem Feld kann festgelegt werden, ob der Bookmark nur in den
Bookmarkaccount (=privat) oder auch in der öffentlichen Schicht
(=öffentlich) angezeigt werden soll.
Tab. 6: Bedeutungen der Formularfelder ( Quelle: eigene Darstellung)
Nachdem der Anwender das Formular ausgefüllt und abgeschickt hat, wird vom System überprüft, ob die URL der Seite, auf die der Bookmark verweisen soll, gültig ist. Dies erfolgt
dadurch, dass das System eine Verbindung zu der angegebenen URL aufbaut und überprüft,
ob die Seite, auf die die eingegebene URL verweist, geladen werden kann. Deshalb ist es
notwendig, dass eine Verbindung zum Internet besteht, wenn ein Bookmark eingefügt werden soll, da ansonsten die URL nicht verifiziert werden kann und eine Fehlermeldung ausgegeben wird. Wenn die URL gültig ist, wird der Bookmark in dass System eingefügt .
9.1.2.2 Die Übersichtsseite
Unter dem Menüpunkt „Eigene Einträge“ des Bookmarkaccounts werden alle, also sowohl
öffentliche als auch private, Bookmarks und die Tags des Anwenders angezeigt. Dabei werden die Bookmarks wie folgt dargestellt:
Abb. 41: Darstellung eines Bookmarks ( Quelle: eigene Darstellung)
102
In der ersten Zeile der Bookmarkdarstellung wird das Einfügedatum des Bookmarks ausgegeben. Danach werden der Titel des Bookmarks, welcher auf die URL des Bookmarks verweist, und daran anschließend die Beschreibung des Bookmarks dargestellt. Die vierte Zeile
enthält Zusatzinformationen zu den Bookmarks, also die Tags, die diesen zugeordnet wurden,
den Namen deren Eigentümer und die Anzahl der Anwender, die einen Bookmark zu der
gleichen URL wie der dargestellte Bookmark in das System eingefügt haben.
Zu beachten ist, dass die drei Informationen der letzten Zeile als Links dargestellt werden,
welchen die verschiedenen Sichten auf den Bookmarkbestand mit den jeweils dargestellten
Bookmarks vernetzen. Die Tags verweisen zu tagspezifischen Seiten, die alle Bookmarks, die
mit den angezeigten Tags verknüpft sind, enthalten. Der Benutzername verweist zu dem
Bookmarklog des Eigentümers des jeweiligen Bookmarks. Die Darstellung der Anzahl der
Anwender, die ebenfalls einen Bookmark zu derselben Ressource gespeichert haben, ist mit
einer Kommentarfunktion verknüpft. Diese Kommentarfunktion gibt die Beschreibungen
aller Bookmarks aus, die mit der gleichen Ressource wie der jeweils dargestellte Bookmark
assoziiert sind.
Des Weiteren werden jedem Bookmark eine Bearbeitungs-, eine Lösch- und eine Exportfunktion zugeordnet. Durch die Bearbeitungsfunktion können die Eigenschaften eines Bookmarks geändert werden und durch die Löschfunktion Bookmarks aus der Erweiterung entfernt werden. Mittels der Exportfunktion, die der Anwender nach Belieben auf der „Einstellungsseite“ des Bookmarkaccounts aktivieren oder deaktivieren kann, können einzelne
Bookmarks nach Del.icio.us exportiert werden. Dies ist aber nur möglich, wenn der Anwender über einen Account bei diesem social bookmarking Anbieter verfügt.
Neben den Bookmarks werden auf dieser Übersichtseite die Tags angezeigt, die von dem
Anwender definiert worden sind. Die Tags dieser Tagliste verweisen auf die tagspezifischen
Seiten, die die Bookmarks enthalten, die dem jeweiligen Tag zugeordnet wurden. Auf diese
tagsspezifischen Seiten werden des Weiteren die verwandten Tags des ausgewählten Tags
ausgegeben. Die Verwandtschaft zwischen zwei Tags kann dabei wie folgt definiert werden:
Zwei Tags sind miteinander verwandt, wenn diese gemeinsam mindestens mit zwei Bookmarks verknüpft sind. Durch die Verwandtschaften können Tags und somit Themengebiete,
die durch diese dargestellt werden, miteinander verknüpft und dadurch die Bookmarks, die
mit diesen verknüpft sind, vernetzt werden.
103
9.1.2.3 Abonnementfunktion - die Inbox
Eine weitere Funktion, die von der social bookmarking Erweiterung angeboten wird, ist die
Abonnementfunktion. Durch diese Funktion können die Anwender bestimmen, dass sie alarmiert werden, wenn Bookmarks eines bestimmten Typs in das System eingefügt werden.
Grundsätzlich kann sich der Anwender zwischen den folgenden drei Abonnementtypen entscheiden:
Abonnementtyp
tagspezifisches Abonnement
Bedeutung
Bei einen tagspezifischen Abonnement wird der Anwender informiert, wenn eine Bookmark zu einen bestimmten
Tag eingefügt wird.
Personenspezifische Abonnement
personenund tagspezifisches Abonnement
Dieser Abonnementtyp informiert den Anwender, wenn
eine bestimmte Person einen Bookmark definiert hat.
Dieses Abonnement stellt eine Mischform der beiden oben
genannten Abonnementtypen dar und informiert den Anwender, wenn eine bestimmte Person einen Bookmark mit
einem bestimmten Tag in das System einfügt
Tab. 7: Die Abonnementtypen ( Quelle: eigene Darstellung)
Der Anwender kann die Abonnements auf verschiedenen Seiten der öffentlichen Schicht, die
in den folgenden Abschnitten näher erläutert werden, einrichten.
Wenn der Anwender Abonnements eingerichtet hat, werden jeweils die Bookmarks, die den
Abonnements entsprechen, in der Inbox des Bookmarkaccounts des Abonnenten angezeigt.
Diese Inbox wird einmal täglich aktualisiert, so dass in dieser nur die aktuellsten Bookmarks
der Abonnements angezeigt werden. Um Bookmarks dennoch für längere Zeit zu speichern,
können die Anwender diese durch eine Kopierfunktion, die jedem Bookmark zugeordnet ist,
in ihrem eigenen Bookmarkaccount kopieren.
Neben den aktuellen Bookmarks werden die verschiedenen Abonnements angezeigt, die jeweils zu der Seite, auf der das Abonnement abgeschlossen wurde, verweisen. Jedem Abonnement wurde des Weiteren eine Löschfunktion zugeordnet, mit der der Anwender die Abonnements wieder entfernen kann. In der folgenden Abbildung wird die „Inbox“ des Bookmarkaccounts dargestellt:
104
Abb. 42: Die Inbox ( Quelle: Eigene Darstellung )
9.1.2.4 Funktion „Tags umbenennen“
Mit dieser Funktion kann der Anwender seine Tags konsistent umbenennen. Diese Funktion
ermöglicht es, alle Bookmarks eines Tags mit einem neuen Tag verknüpfen, der beispielsweise diese Bookmarks besser beschreibt.
Wenn die Funktion aufgerufen wird, öffnet sich ein Formular, in dem der Anwender aus einer Auswahlliste den Tag, den er umbenennen will, auswählen und in einem Textfeld den
neuen Tag eingeben kann. Dem Textfeld ist eine Suggestionsfunktion, die die Benutzereingaben erkennt und Vorschläge für deren Fertigstellung ausgibt, zugeordnet. Dadurch kann
der Anwender beispielsweise bei der Eingabe des neuen Tagnamen direkt sehen welche Tags
schon von anderen Anwendern definiert wurden und einen von diesen für die Umbenennung
seines Tags übernehmen. Nachdem der Anwender einen Tag umbenannt und das Formular
abgeschickt hat, wird der neue Name dem Objekt des Tags, der umbenannt werden soll, zugeordnet. Da das Tagobjekt über eine „N zu M“ Beziehung mit den Bookmarks verknüpft ist,
ist die Umbenennung des Tags über diese Bookmarks konsistent.
9.1.3 Der Bookmarklog
Der Bookmarklog bildet die Schnittstelle zwischen dem privaten Bookmarkaccount und der
öffentlichen Schicht und stellt die Bookmarks einer Person öffentlich dar. Die Startseite des
Bookmarklog enthält alle Bookmarks und Tags des jeweiligen Eigentümers. Die Elemente
der Tagliste, die sich links neben der Bookmarkliste befinden, verweisen zu den tagspezifischen Seiten, auf denen die tagspezifischen Bookmarks des Eigentümers ausgegeben werden.
105
Wenn ein angemeldeter Anwender, der über einen Bookmarkaccount verfügt, einen Bookmarklog aufruft, wird jedem Bookmark eine „Kopierfunktion“ zugeordnet, mit der der Anwender die Bookmarks in seinen eigenen Bookmarkaccount kopieren kann. Des Weiteren
befindet sich oberhalb der verschiedenen Bookmarklisten eine Abonnementfunktion, mit der
der Anwender entweder personenspezifische oder tagund personenspezifische Abonnements einrichten kann. Führt der Anwender diese Funktion auf der Startseite des Bookmarklog aus, abonniert er alle Bookmarks des Eigentümers des Bookmarklogs (personenspezifisches Abonnement). Wird dagegen die Abonnementfunktion auf den tagspezifischen Seiten des bookmarklogs aufgerufen, werden nur die Bookmarks des Eigentümers abonniert, die
den ausgewählten Tags zugeordnet sind (person- und tagspezifisches Abonnent).
Darüber hinaus haben die Bookmarklogs eine Content Syndication Schnittstelle, mit der die
Bookmarks der Bookmarklogs als Feeds exportiert werden können. Feeds sind XMLDokumente, die die Information über Bookmarks strukturiert darstellen, so dass sie von anderen Programmen (z.B. Feedreadern) gelesen und verarbeitet werden können. Um die Content
Syndication dieser Schnittstelle möglichst allgemein zu gestalten, wurden vier verschiedene
Feedformate für diese realisiert:
•
•
RSS 1.0
Atom 1.0
•
•
RSS 0.92
Atom 0.3
Da jeder Anwender selbst bestimmen sollte, welche Feeds auf seinem Bookmarklog angeboten werden sollen, können die Anwender über die Einstellungsseite ihres Bookmarkaccounts
die einzelnen Feeds aktivieren bzw. deaktivieren. Wenn ein Anwender einen Feed aktiviert
hat, wird auf dessen Bookmarklog die entsprechende Exportfunktion ausgegeben. Durch
Ausführen dieser Exportfunktion können die Anwender den entsprechenden Feed nun anfordern und die Bookmarks des Bookmarklogs exportieren.
9.1.4 Funktionen der öffentlichen Schicht
In der öffentlichen Schicht der social bookmarking Erweiterung, auf die jeder Anwender
zugreifen kann, werden alle öffentlichen Bookmarks des Infoasset Brokers und die importierten Bookmarks des social bookmarking Anbieters Del.icio.us dargestellt. Diese Übersichtseiten können über den Menüpunkt „Bookmarks“ des Hauptmenüs des Infoasset Brokers aufgerufen werden.
106
9.1.4.1 Die öffentliche Übersichtsseite
Die Startseite der öffentlichen Übersichtsseite enthält alle Bookmarks, die erst kürzlich in
das System einfügt worden sind. Somit können sich die Anwender auf einen Blick informieren, ob neue Bookmarks eingefügt worden sind oder ob sich der Bookmarkbestand der Erweiterung seit dem letzten Aufruf dieser Seite nicht geändert hat. Dies erleichtert den Anwendern den Überblick über den aktuellen Bookmarkbestand des Systems über einen längeren Zeitraum zu behalten. Zusätzlich werden auf der Startseite die Tags, die von vielen Anwendern der Erweiterung genutzt werden (populäre Tags), angezeigt. Durch die Angabe der
populären Tags wird ersichtlich, für welche Themen sich die Anwender momentan interessieren.
Die populären Tags verweisen jeweils auf die tagspezifischen Seiten der öffentlichen Übersicht. Analog zu den tagspezifischen Seiten des Bookmarkaccounts werden auf diesen Seiten
die verwandten Tags des selektierten Tags ausgegeben. Außerdem bieten die tagspezifischen
Seiten eine Funktion an, mit der die Bookmarks dieser Seite abonniert werden können.
Um auf eine bestimmte tagspezifische Seite zugreifen zu können, werden von der Erweiterung neben der Liste der populärsten Tags noch zwei weitere Möglichkeiten angeboten. Einerseits kann über eine Freitextsuche nach tagspezifischen Seiten gesucht und andererseits
direkt auf eine tagspezifische Seite über eine bestimmte URL, die im Folgenden dargestellt
wird, zugegriffen werden.
http://<host>:<port>/tags
Abb. 43: URL der tagspezifischen Seiten ( Quelle: eigene Darstellung )
An die dargestellte URL können die Anwender den Tag anhängen, dessen Bookmarks auf der
tagspezifischen Seite ausgegeben werden sollen. Durch diese URL können somit die tagspezifischen Seiten geladen werden, ohne dass die komplette Oberfläche des infoasset Brokers
geladen werden muss und sich die Anwender dann bis zur der entsprechende Seite „durchklicken“ müssen. Dadurch wird ein effizienter und schneller Zugriff auf die tagspezifische
Bookmarks ermöglicht.
Des Weiteren kann der Anwender über einen Link auf eine weitere Übersichtsseite zugreifen,
auf der die externen von Del.icio.us importierten Bookmarks angezeigt werden.
Die externen Bookmark können – analog zu den internen Bookmarks - in den vier folgenden
Kontexten dargestellt werden:
107
•
aktuelle Bookmarks
•
tagspezifische Bookmarks
•
personenspezifische Bookmarks
•
personenund tagspezifische Bookmarks
Um angemeldeten Anwendern die Möglichkeit zu geben, die externen Bookmarks in ihren
eigenen Bookmarkaccount zu kopieren, wurde auch in dieser Schicht jedem Bookmark eine
Kopierfunktion zugeordnet.
Da die externen Bookmarks über einen Feed, der von einem externen Server angefordert
wird, in den Infoasset Broker importiert werden, muss beim Aufruf der Übersichtsseite über
die externen Bookmarks eine Verbindung zum Internet bestehen.
9.1.4.2 Das Bookmarklogverzeichnis
Das Bookmarklogverzeichnis ermöglicht den Anwendern, gezielt nach den Bookmarklogs
einer bestimmten Person zu suchen. Innerhalb dieses Indexes werden, wie in der folgenden
Abbildung dargestellt wird, die Titel, die Eigentümer und die Aktualisierungsdaten der verschiedenen Bookmarklogs dargestellt:
Abb. 44: Das Bookmarklogverzeichnis ( Quelle: Eigene Darstellung)
Durch die Ausgabe der Aktualisierungsdaten, nach denen die Einträge des Verzeichnisses
auch sortiert wurden, können die Anwender sofort sehen, welche Bookmarklogs erst vor kurzem aktualisiert wurden. Des Weiteren kann über einen alphabetischen Index auf Unterseiten
des Verzeichnisses zugegriffen werden, die die Bookmarklogtitel darstellen, die mit den aus
dem Index ausgewählten Buchstaben beginnen. Dadurch wird die Suche nach einem
108
bestimmten Bookmarklog für die Anwender erleichtert. Nachdem der Anwender einen interessanten Bookmarklog gefunden hat, kann er direkt durch das Anklicken des Titels auf den
Bookmarklog zugreifen.
9.1.5 Sonstige Funktionen
Neben den Funktionen der social bookmarking Erweiterung wurden weitere Funktionen realisiert, die diese Erweiterung mit den anderen Objekten des Infoasset Broker verknüpft.
9.1.5.1 Erweiterung der Startseite
Auf der Startseite des Infoasset Brokers werden aktuelle Mitteilungen und Nachrichten der
verschiedenen Assets angezeigt, damit der Anwender sofort sehen kann, welche Inhalte zum
Infoasset Broker neu hinzugefügt wurden bzw. überarbeitet wurden. Damit sich die Anwender auf dieser Seite über neue Bookmarks, die in die Erweiterung eingefügt wurden, informieren können, wurden zu dieser Seite zwei weitere Übersichten über den Bookmarkbestand
der Erweiterung hinzugefügt. Zum einen werden die zehn aktuellsten Bookmarks und zum
anderen die populärsten Tags angezeigt.
Die aktuellen Bookmarks werden im Gegensatz zu der Bookmarkdarstellung in der Erweiterung in einer gekürzten Form, die lediglich aus dem Titel, dem Eigentümernamen und dem
Einfügedatum besteht, dargestellt. Dabei wurden sowohl der Titel als auch der Eigentümername als Links realisiert, die zu dem URL der Bookmarks und zu dem Bookmarklog des
Bookmarkeigentümers verweisen. Sollte sich ein Anwender dennoch für die Eigenschaften
eines Bookmarks näher interessieren, kann er direkt über einen Link, der sich oberhalb der
Übersicht befindet, auf die Übersicht der öffentlichen Schicht der social bookmarking Erweiterung, in der die Bookmarks in vollem Umfang dargestellt werden, zugreifen.
Im Informationsblock „beliebte Tags“ werden die zehn populärsten Tags, also die Tags, die
von den meisten Anwendern der Erweiterung verwendet werden, ausgegeben. Um die Popularität der verschiedenen Tags zu visualisieren, wurden diese mit verschiedenen Schriftgrößen, die in Abhängigkeit von deren Popularität variieren, dargestellt. Die angezeigten Tags
verweisen auf ihre tagspezifischen Seiten der Übersichtseite.
109
9.1.5.2 Das Bookmarklet „Quick save“
Die Funktion „Quick save“ ermöglicht den Anwendern, die Seiten des Infoasset Brokers, die
sie interessieren, in ihren Bookmarkaccount zu speichern, so dass sie auf diese von einem
zentralen Ort aus zugreifen können.
Wenn ein Anwender einen Bookmark für die Seite, auf der er sich gerade befindet, anlegen
will, muss er lediglich das Bookmarklet „Quick Save“ anklicken. Dadurch gelangt er zu dem
Einfügeformular seines Bookmarkaccounts, dessen URL-Feld mit der URL der Seite vorbelegt ist, die er speichern will. Nun kann der Anwender die weiteren Felder dieses Formulars
ausfüllen und somit den Bookmark zu dieser Seite definieren.
9.1.5.3 Die Funktion „Quick info“
Ebenfalls auf der rechten Seite der Oberfläche des Infoasset Brokers befindet sich der Button
„Quick Info“. Wird dieser von einem Anwender angeklickt, werden in einem „Pop-up“Fenster die Bookmarks angezeigt, die mit der Seite verknüpft sind, auf der sich der Anwender gerade befindet. Dadurch kann der Anwender sowohl sofort sehen, welche Personen diese Seite gespeichert haben und diese somit als interessant erachten, als auch die Kommentare
durchlesen, die diesen Bookmarks zugeordnet wurden.
Da durch die Speicherung dieser Seiten durch „Quick Save“, Beschreibungen zu diesen hinzugefügt werden können, die durch die Funktion „Quick Info“ wieder abgerufen werden
können, unterstützen diese Funktionen die Zuordnung von verschiedenen Anmerkungen zu
internen Seiten und deren Austausch.
9.1.5.4 Die Webservices
Die Webservices ermöglichen den Anwendern, sowohl Bookmarks und Tags aus der Erweiterung zu exportieren als auch Bookmarks in diese einzufügen, ohne die Benutzeroberfläche
des Infoasset Brokers laden zu müssen. Die verschiedenen Webservices können jeweils durch
bestimmte URLs, die in der folgenden Tabelle dargestellt werden, aufgerufen werden:
110
Typ des Webservices
URL des Webservices
Export von aktuellen
Bookmarks
http://<host>:<port>/api/bookmarks
Export von tagspezifischen Bookmarks
http://<host>:<port>/api/bookmarks?tag=<tag>
Export von personen/tagspezifischen
Bookmarks
http://<host>:<port>/api/bookmarks?tag=<tag>&person=<Login>
Export von populären
Tags
http://<host>:<port>/api/tags
Export von personenspezifischen Tags
http://<host>:<port>/api/tags?person=<login>
Bookmarks einfügen
http://<host>:<port>/api/add?person=<Login>
&passwort=<Passwort>
&titel=<Title>
&tag=<Tags>
&url=<Url>
&beschreibung=<Beschreibung>
& sichtbarkeit=<privat | public>
Abb. 45: Die Webservices der Erweiterung ( Quelle: eigene Darstellung )
Es existieren drei Webservices, mit denen Bookmark exportiert werden können. Werden keine Parameter an die URL des „Bookmark Webservices“ angehängt, werden die aktuellsten
Bookmarks der Erweiterung ausgegeben. Wenn dagegen der Benutzername eines Anwenders
zu der URL hinzugefügt wird, wird ein Antwortdokument mit den Bookmarks dieses Anwenders erzeugt. Wird zusätzlich zu dem Login noch ein bestimmter Tag an diese URL angehängt, gibt der entsprechende Webservice die tagspezifischen Bookmarks einer bestimmten Person aus.
Nachdem ein solcher Webservice ausgeführt wurde, werden die angeforderten Bookmarks in
ein XML-Dokument, das in der folgenden Abbildung dargestellt wird, eingebettet:
Abb. 46: Antwortdokument eines Webservices ( Quelle: eigene Darstellung )
Wie dieser Abbildung zu entnehmen ist, wird in dem posts-Tag die Art des ausgeführten
Webservices (Attribut: „Type“) und in diesem Fall das Tag (Attribut: „Tag“) angegeben, mit
111
den die Bookmarks dieses Dokumentes verknüpft sind. Wenn dagegen personenspezifische
Bookmarks angefordert wurden, wird dem posts-Tag das Attribut „Person“ zugeordnet, das
das Login der Person, dessen Bookmarks exportiert werden, enthält. Die einzelnen Bookmarks werden jeweils durch post-Tags, deren Attribute die Eigenschaften des jeweiligen
Bookmarks enthalten, in das Antwortdokument eingefügt. Dem Attribut „others“ des
„post“-Tags wird die Anzahl der Bookmarks zugeordnet, welche auf die gleichen URL verweisen wie der jeweils dargestellte Bookmark. Die anderen Attribute dieses Tags sind selbsterklärend und benötigen deshalb keine näheren Erläuterungen.
Des Weiteren können entweder die populärsten Tags des Systems oder personenspezifische
Tags durch die entsprechenden Webservices angefordert werden. Nachdem ein solcher Webservices ausgeführt wurde, werden die angeforderten Tags ebenfalls in einem XMLDokuments ausgeben, welches - analog dem Antwortdokument, das von den „Bookmark
Webservices“ erstellt wird - strukturiert ist. Dem posts- Tag wird wiederum durch das Attribut „typ“ der Typ des angeforderten Webservices zugeordnet und, falls personenspezifische
Tags ausgegeben werden, diesem der Namen der Person, dessen Tags angefordert wurden,
durch das Attribut „Person“ hinzugefügt . Die verschiedenen Tags werden anschließend
durch posts-Tags in das Antwortdokument eingebettet, denen die Anzahl der Anwender, die
den jeweiligen dargestellten Tag definiert haben, durch das Attribut „Number“ zugeordnet
wird.
Schließlich ermöglicht ein weiterer Webservice den Import von Bookmarks. Da nur autorisierte Anwender Bookmarks in das System einfügen dürfen, müssen neben den Eigenschaften, die für die Definition eines Bookmarks benötigt werden, auch die Benutzerdaten des
Anwenders, der diesen einfügen will, beim Aufruf dieses Webservices angegeben werden.
Die Benutzerdaten werden von dem Webservice verifiziert und falls diese gültig sind, der
Bookmark entsprechend in das System eingefügt. Nachdem der Webservice erfolgreich ausgeführt wurde, wird ein Antwortdokument mit einer Bestätigungsmeldung erzeugt und ausgegeben.
112
9.2
Der Featurevergleich
In den folgenden Tabellen werden die Features der social bookmarking Anwendungen, die im Rahmen der Marktstudie untersucht worden sind,
dargestellt:
Features
Elements of the Startpage
Linkroll
Simpy
Furl
Blogmark
Connectea Spurl
del.icio.us
popularTags
recently added Bookmarks
active user
Properties of a Bookmark
URL
official title
self selected title
description
tags
comment
categories
visibility (private or public)
113
Features
presentation of the bookmarks
within the application
Linkroll
Simpy
Furl
Blogmark
Connectea Spurl
del.icio.us
URL
title
description
tags
category
comment
owner of the Bookmark
creationdate
related bookmarks
number of user which also save the
pages
Views on the Bookmarkinventory
user specific sites
... which have their own URLs
tag specific sites
... which have their own URLs
User & tagsspecific sites
114
Features
Search options
Linkroll
Simpy
Furl
Blogmark
Connectea Spurl
del.icio.us
Free text search options
For title
For descriptions
For tags
For users
Categoric search
Archive function
Functions of the application
add/modify/delete bookmarks
webbased subscriptions of bookmarks
edit tags
“copy to my bookmarks”-feature
115
Features
Export- resp. Importinterfaces
bookmarklets
Exportinterfaces
Import from ....
Internet Explorer
Netscape
Mozilla
Firefox
Opera
Delicious
Feedversion
Linkroll
Simpy
Furl
RSS
Feed
Explorer
Netscape
Mozillla
RSS 2.0
RSS 0,91/1.0/2.0
Atom 0.3
Blogmark
Connectea
Spurl
Explorer Feeds
Netscape
Mozilla
RIS-Format
Feeds
Javascript Webservices
Feeds
Del.icio.us
RSS 2.0
RSS 1.0
RSS 2.0
Atom
RSS 1.0
del.icio.us
RDF
Bookmarkrecommendations via
Email
116
117

Diplomarbeit Konzeption und Realisierung einer - sebis

Transcription

Similar documents

xt:Commerce 4 – Das Praxishandbuch

QPS 8.5.1 - bekannt gewordene und behobene Probleme

Editorial

Der Roman im Zeitalter der audiovisuellen und

ferienwohnung riffian vier stern