SeamFramework.org Community Documentation

- Prev
- Next

## Chapter 32. Seam annotations

When you write a Seam application, you'll use a lot of annotations. Seam lets you use annotations to achieve a declarative style of programming. Most of the annotations you'll use are defined by the EJB 3.0 specification. The annotations for data validation are defined by the Bean Validation standard. Finally, Seam defines its own set of annotations, which we'll describe in this chapter.

All of these annotations are defined in the package `org.jboss.seam.annotations`.

## 32.1. Annotations for component definition

The first group of annotations lets you define a Seam component. These annotations appear on the component class.

`@Name`

      @Name("componentName")

  Defines the Seam component name for a class. This annotation is required for all Seam components.

`@Scope`

      @Scope(ScopeType.CONVERSATION)

  Defines the default context of the component. The possible values are defined by the `ScopeType` enumeration: `EVENT, PAGE, CONVERSATION, SESSION, BUSINESS_PROCESS, APPLICATION, STATELESS`.

  When no scope is explicitly specified, the default depends upon the component type. For stateless session beans, the default is `STATELESS`. For entity beans and stateful session beans, the default is `CONVERSATION`. For JavaBeans, the default is `EVENT`.

`@Role`

      @Role(name="roleName", scope=ScopeType.SESSION)

  Allows a Seam component to be bound to multiple contexts variables. The `@Name`/`@Scope` annotations define a "default role". Each `@Role` annotation defines an additional role.

  - `name` — the context variable name.

  - `scope` — the context variable scope. When no scope is explicitly specified, the default depends upon the component type, as above.

`@Roles`

      @Roles({

              @Role(name="user", scope=ScopeType.CONVERSATION),

              @Role(name="currentUser", scope=ScopeType.SESSION)

         })

  Allows specification of multiple additional roles.

`@BypassInterceptors`

      @BypassInterceptors

  Disables Seam all interceptors on a particular component or method of a component.

`@JndiName`

      @JndiName("my/jndi/name")

  Specifies the JNDI name that Seam will use to look up the EJB component. If no JNDI name is explicitly specified, Seam will use the JNDI pattern specified by `org.jboss.seam.core.init.jndiPattern`.

`@Conversational`

      @Conversational

  Specifies that a conversation scope component is conversational, meaning that no method of the component may be called unless a long-running conversation is active.

`@PerNestedConversation`

      @PerNestedConversation

  Limits the scope of a CONVERSATION-scoped component to just the parent conversation in which it was instantiated. The component instance will not be visible to nested child conversations, which will get their own instance.

  Warning: this is ill-defined, since it implies that a component will be visible for some part of a request cycle, and invisible after that. It is not recommended that applications use this feature!

`@Startup`

      @Scope(APPLICATION) @Startup(depends="org.jboss.seam.bpm.jbpm")

  Specifies that an application scope component is started immediately at initialization time. This is mainly used for certain built-in components that bootstrap critical infrastructure such as JNDI, datasources, etc.

      @Scope(SESSION) @Startup

  Specifies that a session scope component is started immediately at session creation time.

  - `depends` — specifies that the named components must be started first, if they are installed.

`@Install`

      @Install(false)

  Specifies whether or not a component should be installed by default. The lack of an `@Install` annotation indicates a component should be installed.

      @Install(dependencies="org.jboss.seam.bpm.jbpm")

  Specifies that a component should only be stalled if the components listed as dependencies are also installed.

      @Install(genericDependencies=ManagedQueueSender.class)

  Specifies that a component should only be installed if a component that is implemented by a certain class is installed. This is useful when the dependency doesn't have a single well-known name.

      @Install(classDependencies="org.hibernate.Session")

  Specifies that a component should only be installed if the named class is in the classpath.

      @Install(precedence=BUILT_IN)

  Specifies the precedence of the component. If multiple components with the same name exist, the one with the higher precedence will be installed. The defined precedence values are (in ascending order):

  - `BUILT_IN` — Precedence of all built-in Seam components

  - `FRAMEWORK` — Precedence to use for components of frameworks which extend Seam

  - `APPLICATION` — Precedence of application components (the default precedence)

  - `DEPLOYMENT` — Precedence to use for components which override application components in a particular deployment

  - `MOCK` — Precedence for mock objects used in testing

