Conteúdo


Desenvolver rapidamente um rico aplicativo da web de três camadas, Parte 2: Desenvolver a camada do aplicativo

Use o Rational Application Developer para desenvolver rapidamente um aplicativo Java EE multicamada e implemente-o no IBM Bluemix

Comments

Este tutorial composto por três partes guia você pelo desenvolvimento de um aplicativo da web de multicamadas desde o início, usando o IBM® Rational® Desenvolvedor de Aplicativos, API de Persistência Java (JPA), Enterprise JavaBeans (EJBs), serviços da web de REST e — um front-end avançado da Web 2.0 — o Dojo Toolkit. Você terminará com um aplicativo da web funcionando completamente que exibe dados em uma tabela, a qual os usuários podem editar clicando duas vezes em qualquer célula.

Na Parte 1 você criou um banco de dados no IBM Bluemix, conectado a ele do Desenvolvedor de Aplicativos do Rational e preencheu o banco de dados com dados de amostra. Na Parte 2, você criará a camada do aplicativo que consiste no Enterprise Java Beans (EJBs) para gerenciar a lógica de negócios e as entidades da API de Persistência Java (JPA) para interagir com o banco de dados. Na Parte 3 você criará os serviços da web do REST, fornecerá ao aplicativo uma interface rica da Web 2.0 e implementará o aplicativo ao Bluemix.

Criar a camada JPA

A primeira etapa é a de criar a camada de JPA para interagir com o banco de dados.

Criar um tempo de execução do Liberty

  1. No Desenvolvedor de Aplicativos do Rational, abra a perspectiva do Java Platform, Enterprise Edition e permita quaisquer recursos que sejam solicitados a você.
  2. Selecione a tecnologia Window > Preferências. Role para baixo e expanda Servidor e clique em Ambientes de Tempo de Execução.
  3. Clique em Incluir, escolha Perfil do Liberty do WebSphere Application Server V8.5, e selecione a caixa de seleção Criar um novo servidor local : Screenshot of New Server Runtime Wizard with WebSphere Liberty server selected
    Screenshot of New Server Runtime Wizard with WebSphere Liberty server selected
  4. Clique em Avançar.
  5. Especifique a localização de sua instalação do Liberty ou clique no link para fazer o download. Em seguida, clique em Concluir.
  6. Na caixa de diálogo Preferências, clique em OK.

Criar um projeto EJB

  1. Selecione a tecnologia Arquivo > Novo > projeto EJB.
  2. Altere o Nome do projeto para CustomerEJB. Certifique-se de que o tempo de execução do Perfil do Liberty do WebSphere Application Server 8V.5 esteja selecionado no campo Tempo de execução previsto e altere o nome do projeto do aplicativo corporativo para CustomerEAR: Screenshot of wizard for CustomerEJB project to run on Liberty
    Screenshot of wizard for CustomerEJB project to run on Liberty
  3. Na seção Configuração, clique em Modificar e inclua JPA e Contexto e injeção de dependência (CDI): Screnshot of Project Facets with CDI, JPA and EJB selected
    Screnshot of Project Facets with CDI, JPA and EJB selected
  4. Clique em OK.
  5. Clique em Avançar e Avançar novamente no assistente no Novo Projeto EJB.
  6. Na página de configuração Máscara JPA, escolha SQLDB da lista de Conexão: Screenshot of setting the database connection in the JPA Facet configuration dialog box
    Screenshot of setting the database connection in the JPA Facet configuration dialog box
  7. Clique em Avançar.
  8. Limpe a caixa de seleção Crie um Java archive do EJB .
  9. Clique em Concluir e aceite o comutador para a perspectiva do Java Platform, Enterprise Edition, se solicitado. (Ignore a notificação de erro, que ocorre porque você ainda não criou um EJB — uma tarefa que você irá manipular em uma etapa seguinte.)

Criar entidades JPA

Agora você criará o código JPA para acessar o banco de dados e os beans gerenciador JPA para consultar e inserir dados:

  1. Clique com o botão direito do mouse no projeto EJB Cliente e selecione Ferramentas JPA > Configurar Entidades JPA: Screenshot of the first page of Configure JPA Entity wizard
    Screenshot of the first page of Configure JPA Entity wizard
  2. Clique no botão Criar Novas Entidades JPA... .
  3. Na caixa de diálogo Selecionar Tabelas, escolha a conexão SQLDB , selecione o esquema do cliente (o nome de usuário do banco de dados Bluemix SQL do Parte 1) e selecione a tabela CUSTOMER : Screenshot of Generate Custom Entities wizard
    Screenshot of Generate Custom Entities wizard
  4. Clique em Avançar.
  5. Na página Associações de Tabela, clique em Avançar.
  6. Em Customizar Padrões, configure Gerador de chave para none.
  7. Clique em Avançar e, em seguida, clique em Concluir.
  8. Na caixa de diálogo Configurar Entidades JPA caixa de diálogo, aguarde até que CUSTOMER seja exibido no campo Tabelas e selecione-o. Clique em Avançar.
  9. Na página Tarefas, inclua as consultas padrão: Selecione a entidade Cliente , selecione Consultas Nomeadas da lista de tarefas e clique em Default . Essa seleção inclui um conjunto de consultas padrão e operações que você usará posteriormente para consultar os dados de CUSTOMER : Screenshot showing the queries to be generated
    Screenshot showing the queries to be generated
  10. Clique em Concluir.
  11. Se você for solicitado a escolher uma conexão de banco de dados, escolha SQLDB e clique em Concluir.

