Gemeinsame Objekte

Flash Player 9 und höher, Adobe AIR 1.0 und höher

Ein gemeinsames Objekt, das gelegentlich auch als „Flash-Cookie“ bezeichnet wird, ist eine Datendatei, die von den von Ihnen besuchten Sites auf Ihrem Computer erstellt werden kann. Gemeinsame Objekte werden auch häufig zum Aufwerten Ihres Browsing-Erlebnisses verwendet, z. B. ermöglichen gemeinsame Objekte, das Erscheinungsbild einer häufig besuchten Website zu personalisieren.

Gemeinsame Objekte

Gemeinsame Objekte funktionieren wie Cookies. Mit der SharedObject -Klasse können Sie Daten auf der lokalen Festplatte des Benutzers speichern und diese Daten während derselben Sitzung oder in einer späteren Sitzung aufrufen. Anwendungen können nur auf ihre eigenen SharedObject-Daten zugreifen und dies nur, wenn sie auf derselben Domäne ausgeführt werden. Die Daten werden nicht an den Server geschickt und sind für andere Anwendungen, die in anderen Domänen ausgeführt werden, nicht zugänglich. Sie können jedoch den Anwendungen in derselben Domäne den Zugang ermöglichen.

Gemeinsame Objekte im Vergleich zu Cookies

Cookies und gemeinsame Objekte sind sehr ähnlich. Da viele Programmierer wissen, wie Cookies funktionieren, ist es angebracht, Cookies mit lokalen SharedObjects zu vergleichen.

Cookies, die dem RFC 2109-Standard entsprechen, weisen in der Regel nachstehende Eigenschaften auf:

  • Sie laufen ab und zwar oft am Ende der Sitzung.

  • Sie können vom Client für eine bestimmte Site deaktiviert werden.

  • Es können maximal 300 Cookies insgesamt und 20 Cookies pro Site gespeichert werden.

  • Im Allgemeinen ist ihre Größe auf jeweils 4 KB beschränkt.

  • Manchmal werden sie als Sicherheitsbedrohung empfunden und aus diesem Grund auf dem Client deaktiviert.

  • Sie werden an einem vom Clientbrowser bestimmten Ort gespeichert.

  • Sie werden vom Client über HTTP an den Server übermittelt.

    Gemeinsame Objekte haben hingegen die nachstehenden Eigenschaften:

  • Standardmäßig laufen sie nicht ab.

  • Standardmäßig ist ihre Größe auf jeweils 100 KB beschränkt.

  • Sie können einfache Daten speichern (wie z. B. String, Array und Datum)

  • Sie werden an einem von der Anwendung bestimmten Ort (im Stammverzeichnis des Benutzers) gespeichert.

  • Sie werden nie vom Client an den Server übertragen.

Die SharedObject-Klasse

Mithilfe der SharedObject -Klasse können Sie gemeinsame Objekte erstellen und löschen und die aktuelle Größe eines verwendeten SharedObject-Objekts ermitteln.

Erstellen eines gemeinsamen Objekts

Zum Erstellen eines SharedObject -Objekts verwenden Sie die SharedObject.getLocal() -Methode. Für diese Methode gilt folgende Syntax:

SharedObject.getLocal("objectName" [, pathname]): SharedObject

Im nachstehenden Beispiel wird ein gemeinsames Objekt mit dem Namen mySO erstellt:

public var mySO:SharedObject; 
mySO = SharedObject.getLocal("preferences");

Dies erstellt auf dem Client eine Datei mit dem Namen „preferences.sol“.

Der Begriff lokal bezieht sich auf den Speicherort des gemeinsamen Objekts. In diesem Fall speichert Adobe®Flash® Player die SharedObject-Datei lokal im Stammverzeichnis des Clients.