`@Synchronized`

      @Synchronized(timeout=1000)

  Specifies that a component is accessed concurrently by multiple clients, and that Seam should serialize requests. If a request is not able to obtain its lock on the component in the given timeout period, an exception will be raised.

`@ReadOnly`

      @ReadOnly

  Specifies that a JavaBean component or component method does not require state replication at the end of the invocation.

`@AutoCreate`

      @AutoCreate

  Specifies that a component will be automatically created, even if the client does not specify `create=true`.

## 32.2. Annotations for bijection

The next two annotations control bijection. These attributes occur on component instance variables or property accessor methods.

`@In`

      @In

  Specifies that a component attribute is to be injected from a context variable at the beginning of each component invocation. If the context variable is null, an exception will be thrown.

      @In(required=false)

  Specifies that a component attribute is to be injected from a context variable at the beginning of each component invocation. The context variable may be null.

      @In(create=true)

  Specifies that a component attribute is to be injected from a context variable at the beginning of each component invocation. If the context variable is null, an instance of the component is instantiated by Seam.

      @In(value="contextVariableName")

  Specifies the name of the context variable explicitly, instead of using the annotated instance variable name.

      @In(value="#{customer.addresses['shipping']}")

  Specifies that a component attribute is to be injected by evaluating a JSF EL expression at the beginning of each component invocation.

  - `value` — specifies the name of the context variable. Default to the name of the component attribute. Alternatively, specifies a JSF EL expression, surrounded by `#{...}`.

  - `create` — specifies that Seam should instantiate the component with the same name as the context variable if the context variable is undefined (null) in all contexts. Default to false.

  - `required` — specifies Seam should throw an exception if the context variable is undefined in all contexts.

`@Out`

      @Out

  Specifies that a component attribute that is a Seam component is to be outjected to its context variable at the end of the invocation. If the attribute is null, an exception is thrown.

      @Out(required=false)

  Specifies that a component attribute that is a Seam component is to be outjected to its context variable at the end of the invocation. The attribute may be null.

      @Out(scope=ScopeType.SESSION)

  Specifies that a component attribute that is not a Seam component type is to be outjected to a specific scope at the end of the invocation.

  Alternatively, if no scope is explicitly specified, the scope of the component with the `@Out` attribute is used (or the `EVENT` scope if the component is stateless).

      @Out(value="contextVariableName")

  Specifies the name of the context variable explicitly, instead of using the annotated instance variable name.

  - `value` — specifies the name of the context variable. Default to the name of the component attribute.

  - `required` — specifies Seam should throw an exception if the component attribute is null during outjection.

Note that it is quite common for these annotations to occur together, for example:

    @In(create=true) @Out private User currentUser;

The next annotation supports the manager component pattern; a Seam component manages the lifecycle of an instance of some other class that is to be injected. It appears on a component getter method.

`@Unwrap`

      @Unwrap

  Specifies that the object returned by the annotated getter method is the thing that is injected instead of the component instance itself.

The next annotation supports the factory component pattern; a Seam component is responsible for initializing the value of a context variable. This is especially useful for initializing any state needed for rendering the response to a non-faces request. It appears on a component method.

`@Factory`

      @Factory("processInstance") public void createProcessInstance() { ... }

  Specifies that the method of the component is used to initialize the value of the named context variable, when the context variable has no value. This style is used with methods that return `void`.

      @Factory("processInstance", scope=CONVERSATION) public ProcessInstance createProcessInstance() { ... }

  Specifies that the method returns a value that Seam should use to initialize the value of the named context variable, when the context variable has no value. This style is used with methods that return a value. If no scope is explicitly specified, the scope of the component with the `@Factory` method is used (unless the component is stateless, in which case the `EVENT` context is used).

  - `value` — specifies the name of the context variable. If the method is a getter method, default to the JavaBeans property name.

  - `scope` — specifies the scope that Seam should bind the returned value to. Only meaningful for factory methods which return a value.

  - `autoCreate` — specifies that this factory method should be automatically called whenever the variable is asked for, even if `@In` does not specify `create=true`.

