Coherence Spring

https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle/
Admin
Coherence Spring is a collection of libraries that integrates Oracle Coherence with the Spring...
Tokens:49,776
Snippets:474
Trust Score:8
Update:1 week ago
Show doc for...
Tokens:
Raw
### Run the Coherence server with Maven

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Starts the stand-alone Coherence instance (circuit-breaker-cache-demo-server) using Spring Boot's Maven plugin. Run this before starting the client application.

```bash
cd samples/circuit-breaker-cache-demo/circuit-breaker-cache-demo-server
mvn spring-boot:run
```

--------------------------------

### Plant JSON response example

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Example JSON response for a Plant object with taxonomic properties.

```json
{"id": 1, "genus": "Sabal", "species": "minor", "commonName": "Dwarf palmetto"}
```

--------------------------------

### Run the Spring Boot demo application

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Starts the packaged Spring Boot demo JAR. The application runs an embedded HSQL database and exposes a REST API for managing events and people.

```bash
 $ java -jar samples/coherence-spring-demo/coherence-spring-demo-boot/target/coherence-spring-demo-boot-3.2.0.jar
```

--------------------------------

### List all plants with cache hint

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Curl command to GET all plants with the use-cache parameter to demonstrate query caching.

```bash
curl -i \
  -H "Accept: application/json" \
  -H "Content-Type:application/json" \
  -X GET "http://localhost:9090/plants?use-cache=true"
```

--------------------------------

### Run the client application with Maven

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Starts the client application (circuit-breaker-cache-demo-app) that connects to the Coherence server via Coherence*Extend. Run after the server is running.

```bash
cd samples/circuit-breaker-cache-demo/circuit-breaker-cache-demo-app
mvn spring-boot:run
```

--------------------------------

### List people

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

GET request to list all people.

```bash
 curl --request GET 'http://localhost:8080/api/people'
```

--------------------------------

### List all plants via REST API

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Curl command to GET all plants from the application.

```bash
curl -i \
  -H "Accept: application/json" \
  -H "Content-Type:application/json" \
  -X GET "http://localhost:9090/plants"
```

--------------------------------

### Entity and Repository for Projections

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Example of an entity class Book and a repository interface using a projection BookProjection.

```java
@Entity
public class Book implements Cloneable, Serializable {
    @Id
    protected final UUID uuid;
    protected String title;
    protected Author author;
    protected int pages;
    protected Calendar published;
}

@CoherenceMap("book")
interface BookRepository extends CrudRepository<Book, UUID> {

    List<BookProjection> findByTitle(String title);

    // ...
}
```

--------------------------------

### Start Spring Cloud Config Server

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Commands to build and run the Spring Cloud Config Server demo application. The first command builds the server, the second changes to the target directory, and the third runs the server with a git URI for the configuration repository.

```bash
$ ./mvnw clean package -pl :coherence-spring-cloud-config-demo-server
$ cd coherence-spring-samples/coherence-spring-cloud-config-demo/coherence-spring-cloud-config-demo-server/target
$ java -jar coherence-spring-cloud-config-demo-server-3.2.0.jar \n
    --spring.cloud.config.server.git.uri=file:///path/to/git/repo
```

--------------------------------

### Start Coherence Spring Application

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Commands to build and run the Coherence Spring application demo. The first command builds the app, the second changes to the target directory, and the third runs the application.

```bash
$ ./mvnw clean package -pl :coherence-spring-cloud-config-demo-app
$ cd coherence-spring-samples/coherence-spring-cloud-config-demo/coherence-spring-cloud-config-demo-app/target
$ java -jar coherence-spring-cloud-config-demo-app-3.2.0.jar
```

--------------------------------

### Hibernate Cache Statistics output

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Example console output showing Hibernate second-level cache statistics when retrieving a single plant repeatedly.

```text
2021-06-28 16:12:42.545  INFO 29022 --- [nio-9090-exec-7] i.StatisticalLoggingSessionEventListener : Session Metrics {
27579 nanoseconds spent acquiring 1 JDBC connections;
0 nanoseconds spent releasing 0 JDBC connections;
0 nanoseconds spent preparing 0 JDBC statements;
0 nanoseconds spent executing 0 JDBC statements;
0 nanoseconds spent executing 0 JDBC batches;
0 nanoseconds spent performing 0 L2C puts;
1587296 nanoseconds spent performing 1 L2C hits;
0 nanoseconds spent performing 0 L2C misses;
0 nanoseconds spent executing 0 flushes (flushing a total of 0 entities and 0 collections);
0 nanoseconds spent executing 0 partial-flushes (flushing a total of 0 entities and 0 collections)
}
```

