Working with Bindings

Bindings allow to set up and manage relations between different parts of server's unified data model, e.g. cells in data tables or variables/functions/events of different contexts.

Despite bindings don't normally require any programmatic customization, it's possible to implement and use your own custom binding engine since most of related classes are part of open-source API.

A binding engine is based on several primary classes and interfaces:

  • BindingProcessor responsible to managing binding execution and related threads.
  • BindingProvider defining actions to take once a binding was executed and it's necessary to make use of its result.
  • Binding defining a single binding itself.

Implementing Binding Processor

As for the binding processor, it doesn't require any customization. A standard DefaultBindingProcessor class may be used in most cases.

Implementing Binding Provider

In contrast to the processor, binding provider should have a custom implementation in every binding engine.

The following minimal set of methods should be overridden for customization:

  • createBindings() returning a Map<Binding, EvaluationOptions> with binding objects and their evaluation options
  • writeReference(int method, Binding binding, Reference cause, Object value, ChangeCache cache) that performs actual change of binding's target to the provided value

A method could be one of the following:

  • EvaluationOptions.STARTUP
  • EvaluationOptions.EVENT
  • EvaluationOptions.PERIODIC

If a custom implementation is not based on a standard ContextBindingProvider, it will be also necessary to implement methods that add and remove reference listeners that should be called if a change triggering of a detected binding execution. Those methods are:

  • addReferenceListener(Reference ref, ReferenceListener<T> listener)
  • removeReferenceListener(ReferenceListener<T> listener)

The custom binding provider should inform listeners about a detected change that should trigger an event-based binding execution. This is performed by calling referenceChanged(final Reference cause, final Map<String, Object> environment, ChangeCache cache, boolean asynchronousProcessing) method of a previously added ReferenceListener.

Using Binding Engine

Using a custom binding engine is very easy:

  • First a BindingProcessor should be created. It normally accepts an instance of a custom BindingProvider as an argument. Also, a custom thread pool to be used for concurrent binding processing may be specified as a constructor argument.
  • Second binding processing should be initiated by calling start() method.
  • Once the engine should be terminated, stop() method of the binding processor should be invoked.

Was this page helpful?