Errai Reference Guide

This section covers the core messaging concepts of the ErraiBus messaging framework.

ErraiBus provides a straight-forward approach to a complex problem space. Providing common APIs across the client and server, developers will have no trouble working with complex messaging scenarios such as building instant messaging clients, stock tickers, to monitoring instruments. There’s no more messing with RPC APIs, or unwieldy AJAX or COMET frameworks. We’ve built it all in to one concise messaging framework. It’s single-paradigm, and it’s fun to work with.

public class HelloWorld implements EntryPoint {


  // Get an instance of the RequestDispatcher

  private RequestDispatcher dispatcher = ErraiBus.getDispatcher();


  public void onModuleLoad() {

    Button button = new Button("Send message");


    button.addClickHandler(new ClickHandler() {

      public void onClick(ClickEvent event) {

        // Send a message to the 'HelloWorldService'.

        MessageBuilder.createMessage()

          .toSubject("HelloWorldService") // (1)

          .signalling() // (2)

          .noErrorHandling() // (3)

          .sendNowWith(dispatcher); // (4)

        });


        [...]

      }

   }

}

@Service

  public class HelloWorldService implements MessageCallback {

    public void callback(Message message) {

      System.out.println("Hello, World!");

    }

  }

@Service

public class HelloWorldService implements MessageCallback {


  private RequestDispatcher dispatcher;


  @Inject

  public HelloWorldService(RequestDispatcher dispatcher) {

    dispatcher = dispatcher;

  }


  public void callback(CommandMessage message) {

    // Send a message to the 'HelloWorldClient'.

    MessageBuilder.createMessage()

      .toSubject("HelloWorldClient") // (1)

      .signalling()                  // (2)

      .with("text", "Hi There")      // (3)

      .noErrorHandling()             // (4)

      .sendNowWith(dispatcher);      // (5)

    });

  }

}

public class HelloWorld implements EntryPoint {


  private MessageBus bus = ErraiBus.get();


  public void onModuleLoad() {

     [...]


     /*

      * Declare a service to receive messages on the subject

      * "BroadcastReceiver".

      */

     bus.subscribe("BroadcastReceiver", new MessageCallback() {

       public void callback(CommandMessage message) {

         /*

          * When a message arrives, extract the "text" field and

          * do something with it

          */

          String messageText = message.get(String.class, "text");

        }

     });


     [...]

  }

}

@Local

@Service

  public class HelloIntrovertService implements MessageCallback {

    public void callback(Message message) {

      System.out.println("Hello, me!");

    }

  }

public void registerLocalService(MessageBus bus) {

  bus.subscribeLocal("LocalBroadcastReceiver", new MessageCallback() {

    public void callback(Message message) {

       String messageText = message.get(String.class, "text");

     }

  });

}

MessageBuilder.createMessage()

  .toSubject("ConversationalService").signalling()

  .with("SomeField", someValue)

  .noErrorHandling()

  .repliesTo(new MessageCallback() {

    public void callback(Message message) {

      System.out.println("I received a response");

    }

   })

  MessageBuilder.createMessage()

    .toSubject("ObjectService").signalling()

    .with(MessageParts.ReplyTo, "ClientEndpoint")

    .noErrorHandling().sendNowWith(dispatcher);

  MessageBuilder.createConversation(message)

    .subjectProvided().signalling()

    .with("Records", records)

    .noErrorHandling().reply();

MessageBuilder.createMessage().

    .toSubject("MessageListener")

    .with("Text", "Hello, from your overlords in the cloud")

    .noErrorHandling().sendGlobalWith(dispatcher);

   QueueSession sess = message.getResource(QueueSession.class, Resources.Session.name());

   String sessionId = sess.getSessionId();

...

  public void callback(Message message) {

   QueueSession sess = message.getResource(QueueSession.class, Resources.Session.name());

   String sessionId = sess.getSessionId();


    // Record this sessionId somewhere.

    ...

  }

  MessageBuilder.createMessage()

    .toSubject("ClientMessageListener")

    .signalling()

    .with(MessageParts.SessionID, sessionId)

    .with("Message", "We're relaying a message!")

    .noErrorHandling().sendNowWith(dispatcher);