--------------------------------

### GET request to retrieve a person (404 expected)

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Sends a GET request to the /api/people/100 endpoint. Expect a 404 response because no person with id 100 exists yet.

```bash
curl -i -X GET http://localhost:8080/api/people/100
```

--------------------------------

### Get a single book via REST API

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Sends a GET request to retrieve a single book by ID. The book is retrieved from the Coherence cache immediately.

```bash
curl -i \
  -H "Accept: application/json" \
  -H "Content-Type:application/json" \
  -X GET "http://localhost:8090/api/books/1"
```

--------------------------------

### Open projection using method parameters with args array

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Shows how to use method parameters in a SpEL expression via the args array. The example uses args[0] to reference the first method parameter.

```java
interface NameOnly {

    @Value("args[0] + ' ' + #{target.author.firstName}")
    String getHonorificName(String honorific);
}
```

--------------------------------

### Using a repository with dynamic projections

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Shows how to invoke the dynamic projection repository method with different projection classes to get different result types.

```java
Collection<BookSummary> aggregates = books.findByTitle("Shadow", BookSummary.class);

Collection<BookTitleAndPages> aggregates = books.findByTitle("Remember", BookTitleAndPages.class);
```

--------------------------------

### List all books via REST API

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Sends a GET request to retrieve all books. On first call, the data is fetched from the database and added to the Coherence cache. Subsequent calls will hit the cache.

```bash
curl -i \
  -H "Accept: application/json" \
  -H "Content-Type:application/json" \
  -X GET "http://localhost:8090/api/books"
```

--------------------------------

### Get a single book that triggers a BusinessException

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Sends a GET request for book ID 42, which causes a BusinessException to be thrown. The response is an Internal Server Error (HTTP 500), and a Resilience4j fallback method handles the exception.

```bash
curl -i \
  -H "Accept: application/json" \
  -H "Content-Type:application/json" \
  -X GET "http://localhost:8090/api/books/42"
```

--------------------------------

### GET request after creation with response

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Re-runs the GET request to retrieve the person created earlier. Shows the HTTP 200 response with JSON body containing the person details.

```bash
curl -i -X GET http://localhost:8080/api/people/100
HTTP/1.1 200
Content-Type: application/json
Transfer-Encoding: chunked
Date: Thu, 19 Aug 2021 16:13:47 GMT

{"id":100,"age":21,"firstname":"Joe","lastname":"Smith"}%
```

--------------------------------

### Example Authentication Request JSON

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

JSON payload for authenticating with the sample application. The username is 'coherence' and the password is 'rocks'. A successful authentication returns a 2xx HTTP status with an empty body and a session cookie.

```json
{ "username": "coherence", "password": "rocks" }
```

--------------------------------

### Map locations cache to db-scheme with locationRepository bean

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Example mapping for a different cache store, using the default bean name 'locationRepository' for a LocationRepository class. Shows how to add another cache mapping with a different repository bean.

```xml
<cache-mapping>
    <cache-name>locations</cache-name>
    <scheme-name>db-scheme</scheme-name>
    <init-params>
        <init-param>
            <param-name>repository-bean</param-name>
            <param-value>locationRepository</param-value>
        </init-param>
    </init-params>
</cache-mapping>
```

--------------------------------

### @CoherenceTopicListener receive(Element<Product>)

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Example of an annotated subscriber method that receives an Element parameter, providing access to the message value and metadata.

```APIDOC
## [TOPIC] receive(Element<Product> product)

### Description
This method is invoked when a message is received from the topic. It receives an Element containing the message value and metadata.

### Method
TOPIC

### Endpoint
Not applicable (in-process method)

### Parameters
#### Method Parameters
- **product** (Element<Product>) - Required - The Element received from the topic, containing the message value and metadata.

### Request Example
```java
@CoherenceTopicListener
@Topic("my-products")
public void receive(Element<Product> product) {
    // ... process message ...
}
```

### Response
#### Success Response (200)
- No explicit return value (void)

#### Response Example
Not applicable
```

