<T> ParameterInjector<T> createParameterInjector( Key<T> key, Member member ) throws MissingDependencyException { InternalFactory<? extends T> factory = getFactory(key); if (factory == null) { throw new MissingDependencyException( "No mapping found for dependency " + key + " in " + member + "."); } ExternalContext<T> externalContext = ExternalContext.newInstance(member, key, this); return new ParameterInjector<T>(externalContext, factory); }
public T create(InternalContext context) { try { context.setExternalContext(ExternalContext.newInstance( null, key, context.getContainerImpl())); return scopedFactory.create(context); } finally { context.setExternalContext(null); } } });
/** * Maps an existing factory to a new name. * * @param type of dependency * @param name of dependency * @param alias of to the dependency * @return this builder */ public <T> ContainerBuilder alias(Class<T> type, String name, String alias) { return alias(Key.newInstance(type, name), Key.newInstance(type, alias)); }
@Inject public ClasspathPackageProvider(Container container) { this.actionConfigBuilder = container.getInstance(ActionConfigBuilder.class, container.getInstance(String.class, ConventionConstants.CONVENTION_ACTION_CONFIG_BUILDER)); }
@Inject public Struts2PlexusInSpringObjectFactory( @Inject(value=StrutsConstants.STRUTS_OBJECTFACTORY_SPRING_AUTOWIRE,required=false) String autoWire, @Inject(value=StrutsConstants.STRUTS_OBJECTFACTORY_SPRING_AUTOWIRE_ALWAYS_RESPECT,required=false) String alwaysAutoWire, @Inject(value=StrutsConstants.STRUTS_OBJECTFACTORY_SPRING_USE_CLASS_CACHE,required=false) String useClassCacheStr, @Inject ServletContext servletContext, @Inject(StrutsConstants.STRUTS_DEVMODE) String devMode, @Inject Container container) { super(autoWire, alwaysAutoWire, useClassCacheStr, servletContext, devMode, container); }
@SuppressWarnings("unchecked") public T create(Context context) { Object obj = context.getContainer().inject(implementation); return (T) obj; }
/** * @param obj */ protected Object injectInternalBeans(Object obj) { if (obj != null && container != null) { container.inject(obj); } return obj; }
@Override public void register(ContainerBuilder builder, LocatableProperties props) throws ConfigurationException { builder.factory(type, name, new Factory() { public Object create(Context context) throws Exception { return impl; } }, Scope.SINGLETON); } });
@SuppressWarnings("unchecked") public T create(InternalContext context) { if (constructor == null) { this.constructor = context.getContainerImpl().getConstructor(implementation); } return (T) constructor.construct(context, type); }
T inject( Member member, InternalContext context ) { ExternalContext<?> previous = context.getExternalContext(); context.setExternalContext(externalContext); try { return factory.create(context); } finally { context.setExternalContext(previous); } } }
/** * Maps a constant value to the given name. */ public ContainerBuilder constant(String name, int value) { return constant(int.class, name, value); }
private static Object[] getParameters( Member member, InternalContext context, ParameterInjector[] parameterInjectors ) { if (parameterInjectors == null) { return null; } Object[] parameters = new Object[parameterInjectors.length]; for ( int i = 0; i < parameters.length; i++ ) { parameters[i] = parameterInjectors[i].inject(member, context); } return parameters; }
@Inject public ClasspathConfigurationProvider(Container container) { this.actionConfigBuilder = container.getInstance(ActionConfigBuilder.class, container.getInstance(String.class, ConventionConstants.CONVENTION_ACTION_CONFIG_BUILDER)); }
/** * A helper method which allows instantiate an action if this action extends * {@link com.opensymphony.xwork2.ActionSupport} or any other action class * that requires framework's dependencies injection. */ protected <T> T createAction(Class<T> clazz) { return container.inject(clazz); }
@Override public void register(ContainerBuilder builder, LocatableProperties props) throws ConfigurationException { builder.factory(type, name, new Factory() { public Object create(Context context) throws Exception { return impl; } }, Scope.SINGLETON); } });
/** * Maps a constant value to the given name. */ public ContainerBuilder constant(String name, boolean value) { return constant(boolean.class, name, value); }
/** * Convenience method. Equivalent to {@code factory(type, * Container.DEFAULT_NAME, implementation)}. * * @see #factory(Class, String, Class) */ public <T> ContainerBuilder factory(Class<T> type, Class<? extends T> implementation) { return factory(type, Container.DEFAULT_NAME, implementation); }
/** * Convenience method. Equivalent to {@code factory(type, * Container.DEFAULT_NAME, implementation, scope)}. * * @see #factory(Class, String, Class, Scope) */ public <T> ContainerBuilder factory(Class<T> type, Class<? extends T> implementation, Scope scope) { return factory(type, Container.DEFAULT_NAME, implementation, scope); }
/** * Convenience method. Equivalent to {@code factory(type, * Container.DEFAULT_NAME, type, scope)}. * * @see #factory(Class, String, Class, Scope) */ public <T> ContainerBuilder factory(Class<T> type, Scope scope) { return factory(type, Container.DEFAULT_NAME, type, scope); }