/** {@inheritDoc} */ @Override public void start() { startComponents(); }
/** {@inheritDoc} */ @Override public void stop() { stopComponents(); clear(); }
/** {@inheritDoc} */ @Override public Set<String> keySet() { return container.keySet(); }
@Test public final void testUnwrapp() { final AopPlugin aopPlugin = getApp().getConfig().getBootConfig().getAopPlugin(); final F f = getApp().getComponentSpace().resolve(F.class); // Il y a des aspects sur la classe donc elle doit être dewrappable assertNotEquals(F.class.getName(), f.getClass().getName()); assertEquals(F.class.getName(), aopPlugin.unwrap(f).getClass().getName()); // Il y a pas d'aspect final A myA = getApp().getComponentSpace().resolve(A.class); assertEquals(A.class.getName(), myA.getClass().getName()); assertEquals(A.class.getName(), aopPlugin.unwrap(myA).getClass().getName()); }
@Test public void testProxyWithObjectInterface() { c = getApp().getComponentSpace().resolve("c", C.class); assertTrue(c.isInitialized()); assertFalse(c.isFinalized()); }
@Test public void testProxyWithInterfaceMyException() { Assertions.assertThrows(MyException.class, () -> { b = getApp().getComponentSpace().resolve("b", B.class); b.throwMyException(); }); } }
/** * Resolve a component from its class. * @param componentClass Type of the component * @return Component */ default <C> C resolve(final Class<C> componentClass) { final String normalizedId = StringUtil.first2LowerCase(componentClass.getSimpleName()); return resolve(normalizedId, componentClass); } }
private void testBioManager(final AppConfig appConfig) { try (AutoCloseableApp app = new AutoCloseableApp(appConfig)) { assertEquals(app, app); assertTrue(app.getComponentSpace().contains("bioManager")); final BioManager bioManager = app.getComponentSpace().resolve(BioManager.class); final int res = bioManager.add(1, 2, 3); assertEquals(366, res); assertTrue(bioManager.isActive()); } } }
private <C extends Component> C injectAspects(final C instance, final Class implClass) { //2. AOP , a new instance is created when aspects are injected in the previous instance final Map<Method, List<Aspect>> joinPoints = ComponentAspectUtil.createAspectsByMethod(implClass, aspects); if (!joinPoints.isEmpty()) { return aopPlugin.wrap(instance, joinPoints); } return instance; }
/** {@inheritDoc} */ @Override public <O> O resolve(final String id, final Class<O> clazz) { Assertion.checkNotNull(id); Assertion.checkNotNull(clazz); //----- if (container1.contains(id)) { return container1.resolve(id, clazz); } if (container2.contains(id)) { return container2.resolve(id, clazz); } throw new VSystemException("component info with id '{0}' not found.", id); }
/** {@inheritDoc} */ @Override public <C> C resolve(final String id, final Class<C> componentClass) { final String normalizedId = StringUtil.first2LowerCase(id); Assertion.checkArgument(contains(normalizedId), "Aucun composant enregistré pour id = {0} parmi {1}", normalizedId, keySet()); //----- return componentClass.cast(components.get(normalizedId)); }
/** {@inheritDoc} */ @Override public boolean contains(final String id) { return container.contains(id); }
/** {@inheritDoc} */ @Override public <O> O resolve(final String id, final Class<O> componentClass) { final O result = container.resolve(id, componentClass); usedKeys.add(id); return result; }
private static void stopComponent(final Component component) { if (component instanceof Activeable) { Activeable.class.cast(component).stop(); } }
private static void startComponent(final Component component) { if (component instanceof Activeable) { Activeable.class.cast(component).start(); } }
private void startComponents() { for (final Component component : components.values()) { startedComponents.add(component); startComponent(component); } }
private void appStop() { componentSpaceWritable.stop(); definitionSpaceWritable.clear(); }
private void stopComponents() { /* Fermeture de tous les gestionnaires.*/ //On fait les fermetures dans l'ordre inverse des enregistrements. //On se limite aux composants qui ont été démarrés. final List<Component> reversedComponents = new ArrayList<>(startedComponents); java.util.Collections.reverse(reversedComponents); for (final Component component : reversedComponents) { try { stopComponent(component); } catch (final Exception e) { LOGGER.error("Failed stopping component " + component, e); } } }
@Test public void testInjectPluginsConstructorOrder() { final AppConfig appConfig = createHomeWithInjectPluginsConstructor(false); try (AutoCloseableApp app = new AutoCloseableApp(appConfig)) { final FunctionManager functionManager = app.getComponentSpace().resolve(FunctionManager.class); assertEquals(26, functionManager.computeAll(3)); } }
ComponentDualContainer(final Container container1, final Container container2) { Assertion.checkNotNull(container1); Assertion.checkNotNull(container2); //----- this.container1 = container1; this.container2 = container2; ids = new LinkedHashSet<>(); ids.addAll(container1.keySet()); ids.addAll(container2.keySet()); Assertion.checkArgument(ids.size() == container1.keySet().size() + container2.keySet().size(), "Ambiguité : il y a des ids en doublon"); }