...

Uses the concept of sessions to buckets in order to give a logical separation between different scopes. For example, "config" could be a bucket to store all data related to the configurations scope, and it will be represented as a folder in the local file system provider.

@Inject
protected BinaryDataService binaryDataService;

protected BinaryDataServiceSession session;


@PostConstruct
void init() {
  session = binaryDataService.newSession("config");
}


public void storeConfig(String key, InputStream inputStream) {
  session.store(key, inputStream);
}


public Optional<InputStream> findConfig(String key) {
  return session.find(key);
}

...

...

If the cache statistics are enabled, they will be published as part of the application metrics:

• cache.eviction.weight - the sum of weights of evicted entries
• cache.evictions - the count of cache evictions
• cache.size - the estimated number of entries in the cache
• cache.gets - the number of times a cache-annotated method has returned an item (regardless if it was cached or not). This metric can be refined with the use of tags:
  • result:hit - the number of times cache lookup methods have returned a cached value
  • result:miss - the number of times cache lookup methods have returned an uncached value

...

...

Function to determine the size of an element. Required to trigger a Data Size flush. For instance, a collection of integer elements can define its weigher as:

...

Consumer to be executed if the flush handler was successfully executed. For instance, a success handler for a collection of integer elements can be defined as:

...

BiConsumer to be executed if the flush handler failed. For instance, a failure handler for a collection of integer elements can be defined as:

...

Each collection will publish metrics about the duration of each flush event, its size, and the count of success/failures (see Metrics section).

This can be refined with the use of custom tags during the creation of the collection:

...

{
  "or": [
    {
      "equals": {
        "field": "fieldA",
        "value": "valueA"
      }
    }, {
      "equals": {
        "field": "fieldB",
        "value": "valueB"
      }
    }
  ]
}

EvalEx

EvalEx is a lightweight library capable of processing numeric, logical, conditional, String, array and structure-based expressions at runtime. It doesn’t need any external dependencies. Some minor functionalities such as support for hexadecimal and implicit multiplication are present. None of the functions are null safe due to the conversion of the parameters to EvaluationValue during processing.

Example of basic expression evaluation without variables or configuration.

var input = "5 * 2";
var expression = new Expression(input);
var rawResult = expression.evaluate();
int finalResult = rawResult.getNumberValue().intValue();

If the expression has variables, a Map with the value of said variables must be provided.

var input = "x * y";
Map<String, Object> variables = new HashMap<>();
variables.put("x", "5");
variables.put("y", "2");
var expression = new Expression(input);
var rawResult = expression.withValues(variables).evaluate();
int finalResult = rawResult.getNumberValue().intValue();

Exceptions

The library provides two new exceptions which must be handled. A ParseException is thrown, when the expression could not be parsed. An EvaluationException is thrown, when the expression could be parsed, but not evaluated. If possible, both exceptions report the following details:

• Start Position of the error (character position, starting with 1).
• End Position of the error (character position, starting with 1).
• The Token string, usually the operator, function, variable or literal causing the error.
• The error message.

Default Functions

Although the default operators and functions are not explicitly listed in the official documentation, they can be seen in the ExpressionConfiguration class.

Expression Configuration

The expression evaluation can be configured to enable and disable specific features.

Custom Functions

Personalized functions can be added with the expression configuration. For this process a new class that extends AbstractFunction. In this class @FunctionParameter tags must be added to class. These will signify the parameters needed to use the function. Lastly, an override to the evaluate method is needed to implement the custom function's logic. This functions can be called recursively.

This class is an example of a basic custom function which adds 5 to the parameter provided.

@FunctionParameter(name = "value")
public class AddFiveFunction extends AbstractFunction {

  @Override
  public EvaluationValue evaluate(Expression expression, Token functionToken, EvaluationValue... parameterValues) throws EvaluationException {
    EvaluationValue value = parameterValues[0];
    return new EvaluationValue(value.getNumberValue().doubleValue()+5.0);
  }
}

The function is then added to the evaluated expression via an ExpressionConfiguration object at evaluation time.

ExpressionConfiguration configuration = ExpressionConfiguration.
  defaultConfiguration().withAdditionalFunctions(
  Map.entry("ADDFIVE", new AddFiveFunction()));
var input = "ADDFIVE(5)";
var expression = new Expression(input, configuration);
var rawResult = expression.evaluate();
int finalResult = rawResult.getNumberValue().intValue();

Custom Operators

Much like functions, custom operators can be added. To do this, a new class that extends AbstractOperator is needed. A tag must be added to specify if the operator must be used as prefix, postfix or infix. The tag also specifies the precedence using a value for comparison. The value of the other operators can be seen in the OperatorIfc for reference. If no value is specified, the operator will have the highest precedence.

