Merge pull request #1350 from grails/202

Use Variant of ServiceLoader to allow soft loading of META-INF/services classes

Author: jameskleeh

grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/config/DatastoreServiceMethodInvokingFactoryBean.groovy

@@ -0,0 +1,47 @@
+package org.grails.datastore.mapping.config
+
+import groovy.transform.CompileStatic
+import groovy.transform.Internal
+import org.grails.datastore.mapping.core.Datastore
+import org.grails.datastore.mapping.services.Service
+import org.springframework.beans.factory.BeanFactory
+import org.springframework.beans.factory.config.AutowireCapableBeanFactory
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.beans.factory.config.MethodInvokingFactoryBean
+import org.springframework.lang.Nullable
+
+/**
+ * Variant of {#link MethodInvokingFactoryBean} which returns the correct data service type instead of {@code java.lang.Object} so the Autowire with type works correctly.
+ */
+@Internal
+@CompileStatic
+class DatastoreServiceMethodInvokingFactoryBean extends MethodInvokingFactoryBean {
+
+    @Nullable
+    private ConfigurableBeanFactory beanFactory
+
+    @Override
+    Class<?> getObjectType() {
+        arguments[0] as Class<?>
+    }
+
+    @Override
+    protected Object invokeWithTargetException() throws Exception {
+        Object object = super.invokeWithTargetException()
+        if (object) {
+            ((Service) object).setDatastore((Datastore) targetObject)
+            if (beanFactory instanceof AutowireCapableBeanFactory) {
+                ((AutowireCapableBeanFactory) beanFactory).autowireBean(object)
+            }
+        }
+        object
+    }
+
+    @Override
+    void setBeanFactory(BeanFactory beanFactory) {
+        super.setBeanFactory(beanFactory)
+        if (beanFactory instanceof ConfigurableBeanFactory) {
+            this.beanFactory = (ConfigurableBeanFactory) beanFactory
+        }
+    }
+}

grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/services/DefaultServiceDefinition.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2017-2020 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.grails.datastore.mapping.services;
+
+import groovy.transform.Internal;
+
+import java.util.Optional;
+import java.util.ServiceConfigurationError;
+import java.util.function.Supplier;
+
+/**
+ * Default implementation of {@link ServiceDefinition}.
+ *
+ * @param <S> The type
+ * @author Graeme Rocher
+ * @since 1.0
+ */
+@Internal
+class DefaultServiceDefinition<S> implements ServiceDefinition<S> {
+    private final String name;
+    private final Optional<Class<S>> loadedClass;
+
+    /**
+     * @param name        The name
+     * @param loadedClass The loaded class
+     */
+    DefaultServiceDefinition(String name, Optional<Class<S>> loadedClass) {
+        this.name = name;
+        this.loadedClass = loadedClass;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public Class<S> getType() { return loadedClass.orElseThrow(() -> new ServiceConfigurationError("Call to load() when class '" + name + "' is not present")); }
+
+    @Override
+    public boolean isPresent() {
+        return loadedClass.isPresent();
+    }
+
+    @Override
+    public <X extends Throwable> S orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+        final Class<S> type = loadedClass.orElseThrow(exceptionSupplier);
+        try {
+            return type.newInstance();
+        } catch (Throwable e) {
+            throw exceptionSupplier.get();
+        }
+    }
+
+    @Override
+    public S load() {
+        return loadedClass.map(aClass -> {
+            try {
+                return aClass.newInstance();
+            } catch (Throwable e) {
+                throw new ServiceConfigurationError("Error loading service [" + aClass.getName() + "]: " + e.getMessage(), e);
+            }
+        }).orElseThrow(() -> new ServiceConfigurationError("Call to load() when class '" + name + "' is not present"));
+    }
+}

grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/services/ServiceDefinition.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2017-2020 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.grails.datastore.mapping.services;
+
+import java.util.function.Supplier;
+
+/**
+ * A service that may or may not be present on the classpath.
+ *
+ * @param <T> The service type
+ */
+public interface ServiceDefinition<T> {
+
+    /**
+     * @return The full class name of the service
+     */
+    String getName();
+
+    /**
+     * @return The type of the service
+     */
+    Class<T> getType();
+
+    /**
+     * @return is the service present
+     */
+    boolean isPresent();
+
+    /**
+     * Load the service of throw the given exception.
+     *
+     * @param exceptionSupplier The exception supplier
+     * @param <X>               The exception type
+     * @return The instance
+     * @throws X The exception concrete type
+     */
+    <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X;
+
+    /**
+     * @return load the service
+     */
+    T load();
+}