Wenn Sie ein gemeinsames Objekt erstellen, legt Flash Player in der Sandbox einen neuen Ordner für die Anwendung und die Domäne an. Flash Player erstellt auch eine *.sol-Datei, in der die SharedObject-Daten gespeichert werden. Der Standardspeicherort dieser Datei ist ein Unterverzeichnis des Stammverzeichnisses des Benutzers. In der nachstehenden Tabelle sind die Standardspeicherorte dieses Verzeichnisses aufgeführt:

Betriebssystem

Verzeichnis

Windows 95/98/ME/2000/XP

c:/Documents and Settings/username/Application Data/Macromedia/Flash Player/#SharedObjects

Windows Vista/Windows 7

c:/Users/username/AppData/Roaming/Macromedia/Flash Player/#SharedObjects

Macintosh OS X

/Users/username/Library/Preferences/Macromedia/Flash Player/#SharedObjects/web_domain/path_to_application/application_name/object_name.sol

Linux/Unix

/home/username/.macromedia/Flash_Player/#SharedObjects/web_domain/path_to_application/application_name/object_name.sol

Unter dem Verzeichnis #SharedObjects befindet sich ein nach dem Zufallsprinzip benanntes Verzeichnis. Darunter liegt ein weiteres Verzeichnis, das den Hostnamen, den Pfad der Anwendung und schließlich den Namen der *.sol-Datei enthält.

Wenn Sie zum Beispiel eine Anwendung mit dem Namen MyApp.swf auf dem lokalen Host in einem Unterverzeichnis namens /sos anfordern, legt Flash Player die *.sol-Datei in Windows XP am folgenden Speicherort ab:

c:/Documents and Settings/fred/Application Data/Macromedia/Flash Player/#SharedObjects/KROKWXRK/#localhost/sos/MyApp.swf/data.sol
Hinweis: Geben Sie keinen Namen in der SharedObject.getLocal() -Methode an, benennt Flash Player die Datei als „undefined.sol“.

Standardmäßig kann Flash permanente SharedObject-Objekte von bis zu 100 KB pro Domäne lokal speichern. Der Benutzer kann diesen Wert ändern. Wenn die Anwendung versucht, Daten in einem gemeinsamen Objekt zu speichern, und dabei die 100-KB-Grenze überschritten wird, zeigt Flash Player das Dialogfeld zum lokalen Speichern an. Hier kann der Benutzer die Zuteilung von mehr Speicherplatz für die anfordernde Domäne genehmigen oder verweigern.

Angeben eines Pfads

Über den optionalen pathname -Parameter können Sie den Speicherort der SharedObject -Datei festlegen. Diese Datei muss ein Unterverzeichnis des SharedObject-Verzeichnisses der Domäne sein. Wenn Sie zum Beispiel eine Anwendung auf dem Localhost anfordern und Folgendes angeben:

mySO = SharedObject.getLocal("myObjectFile","/");

schreibt Flash Player die SharedObject-Datei in das Verzeichnis /#localhost (bzw. /localhost für Offline-Anwendungen). Dies ist nützlich, wenn mehrere Anwendungen auf dem Client auf dasselbe gemeinsame Objekt zugreifen sollen. In diesem Fall kann der Client zwei Flex-Anwendungen ausführen, die beide den Pfad zum gemeinsamen Objekt angeben, das das Stammverzeichnis der Domäne ist; der Client kann dann über beide Anwendungen auf dasselbe gemeinsame Objekt zugreifen. Sie können das LocalConnection-Objekt verwenden, damit mehrere Anwendungen auf nicht permanente Weise auf gemeinsame Daten zugreifen können.

Wenn Sie ein Verzeichnis angeben, das nicht existiert, erstellt Flash Player keine SharedObject-Datei.

Hinzufügen von Daten zu einem gemeinsamen Objekt

Zum Hinzufügen von Daten zu der *.sol-Datei eines SharedObject -Objekts verwenden Sie die data -Eigenschaft des SharedObject-Objekts. Mithilfe der nachstehenden Syntax fügen Sie neue Daten zum gemeinsamen Objekt hinzu:

sharedObject_name.data.variable = value;

