@Override public <T> void registerFactory(final Factory<T> factory) { factories.put(factory.getHandle().getFactoryName(), factory); }
@Override public T newInstance() { return contextManager.getNewInstance(handle.getFactoryName()); }
private Collection<UnloadedFactory<?>> getUnloadedAsyncDependencies() { final Deque<UnloadedFactory<?>> unloadedDeps = new LinkedList<>(); final Queue<String> bfsQueue = new LinkedList<>(asyncDependencies); final Set<String> visited = new HashSet<>(); visited.add(handle.getFactoryName()); while (bfsQueue.size() > 0) { final String factoryName = bfsQueue.poll(); if (visited.contains(factoryName)) { continue; } final UnloadedFactory<?> unloadedDep = unloadedByFactoryName.get(factoryName); if (unloadedDep != null && !unloadedDep.loaded) { unloadedDeps.addFirst(unloadedDep); visited.add(factoryName); for (final String dependentFactoryName : unloadedDep.asyncDependencies) { bfsQueue.add(dependentFactoryName); } } } return unloadedDeps; }
private void initializeEagerBeans(final Collection<FactoryHandle> eager) { logger.debug("Initializing eager beans..."); final long start = System.currentTimeMillis(); if (logger.isTraceEnabled()) { for (final FactoryHandle handle : eager) { logger.trace("Initializing {}...", handle); final long beanStart = System.currentTimeMillis(); contextManager.getEagerInstance(handle.getFactoryName()); final long duration = System.currentTimeMillis() - beanStart; logger.trace("Finished initializing in {}ms.", duration); } } else { for (final FactoryHandle handle : eager) { contextManager.getEagerInstance(handle.getFactoryName()); } } final long duration = System.currentTimeMillis() - start; logger.debug("Initialized {} eager beans in {}ms.", eager.size(), duration); }
private void unregisterAsyncBean(final FactoryHandle handle) { final String name = (handle.getBeanName() != null ? handle.getBeanName() : handle.getActualType().getName()); typeNamesByName.remove(name, handle.getActualType().getName()); unloadedByFactoryName.remove(handle.getFactoryName()); for (final Class<?> assignable : handle.getAssignableTypes()) { final Iterator<UnloadedFactory<?>> unloadedIter = unloadedByTypeName.get(assignable.getName()).iterator(); while (unloadedIter.hasNext()) { final UnloadedFactory<?> unloaded = unloadedIter.next(); if (unloaded.getHandle().getFactoryName().equals(handle.getFactoryName())) { unloadedIter.remove(); break; } } } }
@Override protected void registerInstance(final Object unwrappedInstance, final Factory<?> factory) { super.registerInstance(unwrappedInstance, factory); instances.put(factory.getHandle().getFactoryName(), unwrappedInstance); }
@Override public void addContext(final Context context) { if (!contexts.contains(context)) { contexts.add(context); context.setContextManager(this); for (final Factory<?> factory : context.getAllFactories()) { contextsByFactoryName.put(factory.getHandle().getFactoryName(), context); } } }
@Override public T getInstance() { final T instance = contextManager.getInstance(handle.getFactoryName()); if (instance instanceof Proxy) { @SuppressWarnings("unchecked") final Proxy<T> proxy = (Proxy<T>) instance; // Forces bean to be loaded. proxy.unwrap(); } return instance; }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Override public void registerAsyncBean(final FactoryHandle handle, final FactoryLoader<?> future) { final String beanName; if (handle.getBeanName() != null) { beanName = handle.getBeanName(); } else { beanName = handle.getActualType().getName(); } typeNamesByName.put(beanName, handle.getActualType().getName()); final UnloadedFactory unloaded = new UnloadedFactory(handle, future); for (final Class<?> assignable : handle.getAssignableTypes()) { unloadedByTypeName.put(assignable.getName(), unloaded); } unloadedByFactoryName.put(handle.getFactoryName(), unloaded); }
@SuppressWarnings({ "rawtypes", "unchecked" }) public Collection<SyncBeanDef> lookupBeans(final String name, final boolean keepJsDups) { Assert.notNull(name); logger.debug("Looking up beans for {}", name); final Collection<FactoryHandle> handles = handlesByName.get(name); final Collection<SyncBeanDef<?>> runtimeBeanDefs = runtimeBeanDefsByName.get(name); final JsArray<JsTypeProvider<?>> jsProviders = getJsProviders(name); final Set<String> beanDefFactoryNames = new HashSet<>(); final Collection beanDefs = new ArrayList<SyncBeanDef<Object>>(handles.size()+runtimeBeanDefs.size()+jsProviders.length()); beanDefs.addAll(runtimeBeanDefs); for (final FactoryHandle handle : handles) { if (handle.isAvailableByLookup()) { beanDefs.add(new IOCBeanDefImplementation<>(handle, this.<Object>getType(name, handle, handle.getActualType()))); beanDefFactoryNames.add(handle.getFactoryName()); } } for (final JsTypeProvider<?> provider : JsArray.iterable(jsProviders)) { logger.debug("Found JS provider for name {} from factory {}", provider.getName(), provider.getFactoryName()); if (keepJsDups || provider.getFactoryName() == null || !beanDefFactoryNames.contains(provider.getFactoryName())) { logger.debug("Keeping JS provider for name {} from factory {}", provider.getName(), provider.getFactoryName()); beanDefs.add(new JsTypeBeanDefImplementation(provider, name)); } else { logger.debug("Rejecting duplicate JS provider for name {} from factory {}", provider.getName(), provider.getFactoryName()); } } logger.debug("Looked up {} beans: {}", beanDefs.size(), beanDefs); return beanDefs; }
@Override public void addFactory(final Factory<?> factory) { final Context context = getContextForScope(factory.getHandle().getScope()); context.registerFactory(factory); contextsByFactoryName.put(factory.getHandle().getFactoryName(), context); factory.init(context); }