An interceptor binding type is a Java annotation defined as @Target({TYPE, METHOD}) or @Target(TYPE) and @Retention(RUNTIME).

An interceptor binding type may be declared by specifying the @javax.interceptor.InterceptorBinding meta-annotation.

@Inherited
@InterceptorBinding
@Target({TYPE, METHOD})
@Retention(RUNTIME)
public @interface Transactional {}

@Inherited
@InterceptorBinding
@Target({TYPE, METHOD})
@Retention(RUNTIME)
@Transactional
public @interface DataAccess {}

@Transactional
@Secure
@RequestScoped
@Stereotype
@Target(TYPE)
@Retention(RUNTIME)
public @interface Action {}

The interceptor bindings of an interceptor are specified by annotating the interceptor class with the binding types and the @javax.interceptor.Interceptor annotation.

@Transactional @Interceptor
public class TransactionInterceptor {

   @AroundInvoke 
   public Object manageTransaction(InvocationContext ctx) throws Exception { ... }

}

An interceptor class may declare multiple interceptor bindings.

Multiple interceptors may declare the same interceptor bindings.

If an interceptor does not declare an @Interceptor annotation, it must be bound to beans using @Interceptors or ejb-jar.xml.

All interceptors declared using @Interceptor should specify at least one interceptor binding. If an interceptor declared using @Interceptor does not declare any interceptor binding, non-portable behavior results.

An interceptor for lifecycle callbacks may only declare interceptor binding types that are defined as @Target(TYPE). If an interceptor for lifecycle callbacks declares an interceptor binding type that is defined @Target({TYPE, METHOD}), the container automatically detects the problem and treats it as a definition error.

An interceptor binding may be declared by annotating the bean class, or a method of the bean class, with the interceptor binding type.

In the following example, the TransactionInterceptor will be applied at the class level, and therefore applies to all business methods of the class:

@Transactional
public class ShoppingCart { ... }

In this example, the TransactionInterceptor will be applied at the method level:

public class ShoppingCart {

   @Transactional 
   public void placeOrder() { ... }

}

A bean class or method of a bean class may declare multiple interceptor bindings.

If the bean class of a managed bean declares or inherits a class level interceptor binding or a stereotype with interceptor bindings, it must not be declared final, or have any non-static, non-private, final methods. If a managed bean has a class-level interceptor binding and is declared final or has a non-static, non-private, final method, the container automatically detects the problem and treats it as a definition error.

If a non-static, non-private method of a bean class of a managed bean declares a method level interceptor binding, neither the method nor the bean class may be declared final. If a non-static, non-private, final method of a managed bean has a method level interceptor binding, the container automatically detects the problem and treats it as a definition error.

By default, a bean archive has no enabled interceptors bound via interceptor bindings. An interceptor must be explicitly enabled by listing its class under the <interceptors> element of the beans.xml file of the bean archive.

<beans xmlns="http://java.sun.com/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">
   <interceptors>
      <class>org.mycompany.myfwk.TransactionInterceptor</class>
      <class>org.mycompany.myfwk.LoggingInterceptor</class>
   </interceptors>
</beans>

The order of the interceptor declarations determines the interceptor ordering. Interceptors which occur earlier in the list are called first.

Each child <class> element must specify the name of an interceptor class. If there is no class with the specified name, or if the class with the specified name is not an interceptor class, the container automatically detects the problem and treats it as a deployment problem.

If the same class is listed twice under the <interceptors> element, the container automatically detects the problem and treats it as a deployment problem.

Interceptors declared using @Interceptors or in ejb-jar.xml are called before interceptors declared using interceptor bindings.

Interceptors are called before decorators.

An interceptor is said to be enabled if it is enabled in at least one bean archive.

The process of matching interceptors to a certain lifecycle callback method, EJB timeout method or business method of a certain bean is called interceptor resolution.

For a lifecycle callback method, the interceptor bindings include the interceptor bindings declared or inherited by the bean at the class level, including, recursively, interceptor bindings declared as meta-annotations of other interceptor bindings and stereotypes.

For a business method or EJB timeout method, the interceptor bindings include the interceptor bindings declared or inherited by the bean at the class level, including, recursively, interceptor bindings declared as meta-annotations of other interceptor bindings and stereotypes, together with all interceptor bindings declared at the method level, including, recursively, interceptor bindings declared as meta-annotations of other interceptor bindings.

An interceptor is bound to a method if:

For a custom implementation of the Interceptor interface defined in Section 11.1.2, “The Interceptor interface”, the container calls getInterceptorBindings() to determine the interceptor bindings of the interceptor and intercepts() to determine if the interceptor intercepts a given kind of lifecycle callback, EJB timeout or business method.

@Transactional @Secure @Interceptor
public class TransactionalSecurityInterceptor {

   @AroundInvoke 
   public void aroundInvoke() throws Exception { ... }

}

@Transactional @Secure
public class ShoppingCart { ... }

@Transactional
public class ShoppingCart {

   @Secure
   public void placeOrder() { ... }
 
}

@Transactional
public class ShoppingCart {

   public void placeOrder() { ... }
 
}

@Inherited
@InterceptorBinding
@Target({TYPE, METHOD})
@Retention(RUNTIME)
public @interface Transactional {
   boolean requiresNew() default false;
}

@Transactional(requiresNew=true) @Interceptor
public class RequiresNewTransactionInterceptor {

   @AroundInvoke 
   public Object manageTransaction(InvocationContext ctx) throws Exception { ... }

}

@Transactional(requiresNew=true)
public class ShoppingCart { ... }

@Transactional
public class ShoppingCart { ... }

@Inherited
@InterceptorBinding
@Target({TYPE, METHOD})
@Retention(RUNTIME)
public @interface Transactional {
   @Nonbinding boolean requiresNew() default false;
}