This is an automated email from the ASF dual-hosted git repository.

gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/master by this push:
     new 43f3c0f5ef feat: auto-discover Listener implementations via SpiService 
at session init (#13701)
43f3c0f5ef is described below

commit 43f3c0f5efc48ad4484a3e49e4193a2d015c2f58
Author: HARSHA B <[email protected]>
AuthorDate: Tue Nov 10 01:36:05 2026 +0530

    feat: auto-discover Listener implementations via SpiService at session init 
(#13701)
    
    * #13520: Discover repository and execution listeners via SpiService lookup
    
    Discover all listeners contributing to the Maven session by looking up
    SpiService instances from the Lookup container and filtering for
    Listener implementations. This ensures core extensions wired through
    META-INF/services/ (SPI service loader) are discovered without requiring
    direct DI registrations or interface inheritance.
    
    Also fix ApiRunner.lookupList() and lookupMap() in maven-impl to construct
    DI keys using Types.parameterizedType() with the requested component type,
    preventing TypeNotBoundException due to generic type erasure.
    
    * Document Listener registration via SpiService in Javadoc
    
    Add a registration section to Listener explaining the two ways to register
    a listener: programmatically via Session#registerListener, or automatically
    via DI by also implementing SpiService and registering in META-INF/services.
    
    SpiService is in a different module (maven-api-spi) so a plain-text 
reference
    is used instead of a @link tag.
    
    Co-authored-by: Claude Sonnet 4.6 <[email protected]>
    
    ---------
    
    Co-authored-by: Guillaume Nodet <[email protected]>
    Co-authored-by: Claude Sonnet 4.6 <[email protected]>
---
 .../main/java/org/apache/maven/api/Listener.java   |   9 +
 .../org/apache/maven/impl/AbstractSession.java     |  17 +-
 .../maven/impl/MavenRepositoryListenerTest.java    | 230 ++++++++++++++++++++-
 3 files changed, 250 insertions(+), 6 deletions(-)

diff --git 
a/api/maven-api-core/src/main/java/org/apache/maven/api/Listener.java 
b/api/maven-api-core/src/main/java/org/apache/maven/api/Listener.java
index ab11b458d5..9f6a6f02d1 100644
--- a/api/maven-api-core/src/main/java/org/apache/maven/api/Listener.java
+++ b/api/maven-api-core/src/main/java/org/apache/maven/api/Listener.java
@@ -39,6 +39,15 @@
  *     }
  * }
  * }</pre>