Im nachstehenden Beispiel werden die Eigenschaften userName , itemNumbers und adminPrivileges und deren Werte zu einem SharedObject hinzugefügt:

public var currentUserName:String = "Reiner"; 
public var itemsArray:Array = new Array(101,346,483); 
public var currentUserIsAdmin:Boolean = true; 
mySO.data.userName = currentUserName; 
mySO.data.itemNumbers = itemsArray; 
mySO.data.adminPrivileges = currentUserIsAdmin;

Nachdem Sie der data -Eigenschaft Werte zugewiesen haben, müssen Sie den Flash Player anweisen, diese Werte in die SharedObject-Datei zu schreiben. Damit Flash Player die Werte zwingend in die SharedObject-Datei schreibt, verwenden Sie die SharedObject . flush() -Methode, wie nachstehend beschrieben:

mySO.flush();

Wenn Sie die SharedObject.flush() -Methode nicht aufrufen, schreibt Flash Player die Werte in die Datei, sobald die Anwendung beendet wird. So kann der Benutzer jedoch nicht den Datenspeicherplatz für Flash Player vergrößern, wenn die Datenmenge die Standardeinstellungen überschreitet. Deshalb ist es ratsam, SharedObject.flush() aufzurufen.

Wenn Sie die flush() -Methode zum Schreiben von gemeinsamen Objekten auf die Festplatte eines Benutzers verwenden, müssen Sie prüfen, ob der Benutzer die lokale Speicherung mit dem Einstellungsmanager von Flash Player ( www.macromedia.com/support/documentation/de/flashplayer/help/settings_manager07.html ) explizit deaktiviert hat. Ein Beispiel hierfür wird im folgenden Code gezeigt:

var so:SharedObject = SharedObject.getLocal("test"); 
trace("Current SharedObject size is " + so.size + " bytes."); 
so.flush();

Speichern von Objekten in gemeinsamen Objekten

Sie können einfache Objekte, wie Arrays oder Strings, in der data -Eigenschaft eines gemeinsamen Objekts speichern.

Das nachstehende Beispiel ist eine ActionScript-Klasse zur Bestimmung der Methoden, die für die Steuerung der Interaktion mit dem gemeinsamen Objekt verwendet werden. Mithilfe dieser Methoden kann der Benutzer Objekte zum gemeinsamen Objekt hinzuzufügen oder aus diesem entfernen. In dieser Klasse wird eine ArrayCollection gespeichert, die einfache Objekte enthält.

package { 
    import mx.collections.ArrayCollection; 
    import flash.net.SharedObject; 
 
    public class LSOHandler { 
 
        private var mySO:SharedObject; 
        private var ac:ArrayCollection; 
        private var lsoType:String; 
 
        // The parameter is "feeds" or "sites". 
        public function LSOHandler(s:String) { 
            init(s); 
        } 
 
        private function init(s:String):void { 
            ac = new ArrayCollection(); 
            lsoType = s; 
            mySO = SharedObject.getLocal(lsoType); 
            if (getObjects()) { 
                ac = getObjects(); 
            } 
        } 
 
        public function getObjects():ArrayCollection { 
            return mySO.data[lsoType]; 
        } 
 
        public function addObject(o:Object):void { 
            ac.addItem(o); 
            updateSharedObjects(); 
        } 
 
        private function updateSharedObjects():void { 
            mySO.data[lsoType] = ac; 
            mySO.flush(); 
        } 
    } 
 
}

Die folgende Flex-Anwendung erstellt eine Instanz der ActionScript-Klasse für jeden Typ gemeinsamer Objekte, die sie braucht. Anschließend ruft sie Methoden dieser Klasse auf, wenn der Benutzer Blogs oder Site-URLs hinzufügt oder entfernt.

<?xml version="1.0"?> 
<!-- lsos/BlogAggregator.mxml --> 
<mx:Application 
    xmlns:local="*" 
    xmlns:mx="http://www.adobe.com/2006/mxml" 
    creationComplete="initApp()" 
    backgroundColor="#ffffff" 
