Please add the Esper compiler jar file, the common jar file and the compiler dependencies to the classpath of the program that will be compiling EPL. The jar files listed here are not required for the runtime except for esper-common-version.jar.

Optionally, for logging using Log4j, please add slf4j-log4j12-1.7.25.jar and log4j-1.2.17.jar to the classpath.

There are no additional jar files required by Esper for using Esper with JSON-formatted event documents.

Optionally, for using Apache Avro, please add esper-common-avro-version.jar to the classpath.

Your application can register an event type to instruct the compiler what the input events look like. When compiling modules the compiler checks the available event type information to determine that the module is valid.

This example assumes that there is a Java class PersonEvent and each instance of the PersonEvent class is an event.

Our event class for the step-by-step is:

package com.mycompany.myapp;

public class PersonEvent {
  private String name;
  private int age;

  public PersonEvent(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public String getName() {
    return name;
  }

  public int getAge() {
    return age;
  }
}

The different event representations are discussed at Section 3.5, “Comparing Event Representations”.

For declaring event types using EPL with create schema, see Section 5.15, “Declaring an Event Type: Create Schema”.

Your application can obtain a compiler calling the getCompiler static method of the EPCompilerProvider class:

EPCompiler compiler = EPCompilerProvider.getCompiler();

The step-by-step provides a Configuration object to the compiler that adds the predefined person event:

Configuration configuration = new Configuration();
configuration.getCommon().addEventType(PersonEvent.class);

The sample module for this getting-started section simply has one statement that selects the name and the age of each arriving person event. It specifies a statement name using the @name annotation and assigns a name my-statement to the statement.

@name('my-statement') select name, age from PersonEvent

Compile a module by using the compile method passing the configuration as part of the compiler arguments:

CompilerArguments args = new CompilerArguments(configuration);
			
EPCompiled epCompiled;
try {
  epCompiled = compiler.compile("@name('my-statement') select name, age from PersonEvent", args);
}
catch (EPCompileException ex) {
  // handle exception here
  throw new RuntimeException(ex);
}

Upon compiling this module, the compiler verifies that PersonEvent exists since it is listed in the from-clause. The compiler also verifies that the name and age properties are available for the PersonEvent since they are listed in the select-clause. The compiler generates byte code for extracting property values and producing output events. The compiler builds internal data structures for later use by filter indexes to ensure that when a PersonEvent comes in it will be processed fast.

More information on the compile API can be found at Chapter 15, Compiler Reference and the JavaDoc.

Please add the Esper common jar file, the runtime jar file and the runtime dependencies to the classpath of the program that will be executing compiled modules. The runtime jar file is not required for the compiler.

Optionally, for logging using Log4j, please add slf4j-log4j12-1.7.25.jar and log4j-1.2.17.jar to the classpath.

There are no additional jar files required by Esper for using Esper with JSON-formatted event documents.

Optionally, for using Apache Avro, please add esper-common-avro-version.jar to the classpath.

The step-by-step provides a Configuration object to the runtime that adds the predefined person event:

Configuration configuration = new Configuration();
configuration.getCommon().addEventType(PersonEvent.class);

Your application can obtain a runtime by calling the getDefaultRuntime static method of the EPRuntimeProvider class and passing the configuration:

EPRuntime runtime = EPRuntimeProvider.getDefaultRuntime(configuration);

More information about the runtime can be found at Chapter 16, Runtime Reference and the JavaDoc.

More information about configuration can be found at Chapter 17, Configuration and the JavaDoc.

Your application can deploy a compiled module using the deploy method of the administrative interface.

The API calls are:

EPDeployment deployment;
try {
  deployment = runtime.getDeploymentService().deploy(epCompiled);
}
catch (EPDeployException ex) {
  // handle exception here
  throw new RuntimeException(ex);
}

As part of deployment, the runtime verifies that all module dependencies, such as event types, do indeed exist. During deployment the runtime adds entries to filter indexes to ensure that when a PersonEvent comes in it will be processed fast.

Your application can attach a callback to the EPStatement to receive statement results. The following sample callback simply prints name and age:

EPStatement statement = runtime.getDeploymentService().getStatement(deployment.getDeploymentId(), "my-statement");
			
statement.addListener( (newData, oldData, statement, runtime) -> {
  String name = (String) newData[0].get("name");
  int age = (int) newData[0].get("age");
  System.out.println(String.format("Name: %s, Age: %d", name, age));
});

Your application can provide different kinds of callbacks, see Table 16.2, “Choices For Receiving Statement Results”.

Your application can send events into the runtime using the sendEventBean method (or other sendEvent method matching your choice of event) that is part of the runtime interface:

runtime.getEventService().sendEventBean(new PersonEvent("Peter", 10), "PersonEvent");

The output you should see is:

Name: Peter, Age: 10

Upon sending the PersonEvent event object to the runtime, the runtime consults the internally-maintained shared filter index tree structure to determine if any statement is interested in PersonEvent events. The statement that was deployed as part of this example has PersonEvent in the from-clause, thus the runtime delegates processing of such events to the statement. The compiled bytecode obtains the name and age properties by calling the getName and getAge methods.

The compiler and runtime both require the following 3rd-party libraries:

The compiler requires the following 3rd-party libraries for compiling only (and not at runtime):

The runtime does not require any additional 3rd-party libraries.