Interceptors (Interceptadores) são de grande utilidade em qualquer projeto JavaEE. Presente desde a versão EJB 3.0, eles permitem ao bean provider interceptar qualquer session bean, tanto antes quanto depois da sua execução. Pensando nisso, é possível usá-los de várias para diversos fins diferentes, podemos citar por exemplo: logging, tratamento de exceção, auditoria, métricas, etc.

É possível definir Interceptors de algumas maneiras diferentes, vamos citá-los:

1. Default Interceptors – São definidos no ejb-jar xml e podem ser aplicados a todos session beans.
2. Classe Interceptors – São definidos no topo da classe com a anotação @Interceptors
3. Method Interceptors – São definidos no nível de métodos com a anotação @Interceptors
4. Na própria classe – Presentes na própria classe do session bean

Um método do session bean pode ser interceptador por quantos interceptores existirem aplicados para aquele método, e a ordem da execução deles é aplicado seguindo : Default, Class, Method, própria classe. Caso haja mais de um interceptor para alguma categoria, a ordem foi a que foi declarada.

Para se criar um usa-se a anotação @AroundInvoke normalmente um Inteceptor possui a cara abaixo:

@AroundInvoke

public Object aroundInvoke(InvocationContext ic) throws Exception{

System.out.println("start");

Object obj = ic.proceed(); //o método do bean executa aqui

System.out.println("end");

return obj;

}

Um ponto importante a se observar é que o método deve lançar na assinatura Exception. Isso se deve pois session beans podem lançar exceções checadas, então não se sabe qual exceção vai vir de lá, logo declara-se a mais genérica. Um interceptor não pode lançar uma exceção checada que session bean não conheça.

Abaixo o session bean que é interceptado pelo Inteceptor acima:

public class CountryCodeBean implements CountryCodeBeanLocal {
 @Interceptors({InterceptorA.class})

@ExcludeClassInterceptors

@ExcludeDefaultInterceptors

public String getCode(String country){

System.out.println("In getCode");

return country+"_CODE";

}
 @AroundInvoke

public Object selfAround(InvocationContext ic) throws Exception{

System.out.println("In selfAround");

return ic.proceed();

}
}

Coisas a se conderar do código acima:

• O método selfAround é um Inteceptor da própria session bean, e na ordem de execução ele sempre será o último dos interceptors (caso hajam outros).
• @ExcludeClassInterceptors remove da execução os Inteceptors declarados no topo da classe
• @ExcludeDefaultInterceptors remove os Interceptos declarados como default no ejb-jar

Abaixo um exemplo de como se declara um default-interceptor no ejb-jar:

<ejb-jarxmlns="http://java.sun.com/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaeehttp://java.sun.com/xml/ns/javaee/ejb-jar_3_1.xsd"version="3.1">

<assembly-descriptor>

<interceptor-binding>

<ejb-name>*</ejb-name>

<interceptor-class>my.example.MyDefaultInterceptor</interceptor-class>

</interceptor-binding>

</assembly-descriptor>

</ejb-jar>

Outro aspecto importante que vale ressaltar, é que o Interceptor é sempre associado com a instância do Session Bean. Ou seja, se um Interceptor é associado com um statefull session bean, sua instância viverá enquanto a instância do statefull viver, inclusive será passivada e ativada da mesma forma. A mesma regra vale para Singleton e Stateless.