O assistente cria uma classe Java que irá ler e gravar dados na tabela de banco de dados, evitando que você tenha que gravar o código e entender a sintaxe e anotações de JPA. Se for necessário modificar a classe, é possível alterar o código ou executar novamente o assistente. Incluir consultas também ficou muito mais fácil agora, porque você possui um conjunto de exemplos a serem copiados.

A próxima tarefa é a de incluir uma classe de Gerenciador JPA. Uma classe de Gerenciador JPA fornece um conjunto de métodos auxiliares para executar as consultas e criar, atualizar e excluir as entidades. É possível pensar na entidade JPA como a representação de uma linha na tabela e a classe de Gerenciador JPA como a representação da tabela (e, além de fornecer operações em nível de tabela).

  1. Clique com o botão direito no projeto e escolha Ferramentas JPA > Incluir Beans Gerenciador JPA. Selecione a guia Cliente entidade JPA que você acabou de criar: Screenshot of JPA Manager Bean wizard with Customer selected
    Screenshot of JPA Manager Bean wizard with Customer selected
  2. Clique em Avançar e, em seguida, clique em Concluir.

Expanda a pasta ejbModule e observe que agora ela inclui duas pastas contendo as classes geradas: Cliente (a classe de entidade JPA) e CustomerManager (que fornece um conjunto de métodos do agrupador para interagir com o JPA Cliente código). Reserve um momento para olhar para o código para ambas as classes.

Criar um EJB de sessão

Agora que você desenvolveu a camada de acesso de dados (JPA), a próxima etapa é para desenvolver um bean de sessão EJB para fornecer seus métodos de negócios e interagir com o código JPA.

Neste exemplo, a lógica de aplicativo é simples. No entanto, a camada EJB é normalmente onde as regras de negócios e quaisquer cálculos complexos seriam implementados. Essa camada também fornece um local central para reter qualquer lógica para que ela não precise ser repetida em múltiplas UIs. (Por exemplo, se seu aplicativo tiver uma IU da web e uma IU móvel, você implementa qualquer lógica comum na camada EJB.) Os EJBs também fornecem uma fachada para acessar os dados do aplicativo. Portanto, uma solicitação típica para resultados de EJB no EJB interagindo com diversas classes JPA.