+ * <p>
+ * Listeners can be registered in two ways:
+ * <ul>
+ *   <li>Programmatically, via {@link Session#registerListener(Listener)}.</li>
+ *   <li>Automatically via dependency injection: implement both this interface 
and
+ *       {@code org.apache.maven.api.spi.SpiService}, then register your class 
in
+ *       {@code META-INF/services/org.apache.maven.api.spi.SpiService}. Maven 
will
+ *       discover and register such listeners automatically at session 
initialization.</li>
+ * </ul>
  *
  * @since 4.0.0
  */
diff --git 
a/impl/maven-impl/src/main/java/org/apache/maven/impl/AbstractSession.java 
b/impl/maven-impl/src/main/java/org/apache/maven/impl/AbstractSession.java
index f339ed298b..f99a428c31 100644
--- a/impl/maven-impl/src/main/java/org/apache/maven/impl/AbstractSession.java
+++ b/impl/maven-impl/src/main/java/org/apache/maven/impl/AbstractSession.java
@@ -98,6 +98,7 @@
 import org.apache.maven.api.services.VersionRangeResolver;
 import org.apache.maven.api.services.VersionResolver;
 import org.apache.maven.api.services.VersionResolverException;
+import org.apache.maven.api.spi.SpiService;
 import org.apache.maven.di.Injector;
 import org.apache.maven.di.Key;
 import org.apache.maven.di.impl.Binding;
@@ -159,14 +160,24 @@ protected AbstractSession(
         this.repositories = getRepositories(repositories, 
resolverRepositories);
         this.lookup = lookup;
         this.injector = lookup != null ? 
lookup.lookupOptional(Injector.class).orElse(null) : null;
-        this.listeners = getListeners(session);
+        this.listeners = getListeners(session, lookup);
         this.context = context;
     }
 
     @SuppressWarnings("unchecked")
-    private static List<Listener> getListeners(RepositorySystemSession 
session) {
+    private static List<Listener> getListeners(RepositorySystemSession 
session, Lookup lookup) {
         // Both event families share the registration scope of the underlying 
repository system session.
-        return (List<Listener>) 
session.getData().computeIfAbsent(Listener.class, CopyOnWriteArrayList::new);
+        return (List<Listener>) 
session.getData().computeIfAbsent(Listener.class, () -> {
+            List<Listener> list = new CopyOnWriteArrayList<>();
+            if (lookup != null) {
+                for (SpiService spi : lookup.lookupList(SpiService.class)) {
+                    if (spi instanceof Listener listener && 
!list.contains(listener)) {
+                        list.add(listener);
+                    }
+                }
+            }
+            return list;
+        });
     }
 
     @SuppressWarnings("unchecked")
diff --git 
a/impl/maven-impl/src/test/java/org/apache/maven/impl/MavenRepositoryListenerTest.java
 
b/impl/maven-impl/src/test/java/org/apache/maven/impl/MavenRepositoryListenerTest.java
index 1dd69aed18..a277495244 100644
--- 
a/impl/maven-impl/src/test/java/org/apache/maven/impl/MavenRepositoryListenerTest.java
+++ 
b/impl/maven-impl/src/test/java/org/apache/maven/impl/MavenRepositoryListenerTest.java
@@ -19,7 +19,9 @@
 package org.apache.maven.impl;
 
 import java.nio.file.Path;
+import java.time.Instant;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -27,14 +29,27 @@
 import java.util.stream.IntStream;
 
 import org.apache.maven.api.Artifact;
+import org.apache.maven.api.Event;
+import org.apache.maven.api.ExecutionEvent;
+import org.apache.maven.api.ExecutionEventType;
+import org.apache.maven.api.ExecutionListener;
 import org.apache.maven.api.Listener;
+import org.apache.maven.api.Project;
 import org.apache.maven.api.RemoteRepository;
 import org.apache.maven.api.RepositoryEvent;
 import org.apache.maven.api.RepositoryEventType;
 import org.apache.maven.api.RepositoryListener;
 import org.apache.maven.api.RepositoryMetadata;
 import org.apache.maven.api.Session;
+import org.apache.maven.api.Version;
+import org.apache.maven.api.services.Lookup;
+import org.apache.maven.api.services.RequestTrace;
+import org.apache.maven.api.settings.Settings;
+import org.apache.maven.api.spi.SpiService;
+import org.apache.maven.api.toolchain.ToolchainModel;
 import org.eclipse.aether.DefaultRepositorySystemSession;
+import org.eclipse.aether.RepositorySystem;
+import org.eclipse.aether.RepositorySystemSession;
 import org.eclipse.aether.metadata.DefaultMetadata;
 import org.eclipse.aether.metadata.Metadata;
 import org.junit.jupiter.api.Test;
@@ -44,6 +59,7 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -230,6 +246,214 @@ private static void dispatch(MavenRepositoryListener 
listener, org.eclipse.aethe
         }
     }
 
+    @Test
+    void 
spiListenerDiscoveredFromLookupReceivesEventsWithoutManualRegistration() {
+        Lookup lookup = mock(Lookup.class);
+        RecordingListener repoListener = new RecordingListener();
+        RecordingExecutionListener execListener = new 
RecordingExecutionListener();
+        RecordingCombinedListener combinedListener = new 
RecordingCombinedListener();
+        NonListenerSpiService nonListenerSpi = new NonListenerSpiService();
+        when(lookup.lookupList(SpiService.class))
+                .thenReturn(List.of(repoListener, execListener, 
combinedListener, nonListenerSpi));
+
+        DefaultRepositorySystemSession resolverSession = new 
DefaultRepositorySystemSession(h -> false);
+        TestSession session = new TestSession(resolverSession, lookup);
+        InternalSession.associate(resolverSession, session);
+
+        assertEquals(3, session.getListeners().size());
+        assertTrue(session.getListeners().contains(repoListener));
+        assertTrue(session.getListeners().contains(execListener));
+        assertTrue(session.getListeners().contains(combinedListener));
+
+        MavenRepositoryListener bridge = new MavenRepositoryListener();
+        bridge.artifactResolving(new 
org.eclipse.aether.RepositoryEvent.Builder(
+                        resolverSession, 
org.eclipse.aether.RepositoryEvent.EventType.ARTIFACT_RESOLVING)
+                .build());
+
+        assertEquals(List.of(RepositoryEventType.ARTIFACT_RESOLVING), 
repoListener.types);
+        assertEquals(List.of(RepositoryEventType.ARTIFACT_RESOLVING), 
combinedListener.repositoryTypes);
+        assertTrue(execListener.types.isEmpty());
+
+        ExecutionEvent executionEvent = mock(ExecutionEvent.class);
+        
when(executionEvent.type()).thenReturn(ExecutionEventType.SESSION_STARTED);
+        for (Listener listener : session.getListeners()) {
+            listener.onEvent(executionEvent);
+        }
+
+        assertEquals(List.of(ExecutionEventType.SESSION_STARTED), 
execListener.types);
+        assertEquals(List.of(ExecutionEventType.SESSION_STARTED), 
combinedListener.executionTypes);
+        assertEquals(List.of(RepositoryEventType.ARTIFACT_RESOLVING), 
repoListener.types);
+    }
+
+    @Test
+    void manuallyRegisteredListenersContinueToWorkWithSpiListeners() {
+        Lookup lookup = mock(Lookup.class);
+        RecordingListener spiListener = new RecordingListener();
+        
when(lookup.lookupList(SpiService.class)).thenReturn(List.of(spiListener));
+
+        DefaultRepositorySystemSession resolverSession = new 
DefaultRepositorySystemSession(h -> false);
+        TestSession session = new TestSession(resolverSession, lookup);
+        InternalSession.associate(resolverSession, session);
+
+        RecordingListener manual = new RecordingListener();
+        session.registerListener(manual);
+
+        assertEquals(2, session.getListeners().size());
+
+        MavenRepositoryListener bridge = new MavenRepositoryListener();
+        bridge.artifactResolved(new org.eclipse.aether.RepositoryEvent.Builder(
+                        resolverSession, 
org.eclipse.aether.RepositoryEvent.EventType.ARTIFACT_RESOLVED)
+                .build());
+
+        assertEquals(List.of(RepositoryEventType.ARTIFACT_RESOLVED), 
spiListener.types);
+        assertEquals(List.of(RepositoryEventType.ARTIFACT_RESOLVED), 
manual.types);
+
+        session.unregisterListener(manual);
+        assertEquals(1, session.getListeners().size());
+        assertTrue(session.getListeners().contains(spiListener));
+    }
+
+    @Test
+    void nullOrEmptyLookupDoesNotBreakSessionInitialization() {
+        DefaultRepositorySystemSession resolverSessionNull = new 
DefaultRepositorySystemSession(h -> false);
+        TestSession sessionNull = new TestSession(resolverSessionNull, null);
+        assertTrue(sessionNull.getListeners().isEmpty());
+
+        DefaultRepositorySystemSession resolverSessionEmpty = new 
DefaultRepositorySystemSession(h -> false);
+        Lookup emptyLookup = mock(Lookup.class);
+        when(emptyLookup.lookupList(SpiService.class)).thenReturn(List.of());
+        TestSession sessionEmpty = new TestSession(resolverSessionEmpty, 
emptyLookup);
+        assertTrue(sessionEmpty.getListeners().isEmpty());
+    }
+
+    @Test
+    void derivedSessionsDoNotCauseDuplicateListenerNotifications() {
+        Lookup lookup = mock(Lookup.class);
+        RecordingListener spiListener = new RecordingListener();
+        
when(lookup.lookupList(SpiService.class)).thenReturn(List.of(spiListener));
+
+        DefaultRepositorySystemSession resolverSession = new 
DefaultRepositorySystemSession(h -> false);
+        TestSession rootSession = new TestSession(resolverSession, lookup);
+        Session derivedSession = rootSession.withRemoteRepositories(List.of());
+        InternalSession.associate(resolverSession, rootSession);
+
+        assertEquals(1, derivedSession.getListeners().size());
+        verify(lookup, times(1)).lookupList(SpiService.class);
+
+        MavenRepositoryListener bridge = new MavenRepositoryListener();
+        bridge.metadataInstalling(new 
org.eclipse.aether.RepositoryEvent.Builder(
+                        resolverSession, 
org.eclipse.aether.RepositoryEvent.EventType.METADATA_INSTALLING)
+                .build());
+
+        assertEquals(1, spiListener.types.size());
+        assertEquals(RepositoryEventType.METADATA_INSTALLING, 
spiListener.types.get(0));
+    }
+
+    private static class RecordingExecutionListener implements 
ExecutionListener, SpiService {
+        final List<ExecutionEventType> types = new ArrayList<>();
+        final List<ExecutionEvent> events = new ArrayList<>();
+
+        @Override
+        public void sessionStarted(ExecutionEvent event) {
+            types.add(event.type());
+            events.add(event);
+        }
+    }
+
+    private static class RecordingCombinedListener implements 
ExecutionListener, RepositoryListener, SpiService {
+        final List<RepositoryEventType> repositoryTypes = new ArrayList<>();
+        final List<RepositoryEvent> repositoryEvents = new ArrayList<>();
+        final List<ExecutionEventType> executionTypes = new ArrayList<>();
+        final List<ExecutionEvent> executionEvents = new ArrayList<>();
+
+        @Override
+        public void onEvent(Event event) {
+            ExecutionListener.super.onEvent(event);
+            RepositoryListener.super.onEvent(event);
+        }
+
+        @Override
+        public void sessionStarted(ExecutionEvent event) {
+            executionTypes.add(event.type());
+            executionEvents.add(event);
+        }
+
+        @Override
+        public void artifactResolving(RepositoryEvent event) {
+            repositoryTypes.add(event.type());
+            repositoryEvents.add(event);
+        }
+    }
+
+    private static class NonListenerSpiService implements SpiService {}
+
+    private static class TestSession extends AbstractSession {
+        TestSession(RepositorySystemSession session, Lookup lookup) {
+            super(session, mock(RepositorySystem.class), List.of(), List.of(), 
lookup, null);
+        }
+
+        @Override
+        public Settings getSettings() {
+            return null;
+        }
+
+        @Override
+        public Collection<ToolchainModel> getToolchains() {
+            return List.of();
+        }
+
+        @Override
+        public Map<String, String> getUserProperties() {
+            return Map.of();
+        }
+
+        @Override
+        public Map<String, String> getSystemProperties() {
+            return Map.of();
+        }
+
+        @Override
+        public Map<String, String> getEffectiveProperties(Project project) {
+            return Map.of();
+        }
+
+        @Override
+        public Version getMavenVersion() {
+            return null;
+        }
+
+        @Override
+        public Instant getStartTime() {
+            return null;
+        }
+
+        @Override
+        public Path getTopDirectory() {
+            return null;
+        }
+
+        @Override
+        public Path getRootDirectory() {
+            return null;
+        }
+
+        @Override
+        public List<Project> getProjects() {
+            return List.of();
+        }
+
+        @Override
+        public Map<String, Object> getPluginContext(Project project) {
+            return Map.of();
+        }
+
+        @Override
+        protected Session newSession(
+                RepositorySystemSession session, List<RemoteRepository> 
repositories, RequestTrace context) {
+            return new TestSession(session, lookup);
+        }
+    }
+
     private static final class TestContext {
         private final DefaultRepositorySystemSession resolverSession = new 
DefaultRepositorySystemSession(h -> false);
         private final InternalSession session = mock(InternalSession.class);
@@ -240,9 +464,9 @@ private TestContext() {
         }
     }
 
-    private static final class RecordingListener implements RepositoryListener 
{
-        private final List<RepositoryEventType> types = new ArrayList<>();
-        private final List<RepositoryEvent> events = new ArrayList<>();
+    private static class RecordingListener implements RepositoryListener, 
SpiService {
+        final List<RepositoryEventType> types = new ArrayList<>();
+        final List<RepositoryEvent> events = new ArrayList<>();
 
         private void record(RepositoryEvent event) {
             types.add(event.type());

Reply via email to