improve: cache-aware secondary resource lookup for KubernetesDependentResource

Introduces a direct O(1) cache lookup path in KubernetesDependentResource
to retrieve the secondary resource from the InformerEventSource cache,
bypassing the costlier Context.getSecondaryResources() path.

## Problem

AbstractDependentResource.getSecondaryResource() calls
Context.getSecondaryResources(resourceType()), which iterates the
InformerEventSource index to build a Set<R> of all secondary resources
for the primary, then delegates to selectTargetSecondaryResource() to
filter down to the single expected resource. That implementation calls
getOrComputeDesired() to derive the target name/namespace, and then
streams and filters the full Set — even though InformerEventSource
already provides an O(1) cache.get(ResourceID) lookup.

## Solution

KubernetesDependentResource now overrides getSecondaryResource() to
call InformerEventSource.get(targetSecondaryResourceID) directly — a
single hash-map lookup — when the event source is present. Falls back
to the standard AbstractDependentResource path (via
selectTargetSecondaryResource) when the event source is not directly
available (e.g. shared event source scenario).

The existing targetSecondaryResourceID() method drives both the new
fast path and the existing selectTargetSecondaryResource() fallback.
Override it to return a cheap, statically-derivable ResourceID (e.g.
from the primary name/namespace) to avoid the getOrComputeDesired()
call during secondary resource lookup entirely.

The optimisation is intentionally scoped to KubernetesDependentResource
where R extends HasMetadata and ResourceID is a valid secondary resource
identifier. The base class AbstractEventSourceHolderDependentResource
is left unchanged because R is not bounded to HasMetadata there and
ResourceID is not a universally applicable secondary resource key.

## Backward compatibility

All changes are additive or override-with-fallback:
- getSecondaryResource() falls back to super when eventSource() is empty.
- selectTargetSecondaryResource() is retained as the fallback for the
  shared event source scenario.
- targetSecondaryResourceID() behaviour is unchanged.

Signed-off-by: Mohit Gupta <mohitg@zeta.tech>
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Signed-off-by: Mohit Gupta <mohitg@zeta.tech>

Author: Mohit Gupta

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/dependent/kubernetes/KubernetesDependentResource.java

@@ -247,6 +247,48 @@ protected void addSecondaryToPrimaryMapperAnnotations(
     annotations.put(typeKey, GroupVersionKind.gvkFor(primary.getClass()).toGVKString());
   }
 
+  /**
+   * Returns the secondary resource using a direct O(1) lookup against the {@link
+   * InformerEventSource} cache when possible, bypassing the costlier {@link
+   * io.javaoperatorsdk.operator.api.reconciler.Context#getSecondaryResources} path.
+   *
+   * <p>The fast path is taken when the event source is present and {@link
+   * #targetSecondaryResourceID(HasMetadata, Context)} returns a non-null {@link ResourceID}. In
+   * that case {@code informerEventSource.get(resourceID)} is called directly — a single hash-map
+   * lookup — without building a {@code Set} of all secondary resources and filtering through it.
+   *
+   * <p>Falls back to the standard {@link
+   * AbstractDependentResource#getSecondaryResource(HasMetadata, Context)} path (which delegates to
+   * {@link #selectTargetSecondaryResource(Set, HasMetadata, Context)}) when the event source is not
+   * present or {@code targetSecondaryResourceID} returns {@code null}.
+   *
+   * @param primary the primary resource
+   * @param context the reconciliation context
+   * @return the secondary resource if found, or {@link Optional#empty()}
+   */
+  @Override
+  public Optional<R> getSecondaryResource(P primary, Context<P> context) {
+    return eventSource()
+        .flatMap(
+            es -> {
+              ResourceID targetID = targetSecondaryResourceID(primary, context);
+              if (targetID != null) {
+                return es.get(targetID);
+              }
+              return super.getSecondaryResource(primary, context);
+            });
+  }
+
+  /**
+   * Selects the target secondary resource from the full set of candidates. This is the fallback
+   * path taken when {@link #getSecondaryResource(HasMetadata, Context)} cannot use the direct cache
+   * lookup (e.g. when a shared event source is used and the event source reference is not directly
+   * available via {@link #eventSource()}).
+   *
+   * <p>Prefer overriding {@link #targetSecondaryResourceID(HasMetadata, Context)} for
+   * performance-critical paths to avoid both this filtering and the {@code getOrComputeDesired}
+   * call it triggers.
+   */
   @Override
   protected Optional<R> selectTargetSecondaryResource(
       Set<R> secondaryResources, P primary, Context<P> context) {
@@ -262,12 +304,19 @@ protected Optional<R> selectTargetSecondaryResource(
   }
 
   /**
-   * Override this method in order to optimize and not compute the desired when selecting the target
-   * secondary resource. Simply, a static ResourceID can be returned.
+   * Returns the {@link ResourceID} of the target secondary resource. Used by both {@link
+   * #getSecondaryResource(HasMetadata, Context)} (fast cache-lookup path) and {@link
+   * #selectTargetSecondaryResource(Set, HasMetadata, Context)} (fallback filtering path).
+   *
+   * <p>Override this method to return a cheap, statically-derivable {@link ResourceID} (e.g.
+   * derived directly from the primary's name and namespace) to avoid computing the full desired
+   * state during secondary resource lookup. The default implementation calls {@link
+   * #getOrComputeDesired(Context)}, which is correct but may be costlier when the desired state is
+   * non-trivial to compute.
    *
-   * @param primary resource
-   * @param context of current reconciliation
-   * @return id of the target managed resource
+   * @param primary the primary resource
+   * @param context the current reconciliation context
+   * @return the {@link ResourceID} of the managed secondary resource
    */
   protected ResourceID targetSecondaryResourceID(P primary, Context<P> context) {
     return ResourceID.fromResource(getOrComputeDesired(context));