Java - 服务提供者的实现

在C＃中，我有以下“模式”（不是真正意义上的DP），但我倾向于在我的解决方案中使用它，其目标是实现对象实现的中心点提供基于接口（某种工厂）。Java - 服务提供者的实现

它以单身形式访问，用户请求给定接口的实现并返回适当的实现。

我的目标是将其迁移到Java。我有两个函数原型解决方案，但我不是很满意的结果，因为他们（更强大的&复杂）之一，我不得不把很多抽象的实例化机制的顶部，由于Java的泛型的局限性和其他尽管简单也不那么强大（它甚至不能利用泛型 - 在我的使用情况下可能是hany）。。

我想用它在Java中通过以下方式注册新的实现：

ServiceFactory.getInstance（）addService（IMyInterface.class，新MyImplementation（））;

（其中MyImplementations实现IMyInterface）。

沿用了原先的C＃版本和两个Java版本：

C＃代码

public class ObjectProvider<ObjectType, BaseObjectType> : IObjectProvider<BaseObjectType> 
    where ObjectType : BaseObjectType, new() 
{ 

    public BaseObjectType ObjectInstance 
    { 
    get { return (BaseObjectType)new ObjectType(); } 
    } 
} 

public class ServiceManager 
{ 
    private static Dictionary<Type, object> _providersList = null; 
    private static object _listLocker = new object(); 

    private ServiceManager() { } 

    private static void InicializeProvidersList() 
    { 
    _providersList = new Dictionary<Type, object>(); 

    _providersList.Add(typeof(IMyType), new ObjectProvider<MyImplementation, IMyType>()); 
     ... 
    } 

    private static Dictionary<Type, object> ProvidersList 
    { 
    get 
     { 
      lock (_listLocker) 
      { 
       if (_providersList == null) 
        InicializeProvidersList(); 
       return _providersList; 
      } 
     } 
    } 

    public static BusinessType GetBusinessClass<BusinessType>() 
    { 
     Dictionary<Type, object> list = ProvidersList; 
     Type pretendedType = typeof(BusinessType); 
     if (!list.ContainsKey(pretendedType)) 
      return default(BusinessType); 
     IObjectProvider<BusinessType> provider = list[pretendedType] as IObjectProvider<BusinessType>; 
     return provider.ObjectInstance; 
    } 
}

的Java（更强大的解决方案）的代码，

public interface IInstantiator 
{ 
    <BaseObjectType> BaseObjectType getInstance(Object... args); 
    void setCacheable(boolean value); 
} 

public abstract class BaseInstantiator <BaseObjectType, ObjectType extends BaseObjectType> implements IInstantiator 
{ 
    protected Class<ObjectType> objectType; 
    protected boolean isCacheable = true; 
    protected BaseObjectType cache; 

    public BaseInstantiator(Class<ObjectType> objectType) 
    { 
    this.objectType = objectType; 
    } 

    public void setCacheable(boolean value) 
    { 
    this.isCacheable = value; 
    } 

    @SuppressWarnings("unchecked") 
    public final BaseObjectType getInstance(Object... args) 
    { 
    if(isCacheable && cache != null) 
    { 
     return cache; 
    } 
    else 
    { 
     BaseObjectType objectType = createInstance(args); 

     if(isCacheable) 
     { 
      cache = objectType; 
     } 

     return objectType; 
    } 
    } 

    protected abstract BaseObjectType createInstance(Object... args); 
} 

public class Instantiator <BaseObjectType, ObjectType extends BaseObjectType> extends  BaseInstantiator <BaseObjectType, ObjectType> 
{ 

    public Instantiator(Class<ObjectType> ot) 
    { 
    super(ot); 
    } 

    @Override 
    protected BaseObjectType createInstance(Object... args) 
    { 
    try 
    { 
     return objectType.newInstance(); 
    } 
    catch (InstantiationException e) 
    { 
     e.printStackTrace(); 
    } 
    catch (IllegalAccessException e) 
    { 
     e.printStackTrace(); 
    } 

    return null; 
    } 
} 


public class ServiceFactory 
{ 
    private HashMap<Class, IInstantiator> services; 
    private static ServiceFactory instance; 

    public <BaseObjectType> void addService(Class<BaseObjectType> baseObjectType, IInstantiator instantiator) 
    { 
    this.getServices().put(baseObjectType, instantiator); 
    } 

    @SuppressWarnings("unchecked") 
    public <BaseObjectType> BaseObjectType getService(Class<BaseObjectType> baseObjectType, Object... args) 
    { 

    if(! getServices().containsKey(baseObjectType)) 
    { 
     throw new NoSuchElementException("Unknown service interface!"); 
    } 
    else 
    { 
     try 
     { 
      return (BaseObjectType) getServices().get(baseObjectType).getInstance(args); 
     } 
     catch (Exception e) 
     { 
      return null; 
     } 
    } 
    } 

    private ServiceFactory() { } 

    public static synchronized ServiceFactory getInstance() 
    { 

    if(ServiceFactory.instance == null) 
    { 
     ServiceFactory.instance = new ServiceFactory(); 
     populate(); 
    } 

    return ServiceFactory.instance; 
    } 

    private static void populate() 
    { 
     //... 
    } 

    private HashMap<Class, IInstantiator> getServices() 
    { 

    if(this.services == null) 
    { 
     this.services = new HashMap<Class, IInstantiator>(); 
    } 

    return this.services; 
    } 
}

爪哇（更简单和不太强大的解决方案）

@SuppressWarnings("rawtypes") 
public class ManagerFactory 
{ 
    private Map<Class, Object> managers; 

    private ManagerFactory() 
    { 
    populateFactory(); 
    } 

    private static class SingletonHolder 
    { 
    public static final ManagerFactory INSTANCE = new ManagerFactory(); 
    } 

    public static ManagerFactory getInstance() 
    { 
    return SingletonHolder.INSTANCE; 
    } 

    private void populateFactory() 
    { 
    this.managers = new HashMap<Class, Object>(); 

    this.managers.put(ITaskManager.class, new TaskManager()); 
    } 

    public Object getManager(Class interfaceClass) 
    { 
    if(this.managers.containsKey(interfaceClass)) 
     return this.managers.get(interfaceClass); 
    else 
     return null; 
    } 
}

任何人都可以提供在这一个帮助？

在此先感谢！

来源

2012-03-06 Diesel Heart