This annotation lets you inject a `Log`:

`@Logger`

      @Logger("categoryName")

  Specifies that a component field is to be injected with an instance of `org.jboss.seam.log.Log`. For entity beans, the field must be declared as static.

  - `value` — specifies the name of the log category. Default to the name of the component class.

The last annotation lets you inject a request parameter value:

`@RequestParameter`

      @RequestParameter("parameterName")

  Specifies that a component attribute is to be injected with the value of a request parameter. Basic type conversions are performed automatically.

  - `value` — specifies the name of the request parameter. Default to the name of the component attribute.

## 32.3. Annotations for component lifecycle methods

These annotations allow a component to react to its own lifecycle events. They occur on methods of the component. There may be only one of each per component class.

`@Create`

      @Create

  Specifies that the method should be called when an instance of the component is instantiated by Seam. Note that create methods are only supported for JavaBeans and stateful session beans.

`@Destroy`

      @Destroy

  Specifies that the method should be called when the context ends and its context variables are destroyed. Note that destroy methods are only supported for JavaBeans and stateful session beans.

  Destroy methods should be used only for cleanup. Seam catches, logs and swallows any exception that propagates out of a destroy method.

`@Observer`

      @Observer("somethingChanged")

  Specifies that the method should be called when a component-driven event of the specified type occurs.

      @Observer(value="somethingChanged",create=false)

  Specifies that the method should be called when an event of the specified type occurs but that an instance should not be created if one doesn't exist. If an instance does not exist and create is false, the event will not be observed. The default value for create is true.

## 32.4. Annotations for context demarcation

These annotations provide declarative conversation demarcation. They appear on methods of Seam components, usually action listener methods.

Every web request has a conversation context associated with it. Most of these conversations end at the end of the request. If you want a conversation that span multiple requests, you must "promote" the current conversation to a long-running conversation by calling a method marked with `@Begin`.

`@Begin`

      @Begin

  Specifies that a long-running conversation begins when this method returns a non-null outcome without exception.

      @Begin(join=true)

  Specifies that if a long-running conversation is already in progress, the conversation context is simply propagated.

      @Begin(nested=true)

  Specifies that if a long-running conversation is already in progress, a new nested conversation context begins. The nested conversation will end when the next `@End` is encountered, and the outer conversation will resume. It is perfectly legal for multiple nested conversations to exist concurrently in the same outer conversation.

      @Begin(pageflow="process definition name")

  Specifies a jBPM process definition name that defines the pageflow for this conversation.

      @Begin(flushMode=FlushModeType.MANUAL)

  Specify the flush mode of any Seam-managed persistence contexts. `flushMode=FlushModeType.MANUAL` supports the use of atomic conversations where all write operations are queued in the conversation context until an explicit call to `flush()` (which usually occurs at the end of the conversation).

  - `join` — determines the behavior when a long-running conversation is already in progress. If `true`, the context is propagated. If `false`, an exception is thrown. Default to `false`. This setting is ignored when `nested=true` is specified.

  - `nested` — specifies that a nested conversation should be started if a long-running conversation is already in progress.

  - `flushMode` — set the flush mode of any Seam-managed Hibernate sessions or JPA persistence contexts that are created during this conversation.

  - `pageflow` — a process definition name of a jBPM process definition deployed via `org.jboss.seam.bpm.jbpm.pageflowDefinitions.`

`@End`

      @End

  Specifies that a long-running conversation ends when this method returns a non-null outcome without exception.

  - `beforeRedirect` — by default, the conversation will not actually be destroyed until after any redirect has occurred. Setting `beforeRedirect=true` specifies that the conversation should be destroyed at the end of the current request, and that the redirect will be processed in a new temporary conversation context.

  - `root` — by default, ending a nested conversation simply pops the conversation stack and resumes the outer conversation. Setting `root=true` specifies that the root conversation should be destroyed which effectively destroys the entire conversation stack. If the conversation is not nested, the current conversation is simply ended.

