To inject an instance of a NamedMap into the CDI bean, you should define an injection point for it:

import javax.inject.Inject;

@Inject
private NamedMap<Long, Person> people;

In the example above, it is assumed that the map name you want to inject is the same as the name of the field you are injecting into - people. If that is not the case, you can use the @Name qualifier to specify the name of the map you want to obtain explicitly:

import com.oracle.coherence.cdi.Name;
import javax.inject.Inject;

@Inject
@Name("people")
private NamedMap<Long, Person> m_people;

This is also what you have to do if you are using constructor injection or setter injection:

import com.oracle.coherence.cdi.Name;
import javax.inject.Inject;

@Inject
public MyClass(@Name("people") NamedMap<Long, Person> people) {
    ...
}

@Inject
public void setPeople(@Name("people") NamedMap<Long, Person> people) {
    ...
}

All the examples above assume that you want to use the default scope, which is often, but not always the case. For example, you may have an Extend client that connects to multiple Coherence clusters, in which case you would have multiple scopes.

In this case, you would use the @SessionName qualifier to specify the name of the configured Session, that will be used to supply the cache or map:

import com.oracle.coherence.cdi.SessionName;
import javax.inject.Inject;

@Inject
@SessionName("Products")
private NamedCache<Long, Product> products;

@Inject
@SessionName("Customers")
private NamedCache<Long, Customer> customers;

You can replace NamedMap or NamedCache in any of the examples above with AsyncNamedMap and AsyncNamedCache, respectively, to inject asynchronous variant of those APIs:

import com.oracle.coherence.cdi.SessionName;
import javax.inject.Inject;

@Inject
private AsyncNamedMap<Long, Person> people;

@Inject
@SessionName("Products")
private AsyncNamedCache<Long, Person> Product;

This section includes the following topic:

• Injecting NamedMap or NamedCache Views
  

To inject an instance of a NamedTopic into the CDI bean, you should define an injection point for it:

import com.tangosol.net.NamedTopic;
import javax.inject.Inject;

@Inject
private NamedTopic<Order> orders;

In the example above, it is assumed that the topic name you want to inject is the same as the name of the field you are injecting into, in this case orders. If that is not the case, you can use the @Name qualifier to specify the name of the topic you want to obtain explicitly:

import com.oracle.coherence.cdi.Name;
import com.tangosol.net.NamedTopic;
import javax.inject.Inject;

@Inject
@Name("orders")
private NamedTopic<Order> topic;

You have to do the following if you are using 'constructor' or 'setter injection' instead:

import com.oracle.coherence.cdi.Name;
import com.tangosol.net.NamedTopic;
import javax.inject.Inject;

@Inject
public MyClass(@Name("orders") NamedTopic<Order> orders) {
    ...
}

@Inject
public void setOrdersTopic(@Name("orders") NamedTopic<Order> orders) {
    ...
}

All the examples above assume that you want to use the default scope, which is often, but not always the case. For example, you may have an Extend client that connects to multiple Coherence clusters, in which case you would have multiple scopes.

In this case, you would use the @SessionName qualifier to specify the name of the configured Session, that will be used to supply the topic:

import com.oracle.coherence.cdi.SessionName;
import com.tangosol.net.NamedTopic;
import javax.inject.Inject;

@Inject
@SessionName("Finance")
private NamedTopic<PaymentRequest> payments;

@Inject
@SessionName("Shipping")
private NamedTopic<ShippingRequest> shipments;

The examples above allow you to inject a NamedTopic instance into the CDI bean, but it is often simpler and more convenient to inject Publisher or Subscriber for a given topic instead.

This can be easily accomplished by replacing NamedTopic<T> in any of the examples above with one of the following:

Publisher<T>:

import com.oracle.coherence.cdi.Name;
import com.oracle.coherence.cdi.SessionName;
import javax.inject.Inject;

@Inject
private Publisher<Order> orders;

@Inject
@Name("orders")
private Publisher<Order> m_orders;

@Inject
@SessionName("Finance")
private Publisher<PaymentRequest> payments;

OR

import com.oracle.coherence.cdi.Name;
import com.oracle.coherence.cdi.SessionName;
import javax.inject.Inject;