MessageBuilder.createMessage()

    .toSubject("HelloWorldService")

    .signalling()

    .with("msg", "Hi there!")

    .errorsHandledBy(new ErrorCallback() {

      public boolean error(Message message, Throwable throwable) {

        throwable.printStackTrace();

          return true;

      }

    })

    .sendNowWith(dispatcher);

ErrorCallback error = new ErrorCallback() {

  public boolean error(Message message, Throwable throwable) {

    throwable.printStackTrace();

    return true;

  }

}


MessageBuilder.createMessage()

  .toSubject("HelloWorldService")

  .signalling()

  .with("msg", "Hi there!")

  .errorsHandledBy(error)

  .sendNowWith(dispatcher);

messageBus.addTransportErrorHandler(new TransportErrorHandler() {

  public void onError(TransportError error) {

    // error handling code.

  }

});

  MessageBuilder.createConversation(msg)

    .toSubject("FunSubject")

    .signalling()

    .noErrorHandling()

    .replyDelayed(TimeUnit.SECONDS, 5); // sends the message after 5 seconds.

   MessageBuilder.createMessage()

     .toSubject("FunSubject")

     .signalling()

     .noErrorHandling()

     .sendDelayed(requestDispatcher, TimeUnit.SECONDS, 5); // sends the message after 5 seconds.

  MessageBuilder.createMessage()

    .toSubject("FunSubject")

    .signalling()

    .withProvided("time", new ResourceProvider<String>() {

       SimpleDateFormat fmt = new SimpleDateFormat("hh:mm:ss");


       public String get() {

         return fmt.format(new Date(System.currentTimeMillis());

       }

     }

     .noErrorHandling()

     .sendRepeatingWith(requestDispatcher, TimeUnit.SECONDS, 1); //sends a message every 1 second

AsyncTask task = MessageBuilder.createConversation(message)

  .toSubject("TimeChannel").signalling()

  .withProvided(TimeServerParts.TimeString, new ResourceProvider<String>() {

     public String get() {

       return String.valueOf(System.currentTimeMillis());

     }

   }).defaultErrorHandling().replyRepeating(TimeUnit.MILLISECONDS, 100);


    ...


  // cancel the task and interrupt it's thread if necessary.

  task.cancel(true);

public class TestService implements MessageCallback {

  public void callback(final Message message) {

    // obtain a reference to the session context by referencing the incoming message.

    SessionContext injectionContext = SessionContext.get(message);


    // set an attribute.

    injectionContext.setAttribute("MyAttribute", "Foo");

  }

}

public class TestService implements MessageCallback {

  public void callback(final Message message) {

    // obtain a reference to the local context by referencing the incoming message.

    LocalContext injectionContext = LocalContext.get(message);


   // set an attribute.

    injectionContext.setAttribute("MyAttribute", "Foo");

  }

}

2.12. Wire Protocol (J.REP)

ErraiBus implements a JSON-based wire protocol which is used for the federated communication between different buses. The protocol specification encompasses a standard JSON payload structure, a set of verbs, and an object marshalling protocol. The protocol is named J.REP. Which stands for JSON Rich Event Protocol.

[[sid-23036473_WireProtocol%28J.REP%29-PayloadStructure]]

2.12.1. Payload Structure

All wire messages sent across are assumed to be JSON arrays at the outermost element, contained in which, there are 0..n messages. An empty array is considered a no-operation, but should be counted as activity against any idle timeout limit between federated buses.

Example 2.1. Example J.REP Payload

[

  {"ToSubject" : "SomeEndpoint", "Value" : "SomeValue" },

  {"ToSubject" : "SomeOtherEndpoint", "Value" : "SomeOtherValue"}

]

Here we see an example of a J.REP payload containing two messages. One bound for an endpoint named "SomeEndpoint" and the other bound for the endpoint "SomeOtherEndpoint". They both include a payload element "Value" which contain strings. Let’s take a look at the anatomy of an individual message.

Example 2.2. An J.REP Message

{

  "ToSubject" : "TopicSubscriber",

  "CommandType" : "Subscribe",

  "Value " : "happyTopic",

  "ReplyTo" : "MyTopicSubscriberReplyTo"

}

The message shows a very vanilla J.REP message. The keys of the JSON Object represent individual message parts, with the values representing their corresponding values. The standard J.REP protocol encompasses a set of standard message parts and values, which for the purposes of this specification we’ll collectively refer to as the protocol verbs.

The following table describes all of the message parts that a J.REP capable client is expected to understand:

Part	Required	JSON Type	Description
ToSubject	Yes	String	Specifies the subject within the bus, and its federation, which the message should be routed to.
CommandType	No	String	Specifies a command verb to be transmitted to the receiving subject. This is an optional part of a message contract, but is required for using management services
ReplyTo	No	String	Specifies to the receiver what subject it should reply to in response to this message.
Value	No	Any	A recommended but not required standard payload part for sending data to services
PriorityProcessing	No	Number	A processing order salience attribute. Messages which specify priority processing will be processed first if they are competing for resources with other messages in flight. Note: the current version of ErraiBus only supports two salience levels (0 and >1). Any non-zero salience in ErraiBus will be given the same priority relative to 0 salience messages
ErrorMessage	No	String	An accompanying error message with any serialized exception
Throwable	No	Object	If applicable, an encoded object representing any remote exception that was thrown while dispatching the specified service

[[sid-23036473_WireProtocol%28J.REP%29-BuiltinSubjects]]

2.12.1.1. Built-in Subjects

The table contains a list of reserved subject names used for facilitating things like bus management and error handling. A bus should never allow clients to subscribe to these subjects directly.

Subject	Description
ClientBus	The self-hosted message bus endpoint on the client
ServerBus	The self-hosted message bus endpoint on the server
ClientBusErrors	The standard error receiving service for clients

As this table indicates, the bus management protocols in J.REP are accomplished using self-hosted services. See the section on Bus Management and Handshaking Protocols for details.

[[sid-23036473_WireProtocol%28J.REP%29-MessageRouting]]

2.12.2. Message Routing

There is no real distinction in the J.REP protocol between communication with the server, versus communication with the client. In fact, it assumed from an architectural standpoint that there is no real distinction between a client and a server. Each bus participates in a flat-namespaced federation. Therefore, it is possible that a subject may be observed on both the server and the client.

One in-built assumption of a J.REP-compliant bus however, is that messages are routed within the auspices of session isolation. Consider the following diagram:

Figure 2.1. Topology of a J.REP Messaging Federation

It is possible for Client A to send messages to the subjects ServiceA and ServiceB. But it is not possible to address messages to ServiceC. Conversely, Client B can address messages to ServiceC and ServiceB, but not ServiceA.

[[sid-23036473_WireProtocol%28J.REP%29-BusManagementandHandshakingProtocols]]

2.12.3. Bus Management and Handshaking Protocols

Federation between buses requires management traffic to negotiate connections and manage visibility of services between buses. This is accomplished through services named ClientBus and ServerBus which both implement the same protocol contracts which are defined in this section.

[[sid-23036473_WireProtocol%28J.REP%29-ServerBusandClientBuscommands]]

2.12.3.1. ServerBus and ClientBus commands

Both bus services share the same management protocols, by implementing verbs (or commands) that perform different actions. These are specified in the protocol with the CommandType message part. The following table describes these commands:

Table 2.1. Message Parts for Bus Commands:

Command / Verb	Message Parts	Description
ConnectToQueue	N/A	The first message sent by a connecting client to begin the handshaking process.
CapabilitiesNotice	CapabilitiesFlags	A message sent by one bus to another to notify it of its capabilities during handshake (for instance long polling or websockets)
FinishStateSync	N/A	A message sent from one bus to another to indicate that it has now provided all necessary information to the counter-party bus to establish the federation. When both buses have sent this message to each other, the federation is considered active.
RemoteSubscribe	Subjector SubjectsList	A message sent to the remote bus to notify it of a service or set of services which it is capable of routing to.
RemoteUnsubscribe	Subject	A message sent to the remote bus to notify it that a service is no longer available.
Disconnect	Reason	A message sent to a server bus from a client bus to indicate that it wishes to disconnect and defederate. Or, when sent from the client to server, indicates that the session has been terminated.
SessionExpired	N/A	A message sent to a client bus to indicate that its messages are no longer being routed because it no longer has an active session
Heartbeat	N/A	A message sent from one bus to another periodically to indicate it is still active.

Part	Required	JSON Type	Description
CapabilitiesFlags	Yes	String	A comma delimited string of capabilities the bus is capable of us
Subject	Yes	String	The subject to subscribe or unsubscribe from
SubjectsList	Yes	Array	An array of strings representing a list of subjects to subscribe to

@Service

public class HelloWorldService implements MessageCallback {

  public void callback(CommandMessage message) {

    // Send a message to the 'HelloWorldClient' on the client that sent us the

    // the message.

    MessageBuilder.createConversation(message)

      .toSubject("HelloWorldClient")

      .signalling()

      .with("text", "Hi There! We're having a reply!")

      .noErrorHandling().reply();

    });

  }

}