`@StartTask`

      @StartTask

  "Starts" a jBPM task. Specifies that a long-running conversation begins when this method returns a non-null outcome without exception. This conversation is associated with the jBPM task specified in the named request parameter. Within the context of this conversation, a business process context is also defined, for the business process instance of the task instance.

  - The jBPM `TaskInstance` will be available in a request context variable named `taskInstance`. The jBPM `ProcessInstance` will be available in a request context variable named `processInstance`. (Of course, these objects are available for injection via `@In`.)

  - `taskIdParameter` — the name of a request parameter which holds the id of the task. Default to `"taskId"`, which is also the default used by the Seam `taskList` JSF component.

  - `flushMode` — set the flush mode of any Seam-managed Hibernate sessions or JPA persistence contexts that are created during this conversation.

`@BeginTask`

      @BeginTask

  Resumes work on an incomplete jBPM task. Specifies that a long-running conversation begins when this method returns a non-null outcome without exception. This conversation is associated with the jBPM task specified in the named request parameter. Within the context of this conversation, a business process context is also defined, for the business process instance of the task instance.

  - The jBPM `org.jbpm.taskmgmt.exe.TaskInstance` will be available in a request context variable named `taskInstance`. The jBPM `org.jbpm.graph.exe.ProcessInstance` will be available in a request context variable named `processInstance`.

  - `taskIdParameter` — the name of a request parameter which holds the id of the task. Default to `"taskId"`, which is also the default used by the Seam `taskList` JSF component.

  - `flushMode` — set the flush mode of any Seam-managed Hibernate sessions or JPA persistence contexts that are created during this conversation.

`@EndTask`

      @EndTask

  "Ends" a jBPM task. Specifies that a long-running conversation ends when this method returns a non-null outcome, and that the current task is complete. Triggers a jBPM transition. The actual transition triggered will be the default transition unless the application has called `Transition.setName()` on the built-in component named `transition`.

      @EndTask(transition="transitionName")

  Triggers the given jBPM transition.

  - `transition` — the name of the jBPM transition to be triggered when ending the task. Defaults to the default transition.

  - `beforeRedirect` — by default, the conversation will not actually be destroyed until after any redirect has occurred. Setting `beforeRedirect=true` specifies that the conversation should be destroyed at the end of the current request, and that the redirect will be processed in a new temporary conversation context.

`@CreateProcess`

      @CreateProcess(definition="process definition name")

  Creates a new jBPM process instance when the method returns a non-null outcome without exception. The `ProcessInstance` object will be available in a context variable named `processInstance`.

  - `definition` — the name of the jBPM process definition deployed via `org.jboss.seam.bpm.jbpm.processDefinitions`.

`@ResumeProcess`

      @ResumeProcess(processIdParameter="processId")

  Re-enters the scope of an existing jBPM process instance when the method returns a non-null outcome without exception. The `ProcessInstance` object will be available in a context variable named `processInstance`.

  - `processIdParameter` — the name a request parameter holding the process id. Default to `"processId"`.

`@Transition`

      @Transition("cancel")

  Marks a method as signaling a transition in the current jBPM process instance whenever the method returns a non-null result.

## 32.5. Annotations for use with Seam JavaBean components in a J2EE environment

Seam provides an annotation that lets you force a rollback of the JTA transaction for certain action listener outcomes.

`@Transactional`

      @Transactional

  Specifies that a JavaBean component should have a similar transactional behavior to the default behavior of a session bean component. ie. method invocations should take place in a transaction, and if no transaction exists when the method is called, a transaction will be started just for that method. This annotation may be applied at either class or method level.

  Do not use this annotation on EJB 3.0 components, use `@TransactionAttribute`!

