Duvida basica EJB 2.0 / xdoclet e EJB 3.0

Front-end
#1

ae galera eu tava conversando com um amigo meu, falando sobre EJBs, eu disse a ele que tinha uma aplicação rodando com ejb2 e utilizando o xdoclet(comentei que atualizei o xdoclet e tive alguns problemas que eu ja estava corrigindo), ae ele me disse que o ejb3 e java5 nao precisava do xdoclet, alguem pode me dar uma luz do que ele queria dizer?

como que funciona o ejb3…

t+

#2

Além de um refactoring no modelo de criação dos componentes as informações são declaradas por meio de anotações (annotations). Estas anotações são acessadas por reflexion e desta forma o container EJB sabe como gerenciar o cliclo de vida do componente. Anteriormente muitas destas informações eram colocadas em arquivos XML. Não que se tenha extinguido o uso totalmente, mas se não fugir muito do trivial não será necessário declarar quase nada em xml. Segue um exemplo de Stateless.

Inicialmente definimos a interface que irá descrever os métodos que o componente terá.

public interface MyService {
    public static final String NAME = "damnit";
    public void helloWorld();
}

Depois podemos criar nossa interface remote (assim como com EJB 2.x) Mas note que agora a anotação @Remote é que marca a interface.

@Remote
public interface MyServiceRemote extends MyService { }

A interface Local continua com a mesma funcionalidade, chamadas entre componentes localmente. A anotação aqui é @Local

@Local
public interface MyServiceLocal extends MyService { }

Por fim a implementação do serviço propriamente dito.

@Clustered //opcional, somenente em caso de uso de cluster
@Stateless(name=MyService.NAME) //tipo de EJB
@Remote(MyServiceRemote.class) //qual a interfaces remota?
@Local(MyServiceLocal.class) //qual a interfaces local?
public class MyServiceImpl implements MyServiceRemote, MyServiceLocal {
    public void helloWorld() {
         System.out.println("Damnit!");
    }
}

Eu acabei colocando os extends e implements pra garantir que a assinatura na interface de serviço e a implementação estão de acordo.

Posteriormente deve-se criar o application.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE application PUBLIC
   "-//Sun Microsystems, Inc.//DTD J2EE Application 1.3//EN"
   "http://java.sun.com/dtd/application_1_3.dtd">

<application>
    <display-name>MyServiceApplication</display-name>

    <module>
        <ejb>MyEJBs.jar</ejb>
    </module>
   
    <module>
        <java>lib/jdbc.jar</java>
    </module>

    <module>
        <java>lib/brokers.jar</java>
    </module>
    
    <module>
        <java>lib/util.jar</java>
    </module>

</application>

Simulei o uso de alguns jars que seriam as dependências do componente. Por fim a estrutura do arquivo ear deve ser:
[list]
MyServiceApplication.ear
+META-INF/application.xml
+lib/util.jar
+lib/jdbc.jar
+lib/brokers.jar
-MyEJBs.jar
[/list]

O nome do arquivo ear e display-name devem ser iguais! Lembrando que a criação do ear pode ser feita com tasks do ant.

Depois é encontrar um application server (JBoss por exemplo) e fazer o deploy.

O cliente deve receber as interfaces de serviço e remote somente. Neste caso o uso de um ServiceLocator também ajuda.

public class MyServiceClient {
    private MyService service;

    /* não mandatório mas para IOC é necessário */
    @EJB(name = MyServiceService.NAME)
    public void setRemote(MyService service) {
        this.service = service;
    }

    public MyServiceClient() {
        InitialContext ctx = new InitialContext(getProperties());
        final Object serv = ctx.lookup("MyServiceApplication/" + MyService.NAME + "/Remote");
        setRemote((MyService) serv);
    }

    public void helloWorld() {
        service.helloWorld();
    }
}

E por aí vai… T+

#3

A partir do Java 5 existe uma funcionalidade chamada Annotations que permite anotar classes, podendo colocar metadados diretamente no código, assim como podia ser feito com XDoclet, esse recurso foi usado no EJB3 para ser uma opção aos XML’s antes usados por EJB2, com EJB3 os XML’s continuam validos, mas a maioria das pessoas tem preferido as anotações, veja um exemplo de um Session Bean:

Inves de varias interfaces, classes e XML’s, somente isso:

@Stateless public class Calculadora{ public double somar(double a, double b){ return a+b; } }

Inves de um lookup JNDI, injeção de dependencia:

[code]public class MeuServlet extends HttpServlet{
@EJB
private Calculadora calc;

public void doPost(HttpServletRequest request, HttpServletResponse){
//NullPointerException??? Não!
double res = calc.somar(10, 15);
}
}[/code]

Veja exemplos em:
http://www.devx.com/Java/Article/30045/0/page/1

No The Server Side tem um livro sobre EJB3 gratuito:

Sobre Annotations:
http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html

#4

vlw jairelton e iktuz, deu pra sacar bem as “mudanças”

so por curiosidade com o antigo amiguinho xdoclet ele iria criando tbem as interface Local,Util,LocalHome… nesse caso agente teria que fazer na mão ne elas ?

muito obrigado!!!

#5

Não vai criar não, você cria a interface e adiciona a anotação @Remote nela, ex:

@Remote public interface Calculadora{ public double somar(double a, double b); }

E qualquer IDE que trabalhe com EJB3 gera isso tudo pra você.

#6

cara, isso é muito feliz :slight_smile:

vlw ae !

#7