> 
    <mx:Script> 
        <![CDATA[ 
        import mx.collections.ArrayCollection; 
        import mx.utils.ObjectUtil; 
        import flash.net.SharedObject; 
 
        [Bindable] 
        public var welcomeMessage:String; 
        
        [Bindable] 
        public var localFeeds:ArrayCollection = new ArrayCollection(); 
 
        [Bindable] 
        public var localSites:ArrayCollection = new ArrayCollection(); 
 
        public var lsofeeds:LSOHandler; 
        public var lsosites:LSOHandler; 
 
        private function initApp():void { 
            lsofeeds = new LSOHandler("feeds"); 
            lsosites = new LSOHandler("sites"); 
            
            if (lsofeeds.getObjects()) { 
                localFeeds = lsofeeds.getObjects(); 
            } 
            if (lsosites.getObjects()) { 
                localSites = lsosites.getObjects(); 
            } 
        } 
        
        // Adds a new feed to the feeds DataGrid. 
        private function addFeed():void { 
            // Construct an object you want to store in the 
            // LSO. This object can contain any number of fields. 
            var o:Object = {name:ti1.text, url:ti2.text, date:new Date()}; 
            lsofeeds.addObject(o); 
    
            // Because the DataGrid's dataProvider property is 
            // bound to the ArrayCollection, Flex updates the 
            // DataGrid when you call this method. 
            localFeeds = lsofeeds.getObjects(); 
            
            // Clear the text fields. 
            ti1.text = '';        
            ti2.text = ''; 
        } 
        
        // Removes feeds from the feeds DataGrid. 
        private function removeFeed():void { 
            // Use a method of ArrayCollection to remove a feed. 
            // Because the DataGrid's dataProvider property is 
            // bound to the ArrayCollection, Flex updates the 
            // DataGrid when you call this method. You do not need 
            // to update it manually. 
            if (myFeedsGrid.selectedIndex > -1) { 
            
localFeeds.removeItemAt(myFeedsGrid.selectedIndex); 
             } 
        } 
        
        private function addSite():void { 
            var o:Object = {name:ti3.text, date:new Date()}; 
            lsosites.addObject(o); 
            localSites = lsosites.getObjects(); 
            ti3.text = '';                
        } 
        
        private function removeSite():void { 
            if (mySitesGrid.selectedIndex > -1) { 
            
localSites.removeItemAt(mySitesGrid.selectedIndex); 
            }       
        } 
 
        ]]> 
    </mx:Script> 
        
    <mx:Label text="Blog aggregator" fontSize="28"/> 
    
    <mx:Panel title="Blogs"> 
        <mx:Form id="blogForm"> 
            <mx:HBox> 
                <mx:FormItem label="Name:"> 
                    <mx:TextInput id="ti1" width="100"/> 
                </mx:FormItem> 
                <mx:FormItem label="Location:"> 
                    <mx:TextInput id="ti2" width="300"/> 
                </mx:FormItem> 
                <mx:Button id="b1" label="Add Feed" click="addFeed()"/> 
            </mx:HBox> 
 
            <mx:FormItem label="Existing Feeds:"> 
                <mx:DataGrid 
                    id="myFeedsGrid" 
                    dataProvider="{localFeeds}" 
                    width="400" 
                /> 
            </mx:FormItem> 
            <mx:Button id="b2" label="Remove Feed" click="removeFeed()"/> 
        </mx:Form> 
    </mx:Panel> 
    
    <mx:Panel title="Sites"> 
        <mx:Form id="siteForm"> 
            <mx:HBox> 
                <mx:FormItem label="Site:"> 
                    <mx:TextInput id="ti3" width="400"/> 
                </mx:FormItem> 
                <mx:Button id="b3" label="Add Site" click="addSite()"/> 
            </mx:HBox> 
 
            <mx:FormItem label="Existing Sites:"> 
                <mx:DataGrid 
                    id="mySitesGrid" 
                    dataProvider="{localSites}" 
                    width="400" 
                /> 
            </mx:FormItem> 
            <mx:Button id="b4" label="Remove Site" click="removeSite()"/> 
        </mx:Form> 
    </mx:Panel> 
    