--------------------------------

### Build the cache store sample with Maven

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Builds the cache store demo module using the Maven wrapper. Run from the cache store sample root directory.

```bash
./mvnw clean package -pl samples/cachestore-demo
```

--------------------------------

### Receive specific SessionLifecycleEvent types with @Started and @Stopped

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Annotate the event parameter with @Started and @Stopped to receive only those event types. The method will not receive Starting or Stopping events.

```java
@CoherenceEventListener
public void onEvent(@Started @Stopped SessionLifecycleEvent event) {
    // TODO: process the event
}
```

--------------------------------

### Set up Config Data Git Repository

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Commands to create and initialize a Git repository for the configuration data.

```bash
 $ cd /path/to/git/repo
 $ mkdir coherence-spring-config-repository
 $ cd coherence-spring-config-repository
 $ git init
```

--------------------------------

### Get a single plant via REST API

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Curl command to GET a single plant by ID.

```bash
curl -i \
  -H "Accept: application/json" \
  -H "Content-Type:application/json" \
  -X GET "http://localhost:9090/plants/1"
```

--------------------------------

### Receive only Started and Stopped events

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Use @Started and @Stopped annotations on the method parameter to receive only the specified event types.

```java
@CoherenceEventListener
public void onEvent(@Started @Stopped CoherenceLifecycleEvent event) {
    // TODO: process the event
}
```

--------------------------------

### Build the Coherence Server instance with Maven

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Command to build the Hibernate cache demo application using Maven wrapper.

```bash
$ ./mvnw clean package -pl samples/hibernate-cache-demo
```

--------------------------------

### Build the Spring Boot demo with Maven

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Builds the coherence-spring-demo-boot module using the Maven wrapper. The -pl flag targets the specific module.

```bash
 $ ./mvnw clean package -pl samples/coherence-spring-demo/coherence-spring-demo-boot
```

--------------------------------

### config-client.properties

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Properties file for the demo client, setting Coherence logging severity and destination.

```properties
 coherence.logging.severity-level=6                                           __**(1)**
 coherence.logging.destination=slf4j                                          __**(2)**
```

--------------------------------

### Run the Spring Boot application

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Command to run the built Hibernate cache demo JAR file.

```bash
$ java -jar samples/hibernate-cache-demo/target/hibernate-cache-demo-3.2.0.jar
```

--------------------------------

### Demo Client Maven Dependencies

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Maven dependencies for the demo client, including coherence-spring-boot-starter, coherence, and spring-cloud-starter-config.

```xml
<dependency>
    <groupId>com.oracle.coherence.spring</groupId>
    <artifactId>coherence-spring-boot-starter</artifactId> __**(1)**
    <version>{coherence-spring.version}</version>
</dependency>
<dependency>
    <groupId>com.oracle.coherence.ce</groupId>
    <artifactId>coherence</artifactId>                     __**(2)**
    <version>{coherence.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>   __**(3)**
</dependency>
```

--------------------------------

### Retrieving Cache Statistics

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

GET request to retrieve cache statistics for the 'events' cache. The response should show TotalPuts of 1.

```bash
 $ curl --request GET 'http://localhost:8080/api/statistics/events'
```

--------------------------------

### Build Coherence Server Instance (Embedded)

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Maven command to build the Spring Session demo application for the embedded Coherence use case. Run from the repository root.

```bash
$ ./mvnw clean package -pl samples/spring-session-demo/spring-session-demo-app
```

--------------------------------

### Coherence Spring Boot YAML Configuration

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Example YAML configuration for Coherence with Spring Boot, including logging, sessions, and native properties.

```yaml
coherence:
  logging:
    destination: slf4j
    logger-name: MyCoherence
  sessions:
  - name: default
    config: "coherence-cache-config.xml"
    priority: 1
  - name: test
    config: "test-coherence-config.xml"
    priority: 2
  properties:
    coherence.log.limit: 400
    coherence.log.level: 1
```

--------------------------------

### Inject a View with a More Complex @WhereFilter

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

The @WhereFilter can include more complex CohQL expressions, such as combining conditions with 'and'. This example filters on both lastName and age.

