com.neeve.server.app.annotations

Annotation Type AppIntrospectionPoints

@Retention(value=RUNTIME)
@Target(value=METHOD)
public @interface AppIntrospectionPoints

Marks method as a provider of additional objects to be scanned for X annotations.

This annotation can be used on a single method of the application's main Talon entry point class in place of the following more narrowly scoped annotations:

• @AppConfiguredAccessor
• @AppCommandHandlerContainersAccessor
• @AppEventHandlerContainersAccessor
• @AppStatContainersAccessor

...effectively behaving as if the method were annotated with all of the above. In addition, each of the above objects the provided object for @AppInjectionPoints

The method annotated with @AppIntrospectionPoints will be called multiple times during the lifecycle of the application. The method is called at each of the points that the corresponding fine grained @*Accessor method is called. This allows the applications to construct and add objects to be introspected at appropriate points in the application's lifecycle. For example, the set of event handler objects supplied by the application may depend on the value of an @Configured annotation that is applied to an object supplied by the the @AppConfiguredAccessor. To facilitate this the method is called prior to each of the following operations:

1. Injection of the SrvAppLoader.
2. Injection of the AepEngineDescriptor.
3. Injection of @Configured values, after the @AppConfiguredAccessor is called.
4. Discovery of @Command annotated methods, after the @AppCommandHandlerContainersAccessor is called.
5. Discovery of @EventHandler annotated methods, after the @AppCommandHandlerContainersAccessor is called.
6. Discovery of @AppStat annotated methods and fields, after the @AppStatContainersAccessor is called.
7. Injection of the AepMessageSender.
8. Injection of the AepEngine.
9. Injection of Indexes.

Example: injecting handlers sprinkled through the application.

In the following example 2 classes are exposed to the Talon runtime which will introspect them to inject an AepMessageSender and discover their message handlers.

 @AppHAPolicy(HAPolicy.EventSourcing)
 public class OrderProcessingApp {
   private class NewOrderHandler{
     @AppInjectionPoint
     private volatile AepMessageSender sender
   
     @EventHandler
     public void onNewOrder(NewOrderMessage message) {
       NewOrderEventMessage event = NewOrderEventMessage.create();
       event.setOrderId(message.getOrderId();
       sender.sendMessage("order-events", event);
     }
   }
   
   private class OrderCancelHandler{
     @AppStat
     private final Counter canceledOrders = StatsFactory.createCounterStat("Orders Canceled");
   
     @AppInjectionPoint
     private volatile AepMessageSender sender;
   
     @EventHandler
     public void onNewOrder(CancelOrderMessage message) {
       OrderCanceledEventMessage event = OrderCanceledEventMessage.create();
       event.setOrderId(message.getOrderId();
       sender.sendMessage("order-cancels", event);
       canceledOrders.increment();
     }
   }
   
   private LinkedHashSet