</mx:Application>

Speichern von typisierten Objekten in gemeinsamen Objekten

Sie können typisierte ActionScript-Instanzen in gemeinsamen Objekten speichern. Rufen Sie dazu die flash.net.registerClassAlias() -Methode auf, um die Klasse zu registrieren. Sie erhalten eine typisierte Instanz, wenn Sie eine Instanz der Klasse erstellen und sie im Datenmember des gemeinsamen Objekts speichern und später das Objekt lesen. Standardmäßig unterstützt die objectEncoding -Eigenschaft des SharedObject die AMF3-Kodierung und extrahiert die gespeicherte Instanz aus dem SharedObject-Objekt; der Typ der gespeicherten Instanz entspricht jenem, den Sie beim Aufruf der registerClassAlias() -Methode angegeben haben.

(nur iOS) Cloud-Backup für lokale freigegebene Objekte verhindern

Sie können die SharedObject.preventBackup -Eigenschaft festlegen, um zu steuern, ob lokale freigegebene Objekte über den iOS-Cloud-Backup-Dienst gesichert werden. Dies ist laut Apple erforderlich bei Inhalten, die neu generiert oder heruntergeladen werden können, jedoch für das einwandfreie Funktionieren Ihrer Anwendung bei Offline-Verwendung notwendig sind.

Erstellen von mehreren gemeinsamen Objekten

Sie können mehrere gemeinsame Objekte für dieselbe Flex-Anwendung erstellen. Weisen Sie dazu jedem einen anderen Instanznamen zu, wie im nachstehenden Beispiel dargestellt:

public var mySO:SharedObject = SharedObject.getLocal("preferences"); 
public var mySO2:SharedObject = SharedObject.getLocal("history");

So werden die Dateien „preferences.sol“ und „history.sol“ im Stammverzeichnis der Flex-Anwendung angelegt.

Erstellen eines sicheren SharedObject

Wenn Sie mit getLocal() oder getRemote() ein lokales oder entferntes SharedObject erstellen, gibt es einen optionalen Parameter namens secure , mit dem festgelegt werden kann, ob der Zugriff auf dieses gemeinsame Objekt auf SWF-Dateien beschränkt ist, die über eine HTTPS-Verbindung bereitgestellt werden. Wenn dieser Parameter auf true eingestellt ist und Ihre SWF-Datei über HTTPS bereitgestellt wird, erstellt Flash Player ein neues sicheres gemeinsames Objekt oder ruft einen Verweis auf ein vorhandenes sicheres gemeinsames Objekt ab. Dieses sichere gemeinsame Objekt kann nur durch SWF-Dateien gelesen oder geschrieben werden, die über HTTPS bereitgestellt werden und die SharedObject.getLocal() mit der Einstellung true für den secure-Parameter aufrufen. Wenn dieser Parameter auf false eingestellt ist und Ihre SWF-Datei über HTTPS bereitgestellt wird, erstellt Flash Player ein neues gemeinsames Objekt oder ruft einen Verweis auf ein vorhandenes gemeinsames Objekt ab.

An diesem gemeinsamen Objekt können nur SWF-Dateien Lese- oder Schreibvorgänge durchführen, die über andere Verbindungen als HTTPS bereitgestellt werden. Wenn die SWF-Datei über eine andere Verbindung als HTTPS bereitgestellt wird und Sie diesen Parameter auf true einstellen, schlägt die Erstellung des neuen gemeinsamen Objekts (bzw. der Zugriff auf ein zuvor erstelltes sicheres gemeinsames Objekt) fehl. Es wird ein Fehler ausgelöst und das gemeinsame Objekt wird auf null gesetzt. Wenn Sie versuchen, den folgenden Codeausschnitt über eine andere Verbindung als HTTPS auszuführen, löst die SharedObject.getLocal() -Methode einen Fehler aus:

try 
{ 
    var so:SharedObject = SharedObject.getLocal("contactManager", null, true); 
} 
catch (error:Error) 
{ 
    trace("Unable to create SharedObject."); 
}

Unabhängig vom Wert dieses Parameters belegen die erstellten gemeinsamen Objekte einen Teil des von einer Domäne belegten Speicherplatzes.

Anzeigen des Inhalts eines gemeinsamen Objekts

Werte werden in der data -Eigenschaft von gemeinsamen Objekten gespeichert. Sie können jeden Wert innerhalb einer gemeinsamen Objektinstanz durchlaufen. Verwenden Sie hierzu eine for..in -Schleife, wie im folgenden Beispiel gezeigt:

var so:SharedObject = SharedObject.getLocal("test"); 
so.data.hello = "world"; 
so.data.foo = "bar"; 
so.data.timezone = new Date().timezoneOffset; 
for (var i:String in so.data) 
{ 
    trace(i + ":\t" + so.data[i]); 
}

Zerstören von gemeinsamen Objekten

Sie zerstören ein SharedObject auf dem Client, indem Sie die SharedObject.clear() -Methode verwenden. Die Verzeichnisse im Standardpfad der gemeinsamen Objekte der Anwendung werden dabei nicht zerstört.

Im folgenden Beispiel wird die SharedObject-Datei auf dem Client gelöscht:

public function destroySharedObject():void { 
    mySO.clear(); 
}

SharedObject-Beispiel

Das folgende Beispiel zeigt, dass Sie einfache Objekte, wie beispielsweise Date-Objekte, in einem SharedObject -Objekt speichern können, ohne diese Objekte manuell zu serialisieren oder zu deserialisieren.

Im nachstehenden Beispiel werden Sie zunächst als neuer Besucher begrüßt. Wenn Sie auf „Abmelden“ klicken, speichert die Anwendung das aktuelle Datum in einem gemeinsamen Objekt. Wenn Sie diese Anwendung das nächste Mal starten oder die Seite aktualisieren, gibt die Anwendung die Uhrzeit Ihrer Abmeldung an.

Um zu sehen, wie die Anwendung funktioniert, starten Sie die Anwendung, klicken auf „Abmelden“ und aktualisieren anschließend die Seite. Die Anwendung zeigt das Datum und die Uhrzeit der Abmeldung bei Ihrem letzten Besuch. Sie können die gespeicherten Informationen jederzeit löschen. Klicken Sie dazu auf die Schaltfläche „Delete LSO“.

<?xml version="1.0"?> 
<!-- lsos/WelcomeMessage.mxml --> 
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" initialize="initApp()"> 
  <mx:Script><![CDATA[ 
  public var mySO:SharedObject; 
  [Bindable] 
  public var welcomeMessage:String; 
 
  public function initApp():void { 
     mySO = SharedObject.getLocal("mydata"); 
     if (mySO.data.visitDate==null) { 
        welcomeMessage = "Hello first-timer!" 
     } else { 
        welcomeMessage = "Welcome back. You last visited on " + 
           getVisitDate(); 
     } 
  } 
 
  private function getVisitDate():Date { 
     return mySO.data.visitDate; 
  } 
 
  private function storeDate():void { 
     mySO.data.visitDate = new Date(); 
     mySO.flush(); 
  } 
  
  private function deleteLSO():void { 
     // Deletes the SharedObject from the client machine. 
     // Next time they log in, they will be a 'first-timer'. 
     mySO.clear(); 
  } 
  
  ]]></mx:Script> 
  <mx:Label id="label1" text="{welcomeMessage}"/> 
  <mx:Button label="Log Out" click="storeDate()"/> 
  <mx:Button label="Delete LSO" click="deleteLSO()"/> 
</mx:Application>