errai.bus.enable_web_socket_server=true

<subsystem xmlns="urn:jboss:domain:web:1.1" default-virtual-server="default-host" native="false">

<subsystem xmlns="urn:jboss:domain:web:1.1" default-virtual-server="default-host" native="true">

<context-param>

  <param-name>websockets-enabled</param-name>

  <param-value>true</param-value>

</context-param>



<context-param>

  <param-name>websocket-path-element</param-name>

  <param-value>in.erraiBusWS</param-value>

</context-param>

<servlet>

  <servlet-name>ErraiWSServlet</servlet-name>

  <servlet-class>org.jboss.errai.bus.server.servlet.JBossAS7WebSocketServlet</servlet-class>

  <load-on-startup>1</load-on-startup>

</servlet>



<servlet-mapping>

  <servlet-name>ErraiWSServlet</servlet-name>

  <url-pattern>*.erraiBusWS</url-pattern>

</servlet-mapping>

    <dependency>

        <groupId>org.jboss.errai</groupId>

        <artifactId>errai-bus-jboss7-websocket</artifactId>

        <version>${errai.version}</version>

    </dependency>

<!-- For JSR-356 without depending on Weld -->

<dependency>

    <groupId>org.jboss.errai</groupId>

    <artifactId>errai-bus-jsr356-websocket</artifactId>

    <version>${errai.version}</version>

