All Superinterfaces:

java.io.Serializable

All Known Implementing Classes:

CompoundKey, SimpleKey
```
public interface Key
extends java.io.Serializable
```
The Key of a Message.
Message keys are used for different purposes:
- As identifiers for entities stored in a StateRepository, database or other kind of repository.
- For filtering messages, for example, using MessageConsumer.keyPattern(), EventSourceConsumer.keyPattern() or MessageQueueConsumer.keyPattern().
- To select the partition (aka shard) used to send the message: All messages with the same partitionKey() will be sent over the same partiion, so the ordering of theses messages can be guaranteed.
- To specify a key used for compaction purposes: Message compaction will reduce all messages with the same compactionKey() to the last message. The compacted sequence of messages is stored in a MessageStore and used by EventSource to reduce startup times of services.
Example:

A channel with product-update events is partitioned into two shards A and B. Product update events are separated into ProductUpdated, PriceUpdated or AvailabilityUpdated. We need to keep the ordering of all messages per product. Given some variable productId, we could sent messages using the following keys:
- ProductUpdated: Key.of(productId, "ProductUpdated#" + productId)
- PriceUpdated: Key.of(productId, "PriceUpdated#" + productId)
- AvailabilityUpdated: Key.of(productId, "AvailabilityUpdated#" + productId)
Using the productid (or entity id) as a partition key will guarantee that all events of the same product will arrive at the same partition or shard, in the same order as they were sent.

The event-type in combination with the entity-id as a compaction key will guarantee, that after a compaction, the latest events for product-, price- and availability-updates are available in the compacted snapshot.

Field Summary

Fields
Modifier and Type Field Description

static Key NO_KEY
Key used for messages that do not have a distinguished key.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`java.lang.String`	`compactionKey()`	Returns the part of the key that is used for message compaction, where a snapshot of a message log is taken by only keeping the latest message for every compaction-key.
`boolean`	`isCompoundKey()`
`static Key`	`of()`	Key used for messages that do not have a distinguished key.
`static Key`	`of(java.lang.String key)`	Creates a simple `Key` where the same string is used for partitioning and compaction purposes.
`static Key`	`of(java.lang.String partitionKey, java.lang.String compactionKey)`	Creates a compound `Key`, consisting of separate partion- and compaction-keys.
`java.lang.String`	`partitionKey()`	Returns the part of the key that is used to select one of possibly several shards or partitions of a message channel.

- Field Detail
  - NO_KEY
```
static final Key NO_KEY
```
    Key used for messages that do not have a distinguished key.
    Note, that all messages w/o key might be sent over the same partition/shard.
- Method Detail
  - of
```
static Key of()
```
    Key used for messages that do not have a distinguished key.
    Note, that all messages w/o key might be sent over the same partition/shard.
    
    Returns:
    
    NO_KEY
  - of
```
static Key of(@Nonnull
              java.lang.String key)
```
    Creates a simple Key where the same string is used for partitioning and compaction purposes.
    Simple keys are applicable if only a single kind of messages is sent over the channel. In this case, the id of the logical entity (like, for example, the product-id) is a good candidate for building keys.
    
    If the channel is sharded and different kind of messages like price-updates and availability-updates will be sent over the same channel, and if the channel is compacted, of(String, String) must be used, otherwise data-loss after compaction, or out-of-order arrival of messages will most likely be the result.
    
    Parameters:
    
    key - the message key
    
    Returns:
    
    SimpleKey
  - of
```
static Key of(@Nonnull
              java.lang.String partitionKey,
              @Nonnull
              java.lang.String compactionKey)
```
    Creates a compound Key, consisting of separate partion- and compaction-keys.
    Compound keys must be used instead of simple keys if different event-types will be sent of a partitioned channel.
    
    Parameters:
    
    partitionKey - the part of the key that is used to select the partition of a channel when sending messages. In most cases, an entity-id like, for example, a product-id is appropriate.
    
    compactionKey - the part of the key that is used for compaction purposes. A combination of event-type and entity-id will do the job.
    
    Returns:
    
    CompoundKey
  - partitionKey
```
@Nonnull
java.lang.String partitionKey()
```
    Returns the part of the key that is used to select one of possibly several shards or partitions of a message channel.
    All messages with the same partitionKey are guaranteed to keep their ordering.
    
    Returns:
    
    partition key
  - compactionKey
```
@Nonnull
java.lang.String compactionKey()
```
    Returns the part of the key that is used for message compaction, where a snapshot of a message log is taken by only keeping the latest message for every compaction-key.
    
    Returns:
    
    compaction key
  - isCompoundKey
```
boolean isCompoundKey()
```

Interface Key

Field Summary

Method Summary

Field Detail

NO_KEY

Method Detail

of

of

of

partitionKey

compactionKey

isCompoundKey