Add 'InstantiatorService' to allow customization of object construction

Author: chrisdennis

ehcache-core/build.gradle

@@ -16,6 +16,7 @@
 
 plugins {
   id 'org.ehcache.build.internal-module'
+  id 'java-test-fixtures'
 }
 
 publishing.publications.withType(MavenPublication) {

ehcache-core/src/main/java/org/ehcache/core/spi/service/InstantiatorService.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright Terracotta, Inc.
+ *
+ * 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.ehcache.core.spi.service;
+
+import org.ehcache.spi.service.Service;
+
+public interface InstantiatorService extends Service {
+
+  <T> T instantiate(Class<T> clazz, Object[] arguments);
+}

ehcache-core/src/testFixtures/java/org/ehcache/core/spi/ServiceLocatorUtils.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright Terracotta, Inc.
+ *
+ * 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.ehcache.core.spi;
+
+import org.ehcache.spi.service.Service;
+
+import java.util.function.UnaryOperator;
+
+public interface ServiceLocatorUtils {
+
+  static <T extends Service> void withServiceLocator(T service, ServiceTask<T> task) throws Exception {
+    withServiceLocator(service, UnaryOperator.identity(), task);
+  }
+
+  static <T extends Service> void withServiceLocator(T service, UnaryOperator<ServiceLocator.DependencySet> dependencies, ServiceTask<T> task) throws Exception {
+    ServiceLocator serviceLocator = dependencies.apply(ServiceLocator.dependencySet().with(service)).build();
+    serviceLocator.startAllServices();
+    try {
+      task.execute(service);
+    } finally {
+      serviceLocator.stopAllServices();
+    }
+  }
+
+  @FunctionalInterface
+  interface ServiceTask<T extends Service> {
+
+    void execute(T service) throws Exception;
+  }
+
+}

ehcache-impl/build.gradle

@@ -55,6 +55,7 @@ dependencies {
   implementation group: 'org.terracotta', name: 'terracotta-utilities-tools', version: parent.terracottaUtilitiesVersion
   compileOnly 'org.osgi:org.osgi.service.component.annotations:1.3.0'
   testImplementation project(':core-spi-test')
+  testImplementation testFixtures(project(':ehcache-core'))
   testImplementation 'org.ow2.asm:asm:6.2'
   testImplementation 'org.ow2.asm:asm-commons:6.2'
   testImplementation ("org.terracotta:statistics:$parent.statisticVersion")

ehcache-impl/src/main/java/org/ehcache/config/builders/UserManagedCacheBuilder.java

@@ -107,8 +107,7 @@ public class UserManagedCacheBuilder<K, V, T extends UserManagedCache<K, V>> imp
   private final Class<K> keyType;
   private final Class<V> valueType;
   private String id;
-  private final Set<Service> services = new HashSet<>();
-  private final Set<ServiceCreationConfiguration<?, ?>> serviceCreationConfigurations = new HashSet<>();
+  private ServiceLocator.DependencySet dependencySet = ServiceLocator.dependencySet().with(Store.Provider.class);
   private ExpiryPolicy<? super K, ? super V> expiry = ExpiryPolicy.NO_EXPIRY;
   private ClassLoader classLoader = ClassLoading.getDefaultClassLoader();
   private EvictionAdvisor<? super K, ? super V> evictionAdvisor;
@@ -143,8 +142,7 @@ private UserManagedCacheBuilder(UserManagedCacheBuilder<K, V, T> toCopy) {
     this.keyType = toCopy.keyType;
     this.valueType = toCopy.valueType;
     this.id = toCopy.id;
-    this.services.addAll(toCopy.services);
-    this.serviceCreationConfigurations.addAll(toCopy.serviceCreationConfigurations);
+    this.dependencySet = toCopy.dependencySet;
     this.expiry = toCopy.expiry;
     this.classLoader = toCopy.classLoader;
     this.evictionAdvisor = toCopy.evictionAdvisor;
@@ -167,19 +165,15 @@ private UserManagedCacheBuilder(UserManagedCacheBuilder<K, V, T> toCopy) {
   }
 
   @SuppressWarnings("try")
-  T build(ServiceLocator.DependencySet serviceLocatorBuilder) throws IllegalStateException {
+  T internalBuild() throws IllegalStateException {
 
     String alias = id == null ? "UserManaged - " + instanceId.getAndIncrement() : id;
     try(EhcachePrefixLoggerFactory.Context ignored = EhcachePrefixLoggerFactory.withContext("cache-alias", alias)){
       validateListenerConfig();
 
       ServiceLocator serviceLocator;
       try {
-        for (ServiceCreationConfiguration<?, ?> serviceCreationConfig : serviceCreationConfigurations) {
-          serviceLocatorBuilder = serviceLocatorBuilder.with(serviceCreationConfig);
-        }
-        serviceLocatorBuilder = serviceLocatorBuilder.with(Store.Provider.class);
-        serviceLocator = serviceLocatorBuilder.build();
+        serviceLocator = dependencySet.build();
         serviceLocator.startAllServices();
       } catch (Exception e) {
         throw new IllegalStateException("UserManagedCacheBuilder failed to build.", e);
@@ -354,13 +348,7 @@ private void validateListenerConfig() {
 
   private void registerListeners(Cache<K, V> cache, ServiceProvider<Service> serviceProvider, List<LifeCycled> lifeCycledList) {
     if (!eventListenerConfigurations.isEmpty()) {
-      final CacheEventListenerProvider listenerProvider;
-      CacheEventListenerProvider provider;
-      if ((provider = serviceProvider.getService(CacheEventListenerProvider.class)) != null) {
-        listenerProvider = provider;
-      } else {
-        listenerProvider = new DefaultCacheEventListenerProvider();
-      }
+      final CacheEventListenerProvider listenerProvider = serviceProvider.getService(CacheEventListenerProvider.class);
       for (CacheEventListenerConfiguration<?> config : eventListenerConfigurations) {
         final CacheEventListener<K, V> listener = listenerProvider.createEventListener(id, config);
         if (listener != null) {
@@ -396,7 +384,7 @@ T cast(UserManagedCache<K, V> cache) {
    * @throws IllegalStateException if the user managed cache cannot be built
    */
   public final T build(final boolean init) throws IllegalStateException {
-    final T build = build(dependencySet().withoutMandatoryServices().with(services));
+    final T build = internalBuild();
     if (init) {
       build.init();
     }
@@ -557,6 +545,7 @@ public final UserManagedCacheBuilder<K, V, T> withEventListeners(CacheEventListe
    */
   public final UserManagedCacheBuilder<K, V, T> withEventListeners(CacheEventListenerConfiguration<?> ... cacheEventListenerConfigurations) {
     UserManagedCacheBuilder<K, V, T> otherBuilder = new UserManagedCacheBuilder<>(this);
+    otherBuilder.dependencySet.with(CacheEventListenerProvider.class);
     otherBuilder.eventListenerConfigurations.addAll(Arrays.asList(cacheEventListenerConfigurations));
     return otherBuilder;
   }
@@ -737,9 +726,8 @@ public UserManagedCacheBuilder<K, V, T> withValueSerializer(Serializer<V> valueS
   @Deprecated
   public UserManagedCacheBuilder<K, V, T> withSizeOfMaxObjectGraph(long size) {
     UserManagedCacheBuilder<K, V, T> otherBuilder = new UserManagedCacheBuilder<>(this);
-    removeAnySizeOfEngine(otherBuilder);
     otherBuilder.objectGraphSize = size;
-    otherBuilder.serviceCreationConfigurations.add(new org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration(otherBuilder.maxObjectSize, otherBuilder.sizeOfUnit, otherBuilder.objectGraphSize));
+    otherBuilder.dependencySet.with(new org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration(otherBuilder.maxObjectSize, otherBuilder.sizeOfUnit, otherBuilder.objectGraphSize));
     return otherBuilder;
   }
 
@@ -756,10 +744,9 @@ public UserManagedCacheBuilder<K, V, T> withSizeOfMaxObjectGraph(long size) {
   @Deprecated
   public UserManagedCacheBuilder<K, V, T> withSizeOfMaxObjectSize(long size, MemoryUnit unit) {
     UserManagedCacheBuilder<K, V, T> otherBuilder = new UserManagedCacheBuilder<>(this);
-    removeAnySizeOfEngine(otherBuilder);
     otherBuilder.maxObjectSize = size;
     otherBuilder.sizeOfUnit = unit;
-    otherBuilder.serviceCreationConfigurations.add(new org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration(otherBuilder.maxObjectSize, otherBuilder.sizeOfUnit, otherBuilder.objectGraphSize));
+    otherBuilder.dependencySet.with(new org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration(otherBuilder.maxObjectSize, otherBuilder.sizeOfUnit, otherBuilder.objectGraphSize));
     return otherBuilder;
   }
 
@@ -791,10 +778,7 @@ public static <K, V> UserManagedCacheBuilder<K, V, UserManagedCache<K, V>> newUs
   @SuppressWarnings("deprecation")
   public UserManagedCacheBuilder<K, V, T> using(Service service) {
     UserManagedCacheBuilder<K, V, T> otherBuilder = new UserManagedCacheBuilder<>(this);
-    if (service instanceof org.ehcache.core.spi.store.heap.SizeOfEngineProvider) {
-      removeAnySizeOfEngine(otherBuilder);
-    }
-    otherBuilder.services.add(service);
+    otherBuilder.dependencySet.with(service);
     return otherBuilder;
   }
 
@@ -815,17 +799,7 @@ public UserManagedCacheBuilder<K, V, T> using(Service service) {
   @SuppressWarnings("deprecation")
   public UserManagedCacheBuilder<K, V, T> using(ServiceCreationConfiguration<?, ?> serviceConfiguration) {
     UserManagedCacheBuilder<K, V, T> otherBuilder = new UserManagedCacheBuilder<>(this);
-    if (serviceConfiguration instanceof org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration) {
-      removeAnySizeOfEngine(otherBuilder);
-    }
-    otherBuilder.serviceCreationConfigurations.add(serviceConfiguration);
+    otherBuilder.dependencySet.with(serviceConfiguration);
     return otherBuilder;
   }
-
-  @Deprecated
-  private static void removeAnySizeOfEngine(UserManagedCacheBuilder<?, ?, ?> builder) {
-    builder.services.remove(findSingletonAmongst(org.ehcache.core.spi.store.heap.SizeOfEngineProvider.class, builder.services));
-    builder.serviceCreationConfigurations.remove(findSingletonAmongst(org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration.class, builder.serviceCreationConfigurations));
-  }
-
 }

ehcache-impl/src/main/java/org/ehcache/impl/internal/DefaultInstantiatorServiceFactory.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright Terracotta, Inc.
+ *
+ * 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.ehcache.impl.internal;
+
+import org.ehcache.core.spi.service.InstantiatorService;
+import org.ehcache.core.spi.service.ServiceFactory;
+import org.ehcache.impl.internal.classes.DefaultInstantiatorService;
+import org.ehcache.spi.service.ServiceCreationConfiguration;
+import org.osgi.service.component.annotations.Component;
+
+@Component
+public class DefaultInstantiatorServiceFactory implements ServiceFactory<InstantiatorService> {
+
+  @Override
+  public int rank() {
+    return Integer.MIN_VALUE;
+  }
+
+  @Override
+  public InstantiatorService create(ServiceCreationConfiguration<InstantiatorService, ?> configuration) {
+    return new DefaultInstantiatorService();
+  }
+
+  @Override
+  public Class<? extends InstantiatorService> getServiceType() {
+    return DefaultInstantiatorService.class;
+  }
+}

ehcache-impl/src/main/java/org/ehcache/impl/internal/classes/ClassInstanceProvider.java

@@ -17,29 +17,30 @@
 package org.ehcache.impl.internal.classes;
 
 import org.ehcache.config.CacheConfiguration;
+import org.ehcache.core.spi.service.InstantiatorService;
+import org.ehcache.spi.service.ServiceDependencies;
 import org.ehcache.spi.service.ServiceProvider;
 import org.ehcache.spi.service.Service;
 import org.ehcache.spi.service.ServiceConfiguration;
 import org.ehcache.core.collections.ConcurrentWeakIdentityHashMap;
 
 import java.io.Closeable;
 import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import static org.ehcache.impl.internal.classes.commonslang.reflect.ConstructorUtils.invokeConstructor;
 import static org.ehcache.core.spi.service.ServiceUtils.findAmongst;
 import static org.ehcache.core.spi.service.ServiceUtils.findSingletonAmongst;
 
 /**
  * @author Alex Snaps
  */
-public class ClassInstanceProvider<K, C extends ClassInstanceConfiguration<? extends T>, T> {
+@ServiceDependencies(InstantiatorService.class)
+public class ClassInstanceProvider<K, C extends ClassInstanceConfiguration<? extends T>, T> implements Service {
 
   /**
    * The order in which entries are put in is kept.
@@ -55,6 +56,8 @@ public class ClassInstanceProvider<K, C extends ClassInstanceConfiguration<? ext
   private final Class<C> cacheLevelConfig;
   private final boolean uniqueClassLevelConfig;
 
+  private InstantiatorService instantiator;
+
   protected ClassInstanceProvider(ClassInstanceProviderConfiguration<K, C> factoryConfig,
                                   Class<C> cacheLevelConfig) {
     this(factoryConfig, cacheLevelConfig, false);
@@ -117,12 +120,8 @@ private T newInstance(K alias, ClassInstanceConfiguration<? extends T> config) {
     if(config.getInstance() != null) {
       instance = config.getInstance();
     } else {
-      try {
-        instance = invokeConstructor(config.getClazz(), config.getArguments());
-        instantiated.add(instance);
-      } catch (InstantiationException | InvocationTargetException | NoSuchMethodException | IllegalAccessException e) {
-        throw new RuntimeException(e);
-      }
+      instance = instantiator.instantiate(config.getClazz(), config.getArguments());
+      instantiated.add(instance);
     }
 
     AtomicInteger currentCount = providedVsCount.putIfAbsent(instance, new AtomicInteger(1));
@@ -153,10 +152,10 @@ protected void releaseInstance(T instance) throws IOException {
   }
 
   public void start(ServiceProvider<Service> serviceProvider) {
-    // default no-op
+    this.instantiator = serviceProvider.getService(InstantiatorService.class);
   }
 
   public void stop() {
-    // default no-op
+    this.instantiator = null;
   }
 }

ehcache-impl/src/main/java/org/ehcache/impl/internal/classes/DefaultInstantiatorService.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright Terracotta, Inc.
+ *
+ * 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.ehcache.impl.internal.classes;
+
+import org.ehcache.core.spi.service.InstantiatorService;
+import org.ehcache.impl.internal.classes.commonslang.reflect.ConstructorUtils;
+import org.ehcache.spi.service.Service;
+import org.ehcache.spi.service.ServiceProvider;
+
+public class DefaultInstantiatorService implements InstantiatorService {
+
+  @Override
+  public void start(ServiceProvider<Service> serviceProvider) {
+
+  }
+
+  @Override
+  public void stop() {
+
+  }
+
+  @Override
+  public <T> T instantiate(Class<T> clazz, Object[] arguments) {
+    try {
+      return ConstructorUtils.invokeConstructor(clazz, arguments);
+    } catch (ReflectiveOperationException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}

ehcache-impl/src/main/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProvider.java

@@ -16,6 +16,7 @@
 package org.ehcache.impl.internal.spi.resilience;
 
 import org.ehcache.config.CacheConfiguration;
+import org.ehcache.core.spi.service.InstantiatorService;
 import org.ehcache.impl.config.resilience.DefaultResilienceStrategyConfiguration;
 import org.ehcache.impl.config.resilience.DefaultResilienceStrategyProviderConfiguration;
 import org.ehcache.impl.internal.classes.ClassInstanceProvider;
@@ -24,10 +25,12 @@
 import org.ehcache.spi.resilience.ResilienceStrategy;
 import org.ehcache.spi.resilience.ResilienceStrategyProvider;
 import org.ehcache.spi.service.Service;
+import org.ehcache.spi.service.ServiceDependencies;
 import org.ehcache.spi.service.ServiceProvider;
 
 import static org.ehcache.core.spi.service.ServiceUtils.findSingletonAmongst;
 
+@ServiceDependencies(InstantiatorService.class)
 public class DefaultResilienceStrategyProvider implements ResilienceStrategyProvider {
 
   private final ComponentProvider regularStrategies;

ehcache-impl/src/main/resources/META-INF/services/org.ehcache.core.spi.service.ServiceFactory

@@ -5,6 +5,7 @@ org.ehcache.impl.internal.store.tiering.TieredStoreProviderFactory
 org.ehcache.impl.internal.store.tiering.CompoundCachingTierProviderFactory
 org.ehcache.impl.internal.store.loaderwriter.LoaderWriterStoreProviderFactory
 
+org.ehcache.impl.internal.DefaultInstantiatorServiceFactory
 org.ehcache.impl.internal.TimeSourceServiceFactory
 org.ehcache.impl.internal.spi.serialization.DefaultSerializationProviderFactory
 org.ehcache.impl.internal.spi.loaderwriter.DefaultCacheLoaderWriterProviderFactory