</dependency>



<!-- For JEE environment with Weld-->

<dependency>

    <groupId>org.jboss.errai</groupId>

    <artifactId>errai-bus-jsr356-websocket-weld</artifactId>

    <version>${errai.version}</version>

</dependency>

<context-param>

    <param-name>websockets-enabled</param-name>

    <param-value>true</param-value>

</context-param>

<context-param>

    <param-name>errai-jsr-356-websocket-filter</param-name>

    <param-value>foo.bar.FooFilter,foo.bar.BarFilter</param-value>

</context-param>

<dependency>

    <groupId>org.jboss.spec.javax.websocket</groupId>

    <artifactId>jboss-websocket-api_1.0_spec</artifactId>

    <scope>provided</scope>

    <version>1.0.0.Final</version>

</dependency>

<context-param>

  <param-name>force-secure-websockets</param-name>

  <param-value>true</param-value>

</context-param>

class BusStatusLogger implements BusLifecycleListener {


  @Override

  public void busAssociating(BusLifecycleEvent e) {

    GWT.log("Errai Bus trying to connect...");

  }


  @Override

  public void busOnline(BusLifecycleEvent e) {

    GWT.log("Errai Bus connected!");

  }


  @Override

  public void busOffline(BusLifecycleEvent e) {

    GWT.log("Errai Bus trying to connect...");

  }


  @Override

  public void busDisassociating(BusLifecycleEvent e) {

    GWT.log("Errai Bus going into local-only mode.");

  }

}

ClientMessageBus bus = (ClientMessageBus) ErraiBus.get();

bus.addLifecycleListener(new BusStatusLogger());

@ShadowService

public class SignupShadowService implements MessageCallback {

   @Override

   public void callback(Message message) {

   }

}

@ShadowService

public class SignupServiceShadow implements SignupService {

   @Override

   public User register(User newUserObject, String password) throws RegistrationException {

   }

}

2.17. Debugging Messaging Problems

Errai includes a bus monitoring application, which allows you to monitor all of the message exchange activity on the bus in order to help track down any potential problems It allows you to inspect individual messages to examine their state and structure.

To utilize the bus monitor, you’ll need to include the _errai-tools _ package as part of your application’s dependencies. When you run your application in development mode, you will simply need to add the following JVM options to your run configuration in order to launch the monitor: -Derrai.tools.bus_monitor_attach=true

Figure 2.2. ErraiBus Monitor

The monitor provides you a real-time perspective on what’s going on inside the bus. The left side of the main screen lists the services that are currently available, and the right side is the service-explorer, which will show details about the service.

