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 Hibernate Validator package. 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.
The first group of annotations lets you define a Seam component. These annotations appear on the component class.
@Name("componentName")Defines the Seam component name for a class. This annotation is required for all Seam components.
@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(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({
@Role(name="user", scope=ScopeType.CONVERSATION),
@Role(name="currentUser", scope=ScopeType.SESSION)
})Allows specification of multiple additional roles.
@BypassInterceptors
Disables Seam all interceptors on a particular component or method of a component.
@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
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.
@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(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 precendence 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 — Predence 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(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
Specifies that a JavaBean component or component method does not require state replication at the end of the invocation.
@AutoCreate
Specifies that a component will be automatically created, even if the client does not specify create=true.
The next two annotations control bijection. These attributes occur on component instance variables or property accessor methods.
@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
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, where a Seam component that manages the lifecycle of an instance of some other class that is to be injected. It appears on a component getter method.
The next annotation supports the factory component pattern, where 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("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:
The last annotation lets you inject a request parameter value:
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
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
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("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.
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
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
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.
@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 jPBM 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
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 jPBM 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
"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(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(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("cancel")Marks a method as signalling a transition in the current jBPM process instance whenever the method returns a non-null result.
Seam provides an annotation that lets you force a rollback of the JTA transaction for certain action listener outcomes.
@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 annotations on EJB 3.0 components, use @TransactionAttribute!
@Transactional
TDB
@Transactional
TDB
These annotations are mostly useful for JavaBean Seam components. If you use EJB 3.0 components, you should use the standard @TransactionAttribute annotation.
These annotations let you specify how Seam should handle an exception that propagates out of a Seam component.
@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(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.
Seam Remoting requires that the local interface of a session bean be annotated with the following annotation:
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(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.
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
Specifies that the method call is processed asynchronously.
@Duration
Specifies that a parameter of the asynchronous call is the duration before the call is processed (or first processed for recurring calls).
@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
Specifies that an asynchronous method call recurs, and that the annotationed parameter is duration between recurrences.
The following annotations make working with JSF easier.
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.
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.
The following annotations make it easy to implement clickable lists backed by a stateful session bean. They appear on attributes.
@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
Injects the selected value from the JSF DataModel (this is the element of the underlying collection, or the map value).
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
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).
value — name of the conversation context variable. Not needed if there is exactly one @DataModel in the component.
These meta-annotations make it possible to implement similar functionality to @DataModel and @DataModelSelection for other datastructures apart from lists.
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(value="http://jboss.com/products/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.com/products/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 refere to a component named org.jboss.seam.core.init.
These annotations allow you to integrate your Seam components with the servlet container.
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.