{scrollbar}

Injection in Detail

Injection in Tapestry IoC can be a complicated subject for a number of reasons:

...

Some aspects of this discussion reflect Tapestry IoC used within a Tapestry web application: the tapestry-core module makes some extensions to injection.

Injection Triggers

Injection is triggered in a number of ways:

...

Injection also covers a related matter: providing special resources to a service or component. For a service, the service's id (as a string) or extensible configuration (as a Collection, List or Map) may be provided. For a component, the component's id, locale, message catalog, or component resources may be provided.

Standard Injection Processing

This section describes standard injection, which applies at the IoC layer: autobuild objects and service implementations. The steps for injection into Tapestry components are slightly different and are covered later.

...

Tapestry proceeds with this information.

Check for InjectService

Tapestry checks first for the InjectService annotation. The value of this annotation is the service id to inject. When InjectService is present at the point of injection, that process is done, though it can fail if the service id indicated does not exist, or if the service's interface is not compatible with the field's type.

Check for service resources

This step applies only to IoC layer injection (not to injection into components).

...

Service Lookup by Type and Annotations

Tapestry attempts to find a matching service.

...

• If there is a single matching service, then the value to inject as been identified.
• If there are no matches, and there were no marker annotations at the point of injection, then the Tapestry continues to the next step.
• Otherwise there were either no matches, or too many matches: Tapestry will throw a RuntimeException.

  MasterObjectProvider Lookup

This is the point at which Tapestry's extensibility comes into play. MasterObjectProvider is a service, with a configuration of ObjectProviders.

...

Value ObjectProvider

Checks for the presence of the @Value annotation. If present, then the annotations value is evaluated (to expand any symbol references), and the TypeCoercer coverts the resulting String to the injection type.

Symbol ObjectProvider

Similar to the Value ObjectProvider: the @Symbol annotation's value (if present) is lookup up and converted to the injection type.

Autobuild ObjectProvider

Checks to see if the @Autobuild annotation is present and, if so, autobuilds the value for the parameter. Of course, the object being built will itself be configured via injection.

ServiceOverride ObjectProvider

Checks any contributions to the ServiceOverride service. Contributions map a type to an object of that type. Thus, ServiceOverrides will override injections of services that are not qualified with a marker annotation.

Alias ObjectProvider (tapestry-core)

Uses the @Alias service to look for an object that can be injected.

...

This is commonly used to override a built-in service by contributing an object with the exact same interface. This is an older and more complex version of the ServiceOverride provider.

Asset ObjectProvider (tapestry-core)

Checks for the @Path annotation.

...

The TypeCoercer can then convert the Asset to the injection type, for example, as Resource.

Service ObjectProvider (tapestry-core)

Looks for the @Service annotation; if present, the annotation's value is the exact service id to inject. This is necessary because injections into component fields are always triggered by the Inject annotation.

SpringBean ObjectProvider (tapestry-spring)

Attempts to resolve a Spring bean purely by object type (Spring qualifiers are not supported). If no beans are assignable to the type, then processing continues. If exactly one is assignable, it is used as the injection value. If more than one bean is assignable, it is an error (and a list of matching beans names will be part of the thrown exception).

Service Lookup

If none of the ObjectProviders can identify the value to inject, a last step occurs: lookup by service type. If exactly one service matches the injection type, then that service is injected.

Otherwise, the lookup fails because either no services match, or more than one matches. An exception will be thrown with the details, including a list of matching services (if there is more than one match).

Post-Injection Methods

Autobuilt objects (services and the like, but not components) may have post-injection methods.

...

public class MyServiceImpl implements MyService, UpdateListener
{
  @PostInjection
  public void registerAsListener(UpdateListenerHub hub)
  {
    hub.addUpdateListener(this);
  }
}

Component Injection

Inside Tapestry components, injection occurs exclusively on fields and is always triggered by the @Inject (or @InjectService) annotation.

...

Injection is the responsibility of the InjectionProvider service, which is a chain-of-command across a number of implementations.

Block InjectionProvider

Checks if the field type is Block. If so, determines the block id to inject (either from the field name, or from an @Id annotation, if present).

Default InjectionProvider

Uses the MasterObjectProvider service to provide the injectable value. The Service Lookup stage is skipped.

ComponentResources InjectionProvider

Injects fields of type ComponentResources.

CommonResources InjectionProvider

Injects fields with common resources:

• String: the components' complete id
• org.slf4j.Logger: Logger for the component (based on component class name)
• Locale: locale for the containing page (page locale is immutable)
• Messages: Component's message catalog

Asset InjectionProvider

Triggered by the @Path annotation: the Path value has symbols expanded, and is then converted to an Asset.

Service InjectionProvider

Equivalent to the Service Lookup phase in an IoC layer injection.

@InjectService in Components

This is now supported; you may use the InjectService annotation on component fields.

...