`@ApplicationException`

      @ApplicationException

  Synonym for javax.ejb.ApplicationException, for use in a pre Java EE 5 environment. Applied to an exception to denote that it is an application exception and should be reported to the client directly(i.e., unwrapped).

  Do not use this annotation on EJB 3.0 components, use `@javax.ejb.ApplicationException` instead.

  - `rollback` — by default `false`, if `true` this exception should set the transaction to rollback only

  - `end` — by default `false`, if `true` this exception should end the current long-running conversation

`@Interceptors`

      @Interceptors({DVDInterceptor, CDInterceptor})

  Synonym for javax.interceptors.Interceptors, for use in a pre Java EE 5 environment. Note that this may only be used as a meta-annotation. Declares an ordered list of interceptors for a class or method.

  Do not use this annotations on EJB 3.0 components, use `@javax.interceptor.Interceptors` instead.

These annotations are mostly useful for JavaBean Seam components. If you use EJB 3.0 components, you should use the standard Java EE5 annotation.

## 32.6. Annotations for exceptions

These annotations let you specify how Seam should handle an exception that propagates out of a Seam component.

`@Redirect`

      @Redirect(viewId="error.jsp")

  Specifies that the annotated exception causes a browser redirect to a specified view id.

  - `viewId` — specifies the JSF view id to redirect to. You can use EL here.

  - `message` — a message to be displayed, default to the exception message.

  - `end` — specifies that the long-running conversation should end, default to `false`.

`@HttpError`

      @HttpError(errorCode=404)

  Specifies that the annotated exception causes a HTTP error to be sent.

  - `errorCode` — the HTTP error code, default to `500`.

  - `message` — a message to be sent with the HTTP error, default to the exception message.

  - `end` — specifies that the long-running conversation should end, default to `false`.

## 32.7. Annotations for Seam Remoting

Seam Remoting requires that the local interface of a session bean be annotated with the following annotation:

`@WebRemote`

      @WebRemote(exclude="path.to.exclude")

  Indicates that the annotated method may be called from client-side JavaScript. The `exclude` property is optional and allows objects to be excluded from the result's object graph (see the Chapter 26, Remoting chapter for more details).

## 32.8. Annotations for Seam interceptors

The following annotations appear on Seam interceptor classes.

Please refer to the documentation for the EJB 3.0 specification for information about the annotations required for EJB interceptor definition.

`@Interceptor`

      @Interceptor(stateless=true)

  Specifies that this interceptor is stateless and Seam may optimize replication.

      @Interceptor(type=CLIENT)

  Specifies that this interceptor is a "client-side" interceptor that is called before the EJB container.

      @Interceptor(around={SomeInterceptor.class, OtherInterceptor.class})

  Specifies that this interceptor is positioned higher in the stack than the given interceptors.

      @Interceptor(within={SomeInterceptor.class, OtherInterceptor.class})

  Specifies that this interceptor is positioned deeper in the stack than the given interceptors.

## 32.9. Annotations for asynchronicity

The following annotations are used to declare an asynchronous method, for example:

    @Asynchronous public void scheduleAlert(Alert alert, @Expiration Date date) { ... }

    @Asynchronous public Timer scheduleAlerts(Alert alert,

       @Expiration Date date,

       @IntervalDuration long interval) { ... }

`@Asynchronous`

      @Asynchronous

  Specifies that the method call is processed asynchronously.

`@Duration`

      @Duration

  Specifies that a parameter of the asynchronous call is the duration before the call is processed (or first processed for recurring calls).

`@Expiration`

      @Expiration

  Specifies that a parameter of the asynchronous call is the datetime at which the call is processed (or first processed for recurring calls).

`@IntervalDuration`

      @IntervalDuration

  Specifies that an asynchronous method call recurs, and that the annotation parameter is duration between recurrences.

## 32.10. Annotations for use with JSF

The following annotations make working with JSF easier.

`@Converter`

  Allows a Seam component to act as a JSF converter. The annotated class must be a Seam component, and must implement `javax.faces.convert.Converter`.

  - `id` — the JSF converter id. Defaults to the component name.

  - `forClass` — if specified, register this component as the default converter for a type.

