org.openecomp.core.factory.api

Class AbstractFactory<I>

java.lang.Object

org.openecomp.core.factory.impl.AbstractFactoryBase

org.openecomp.core.factory.api.AbstractFactory<I>

Type Parameters:

I - Java interface type created by the factory.

Direct Known Subclasses:

AbstractComponentFactory

public abstract class AbstractFactory<I>
extends AbstractFactoryBase

This class provides generic implementation of an abstract factory. Components exposed as Java interfaces should have their own concrete factories derived from the given class. This assures code alignment and consistency across all Service Management components. The class actually uses singleton pattern to instantiate and reuse just one instance of a factory. Therefore, each factory implementation has to be thread-safe. In a general case, the hierarchy of factory objects for an Java interface IUknown may look as follows:

                     AbstractFactory<IUnknown>
                                ^
                                |
   Application code ----> ConcreteFactory
                                ^
                                |
                      +---------+---------+
                      |                   |
             BaselineFactoryImpl   CustomFactoryImpl
 

Where the classes responsibility is:

• Abstract factory - common logic to retrieve the implementation class name from a central repository.
• Concrete factory - abstract class that only exposes to application layer the type specific API such as:
  • public static ConcreteFactory getInstance()
• Baseline factory - out of the box implementation of concrete factory (that can be replaced by a custom one depending on customer needs) which actually implements method:
  • public IUnknown createInterface()

The normal concrete factory class may look like:

 public abstract class ConcreteFactory extends AbstractFactory<IUnknown> {
   static {
     registerFactory(ConcreteFactory.class, BaselineFactoryImpl.class);
   }
   public static ConcreteFactory getInstance() {
 return AbstractFactory.<IUnknown, ConcreteFactory.class>getInstance(ConcreteFactory.class);
   }
 }
 

Constructor Summary

Constructors

Constructor and Description
AbstractFactory()

Method Summary

Modifier and Type	Method and Description
abstract I	createInterface() Returns the interface implementor instance.

Methods inherited from class org.openecomp.core.factory.impl.AbstractFactoryBase

getInstance, init, isFactoryRegistered, registerFactory, registerFactory, stop, stopAll, unregisterFactory

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AbstractFactory

public AbstractFactory()

Method Detail

createInterface

public abstract I createInterface()

Returns the interface implementor instance. Note: It's up to the concrete factory to decide on the actual implementation of the returned interface. Therefore, the call can get the same instance per each call in case of singleton implementation or new instance otherwise. However, the API consumer may not assume anything regarding the underlying logic and has always go through the factory to obtain the reference.

Returns:

Implementor of the exposed Java interface.