To see what’s going on with a specific service, simply double-click on the service or highlight the service, then click "Monitor Service…​". This will bring up the service activity monitor.

Figure 2.3. ErraiBus Monitor details

The service activity monitor will display a list of all the messages that were transmitted on the bus since the monitor became active. You do not need to actually have each specific monitor window open in order to actively monitor the bus activity. All activity on the bus is recorded.

The monitor allows you select individual messages, an view their individual parts. Clicking on a message part will bring up the object inspector, which will allow you to explore the state of any objects contained within the message, not unlike the object inspectors provided by debuggers in your favorite IDE. This can be a powerful tool for looking under the covers of your application.

The core Errai IOC module implements the JSR-330 Dependency Injection specification for in-client component wiring.

Dependency injection (DI) allows for cleaner and more modular code, by permitting the implementation of decoupled and type-safe components. By using DI, components do not need to be aware of the implementation of provided services. Instead, they merely declare a contract with the container, which in turn provides instances of the services that component depends on.

A simple example:

public class MyLittleClass {

  private final TimeService timeService;


  @Inject

  public MyLittleClass(TimeService timeService) {

    this.timeService = timeService;

  }


  public void printTime() {

    System.out.println(this.timeService.getTime());

  }

}

In this example, we create a simple class which declares a dependency using @Inject for the interface TimeService. In this particular case, we use constructor injection to establish the contract between the container and the component. We can similarly use field injection to the same effect:

public class MyLittleClass {

  @Inject

  private TimeService timeService;


  public void printTime() {

    System.out.println(this.timeService.getTime());

  }

}

Below is an example of an @ApplicationScoped TimeService, meaning a single instance of TimeService would be provided by the container for all injection sites.

@ApplicationScoped

public class TimeService {

}

We could also annotate the type @Dependent so that every injection site has its own unique instance.

@Dependent

public class TimeService {

}

public interface TimeService {

  public String getTime();

}

@IOCProvider

@Singleton

public class TimeServiceProvider implements Provider<TimeService> {

  @Override

  public TimeService get() {

    return new TimeService() {

      public String getTime() {

        return "It's midnight somewhere!";

      }

    };

  }

}

Guice.createInjector(new AbstractModule() {

  public void configure() {

    bind(TimeService.class).toProvider(TimeServiceProvider.class);

  }

 }).getInstance(MyApp.class);

public void MyDependentScopedBean {

  private final Date createdDate;


  public MyDependentScopedBean {

    createdDate = new Date();

  }

}

@ApplicationScoped

public void MyClientBean {

  @Inject MyDependentScopedBean bean;


  // ... //

}

@Service

public class MyService implements MessageCallback {

  public void callback(Message message) {

    // ... //

  }

}

@Service @Local

public class MyLocalService implements MessageCallback {

  public void callback(Message message) {

    // ... //

  }

}

@Inject MessageBus bus;

@Inject RequestDispatcher dispatcher;