This class is an example of a basic custom function which adds 5 to the parameter provided.

@PrefixOperator(precedence = 1)
public class TimesThreeOperator extends AbstractOperator {

  @Override
  public EvaluationValue evaluate(Expression expression, Token operatorToken, EvaluationValue... operands) throws EvaluationException {
    return new EvaluationValue(operands[0].getNumberValue().intValue()*3);
  }
}

The operator is then added to the evaluated expression via an ExpressionConfiguration object at evaluation time.

ExpressionConfiguration configuration = ExpressionConfiguration.
  defaultConfiguration().withAdditionalOperators(
  Map.entry("@", new TimesThreeOperator()));
var input = "@3";
Expression expression = new Expression(input, configuration);
return expression.evaluate();

EvalEx Utils

The EvalExUtils class contains methods made to facilitate the processes that may use the Expression Language evaluator.

Array Converters

When an array is evaluated all of its contents are converted to an EvaluationValue object. This renders the resulting array useless if not processed. To simplify this, 4 array converters were included to convert an EvaluationValue array to an Integer, String, Boolean or plain Object array.

Added Functions

System Function

SystemFunction gets a System property or Environment Variable value given it's key. The System property has precedence. If no System property or Environment variable is found, an EvaluationException is thrown with the message "No such system parameter or environment variable". It is used with the SYSTEM tag. E.g. SYSTEM(java.runtime.version) = 17.0.6+10 (result may vary).

Encrypt and Decrypt Functions

EncryptFunction encrypts the given content using the encryption method in CryptoUtils. It is used with the ENCRYPT tag. E.g. ENCRYPT("Test") = (Encrypted string for "Test"). DecryptFunction decrypts an encrypted content using the decryption method in CryptoUtils. It is used with the DECRYPT tag. E.g. DECRYPT(Encrypted string for "Test") = Test.

Regex Match Function

RegexMatchFunction returns a boolean specifying if a string matches a given pattern. It is used with the REGEX_MATCH tag. E.g. REGEX_MATCH("This is a Test", ".t") = true.

Ends With and Starts with Functions

EndsWithFunction verifies with a boolean if a string ends with a given substring. It is used with the STR_ENDSWITH tag. E.g. STR_ENDSWITH("This is a test","test") = true. StartsWithFunction verifies with a boolean if a string starts with a given substring. These functions are case-sensitive. It is used with the STR_STARTSWITH tag. E.g. STR_STARTSWITH("This is a test","This") = true.

Is Empty and Is Blank Functions

IsBlankFuction verifies with a boolean if a string is blank. It is used with the tag STR_ISBLANK tag. E.g. STR_ISBLANK(" ") = true. IsEmptyFunction verifies with a boolean if a string is empty. It is used with the tag STR_ISEMPTY tag. E.g. STR_ISEMPTY("") = true.

Split Function

SplitFunction splits a given string by a given token. The resulting array contains EvaluationValue objects, therefore the substrings must be converted back to strings. It is used with the STR_SPLIT tag. E.g. STR_SPLIT("This is a Test", "") = {"This", "is", "a", "test"}.

Concat Function

ConcatFunction concatenates any given set of strings. It is used with the STR_CONCAT tag. E.g. STR_CONCAT("This", "is", "a", "test") = "This is a Test".

Array Join Function

ArrayJoinFunction concatenates two given arrays of the same type into one array. It is used with the ARR_JOIN tag. The resulting array will be an Object[], therefore it must be processed with the arrayFactoryProcessor. E.g. JOIN(list1, list2) = (1, 2, 3, 4, 5, 6) with list1 = (1, 2, 3) and list2 = (4, 5, 6) being variables.

Array Contains Function

ArrayContainsFunction verifies if an array contains a given value. It is used with the ARR_CONTAINS tag. E.g. ARR_CONTAINS(array, 1) = true, with array = (1, 2, 3) being a variable.

Get By Index Function

GetByIndexFunction provides the value in the given index. It is used with the ARR_GET tag. E.g. ARR_GET(array, 0) = "This", with array = ("This", "is", "a", "test") being a variable.

Array Is Empty Function

ArrayIsEmptyFunction provides a boolean specifying if an array is Empty. It is used with the ARR_ISEMPTY tag. E.g. ARR_ISEMPTY(array) = true, with array = () being a variable.

Array Size Function

ArraySizeFunction provides the value in the given index. It is used with the ARR_SIZE tag. E.g. SIZE(array) = 3, with array = (1, 2, 3) being a variable.

HTTP Base Client

The HTTP Base Client is an abstraction of the OkHttpClient. It provides features such as retry handlers (see Retries) and automated paginated requests.

...

...

...

...

Providers

RabbitMQ

...