Refactor the factory registry and instance creation.
Remove unnecessary static code in Factory creation.
Centralize the responsibility to read the factory registry configuration
and cache the factory instances in a Singleton called
FactoryRegistryManager.
Clean the base abstract factory that was sharing non factory code, it
had all the factory registry code statically, never used by the concrete
factory classes.
Change-Id: Ie2e9c29013acd36ddaf15383dd6b06432fbdbb66
Issue-ID: SDC-1905
Signed-off-by: andre.schmid <andre.schmid@est.tech>
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class ComponentDependencyModelManagerFactory extends
AbstractComponentFactory<ComponentDependencyModelManager> {
public static ComponentDependencyModelManagerFactory getInstance() {
- return AbstractFactory.getInstance(ComponentDependencyModelManagerFactory.class);
+ return getInstance(ComponentDependencyModelManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class ComponentManagerFactory extends AbstractComponentFactory<ComponentManager> {
public static ComponentManagerFactory getInstance() {
- return AbstractFactory.getInstance(ComponentManagerFactory.class);
+ return getInstance(ComponentManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class CompositionEntityDataManagerFactory extends
AbstractComponentFactory<CompositionEntityDataManager> {
public static CompositionEntityDataManagerFactory getInstance() {
- return AbstractFactory.getInstance(CompositionEntityDataManagerFactory.class);
+ return getInstance(CompositionEntityDataManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class ComputeManagerFactory extends AbstractComponentFactory<ComputeManager> {
public static ComputeManagerFactory getInstance() {
- return AbstractFactory.getInstance(ComputeManagerFactory.class);
+ return getInstance(ComputeManagerFactory.class);
}
}
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class DeploymentFlavorManagerFactory extends
AbstractComponentFactory<DeploymentFlavorManager> {
public static DeploymentFlavorManagerFactory getInstance() {
- return AbstractFactory.getInstance(DeploymentFlavorManagerFactory.class);
+ return getInstance(DeploymentFlavorManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class ImageManagerFactory extends AbstractComponentFactory<ImageManager> {
public static ImageManagerFactory getInstance() {
- return AbstractFactory.getInstance(ImageManagerFactory.class);
+ return getInstance(ImageManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class MonitoringUploadsManagerFactory
extends AbstractComponentFactory<MonitoringUploadsManager> {
public static MonitoringUploadsManagerFactory getInstance() {
- return AbstractFactory.getInstance(MonitoringUploadsManagerFactory.class);
+ return getInstance(MonitoringUploadsManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class NetworkManagerFactory extends AbstractComponentFactory<NetworkManager> {
public static NetworkManagerFactory getInstance() {
- return AbstractFactory.getInstance(NetworkManagerFactory.class);
+ return getInstance(NetworkManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class NicManagerFactory extends AbstractComponentFactory<NicManager> {
public static NicManagerFactory getInstance() {
- return AbstractFactory.getInstance(NicManagerFactory.class);
+ return getInstance(NicManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class OrchestrationTemplateCandidateManagerFactory
extends AbstractComponentFactory<OrchestrationTemplateCandidateManager> {
public static OrchestrationTemplateCandidateManagerFactory getInstance() {
- return AbstractFactory.getInstance(OrchestrationTemplateCandidateManagerFactory.class);
+ return getInstance(OrchestrationTemplateCandidateManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class ProcessManagerFactory extends AbstractComponentFactory<ProcessManager> {
public static ProcessManagerFactory getInstance() {
- return AbstractFactory.getInstance(ProcessManagerFactory.class);
+ return getInstance(ProcessManagerFactory.class);
}
}
package org.openecomp.sdc.vendorsoftwareproduct;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
public abstract class VspManagerFactory
extends AbstractComponentFactory<VendorSoftwareProductManager> {
public static VspManagerFactory getInstance() {
- return AbstractFactory.getInstance(VspManagerFactory.class);
+ return getInstance(VspManagerFactory.class);
}
}
package org.openecomp.core.factory.impl;
-import static org.openecomp.core.utilities.CommonMethods.newInstance;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.apache.commons.lang3.StringUtils;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.common.errors.ErrorCategory;
-import org.openecomp.sdc.common.errors.ErrorCode;
-
public abstract class AbstractFactoryBase {
- /**
- * Temporary registry of default implementations. The map keeps class names rather then class
- * types to allow unloading of those classes from memory by garbage collector if factory is not
- * actually used.
- */
- private static final Map<String, String> REGISTRY = new ConcurrentHashMap<>();
-
- /**
- * Cached factory instances.
- */
- private static final Map<String, AbstractFactoryBase> FACTORY_MAP = new ConcurrentHashMap<>();
- public static final String E0001 = "E0001";
-
- /**
- * Registers implementor for an abstract factory. The method accepts Java classes rather then
- * class names to ensure type safety at compilation time.
- *
- * @param <I> Java interface type instantiated by abstract factory
- * @param <F> Type specific abstract factory for concrete Java interface
- * @param factory Java class of a type specific abstract factory
- * @param impl Java class of type specific factory implementor
- */
- public static <I, F extends AbstractFactoryBase> void registerFactory(Class<F> factory,
- Class<? extends F> impl) {
- if (factory == null) {
- throw new CoreException(
- new ErrorCode.ErrorCodeBuilder().withId(E0001).withMessage("Mandatory input factory.")
- .withCategory(ErrorCategory.SYSTEM).build());
- }
-
- if (impl == null) {
- throw new CoreException(
- new ErrorCode.ErrorCodeBuilder().withId(E0001).withMessage("Mandatory input impl.")
- .withCategory(ErrorCategory.SYSTEM).build());
- }
- if (FACTORY_MAP.containsKey(factory.getName())) {
- FACTORY_MAP.remove(factory.getName());
- }
- REGISTRY.put(factory.getName(), impl.getName());
- } // registerFactory
-
- // TODO: Remove
- protected static void registerFactory(String factoryName, String implName) {
- REGISTRY.put(factoryName, implName);
- } // registerFactory
-
- /**
- * Unregister factory.
- *
- * @param <F> the type parameter
- * @param factory the factory
- */
- public static <F extends AbstractFactoryBase> void unregisterFactory(Class<F> factory) {
- if (factory == null) {
- throw new CoreException(
- new ErrorCode.ErrorCodeBuilder().withId(E0001).withMessage("Mandatory input factory.")
- .withCategory(ErrorCategory.SYSTEM).build());
- }
-
- FACTORY_MAP.remove(factory.getName());
- }
-
/**
* Instantiates the configured implementation of an abstract factory.
*
- * @param <I> Java interface type instantiated by abstract factory
* @param <F> Type specific abstract factory for concrete Java interface
* @param factoryType Java class of type specific abstract factory
* @return Instance of implementation class
*/
- @SuppressWarnings("unchecked")
- public static <I, F extends AbstractFactoryBase> F getInstance(Class<F> factoryType) {
- if (factoryType == null) {
- throw new CoreException(
- new ErrorCode.ErrorCodeBuilder().withId(E0001)
- .withMessage("Mandatory input factory type.").withCategory(ErrorCategory.SYSTEM)
- .build());
-
- }
- // Pick up factory instance from cache
- F factory = (F) FACTORY_MAP.get(factoryType.getName());
- // Check for the first time access
- if (factory == null) {
- // Synchronize factory instantiation
- synchronized (FACTORY_MAP) {
- // Re-check the factory instance
- factory = (F) FACTORY_MAP.get(factoryType.getName());
- if (factory == null) {
- // Get the implementation class name
- String implName = REGISTRY.get(factoryType.getName());
-
- if (StringUtils.isEmpty(implName)) {
- throw new CoreException(
- new ErrorCode.ErrorCodeBuilder().withId(E0001)
- .withMessage("Mandatory input factory implementation.")
- .withCategory(ErrorCategory.SYSTEM).build());
- }
-
- factory = newInstance(implName, factoryType);
-
- factory.init();
-
- // Cache the instantiated singleton
- FACTORY_MAP.put(factoryType.getName(), factory);
- }
- }
- }
-
- return factory;
-
- } // getInstance
-
-
- /**
- * Is factory registered boolean.
- *
- * @param <F> the type parameter
- * @param factoryType the factory type
- * @return the boolean
- */
- public static <F extends AbstractFactoryBase> boolean isFactoryRegistered(Class<F> factoryType) {
- boolean isFactoryRegistered = false;
- if (factoryType == null) {
- throw new CoreException(
- new ErrorCode.ErrorCodeBuilder().withId(E0001)
- .withMessage("Mandatory input factory type.").withCategory(ErrorCategory.SYSTEM)
- .build());
- }
- // Pick up factory instance from cache
- F factory = (F) FACTORY_MAP.get(factoryType.getName());
- // Check for the first time access
- if (factory != null) {
- isFactoryRegistered = true;
- } else {
- // Get the implementation class name
- String implName = REGISTRY.get(factoryType.getName());
- if (StringUtils.isNotEmpty(implName)) {
- isFactoryRegistered = true;
- }
- }
- return isFactoryRegistered;
- }
-
- /**
- * Stop all.
- */
- public static void stopAll() {
- Collection<AbstractFactoryBase> factorylist = FACTORY_MAP.values();
- for (AbstractFactoryBase factory : factorylist) {
- factory.stop();
- }
+ public static <F extends AbstractFactoryBase> F getInstance(Class<F> factoryType) {
+ return FactoryManager.getInstance().getFactoryInstance(factoryType);
}
protected void init() {
--- /dev/null
+/*
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2019 Nordix Foundation
+ * ================================================================================
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.core.factory.impl;
+
+import com.amdocs.zusammen.utils.facade.impl.FactoryConfig;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.apache.commons.lang3.StringUtils;
+import org.openecomp.core.utilities.CommonMethods;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+
+public class FactoryManager {
+
+ private static final FactoryManager instance = new FactoryManager();
+ private static final String ERROR_CODE_E0001 = "E0001";
+ /**
+ * Temporary registry of default implementations. The map keeps class names rather then class
+ * types to allow unloading of those classes from memory by garbage collector if factory is not
+ * actually used.
+ */
+ private final Map<String, String> factoryRegistry = new ConcurrentHashMap<>();
+ /**
+ * Cached factory instances.
+ */
+ private final Map<String, AbstractFactoryBase> factoryInstanceMap = new ConcurrentHashMap<>();
+
+
+ private FactoryManager() {
+ initializeFactoryRegistry();
+ }
+
+ public static synchronized FactoryManager getInstance() {
+ return instance;
+ }
+
+ private void initializeFactoryRegistry() {
+ final Map<String, String> factoryMap = FactoryConfig.getFactoriesMap();
+
+ for (final Map.Entry<String, String> entry : factoryMap.entrySet()) {
+ final String abstractClassName = entry.getKey();
+ final String concreteTypeName = entry.getValue();
+
+ if (StringUtils.isEmpty(concreteTypeName)) {
+ throw new CoreException(
+ new ErrorCode.ErrorCodeBuilder().withId("E0003")
+ .withMessage("Missing configuration value:" + concreteTypeName + ".")
+ .withCategory(ErrorCategory.SYSTEM).build());
+
+ }
+ registerFactory(abstractClassName, concreteTypeName);
+ }
+ }
+
+ /**
+ * Instantiates the configured implementation of an abstract factory.
+ *
+ * @param <F> Type specific abstract factory for concrete Java interface
+ * @param factoryType Java class of type specific abstract factory
+ * @return Instance of implementation class
+ */
+ @SuppressWarnings("unchecked")
+ public <F extends AbstractFactoryBase> F getFactoryInstance(Class<F> factoryType) {
+ if (factoryType == null) {
+ throw new CoreException(
+ new ErrorCode.ErrorCodeBuilder().withId(ERROR_CODE_E0001)
+ .withMessage("Mandatory input factory type.").withCategory(ErrorCategory.SYSTEM)
+ .build());
+
+ }
+ final String factoryTypeName = factoryType.getName();
+ // Check if the factory is already cached
+ if (factoryInstanceMap.get(factoryTypeName) == null) {
+ //if not, create a new one and cache it
+ // Get the implementation class name
+ final String implName = factoryRegistry.get(factoryTypeName);
+
+ if (StringUtils.isEmpty(implName)) {
+ throw new CoreException(
+ new ErrorCode.ErrorCodeBuilder().withId(ERROR_CODE_E0001)
+ .withMessage("Mandatory input factory implementation.")
+ .withCategory(ErrorCategory.SYSTEM).build());
+ }
+
+ F factory = CommonMethods.newInstance(implName, factoryType);
+ factory.init();
+ // Cache the instantiated singleton
+ factoryInstanceMap.putIfAbsent(factoryTypeName, factory);
+ }
+
+ return (F) factoryInstanceMap.get(factoryTypeName);
+ }
+
+ public void registerFactory(final String factoryName, final String implName) {
+ factoryRegistry.put(factoryName, implName);
+ }
+
+ /**
+ * Unregister factory and removes the cached instance if any.
+ * @param factoryName the factory name to unregister
+ */
+ public void unregisterFactory(final String factoryName) {
+ final String factoryClass = factoryRegistry.get(factoryName);
+ if (StringUtils.isNotEmpty(factoryClass)) {
+ factoryInstanceMap.remove(factoryClass);
+ factoryRegistry.remove(factoryName);
+ }
+ }
+
+ /**
+ * Removes the cached factory instance if any.
+ *
+ * @param <F> the type parameter
+ * @param factory the factory
+ */
+ public <F extends AbstractFactoryBase> void removeFactoryInstance(Class<F> factory) {
+ if (factory == null) {
+ throw new CoreException(
+ new ErrorCode.ErrorCodeBuilder().withId(ERROR_CODE_E0001).withMessage("Mandatory input factory.")
+ .withCategory(ErrorCategory.SYSTEM).build());
+ }
+
+ factoryInstanceMap.remove(factory.getName());
+ }
+
+ /**
+ * Stop all.
+ */
+ public void stopAll() {
+ factoryInstanceMap.values().forEach(AbstractFactoryBase::stop);
+ }
+}
public final class FactoriesConfigImpl implements FactoriesConfiguration {
+ private final Map factoryConfigurationMap = new HashMap();
- private static final String FACTORY_CONFIG_FILE_NAME = "factoryConfiguration.json";
- private static final Map FACTORY_MAP = new HashMap();
- private static boolean initialized = false;
+ public FactoriesConfigImpl() {
+ init();
+ }
@SuppressWarnings("unchecked")
@Override
public Map<String, String> getFactoriesMap() {
- synchronized (this) {
- if (!initialized) {
- init();
- initialized = true;
- }
- }
- return FACTORY_MAP;
+ return factoryConfigurationMap;
}
private void init() {
-
- List<URL> factoryConfigUrlList = FileUtils.getAllLocations(FACTORY_CONFIG_FILE_NAME);
- for (URL factoryConfigUrl : factoryConfigUrlList) {
-
+ final List<URL> factoryConfigUrlList = FileUtils.getAllLocations("factoryConfiguration.json");
+ for (final URL factoryConfigUrl : factoryConfigUrlList) {
try (InputStream stream = factoryConfigUrl.openStream()) {
- FACTORY_MAP.putAll(JsonUtil.json2Object(stream, Map.class));
- } catch (IOException e) {
+ factoryConfigurationMap.putAll(JsonUtil.json2Object(stream, Map.class));
+ } catch (final IOException e) {
throw new SdcConfigurationException("Failed to initialize Factory from '" + factoryConfigUrl.getPath() +"'", e);
}
}
package org.openecomp.core.factory;
+import java.util.Map;
import org.openecomp.core.factory.api.FactoriesConfiguration;
import org.openecomp.core.utilities.CommonMethods;
-import java.util.Map;
-
public final class FactoryConfig {
- private static final FactoriesConfiguration INSTANCE;
+ private static final FactoriesConfiguration INSTANCE = CommonMethods.newInstance(
+ "org.openecomp.core.factory.FactoriesConfigImpl", FactoriesConfiguration.class);
- static {
+ private FactoryConfig() {
- try {
- INSTANCE = CommonMethods.newInstance(
- "org.openecomp.core.factory.FactoriesConfigImpl", FactoriesConfiguration.class);
- } catch (Exception exception) {
- throw exception;
- }
}
public static Map<String, String> getFactoriesMap() {
package org.openecomp.core.factory.api;
-import org.apache.commons.lang3.StringUtils;
-import org.openecomp.core.factory.FactoryConfig;
-import org.openecomp.core.factory.impl.AbstractFactoryBase;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.common.errors.ErrorCategory;
-import org.openecomp.sdc.common.errors.ErrorCode;
-
-import java.util.Map;
-
public abstract class AbstractComponentFactory<I> extends AbstractFactory<I> {
-
- static {
- Registry registry = new RegistryImpl();
- InitializationHelper.registerFactoryMapping(registry);
- }
-
- @FunctionalInterface
- interface Registry {
- void register(String factory, String impl);
- }
-
- private static class RegistryImpl implements Registry {
- @Override
- public void register(String factory, String impl) {
- AbstractFactoryBase.registerFactory(factory, impl);
- }
- }
-
- static class InitializationHelper {
-
-
- private static boolean isRegistered = false;
-
- private InitializationHelper() {
- }
-
- static synchronized void registerFactoryMapping(Registry registry) {
- if (!isRegistered) {
- registerFactoryMappingImpl(registry);
- isRegistered = true;
- }
- }
-
- private static void registerFactoryMappingImpl(Registry registry) {
- Map<String, String> factoryMap = FactoryConfig.getFactoriesMap();
-
- for (Map.Entry<String, String> entry : factoryMap.entrySet()) {
- String abstractClassName = entry.getKey();
- String concreteTypeName = entry.getValue();
-
- if (StringUtils.isEmpty(concreteTypeName)) {
- throw new CoreException(
- new ErrorCode.ErrorCodeBuilder().withId("E0003")
- .withMessage("Missing configuration value:" + concreteTypeName + ".")
- .withCategory(ErrorCategory.SYSTEM).build());
-
- }
- registry.register(abstractClassName, concreteTypeName);
- }
- }
- }
-
}
package org.openecomp.core.utilities;
import java.lang.reflect.Array;
+import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
+import org.openecomp.core.utilities.exception.NewInstanceRuntimeException;
/**
* This class provides auxiliary static methods.
* @param cls the cls
* @return the t
*/
- public static <T> T newInstance(Class<T> cls) {
+ public static <T> T newInstance(final Class<T> cls) {
try {
- return cls.newInstance();
- } catch (InstantiationException | IllegalAccessException exception) {
- throw new RuntimeException(exception);
+ return cls.getDeclaredConstructor().newInstance();
+ } catch (final InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException ex) {
+ throw new NewInstanceRuntimeException(String.format("Could not create instance for '%s'", cls.getName())
+ , ex);
}
}
--- /dev/null
+/*
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2019 Nordix Foundation
+ * ================================================================================
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.core.utilities.exception;
+
+public class NewInstanceRuntimeException extends RuntimeException {
+
+ public NewInstanceRuntimeException(String s) {
+ super(s);
+ }
+
+ public NewInstanceRuntimeException(String s, Throwable throwable) {
+ super(s, throwable);
+ }
+}
package org.openecomp.core.translator.factory;
import org.openecomp.core.factory.api.AbstractComponentFactory;
-import org.openecomp.core.factory.api.AbstractFactory;
import org.openecomp.core.translator.api.HeatToToscaTranslator;
extends AbstractComponentFactory<HeatToToscaTranslator> {
public static HeatToToscaTranslatorFactory getInstance() {
- return AbstractFactory.getInstance(HeatToToscaTranslatorFactory.class);
+ return getInstance(HeatToToscaTranslatorFactory.class);
}
}
Code Review / sdc.git / commitdiff