```java
    @CoherenceMap("people")
    @View
    @WhereFilter("lastName = 'Simpson' and age > 10")        __**(1)**
    private NamedMap<String, Person> simpsons;
```

--------------------------------

### Retrieve Event

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

GET request to retrieve the event with id 1. The value is returned directly from the cache without executing SQL queries.

```bash
 curl --request GET 'http://localhost:8080/api/events/1'
```

--------------------------------

### Clone the Spring Cloud Config demo project

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Commands to clone the Coherence Spring repository and change into the coherence-spring directory to access the Spring Cloud Config demo.

```bash
 $ git clone https://github.com/coherence-community/coherence-spring.git
 $ cd coherence-spring

```

--------------------------------

### Receive specific EntryEvent types with @Inserted and @Removed

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Apply one or more event type annotations to the method parameter to restrict received events. This example receives only Inserted and Removed events.

```java
@CoherenceEventListener
public void onEvent(@Inserted @Removed EntryEvent event) {
    // TODO: process the event
}
```

--------------------------------

### Enable Coherence Repositories with @EnableCoherenceRepositories

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Configuration class that enables Coherence and Coherence repositories. Must be used to activate repository support.

```java
import com.oracle.coherence.spring.configuration.annotation.EnableCoherence;
import com.oracle.coherence.spring.configuration.data.config.EnableCoherenceRepositories;

// ...

@Configuration
@EnableCoherence
@EnableCoherenceRepositories
public static class Config {
}
```

--------------------------------

### Run the Spring Boot jar

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Runs the built Spring Boot jar using the standard java -jar command.

```bash
java -jar samples/cachestore-demo/target/coherence-spring-cachestore-demo-3.2.0.jar
```

--------------------------------

### Using @CoherenceMap with session parameter

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

A more concise way to specify both the cache name and session name using the session parameter of @CoherenceMap. This example injects a NamedMap from the 'products' cache in the 'Catalog' session.

```java
@CoherenceMap(name="products", session="Catalog")
private NamedMap<String, Product> map;
```

--------------------------------

### POM configuration: Add Coherence Spring Boot Starter and Coherence dependencies

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Add the coherence-spring-boot-starter dependency to activate AutoConfiguration, and the desired version of Coherence (CE or Commercial). The version shown is 3.2.0 for the starter and 21.12.4 for Coherence CE.

```xml
 <dependency>
     <groupId>com.oracle.coherence.spring</groupId>
     <artifactId>coherence-spring-boot-starter</artifactId> __**(1)**
     <version>3.2.0</version>
 </dependency>
 <dependency>
     <groupId>com.oracle.coherence.ce</groupId>
     <artifactId>coherence</artifactId>                     __**(2)**
     <version>21.12.4</version>
 </dependency>
```

--------------------------------

### Build Coherence Server Instance (Remote)

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Maven command to build the Coherence server instance for the remote Coherence use case.

```bash
$ ./mvnw clean package -pl samples/spring-session-demo/spring-session-demo-server
```

--------------------------------

### Receive TransferEvent from a specific cache service

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Apply the @ServiceName annotation to the method parameter to restrict events to those from a specific cache service. The example receives events only for caches owned by the service named 'StorageService'.

```java
@CoherenceEventListener
public void onEvent(@ServiceName("StorageService") TransferEvent event) {
    // TODO: process the event
}
```

--------------------------------

### Enable Async Support with @EnableAsync

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Configuration class that enables async support along with Coherence repositories. Required for @Async methods to work.

```java
import com.oracle.coherence.spring.configuration.annotation.EnableCoherence;
import com.oracle.coherence.spring.configuration.data.config.EnableCoherenceRepositories;
import org.springframework.scheduling.annotation.EnableAsync;

// ...

@Configuration
@EnableAsync
@EnableCoherence
@EnableCoherenceRepositories
public static class Config {
}
```

--------------------------------

### Using ProductClient bean

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Retrieve the ProductClient bean from the ApplicationContext and send a message.

```java
ProductClient client = applicationContext.getBean(ProductClient.class);
client.sendProduct("Blue Trainers");
```

--------------------------------

### POST request to create a person

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Creates a Person with id 100, firstName Joe, lastName Smith, and age 21. Expect a 200 response and the person is stored in the database.