Criar e configurar um bean de sessão

  1. Selecione o projeto CustomerEJB no Enterprise Explorer, clique com o botão direito e escolha Novo > Bean de Sessão (3.x). Configurar Pacote Java para ejbs, configure Nome de classe para CustomerEJB, e selecione a caixa de seleção Local caixa de seleção (deixando o nome como o padrão): Completed Create EJB session bean wizard
    Completed Create EJB session bean wizard
  2. Clique em Concluir. O código para o bean de sessão deve ser aberto no editor Java.
  3. No bean de sessão, inclua uma variável para a classe CustomerManager , e marca a variável como uma solicitação de injeção de dependência usando a anotação @Inject : Posicione o cursor antes do construtor e inclua o código a seguir:
    @Inject
    private CustomerManager mgr;

    A anotação @Inject assegura que o atributo mgr será injetado pelo contêiner, portanto, você não precisa se preocupar sobre como criar uma instância CustomerManager . Por sua vez, as dependências da classe CustomerManager (em particular PersistenceUnit— Também será injetada uma classe gerenciada pelo servidor de aplicativos que realiza diversas elevações pesadas ao interagir com o banco de dados).
  4. Se ocorrerem erros de compilação, pressione Ctrl-Shift-O para incluí-los nas importações necessárias.
  5. Inclua os dois métodos a seguir na classe, imediatamente após o construtor:
    public List<Customer> getCustomers()
        {
        	return mgr.getCustomer();
        }
        
        public void updateCustomer(ID da sequência, nome da sequência,
    endereço da sequência, país da sequência)
        {
        	try {
    			Customer cust = new Customer();
    
    			cust.setAddress(endereço);
    			cust.setCountry(país);
    			cust.setName(nome);
    			cust.setCustno(Integer.parseInt(id));
    			
    			mgr.updateCustomer(cust);
    		} catch (NumberFormatException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
        }

    O método getCustomers() obtém uma lista de clientes, e o método updateCustomer() suporta a atualização de um cliente.
  6. Pressione Ctrl-Shift-O novamente.
  7. Salve o código. Se você possuir erros de compilação, pressione Ctrl-Shift-O para incluir as importações. Quando for solicitado para a importação de Lista , escolha java.util.List. Salve o arquivo novamente. Seu código agora deve se parecer com:
    package ejbs;
    
    import java.util.List;
    
    import javax.ejb.Local;
    import javax.ejb.LocalBean;
    import javax.ejb.Stateless;
    import javax.inject.Inject;
    
    import ejbs.view.CustomerEJBLocal;
    import entities.Customer;
    import entities.controller.CustomerManager;
    
    /**
     * Session Bean implementation class CustomerEJB
     */
    @Stateless
    @Local(CustomerEJBLocal.class)
    @LocalBean
    public class CustomerEJB implements CustomerEJBLocal {
    
        @Inject
        private CustomerManager mgr;
        /**
         * Default constructor. 
         */
        public CustomerEJB() {
            // TODO Auto-generated constructor stub
        }
        
        public List<Customer> getCustomers()
        {
            return mgr.getCustomer();
        }
        
        public void updateCustomer(ID da sequência, nome da sequência,
    endereço da sequência, país da sequência)     {
            try {
                Customer cust = new Customer();
                cust.setAddress(endereço);
                cust.setCountry(país);
                cust.setName(nome);
                cust.setCustno(Integer.parseInt(id));
    			
                mgr.updateCustomer(cust);
            } catch (NumberFormatException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (Exception e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
            }
        }
    }

Promover métodos

O EJBs possui interfaces para definir quais métodos podem ser chamados de outras classes no aplicativo. Para o getCustomers() e updateCustomer() métodos a serem selecionáveis dos serviços da web que você desenvolverá no Parte 3, eles devem ser promovidos na interface:

  1. Clique com o botão direito no editor CustomerEJB.java e escolha Ferramentas Java Platform, Enterprise Edition > Promover métodos.
  2. Na caixa de diálogo, selecione a caixa de seleção para o getCustomers() e updateCustomer() métodos: Screenshot of the Promote Methods dialog with both methods selected
    Screenshot of the Promote Methods dialog with both methods selected
  3. Clique em OK.

Configure o servidor do Liberty

Antes de você poder iniciar a construção da camada da web e testar o aplicativo, você deve configurar o servidor do Liberty para conversar com o DB2 e configurar a conexão do Java Naming and Directory Interface (JNDI) ao banco de dados:

  1. Inclua o projeto ao servidor: Na visualização Servidores, clique com o botão direito do mouse no servidor WebSphere Liberty e escolha Incluir e Remover.... Na caixa de diálogo resultante, inclua o arquivo CustomerEAR no servidor e clique em Concluir.
  2. Criar a fonte de dados no servidor: Na visualização Servidores, expanda o perfil do WebSphere Application Server V8.5 Liberty no localhost e dê um clique duplo Configuração do Servidor: Screenshot of server configuration editor
    Screenshot of server configuration editor
  3. No editor de Configuração do Servidor, clique em Incluir e escolha driver JDBC. Especifique DB2 como o ID: Screenshot of Liberty configuration with JDBC driver
    Screenshot of Liberty configuration with JDBC driver
  4. Clique no botão Incluir botão próximo ao Referência da biblioteca compartilhada. Na caixa de diálogo Nome, campo, tipo DB2library.
  5. Diga ao servidor onde estão as bibliotecas de DB2 JDBC: Próximo à referência de conjunto de arquivo, clique em Incluir, e para a propriedade do diretório base, digite a localização da pasta que contém o arquivo do driver JDBC (db2jcc4.jar) — por exemplo, c:\ibm\sqllib\java: Screenshot of fileset configuration under shared library
    Screenshot of fileset configuration under shared library
  6. Inclua a fonte de dados: Selecione Configuração do Servidor, clique em Incluir e escolha Fonte de Dados.
  7. Configure o ID para SQLDB e configure o nome JNDI para jdbc/SQLDB. Na caixa de diálogo referência do driver JDBC campo, escolha DB2 da lista: Screen shot of data source properties dialog box
    Screen shot of data source properties dialog box
  8. Inclua as informações sobre autenticação para a fonte de dados: Selecione a fonte de dados à esquerda, clique em Incluir e escolha Propriedades de DB2 JCC. Especifique SQLDB como o Nome do banco de dados e forneça o nome do host, nome de usuário e a senha para acessar o banco de dados: Screenshot of database authentication properties configuration
    Screenshot of database authentication properties configuration
  9. Salve o arquivo server.xml.

A seguir

O servidor agora está configurado e você concluiu a criação de EJB e do código JPA. Você está pronto para continuar para Parte 3, onde você irá criar serviços da Web do REST e uma IU da Web do Dojo para exibir e modificar os dados por meio de serviços do REST. Por fim, após o aplicativo estar sendo executado localmente, você irá implementá-lo no IBM Bluemix.


Recursos para download


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Cloud computing, Tecnologia Java, Rational
ArticleID=1004937
ArticleTitle=Desenvolver rapidamente um rico aplicativo da web de três camadas, Parte 2: Desenvolver a camada do aplicativo
publish-date=04302015