Как сгенерировать реализацию службы из нескольких реализаций во время выполнения?

Самый простой способ - поместить весь интерфейс в один интерфейс:

public interface CommonService<T, Z> {
    void findById(long id);
    void findAll();
    void save();
    void deleteById(long id);
}

затем сделайте свой сервис, который расширяет CommonService

public interface ObjectService extends CommonService<Object, long> {

}

и, наконец, вы можете сделать импл, который реализует ObjectService

public class ObjectImpl implements ObjectService {
@Override
    public void findById(long id) {
        System.out.println("ObjectImpl::findById(" + id + ")");
    }

    @Override
    public void findAll() {
        System.out.println("ObjectImpl::findAll()");
    }

    @Override
    public void save() {
        System.out.println("ObjectImpl::save()");
    }

    @Override
    public void deleteById(long id) {
        System.out.println("ObjectImpl::deleteById(" + id + ")");
    }

}

Отказ от ответственности

Я не эксперт по Spring, особенно в том, что касается создания bean-компонентов и т. д., поэтому примите следующий подход с недоверием. Ваш вопрос заставил меня задуматься, поэтому я поиграл со Spring и смог придумать следующий базовый подход.

Обратите внимание, что это предназначено только для того, чтобы вы начали работу, и далеко не готово к производству. Потребуются дополнительные исследования, и другие могут даже прийти и показать, что это неправильный подход.

Подход

Теперь вот подход:

• Создайте пользовательскую аннотацию, чтобы отметить интересующие вас интерфейсы.
• Зарегистрируйте фабричные методы, которые создают прокси для этих интерфейсов. Эти прокси будут делегировать вызовы соответствующим реализациям «фрагментов».
• Включите все с аннотацией в вашем классе приложения.

Код (только дополнительные соответствующие части)

Аннотация интерфейса:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface CompositeService {}

Аннотация включения:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import({CompositeServiceFactoryRegistrar.class})
public @interface EnableCompositeServices {}

Главный заводской регистратор (со встроенными комментариями):

@Component
public class CompositeServiceFactoryRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    private Map<Class<?>, Supplier<Object>> fragmentFactories = new HashMap<>();

    private Environment environment;
   
    public CompositeServiceFactoryRegistrar() {
        //hard coded fragment registration, you'll probably want to do a lookup of all interfaces and their implementation on the classpath instead
        fragmentFactories.put(SaveExtension.class, () -> new SaveExtensionImpl());
        fragmentFactories.put(DeleteExtension.class, () -> new DeleteExtensionImpl());      
        fragmentFactories.put(FindExtension.class, () -> new FindExtensionImpl());
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        
        //get the enablement annotation and set up package scan
        Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(EnableCompositeServices.class.getCanonicalName());

        if (annotationAttributes != null) {
            String[] basePackages = (String[]) annotationAttributes.get("value");

            if (basePackages == null || basePackages.length == 0) {
                // If value attribute is not set, fallback to the package of the annotated class
                basePackages = new String[] {
                        ((StandardAnnotationMetadata) metadata).getIntrospectedClass().getPackage().getName() };
            }

            // using these packages, scan for interface annotated with MyCustomBean
            ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(
                    false, environment) {
                // Override isCandidateComponent to only scan for interface
                @Override
                protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
                    AnnotationMetadata metadata = beanDefinition.getMetadata();
                    return metadata.isIndependent() && metadata.isInterface();
                }
            };
            provider.addIncludeFilter(new AnnotationTypeFilter(CompositeService.class));

            // Scan all packages
            for (String basePackage : basePackages) {
                for (BeanDefinition beanDefinition : provider.findCandidateComponents(basePackage)) {                   

                    GenericBeanDefinition genericDef = new GenericBeanDefinition(beanDefinition);
                    
                    //resolve the interface class if not done yet
                    if ( !genericDef.hasBeanClass()) {
                        try {
                            genericDef.resolveBeanClass(getClassLoader());
                        } catch(ClassNotFoundException e) {
                            //simple logging, replace that with something more appropriate
                            e.printStackTrace();
                        }
                    }
                    
                    Class<?> interfaceType = genericDef.getBeanClass();                                 

                    //add the factory to the bean definition and then register it
                    genericDef.setInstanceSupplier(() -> createProxy(interfaceType) );                  
                    registry.registerBeanDefinition(interfaceType.getSimpleName(), genericDef);
                }
            }
        }
    }

    /*
     * Main factory method
     */
    @SuppressWarnings("unchecked")
    private <T> T createProxy(Class<T> type) {
        //create the factory and set the interface type
        ProxyFactory factory = new ProxyFactory();
        factory.setInterfaces(type);

        //add the advice that actually delegates to the fragments
        factory.addAdvice(new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                Method invokedMethod = invocation.getMethod();

                Class<?> invokedClass = invokedMethod.getDeclaringClass();
                if (invokedClass.isInterface()) {

                    //create the fragment for this method, if not possible continue with the next interceptor
                    Supplier<Object> supplier = fragmentFactories.get(invokedClass);
                    if (supplier == null) {
                        return invocation.proceed();
                    }

                    Object fragment = supplier.get();

                    //get the fragment method and invoke it
                    Method targetMethod = fragment.getClass().getDeclaredMethod(invokedMethod.getName(),
                            invokedMethod.getParameterTypes());

                    return targetMethod.invoke(fragment, invocation.getArguments());
                } else {
                    return invocation.proceed();
                }
            }
        });

        return (T) factory.getProxy(getClassLoader());
    }
    
    private ClassLoader getClassLoader() {
        return getClass().getClassLoader();
    }
}

Обратите внимание, что это очень простая реализация и имеет несколько недостатков, например.

• он не обрабатывает перегрузки и преобразование параметров
• у него могут быть трудности с переопределением -> нужно больше магии отражения
• фрагменты жестко закодированы
• (подозреваю много других)