@Inject
private Subscriber<Order> orders;

@Inject
@Name("orders")
private Subscriber<Order> m_orders;

@Inject
@SessionName("Finance")
private Subscriber<PaymentRequest> payments;

Topic metadata, such as topic name (based on either injection point name or the explicit name from @Name annotation), scope, and message type, will be used under the hood to retrieve the NamedTopic, and to obtain Publisher or Subscriber from it.

Additionally, if you want to place your Subscribers into a subscriber group (effectively turning a topic into a queue), you can easily accomplish that by adding the @SubscriberGroup qualifier to the injection point:

import com.oracle.coherence.cdi.SubscriberGroup;
import javax.inject.Inject;

@Inject
@SubscriberGroup("orders-queue")
private Subscriber<Order> orders;

While the injection of a NamedMap, NamedCache, NamedTopic, and related instances is probably the single most used feature of Coherence CDI, it is certainly not the only one.

The following sections describe the other Coherence artifacts that can be injected using Coherence CDI:

• Cluster and OperationalContext Injection
  
• Named Session Injection
  
• Serializer Injection
  
• POF Serializer with a Specific POF Configuration
  

While the above examples show that you can implement any Coherence EventInterceptor as a CDI bean and register it using the <cdi:bean> element within the cache configuration file, Coherence CDI also provides a much simpler way to accomplish the same goal using the standard CDI Events and Observers.

For example, to observe events raised by a NamedMap with the name people, with keys of type Long, and values of type Person, you would define a CDI observer such as the following:

private void onMapChange(@Observes @MapName("people") EntryEvent<Long, Person> event) {
    // handle all events raised by the 'people' map/cache
}

This section includes the following topics:

• Observing Specific Event Types
  
• Filtering the Observed Events
  
• Transforming the Observed Events
  
• Observing Events for Maps and Caches in Specific Services and Scopes
  
• Using Asynchronous Observers
  

While not technically a true marker interface, Injectable can be treated as such for all intents and purposes. All you need to do is add it to the implements clause of your class to initiate injection on deserialization:

public class InjectableBean
        implements Injectable, Serializable {

    @Inject
    private Converter<String, String> converter;

    private String text;

    InjectableBean() {
    }

    InjectableBean(String text) {
        this.text = text;
    }

    String getConvertedText() {
        return converter.convert(text);
    }
}

Assuming that you have the following Converter service implementation in your application, it will be injected into InjectableBean during deserialization, and the getConvertedText method will return the value of the text field converted to upper case:

@ApplicationScoped
public class ToUpperConverter
        implements Converter<String, String> {
    @Override
    public String convert(String s) {
        return s.toUpperCase();
    }
}

This functionality is not dependent on the serialization format and will work with both Java and POF serialization (or any other custom serializer), and for any object that is deserialized on any Coherence member (or even on a remote client).

While the deserialized transient objects are not true CDI managed beans, being able to inject CDI managed dependencies into them upon deserialization will likely satisfy most dependency injection requirements you will ever have in those application components.

Creating the filter annotation is same as creating a normal Java annotation class that is annotated with the @com.oracle.coherence.cdi.FilterBinding annotation.

In the following example, the most important part is that this new annotation is annotated with FilterBinding so that the Coherence CDI extensions can recognize that it represents a Filter.

@Inherited
@FilterBinding  
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomFilter {
}

After you create the custom annotation, you can create a FilterFactories implementation that is responsible for producing instances of the required Filter.

@ApplicationScoped    
@CustomFilter         
static class CustomFilterSupplier
        implements FilterFactory<CustomFilter, Object>
    {
    @Override
    public Filter<Object> create(CustomFilter annotation)
        {
        return new CustomComplexFilter(); 
        }
    }

Because there is both a custom annotation and an annotated FilterFactories, you can annotate the injection point requiring the Filter with the new annotation.

@Inject
@View
@CustomFilter
private NamedMap<Long, Person> people;

Just like views, you can use custom filter binding annotations for event observers. For example, if there is an event observer method that should only receive events matching the same custom Filter, then you can annotate the method with the same custom filter annotation.