```bash
curl -i -X POST http://localhost:8080/api/people \
    -d 'firstName=Joe' -d 'lastName=Smith' \
    -d 'age=21' -d 'id=100'
```

--------------------------------

### Define a custom filter binding annotation with @FilterBinding

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Create a custom annotation annotated with @FilterBinding, @Documented, and @Retention(RUNTIME). The annotation is used to specify a Coherence Filter at injection points. The example defines the LargePalmTrees annotation.

```java
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

import com.oracle.coherence.spring.annotation.FilterBinding;

@FilterBinding                                   __**(1)**
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface LargePalmTrees {               __**(2)**
}
```

--------------------------------

### Receive TransactionEvent from specific cache service with @ServiceName

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Restrict events received by a method to only those related to caches owned by a specific service by annotating the method parameter with @ServiceName. This example only receives events for the caches owned by the service named 'StorageService'.

```java
@CoherenceEventListener
public void onEvent(@ServiceName("StorageService") TransactionEvent event) {
    // TODO: process the event
}
```

--------------------------------

### Log into the application using CURL

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Curl command to authenticate to the application at localhost:8090/login. It sends a JSON POST request with the username and password, and saves the session cookie to cookie.txt.

```bash
$ curl -i -c cookie.txt \
 -H "Accept: application/json" \
 -H "Content-Type:application/json" \
 -X POST --data '{"username": "coherence", "password": "rocks"}' \
 "http://localhost:8090/login"
```

--------------------------------

### Using @CoherenceMap with session parameter in a constructor

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

The @CoherenceMap annotation with session parameter can also be used on method parameter injection points, such as constructor parameters. This example shows a controller constructor injecting a NamedMap from the 'products' cache in the 'Catalog' session.

```java
@Controller
public class CatalogController {

    public CatalogController(@CoherenceMap(name="products", session="Catalog")
                             NamedMap<String, Product> products) {
        // TODO: initialize the bean...
    }
}
```

--------------------------------

### POM configuration: Add Spring Cache Abstraction dependency

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Add the spring-boot-starter-cache dependency to use Spring's caching abstraction with Coherence.

```xml
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-cache</artifactId>
 </dependency>
```

--------------------------------

### Receive Committed TransactionEvent with @Committed annotation

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Restrict the TransactionEvent types received by a method by applying one or more annotations (e.g., @Committing, @Committed) to the method parameter. This example receives only Committed events, which are raised after mutations have been committed to the underlying backing maps.

```java
@CoherenceEventListener
public void onEvent(@Committed TransactionEvent event) {
    // TODO: process the event
}
```

--------------------------------

### Create the first event

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

POST request to create an event with title 'First Event' and date '2020-11-30'. The event is persisted and added to the 'events' cache via @CachePut.

```bash
 curl --request POST 'http://localhost:8080/api/events?title=First%20Event&date=2020-11-30'
```

--------------------------------

### Access the HelloController

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Curl command to access the /hello endpoint using the session cookie from cookie.txt. It returns the string 'Hello Coherence'.

```bash
$ curl -i -b cookie.txt \
 -H "Accept: application/json" \
 -H "Content-Type:application/json" \
 -X GET "http://localhost:8090/hello"
```

--------------------------------

### Inject a Publisher that publishes on the 'orders' topic (constructor parameter)

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Injects a Publisher<Order> into a constructor parameter, using @Name("orders") to specify the topic name.

```java
@Controller
public class OrderController {
    @Inject
    public OrderController(@Name("orders") Publisher<Order> topic) {
        // ToDo:
    }
}
```

--------------------------------

### Add a plant via REST API

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Curl command to POST a new plant to the application on port 9090.

```bash
curl -i \
  -H "Accept: application/json" \
  -H "Content-Type:application/json" \
  -X POST --data '{"genus": "Sabal", "species": "minor", "commonName": "Dwarf palmetto"}' \
  "http://localhost:9090/plants"
```

--------------------------------

### Log output showing cache hit for all books

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Expected log output when retrieving the list of books again after the first call, indicating the cache entry for key 'SimpleKey []' was found in cache 'allBooks'.

```log
Cache entry for key 'SimpleKey []' found in cache 'allBooks'
```

--------------------------------

### Clone the Coherence Spring repository

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Clones the coherence-spring repository from GitHub and changes into the project directory. Required before building the demo.

