> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kameleoon.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Java SDK

> Integrieren Sie das Kameleoon Java SDK, um Experiments auszuführen und feature flags auf Java EE- oder Jakarta EE-Anwendungsservern zu aktivieren.

Mit dem Kameleoon Java SDK können Sie Experiments ausführen und feature flags auf Ihrem Java EE / Jakarta EE Anwendungsserver aktivieren.

**Erste Schritte**: Hilfe für den Einstieg finden Sie im [Entwicklerhandbuch](#developer-guide)

**Changelog**: Aktuelle Version des Java SDK: 4.22.0 [Changelog](https://github.com/Kameleoon/client-java/blob/master/CHANGELOG.md).

**SDK-Methoden**: Die vollständige Referenzdokumentation des Java SDK finden Sie im Abschnitt [Referenz](#reference).

## Developer guide

Dieser Leitfaden soll Ihnen helfen, unser SDK in wenigen Minuten zu integrieren und mit der Durchführung von Experiments in Ihren Java-Anwendungen zu beginnen.

### Getting started

#### Starter kit

Um den Einstieg zu erleichtern, stellt Kameleoon ein Starter Kit und eine Demo-Anwendung zum Testen des SDK bereit. Das Starter Kit enthält eine vollständig konfigurierte App mit Beispielen, die zeigen, wie SDK-Methoden in einer App verwendet werden können. Das Starter Kit, die Demo-Anwendung und detaillierte Anweisungen sind unter [Starter kit for Java](https://github.com/Kameleoon/java-examples) verfügbar.

#### Install the Java client

Das Installationspaket ist im Maven Central Repository verfügbar. Sie können das Java SDK installieren, indem Sie eine Abhängigkeit in die `pom.xml`-Datei Ihres Projekts einfügen, wie im Beispiel rechts gezeigt. Wenn Sie ein anderes Projektmanagementsystem verwenden, finden Sie auf der Seite [integrations](https://search.maven.org/artifact/com.kameleoon/kameleoon-client-java) weitere Beispiele.

<Tabs>
  <Tab title="Java EE">
    ```java title="pom.xml" theme={null}
    <dependency>
      <groupId>com.kameleoon</groupId>
      <artifactId>kameleoon-client-java</artifactId>
      <version>4.16.0</version>
    </dependency>
    ```
  </Tab>

  <Tab title="Jakarta EE">
    ```java title="pom.xml" theme={null}
    <dependency>
      <groupId>com.kameleoon</groupId>
      <artifactId>kameleoon-client-java-jakarta</artifactId>
      <version>4.16.0</version>
    </dependency>
    ```
  </Tab>
</Tabs>

#### Additional configuration

Erstellen Sie eine `.properties`-Konfigurationsdatei, um Anmeldeinformationen bereitzustellen und das SDK-Verhalten anzupassen. Sie können auch [unsere Beispiel-Konfigurationsdatei herunterladen](/assets/developer-docs/sdks/web-sdks/client-configs/client-java.properties).

Wir empfehlen, diese Datei im Standardpfad `/etc/kameleoon/client-java.conf` zu speichern, aber Sie können sie überall im Classpath als `kameleoon-client-java.properties` speichern.

Die folgende Tabelle zeigt die verfügbaren Eigenschaften, die Sie festlegen können:

| Schlüssel                                                              | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Standardwert          |
| ---------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
| `clientId` / `client_id` (*erforderlich*)                              | Erforderlich für die Authentifizierung beim Kameleoon-Dienst. Um Ihre `client_id` zu finden, lesen Sie die Dokumentation [API credentials](/user-manual/account-and-team-management/users-and-teams/api-credentials).                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                       |
| `clientSecret` / `client_secret` (*erforderlich*)                      | Erforderlich für die Authentifizierung beim Kameleoon-Dienst. Um Ihr `client_secret` zu finden, lesen Sie die Dokumentation [API credentials](/user-manual/account-and-team-management/users-and-teams/api-credentials).                                                                                                                                                                                                                                                                                                                                                                                                                                                               |                       |
| `sessionDuration` / `session_duration_minute` (*optional*)             | Bezeichnet das vordefinierte Zeitintervall, in dem Kameleoon den Besucher und die zugehörigen Daten im Arbeitsspeicher (RAM) speichert. Beachten Sie, dass eine Erhöhung der Sitzungsdauer die Menge an RAM erhöht, die zum Speichern der Besucherdaten zugewiesen werden muss.                                                                                                                                                                                                                                                                                                                                                                                                        | `30` Minuten          |
| `refreshInterval` / `refresh_interval_minute` (*optional*)             | Gibt das Aktualisierungsintervall in Minuten an, in dem das SDK die Konfiguration für die aktiven Experiments und feature flags abruft. Der Wert bestimmt die maximale Zeit, die benötigt wird, um Änderungen wie das Aktivieren oder Deaktivieren von feature flags oder das Starten von Experiments an Ihre Produktionsserver zu übermitteln. Zusätzlich bieten wir einen [Streaming-Modus](/developer-docs/feature-experimentation/technical-reference/technical-considerations/#streaming-premium-option) an, der server-sent events (SSE) verwendet, um neue Konfigurationen automatisch an das SDK zu pushen und neue Konfigurationen in Echtzeit ohne Verzögerungen anzuwenden. | `60` Minuten          |
| `defaultTimeout` / `default_timeout_millisecond` (*optional*)          | Gibt das Timeout in Millisekunden für Netzwerkanfragen vom SDK an. Setzen Sie den Wert auf 30 Sekunden oder mehr, wenn Sie keine stabile Verbindung haben. Einige Methoden haben einen zusätzlichen Parameter, mit dem Sie das Standard-Timeout für diese spezielle Methode überschreiben können. Wenn Sie das Timeout für eine Methode nicht explizit angeben, verwendet das SDK diesen Standardwert.                                                                                                                                                                                                                                                                                 | `10000` Millisekunden |
| `trackingInterval` / `tracking_interval_millisecond` (*optional*)      | Gibt das Intervall für Tracking-Anfragen in Millisekunden an. Alle Besucher, die Kameleoon für ein feature flag ausgewertet hat oder deren Daten geflusht wurden, sind in dieser Tracking-Anfrage enthalten, die das SDK einmal pro Intervall durchführt. Der Mindestwert ist `1000` ms, was auch der Standardwert ist, und der Höchstwert ist `5000` ms.                                                                                                                                                                                                                                                                                                                              | `1000` Millisekunden  |
| `environment` / `environment` (*optional*)                             | Umgebung, aus der die Konfiguration des feature flags verwendet werden soll. Der Wert kann `production`, `staging`, `development` sein. Siehe den Artikel [managing environments](/user-manual/experimentation/feature-experimentation/configure-your-feature-flags/manage-environments) für Details.                                                                                                                                                                                                                                                                                                                                                                                  | `production`          |
| `topLevelDomain` / `top_level_domain` *(im Hybrid-Modus erforderlich)* | Die aktuelle Top-Level-Domain für Ihre Website. Verwenden Sie das Format: `example.com`. Schließen Sie nicht `https://`, `www` oder andere Subdomains ein. Kameleoon verwendet diese Information, um das entsprechende Cookie auf der Top-Level-Domain zu setzen.                                                                                                                                                                                                                                                                                                                                                                                                                      | `null`                |
| `proxyHost` / `proxy_host` (*optional*)                                | Legt den Proxy-Host für alle ausgehenden Serveraufrufe des SDK fest.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `null`                |
| `networkDomain` / `network_domain` (*optional*)                        | Benutzerdefinierte Domain, die von SDKs für ausgehende Anfragen verwendet wird, häufig für das Proxying. Muss eine gültige Domain sein (z. B. example.com oder sub.example.com). Ungültige Formate werden auf den Standardwert von Kameleoon gesetzt.                                                                                                                                                                                                                                                                                                                                                                                                                                  | `null`                |

#### Initialize the Kameleoon client

Nachdem Sie das SDK in Ihre Anwendung installiert und Ihre Anmeldeinformationen und das SDK-Verhalten (in `/etc/kameleoon/client-java.conf`) konfiguriert haben, besteht der nächste Schritt darin, den Kameleoon-Client in Ihrem Anwendungscode zu erstellen. Zum Beispiel:

```java theme={null}
import com.kameleoon.KameleoonClientFactory;

String siteCode = "a8st4f59bj";

try {
    KameleoonClient kameleoonClient = KameleoonClientFactory.create(siteCode, "custom/file/path/client-java.properties");
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}

try {
    KameleoonClientConfig config = new KameleoonClientConfig.Builder()
    .clientId("<clientId>") // mandatory
    .clientSecret("<clientSecret>") // mandatory
    .refreshInterval(60) // in minutes, optional (60 minutes by default)
    .sessionDuration(30) // in minutes, optional (30 minutes by default)
    .defaultTimeout(10_000) // in milliseconds, optional (10000 ms by default)
    .trackingInterval(1000) // in milliseconds, optional (1000 ms by default)
    .topLevelDomain("example.com") // mandatory if you use hybrid mode (engine or web experiments)
    .environment("development") // optional
    .proxyHost(new HttpHost("192.168.0.25", 8080, "http")) // optional
    .networkDomain("example.com") // optional
    .build();
    KameleoonClientFactory.create(siteCode, config);
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}
```

Ein KameleoonClient ist ein Singleton-Objekt, das eine Brücke zwischen Ihrer Anwendung und der Kameleoon-Plattform schlägt. Es enthält alle Methoden und Eigenschaften, die Sie zur Durchführung eines Experiments benötigen. Beachten Sie, dass wir auch die Verwendung eines HTTP-Proxys im Java SDK unterstützen (siehe die Referenz der Methode [`create()`](#create) für Details).

<Note>
  Es liegt in Ihrer Verantwortung, die ordnungsgemäße Logik Ihres Anwendungscodes im Kontext von A/B test über Kameleoon sicherzustellen. Eine bewährte Praxis ist es, immer davon auszugehen, dass Sie den aktuellen Besucher aus dem Experiment ausschließen können, wenn Sie das Experiment nicht gestartet haben. Dieser Ausschluss ist einfach, da er der Implementierung der Standard- und Referenzvariation-Logik entspricht.
</Note>

Sie sind nun bereit, mit der Erstellung und Implementierung von Experiments und feature flagging zu beginnen.

#### Activating a feature flag

##### Assigning a unique ID to a user

Um einem Benutzer eine eindeutige ID zuzuweisen, können Sie die Methode [`getVisitorCode()`](#getvisitorcode) verwenden. Wenn ein **visitor code** nicht existiert (aus dem Cookie der Anfrage-Header), generiert die Methode eine zufällige eindeutige ID oder verwendet einen `defaultVisitorCode`, den Sie generiert hätten. Die ID wird dann in einem Cookie der Antwort-Header festgelegt.

Wenn Sie Kameleoon im [Hybrid mode](/developer-docs/feature-experimentation/get-started/hybrid-experimentation) verwenden, stellt der Aufruf der Methode `getVisitorCode()` sicher, dass die eindeutige ID (**visitor code**) zwischen der Anwendungsdatei `engine.js` (früher `kameleoon.js` genannt) und dem SDK geteilt wird.

##### Retrieving a flag configuration

Um ein feature flag in Ihrem Code zu implementieren, müssen Sie zunächst das feature flag in Ihrem Kameleoon-Konto erstellen.

Um den Status oder die Variation eines feature flags für einen bestimmten Benutzer zu bestimmen, sollten Sie die Methode [`getVariation()`](#getvariation) oder [`isFeatureActive()`](#isfeatureactive) verwenden, um die Konfiguration basierend auf der `featureKey` abzurufen.

Die Methode `getVariation()` verarbeitet sowohl einfache feature flags mit ON/OFF-Zuständen als auch komplexere Flags mit mehreren Variationen. Die Methode ruft die entsprechende Variation für den Benutzer ab, indem sie die Feature-Regeln prüft, die Variation zuweist und sie basierend auf der `featureKey` und dem `visitorCode` zurückgibt.

Die Methode `isFeatureActive()` kann verwendet werden, wenn Sie die Konfiguration eines einfachen feature flags abrufen möchten, das nur einen ON- oder OFF-Zustand hat, im Gegensatz zu komplexeren feature flags mit mehreren Variationen oder Targeting-Optionen.

Wenn Ihr feature flag zugehörige Variablen hat (wie spezifische Verhaltensweisen, die an jede Variation gebunden sind), ermöglicht Ihnen `getVariation()` auch den Zugriff auf das [`Variation`](#variation)-Objekt, das Details über die zugewiesene Variation und das zugehörige Experiment liefert. Diese Methode prüft, ob der Benutzer targetiert ist, findet die dem Besucher zugewiesene Variation und speichert sie im Speicher. Wenn `track=true`, sendet das SDK das Expositionsereignis an das angegebene Experiment bei der nächsten Tracking-Anfrage, die automatisch basierend auf dem [`tracking_interval_millisecond`](#additional-configuration) des SDK ausgelöst wird. Standardmäßig ist dieses Intervall auf 1000 Millisekunden (1 Sekunde) eingestellt.

Die Methode `getVariation()` ermöglicht es Ihnen zu steuern, ob ein Tracking durchgeführt wird. Wenn `track=false`, werden keine Expositionsereignisse vom SDK gesendet. Dies ist nützlich, wenn Sie es vorziehen, Daten nicht über das SDK zu verfolgen und sich stattdessen beispielsweise auf das vom Kameleoon-Engine verwaltete clientseitige Tracking zu verlassen. Außerdem ist `track=false` hilfreich, wenn Sie die Methode `getVariations()` verwenden, bei der Sie möglicherweise nur die Variationen für alle Flags benötigen, ohne Tracking-Ereignisse auszulösen. Wenn Sie mehr darüber erfahren möchten, wie Tracking funktioniert, lesen Sie [diesen Artikel](/developer-docs/feature-experimentation/technical-reference/faq-global#when-does-the-sdk-send-a-tracking-request-for-analytics)

##### Adding data points to target a user or filter / breakdown visits in reports

Um einen Benutzer zu targetieren, stellen Sie sicher, dass Sie relevante Datenpunkte zu seinem Profil hinzugefügt haben, bevor Sie die Feature-Variation abrufen oder prüfen, ob das Flag aktiv ist. Verwenden Sie die Methode [`addData()`](#adddata), um diese Datenpunkte zum Profil des Benutzers hinzuzufügen.

Um Datenpunkte abzurufen, die auf anderen Geräten gesammelt wurden, oder um auf vergangene Benutzerdaten zuzugreifen (clientseitig gesammelt, wenn Kameleoon im Hybrid-Modus verwendet wird), verwenden Sie die Methode [`getRemoteVisitorData()`](#getremotevisitordata). Diese Methode ruft Daten asynchron von den Servern ab. Es ist wichtig, `getRemoteVisitorData()` *vor* dem Abrufen der Variation oder dem Prüfen, ob das feature flag aktiv ist, aufzurufen, da diese Daten möglicherweise erforderlich sind, um einem Benutzer eine bestimmte Variation zuzuweisen.

Um mehr über verfügbare Targeting-Bedingungen zu erfahren, lesen Sie den [detaillierten Artikel zum Thema](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation).

Darüber hinaus sind die Datenpunkte, die Sie dem Besucherprofil hinzufügen, bei der Analyse Ihrer Experiments verfügbar, sodass Sie Ihre Ergebnisse nach Faktoren wie Gerät und Browser filtern und aufschlüsseln können. Der Kameleoon-Hybrid-Modus sammelt automatisch eine Vielzahl von Datenpunkten auf der Client-Seite, was die Aufschlüsselung Ihrer Ergebnisse basierend auf diesen vorab gesammelten Datenpunkten erleichtert. Sehen Sie die vollständige Liste [hier](/de/user-manual/experiment-analytics/analyze-results/results-page/results-page-settings#zielgruppe-aufschlüsseln).

Wenn Sie zusätzliche Datenpunkte verfolgen möchten, die über das automatisch gesammelte hinausgehen, können Sie Kameleoons [Custom Data Feature](#customdata) verwenden. Custom Data ermöglicht es Ihnen, spezifische Informationen, die für Ihre Experiments relevant sind, zu erfassen und zu analysieren. Vergessen Sie nicht, die Methode [`flush()`](#flush) aufzurufen, um die gesammelten Daten an die Kameleoon-Server zur Analyse zu senden.

<Note>
  Um die Genauigkeit Ihrer Ergebnisse zu gewährleisten, wird empfohlen, Bots mithilfe des Datentyps [`UserAgent`](#useragent) herauszufiltern.
</Note>

##### Tracking goal conversions

Wenn ein Benutzer eine gewünschte Aktion ausführt (z. B. einen Kauf tätigt), wird dies als Konversion aufgezeichnet. Um Konversionen zu verfolgen, verwenden Sie die Methode [`trackConversion()`](#trackconversion) und geben Sie die erforderlichen Parameter `visitorCode` und `goalId` an.

Die Konversions-Tracking-Anfrage wird zusammen mit der nächsten geplanten Tracking-Anfrage gesendet, die das SDK in regelmäßigen Abständen sendet (definiert durch [`tracking_interval_millisecond`](#additional-configuration)). Wenn Sie die Anfrage sofort senden möchten, verwenden Sie die Methode [`flush()`](#flush) mit dem Parameter `instant=true`.

##### Sending events to analytics solutions

Um Konversionen zu verfolgen und Expositionsereignisse an Ihre Customer-Analytics-Lösung zu senden, müssen Sie zunächst Kameleoon im [Hybrid mode](/developer-docs/feature-experimentation/get-started/hybrid-experimentation/) implementieren. Verwenden Sie dann die Methode [`getEngineTrackingCode()`](#getenginetrackingcode).

Die Methode `getEngineTrackingCode()` ruft den eindeutigen Tracking-Code ab, der erforderlich ist, um Expositionsereignisse an Ihre Analytics-Lösung zu senden. Mit dieser Methode können Sie Ereignisse aufzeichnen und an Ihre gewünschte Analytics-Plattform senden.

### Using a custom bucketing key

Standardmäßig verwendet Kameleoon eine eindeutige, anonyme Besucher-ID (`visitorCode`), um Benutzer feature flag-Variationen zuzuweisen. Diese ID wird normalerweise auf dem Gerät des Benutzers generiert und gespeichert (in einem Browser-Cookie für client- und serverseitige SDKs — im persistenten Speicher für mobile SDKs). In bestimmten Szenarien müssen Sie jedoch möglicherweise sicherstellen, dass alle Benutzer derselben Organisation dieselbe Variante eines feature flags sehen.

Die Option **Custom Bucketing Key** ermöglicht es Ihnen, dieses Standardverhalten zu überschreiben, indem Sie Ihre eigene benutzerdefinierte Kennung für das Bucketing bereitstellen. Diese Überschreibung stellt sicher, dass die Zuweisungslogik von Kameleoon Ihren angegebenen Schlüssel anstelle des standardmäßigen `visitorCode` verwendet.

#### Use cases

Die Verwendung eines custom bucketing keys ist entscheidend für die Aufrechterhaltung von Konsistenz und Genauigkeit in Ihren feature flag-Zuweisungen, insbesondere in diesen Situationen:

* **Experiments auf Konto- oder Organisationsebene:** Für B2B-Produkte oder Szenarien, in denen Sie alle Benutzer derselben Organisation derselben Variation zuweisen möchten, können Sie eine Kennung wie eine `accountId` verwenden. Custom bucketing keys sind entscheidend für A/B test-Features, die sich auf ein ganzes Team oder Unternehmen auswirken.

Durch die Implementierung eines custom bucketing keys gewährleisten Sie eine größere Konsistenz und Genauigkeit in Ihren Experiments, was zu zuverlässigeren Ergebnissen und einer besseren Benutzererfahrung führt.

#### Technical details

Wenn Sie einen custom bucketing key für ein feature flag konfigurieren, stellen Sie Kameleoon eine bestimmte Kennung aus den Daten Ihrer Anwendung zur Verfügung:

```java theme={null}
kameleoonClient.addData(visitorCode, new CustomData(index, "newVisitorCode"));
```

* **Bereitstellung des benutzerdefinierten Schlüssels:** Sie stellen dem Kameleoon SDK Ihre benutzerdefinierte Kennung mithilfe der Methode [`addData()`](#adddata) zur Verfügung. In dieser Methode übergeben Sie Ihren gewählten custom bucketing key als [`CustomData`](#customdata)-Objekt. Hier bezieht sich `newVisitorCode` auf die Kennung, die Sie für Ihr Bucketing verwenden möchten (z. B. die neue `userId` oder `accountId`).

<Warning>
  Damit der custom bucketing key korrekt funktioniert, muss er auch für das feature flag während des Erstellungs- oder Bearbeitungsprozesses des Flags definiert und konfiguriert werden. Ohne diese entsprechende Konfiguration wendet das Bucketing des SDK Ihren benutzerdefinierten Schlüssel nicht an. Detaillierte Anweisungen zur Einrichtung in Kameleoon finden Sie in diesem [Artikel](/user-manual/experimentation/feature-experimentation/create-and-manage-flags/create-a-feature-flag#Advanced_Flag_Settings).
</Warning>

* **Bucketing-Logik:** Sobald ein custom bucketing key über die Methode `addData()` bereitgestellt wird, verwenden alle Hash-Berechnungen zur Zuweisung von Benutzern zu Variationen diesen `newVisitorCode` (Ihren benutzerdefinierten Schlüssel) anstelle des standardmäßigen `visitorCode`. Die Verwendung des `newVisitorCode` bedeutet, dass die Bucketing-Entscheidung an Ihre benutzerdefinierte Kennung gebunden ist, was konsistente Zuweisungen in verschiedenen Kontexten gewährleistet, in denen diese Kennung vorhanden ist.
* **Datentracking und Analytik:** Es ist wichtig zu beachten, dass, während der `newVisitorCode` (Ihr benutzerdefinierter Schlüssel) für Bucketing-Entscheidungen verwendet wird, **alle nachfolgenden Daten (z. B. Tracking-Ereignisse und Konversionen) gesendet und dem *ursprünglichen* `visitorCode` zugeordnet werden.** Diese Trennung stellt sicher, dass Ihre Analytik die individuellen Benutzerreisen und Interaktionen innerhalb des breiteren Kontexts Ihres Experiments genau widerspiegelt, selbst wenn das Bucketing auf einer höheren Ebene (wie einem Konto) oder über mehrere Geräte/Sitzungen hinweg durchgeführt wird. Ihre ursprünglichen Besucherdaten bleiben für umfassende Berichte intakt.

#### Technical requirementes

Um einen custom bucketing key effektiv zu verwenden:

* Der Schlüssel muss ein `String` sein.
* Er muss für die Entität, die Sie bucketen möchten, eindeutig sein (z. B. wenn Sie eine `userId` verwenden, sollte die ID jedes Benutzers eindeutig sein).
* Der Schlüssel muss dem SDK genau zu dem Zeitpunkt zur Verfügung stehen, zu dem die feature flag-Entscheidung für diesen Benutzer oder diese Anfrage ausgewertet wird.

### Targeting conditions

Die Kameleoon SDKs unterstützen eine Vielzahl vordefinierter Targeting-Bedingungen, die Sie verwenden können, um Benutzer in Ihren Kampagnen zu targetieren. Die Liste der Bedingungen, die dieses SDK unterstützt, finden Sie unter [use visit history to target users](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation).

Sie können auch Ihre eigenen [externen Daten verwenden, um Benutzer zu targetieren](/developer-docs/apis/data-api-rest/tutorials/storing-and-retrieving-external-data-to-target-users).

### Cross-device experimentation

Um Besucher zu unterstützen, die von mehreren Geräten auf eine App zugreifen, ermöglicht Kameleoon die Synchronisierung zuvor gesammelter Besucherdaten über alle Geräte des Besuchers hinweg und die Abstimmung ihres Besuchsverlaufs über mehrere Geräte durch cross-device experimentation. Fallstudien und detaillierte Informationen darüber, wie Kameleoon Daten geräteübergreifend verarbeitet, finden Sie im [Artikel über cross-device experimentation](/developer-docs/cross-device-experimentation).

#### Synchronizing custom data across devices

Obwohl die Synchronisierung von benutzerdefinierten Mappings verwendet wird, um Besucherdaten geräteübergreifend abzugleichen, ist sie nicht immer notwendig. Im Folgenden finden Sie zwei Szenarien, in denen eine benutzerdefinierte Mapping-Synchronisierung nicht erforderlich ist:

**Gleiche User-ID auf allen Geräten**
Wenn dieselbe User-ID konsistent auf allen Geräten verwendet wird, wird die Synchronisierung automatisch ohne eine benutzerdefinierte Mapping-Synchronisierung gehandhabt. Es genügt, die Methode `getRemoteVisitorData()` aufzurufen, wenn Sie die zwischen mehreren Geräten gesammelten Daten synchronisieren möchten.

**Multi-Server-Instanzen mit konsistenten IDs**
In komplexen Setups mit mehreren Servern (z. B. verteilten Server-Instanzen), bei denen dieselbe User-ID auf allen Servern verfügbar ist, reicht die Synchronisierung zwischen Servern (mit `getRemoteVisitorData()`) aus, ohne dass eine zusätzliche benutzerdefinierte Mapping-Synchronisierung erforderlich ist.

Kunden, die zusätzliche Daten benötigen, können die Beschreibung der Methode [`getRemoteVisitorData()`](#getremotevisitordata) für weitere Anleitungen heranziehen. Im folgenden Code wird angenommen, dass dieselbe eindeutige Kennung (in diesem Fall der `visitorCode`, der auch als `userId` bezeichnet werden kann) konsistent zwischen den beiden Geräten für eine genaue Datenabfrage verwendet wird.

<Note>
  Wenn Sie gesammelte Daten in Echtzeit synchronisieren möchten, müssen Sie den Scope **Visitor** für Ihre Custom Data wählen.
</Note>

```java title="Device A" theme={null}
// In this example, a Custom data with index `90` was set to "Visitor" scope in Kameleoon.
final int VISITOR_SCOPE_CUSTOM_DATA_INDEX = 90;

kameleoonClient.addData(visitorCode, new CustomData(VISITOR_SCOPE_CUSTOM_DATA_INDEX, "your data"));
kameleoonClient.flush(visitorCode);
```

```java title="Device B" theme={null}
// Before working with the data, call the `getRemoteVisitorData` method.
kameleoonClient.getRemoteVisitorData(visitorCode).get();

// After calling the method, the SDK on Device B will have access to CustomData of Visitor scope defined on Device A.
// So, "your data" will be available for targeting and tracking the visitor.
```

#### Using custom data for session merging

[Cross-device experimentation](/developer-docs/cross-device-experimentation) ermöglicht das Zusammenführen des Verlaufs eines Besuchers über alle Geräte hinweg (Verlaufsabgleich). Der Verlaufsabgleich ermöglicht das Zusammenführen verschiedener Besuchersitzungen zu einer. Um den Besuchsverlauf abzugleichen, verwenden Sie [`CustomData`](#customdata), um eine eindeutige Kennung für den Besucher bereitzustellen. Weitere Informationen finden Sie in der [zugehörigen Dokumentation](/developer-docs/cross-device-experimentation/#activating-cross-device-history-reconciliation).

Nachdem der geräteübergreifende Abgleich aktiviert wurde, ruft der Aufruf von [`getRemoteVisitorData()`](#getremotevisitordata) mit dem Parameter `userId` alle bekannten Daten für einen bestimmten Benutzer ab.

Sitzungen mit derselben Kennung werden in einem Experiment immer dieselbe Variation angezeigt. In der Visitor-Ansicht der Ergebnisseiten Ihres Experiments werden diese Sitzungen als ein einzelner Besucher angezeigt.

Die SDK-Konfiguration stellt sicher, dass zugeordnete Sitzungen immer dieselbe Variation des Experiments sehen. Es gibt jedoch einige Einschränkungen hinsichtlich der geräteübergreifenden Variation-Zuweisung. Diese Einschränkungen sind [hier](/developer-docs/cross-device-experimentation#critical-points-and-practical-insights) beschrieben.

Folgen Sie dem Leitfaden [activating cross-device history reconciliation](#cross-device-experimentation), um Ihre Custom Data auf der Kameleoon-Plattform einzurichten.

Anschließend können Sie das SDK normal verwenden. Die folgenden Methoden können im Kontext der Sitzungszusammenführung hilfreich sein:

* `getRemoteVisitorData()` mit hinzugefügtem `UniqueIdentifier(true)` – um Daten für alle verknüpften Besucher abzurufen.
* [`trackConversion()`](#trackconversion) oder [`flush()`](#flush) mit hinzugefügten `UniqueIdentifier(true)`-Daten – um bestimmte Daten für einen bestimmten Besucher zu verfolgen, der mit einem anderen Besucher verknüpft ist.

<Tip>
  Da die Custom Data, die Sie als Kennung verwenden, auf den **Visitor-Scope** gesetzt werden müssen, müssen Sie die [geräteübergreifende Synchronisierung von Custom Data](/developer-docs/cross-device-experimentation) verwenden, um die Kennung mit der Methode [`getRemoteVisitorData()`](#getremotevisitordata) auf jedem Gerät abzurufen.
</Tip>

Hier ist ein Beispiel, wie Custom Data für die Sitzungszusammenführung verwendet werden kann.

```java theme={null}
// In this example, 91 represents the Custom Data's index configured as a unique identifier in Kameleoon.
final int MAPPING_INDEX = 91;
final String FEATURE_KEY = "ff123";

// 1. Before the visitor is authenticated

// Retrieve the variation for an unauthenticated visitor.
// Assume anonymousVisitorCode is the randomly generated ID for that visitor.
Variation anonymousVariation = kameleoonClient.getVariation(anonymousVisitorCode, FEATURE_KEY);

// 2. After the visitor is authenticated

// Assume `userId` is the visitor code of the authenticated visitor.
kameleoonClient.addData(anonymousVisitorCode, new CustomData(MAPPING_INDEX, userId));
kameleoonClient.flush(true, anonymousVisitorCode);

// Indicate that `userId` is a unique identifier.
kameleoonClient.addData(userId, new UniqueIdentifier(true));

// 3. After the visitor was authorized

// Retrieve the variation for the `userId`, which will match the anonymous visitor code's variation.
Variation userVariation = kameleoonClient.getVariation(userId, FEATURE_KEY);
boolean isSameVariation = userVariation.getKey().equals(anonymousVariation.getKey()); // true

// `userId` and `anonymousVisitorCode` are now linked and can be tracked as a single visitor.
kameleoonClient.trackConversion(userId, 123, 10.0);

// Additionally, the linked visitors share all fetched previously tracked remote data.
kameleoonClient.getRemoteVisitorData(userId).get();
```

In diesem Beispiel verfügt die Anwendung über eine Anmeldeseite. Da die User-ID zum Zeitpunkt der Anmeldung unbekannt ist, wird eine anonyme Besucher-Kennung verwendet, die von der Methode [`getVisitorCode()`](#getvisitorcode) generiert wird. Nachdem sich der Benutzer angemeldet hat, wird der anonyme Besucher mit der User-ID verknüpft und als eindeutige Kennung für den Besucher verwendet.

### Logging

Das SDK generiert Logs, um verschiedene interne Prozesse und Probleme widerzuspiegeln.

#### Log levels

Das SDK unterstützt die Konfiguration der Begrenzung der Protokollierung durch ein Log Level.

```java theme={null}
// The `NONE` log level does not allow logging.
com.kameleoon.logging.KameleoonLogger.setLogLevel(com.kameleoon.logging.LogLevel.NONE);

// The `ERROR` log level only allows logging issues that may affect the SDK's primary behaviour.
com.kameleoon.logging.KameleoonLogger.setLogLevel(com.kameleoon.logging.LogLevel.ERROR);

// The `WARNING` log level allows logging issues which may require an attention.
// It extends the `ERROR` log level.
// The `WARNING` log level is a default log level.
com.kameleoon.logging.KameleoonLogger.setLogLevel(com.kameleoon.logging.LogLevel.WARNING);

// The `INFO` log level allows logging general information on the SDK's internal processes.
// It extends the `WARNING` log level.
com.kameleoon.logging.KameleoonLogger.setLogLevel(com.kameleoon.logging.LogLevel.INFO);

// The `DEBUG` level logs additional details about the SDK’s internal processes and extends the `INFO` level
// with more granular. diagnostic output.
// This information is not intended for end-user interpretation but can be sent to our support team
// to assist with internal troubleshooting.
com.kameleoon.logging.KameleoonLogger.setLogLevel(com.kameleoon.logging.LogLevel.DEBUG);
```

#### Custom handling of logs

Das SDK schreibt seine Logs standardmäßig in die Konsolenausgabe. Dieses Verhalten kann überschrieben werden.

<Note>
  Die Begrenzung des Loggings durch ein Log Level erfolgt unabhängig von der Log-Handling-Logik.
</Note>

```java theme={null}
public class CustomLogger implements com.kameleoon.logging.Logger {
    private final java.util.logging.Logger inner;

    public CustomLogger(java.util.logging.Logger inner) {
        this.inner = inner;
    }

    // `log` method accepts logs from the SDK
    @Override
    public void log(com.kameleoon.logging.LogLevel level, String message) {
        // Custom log handling logic here. For example:
        switch (level) {
            case ERROR:
                inner.log(java.util.logging.Level.SEVERE, message);
                break;
            case WARNING:
                inner.log(java.util.logging.Level.WARNING, message);
                break;
            case INFO:
                inner.log(java.util.logging.Level.INFO, message);
                break;
            case DEBUG:
                inner.log(java.util.logging.Level.FINE, message);
                break;
        }
    }
}

// Log level filtering is applied separately from log handling logic.
// The custom logger will only accept logs that meet or exceed the specified log level.
// Ensure the log level is set correctly.
com.kameleoon.logging.KameleoonLogger.setLogLevel(com.kameleoon.logging.LogLevel.DEBUG); // Optional; defaults to `LogLevel.WARNING`.
com.kameleoon.logging.KameleoonLogger.setLogger(new CustomLogger());
```

## Reference

Dies ist die vollständige Referenzdokumentation für das Java SDK.

### Initialization

#### create()

Um das SDK zu verwenden, müssen Sie die Initialisierung abschließen. Ihre App führt alle Interaktionen mit dem SDK über ein Objekt der Klasse `KameleoonClient` durch. Erstellen Sie dieses Objekt mit der statischen Methode `create()` in `KameleoonClientFactory`.

```java theme={null}
import com.kameleoon.KameleoonClientFactory;

String siteCode = "a8st4f59bj";

try {
    KameleoonClient kameleoonClient = KameleoonClientFactory.create(siteCode, "custom/file/path/client-java.properties");
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}

try {
    KameleoonClientConfig config = new KameleoonClientConfig.Builder()
        .clientId("<clientId>") // mandatory
        .clientSecret("<clientSecret>") // mandatory
        .refreshInterval(60) // in minutes, optional (60 minutes by default)
        .sessionDuration(30) // in minutes, optional (30 minutes by default)
        .defaultTimeout(10_000) // in milliseconds, optional (10000 ms by default)
        .trackingInterval(1000) // in milliseconds, optional (1000 ms by default)
        .topLevelDomain("example.com") // mandatory if you use hybrid mode (engine or web experiments)
        .environment("development") // optional
        .proxyHost(new HttpHost("192.168.0.25", 8080, "http")) // optional
        .networkDomain("example.com") // optional
        .build();
    KameleoonClientFactory.create(siteCode, config);
} catch (KameleoonException.SiteCodeIsEmpty e) {
    // indicates that provided site code is empty
} catch (KameleoonException.ConfigCredentialsInvalid exception) {
    // indicates that provided clientId / clientSecret are not valid
}
```

##### Arguments

| Name                           | Typ                     | Beschreibung                                                                                                                            | Standardwert                      |
| ------------------------------ | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------- |
| siteCode (*erforderlich*)      | `String`                | Dies ist ein [eindeutiger Schlüssel](/user-manual/faq#how-do-i-find-my-sitecode) des Kameleoon-Projekts, das Sie mit dem SDK verwenden. |                                   |
| configurationPath (*optional*) | `String`                | Pfad zur SDK-Konfigurationsdatei.                                                                                                       | `/etc/kameleoon/client-java.conf` |
| kameleoonConfig (*optional*)   | `KameleoonClientConfig` | Konfigurations-SDK-Objekt, das Sie anstelle einer Konfigurationsdatei übergeben können.                                                 | `null`                            |

##### Return value

| Typ               | Beschreibung                                                                                                                     |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `KameleoonClient` | Eine Instanz der Klasse `KameleoonClient`, die Ihre App dann verwenden kann, um Ihre Experiments und feature flags zu verwalten. |

##### Exceptions thrown

| Typ                                         | Beschreibung                                                                                                                                                       |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| KameleoonException.ConfigCredentialsInvalid | Exception, die anzeigt, dass die angeforderten Anmeldeinformationen nicht bereitgestellt wurden (weder in der Konfigurationsdatei noch als Argumente der Methode). |
| KameleoonException.SiteCodeIsEmpty          | Exception, die anzeigt, dass der angegebene Site-Code ein leerer String ist, was ein ungültiger Wert ist.                                                          |

#### waitInit()

`waitInit()` wartet auf die Initialisierung des `KameleoonClient`. Mit dieser Methode können Sie prüfen, ob das SDK den Client erfolgreich initialisiert hat, bevor Sie mit anderen Operationen fortfahren.

<Note>
  Wenn die Methode `waitInit()` fehlschlägt, wird der Initialisierungsprozess ohne Unterbrechung fortgesetzt. Nachfolgende Aufrufe der Methode `waitInit()` geben Ergebnisse zurück, die den aktuellen Zustand des `KameleoonClient` widerspiegeln. Sie können also die Methode `waitInit()` mehrmals aufrufen, um den Status des SDK zu überprüfen.
</Note>

```java theme={null}
// Synchronized approach
try {
    kameleoonClient.waitInit().get();
} catch (InterruptedException | ExecutionException exception) {
    // Indicates that the client could not be initialized due to the thrown exception.
}

// Asynchronous approach
kameleeoonClient.waitInit().handle((res, ex) -> {
    if (ex != null) {
        // Indicates that the client could not be initialized due to the thrown exception.
    }
    return res;
});
```

##### Return value

| Typ                       | Beschreibung                                                                     |
| ------------------------- | -------------------------------------------------------------------------------- |
| `CompletableFuture<Void>` | Die Aufgabe wird abgeschlossen, wenn der Client erfolgreich initialisiert wurde. |

##### Exceptions thrown

| Typ         | Beschreibung                                                                                                        |
| ----------- | ------------------------------------------------------------------------------------------------------------------- |
| SDKNotReady | Exception, die anzeigt, dass der Client nicht ordnungsgemäß initialisiert ist und noch nicht verwendet werden kann. |

### Feature flags and variations

#### isFeatureActive()

* *📨 Sendet Tracking-Daten an Kameleoon (abhängig vom Parameter `track`)*

<Note>
  Diese Methode hieß zuvor `activeFeature` und wurde in SDK-Version `4.0.0` entfernt.
</Note>

Rufen Sie diese Methode auf, um zu prüfen, ob ein feature flag für einen bestimmten Benutzer aktiv sein soll. Diese Methode nimmt einen `visitorCode` und eine `featureKey` als obligatorische Argumente entgegen, um zu prüfen, ob das Feature für den Benutzer aktiv ist.

Wenn der Benutzer noch nie mit diesem feature flag verknüpft war, gibt das SDK einen zufälligen booleschen Wert zurück (entweder `true`, um den Benutzer zu diesem Feature hinzuzufügen, oder `false`, um ihn vom Feature auszuschließen). Wenn ein Benutzer mit dem angegebenen `visitorCode` bereits mit diesem feature flag registriert ist, erkennt das SDK den vorherigen `featureFlag`-Wert.

Stellen Sie sicher, dass Sie mögliche Exceptions abfangen und behandeln.

Wenn Sie einen `visitorCode` angeben, verwendet die Methode `isFeatureActive()` ihn als eindeutige Besucherkennung, was für [Cross-device experimentation](/developer-docs/cross-device-experimentation) nützlich ist. Wenn Sie einen `visitorCode` angeben und den Parameter `isUniqueIdentifier` auf `true` setzen, verknüpft das SDK die geflushten Daten mit dem Besucher, der mit der angegebenen Kennung verknüpft ist.

<Note>
  Der Parameter `isUniqueIdentifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).

  Der `isUniqueIdentifier` kann in besonderen Situationen hilfreich sein; zum Beispiel, wenn Sie nicht auf den anonymen `visitorCode` zugreifen können, der einem Besucher zugewiesen wurde, aber eine interne ID verwenden können, die über Session-Merging mit diesem Besucher verknüpft ist.
</Note>

```java theme={null}
String visitorCode = kameleoonClient.getVisitorCode(httpServletRequest, httpServletResponse);
String featureKey = "new_checkout";
Boolean hasNewCheckout = false;

try {
  hasNewCheckout = kameleoonClient.isFeatureActive(visitorCode, featureKey);
  // disabling tracking
  hasNewCheckout = kameleoonClient.isFeatureActive(false, visitorCode, featureKey);
} catch (KameleoonException.FeatureNotFound e) {
  // Feature toggle not yet activated on Kameleoon's side - we consider the feature inactive.
  hasNewCheckout = false;
} catch (Exception e) {
  // This is a generic exception handler that handles all exceptions.
  System.out.println("Exception occurred");
}
if (hasNewCheckout)
{
  // Implement new checkout code here
}
```

##### Arguments

| Name                            | Typ       | Beschreibung                                                                                                                                                       |
| ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| track                           | `boolean` | Ein optionaler Parameter zum Aktivieren oder Deaktivieren des Trackings der Feature-Evaluierung (`true` standardmäßig).                                            |
| visitorCode                     | `String`  | Eindeutige Kennung des Benutzers. Dieses Feld ist erforderlich.                                                                                                    |
| featureKey                      | `String`  | Schlüssel des Features, dessen Status Sie für den Benutzer prüfen möchten. Dieses Feld ist erforderlich.                                                           |
| isUniqueIdentifier (Deprecated) | `boolean` | Ein optionaler Parameter, um anzugeben, ob der visitorCode eine eindeutige Kennung ist. Wenn nicht angegeben, ist der Standardwert `false`. Das Feld ist optional. |

##### Return value

| Typ       | Beschreibung                                                              |
| --------- | ------------------------------------------------------------------------- |
| `boolean` | Wert des Features, der für den angegebenen `visitorCode` registriert ist. |

##### Exceptions thrown

| Typ                                   | Beschreibung                                                                                                                                                                                                                                                                                                                       |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.FeatureNotFound    | Exception, die anzeigt, dass die angeforderte Feature-ID in der internen Konfiguration des SDK nicht gefunden wurde. Diese Exception bedeutet normalerweise, dass das feature flag noch nicht auf der Kameleoon-Seite aktiviert wurde (aber der Code, der das Feature implementiert, bereits in der Anwendung bereitgestellt ist). |
| KameleoonException.VisitorCodeInvalid | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist. Er ist entweder leer oder länger als 255 Zeichen.                                                                                                                                                                                                  |

#### getVariation()

* 📨 *Sendet Tracking-Daten an Kameleoon (abhängig vom Parameter `track`)*

Ruft die [`Variation`](#variation) ab, die einem bestimmten Besucher für ein bestimmtes feature flag zugewiesen ist.

Diese Methode nimmt einen `visitorCode` und eine `featureKey` als obligatorische Argumente entgegen. Das `track`-Argument ist optional und standardmäßig `true`.

Sie gibt die zugewiesene `Variation` für den Besucher zurück. Wenn der Besucher mit keinen feature flag-Regeln verknüpft ist, gibt die Methode die Standard-`Variation` für das angegebene feature flag zurück.

Stellen Sie sicher, dass in Ihrem Code eine ordnungsgemäße Fehlerbehandlung implementiert ist, um mögliche Exceptions zu verwalten.

<Note>
  Die Standardvariation bezieht sich auf die Variation, die einem Besucher zugewiesen wird, wenn er nicht mit vordefinierten Delivery-Regeln für ein feature flag übereinstimmt. Mit anderen Worten, es ist die Fallback-Variation, die auf alle Benutzer angewendet wird, die nicht von bestimmten Regeln targetiert werden. Sie wird als die Variation im Abschnitt "Then, for everyone else..." in einer Verwaltungsoberfläche dargestellt.
</Note>

```java theme={null}
String visitorCode = kameleoonClient.getVisitorCode(httpServletRequest, httpServletResponse);
String featureKey = "new_checkout";
Variation variation;

try {
  variation = kameleoonClient.getVariation(visitorCode, featureKey);
  // disabling tracking
  variation = kameleoonClient.getVariation(visitorCode, featureKey, false);
} catch (KameleoonException.FeatureNotFound e) {
  // The error has occurred; the feature flag isn't found in the current configuration.
} catch (KameleoonException.FeatureEnvironmentDisabled e) {
  // The feature flag is disabled for the environment.
} catch (KameleoonException.VisitorCodeInvalid e) {
  // The visitor code you passed to the method is invalid and can't be accepted by SDK.
} catch (KameleoonException ex) {
  // Handle the common Kameleoon Exception
}

// Fetch a variable value for the assigned variation
String title = (String) variation.getVariables().get("title").getValue();

switch (variation.getKey()) {
  case 'on':
    // Main variation key is selected for visitorCode
    break;
  case 'alternative_variation':
    // Alternative variation key
    break;
  default:
    // Default variation key
    break;
}
```

##### Arguments

| Name                         | Typ       | Beschreibung                                                                                     | Standard |
| ---------------------------- | --------- | ------------------------------------------------------------------------------------------------ | -------- |
| visitorCode (*erforderlich*) | `String`  | Eindeutige Kennung des Besuchers.                                                                |          |
| featureKey (*erforderlich*)  | `String`  | Schlüssel des Features, das Sie einem Besucher zugänglich machen möchten.                        |          |
| track (*optional*)           | `boolean` | Ein optionaler Parameter zum Aktivieren oder Deaktivieren des Trackings der Feature-Evaluierung. | `true`   |

##### Return value

| Typ         | Beschreibung                                                                                              |
| ----------- | --------------------------------------------------------------------------------------------------------- |
| `Variation` | Eine zugewiesene [`Variation`](#variation) für einen bestimmten Besucher für ein bestimmtes feature flag. |

##### Exceptions thrown

| Typ                          | Beschreibung                                                                                                                                                                                                                                                                                                   |
| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid`         | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist. Er ist entweder leer oder länger als 255 Zeichen.                                                                                                                                                                              |
| `FeatureNotFound`            | Exception, die anzeigt, dass der angeforderte Feature-Key in der internen Konfiguration des SDK nicht gefunden wurde. Dies bedeutet normalerweise, dass das feature flag nicht in der Kameleoon-App aktiviert ist (aber der Code, der das Feature implementiert, bereits in der Anwendung bereitgestellt ist). |
| `FeatureEnvironmentDisabled` | Exception, die anzeigt, dass das feature flag für die aktuelle Umgebung des Besuchers deaktiviert ist (z. B. production, staging oder development).                                                                                                                                                            |

#### getVariations()

* 📨 *Sendet Tracking-Daten an Kameleoon (abhängig vom Parameter `track`)*

Ruft eine Map von [`Variation`](#variation)-Objekten ab, die einem bestimmten Besucher über alle feature flags hinweg zugewiesen sind.

Diese Methode iteriert über alle verfügbaren feature flags und gibt die zugewiesene `Variation` für jedes Flag zurück, das mit dem angegebenen Besucher verknüpft ist. Sie nimmt `visitorCode` als obligatorisches Argument entgegen, während `onlyActive` und `track` optional sind.

* Wenn `onlyActive` auf `true` gesetzt ist, gibt die Methode `getVariations()` feature flags-Variationen zurück, sofern der Benutzer nicht mit der `off`-Variation gebucketet ist.
* Der Parameter `track` steuert, ob die Methode die Variationszuweisungen verfolgt oder nicht. Standardmäßig ist er auf `true` gesetzt. Wenn er auf `false` gesetzt ist, wird das Tracking deaktiviert.

Die zurückgegebene Map besteht aus feature flag-Keys als Schlüsseln und ihren entsprechenden `Variation` als Werten. Wenn für ein feature flag keine Variation zugewiesen ist, gibt die Methode die Standard-`Variation` für dieses Flag zurück.

Eine ordnungsgemäße Fehlerbehandlung sollte implementiert werden, um mögliche Exceptions zu verwalten.

<Note>
  Die Standardvariation bezieht sich auf die Variation, die einem Besucher zugewiesen wird, wenn er nicht mit vordefinierten Delivery-Regeln für ein feature flag übereinstimmt. Mit anderen Worten, es ist die Fallback-Variation, die auf alle Benutzer angewendet wird, die nicht von bestimmten Regeln targetiert werden. Sie wird als die Variation im Abschnitt "Then, for everyone else..." in einer Verwaltungsoberfläche dargestellt.
</Note>

```java theme={null}
try {
    Map<String, Variation> variations = kameleoonClient.getVariations(visitorCode);
    // only active variations
    Map<String, Variation> variations = kameleoonClient.getVariations(visitorCode, true);
    // disable tracking
    Map<String, Variation> variations = kameleoonClient.getVariations(visitorCode, true, false);
} catch (VisitorCodeInvalid e) {
    //  Handle exception
}
```

##### Arguments

| Name                         | Typ       | Beschreibung                                                                                                                            | Standard |
| ---------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------- | -------- |
| visitorCode (*erforderlich*) | `String`  | Eindeutige Kennung des Besuchers.                                                                                                       |          |
| onlyActive (*optional*)      | `boolean` | Ein optionaler Parameter, der angibt, ob Variationen für aktive (`true`) oder alle (`false`) feature flags zurückgegeben werden sollen. | `false`  |
| track (*optional*)           | `boolean` | Ein optionaler Parameter zum Aktivieren oder Deaktivieren des Trackings der Feature-Evaluierung.                                        | `true`   |

##### Return value

| Typ                      | Beschreibung                                                                                                                                      |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Map<String, Variation>` | Map, die die zugewiesenen [`Variation`](#variation)-Objekte der feature flags unter Verwendung der Schlüssel der entsprechenden Features enthält. |

##### Exceptions thrown

| Typ                  | Beschreibung                                                                                                                      |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist. Er ist entweder leer oder länger als 255 Zeichen. |

#### setForcedVariation()

Die Methode ermöglicht es Ihnen, einem Benutzer programmatisch eine bestimmte [`Variation`](#variation) zuzuweisen und dabei den standardmäßigen Evaluierungsprozess zu umgehen. Dies ist besonders wertvoll für kontrollierte Experiments, bei denen die übliche Evaluierungslogik nicht erforderlich ist oder übersprungen werden muss. Es kann auch in Szenarien wie Debugging oder benutzerdefinierten Tests hilfreich sein.

Wenn eine **erzwungene** Variation festgelegt wird, überschreibt sie die Echtzeit-Evaluierungslogik von Kameleoon. Prozesse wie Segmentierung, Targeting-Bedingungen und algorithmische Berechnungen werden übersprungen. Um Segmentierung und Targeting-Bedingungen während eines Experiments zu erhalten, setzen Sie stattdessen `forceTargeting=false`.

<Info>
  **Simulierte** Variationen haben in der Ausführungsreihenfolge immer Vorrang. Wenn eine Berechnung einer **simulierten** Variation ausgelöst wird, wird sie zuerst vollständig verarbeitet und abgeschlossen.
</Info>

Eine erzwungene Variation wird genauso behandelt wie eine evaluierte Variation. Sie wird in der Analytik verfolgt und im Benutzerkontext wie jede standardmäßig evaluierte Variation gespeichert, was die Konsistenz im Reporting gewährleistet.

Die Methode kann unter bestimmten Bedingungen Exceptions auslösen (z. B. ungültige Parameter, Benutzerkontext oder interne Probleme). Eine ordnungsgemäße Exception-Behandlung ist unerlässlich, um sicherzustellen, dass Ihre Anwendung stabil und widerstandsfähig bleibt.

<Warning>
  Es ist wichtig, **erzwungene** Variationen von **[simulierten](#getvisitorcode)** Variationen zu unterscheiden:

  * **Forced variations**: Sind spezifisch für ein einzelnes Experiment.
  * **Simulated variations**: Beeinflussen das Gesamtergebnis des **feature flags**.
</Warning>

```java theme={null}
try {
    // Forcing the variation "on" for the feature flag "featureKey1" for the visitor
    final int experimentId = 9516;
    kameleoonClient.setForcedVariation(visitorCode, experimentId, "on");

    // Resetting the forced variation for the feature flag "featureKey1" for the visitor
    kameleoonClient.setForcedVariation(visitorCode, experimentId, null);
} catch (KameleoonException ex) {
    // Handle the common Kameleoon Exception
}
```

##### Arguments

| Name                          | Typ       | Beschreibung                                                                                                                                                                                       | Standard |
| ----------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
| visitorCode (*erforderlich*)  | `String`  | Eindeutige Kennung des Besuchers.                                                                                                                                                                  |          |
| experimentId (*erforderlich*) | `int`     | **Experiment Id**, die während des Evaluierungsprozesses targetiert und ausgewählt wird.                                                                                                           |          |
| variationKey (*erforderlich*) | `String`  | **Variation Key**, der einer `Variation` entspricht, die als zurückgegebener Wert für das Experiment erzwungen werden soll. Wenn der Wert `null` ist, wird die erzwungene Variation zurückgesetzt. |          |
| forceTargeting (*optional*)   | `boolean` | Gibt an, ob das Targeting für das Experiment erzwungen und übersprungen werden soll (`true`) oder wie im standardmäßigen Evaluierungsprozess angewendet werden soll (`false`).                     | `true`   |

##### Exceptions thrown

| Typ                         | Beschreibung                                                                                                                                                                                                                                                                 |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid`        | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist. Er ist entweder leer oder länger als 255 Zeichen.                                                                                                                                            |
| `FeatureExperimentNotFound` | Exception, die anzeigt, dass die angeforderte Experiment-ID in der internen Konfiguration des SDK nicht gefunden wurde. Dies ist normalerweise normal und bedeutet, dass das der Regel entsprechende Experiment noch nicht auf der Kameleoon-Seite aktiviert wurde.          |
| `FeatureVariationNotFound`  | Exception, die anzeigt, dass der angeforderte Variation-Key (ID) in der internen Konfiguration des SDK nicht gefunden wurde. Dies ist normalerweise normal und bedeutet, dass das der Variation entsprechende Experiment noch nicht auf der Kameleoon-Seite aktiviert wurde. |

<Info>
  In den meisten Fällen muss nur der grundlegende Fehler `KameleoonException` behandelt werden, wie im Beispiel gezeigt. Wenn jedoch verschiedene Fehlertypen eine Reaktion erfordern, behandeln Sie jeden basierend auf den spezifischen Anforderungen separat. Darüber hinaus können für eine erhöhte Zuverlässigkeit allgemeine Sprachfehler durch Einschluss von `Exception` behandelt werden.
</Info>

#### evaluateAudiences()

* 📨 *Sendet Tracking-Daten an Kameleoon*

Diese Methode evaluiert Besucher anhand aller verfügbaren Audiences Explorer-Segmente und verfolgt diejenigen, die übereinstimmen.

`evaluateAudiences()` sollte **nachdem alle relevanten Besucherdaten gesetzt oder aktualisiert wurden** und **kurz bevor** eine Feature-Variation abgerufen oder ein feature flag geprüft wird, aufgerufen werden. Dieser Ansatz stellt sicher, dass der Besucher anhand der aktuellsten verfügbaren Daten bewertet wird, was eine genaue Audience-Zuweisung basierend auf allen Kriterien ermöglicht.

Nach dem Aufruf dieser Methode können Sie eine detaillierte Analyse der Segmentleistung in Audiences Explorer durchführen.

```java theme={null}
try {
    kameleoonClient.evaluateAudiences(visitorCode);
} catch (KameleoonException ex) {
    // Handle the common Kameleoon Exception
}
```

##### Arguments

| Name                         | Typ      | Beschreibung                      |
| ---------------------------- | -------- | --------------------------------- |
| visitorCode (*erforderlich*) | `String` | Eindeutige Kennung des Besuchers. |

##### Exceptions thrown

| Typ                  | Beschreibung                                                                                                                      |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist. Er ist entweder leer oder länger als 255 Zeichen. |

<Info>
  In den meisten Fällen muss nur der grundlegende Fehler `KameleoonException` behandelt werden, wie im Beispiel gezeigt. Wenn jedoch verschiedene Fehlertypen eine Reaktion erfordern, behandeln Sie jeden basierend auf den spezifischen Anforderungen separat. Darüber hinaus können für eine erhöhte Zuverlässigkeit allgemeine Sprachfehler durch Einschluss von `Exception` behandelt werden.
</Info>

#### getFeatureList()

<Note>
  Diese Methode hieß zuvor `obtainFeatureList` und wurde in SDK-Version `4.0.0` entfernt.
</Note>

Gibt eine Liste der feature flag-Keys zurück, die derzeit für das SDK verfügbar sind.

```java theme={null}
List<String> allFeatureFlagKey = kameleoonClient.getFeatureList();
```

##### Return value

| Typ            | Beschreibung                |
| -------------- | --------------------------- |
| `List<String>` | Liste der feature flag-Keys |

#### getDataFile()

<Tip>
  Um alle feature flags zu evaluieren, verwenden Sie [`getVariations()`](#getvariations). Diese Methode ist effizienter als der Aufruf von `DataFile` und das Iterieren durch Flags mit [`getVariation()`](#getvariation).
</Tip>

Gibt die aktuelle SDK-Konfiguration als [`DataFile`](#datafile)-Objekt zurück.

```java theme={null}
try {
    DataFile dataFile = kameleoonClient.getDataFile();
} catch (Exception e) {
    // Recommended (but optional) safeguard for unexpected exceptions from third-party libraries
}
```

##### Return value

| Typ        | Beschreibung                                                   |
| ---------- | -------------------------------------------------------------- |
| `DataFile` | Das [`DataFile`](#datafile), das die SDK-Konfiguration enthält |

### Visitor data

#### getVisitorCode()

<Note>
  Diese Methode hieß zuvor `obtainVisitorCode` und wurde in SDK-Version `4.0.0` entfernt.
</Note>

Die Methode `getVisitorCode()` sollte aufgerufen werden, um den Kameleoon-`visitorCode` für den aktuellen Besucher zu erhalten. Diese Methode ist besonders wichtig, wenn Kameleoon in einer gemischten Front-End- und Back-End-Umgebung verwendet wird, in der die Konsistenz der Benutzeridentifikation garantiert sein muss. Die Implementierungslogik wird hier beschrieben:

1. Wir prüfen, ob ein `kameleoonVisitorCode`-Cookie oder ein Query-Parameter, der mit der aktuellen HTTP-Anfrage verbunden ist, gefunden werden kann. Falls ja, verwenden wir diesen `kameleoonVisitorCode` als Besucherkennung.

2. Wenn in der aktuellen Anfrage kein Cookie / Parameter gefunden wird, generieren wir entweder zufällig eine neue Kennung oder verwenden das `defaultVisitorCode`-Argument als Kennung, wenn es übergeben wird. Dieser Prozess ermöglicht es unseren Kunden, ihre Kennungen als Visitor-Codes zu verwenden, sofern sie dies wünschen. Diese Flexibilität bietet den zusätzlichen Vorteil, Kameleoon-Besucher mit ihren eigenen Benutzern ohne zusätzliche Lookups in einer Matching-Tabelle abzugleichen.

3. In jedem Fall wird das serverseitige (über HTTP-Header) `kameleoonVisitorCode`-Cookie mit dem entsprechenden Wert gesetzt. Dann gibt die Methode diesen Kennungswert zurück.

Weitere Informationen finden Sie in [diesem Artikel](/developer-docs/feature-experimentation/get-started/hybrid-experimentation/).

<Warning>
  Wenn Sie einen `visitorCode` angeben, muss seine Eindeutigkeit von Ihrer Seite garantiert werden - das SDK kann sie nicht überprüfen. Beachten Sie auch, dass die Länge des `visitorCode` auf `255` Zeichen begrenzt ist. Jedes überschüssige Zeichen wirft eine Exception aus.
</Warning>

<Info>
  Die Methode `getVisitorCode()` ermöglicht es Ihnen, **simulierte** Variationen für einen Besucher festzulegen. Wenn Cookies (aus einer **Anfrage** oder einem **Dokument**) den Schlüssel `kameleoonSimulationFFData` enthalten, wird der standardmäßige Evaluierungsprozess umgangen. Stattdessen gibt die Methode direkt eine [`Variation`](#variation) basierend auf den bereitgestellten Daten zurück.

  Sie können Simulationen auf zwei Arten anwenden:

  * **Automatisch (empfohlen):** Wenn Sie Kameleoon Web Experimentation oder das SDK im [Hybrid mode](/developer-docs/feature-experimentation/get-started/hybrid-experimentation#linking-feature-experiments-with-front-end-tracking-code) verwenden, wird das Cookie automatisch erstellt, wenn die Anzeige einer Variante mit dem [Simulation Panel](/user-manual/experimentation/feature-experimentation/using-the-rollout-planner/validation-and-rollback/using-simulation-mode) simuliert wird.
  * **Manuell:** Setzen Sie das Cookie `kameleoonSimulationFFData` manuell.

  Es ist wichtig, **simulierte** Variationen von **[erzwungenen](#setforcedvariation)** Variationen zu unterscheiden:

  * **Simulated variations**: Beeinflussen das Gesamtergebnis des **feature flags**.
  * **Forced variations**: Sind spezifisch für ein einzelnes Experiment.

  ⚙️ **Manuelle Einrichtung**

  Stellen Sie bitte sicher, dass das Cookie `kameleoonSimulationFFData` diesem Format folgt:

  * `kameleoonSimulationFFData={"featureKey":{"expId":10,"varId":20}}`: Simuliert die Variation mit `varId` des Experiments `expId` für die angegebene `featureKey`.
  * `kameleoonSimulationFFData={"featureKey":{"expId":0}}`: Simuliert die Standardvariation (definiert im Abschnitt **Then, for everyone else in Production, serve**) für die angegebene `featureKey`.

  ⚠️ Um die ordnungsgemäße Funktionalität zu gewährleisten, muss der Cookie-Wert als URI-Komponente mit einer Methode wie [`encodeURIComponent`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent) codiert werden.
</Info>

```java theme={null}
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

String visitorCode = kameleoonClient.getVisitorCode(httpServletRequest, httpServletResponse);

String visitorCode = kameleoonClient.getVisitorCode(httpServletRequest, httpServletResponse, defaultVisitorCode);
```

##### Arguments

| Name                | Typ                   | Beschreibung                                                                                                                                                                                                                                                                                              |
| ------------------- | --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| httpServletRequest  | `HttpServletRequest`  | Das aktuelle HttpServletRequest-Objekt sollte als erster Parameter übergeben werden. Dieses Feld ist obligatorisch.                                                                                                                                                                                       |
| httpServletResponse | `HttpServletResponse` | Das aktuelle HttpServletResponse-Objekt sollte als zweiter Parameter übergeben werden. Dieses Feld ist obligatorisch.                                                                                                                                                                                     |
| defaultVisitorCode  | `String`              | Dieser Parameter wird als `visitorCode` verwendet, wenn in der Anfrage kein vorhandenes `kameleoonVisitorCode`-Cookie gefunden wird. Dieses Feld ist optional. Wenn nicht angegeben, generiert das SDK einen zufälligen `visitorCode`, wenn kein vorhandenes `kameleoonVisitorCode`-Cookie vorhanden ist. |

##### Return value

| Typ      | Beschreibung                                                                                                                       |
| -------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| `String` | Ein `visitorCode`, der mit diesem bestimmten Benutzer verknüpft wird und mit den meisten Methoden des SDK verwendet werden sollte. |

#### addData()

Die Methode `addData()` fügt dem Speicher [Targeting-Daten](#data-types) hinzu, damit andere Methoden die Daten verwenden können, um zu entscheiden, ob der aktuelle Besucher targetiert werden soll oder nicht.

Die Methode `addData()` gibt keinen Wert zurück und interagiert nicht selbstständig mit den Back-End-Servern von Kameleoon. Stattdessen werden alle deklarierten Daten für die zukünftige Übertragung mit der Methode [`flush()`](#flush) gespeichert. Dieser Ansatz reduziert die Anzahl der durchgeführten Serveraufrufe, da die Daten typischerweise in einem einzigen Serveraufruf zusammengefasst werden, der durch `flush()` ausgelöst wird.

Die Methode [`trackConversion()`](#trackconversion) sendet ebenfalls alle zuvor zugeordneten Daten, genau wie `flush()`. Dasselbe gilt für die Methoden [`getVariation()`](#getvariation) und [`getVariations()`](#getvariations), wenn eine Experimentierungsregel ausgelöst wird.

<Tip>
  Jeder Besucher kann für die meisten Datentypen nur eine Instanz zugeordneter Daten haben. [`CustomData`](#customdata) ist jedoch eine Ausnahme. Besucher können eine Instanz zugeordneter `CustomData` pro Index haben.
</Tip>

```java theme={null}
// Add a single data item (tracked by default)
kameleoonClient.addData(visitorCode, Browser.chrome());

// Add multiple data items (tracked by default)
kameleoonClient.addData(visitorCode, new PageView("https://url.com", "title"), new UserAgent("UserAgent"));

// Add multiple data items stored locally for targeting only (not sent to the Kameleoon Data API)
kameleoonClient.addData(visitorCode, false, new PageView("https://url.com", "title"), new UserAgent("UserAgent"));
```

##### Arguments

| Name                         | Typ       | Beschreibung                                                                                                                                                                                                                           | Standardwert |
| ---------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
| visitorCode (*erforderlich*) | `String`  | Eindeutige Kennung des Besuchers.                                                                                                                                                                                                      |              |
| track (*optional*)           | `boolean` | Gibt an, ob die hinzugefügten Daten für das Tracking geeignet sind. Wenn auf `false` gesetzt, werden die Daten lokal gespeichert und nur für die Targeting-Evaluierung verwendet; sie werden nicht an die Kameleoon Data API gesendet. | `true`       |
| data (*erforderlich*)        | `Data...` | Sammlung von Kameleoon-Datentypen.                                                                                                                                                                                                     |              |

##### Exceptions

| Typ                  | Beschreibung                                                                                                                      |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist. Er ist entweder leer oder länger als 255 Zeichen. |

#### flush()

* *📨 Sendet Tracking-Daten an Kameleoon*

Die Methode `flush()` sammelt die Kameleoon-Daten, die mit dem Besucher verknüpft sind. Sie sendet dann eine Tracking-Anfrage zusammen mit allen Daten, die mit der `addData`-Methode hinzugefügt wurden und noch nicht mit einer [dieser Methoden](/developer-docs/feature-experimentation/technical-reference/faq-global#when-does-the-sdk-send-a-tracking-request-for-analytics) gesendet wurden. `flush()` ist nicht blockierend, da der Serveraufruf asynchron erfolgt.

`flush` ermöglicht es Ihnen zu steuern, wann Daten, die mit einem bestimmten `visitorCode` verknüpft sind, an unsere Server gesendet werden. Wenn Sie beispielsweise `addData()` ein Dutzend Mal aufrufen, wäre es ineffizient, die Daten bei jedem Aufruf von `addData()` an den Server zu senden. Sie müssen also nur einmal `flush()` aufrufen.

Wenn Sie einen `visitorCode` angeben, verwendet die Methode `flush()` diesen Code als eindeutige Besucherkennung, was für [cross-device experimentation](/developer-docs/cross-device-experimentation) nützlich ist. Wenn Sie einen `visitorCode` angeben und den Parameter `isUniqueIdentifier` auf `true` setzen, verknüpft das SDK die geflushten Daten mit dem Besucher, der mit der angegebenen Kennung verknüpft ist.

<Note>
  Der Parameter `isUniqueIdentifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).

  Der `isUniqueIdentifier` kann in besonderen Situationen hilfreich sein; zum Beispiel, wenn Sie nicht auf den anonymen `visitorCode` zugreifen können, der einem Besucher zugewiesen wurde, aber eine interne ID verwenden können, die über Session-Merging mit diesem Besucher verknüpft ist.
</Note>

```java theme={null}

try {
    kameleoonClient.flush(visitorCode); // Interval tracking (most performant tracking method)
    kameleoonClient.flush(true, visitorCode); // Instant tracking
} catch (VisitorCodeInvalid e) {
  // Catch exception
}
```

##### Arguments

| Name                            | Typ       | Beschreibung                                                                                                                                                                                                                                                                                                     |
| ------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| instant                         | `boolean` | Boolesches Flag, das angibt, ob die Daten sofort gesendet werden sollen (`true`) oder gemäß dem standardmäßigen Tracking-Intervall (`false`), das mit dem SDK-Parameter [`tracking_interval_millisecond`](#additional-configuration) festgelegt wurde. Dieses Feld ist optional.                                 |
| visitorCode                     | `String`  | Eindeutige Kennung des Benutzers. Dieses Feld ist erforderlich.                                                                                                                                                                                                                                                  |
| isUniqueIdentifier (Deprecated) | `boolean` | Ein optionaler Parameter, um anzugeben, ob der visitorCode eine eindeutige Kennung ist. Der `visitorCode` muss angegeben und nicht `null` sein, um `isUniqueIdentifier` für einen Besucher anzuwenden, andernfalls wird er ignoriert. Wenn nicht angegeben, ist der Standardwert `false`. Das Feld ist optional. |

#### getRemoteData()

<Note>
  Diese Methode hieß zuvor `retrieveDataFromRemoteSource` und wurde in SDK-Version `4.0.0` entfernt.
</Note>

Die Methode `getRemoteData()` ermöglicht es Ihnen, Daten (gemäß einem als Argument übergebenen `key`) für den angegebenen `siteCode` abzurufen, die auf dem Kameleoon-Server gespeichert sind. Ihr Site-Code wird in `KameleoonClientFactory.create()` angegeben. Normalerweise werden Daten auf unseren Remote-Servern mit unserer Data API gespeichert. Diese Methode bietet zusammen mit der Verfügbarkeit unserer skalierbaren Server eine bequeme Möglichkeit, zusätzliche Daten zu speichern, die Sie später für Ihre App abrufen können.

```java theme={null}
CompletableFuture<JsonObject> data = kameleoonClient.getRemoteData("key");

try {
  JsonObject test = kameleoonClient.getRemoteData("key").get(5_000, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
  // Catch exception
}
```

##### Arguments

| Name | Typ      | Beschreibung                                                                               |
| ---- | -------- | ------------------------------------------------------------------------------------------ |
| key  | `String` | Der Schlüssel, der mit den abgerufenen Daten verknüpft ist. Dieses Feld ist obligatorisch. |

##### Return value

| Typ                             | Beschreibung                                                                                   |
| ------------------------------- | ---------------------------------------------------------------------------------------------- |
| `CompletableFuture<JsonObject>` | Future `JsonObject`, das mit dem Abrufen von Daten für einen bestimmten **key** verknüpft ist. |

#### getRemoteVisitorData()

`getRemoteVisitorData()` ist eine asynchrone Methode zum Abrufen von Kameleoon Visits Data für den `visitorCode` von der Kameleoon Data API. Die Methode fügt die Daten dem Speicher hinzu, damit andere Methoden sie beim Treffen von Targeting-Entscheidungen verwenden können.

Mit dieser Methode erhaltene Daten spielen eine wichtige Rolle, wenn Sie:

* Daten verwenden möchten, die von anderen Geräten gesammelt wurden.
* auf den Verlauf eines Benutzers zugreifen möchten, z. B. zuvor besuchte Seiten während vergangener Besuche.
* Daten verwenden möchten, die nur auf der Client-Seite zugänglich sind, wie Datalayer-Variablen und Ziele, die auf dem Front-End konvertieren.

Lesen Sie [diesen Artikel](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation) für ein besseres Verständnis möglicher Anwendungsfälle.

<Warning>
  Standardmäßig ruft `getRemoteVisitorData()` automatisch die zuletzt gespeicherten Custom Data mit `scope=Visitor` ab und fügt sie dem Besucher hinzu, ohne dass die Methode `addData()` aufgerufen werden muss. Dies ist besonders nützlich für die [Synchronisierung von Custom Data zwischen mehreren Geräten](/developer-docs/sdks/web-sdks/nodejs-sdk#synchronizing-custom-data-across-devices).
</Warning>

<Note>
  Der Parameter `isUniqueIdentifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).

  Der `isUniqueIdentifier` kann in besonderen Situationen hilfreich sein; zum Beispiel, wenn Sie nicht auf den anonymen `visitorCode` zugreifen können, der einem Besucher zugewiesen wurde, aber eine interne ID verwenden können, die über Session-Merging mit diesem Besucher verknüpft ist.
</Note>

```java theme={null}
String visitorCode = "visitorCode";
// Visitor data will be fetched and automatically added for `visitorCode`
CompletableFuture<List<Data>> visitorData = kameleoonClient.getRemoteVisitorData(visitorCode);

// If you only want to fetch data and add it yourself manually, set addData == `false`
CompletableFuture<List<Data>> visitorData = kameleoonClient.getRemoteVisitorData(visitorCode, false);

// If you want to fetch custom list of data types
RemoteVisitorDataFilter filter = RemoteVisitorDataFilter.builder()
    .previousVisitAmount(25)
    .customData(false)
    .conversions(true)
    .build();
CompletableFuture<List<Data>> visitorData = kameleoonClient.getRemoteVisitorData(visitorCode, filter, true, false);

try {
  List<Data> visitorData = kameleoonClient.getRemoteVisitorData(visitorCode).get(5_000, TimeUnit.MILLISECONDS);
  // Your custom code
} catch (CancellationException | InterruptedException | ExecutionException | TimeoutException e) {
  // Catch exception
}
```

##### Arguments

| Name                            | Typ                       | Beschreibung                                                                                                                                                                                                                                                                                                                         |
| ------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| visitorCode                     | string                    | Der Visitor-Code für die Daten, die Sie abrufen möchten. Dieses Feld ist obligatorisch.                                                                                                                                                                                                                                              |
| filter                          | `RemoteVisitorDataFilter` | Filter zur Angabe, welche Daten aus den Besuchen abgerufen werden sollen. Standardmäßig werden nur `CustomData` vom aktuellen und letzten vorherigen Besuch abgerufen (`RemoteVisitorDataFilter.builder().build()` oder `new RemoteVisitorDataFilter()`). Andere Filterparameter sind auf `false` gesetzt. Dieses Feld ist optional. |
| addData                         | `boolean`                 | Ein boolescher Wert, der angibt, ob die Methode automatisch abgerufene Daten für einen Besucher hinzufügen soll. Dieses Feld ist optional.                                                                                                                                                                                           |
| isUniqueIdentifier (Deprecated) | `boolean`                 | Ein optionaler Parameter, um anzugeben, ob der `visitorCode` eine eindeutige Kennung ist. Wenn nicht angegeben, ist der Standardwert `false`. Das Feld ist optional.                                                                                                                                                                 |

##### Return value

| Typ                             | Beschreibung                                                          |
| ------------------------------- | --------------------------------------------------------------------- |
| `CompletableFuture<List<Data>>` | Future `List<Data>`, die mit einem bestimmten Besucher verknüpft ist. |

##### Using parameters in getRemoteVisitorData()

Die Methode `getRemoteVisitorData()` bietet Flexibilität, indem sie es Ihnen ermöglicht, verschiedene Parameter beim Abrufen von Daten zu Besuchern zu definieren. Egal, ob Sie auf der Grundlage von Zielen, Experiments oder Variationen targetieren, derselbe Ansatz gilt für alle Datentypen.

Angenommen, Sie möchten Daten zu Besuchern abrufen, die ein Ziel "Order transaction" abgeschlossen haben. Sie können Parameter innerhalb der Methode `getRemoteVisitorData()` angeben, um Ihr Targeting zu verfeinern. Wenn Sie beispielsweise nur Benutzer targetieren möchten, die in ihren letzten fünf Besuchen das Ziel konvertiert haben, können Sie den Parameter `previousVisitAmount` auf 5 und `conversions` auf true setzen.

Die in diesem Beispiel gezeigte Flexibilität beschränkt sich nicht auf Zieldaten. Sie können Parameter innerhalb der Methode `getRemoteVisitorData()` verwenden, um Daten zu einer Vielzahl von Besucherverhaltensweisen abzurufen.

<Note>
  Hier ist die Liste der verfügbaren `kameleoon.types.RemoteVisitorDataFilter`-Optionen:

  | Name                             | Typ       | Beschreibung                                                                                                                                                                                                                                                                                                                                                             | Standard |
  | -------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------- |
  | previousVisitAmount (*optional*) | `int`     | Anzahl der vorherigen Besuche, aus denen Daten abgerufen werden sollen. Zahl zwischen `1` und `25`                                                                                                                                                                                                                                                                       | `1`      |
  | currentVisit (*optional*)        | `boolean` | Wenn true, werden Daten des aktuellen Besuchs abgerufen                                                                                                                                                                                                                                                                                                                  | `true`   |
  | customData (*optional*)          | `boolean` | Wenn true, werden Custom Data abgerufen.                                                                                                                                                                                                                                                                                                                                 | `true`   |
  | pageViews (*optional*)           | `boolean` | Wenn true, werden Seitendaten abgerufen.                                                                                                                                                                                                                                                                                                                                 | `false`  |
  | geolocation (*optional*)         | `boolean` | Wenn true, werden Geolokalisierungsdaten abgerufen.                                                                                                                                                                                                                                                                                                                      | `false`  |
  | device (*optional*)              | `boolean` | Wenn true, werden Gerätedaten abgerufen.                                                                                                                                                                                                                                                                                                                                 | `false`  |
  | browser (*optional*)             | `boolean` | Wenn true, werden Browserdaten abgerufen.                                                                                                                                                                                                                                                                                                                                | `false`  |
  | operatingSystem (*optional*)     | `boolean` | Wenn true, werden Daten zum Betriebssystem abgerufen.                                                                                                                                                                                                                                                                                                                    | `false`  |
  | conversions (*optional*)         | `boolean` | Wenn true, werden Konversionsdaten abgerufen.                                                                                                                                                                                                                                                                                                                            | `false`  |
  | experiments (*optional*)         | `boolean` | Wenn true, werden Experiment-Daten abgerufen.                                                                                                                                                                                                                                                                                                                            | `false`  |
  | kcs (*optional*)                 | `boolean` | Wenn true, wird der Kameleoon Conversion Score (KCS) abgerufen. Erfordert das [AI Predictive Targeting add-on](/user-manual/ai-predictive-targeting/target-users-based-on-likelihood-to-convert)                                                                                                                                                                         | `false`  |
  | visitorCode (*optional*)         | `boolean` | Wenn true, ruft Kameleoon den `visitorCode` vom jüngsten Besuch ab und verwendet ihn für den aktuellen Besuch. Dies ist erforderlich, wenn Sie sicherstellen möchten, dass der Besucher, identifiziert durch seinen `visitorCode`, für [Cross-device experimentation](/developer-docs/cross-device-experimentation) immer dieselbe Variation über Besuche hinweg erhält. | `true`   |
  | personalization (*optional*)     | `boolean` | Wenn true, werden Personalisierungsdaten abgerufen. Dies ist für die Personalisierungsbedingung erforderlich.                                                                                                                                                                                                                                                            | `false`  |
  | cbs (*optional*)                 | `boolean` | Wenn true, werden Contextual Bandit Score-Daten abgerufen.                                                                                                                                                                                                                                                                                                               | `false`  |
</Note>

#### getVisitorWarehouseAudience()

Diese Methode ruft alle Audience-Daten ab, die mit dem Besucher in Ihrem Data Warehouse verknüpft sind, unter Verwendung des angegebenen `visitorCode` und `warehouseKey`. Der `warehouseKey` ist typischerweise Ihre interne Benutzer-ID. Der Parameter `customDataIndex` entspricht den Kameleoon Custom Data, die Kameleoon verwendet, um Ihre Besucher zu targetieren. Sie können sich auf die [Warehouse-Targeting-Dokumentation](/user-manual/integrations/data-warehouses/bigquery/use-bigquery-as-a-source-audience-targeting) für zusätzliche Details beziehen. Die Methode übergibt das Ergebnis an das zurückgegebene Future als `CustomData`-Objekt und bestätigt, dass die Daten dem Besucher hinzugefügt wurden und für Targeting-Zwecke verfügbar sind.

```java theme={null}
CompletableFuture<CustomData> warehouseAudienceDataCF =
  kameleoonClient.getVisitorWarehouseAudience(visitorCode, warehouseKeyValue, customDataIndex);

// If you need to specify warehouse key
CompletableFuture<CustomData> warehouseAudienceDataCF =
  kameleoonClient.getVisitorWarehouseAudience(visitorCode, customDataIndex);

try {
  CustomData warehouseAudienceData = warehouseAudienceDataCF.get(5_000, TimeUnit.MILLISECONDS);
  // Your custom code
} catch (CancellationException | InterruptedException | ExecutionException | TimeoutException e) {
  // Catch exception
}
```

##### Arguments

| Name            | Typ      | Beschreibung                                                                                                                         |
| --------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| visitorCode     | `String` | Die eindeutige Kennung des Besuchers, für den Sie die Daten abrufen und hinzufügen möchten.                                          |
| warehouseKey    | `String` | Der eindeutige Schlüssel zur Identifizierung der Warehouse-Daten (normalerweise Ihre interne Benutzer-ID). Dieses Feld ist optional. |
| customDataIndex | `int`    | Eine Ganzzahl, die den Index der Custom Data darstellt, die Sie zur Targetierung Ihrer BigQuery-Audiences verwenden möchten.         |

##### Return value

| Typ                             | Beschreibung                                                                                |
| ------------------------------- | ------------------------------------------------------------------------------------------- |
| `CompletableFuture<CustomData>` | Future `CustomData`-Instanz, die bestätigt, dass die Daten dem Besucher hinzugefügt wurden. |

##### Exceptions thrown

| Typ                  | Beschreibung                                                                                                                       |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist (er ist entweder leer oder länger als 255 Zeichen). |

#### setLegalConsent()

Sie müssen diese Methode verwenden, um anzugeben, ob der Besucher seine rechtliche Zustimmung zur Verwendung personenbezogener Daten gegeben hat. Das Setzen des Parameters `legalConsent` auf `false` schränkt die Arten von Daten ein, die Sie in Tracking-Anfragen aufnehmen können. Diese Methode hilft Ihnen, rechtliche und regulatorische Anforderungen einzuhalten und gleichzeitig Besucherdaten verantwortungsvoll zu verwalten. Weitere Informationen zu personenbezogenen Daten finden Sie in der [Richtlinie zur Einwilligungsverwaltung](/user-manual/project-management/consent-management-policy).

```java theme={null}
// if you do not need to set the visitor code in a cookie to respond
kameleoonClient.setLegalConsent(visitorCode, true);

String visitorCode = kameleoonClient.getVisitorCode(httpServletRequest, httpServletResponse);
kameleoonClient.setLegalConsent(visitorCode, true, httpServletResponse);
```

##### Arguments

| Name         | Typ                 | Beschreibung                                                                                                                                                                                                                                                                           |
| ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitorCode  | `String`            | Die eindeutige Kennung des Benutzers. Dieses Feld ist erforderlich.                                                                                                                                                                                                                    |
| legalConsent | `boolean`           | Ein boolescher Wert, der den Status der rechtlichen Zustimmung darstellt. `true` zeigt an, dass der Besucher seine rechtliche Zustimmung gegeben hat, `false` zeigt an, dass der Besucher nie eine rechtliche Zustimmung erteilt oder zurückgezogen hat. Dieses Feld ist erforderlich. |
| response     | HttpServletResponse | Die HTTP-Servlet-Antwort, in der die Werte in den Cookies basierend auf dem Status der rechtlichen Zustimmung angepasst werden. Das Feld ist optional.                                                                                                                                 |

##### Exceptions thrown

| Typ                                   | Beschreibung                                                                                                                  |
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.VisitorCodeInvalid | Exception, die anzeigt, dass der bereitgestellte Visitor-Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |

##### Consent revocation behavior

Wenn Sie `setLegalConsent()` mit `legalConsent=false` aufrufen, löscht das SDK das `kameleoonVisitorCode`-Cookie nicht. Stattdessen verlängert es das Ablaufdatum des Cookies nicht mehr und lässt das Cookie bestehen, bis es natürlich abläuft.

Wenn Ihre Compliance-Anforderungen die sofortige Entfernung der Cookie-Datei beim Opt-Out verlangen, müssen Sie sie manuell mit den nativen Cookie-Verwaltungsmethoden Ihres Frameworks löschen. Das SDK entfernt die Datei nicht automatisch.

### Goals and third-party analytics

#### trackConversion()

* 📨 *Sendet Tracking-Daten an Kameleoon*

Verwenden Sie diese Methode, um eine Konversion für ein bestimmtes [Ziel](/user-manual//assets/goals/create-a-goal) und einen bestimmten Benutzer zu verfolgen. Diese Methode erfordert `visitorCode` und `goalId`. Außerdem akzeptiert diese Methode auch optionale Argumente `revenue`, `negative` und `metadata`. Der `visitorCode` ist normalerweise identisch mit demjenigen, der beim Auslösen des Experiments verwendet wurde.

Die Methode `trackConversion()` gibt keinen Wert zurück. Diese Methode ist nicht blockierend, da der Serveraufruf asynchron erfolgt.

<Note>
  Der Parameter `isUniqueIdentifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).

  Der `isUniqueIdentifier` kann auch in anderen Sonderfällen nützlich sein, z. B. wenn Sie nicht auf den anonymen `visitorCode` zugreifen können, der dem Besucher ursprünglich zugewiesen wurde, aber auf eine interne ID zugreifen können, die mit dem anonymen Besucher über Session-Merging-Funktionen verbunden ist.
</Note>

```java theme={null}
String visitorCode = kameleoonClient.getVisitorCode(httpServletRequest, httpServletResponse);
int goalId = 83023;

kameleoonClient.trackConversion(visitorCode, goalId);

// Add metadata
CustomData cd = new CustomData(1, "metadata");
kameleoonClient.trackConversion(visitorCode, goalId, cd);
```

##### Arguments

| Name                              | Typ             | Beschreibung                                                                                                                                                                                                                                                                                                                                                | Standard            |
| --------------------------------- | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- |
| visitorCode (*erforderlich*)      | `String`        | Eindeutige Kennung des Besuchers.                                                                                                                                                                                                                                                                                                                           |                     |
| goalId (*erforderlich*)           | `int`           | ID des Ziels.                                                                                                                                                                                                                                                                                                                                               |                     |
| revenue (*optional*)              | `float`         | Umsatz der Konversion.                                                                                                                                                                                                                                                                                                                                      | `0`                 |
| negative (*optional*)             | `boolean`       | Definiert, ob der Umsatz positiv oder negativ ist.                                                                                                                                                                                                                                                                                                          | `false`             |
| metadata (*optional*)             | `CustomData...` | Ermöglicht es Ihnen, spezifische Werte für Custom Data festzulegen, die als Metadaten für das Ziel in der Kameleoon-App definiert wurden. Beispiel: `[CustomData{id: 5, value: "Payment Type"}, CustomData{id: 6, value: "Delivery Method"}]`. In diesem Beispiel sind `5` und `9` die Indizes der Custom Data (5 = "Payment Type", 9 = "Delivery Method"). | `new CustomData[0]` |
| isUniqueIdentifier *(deprecated)* | `boolean`       | Ein optionaler Parameter, um anzugeben, ob der visitorCode eine eindeutige Kennung ist.                                                                                                                                                                                                                                                                     | `false`             |

<Note>
  Metadatenwerte sind über [Rohdatenexporte](/user-manual/experiment-analytics/analyze-results/results-page/results-page-actions#Export) und [die Ergebnisseite](/user-manual/experiment-analytics/analyze-results/data-and-metrics/goal-metadata) zugänglich.

  Wenn der Parameter `metadata` angegeben wird, verwendet Kameleoon diese angegebenen Werte für die aktuelle Konversion anstelle der zuvor mit der Methode [`addData()`](#adddata) gesammelten Werte. Wenn der Parameter weggelassen wird, verwendet Kameleoon die zuletzt verfolgten Werte für diese [`CustomData`](#customdata) vor der Konversion und innerhalb desselben Besuchs.

  Kameleoon berücksichtigt nur die Metadatenwerte, die explizit als Parameter an die Methode `trackConversion()` übergeben werden.

  Im untenstehenden Beispiel ordnet Kameleoon die Konversion nur dem Custom Data-Wert zu, der explizit als Parameter angegeben wurde (hier: Index 5 mit dem Wert 'Amex Credit Card').

  ```java theme={null}
  kameleoonClient.addData(visitorCode, new CustomData(5, "Credit Card"), new CustomData(9, "Express Delivery"));
  kameleoonClient.trackConversion(visitorCode, 1000, new CustomData(5, "Amex Credit Card"));
  ```
</Note>

##### Exceptions

| Typ                  | Beschreibung                                                                                                                      |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist. Er ist entweder leer oder länger als 255 Zeichen. |

#### getEngineTrackingCode()

Kameleoon lässt sich mit mehreren Analytics-Lösungen integrieren, darunter Mixpanel, Google Analytics 4 und Segment. Um serverseitige Experiments korrekt zu verfolgen, rufen Sie die Methode `getEngineTrackingCode()` auf, nachdem der Besucher ein Experiment ausgelöst hat. Das SDK gibt JavaScript-Queue-Befehle für die Experiments zurück, die der Besucher in den letzten fünf Sekunden ausgelöst hat. Wenn Sie diesen Code in die Seite einfügen, verarbeitet Engine.js die Befehle und sendet die Expositionsereignisse über die aktive Analytics-Integration.

Siehe [hybrid experimentation](/developer-docs/feature-experimentation/get-started/hybrid-experimentation) für weitere Informationen zur Implementierung dieser Methode.

```java theme={null}
String engineTrackingCode = kameleoonClient.getEngineTrackingCode(visitorCode);
```

<Note>
  * Um diese Funktion zu nutzen, implementieren Sie sowohl das Java SDK als auch Kameleoon [Engine.js](/developer-docs/web-experimentation/implementation-and-deployment/standard-implementation). Da Engine.js in diesem Flow nur für das Tracking verwendet wird, können Sie das asynchrone Tag vor dem schließenden `</body>`-Tag installieren.
  * Wenn Sie Experiments nur in Kameleoon verfolgen möchten und keine Expositionsereignisse an Drittanbieter-Analytics-Tools senden müssen, verwenden Sie das [JavaScript / TypeScript SDK](/developer-docs/sdks/web-sdks/js-sdk). Diese Option funktioniert gut für [serverless edge compute platforms](/developer-docs/feature-experimentation/implementation-and-deployment/serverless-edge-compute-starter-kits). Das JavaScript / TypeScript SDK verfolgt Variationen automatisch, wenn Sie [`getVisitorCode`](/developer-docs/sdks/web-sdks/js-sdk#getvisitorcode) aufrufen, sofern Sie die entsprechenden Experiment-Zuweisungen zu `window.kameleoonQueue` hinzufügen..
  * Sie können den zurückgegebenen Tracking-Code direkt in ein HTML-`<script>`-Tag einfügen.

  ```html theme={null}
  <html lang="en">
    <body>
      <script>
        const engineTrackingCode = `
          window.kameleoonQueue = window.kameleoonQueue || [];
          window.kameleoonQueue.push(['Experiments.assignVariation', 123456, 7890, true]);
          window.kameleoonQueue.push(['Experiments.trigger', 123456, true]);
          window.kameleoonQueue.push(['Experiments.assignVariation', 234567, 8901, true]);
          window.kameleoonQueue.push(['Experiments.trigger', 234567, true]);
        `;
        const script = document.createElement('script');

        script.textContent = engineTrackingCode;
        document.body.appendChild(script);
      </script>

    </body>
  </html>
  ```

  In diesem Beispiel sind `123456` und `234567` Experiment-IDs und `7890` und `8901` Variation-IDs. In Ihrer Implementierung generiert das SDK diese Werte im zurückgegebenen Tracking-Code.
</Note>

##### Arguments

| Name                         | Typ      | Beschreibung                      |
| ---------------------------- | -------- | --------------------------------- |
| visitorCode (*erforderlich*) | `String` | Eindeutige Kennung des Besuchers. |

##### Return value

| Typ      | Beschreibung                                             |
| -------- | -------------------------------------------------------- |
| `String` | JavaScript-Code, der in die Seite eingefügt werden soll. |

### Events

#### setEventHandler()

Verwenden Sie diese Methode, um einen Handler für SDK-Ereignisse zu registrieren. Das SDK ruft den Handler auf, wenn das ausgewählte Ereignis eintritt. Das Registrieren eines neuen Handlers für denselben Ereignistyp ersetzt den vorherigen Handler. Wenn Sie `null` als `handler` übergeben, wird der aktuelle Handler für den ausgewählten Ereignistyp entfernt.

<Tabs>
  <Tab title="DATAFILE_UPDATE">
    ```java theme={null}
    import com.kameleoon.events.DataFileUpdateEvent;
    import com.kameleoon.events.EventType;

    kameleoonClient.setEventHandler(EventType.DATAFILE_UPDATE, event -> {
      DataFileUpdateEvent.Source source = event.getSource(); // POLLING or STREAMING
      long dateModified = event.getDateModified(); // Data file modification date in milliseconds.

      // React to the data file update.
    });

    // Clear the handler.
    kameleoonClient.setEventHandler(EventType.DATAFILE_UPDATE, null);
    ```

    <Tip>
      `DataFileUpdateEvent` enthält Informationen über eine Aktualisierung der SDK-Datendatei.

      | Name           | Typ                          | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                         |
      | -------------- | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
      | `source`       | `DataFileUpdateEvent.Source` | Die Aktualisierungsquelle. [`POLLING`](/de/developer-docs/feature-experimentation/technical-reference/technical-considerations#polling-standard) gibt eine geplante Aktualisierung der Datendatei an, und [`STREAMING`](/developer-docs/feature-experimentation/technical-reference/technical-considerations#streaming-premium-option) gibt eine Echtzeit-Aktualisierung an, die im Streaming-Modus empfangen wurde. |
      | `dateModified` | `long`                       | Das Änderungsdatum der aktualisierten Datendatei in Millisekunden.                                                                                                                                                                                                                                                                                                                                                   |
    </Tip>
  </Tab>

  <Tab title="HTTP_REQUEST">
    ```java theme={null}
    import com.kameleoon.events.EventType;
    import com.kameleoon.events.HttpRequestFailure;
    import com.kameleoon.events.HttpRequestHandler;
    import com.kameleoon.events.HttpRequestHandler.RequestType;

    kameleoonClient.setEventHandler(EventType.HTTP_REQUEST, new HttpRequestHandler() {
      @Override
      public void onRequestSucceeded(RequestType requestType, int httpStatus, long durationMillis) {
        // The SDK request completed successfully.
      }

      @Override
      public void onRequestFailed(RequestType requestType, HttpRequestFailure failure, long durationMillis) {
        HttpRequestFailure.Reason reason = failure.getReason();
        Integer httpStatus = failure.getHttpStatus();
        Throwable cause = failure.getCause();

        // The SDK request failed.
      }
    });

    // Clear the handler.
    kameleoonClient.setEventHandler(EventType.HTTP_REQUEST, null);
    ```

    <Tip>
      `HttpRequestHandler` ermöglicht es Ihnen, auf abgeschlossene SDK-HTTP-Anfragen zu reagieren. Das SDK ruft `onRequestSucceeded()` für erfolgreiche Antworten und `onRequestFailed()` für fehlgeschlagene Antworten, Ausnahmen oder abgebrochene Anfragen auf.

      | Methode                | Beschreibung                                                                                                            |
      | ---------------------- | ----------------------------------------------------------------------------------------------------------------------- |
      | `onRequestSucceeded()` | Wird aufgerufen, wenn eine SDK-HTTP-Anfrage erfolgreich abgeschlossen wird.                                             |
      | `onRequestFailed()`    | Wird aufgerufen, wenn eine SDK-HTTP-Anfrage aufgrund eines HTTP-Status, einer Ausnahme oder eines Abbruchs fehlschlägt. |

      <Accordion title="Callback-Parameter und Fehlerdetails">
        ##### Callback-Parameter

        | Name             | Typ                              | Beschreibung                                                                                                             |
        | ---------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
        | `requestType`    | `HttpRequestHandler.RequestType` | Der SDK-Anfragetyp. Mögliche Werte sind `DATAFILE`, `TRACKING`, `REMOTE_VISITOR_DATA`, `REMOTE_DATA` und `ACCESS_TOKEN`. |
        | `httpStatus`     | `int`                            | Der von der Anfrage zurückgegebene HTTP-Statuscode. Wird nur an `onRequestSucceeded()` übergeben.                        |
        | `failure`        | `HttpRequestFailure`             | Details darüber, warum die Anfrage fehlgeschlagen ist. Wird nur an `onRequestFailed()` übergeben.                        |
        | `durationMillis` | `long`                           | Die Anfragedauer in Millisekunden.                                                                                       |

        ##### HttpRequestFailure

        `HttpRequestFailure` enthält Details über eine fehlgeschlagene SDK-HTTP-Anfrage.

        | Name         | Typ                         | Beschreibung                                                                                                                                                            |
        | ------------ | --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
        | `reason`     | `HttpRequestFailure.Reason` | Der Fehlergrund. Mögliche Werte sind `HTTP_STATUS`, `EXCEPTION` und `CANCELLED`.                                                                                        |
        | `httpStatus` | `Integer`                   | Der HTTP-Statuscode für Fehler, die durch eine nicht erfolgreiche HTTP-Antwort verursacht wurden. Dieser Wert ist `null` bei Fehlern durch Ausnahmen oder Abbrüche.     |
        | `cause`      | `Throwable`                 | Die Ausnahme, die zum Fehlschlagen der Anfrage geführt hat. Dieser Wert ist `null`, wenn die Anfrage aufgrund eines HTTP-Status oder eines Abbruchs fehlgeschlagen ist. |
      </Accordion>
    </Tip>
  </Tab>
</Tabs>

##### Arguments

| Name                         | Typ                      | Beschreibung                                                                                                                                                                                                                                                           |
| ---------------------------- | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `eventType` (*erforderlich*) | `EventType<T>`           | Der zu verarbeitende SDK-Ereignistyp. Verwenden Sie `EventType.DATAFILE_UPDATE`, um auf Aktualisierungen der SDK-Datendatei zu reagieren, oder `EventType.HTTP_REQUEST`, um auf abgeschlossene SDK-HTTP-Anfragen zu reagieren.                                         |
| `handler` (*optional*)       | `T extends EventHandler` | Der für den ausgewählten Ereignistyp zu registrierende Handler. Verwenden Sie einen `DataFileUpdateHandler` für `EventType.DATAFILE_UPDATE` oder einen `HttpRequestHandler` für `EventType.HTTP_REQUEST`. Übergeben Sie `null`, um den aktuellen Handler zu entfernen. |

### Data types

Dieser Abschnitt listet die von Kameleoon in `com.kameleoon.Data` unterstützten Datentypen auf. Wir bieten mehrere Standarddatentypen sowie den Typ `CustomData`, mit dem Sie benutzerdefinierte Datentypen definieren können.

#### Browser

Das hier gespeicherte `Browser`-Dataset kann verwendet werden, um Experiment- und Personalisierungsberichte nach jedem damit verknüpften Wert zu filtern.

| Name                  | Typ            | Beschreibung                                                                             |
| --------------------- | -------------- | ---------------------------------------------------------------------------------------- |
| type (*erforderlich*) | `Browser.Type` | Liste der Browser: `CHROME`, `INTERNET_EXPLORER`, `FIREFOX`, `SAFARI`, `OPERA`, `OTHER`. |
| version (*optional*)  | `Float`        | Version des Browsers, Gleitkommazahl stellt die Haupt- und Nebenversion des Browsers dar |

```java theme={null}
kameleoonClient.addData(visitorCode, Browser.chrome());
kameleoonClient.addData(visitorCode, Browser.safari());

kameleoonClient.addData(visitorCode, new Browser(Browser.Type.CHROME, 10.0));
```

#### Conversion

Das hier gespeicherte `Conversion`-Dataset kann verwendet werden, um Experiment- und Personalisierungsberichte nach jedem damit verknüpften Ziel zu filtern.

<Tip>
  * Jeder Besucher kann mehrere `Conversion`-Objekte haben.
  * Sie können die `goalId` in der Kameleoon-App finden.
</Tip>

| Name                    | Typ             | Beschreibung                                       | Standard            |
| ----------------------- | --------------- | -------------------------------------------------- | ------------------- |
| goalId (*erforderlich*) | `int`           | ID des Ziels.                                      |                     |
| revenue (*optional*)    | `float`         | Umsatz der Konversion                              | `0`                 |
| negative (*optional*)   | `boolean`       | Definiert, ob der Umsatz positiv oder negativ ist. | `false`             |
| metadata (*optional*)   | `CustomData...` | Metadaten der Konversion.                          | `new CustomData[0]` |

```java theme={null}
kameleoonClient.addData(visitorCode, new Conversion(32, 10f));

kameleoonClient.addData(visitorCode, new Conversion(33, null, true));

kameleoonClient.addData(
    visitorCode,
    new Conversion(34, 5f, new CustomData(3, "metadata1", "md2"), new CustomData(5, "md3"))
);
```

#### Cookie

`Cookie` enthält Informationen über das Cookie, das auf dem Gerät des Besuchers gespeichert ist.

| Name    | Typ                   | Beschreibung                                                                                         |
| ------- | --------------------- | ---------------------------------------------------------------------------------------------------- |
| cookies | `Map<String, String>` | Eine String-Objekt-Map, die aus Cookie-Schlüsseln und -Werten besteht. Dieses Feld ist erforderlich. |

<Tip>
  Jeder Besucher kann nur ein `Cookie` haben. Das Hinzufügen eines zweiten `Cookie` überschreibt das erste.
</Tip>

```java theme={null}
Cookie cookie = new Cookie (new HashMap<String, String>() {{
    put("my_key1", "my_value1");
    put("my_key2", "my_value1");
}});
kameleoonClient.addData(visitorCode, cookie);
```

#### Geolocation

`Geolocation` enthält die Geolokalisierungsdetails des Besuchers.

| Name                     | Typ                   | Beschreibung                                                                                                  |
| ------------------------ | --------------------- | ------------------------------------------------------------------------------------------------------------- |
| country (*erforderlich*) | `String`              | Das Land des Besuchers.                                                                                       |
| region (*optional*)      | <nobr>`String`</nobr> | Die Region des Besuchers.                                                                                     |
| city (*optional*)        | <nobr>`String`</nobr> | Die Stadt des Besuchers.                                                                                      |
| postalCode (*optional*)  | <nobr>`String`</nobr> | Die Postleitzahl des Besuchers.                                                                               |
| latitude (*optional*)    | `float`               | Die Breitenkoordinate, die den Standort des Besuchers darstellt. Die Koordinatenzahl stellt Dezimalgrade dar. |
| longitude (*optional*)   | `float`               | Die Längenkoordinate, die den Standort des Besuchers darstellt. Die Koordinatenzahl stellt Dezimalgrade dar.  |

<Tip>
  * Jeder Besucher kann nur eine `Geolocation` haben. Das Hinzufügen einer zweiten `Geolocation` überschreibt die erste.
</Tip>

```java theme={null}
kameleoonClient.addData(visitorCode, new Geolocation("France", "Île-de-France", "Paris"));
```

#### CustomData

`CustomData` ermöglicht die Verknüpfung jeder Art von Daten mit jedem Besucher und macht es zu einem effektiven Werkzeug für Targeting-Bedingungen in [Segmenten](/user-manual/assets/segments/create-a-segment/). Darüber hinaus kann es als Filter oder Breakdown in Experiment-Berichten verwendet werden. Weitere Informationen zu Custom Data finden Sie in diesem [Artikel](/developer-docs/custom-data).

Definieren Sie Custom Data-Typen in der Kameleoon-App oder der Data API und verwenden Sie sie vom SDK aus.

| Name                        | Typ                        | Beschreibung                                                                                                                                                                                              | Standard |
| --------------------------- | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
| index/name (*erforderlich*) | `int`/`String`             | Index oder Name der Custom Data. **Entweder `index` oder `name` muss angegeben werden**, um die Daten zu identifizieren..                                                                                 |          |
| values (*erforderlich*)     | `String...`/`List<String>` | Werte der Custom Data, die gespeichert werden sollen.                                                                                                                                                     |          |
| overwrite (*optional*)      | `boolean`                  | Flag zur expliziten Steuerung, wie die Werte gespeichert werden und wie sie in Berichten erscheinen. [Mehr sehen](/developer-docs/custom-data#default-logic-when-overwrite-parameter-is-false-or-omitted) | `true`   |

<Note>
  * Jeder Besucher ist nur eine `CustomData` für jeden eindeutigen `index`(`name`) erlaubt. Das Hinzufügen einer weiteren `CustomData` mit demselben `index`(`name`) ersetzt die vorhandene.

  * Der Custom Data-Index befindet sich im [Custom Data dashboard](/user-manual/assets/custom-data/manage-custom-data) unter der Spalte "INDEX".

  * Um zu verhindern, dass das SDK Daten mit dem ausgewählten Index aus Datenschutzgründen an Kameleoon-Server sendet, aktivieren Sie die Option: **Use this data only locally for targeting purposes** beim Erstellen von Custom Data.

  * Das Hinzufügen einer `CustomData`-Instanz, die mit einem Namen erstellt wurde, wenn die SDK-Instanz nicht initialisiert ist oder der Name nicht registriert ist, führt dazu, dass die Daten ignoriert werden.
</Note>

```java theme={null}
kameleoonClient.addData(visitorCode, new CustomData(1, "value"));

// With several values
kameleoonClient.addData(visitorCode, new CustomData(1, "value1", "value2"));

// To set the 'overwrite' flag to false
kameleoonClient.addData(visitorCode, new CustomData(1, false, "value"));

// To use a name instead of the index
kameleoonClient.addData(visitorCode, new CustomData("my-custom-data", "value"));
```

#### Device

| Name   | Typ      | Beschreibung                                                                  |
| ------ | -------- | ----------------------------------------------------------------------------- |
| device | `Device` | Liste der Geräte: `PHONE`, `TABLET`, `DESKTOP`. Dieses Feld ist erforderlich. |

```java theme={null}
kameleoonClient.addData(visitorCode, Device.desktop());
```

#### PageView

Speichert Page-View-Ereignisse.

| Name      | Typ             | Beschreibung                                               |
| --------- | --------------- | ---------------------------------------------------------- |
| url       | `String`        | URL der angesehenen Seite. Dieses Feld ist erforderlich.   |
| title     | `String`        | Titel der angesehenen Seite. Dieses Feld ist erforderlich. |
| referrers | `List<Integer>` | Referrer der angesehenen Seiten. Dieses Feld ist optional. |

<Note>
  Der Index (ID) des Referrers ist in der Kameleoon-App auf der Seite der [Konfiguration des Akquisitionskanals](/user-manual/assets/advanced-targeting-tools/create-an-acquisition-channel) verfügbar. Vorsicht: Dieser Index beginnt bei 0, sodass der erste Akquisitionskanal, den Sie für die angegebene Site erstellen, die ID 0 hätte, nicht 1.
</Note>

```java theme={null}
kameleoonClient.addData(
  visitorCode,
  new PageView("https://url.com", "title", Array.asList(3))
);
```

#### UserAgent

Serverseitige Experiments sind mit größerer Wahrscheinlichkeit von Bot-Traffic betroffen als clientseitige Experiments. Kameleoon verwendet die IAB/ABC International Spiders and Bots List, um dieses Problem anzugehen und bekannte Bots und Spider zu erkennen. Kameleoon verwendet auch das Feld `UserAgent`, um Bots und anderen unerwünschten Traffic herauszufiltern, der Ihre Konversionsmetriken verfälschen könnte. Weitere Details finden Sie in unserem Hilfeartikel zum [Bot-Filtering](/user-manual/faq#how-does-kameleoon-filter-bot-traffic-from-my-results).

Wenn Sie interne Bots verwenden, empfehlen wir, den Wert **curl/8.0** des userAgent zu übergeben, um sie aus unserer Analytik auszuschließen.

| Name  | Typ      | Beschreibung                                                                                |
| ----- | -------- | ------------------------------------------------------------------------------------------- |
| value | `String` | Der User-Agent-Wert, der mit Tracking-Anfragen gesendet wird. Dieses Feld ist erforderlich. |

```java theme={null}
kameleoonClient.addData(visitorCode, new UserAgent("Your User Agent"));
```

#### UniqueIdentifier

Wenn Sie keinen `UniqueIdentifier` für einen Besucher hinzufügen, wird `visitorCode` als eindeutige Besucherkennung verwendet, was für [Cross-device experimentation](/developer-docs/cross-device-experimentation) nützlich ist. Wenn Sie `UniqueIdentifier` für einen Besucher hinzufügen, verknüpft das SDK die geflushten Daten mit dem Besucher, der mit der angegebenen Kennung verknüpft ist.

Der `isUniqueIdentifier` kann in besonderen Situationen hilfreich sein; zum Beispiel, wenn Sie nicht auf den anonymen `visitorCode` zugreifen können, der einem Besucher zugewiesen wurde, aber eine interne ID verwenden können, die über Session-Merging mit diesem Besucher verknüpft ist.

| Name  | Typ       | Beschreibung                                                                                         |
| ----- | --------- | ---------------------------------------------------------------------------------------------------- |
| value | `boolean` | Parameter, der angibt, ob der visitorCode eine eindeutige Kennung ist. Dieses Feld ist erforderlich. |

```java theme={null}
kameleoonClient.addData(visitorCode, new UniqueIdentifier(true));
```

#### OperatingSystem

`OperatingSystem` enthält Informationen über das Betriebssystem auf dem Gerät des Besuchers.

| Name | Typ                    | Beschreibung                                                                                                              |
| ---- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| type | `OperatingSystem.Type` | Liste der Betriebssysteme: `WINDOWS_PHONE`, `WINDOWS`, `ANDROID`, `LINUX`, `MAC` und `IOS`. Dieses Feld ist erforderlich. |

<Tip>
  Jeder Besucher kann nur ein `OperatingSystem` haben. Das Hinzufügen eines zweiten `OperatingSystem` überschreibt das erste.
</Tip>

```java theme={null}
kameleoonClient.addData(visitorCode, new OperatingSystem(OperatingSystem.Type.WINDOWS));

kameleoonClient.addData(visitorCode, OperatingSystem.mac());
```

#### ApplicationVersion

`ApplicationVersion` repräsentiert die semantische Versionsnummer Ihrer Anwendung.

<Tip>
  Ein **Besucher** kann nur eine `ApplicationVersion` haben. Das Hinzufügen einer zweiten Instanz überschreibt die erste.
</Tip>

| Name                 | Typ      | Beschreibung                                                                                                                                                         |
| -------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| version (*optional*) | `String` | Die Version der mobilen Anwendung. Dieses Feld muss der semantischen Versionierung folgen. Akzeptierte Formate sind `major`, `major.minor` oder `major.minor.patch`. |

```java theme={null}
kameleoonClient.addData(visitorCode, new ApplicationVersion("10")); // major

kameleoonClient.addData(visitorCode, new ApplicationVersion("10.20")); // major.minor

kameleoonClient.addData(visitorCode, new ApplicationVersion("10.20.30")); // major.minor.patch
```

### Returned Types

#### DataFile

Das `DataFile` enthält die SDK-Konfigurationsdetails.

Es kann bei Bedarf von Kunden um zusätzliche Informationen erweitert werden. Wenn Sie weitere Details benötigen, wenden Sie sich bitte an Ihren Customer Success Manager.

| Name         | Typ                        | Beschreibung                                                                                |
| ------------ | -------------------------- | ------------------------------------------------------------------------------------------- |
| featureFlags | `Map<String, FeatureFlag>` | Eine Map von [`FeatureFlag`](#featureflag)-Objekten, indiziert durch feature flag-Keys.     |
| dateModified | `long`                     | Der Zeitstempel (in Millisekunden), der angibt, wann das `DataFile` zuletzt geändert wurde. |

```java theme={null}
// Retrieves the map of feature flags from the DataFile.
// The map is keyed by feature flag identifiers, with each value being a FeatureFlag object.
Map<String, FeatureFlag> featureFlags = dataFile.getFeatureFlags();

// Retrieves the last modification timestamp of the DataFile.
// The value is a long representing milliseconds since the Unix epoch.
long dateModified = dataFile.getDateModified();
```

#### FeatureFlag

Das `FeatureFlag` repräsentiert eine Reihe von Eigenschaften, die ein feature flag selbst definieren – z. B. seine [`Variations`](#variation), [`Rules`](#rule), den Status der Umgebung und andere zugehörige Details.

Es kann bei Bedarf von Kunden um zusätzliche Informationen erweitert werden. Wenn Sie weitere Details benötigen, wenden Sie sich bitte an Ihren Customer Success Manager.

| Name                | Typ                      | Beschreibung                                                                 |
| ------------------- | ------------------------ | ---------------------------------------------------------------------------- |
| environmentEnabled  | `boolean`                | Gibt an, ob das feature flag in der aktuellen Umgebung aktiviert ist.        |
| defaultVariationKey | `String`                 | Der Schlüssel der Standardvariation, die mit dem feature flag verknüpft ist. |
| variations          | `Map<String, Variation>` | Eine Map von `Variation`-Objekten, indiziert durch Variation-Keys.           |
| rules               | `List<Rule>`             | Eine Liste von `Rule`-Objekten                                               |

```java theme={null}
// Check whether the feature flag is enabled in the current environment
boolean isEnvironmentEnabled = featureFlag.isEnvironmentEnabled();

// Retrieve the key of the default variation
String defaultVariationKey = featureFlag.getDefaultVariationKey();

// Retrieve the default variation object
Variation defaultVariation = featureFlag.getDefaultVariation();

// Retrieve all variations of the feature flag as a map (key = variation key, value = Variation object)
Map<String, Variation> variations = featureFlag.getVariations();

// Retrieve all targeting rules associated with the feature flag
List<Rule> rules = featureFlag.getRules();
```

#### Rule

Die `Rule` repräsentiert eine Reihe von Eigenschaften, die eine Regel selbst definieren – z. B. ihre [`Variations`](#variation).

Sie kann bei Bedarf von Kunden um zusätzliche Informationen erweitert werden. Wenn Sie weitere Details benötigen, wenden Sie sich bitte an Ihren Customer Success Manager.

| Name       | Typ                      | Beschreibung                                                       |
| ---------- | ------------------------ | ------------------------------------------------------------------ |
| variations | `Map<String, Variation>` | Eine Map von `Variation`-Objekten, indiziert durch Variation-Keys. |

```java theme={null}
// Retrieve all variations of the rule as a map (key = variation key, value = Variation object)
Map<String, Variation> variations = rule.getVariations();
```

#### Variation

`Variation` enthält Informationen über die zugewiesene Variation des Besuchers (oder die Standardvariation, wenn keine spezifische Zuweisung existiert).

| Name         | Typ                     | Beschreibung                                                                                                                                                             |
| ------------ | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| name         | `String`                | Der Name der Variation.                                                                                                                                                  |
| key          | `String`                | Der eindeutige Schlüssel, der die Variation identifiziert.                                                                                                               |
| id           | `Integer`               | Die ID der zugewiesenen Variation (oder `null`, wenn es die Standardvariation ist).                                                                                      |
| experimentId | `Integer`               | Die ID des mit der Variation verknüpften Experiments (oder `null`, wenn Standard).                                                                                       |
| variables    | `Map<String, Variable>` | Eine Map, die die Variablen der zugewiesenen Variation enthält, indiziert durch Variablennamen. Dies kann eine leere Sammlung sein, wenn keine Variablen verknüpft sind. |

<Note>
  * Das `Variation`-Objekt liefert Details über die zugewiesene Variation und das zugehörige Experiment, während das [`Variable`](#variable)-Objekt spezifische Details über jede Variable innerhalb einer Variation enthält.
  * Stellen Sie sicher, dass Ihr Code den Fall behandelt, in dem `id` oder `experimentId` `null` sein können, was auf eine Standardvariation hinweist.
  * Die `variables`-Map kann leer sein, wenn keine Variablen mit der Variation verknüpft sind.
</Note>

```java theme={null}
// Retrieving the variation name
String variationName = variation.getName();

// Retrieving the variation key
String variationKey = variation.getKey();

// Retrieving the variation id
Integer variationId = variation.getId();

// Retrieving the experiment id
Integer experimentId = variation.getExperimentId();

// Retrieving the variables map
Map<String, Variable> variables = variation.getVariables();
```

#### Variable

`Variable` enthält Informationen über eine Variable, die mit der zugewiesenen Variation verknüpft ist.

| Name  | Typ      | Beschreibung                                                                                                                                         |
| ----- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| key   | `String` | Der eindeutige Schlüssel, der die Variable identifiziert.                                                                                            |
| type  | `String` | Der Typ der Variable. Mögliche Werte: **BOOLEAN**, **NUMBER**, **STRING**, **JSON**, **JS**, **CSS**.                                                |
| value | `Object` | Der Wert der Variable, der von folgenden Typen sein kann: **Boolean**, **Integer**, **Long**, **Double**, **String**, **JsonObject**, **JsonArray**. |

```java theme={null}
// Retrieving the variables map
Map<String, Variable> variables = variation.getVariables();

// Variable type can be retrieved for further processing
String type = variables.get("isDiscount").getType();

// Retrieving the variable value by key
Boolean isDiscount = (Boolean) variables.get("isDiscount").getValue();

// Variable value can be of different types
String title = (String) variables.get("title").getValue();
```

### Deprecated methods

<Warning>
  Diese Methoden sind veraltet und werden in SDK-Version `5.0.0` entfernt.
</Warning>

#### getFeatureVariationKey()

* *📨 Sendet Tracking-Daten an Kameleoon*

<Note>
  Verwenden Sie stattdessen [`getVariation()`](#getvariation).
</Note>

Rufen Sie diese Methode auf, um den Feature-Variation-Key für einen angegebenen Benutzer und ein angegebenes Feature zu erhalten. Diese Methode nimmt einen `visitorCode` und eine `featureKey` als obligatorische Argumente entgegen, um den Variation-Key für den Benutzer und das Feature zu erhalten.

Wenn der Benutzer noch nie mit diesem feature flag verknüpft war, gibt das SDK einen zufällig zugewiesenen Variation-Key zurück (gemäß den feature flag-Regeln). Wenn ein Benutzer mit dem angegebenen `visitorCode` bereits mit diesem feature flag registriert ist, erkennt das SDK den vorherigen Variation-Key-Wert. Wenn der Benutzer mit keiner der Regeln übereinstimmt, wird der Standardwert zurückgegeben, den Sie in der Kameleoon-App anpassen können.

Stellen Sie sicher, dass Sie mögliche Exceptions abfangen und behandeln.

Wenn Sie einen `visitorCode` angeben, verwendet die Methode `flush()` ihn als eindeutige Besucherkennung, was für [Cross-device experimentation](/developer-docs/cross-device-experimentation) nützlich ist. Wenn Sie einen `visitorCode` angeben und den Parameter `isUniqueIdentifier` auf `true` setzen, verknüpft das SDK die geflushten Daten mit dem Besucher, der mit der angegebenen Kennung verknüpft ist.

<Note>
  Der Parameter `isUniqueIdentifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).

  Der `isUniqueIdentifier` kann in besonderen Situationen hilfreich sein; zum Beispiel, wenn Sie nicht auf den anonymen `visitorCode` zugreifen können, der einem Besucher zugewiesen wurde, aber eine interne ID verwenden können, die über Session-Merging mit diesem Besucher verknüpft ist.
</Note>

```java theme={null}
String visitorCode = kameleoonClient.getVisitorCode(httpServletRequest, httpServletResponse);
String featureKey = "new_checkout";
String variationKey = ""

try {
  variationKey = kameleoonClient.GetFeatureVariationKey(visitorCode, featureKey);
} catch (KameleoonException.FeatureNotFound e) {
  // The error has occurred; the feature flag isn't found in the current configuration
} catch (KameleoonException.FeatureEnvironmentDisabled e) {
  // The feature flag is disabled for the environment
} catch (KameleoonException.VisitorCodeInvalid e) {
  // The visitor code you passed to the method is invalid and can't be accepted by SDK.
}

switch (variationKey) {
  case 'on':
    // Main variation key is selected for visitorCode
    break;
  case 'alternative_variation':
    // Alternative variation key
    break;
  default:
    // Default variation key
    break;
}
```

##### Arguments

| Name                            | Typ       | Beschreibung                                                                                                                                                       |
| ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| visitorCode                     | `String`  | Eindeutige Kennung des Benutzers. Dieses Feld ist erforderlich.                                                                                                    |
| featureKey                      | `String`  | Schlüssel des Features, das Sie einem Benutzer zugänglich machen möchten. Dieses Feld ist erforderlich.                                                            |
| isUniqueIdentifier (Deprecated) | `boolean` | Ein optionaler Parameter, um anzugeben, ob der visitorCode eine eindeutige Kennung ist. Wenn nicht angegeben, ist der Standardwert `false`. Das Feld ist optional. |

##### Return value

| Typ      | Beschreibung                                                                            |
| -------- | --------------------------------------------------------------------------------------- |
| `String` | Variation-Key des feature flags, der für den angegebenen `visitorCode` registriert ist. |

##### Exceptions thrown

| Typ                                           | Beschreibung                                                                                                                                                                                                                                                                                                                |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.FeatureNotFound            | Exception, die anzeigt, dass der angeforderte Feature-Key in der internen Konfiguration des SDK nicht gefunden wurde. Diese Exception bedeutet normalerweise, dass das feature flag in der Kameleoon-App nicht aktiviert ist (aber der Code, der das Feature implementiert, bereits in Ihrer Anwendung bereitgestellt ist). |
| KameleoonException.FeatureEnvironmentDisabled | Exception, die anzeigt, dass das feature flag für die aktuelle Umgebung des Besuchers deaktiviert ist (z. B. production, staging oder development).                                                                                                                                                                         |
| KameleoonException.VisitorCodeInvalid         | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist. Er ist leer oder länger als 255 Zeichen.                                                                                                                                                                                                    |

#### getActiveFeatures()

<Note>
  Verwenden Sie stattdessen [`getVariations()`](#getvariations).
</Note>

Diese Methode nimmt einen einzelnen Parameter **visitorCode** entgegen. Das Ergebnis enthält nur aktive Features für einen bestimmten Besucher.

```java theme={null}
try {
    Map<String, Variation> activeFeatures = kameleoonClient.getActiveFeatures(visitorCode);
} catch (VisitorCodeInvalid e) {
    //  Handle exception
}
```

##### Arguments

| Name        | Typ    | Beschreibung                                                    |
| ----------- | ------ | --------------------------------------------------------------- |
| visitorCode | String | Eindeutige Kennung des Benutzers. Dieses Feld ist erforderlich. |

##### Return value

| Typ                      | Beschreibung                                                                                                                           |
| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
| `Map<String, Variation>` | Map, die die zugewiesenen Variationen der aktiven Features unter Verwendung der Schlüssel der entsprechenden aktiven Features enthält. |

##### Exceptions thrown

| Typ                | Beschreibung                                                                                                                      |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| VisitorCodeInvalid | Exception, die anzeigt, dass der bereitgestellte Visitor-Code nicht gültig ist. Er ist entweder leer oder länger als 255 Zeichen. |

#### getActiveFeatureListForVisitorCode()

<Note>
  * Verwenden Sie stattdessen [`getVariations()`](#getvariations).
  * Diese Methode hieß zuvor `obtainFeatureListForVisitorCode` und wurde in SDK-Version `4.0.0` entfernt.
</Note>

Diese Methode nimmt einen einzelnen Parameter `visitorCode` entgegen. Gibt nur die aktiven feature flags für den angegebenen Besucher zurück.

```java theme={null}
List<String> listActiveFeatureFlags = kameleoonClient.getActiveFeatureListForVisitorCode(visitorCode);
```

##### Arguments

| Name        | Typ      | Beschreibung                                                    |
| ----------- | -------- | --------------------------------------------------------------- |
| visitorCode | `String` | Eindeutige Kennung des Benutzers. Dieses Feld ist erforderlich. |

##### Return value

| Typ            | Beschreibung                                                                               |
| -------------- | ------------------------------------------------------------------------------------------ |
| `List<String>` | Liste der aktiven feature flag-Keys, die für einen bestimmten `visitorCode` verfügbar sind |

#### getFeatureVariable()

* *📨 Sendet Tracking-Daten an Kameleoon*

<Note>
  Verwenden Sie stattdessen [`getVariation()`](#getvariation).
</Note>

Rufen Sie diese Methode auf, um den zugehörigen Feature-Variationswert eines Benutzers zu erhalten. Diese Methode nimmt einen `visitorCode`, eine `featureKey` und eine `variableKey` als erforderliche Argumente entgegen, um die Variable des Variation-Keys für den angegebenen Benutzer zu erhalten.

Wenn ein Benutzer noch nie mit diesem feature flag verknüpft war, gibt das SDK einen zufällig zugewiesenen Variablenwert des Variation-Keys gemäß den feature flag-Regeln zurück. Wenn ein Benutzer mit dem angegebenen `visitorCode` bereits mit diesem feature flag registriert ist, gibt das SDK den Variablenwert für die zuvor zugeordnete Variation zurück. Wenn der Benutzer mit keiner der Regeln übereinstimmt, wird die Standardvariable zurückgegeben.

Stellen Sie sicher, dass Sie mögliche Exceptions abfangen und behandeln.

Wenn Sie einen `visitorCode` angeben, verwendet die Methode `getFeatureVariable()` den Code als eindeutige Besucherkennung, was für [cross-device experimentation](/developer-docs/cross-device-experimentation) nützlich ist. Wenn Sie einen `visitorCode` angeben und den Parameter `isUniqueIdentifier` auf `true` setzen, verknüpft das SDK die geflushten Daten mit dem Besucher, der mit der angegebenen Kennung verknüpft ist.

<Note>
  Der Parameter `isUniqueIdentifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).

  Der `isUniqueIdentifier` kann in besonderen Situationen hilfreich sein; zum Beispiel, wenn Sie nicht auf den anonymen `visitorCode` zugreifen können, der einem Besucher zugewiesen wurde, aber eine interne ID verwenden können, die über Session-Merging mit diesem Besucher verknüpft ist.
</Note>

```java theme={null}
String visitorCode = kameleoonClient.getVisitorCode(httpServletRequest, httpServletResponse);
String featureKey = "feature_key";
String variableKey = "var"

try {
  var variableValue = kameleoonClient.getFeatureVariable(visitorCode, featureKey, variableKey);
  // Your custom code, depending on variableValue.
} catch (KameleoonException.FeatureNotFound e) {
  // The error has occurred; the feature flag isn't found in current configuration
} catch (KameleoonException.FeatureEnvironmentDisabled e) {
  // The feature flag is disabled for the environment.
} catch (KameleoonException.FeatureVariableNotFound e) {
  // Requested variable not defined on Kameleoon's side
} catch (KameleoonException.VisitorCodeInvalid e) {
  // The visitor code passed to the method is invalid and can't be accepted by SDK.
}
```

##### Arguments

| Name                            | Typ       | Beschreibung                                                                                                                                                       |
| ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| visitorCode                     | `String`  | Eindeutige Kennung des Benutzers. Dieses Feld ist erforderlich.                                                                                                    |
| featureKey                      | `String`  | Schlüssel des Features, das Sie einem Benutzer zugänglich machen möchten. Dieses Feld ist erforderlich.                                                            |
| variableKey                     | `String`  | Name der Variable, für die Sie einen Wert erhalten möchten. Dieses Feld ist erforderlich.                                                                          |
| isUniqueIdentifier (Deprecated) | `boolean` | Ein optionaler Parameter, um anzugeben, ob der visitorCode eine eindeutige Kennung ist. Wenn nicht angegeben, ist der Standardwert `false`. Das Feld ist optional. |

##### Return value

| Typ    | Beschreibung                                                                                                                                                                           |
| ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| object | Wert der Variable der Variation, der für den angegebenen `visitorCode` für dieses feature flag registriert ist. Mögliche Typen: `bool`, `int`, `double`, `string`, `JObject`, `JArray` |

##### Exceptions thrown

| Typ                                           | Beschreibung                                                                                                                                                                                                                                                                                                        |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.FeatureNotFound            | Exception, die anzeigt, dass der angeforderte Feature-Key in der internen SDK-Konfiguration nicht gefunden wurde. Dies bedeutet normalerweise, dass das feature flag noch nicht in der Kameleoon-App aktiviert wurde (aber der Code, der das Feature implementiert, bereits in Ihrer Anwendung bereitgestellt ist). |
| KameleoonException.FeatureEnvironmentDisabled | Exception, die anzeigt, dass das feature flag für die aktuelle Umgebung des Besuchers deaktiviert ist (z. B. production, staging oder development).                                                                                                                                                                 |
| KameleoonException.FeatureVariableNotFound    | Exception, die anzeigt, dass die angeforderte Variable nicht gefunden wurde. Überprüfen Sie, ob der Schlüssel der Variable in der Kameleoon-App mit Ihrem Code übereinstimmt.                                                                                                                                       |
| KameleoonException.VisitorCodeInvalid         | Exception, die anzeigt, dass der angegebene Visitor-Code nicht gültig ist. (Er ist entweder leer oder länger als 255 Zeichen).                                                                                                                                                                                      |

#### getFeatureVariables()

* *📨 Sendet Tracking-Daten an Kameleoon*

<Note>
  Verwenden Sie stattdessen [`getVariation()`](#getvariation).
</Note>

Diese Methode ruft eine Map ab, die Variablenschlüssel und ihre Werte enthält, die gemäß der Variation zugewiesen werden, der der Besucher im angegebenen feature flag zugewiesen ist. Feature-Variablen können in der Kameleoon-App geändert werden.

Wenn ein Benutzer noch nie mit diesem feature flag verknüpft war, gibt das SDK einen zufällig zugewiesenen Satz von Variablenwerten in der Variation gemäß den feature flag-Regeln zurück. Wenn ein Benutzer mit dem angegebenen `visitorCode` bereits mit diesem feature flag registriert ist, gibt das SDK die Variablenwerte für die zuvor verwendete Variation zurück. Wenn der Benutzer mit keiner der Regeln übereinstimmt, werden die Standardvariablen zurückgegeben.

Stellen Sie sicher, dass Sie mögliche Exceptions abfangen und behandeln.

```java theme={null}
String visitorCode = kameleoonClient.getVisitorCode(httpServletRequest, httpServletResponse);
String featureKey = "feature_key";
String variableKey = "var"

try {
  var variableValue = kameleoonClient.getFeatureVariables(visitorCode, featureKey);
  // Your custom code, depending on variable values.
} catch (KameleoonException.FeatureNotFound e) {
  // The error has occurred; the feature flag isn't found in current configuration.
} catch (KameleoonException.FeatureEnvironmentDisabled e) {
  // The feature flag is disabled for the environment.
} catch (KameleoonException.FeatureVariableNotFound e) {
  // Requested variable not defined on Kameleoon's side
} catch (KameleoonException.VisitorCodeInvalid e) {
  // The visitor code passed to the method is invalid and can't be accepted by SDK.
}
```

##### Arguments

| Name         | Typ      | Beschreibung                                                                     |
| ------------ | -------- | -------------------------------------------------------------------------------- |
| featureKey   | `String` | Schlüssel des Features, das Sie erhalten möchten. Dieses Feld ist erforderlich.  |
| variationKey | `String` | Schlüssel der Variation, die Sie erhalten möchten. Dieses Feld ist erforderlich. |

##### Return value

| Typ                  | Beschreibung                                                                                                                                                                          |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Map<String,Object>` | Mit diesem feature flag verknüpfte Daten. Die Werte können `Boolean`, `Integer`, `Double`, `String`, `JsonObject` oder `JsonArray` sein (der Typ ist in der Kameleoon-App definiert). |

##### Exceptions thrown

| Typ                                           | Beschreibung                                                                                                                                                                                                                                                                                                              |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.FeatureNotFound            | Exception, die anzeigt, dass der angeforderte Feature-Key in der internen SDK-Konfiguration nicht gefunden wurde. Diese Exception bedeutet normalerweise, dass das feature flag nicht in der Kameleoon-App aktiviert wurde (aber der Code, der das Feature implementiert, bereits in Ihrer Anwendung bereitgestellt ist). |
| KameleoonException.FeatureEnvironmentDisabled | Exception, die anzeigt, dass das feature flag für die aktuelle Umgebung des Besuchers deaktiviert ist (z. B. production, staging oder development).                                                                                                                                                                       |
| KameleoonException.FeatureVariationNotFound   | Exception, die anzeigt, dass der angeforderte Variation-Key in der internen Konfiguration des SDK nicht gefunden wurde. Dies bedeutet normalerweise, dass das der Variation entsprechende Experiment nicht in der Kameleoon-App aktiviert ist.                                                                            |
| KameleoonException.VisitorCodeInvalid         | Exception, die anzeigt, dass der angegebene Visitor-Code nicht gültig ist. (Er ist entweder leer oder länger als 255 Zeichen).                                                                                                                                                                                            |

#### getFeatureVariationVariables()

<Note>
  * Verwenden Sie stattdessen [`getVariation()`](#getvariation).
  * Diese Methode hieß zuvor `getFeatureAllVariables` und wurde in SDK-Version `4.0.0` entfernt.
</Note>

Rufen Sie diese Methode auf, um alle Feature-Variablen für ein Feature abzurufen. Sie können Feature-Variablen in der Kameleoon-App ändern.

Diese Methode nimmt zwei Eingabeparameter entgegen: `featureKey` und `variationKey`. Sie gibt die Daten mit dem Typ `Map<String, Object>` zurück, wie in der Kameleoon-App definiert. Sie wirft eine Exception (`KameleoonException.FeatureNotFound`), wenn das angeforderte Feature in der internen Konfiguration des SDK nicht gefunden wird.

```java theme={null}
String featureKey = "featureKey";
String variationKey = "variationKey";

try {
  Map<String, Object> allVariables = kameleoonClient.getFeatureVariationVariables(featureKey, variationKey);
} catch (KameleoonException.FeatureNotFound e) {
  // The feature is not activated in the Kameleoon app.
} catch (KameleoonException.FeatureEnvironmentDisabled e) {
  // The feature flag is disabled for the environment.
} catch (KameleoonException.FeatureVariationNotFound e) {
  // The variation is not activated in the Kameleoon app (most likely, the associated experiment is not active)
} catch (Exception e) {
  // This is a generic Exception handler which will handle all exceptions.
  System.out.println("Exception occurred");
}
```

##### Arguments

| Name         | Typ    | Beschreibung                                                                     |
| ------------ | ------ | -------------------------------------------------------------------------------- |
| featureKey   | String | Schlüssel des Features, das Sie erhalten möchten. Dieses Feld ist erforderlich.  |
| variationKey | String | Schlüssel der Variation, die Sie erhalten möchten. Dieses Feld ist erforderlich. |

##### Return value

| Typ                  | Beschreibung                                                                                                                                                                            |
| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Map<String,Object>` | Mit diesem feature flag verknüpfte Daten. Die Werte können `Boolean`, `Integer`, `Double`, `String`, `JsonObject`, `JsonArray` sein (je nach dem in der Kameleoon-App definierten Typ). |

##### Exceptions thrown

| Typ                                           | Beschreibung                                                                                                                                                                                                                                   |
| --------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| KameleoonException.FeatureNotFound            | Exception, die anzeigt, dass das angeforderte Feature in der internen Konfiguration des SDK nicht gefunden wurde. Diese Exception bedeutet normalerweise, dass das feature flag nicht in der Kameleoon-App aktiviert ist.                      |
| KameleoonException.FeatureEnvironmentDisabled | Exception, die anzeigt, dass das feature flag für die aktuelle Umgebung des Besuchers deaktiviert ist (z. B. production, staging oder development).                                                                                            |
| KameleoonException.FeatureVariationNotFound   | Exception, die anzeigt, dass der angeforderte Variation-Key in der internen Konfiguration des SDK nicht gefunden wurde. Dies bedeutet normalerweise, dass das der Variation entsprechende Experiment nicht in der Kameleoon-App aktiviert ist. |