@CustomFilter
private void onPerson(@Observes @MapName("people") EntryEvent<Long, Person> event) {

The following types of built-in ExtractorBinding annotations are available for use:

@PropertyExtractor("lastName")

new UniversalExtractor("lastName");

@PropertyExtractor("firstName")
@PropertyExtractor("lastName")
private void onPerson(@Observes @MapName("people") EntryEvent<Long, List<String>> event) {

@ChainedExtractor("address", "city")

UniversalExtractor[] chain = new UniversalExtractor[] {
        new UniversalExtractor("address"),
        new UniversalExtractor("city")
};
ChainedExtractor extractor = new ChainedExtractor(chain);

@PofExtractor(index = 4)

com.tangosol.util.extractor.PofExtractor(null, 4);

@PofExtractor(index = {2}, type = Long.class)

com.tangosol.util.extractor.PofExtractor(Long.class, 2);

@PofExtractor(index = {5, 3})

@PofExtractor(path = "lastName")

@PofExtractor(path = {"address", "city"})

@PofExtractor(path = "sales", type Long.class)

When the built-in extractor bindings are not suitable, or when a custom ValueExtractor implementation is required, then you can create a custom extractor binding annotation with a corresponding com.oracle.coherence.cdi.ExtractorFactory implementation.

You should perform the following steps to create a custom extractor:

• Create a custom annotation class to represent the required ValueExtractor.
• Create a bean class implementing com.oracle.coherence.cdi.ExtractorFactory annotated with the custom annotation that will be the factory for producing instances of the custom ValueExtractor.
• Annotate the view injection point with the custom annotation.

Creating the extractor annotation is same as creating a normal Java annotation class which is annotated with the @com.oracle.coherence.cdi.ExtractorBinding annotation.

The most important part is that the following new annotation is annotated with ExtractorBinding so that the Coherence CDI extensions can recognize that it represents a ValueExtractor.

@Inherited
@ExtractorBinding  
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomExtractor {
}

After you create the custom annotation, you can create an ExtractorFactory implementation that will be responsible for producing instances of the required ValueExtractor.

@ApplicationScoped
@CustomExtractor      
static class CustomExtractorSupplier
        implements ExtractorFactory<CustomExtractor, Object, Object>
    {
    @Override
    public ValueExtractor<Object, Object> create(CustomExtractor annotation)
        {
        return new CustomComplexExtractor(); 
        }
    }

Because there is both a custom annotation and an annotated ExtractorFactory, you can annotate the injection point requiring the ValueExtractor with the new annotation.

@Inject
@View
@CustomExtractor
private NamedMap<Long, String> people;

Like views, you can use custom filter binding annotations for event observers. For example, if there is an event observer method that should only receive transformed events using the custom extractor to transform the event, then you can use custom filter binding annotations as given below:

@CustomExtractor
private void onPerson(@Observes @MapName("people") EntryEvent<Long, String> event) {

Creating the extractor annotation is same as creating a normal Java annotation class which is annotated with the @com.oracle.coherence.cdi.MapEventTransformerBinding annotation.

The most important part is that the following new annotation is annotated with MapEventTransformerBinding so that the Coherence CDI extensions can recognize that it represents a MapEventTransformer.

@Inherited
@MapEventTransformerBinding  
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomTransformer {
}

After you create the custom annotation, you can create a MapEventTransformerFactory implementation that will be responsible for producing instances of the required MapEventTransformer.

@ApplicationScoped
@CustomTransformer      
static class CustomExtractorSupplier
        implements ExtractorFactory<CustomExtractor, Object, Object>
    {
    @Override
    public ValueExtractor<Object, Object> create(CustomExtractor annotation)
        {
        return new CustomComplexExtractor(); 
        }
    }

Because there is both a custom annotation and an annotated MapEventTransformerFactory, you can annotate the observer method requiring the MapEventTransformer with the new annotation.

@CustomTransformer
private void onPerson(@Observes @MapName("people") EntryEvent<Long, String> event) {

The specific cache to be used for response caching can be declared by the @CacheName and @SessionName annotations on a class or a method.

The following response caching annotations are supported:

• @CacheAdd
  
• @CacheGet
  
• @CachePut
  
• @CacheRemove
  
• @CacheKey