Micronaut's @Cacheable annotation TTL and Retention-Policy

I am using Kotlin-Micronaut's cacheable annotation for a method that calls an API as below:

@Retryable(attempts = "5", delay = "20ms", multiplier = "2.0")
@Cacheable(value = ["my-cache"], parameters = ["id"])
@Get("/fetch/mydata")
fun fetchData() {
   ....required confs for calling the api
}

I need help understanding:

1. What is the default TTL (I have gone through docs but not able to find one)
2. What is meant as the retention-policy at docs having following enums: SOURCE, CLASS, RUNTIME
3. Where are the cached-items stored?

Any help appreciated, thanks in advance!

As mentioned in the comments above, you need to choose a caching library such as Caffeine, Eh-Cache, Hazelcast, … (see available caches in Micronaut Cache documentation)

If you simply have micronaut-cache-core in your classpath, your application is not gonna have an caching functionality, since these are provided e.g. by micronaut-cache-caffeine.

> What is the default TTL (I have gone through docs but not able to find one)

This depends on what cache you are going to use. Micronauts Cache configuration provides the following two durations expireAfterWrite and expireAfterAccess (see GitHub). As fair as I know Caffeine, the default behaviour is that nothing is going to expire unless you configure it. Means your cache items live for ever.

> Where are the cached-items stored?

For Caffeine it is strictly in memory. Meaning if you choose Caffeine as your cache you lose the cache items when you restart your Micronaut application.

> What is meant as the retention-policy at docs having following enums: SOURCE, CLASS, RUNTIME

That question is a bit off topic, since it has nothing to do with caching. But I assume you're asking about Java's enum java.lang.annotation.RetentionPolicy. The Java enum is very well documented. Please take a look at the documentation.

package java.lang.annotation;

/**
 * Annotation retention policy.  The constants of this enumerated class
 * describe the various policies for retaining annotations.  They are used
 * in conjunction with the {@link Retention} meta-annotation interface to
 * specify how long annotations are to be retained.
 *
 * @author  Joshua Bloch
 * @since 1.5
 */
public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}