public void MyClientBean {

  @Inject

  private Caller<MyRpcInterface> rpcCaller;


  // ... ///


  @EventHandler("button")

  public void onButtonClick(ClickHandler handler) {

    rpcCaller.call(new RemoteCallback<Void>() {

      public void callback(Void void) {

        // put code here that should execute after RPC response arrives

      }

    ).callSomeMethod();

  }

}

  @Inject

  @ToSubject("ListCapitializationService")

  Sender<List<String>> listSender;


  // ... ///


  @EventHandler("button")

  public void onButtonClick(ClickHandler handler) {

    List<String> myListOfStrings = getSelectedCitiesFromForm();

    listSender.send(myListOfStrings, new MessageCallback() {

      public void callback(Message reply) {

        // do stuff with reply

      }

    );

  }

  @Inject

  @ToSubject("ListCapitializationService")

  @ReplyTo("ClientListService")

  Sender<List<String>> listSender;


  // ... ///


  @EventHandler("button")

  public void onButtonClick(ClickHandler handler) {

    List<String> myListOfStrings = getSelectedCitiesFromForm();

    listSender.send(myListOfStrings);

  }


  @Singleton

  @Service

  public static class ClientListService implements MessageCallback {

    @Override

    public void callback(Message message) {

      // do stuff with message

    }

  }

@ApplicationScoped

public class SingletonHandler {

  @UncaughtExceptionHandler

  private void handle(Throwable t) {

    // do something

  }

}

@Singleton

public class MyClientBean {

  @Inject InitBallot<MyClientBean> ballot;


  @PostConstruct

  public void doStuff() {

    // ... do some work ...


    ballot.voteForInit();

  }

}

@Singleton

public class MyClientBean {

  @AfterInitialization

  public void doStuffAfterInit() {

    // ... do some work ...

  }

}

@Timed(type = TimerType.REPEATING, interval = 1, timeUnit = TimeUnit.SECONDS)

private void updateTime() {

  timeWidget.setTime(System.currentTimeMillis);

}

public MyManagedBean {

  @Inject SyncBeanManager manager;


  // class body

}

public MyManagedBean {

  @Inject SyncBeanManager manager;


  public void lookupBean() {

    IOCBeanDef<SimpleBean> bean = manager.lookupBean(SimpleBean.class);


    if (bean != null) {

      // get the instance of the bean

      SimpleBean inst = bean.getInstance();

    }

  }

}

MyQualifier qual = new MyQualifier() {

  public annotationType() {

    return MyQualifier.class;

  }

}


MyOtherQualifier qual2 = new MyOtherQualifier() {

  public annotationType() {

    return MyOtherQualifier.class;

  }

}


// pass qualifiers to ClientBeanManager.lookupBeans

IOCBeanDef<SimpleBean> bean = beanManager.lookupBean(SimpleBean.class, qual, qual2);

@Singleton @Alternative

public class MobileView implements View {

  // ... //

}

@Singleton @Alternative

public class DesktopView implements View {

  // ... //

@EntryPoint

public class MyApp {

  @Inject

  View view;


  // ... //

}

errai.ioc.enabled.alternatives=org.foo.MobileView

errai.ioc.enabled.alternatives=org.foo.MobileView \
                               org.foo.HTML5Orientation \
                               org.foo.MobileStorage

public MyManagedBean {

  @Inject SyncBeanManager manager;


  public void createABeanThenDestroyIt() {

    // get a new bean.

    SimpleBean bean = manager.lookupBean(SimpleBean.class).getInstance();


    bean.sendMessage("Sorry, I need to dispose of you now");


    // destroy the bean!

    manager.destroyBean(bean);

  }

}

@Dependent

public class SimpleBean {

   @Inject @New AnotherBean anotherBean;


   public AnotherBean getAnotherBean() {

     return anotherBean;

   }


   @PreDestroy

   private void cleanUp() {

     // do some cleanup tasks

   }

}

public MyManagedBean {

  @Inject SyncBeanManager manager;


  public void createABeanThenDestroyIt() {

    // get a new bean.

    SimpleBean bean = manager.lookupBean(SimpleBean.class).getInstance();


    // destroy the AnotherBean reference from inside the bean

    manager.destroyBean(bean.getAnotherBean());

  }

}

public MyManagedBean {

  @Inject @New SimpleBean myNewSimpleBean;

  @Inject Disposer<SimpleBean> simpleBeanDisposer;


  public void destroyMyBean() {

    simpleBeanDisposer.dispose(myNewSimpleBean);

  }

}

CDI (Contexts and Dependency Injection) is the Java EE standard (JSR-299) for handling dependency injection. In addition to dependency injection, the standard encompasses component lifecycle, application configuration, call-interception and a decoupled, type-safe eventing specification.

The Errai CDI extension implements a subset of the specification for use inside of client-side applications within Errai, as well as additional capabilities such as distributed eventing.

Errai CDI does not currently implement all life cycles specified in JSR-299 or interceptors. These deficiencies may be addressed in future versions.

public class FraudClient extends LayoutPanel {


  @Inject

  private Event<AccountActivity> event; (1)


  private HTML responsePanel;


  public FraudClient() {

    super(new BoxLayout(BoxLayout.Orientation.VERTICAL));

  }


  @PostConstruct

  public void buildUI() {

    Button button = new Button("Create activity", new ClickHandler() {

      public void onClick(ClickEvent clickEvent) {

        event.fire(new AccountActivity());

      }

    });

    responsePanel = new HTML();

    add(button);

    add(responsePanel);

  }


  public void processFraud(@Observes @Detected Fraud fraudEvent) { (2)

    responsePanel.setText("Fraud detected: " + fraudEvent.getTimestamp());

  }

}