DiInjected diInjected = new DiInjected();
            container.lookup(org.apache.maven.di.Injector.class).injectInstance(diInjected);
            assertNotNull(diInjected.parser);
            assertNotNull(diInjected.parsers);
            assertEquals(1, diInjected.parsers.size());
            assertNotNull(diInjected.parsersMap);
            assertEquals(1, diInjected.parsersMap.size());
        }

- DI via `@Resource` annotation
- `HtmlResponse` for JSP, `JsonResponse` for APIs

### Services
- Business logic in `app.service.*`
- Injected into Actions
- Use behavior classes to access OpenSearch

### Helpers
- Cross-cutting utilities in `helper.*`
- Stateless, injected via DI
- Access via `ComponentUtil.getFooHelper()`

## Development Notes

- **Code Style**: Enforced by `mvn formatter:format`

import org.apache.maven.extension.internal.CoreExports;

/**
 */
@Named
@Singleton
@Deprecated
public class DefaultArtifactFilterManager implements ArtifactFilterManager {

    // this is a live injected collection
    protected final List<ArtifactFilterManagerDelegate> delegates;

    protected Set<String> excludedArtifacts;

    private final Set<String> coreArtifacts;

    @Inject

    /** Injected search engine client for OpenSearch operations. */
    @Resource
    protected SearchEngineClient searchEngineClient;

    /** Injected helper for web and file system indexing operations. */
    @Resource
    protected WebFsIndexHelper webFsIndexHelper;

    /** Injected helper for data store indexing operations. */
    @Resource

 * Meta-annotation that marks other annotations as qualifier annotations.
 * <p>
 * Qualifiers are used to distinguish between multiple beans of the same type,
 * allowing for more precise control over which implementation should be injected.
 * Custom qualifier annotations should be annotated with {@code @Qualifier}.
 * <p>
 * Example of creating a custom qualifier:
 * <pre>
 * {@literal @}Qualifier
 * {@literal @}Retention(RUNTIME)

 * for managing object lifecycle and dependencies within Maven's build process.
 * <p>
 * This package provides a set of annotations that control how objects are created,
 * managed and injected throughout Maven's execution lifecycle. The framework is designed
 * to be lightweight yet powerful, supporting various scopes of object lifecycle from
 * singleton instances to mojo-execution-scoped beans.
 * <p>

 *
 * This is because the ModelProcessor interface extends ModelLocator and ModelReader. If we
 * made this component available under all its interfaces then it could end up being injected
 * into itself leading to a stack overflow.
 *
 * A side effect of using @Typed is that it translates to explicit bindings in the container.

                if (annotation != null) {
                    final Object injected = container.getComponent(fieldDesc.getFieldName());
                    if (injected != null) {
                        FieldUtil.set(fieldDesc.getField(), component, injected);
                    }
                }
            }

    /**
     * Injects plugin executions induced by lifecycle bindings into the specified model. The model has already undergone
     * injection of plugin management so any plugins that are injected by lifecycle bindings and are not already present
     * in the model's plugin section need to be subjected to the model's plugin management.
     *

     *
     * @param model The model into which to merge the values defined by the profile, must not be <code>null</code>.
     * @param profile The (read-only) profile whose values should be injected, may be <code>null</code>.
     * @param request The model building request that holds further settings, must not be {@code null}.