SDK de Java

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
}

kameleoonClient.addData(visitorCode, new CustomData(index, "newVisitorCode"));

// 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();

// 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);

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());

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
}

// 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;
});

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
}

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;
}

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
}

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
}

try {
    kameleoonClient.evaluateAudiences(visitorCode);
} catch (KameleoonException ex) {
    // Handle the common Kameleoon Exception
}

List<String> allFeatureFlagKey = kameleoonClient.getFeatureList();

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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

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

// 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"));

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

CompletableFuture<JsonObject> data = kameleoonClient.getRemoteData("key");

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

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
}

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
}

// 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);

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);

String engineTrackingCode = kameleoonClient.getEngineTrackingCode(visitorCode);

kameleoonClient.updateConfigurationHandler(() -> {
  // Configuration was updated
});

kameleoonClient.addData(visitorCode, Browser.chrome());
kameleoonClient.addData(visitorCode, Browser.safari());

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

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 = new Cookie (new HashMap<String, String>() {{
    put("my_key1", "my_value1");
    put("my_key2", "my_value1");
}});
kameleoonClient.addData(visitorCode, cookie);

kameleoonClient.addData(visitorCode, new Geolocation("France", "Île-de-France", "Paris"));

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"));

kameleoonClient.addData(visitorCode, Device.desktop());

kameleoonClient.addData(
  visitorCode,
  new PageView("https://url.com", "title", Array.asList(3))
);

kameleoonClient.addData(visitorCode, new UserAgent("Your User Agent"));

kameleoonClient.addData(visitorCode, new UniqueIdentifier(true));

kameleoonClient.addData(visitorCode, new OperatingSystem(OperatingSystem.Type.WINDOWS));

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

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

// 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();

// 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();

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

// 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();

// 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();

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;
}

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

List<String> listActiveFeatureFlags = kameleoonClient.getActiveFeatureListForVisitorCode(visitorCode);

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.
}

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.
}

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");
}