```bash
 $ git clone https://github.com/coherence-community/coherence-spring.git
 $ cd coherence-spring
```

--------------------------------

### Run Spring Boot Application (Embedded)

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Commands to launch two instances of the Spring Boot application for the embedded Coherence use case. The first instance uses the pre-configured port 8090, the second uses port 8091 via the --server.port argument.

```bash
$ java -jar samples/spring-session-demo/spring-session-demo-app/target/spring-session-demo-app-3.2.0.jar
$ java -jar samples/spring-session-demo/spring-session-demo-app/target/spring-session-demo-app-3.2.0.jar --server.port=8091
```

--------------------------------

### Projection interface using nullable wrappers

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Shows a projection interface using java.util.Optional as a nullable wrapper for null-safety. Supported wrappers include Optional, Guava Optional, scala.Option, and vavr Option.

```java
interface TitleOnly {

    Optional<String> getTitle();
}
```

--------------------------------

### Open projection using a default method

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Defines an open projection interface with a default method that implements custom logic using the projection's getter methods.

```java
interface BookTitleAndAuthor {

    default String getTitleAndAuthor() {
        return getAuthor().getFirstName().concat(' - ').concat(getTitle());
    }
}
```

--------------------------------

### Async Repository with @Async and CoherenceAsyncRepository

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Repository interface extending CoherenceAsyncRepository with an async finder method annotated with @Async. Requires @EnableAsync on configuration.

```java
import com.oracle.coherence.spring.data.config.CoherenceMap;
import com.oracle.coherence.spring.data.model.Author;
import com.oracle.coherence.spring.data.model.Book;
import com.oracle.coherence.spring.data.repository.CoherenceAsyncRepository;
import com.tangosol.util.UUID;

import org.springframework.scheduling.annotation.Async;

// ...

@CoherenceMap("book")
public interface CoherenceBookAsyncRepository extends CoherenceAsyncRepository<Book, UUID> {

    @Async
    CompletableFuture<List<Book>> findByAuthor(Author author);
}
```

--------------------------------

### Assign People to Events

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

POST requests to assign people with ids 2 and 3 to event with id 1.

```bash
 curl --request POST 'http://localhost:8080/api/people/2/add-to-event/1'
 curl --request POST 'http://localhost:8080/api/people/3/add-to-event/1'
```

--------------------------------

### Inject a Publisher while specifying the owning session

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Injects a Publisher<Order> from the 'Customers' session, with topic name 'orders' specified via @Name.

```java
@Inject
@Name("orders")
@SessionName("Customers")
private Publisher<Order> orders;
```

--------------------------------

### PersonController.java - REST controller for cache store sample

Source: https://spring.coherence.community/3.2.0/refdocs/reference/htmlsingle

Spring Boot controller with endpoints to create and retrieve Person entities. Uses @CoherenceMap to inject a NamedMap for the 'people' cache, which is configured to use a CacheStore. The createPerson method puts a Person into the cache, and the getPerson method retrieves it, throwing a 404 if not found.

```java
@RestController
@RequestMapping(path = "/api/people")
@Transactional()
public class PersonController {

    /**
     * The {@link NamedMap} to store {@link Person} entities.
     */
    @CoherenceMap
    private NamedMap<Long, Person> people;

    /**
     * Create a {@link Person} in the cache.
     * @param id         the unique identifier for the person
     * @param firstName  the person's first name
     * @param lastName   the person's last name
     * @param age        the person's age
     * @return the identifier used to create the person
     */
    @PostMapping
    public Long createPerson(@RequestParam("id") long id, @RequestParam("firstName") String firstName,
            @RequestParam("lastName") String lastName, @RequestParam("age") int age) {
        Person person = new Person();
        person.setFirstname(firstName);
        person.setLastname(lastName);
        person.setAge(age);
        person.setId(id);
        people.put(id, person);
        return id;
    }

    /**
     * Returns the {@link Person} with the specified identifier.
     *
     * @param personId  the unique identifier for the person
     * @return  the {@link Person} with the specified identifier
     */
    @GetMapping("/{personId}")
    public Person getPerson(@PathVariable("personId") Long personId) {
        Person person = people.get(personId);
        if (person == null) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Person " + personId + " does not exist");
        }
        return person;
    }

}
```
Tokens:
Raw