`@Validator`

  Allows a Seam component to act as a JSF validator. The annotated class must be a Seam component, and must implement `javax.faces.validator.Validator`.

  - `id` — the JSF validator id. Defaults to the component name.

### 32.10.1. Annotations for use with `dataTable`

The following annotations make it easy to implement clickable lists backed by a stateful session bean. They appear on attributes.

`@DataModel`

      @DataModel("variableName")

  Outjects a property of type `List`, `Map`, `Set` or `Object[]` as a JSF `DataModel` into the scope of the owning component (or the `EVENT` scope if the owning component is `STATELESS`). In the case of `Map`, each row of the `DataModel` is a `Map.Entry`.

  - `value` — name of the conversation context variable. Default to the attribute name.

  - `scope` — if `scope=ScopeType.PAGE` is explicitly specified, the `DataModel` will be kept in the `PAGE` context.

`@DataModelSelection`

      @DataModelSelection

  Injects the selected value from the JSF `DataModel` (this is the element of the underlying collection, or the map value). If only one `@DataModel` attribute is defined for a component, the selected value from that `DataModel` will be injected. Otherwise, the component name of each `@DataModel` must be specified in the value attribute for each `@DataModelSelection`.

  If `PAGE` scope is specified on the associated `@DataModel`, then, in addition to the DataModel Selection being injected, the associated DataModel will also be injected. In this case, if the property annotated with `@DataModel` is a getter method, then a setter method for the property must also be part of the Business API of the containing Seam Component.

  - `value` — name of the conversation context variable. Not needed if there is exactly one `@DataModel` in the component.

`@DataModelSelectionIndex`

      @DataModelSelectionIndex

  Exposes the selection index of the JSF `DataModel` as an attribute of the component (this is the row number of the underlying collection, or the map key). If only one `@DataModel` attribute is defined for a component, the selected value from that `DataModel` will be injected. Otherwise, the component name of each `@DataModel` must be specified in the value attribute for each `@DataModelSelectionIndex`.

  - `value` — name of the conversation context variable. Not needed if there is exactly one `@DataModel` in the component.

## 32.11. Meta-annotations for databinding

These meta-annotations make it possible to implement similar functionality to `@DataModel` and `@DataModelSelection` for other datastructures apart from lists.

`@DataBinderClass`

      @DataBinderClass(DataModelBinder.class)

  Specifies that an annotation is a databinding annotation.

`@DataSelectorClass`

      @DataSelectorClass(DataModelSelector.class)

  Specifies that an annotation is a dataselection annotation.

## 32.12. Annotations for packaging

This annotation provides a mechanism for declaring information about a set of components that are packaged together. It can be applied to any Java package.

`@Namespace`

      @Namespace(value="http://jboss.org/schema/seam/example/seampay")

  Specifies that components in the current package are associated with the given namespace. The declared namespace can be used as an XML namespace in a `components.xml` file to simplify application configuration.

      @Namespace(value="http://jboss.org/schema/seam/core", prefix="org.jboss.seam.core")

  Specifies a namespace to associate with a given package. Additionally, it specifies a component name prefix to be applied to component names specified in the XML file. For example, an XML element named `init` that is associated with this namespace would be understood to actually refer to a component named `org.jboss.seam.core.init`.

## 32.13. Annotations for integrating with the servlet container

These annotations allow you to integrate your Seam components with the servlet container.

`@Filter`

  Use the Seam component (which implements `javax.servlet.Filter`) annotated with `@Filter` as a servlet filter. It will be executed by Seam's master filter.

  -     @Filter(around={"seamComponent", "otherSeamComponent"})

    Specifies that this filter is positioned higher in the stack than the given filters.

  -     @Filter(within={"seamComponent", "otherSeamComponent"})

    Specifies that this filter is positioned deeper in the stack than the given filters.

- PrevChapter 31. Configuring Seam and packaging Seam a...
- Top of page
- Front page
- NextChapter 33. Built-in Seam components