Tutorial AndroMDA versão 3.1.1.3.4 - softwarepublico.gov.br · código gerado se trata de páginas JSP e de códigos em Java J2EE. Este tutorial foi feito com o ArgoUML 0.22, que

Tutorial

AndroMDA

versão 3.1.1.3.4.11

Elaboração: UFRJModificado: Serpro/CETEC RJO Versão: 1.2Rio de JaneiroFevereiro de 2009

Índice

1 Preparação do Ambiente para utilização do AndroMDA (versão 3.1.1.3.4.11) .................... 3 2 Desenvolvimento de Projetos com AndroMDA ..................................................................... 3

2.1 Criação de Novo Projeto/Configuração do Ambiente .................................................... 3 2.2 Configuração do Banco ................................................................................................... 4

3 Iniciando o projeto no ArgoUML .......................................................................................... 6 3.1 O exemplo: ....................................................................................................................... 8

3.1.1 Casos de Uso ............................................................................................................ 8 3.2 Caso de uso de “ConsultarPais” ...................................................................................... 9

3.2.1 Camada de Domínio ................................................................................................ 9 3.2.2 Código de Banco de Dados gerados ...................................................................... 19 3.2.3 Criação de Value Object ........................................................................................ 19 3.2.4 Camada de Serviços ............................................................................................... 20 3.2.5 Camada de Interface .............................................................................................. 24 3.2.6 Implementação do Código da Consulta ................................................................. 42

3.3 Caso de uso “DetalharPais” ........................................................................................... 49 3.3.1 Camada de Domínio .............................................................................................. 49 3.3.2 Camada de Serviço ................................................................................................ 49 3.3.3 Camada de Interface .............................................................................................. 49 3.3.4 Implementação do Código do Detalhamento ........................................................ 59

3.4 Caso de uso “AlterarPais” ............................................................................................. 59 3.4.1 Camada de Domínio .............................................................................................. 59 3.4.2 Camada de Serviço ................................................................................................ 59 3.4.3 Camada de Interface .............................................................................................. 60 3.4.4 Implementação do Código do Alterar Pais ............................................................ 67

3.5 Caso de uso “IncluirPais” .............................................................................................. 69 3.5.1 Camada de Domínio .............................................................................................. 69 3.5.2 Camada de Serviço ................................................................................................ 69 3.5.3 Camada de Interface .............................................................................................. 69 3.5.4 Implementação do Código da Inclusão ................................................................. 74

3.6 Caso de uso “ExcluirPais” ............................................................................................. 75 3.6.1 Camada de Domínio .............................................................................................. 75 3.6.2 Camada de Serviço ................................................................................................ 76 3.6.3 Camada de Interface .............................................................................................. 76 3.6.4 Implementação do Código da Exclusão ................................................................ 80 3.6.5 Modo de Operação ................................................................................................. 80 3.6.6 Exclusão Múltipla .................................................................................................. 83

3.7 Editando Paginas JSP .................................................................................................... 86 3.7.1 Achando a localização da página ........................................................................... 86 3.7.2 Alterando as Paginas .............................................................................................. 87 3.7.3 Retrabalho .............................................................................................................. 87 3.7.4 Abas ........................................................................................................................ 88

2

1 Preparação do Ambiente para utilização do AndroMDA (versão 3.1.1.3.4.11)

Antes de iniciar a execução desse tutorial siga o passo a passo de instalação descrito no documento Manual_AndroMDA_Instalacao.pdf.

2 Desenvolvimento de Projetos com AndroMDA

Nesta seção veremos os passos necessários ao desenvolvimento de projetos com o AndroMDA, utilizando os cartuchos EJB, Hibernate e BPM4Struts já personalizados.

2.1 Criação de Novo Projeto/Configuração do Ambiente

O plug-in do AndroMDA para o Maven já possui um procedimento parametrizado para criação de projetos, que funciona como um wizard, onde o usuário deve responder a perguntas. Através das respostas fornecidas o AndroMDA irá direcionar a criação da estrutura básica e dos artefatos básicos de configuração de projetos. O procedimento para criação de um novo projeto é:

1.Abra o console (command prompt) e vá para o diretório onde se deseja criar o projeto. Na verdade o projeto será gerado em um subdiretório do diretório escolhido.

No windows não se pode ter espaços em branco no caminho desse diretório. Exemplo de diretório inválido: C:\Documents and Settings\andromda.

2.Digite o comando: maven andromdapp:generate

3.Responda as perguntas de acordo com o seu projeto. Abaixo um exemplo com respostas típicas (perguntas em negrito):

Please enter your first and last name (i.e. Chad Brandon):CETECPlease enter the name of your J2EE project (i.e. Animal Quiz):SuportePaisPlease enter the id for your J2EE project (i.e. animalquiz):SuportePaisPlease enter a version for your project (i.e. 1.0-SNAPSHOT):1.0Please enter the base package name for your J2EE project (i.e. org.andromda.samples):br.gov.tutorialWould you use jboss or tomcat (enter 'jboss' or 'tomcat')?jbossWould you use jboss 4.0.3 or under? (enter 'yes' or 'no')?yes

3

Would you like to enable security? (enter 'yes' or 'no')?yesWould you like to use modules (enter 'yes' or 'no')?yesPlease enter the type of transactional/persistence cartridge to use (enter 'hibernate', 'ejb', or 'spring'):hibernateWould you like to use the jBpm workflow engine, it uses Hibernate3 (enter 'yes' or 'no')?noPlease enter the hibernate version number (enter '2' for 2.1.x or '3' for 3.0.x):3Would you like a web application? (enter 'yes' or 'no'):yesWould you like your web tier to use JSF or Struts? (enter 'jsf' or 'struts'):struts

4.Após receber as respostas, o AndroMDA criará um subdiretório onde será gerada a estrutura inicial do projeto. A partir desse momento chamaremos esse diretório de <DiretorioProjeto>.

5.Ainda no console, vá para o diretório onde está seu projeto: <DiretorioProjeto>.

6.Digite maven. Isto obrigará o Maven a obter todos os artefatos (por exemplo, bibliotecas) de que o projeto dependerá.

2.2 Configuração do Banco

Para se configurar o Banco de Dados é necessário modificar o arquivo project.properties da raiz do projeto, onde se encontram as propriedades que devem ser alteradas. Abaixo as propriedades do arquivo de configuração para cada um dos Bancos de Dados

•Hypersonic:

dataSource.driver.jar=${env.JBOSS_HOME}/server/default/lib/hsqldb.jardataSource.driver.class=org.hsqldb.jdbcDriverdataSource.url=jdbc:hsqldb:hsql://127.0.0.1:1701

sql.mappings=HypersonicSqlhibernate.db.dialect=org.hibernate.dialect.HSQLDialect

•Oracle:

dataSource.driver.jar=${env.JBOSS_HOME}/server/default/lib/ojdbc14.jar

4

dataSource.driver.class=oracle.jdbc.driver.OracleDriverdataSource.url=jdbc:oracle:thin:@10.3.18.1:1521:sgdcpdes

sql.mappings=Oracle9ihibernate.db.dialect=org.hibernate.dialect.Oracle9Dialect

•Firebird:

dataSource.driver.jar=${env.JBOSS_HOME}/server/default/lib/jaybird-full-2.0.1.jardataSource.driver.class=org.firebirdsql.jdbc.FBDriverdataSource.url=jdbc:firebird://10.3.18.1/3050//opt/firebird/db/sgdcp.fdb

sql.mappings=Firebirdhibernate.db.dialect=org.hibernate.dialect.FirebirdDialect

•SQLServer:

dataSource.driver.jar=${env.JBOSS_HOME}/server/default/lib/jtds-1.1.jardataSource.driver.class=net.sourceforge.jtds.jdbc.DriverdataSource.url=jdbc:jtds:sqlserver://<server>/<database>

sql.mappings= MSSQLhibernate.db.dialect=org.hibernate.dialect.SQLServerDialect

•Postgres:

dataSource.driver.jar=${env.JBOSS_HOME}/server/default/lib/postgresql-8.1-405.jdbc3.jar dataSource.driver.class=org.postgresql.DriverdataSource.url=jdbc:postgresql://10.14.1.134:5432/postgresdefaultHibernateGeneratorClass=sequence

sql.mappings=PostgreSQL hibernate.db.dialect=org.hibernate.dialect.PostgreSQLDialect

Outro arquivo que deve ser alterado ou criado é o arquivo de configurações do Banco de Dados do Jboss (arquivo localizado no diretório <JbossHOME>/server/default/deploy/ com formação do nome terminando com -ds.xml ex.: oracle-ds.xml), que deve ter a tag <local-tx-datasource> preenchida de acordo com as informações fornecidas no arquivo <projeto>/project.properties.

Exemplo:<local-tx-datasource>

<jndi-name>postgresDS</jndi-name><use-java-context>false</use-java-context><connection-url>jdbc:postgresql://10.14.1.134:5432/postgres</connection-url>

5

<driver-class>org.postgresql.Driver</driver-class><user-name>postgres</user-name><password>postgres</password> <metadata>

<type-mapping>PostgreSQL 8.1</type-mapping></metadata>

</local-tx-datasource>

3 Iniciando o projeto no ArgoUML

Esta seção visa descrever como desenvolver os modelos de diagramas UML que serão posteriormente utilizados pelo AndroMDA para geração automática de artefatos, como código fonte e descritores. Como ferramenta de modelagem utilizaremos o ArgoUML, depois disso apenas alguns métodos deverão ser alterados no Eclipse. O código gerado se trata de páginas JSP e de códigos em Java J2EE. Este tutorial foi feito com o ArgoUML 0.22, que é totalmente compatível com o AndroMDA.

Todas as consultas e manipulações de informação do banco de dados serão via Web através das páginas JSP, e toda a aplicação será gerenciada pela aplicação de servidor Java que será feito em J2EE. O JBoss será a aplicação necessária para essa comunicação acontecer, esta deverá estar sendo executada, neste caso em particular, no Eclipse.

Observações:Os modelos utilizados pelo AndroMDA devem ser independentes de plataforma.

Por isso, não se deve colocar no modelo características que sejam específicas a alguma linguagem ou plataforma. Inclusive, deve-se usar tipos genéricos. Por exemplo, ao definir que o tipo de um determinado atributo é String, não se pode colocar o tipo java.lang.String, mas sim o tipo datatype String do profile do AndroMDA (String [datatype]).

Alguns tipos utilizados encontram-se com a primeira letra em maiúsculo e minúsculo. Deve-se sempre utilizar o primeiro (ex: utiliza-se Long em vez de long).

Antes de começarmos a modelagem é necessário importar os profiles contendo os estoriótipos utilizados pelo andromda para geração do código através do modelo.

1.No ArgoUML, crie um novo projeto. Ficheiro -> Novo

2.Clique em Ficheiro -> Importar XMI... e abra o arquivo andromda-profile-argouml.xml.zip. O caminho do arquivo dependo no sistema operacional.

No Windows XP:C:\Documents and Settings\<usuário>\.maven\repository\andromda\xml.zips

6

No Linux /home/<usuário>/.maven/repository/andromda/xml.zips

Observe que a estrutura básica de pacotes foi importada. Esta estrutura já engloba a funcionalidade de controle de acesso.

7

3.1 O exemplo:

A situação relacionada como exemplo neste tutorial servirá de base para as aplicações a serem desenvolvidas no projeto. Embora este seja bem mais simples, fornecerá a base necessária para o prosseguimento do projeto.

O exemplo se trata de um sistema de informação, com manipulação em um banco de dados centralizado em servidor. O banco de dados é para a organização do cadastro de países. Com isso, a aplicação deverá ser capaz de incluir, consultar, editar e excluir cadastro de países.

3.1.1 Casos de Uso

Abaixo se encontra o caso de uso padrão que representa a implementação.

Pode se notar que a ação inicial será de consulta do país. Depois desta ação o usuário irá visualizar os países encontrados.

A partir dessa listagem, o usuário poderá optar por detalhar o(s) país(es) encontrados, incluir um novo país, alterar ou excluir algum país, assim como selecionar vários países e remover todos ao mesmo tempo.

Na parte de detalhamento do país estará a mostra todos os campos e ainda mais dois botões, um botão de exclusão e um botão de alteração.

3.2 Caso de uso de “ConsultarPais”

O caso de uso de consulta consiste em uma tela de consulta com as informações básicas desejadas e uma tela de exibição do resultado da busca.

8

3.2.1 Camada de Domínio

Na camada de domínio, estarão as classes do domínio da aplicação. Elas serão entidades e estarão associadas a algum modo de persistência. Essas classes deverão conter o estereótipo <<Entity>> e os atributos que serão persistidos. Todas as classes de entidade devem obrigatoriamente estar no pacote <PacoteProjeto>.cd, onde <PacoteProjeto> é o pacote definido para o projeto. Atualmente, estamos utilizando framework Hibernate para esta camada.

1.Crie a mesma estrutura de pacotes que foi definido no projeto e dentro do pacote do projeto crie o pacote “cd”.

9

2.Clique com o botão direito do mouse no pacote cd e selecione a opção Create Diagram e, em seguida, selecione Novo Diagrama de Classes.

3.Indique o nome desejado para o diagrama.

10

4.No diagrama de classe, crie uma nova classe. Selecione a classe e na parte inferior da tela, na aba propriedades, defina o nome da classe como Pais (país sem acento).

5.Crie os atributos na classe Pais (codigo, codigoAuxiliar, valor, descricao) selecionando o botão Novo Atributo na aba propriedades. As figuras abaixo exemplificam a criação do atributo codigo. O campo Visibilidade deve ser público.

11

A multiplicidade com valor 1 significa que o atributo é obrigatório (NOT NULL), com valor 0..1 indica que o atributo não é obrigatório. Por default, todos os atributos são gerados como NOT NULL. Não é necessário modelar o atributo id, pois esse é gerado automaticamente.

6.Colocar o estereótipo <<Unique>> no atributo codigo para indicar que cada código deve ser único, ou seja, não pode haver dois códigos iguais. Abra a especificação do atributo codigo e selecione a aba Estereótipo. Nessa aba selecione o estereótipo <<Unique>>.

12

7.Colocar o estereótipo <<Entity>> na classe.

Para cada entidade, podem ser atribuídos tagged values para agregar ao modelo parâmetros para a geração de código. Por exemplo, o tagged value @andromda.persistence.table reflete o nome da tabela a ser criada no banco de dados.

Da mesma forma, podemos atribuir estereótipos e tagged values aos atributos. Entre os estereótipos temos: <<Identifier>> que determina que o atributo será o identificador do objeto (possível chave primária) e <<Unique>> que determina que o valor do atributo deverá ser único.

Como exemplo de tagged values temos @andromda.persistence.column que define o nome da coluna a ser criada no banco de dados e @andromda.persistence.column.lenght que define o tamanho da coluna.

13

8.No diagrama de classe, crie a outra classe desse pacote. Selecione a opção Specification, clicando com o botão direito, e defina o nome da classe como UnidadeFederativa.

9.Crie os atributos na classe UnidadeFederativa (codigo, descricao). O campo Visibilidade deve ser público, assim como feito anteriormente.

10.Colocar o estereótipo <<Unique>> no atributo codigo para indicar que cada código deve ser único. Abra a especificação do atributo codigo e selecione a aba Stereotypes. Nessa aba selecione o estereótipo <<Unique>>.

11.Colocar o estereótipo <<Entity>> na classe.

12.Agora, crie uma associação entre as classes, vá no diagrama de classes e puxe association de uma classe para outra.

13.A associação será de 1 para muitos, para fazer isso clique uma vez na associação e irá aparecer na parte de baixo da tela, na aba “propriedades”, as conexões da associação. A primeira é referente à classe Pais que, por padrão está com multiplicidade “1”, modificador “navegável” e visibilidade “público”. Dê dois cliques na segunda conexão, que é referente à classe UnidadeFederativa. Coloque sua multiplicidade “0..*”, modificador “navegável” e visibilidade “público”.

14

A associação deve ser dupla, tanto UnidadeFederativa quanto Pais devem se enxergar, dessa forma clique com o botão direito sobre a associaçã e escolha a navegabilidade “bidirecional”.

14. Salve o projeto (Ficheiro -> Guardar Projeto) no caminho <DiretorioProjeto>\mda\src\uml\<NomeProjeto>.zargo.

15

15. Exporte o projeto para o formato *.XMI ((Ficheiro -> Exportar XMI...) também para o diretório <DiretorioProjeto>\mda\src\uml\

16.O AndroMDA reconhece arquivos com estrutura de um XMI, porém se eles estiverem com a extensão “*.xml”. Então renomeie seu arquivo <NomeProjeto>.xmi para <NomeProjeto>.xml

17.No diretório da aplicação, executar o comando maven para validar o modelo e gerar o script de criação do banco de dados. O resultado apresentado deve ser “BUILD SUCCESFULL”.

16

3.2.2 Código de Banco de Dados gerados

Você já deve ter percebido que o maven já cria todas as classes sozinhas, só que ele não faz só isso, ele cria outras coisas também, como por exemplo o código sql de criação de tabela que será utilizado no projeto. Para ver isso vá em <DiretorioProjeto>/core/cd/target e procure pelo arquivo “schema-create.sql”. Abra esse arquivo e encontrará o código sql da criação das tabelas Pais, UnidadeFederativa e todas do controle de acesso. O comando maven que cria/executa esse arquivo é o maven create-schema.

Outro arquivo que pode ser encontrado nessa pasta é o “schema-drop.sql”. Que contém os códigos para que sejam apagadas as tabelas. O comando maven que executa esse arquivo é maven drop-schema.

3.2.3 Criação de Value Object

Em breve, codificaremos o método responsável por realizar a consulta de países na camada de domínio. Vamos partir do princípio que o usuário poderá refinar a consulta preenchendo um ou mais atributos da entidade país. Por exemplo, ele poderá realizar a consulta digitando o código do país(uma restrição), ou poderá digitar também o código auxiliar(outra restrição). Precisaremos, então, de uma classe que nos auxilie carregando esses valores para que a consulta seja feita com as restrições corretas. Essa classe pegará os dados fornecidos pelo usuário e será utilizada na criação de restrições para a consulta sobre esses dados. Ou seja, esta classe será preenchida no controle com os dados digitados pelo usuário e seguirá até o objeto de acesso aos dados (DAO) onde será executada a consulta. A execução da consulta será implementada em um método do manipula (cujo código será apresentado mais a frente) e não será necessário criar método na camada de serviço para tratar o filtro.

A classe responsável por armazenar os parâmetros da consulta tem o estereótipo <<ValueObject>>, sendo caracterizada por armazenar informações que são transferidas entre camadas (controle ==> serviço ==> dado ou dado ==> controle ==> serviço).

Todas as classes VO devem obrigatoriamente estar no pacote <PacoteProjeto>.vo, onde <PacoteProjeto> é o pacote definido para o projeto.

Detalhando mais, os Values Objects são estruturas de armazenamento de dados, armazenando informações num formato específico. Geralmente são utilizadas neste projeto para generalizar a busca de dados.

No caso de busca, devem ser armazenados nos Values Objects os critérios de pesquisa diretamente da submissão do usuário, e de acordo com a necessidade pode ser feita uma busca por diversos critérios, deixando as consultas em apenas um método direto de manipulação que é o handleFilter.

Para criar o Value Object:

17

1.Crie uma pasta “vo” dentro do pacote do projeto.

2.Crie um diagrama de classes dentro da pasta “vo”.

3.No diagrama, crie uma classe chamada PaisVO.

4.Para cada atributo da classe Pais, crie um atributo com o mesmo nome e tipo dentro da classe PaisVO. Ou seja: devem ser criados os atributos, todos públicos, codigo(String), codigoAuxiliar(String), valor(String) e descricao(String).

5.Colocar o estereótipo <<ValueObject>> na classe, clicando nela com o botão direito, no submenu Aplicar Estereótipo, selecione o esteriótipo.

18

3.2.4 Camada de Serviços

Na camada de serviço serão implementadas as classes responsáveis pela lógica de negócio da aplicação. As classes especificadas se tornarão os serviços (API) da aplicação. Os serviços definidos no modelo se tornarão disponíveis através de Session Beans.

Os Session Beans são componentes de negócio. A lógica de negócio dos componentes EJB se encontram nestes componentes. Existem dois tipos de Componentes Session Bean, o Stateless Session Bean e o Stateful Session Beans. O Stateless é um componente de negócio que não mantém conversação com o usuário, não há garantia que chamadas sucessivas de métodos remotos vão ser feitas no mesmo objeto. O Stateful é um componente que mantêm estado, com ele temos a garantia que chamadas sucessivas de métodos remotos feitas por um mesmo cliente serão processadas por um mesmo objeto.

Os beans EJB precisam ser modelados em um diagrama de classes. As classes destes beans precisam ter o estereótipo <<Service>>. Todas as classes de serviço devem estar no pacote <PacoteProjeto>.cs. Além disso, o pacote cs deve ter o estereótipo <<ModuloServico>>.

1.Crie um pacote <PacoteProjeto>.cs, onde <PacoteProjeto> é o pacote definido para o projeto.

2.Aplique o estereótipo <<ModuloServico>> ao pacote.

19

3.Crie um diagrama de classe dentro do pacote cs com o nome que desejar.

4.Crie uma classe chamada PaisHandler com estereótipo Service. A classe PaisHandler deve ficar como na figura abaixo.

5.Crie uma classe chamada PaisException com o estereótipo ApplicationException.

6.Arraste para o diagrama de classes a classe Pais.

7.Crie dependências entre as classes PaisHandler e Pais e entre a classe PaisHandler e a classe PaisException. Para isso, utilize a ferramenta do ArgoUML da figura abaixo. Clique na ferramenta, clique na classe ou método de origem e arraste a seta até a classe destino.

8.Verifique se o diagrama está como a figura abaixo.

20

9.A dependência entre PaisHandler e PaisException fará com que todos os métodos de PaisHandler lance exceção para PaisException. Se a dependência tivesse sido entre algum método de PaisHandler e não com a própria classe, somente o método com dependência lançaria exceção.

A dependência entre PaisHandler e Pais cria um método nas classes de serviços chamado manipula e esse método realiza operações básicas de banco de dados, como inserir, alterar, remover etc. Mas como o método manipula “sabe” qual operação deve ser realizada? Esse método possui a seguinte assinatura:

public List manipulaEntidade(Entidade entidade, Action action)

É através do parâmetro action que informaremos ao método qual a operação que ele deve realizar. Por exemplo, se quisermos fazer uma inserção, passaremos uma instância da classe InsertAction. Se for uma remoção, passaremos uma instância da classe DeleteAction.

No exemplo de consulta, estamos interessados na operação Filter. Essa operação retorna todos os registros que atendem a determinadas restrições. Por exemplo, queremos saber qual o país que possui o código “X”. Para que o método manipula execute uma operação de Filter, passaremos uma instância da classe FilterAction como parâmetro. Utilizaremos o seguinte construtor da classe FilterAction:

public FilterAction(VO objetoVO, Integer paginacao);O objeto VO conterá as restrições da consulta.

10.Salve o projeto (Ficheiro -> Guardar Projeto) no caminho <DiretorioProjeto>\mda\src\uml\<NomeProjeto>.zargo. Onde <NomePojeto> deve ser igual ao nome dado ao projeto no momento de sua criação, de acordo com a resposta dada ao AndroMDA.

11. Exporte o projeto para o formato *.XMI ((Ficheiro -> Exportar XMI...) também para o diretório <DiretorioProjeto>\mda\src\uml\

12.O AndroMDA reconhece arquivos com estrutura de um XMI, porém se eles estiverem com a extensão “*.xml”. Então renomeie seu arquivo <NomeProjeto>.xmi para <NomeProjeto>.xml

13.No diretório da aplicação, executar o comando maven. O resultado apresentado deve ser “BUILD SUCCESFULL”. Caso o Maven detecte erros no projeto resolva-os antes de seguir os próximos passos do tutorial.

21

3.2.5 Camada de Interface

A modelagem é feita através de diagramas de atividades. Estes diagramas expressam a forma como os casos de uso irão se comportar. O fluxo de navegação da aplicação é descrito basicamente em termos de estados e transições.

1.Criar um novo pacote abaixo do pacote “tutorial”, para agrupar o(s) caso(s) de uso. O nome do pacote deverá ser padronizado, com o nome de web.

2.Dentro do pacote web, crie um pacote chamado cadastroPais, que será o módulo web. Cada caso de uso tem que estar dentro de um pacote dentro do seu respctivo módulo web. Crie outro pacote chamado consultaPais.

3.Atribua os esteriótipos <ModuloWeb> e <ModuloWebPrincipal> ao pacote cadastroPais.

4.Criar um diagrama de classes com um nome qualquer, dentro do pacote consultaPais;

5.Criar uma classe de controle, para cada caso de uso elaborado;

As classes de controle são aquelas que recebem as solicitações da camada de visão e as transfere para a camada de serviço. Essas classes compõem a camada de controle.

O nome da classe de controle deverá ser padronizado de acordo com o caso de uso, sempre acrescentando “Controle” no nome do caso de uso, ficando neste caso: ConsultaPaisControle

22

6.Criar um diagrama de casos de uso (utilização), dentro do pacote consultaPais. Dentro desse diagrama, adicione um caso de uso. Nesse exemplo o caso de uso será chamado ConsultarPais.

7.Atribuir ao caso de uso criado os estereótipos <FrontEndApplication> e <FrontEndUseCase> para indicar que este caso de uso é o principal do sistema, o que significa que será o primeiro a ser executado, (clicar com o botão direito no caso de uso, depois Aplicar Estereótipo). Somente um caso de uso pode possuir este estereótipo.

23

8.Criar um diagrama de atividade abaixo da classe de controle. Nome do diagrama de atividades deverá ser padronizado de acordo com o caso de uso, por exemplo: ConsultarPaisDA.

24

Um diagrama de atividade é essencialmente um gráfico de fluxo, mostrando o fluxo de controle de uma atividade para outra. No MDA as atividades do tipo <<FrontEndView>> serão transformadas em telas para o usuário e as demais atividades serão interações com o servidor.

9.Modelar o diagrama de atividades. Para isso, abra o diagrama de atividades (executar duplo clique sobre o nome do diagrama).

a) Crie um estado inicial. Cada diagrama de atividades deve possuir apenas um estado inicial;

b) Crie um Estado de Ação. Como exemplo, criamos uma ação com o nome “Preencha os Dados da Consulta de Pais” e colocamos o estereótipo <<FrontEndView>>. Este estereótipo indica que esta ação é uma página JSP cujo título é o nome que foi dado a ela. Toda atividade deve estar com o nome preenchido. Para nomear uma atividade, deve-se clicar nela e editar o campo “nome” na parte inferior da tela, na aba “propriedades”;

c) Criar uma transição do estado inicial para a atividade que foi criada no exemplo acima (ver figura abaixo);

25

10.Criar um método na classe ConsultaPaisControle que irá ser chamado quando a atividade for executada (ou seja, a atividade gerará uma página jsp que, quando submetida, executará este método). Como exemplo, criamos o método consultaPais. Para criação deste método são executados os seguintes passos:

a) Criar nova operação

b) Preencher os campos abaixo:

• Name: consultaPais (exemplo)• Return type: void• Parâmetros: codigo, codigoAuxiliar, valor, descricao

Obs.: No ArgoUML, ao se criar uma nova operação, por padrão ele já cria um parâmetro chamado “return” do tipo tipo “void”. Esse parâmetro será o retorno do método.

26

A tela abaixo mostra o método consultaPais criado;

11.Para que a classe ConsultaPaisControle possa ser referenciada no Diagrama de Atividades do caso de uso em questão, é necessário que ela seja relacionada ao diagrama.

a) Para isso, clique no diagrama de atividades e, na parte inferior da tela, na abara propriedades, mude o “Nome do Espaço” para o nome do caso de uso em questão, no caso “ConsultarPais”, como mostra a figura;

27

12.No Diagrama de Atividade não é permitido criar transições entre duas ações com estereótipos <<FrontEndView>>. É necessário criar uma ação que representará o lado do servidor. Como exemplo, criamos uma ação com o nome Consulta Pais. Esta ação deverá possuir um deferrable event para o método criado no controlador. Para isso devemos: (ver figura abaixo)

a) Criar a ação:

28

b) Adicione à ação “Consulta Pais”, um novo “Evento Deferível” do tipo “Evento de Invocação”;

c) No campo “Operações” escolher o método consultaPais e não precisa nomear a chamada ao método;

29

13.Criar uma transição entre a ação de FrontEndView e a ação criada no item anterior;

Clique sobre a transição com o botão direito e escolher a opção Specification, o trigger desta transição deve ser do tipo signal. Como exemplo, editamos o trigger colocando o nome consulta;

a) Criar os parâmetros codigo, codigoAuxiliar, valor, descrição e preencher os campos abaixo:

•Name : codigo (exemplo),•Tipo: String (ver documentação dos tipos utilizados)•Direção Tipo: inout

30

b) Abaixo a visualização dos parâmetros criados;

14.Até aqui você definiu as ações que serão executadas para exibir o formulário de preenchimento das informações para consulta de um país, e já é possível visualizar este formulário executando a aplicação. Para tal execute os seguintes passos:

a) Copie as implementações das classes ControleAcessoImpl (<DiretorioProjeto>/core/cs/compartilhado/src/java/accessControl) e OperadorCaDAOImpl (<DiretorioProjeto>/core/cd/src/java/br/gov/controleacesso/cd, são ambas, classes implementadas pela UFRJ para Controle de Acesso)

Obs: Não copie o arquivo, substituindo um pelo outro, apenas substitua o seu conteúdo.

b) É necessário criar o arquivo SuportePais-port.properties no diretório server\default\conf do Jboss, com o seguinte conteúdo:

http.port=8080https.port=8443troca.de.porta.gerenciada.pela.aplicacao=falsejboss.ip.local=127.0.0.1aplicacao.permite.uso.back.browser=true

c) Alterar o arquivo login-config.xml do jboss (jboss\server\default\conf) incluindo a tag application-policy com a configuração de autenticação do projeto.

<application-policy name="SuportePais"> <authentication> <login-module code="org.jboss.security.ClientLoginModule" flag="required"/>

<login-module code="accessControl.LoginModuleImpl" flag="required">

31

<module-option name="dsJndiName">postgresDS</module-option> <module-option name="unauthenticatedIdentity">guest</module-option> <module-option name="principalClass">accessControl.PrincipalImpl</module-option> <module-option name="hashEncoding">hex</module-option> <module-option name="hashAlgorithm">md5</module-option>

<module-option name="principalsQuery">select SENHA from OP_CA where LOGIN=?</module-option>

<module-option name="rolesQuery">select PO.ID, 'Roles'from OP_CA OP,CONTEXTO_CA CTX,CONTEXTO_CA_PF_OP_CA CPO,PF_OP_CA POwhere OP.LOGIN=?and CTX.OP_CA_FK = OP.IDand CTX.ID = CPO.CONTEXTO_CA_FKand CPO.PF_OP_CA_FK = PO.ID

</module-option> </login-module>

</authentication></application-policy>

d) Salve o projeto (Ficheiro -> Guardar Projeto) no caminho <DiretorioProjeto>\mda\src\uml\<NomeProjeto>.zargo. Onde <NomePojeto> deve ser igual ao nome dado ao projeto no momento de sua criação, de acordo com a resposta dada ao AndroMDA.

e) Exporte o projeto para o formato *.XMI ((Ficheiro -> Exportar XMI...) também para o diretório <DiretorioProjeto>\mda\src\uml\

f) O AndroMDA reconhece arquivos com estrutura de um XMI, porém se eles estiverem com a extensão “*.xml”. Então renomeie seu arquivo <NomeProjeto>.xmi para <NomeProjeto>.xml

g) No prompt de comando, entrar no diretório <DiretorioProjeto> e executar o comando maven. Isso validará o modelo do ArgoUML e gerará as classes Java. O resultado apresentado deve ser “BUILD SUCCESFULL”.

h) Rodar o script de criação das tabelas (schema_create.sql), que se encontra no caminho <DiretorioProjeto>\core\cd\target

i) Rodar os scripts de criação do super usuário e do guest

j) Rodar o script de criação dos serviços (controle de acesso), que se encontram no caminho, <DiretorioProjeto>\core\cs\compartilhado\target\src\accessControl

32

(Serviços.sql – por default este script é gerado para banco Oracle, para outro banco ele deve ser modificado)

Observação:Na geração dos scripts de banco, o maven utiliza o arquivo

abreviacoes.properties em <DiretorioProjeto>, que contem as abreviações que serão utilizadas nas definições dos nomes das tabelas, sequences, etc. Este arquivo é necessário quando os nomes gerados pelo AndroMDA forem grandes podendo causar conflitos devido a perda de informação causada pela limitação de caracteres nas definições dos nomes no banco de dados.

O Andromda verifica se nesse arquivo existe alguma abreviação para as tabelas, sequences, etc, geradas pelo banco, caso exista, ao invés de gerá-las com o nome anterior, ele gera com a abreviação, diminuindo o risco de ocorrer conflitos de nomes.

Exemplo:MENSAGEM=MSGNIVEIS=NIVSNIVEL=NIVNOME=NMSEQUENCIA=SEQSERVICO=SVSISTEMA=SISTEXTO=TXTTEXTUAL=TXTTIPO=TP

k) Ainda no <DiretorioProjeto> executar o comando maven deploy. Este irá gerar um pacote do projeto e copiará o arquivo para o Jboss.

l) Para ver a tela gerada, inicie o Jboss através do eclipse e abra um browser e acesse o endereço http://localhost:8080/<nome do projeto>/.

Por exemplo: http://localhost:8080/SuportePais/Na tela de login entre com o login e senha do super usuário (login: su e senha: su).

Após será apresentada a tela de consulta “Preencha os Dados da Consulta de Pais”

33

http://localhost:8080/SuportePais/

Observe que ao clicar no botão “Consulta” aparecerá uma página em branco. Isso ocorre porque apenas foram descritas as atividades necessárias para a exibição da tela de filtro (primeiro formulário) e nenhuma atividade para execução da consulta, as quais serão definidas nos seguintes passos:

1.Para exibir o resultado da consulta na tela é necessário criar, no Diagrama de Atividades ConsultarPaisDA, uma nova atividade com o estereótipo FrontEndView com uma transição que parte da ação consultaPais. Vamos chamar essa nova atividade de “Resultado da Consulta de Pais”, que tem a finalidade de exibir os países retornados na consulta em uma tabela, exibindo como colunas os campos código e valor.

34

Observe que à atividade “Resultado da Consulta Pais” foi atribuído o estereótipo “FrontEndView”, definindo a atividade como responsável pela construção de uma página JSP para exibição dos dados.

2.Como descrito anteriormente associe a transição entre as atividades “ConsultaPais” e “Resultado da Consulta de Pais” à uma trigger do tipo signal. Para isso:

a) Clique na última transição criada. Na parte de baixo da tela, na aba propriedades, clique com o botão direito no campo “Disparador” e adicione um novo “Signal Event”.

O resultado da consulta será uma coleção de países, os quais serão obtidos na execução do método da atividade “consultaPais” e serão repassados para a atividade “Resultado da Consulta de Pais”. Sendo assim, execute os passos abaixo para formatar a exibição da Collection em uma tabela:

c) Na tela de edição do Signal Event criado, na aba “Propriedades”, clique com o botão direito no campo “Parâmetros” e clique em “Novo Parâmetro”.

35

d) Crie o parâmetro preenchendo o campo “Nome” com o valor “paises” e altere o campo “Tipo” para Collection.

e) Na aba “Valores Marcados”, ainda na mesma janela, selecione a “Marca” “@andromda.presentation.view.table.columns” e digite no campo “Valor”: “codigo, valor”

O preenchimento dessa tag indica quais atributos da coleção paises devem ser exibidos na tabela que apresentará o resultado da consulta.

3.Para finalizar o diagrama de atividades, é necessário adicionar um estado final, com o nome do caso de uso que será invocado após o término deste caso de uso. Como exemplo, criamos um estado final que volta para o caso de uso principal da aplicação, nesse exemplo o caso de uso ConsultarPais.

36

4.O último passo é criar uma transição entre a ação “Resultado da Consulta de Pais”, para o estado final criado anteriormente. Esta transição também deverá ter um disparador do tipo “Signal Event”, com “Nome” “voltar” e sem parâmetros. Esse nome será atribuído a um botão gerado para executar a ação que, nesse exemplo, irá voltar para o caso de uso principal.

37

A figura abaixo mostra o digrama de atividades do caso de uso ConsultarPais;

Agora vamos criar um diagrama de classes:

5.Dentro do pacote cadastroPais, crie o diagrama de classe com o nome Servico2CadastroPais e arraste para ele as classes ConsultaPaisControle e PaisHandler.

6.Criar uma dependência entre a classe ConsultaPaisControle e PaisHandler, como na figura abaixo. Dessa forma, está sendo definido que a classe de controle “ConsultaPaisControle” pode invocar métodos da classe de serviço “PaisHandler”.

38

7.Salve o projeto (Ficheiro -> Guardar Projeto) no caminho <DiretorioProjeto>\mda\src\uml\<NomeProjeto>.zargo. Onde <NomePojeto> deve ser igual ao nome dado ao projeto no momento de sua criação, de acordo com a resposta dada ao AndroMDA.

8.Exporte o projeto para o formato *.XMI ((Ficheiro -> Exportar XMI...) também para o diretório <DiretorioProjeto>\mda\src\uml\

9.O AndroMDA reconhece arquivos com estrutura de um XMI, porém se eles estiverem com a extensão “*.xml”. Então renomeie seu arquivo <NomeProjeto>.xmi para <NomeProjeto>.xml.

10.Valide o modelo gerado até o momento. No prompt de comando, entrar no diretório <DiretorioProjeto> e executar o comando maven. O resultado apresentado deve ser “BUILD SUCCESFULL”.

11. Executar o comando maven deploy.

12.Para ver a tela gerada, abra um browser e acesse o endereço http://localhost:8080/<nome do projeto>. Garanta que o JBoss esteja rodando.

Por exemplo: http://localhost:8080/SuportePais/

Observe que, desta vez, ao clicar no botão “Consulta”, no formulário de filtro, aparecerá uma tela com título “Resultado da Consulta de Pais” com um botão “Voltar”. Se você clicar no botão “Voltar”, você será redirecionado para a tela principal, que neste caso, é a tela de filtro.

A consulta não retornou nenhum resultado, pois não foi especificado nenhuma implementação para obter os países e exibi-los. Além disso, provavelmente a tabela de países ainda está vazia.

39

3.2.6 Implementação do Código da Consulta

O primeiro passo é importarmos o projeto para dentro do Eclipse. Para isso:

1.Abra o eclipse, clique em File - > Import e escolha a opção “Existing Projects into Workspace”.

2.Na janela seguinte indicar o caminho para <DiretorioProjeto>, selecionar o projeto e clicar em Finish.

40

3.Uma vez que o projeto seja importado vários erros de dependência não resolvidas serão apresentados pelo Eclipse. Para resolver as dependências é necessário criar uma variável no Eclipse chamada MAVEN_REPO. Para isso clique com o botão direito do mouse sobre o projeto no Package Explorer e selecione a opção Properties.

4.Na janela “Properties for <NomeProjeto>” selecione no menu do lado direito a opção Java Build Path e clique no botão “Add Variable...” da aba “Libraries”.

41

5.Na janela “New Variable Classpath Entry” clique no botão “Configure Variables...”, na próxima janela “Preferences” clique no botão “New...”. Nos campos “Name” e “Path”, da janela “New Variable Entry” digite respectivamente: MAVEN_REPO e o caminho para o diretório <user>\.maven\repository.

42

6.Clique no botão “OK” nas janelas “Preferences” e “New Variable Entry”.

7.Na janela “New Variables Classpath Entry” selecione a variável “MAVEN_REPO” e clique no botão “Extend...”

43

8.Na janela “Variable Extension” selecione todas os arquivos “.jar” abaixo e clique em OK.

•MAVEN_REPO/struts/jars/struts-1.2.8.jar•MAVEN_REPO/servletapi/jars/servletapi-2.4-20040521.jar•MAVEN_REPO/hibernate/jars/hibernate-3.1.3-coppetec.jar"•MAVEN_REPO/jboss/jars/jboss-j2ee-4.0.2.jar•MAVEN_REPO/dom4j/jars/dom4j-1.4-dev-8.jar•MAVEN_REPO/commons-logging/jars/commons-logging-1.0.4.jar•MAVEN_REPO/commons-validator/jars/commons-validator-1.1.4.jar•MAVEN_REPO/commons-beanutils/jars/commons-beanutils-1.7.0.jar•MAVEN_REPO/commons-lang/jars/commons-lang-2.1.jar

Com o eclipse configurado, iremos implementar o código específico para executar a consulta de países e repassar a coleção resultante para ser exibida na página de resultados.

44

1.Primeiro implementaremos a chamada para o método da classe de serviço a partir da classe de controle, ou seja, vamos implementar a chamada para o método “manipulaPais” da classe de serviço “PaisHandler” a partir do método “consultaPais” da classe “ConsultaPaisControleImpl” que implementa a classe de controle.

2.No Eclipse abra o arquivo: <DiretorioProjeto>/web/src/java/<PacoteProjeto>/web/cadastroPais/consultaPais/ConsultaPaisControleImpl.java

3.O objeto dessa classe será responsável por receber a solicitação do browser quando o usuário preencher os critérios de pesquisa e clicar no botão “Consulta”. O método “consultaPais” não recebe os atributos modelados na classe de controle “ConsultaPaisControle”, no entanto, esse método recebe um atributo do tipo “ConsultaPaisForm”. Esse atributo contém os parâmetros de entrada do formulário preenchido pelo usuário. Esse método deve ser desenvolvido de forma semelhante ao exemplo abaixo:

public final void consultaPais(ActionMapping mapping, br.gov.tutorial.web.cadastroPais.consultaPais.ConsultarPaisForm form, HttpServletRequest request, HttpServletResponse response) throws Exception{

Integer paginacao = (((Integer) request.getAttribute(Constantes.PARAMETRO_GRUPO)));

PaisVO paisVO = new PaisVO();paisVO.setCodigo(form.getCodigo());paisVO.setCodigoAuxiliar(form.getCodigoAuxiliar());paisVO.setDescricao(form.getDescricao());paisVO.setValor(form.getValor());Collection paises = getPaisHandler(request).manipulaPais(new PaisImpl(), new FilterAction(paisVO, paginacao));form.setPaises(paises);

}

Após implementação, é necessário importar as classes dos objetos utilizados. Para isso, clique em ctrl + shift + o, todos ao mesmo tempo.

Observe que há uma variável chamada paginacao. Essa variável é criada automaticamente pelo Maven e é utilizada quando o retorno pode ser muito longo. Assim, é possível dividir a lista retornada pela consulta em diferentes páginas.

45

A especialização do Maven também gera automaticamente sobrecargas dos métodos modelados nas camadas de serviço e controle com um parâmetro extra chamado paginacao, para que seja possível requisitar para essas camadas a página desejada e obter somente os registros pertinentes à essa página. Não é necessário incluir esse atributo na modelagem.

4.O próximo passo consiste na implementação da consulta para obter os países, a qual é implementada na classe DAO (Data Access Object). Para especificação da consulta a ser realizada utilizaremos um objeto da classe “Criteria”: definiremos que a consulta deve ser realizada sobre a classe “Pais” e em seguida definiremos os critérios de filtro a serem executados.

5.No Eclipse abra o arquivo: <DiretorioProjeto>/core/cd/src/java/<PacoteProjeto>/cd/PaisDAOImpl.java

6.No método “handleFilter” criaremos um objeto do tipo Criteria onde encapsularemos os critérios de filtragem das informações de nossa consulta. Isso significa que esse objeto irá levar ao Hibernate as restrições da consulta. Esse mesmo objeto será retornado pelo método, pois será reutilizado para a paginação. Caso queira saber sobre o hibernate consulte o (Hibernate Reference Documentation), no capitulo 15 – criteria queries.

protected Object handleFilter(br.gov.tutorial.cd.ValueObject vo)throws br.gov.tutorial.cd.DAOException {

Session session = AbstractDAO.currentSession();Criteria criterios = session.createCriteria(PaisImpl.class);if(vo instanceof PaisVO){ PaisVO paisVO = (PaisVO)vo; Pais pais = new PaisImpl(); if ((paisVO.getCodigo()!= null) && (!paisVO.getCodigo().equals(""))){ pais.setCodigo(paisVO.getCodigo()); } if ((paisVO.getCodigoAuxiliar()!= null) && (!paisVO.getCodigoAuxiliar().equals(""))){ pais.setCodigoAuxiliar(paisVO.getCodigoAuxiliar()); } if( (paisVO.getDescricao()!= null) && (!paisVO.getDescricao().equals(""))){ pais.setDescricao(paisVO.getDescricao()); } if( (paisVO.getValor()!= null) && (!paisVO.getValor().equals(""))){ pais.setValor(paisVO.getValor()); }

criterios.add(Example.create(pais).enableLike(MatchMode.ANYWHERE));}return criterios; }

46

7.Salve os arquivos no Eclipse, abra um terminal e, no diretório do projeto, execute o comando maven core deploy.

8.Inicie o Jboss e abra um browser e acesse o endereço http://localhost:8080/<nome do projeto>/.


3.3 Caso de uso “DetalharPais”

O caso de uso de detalhamento é estendido pelo caso de uso de consulta. Isso significa que ele pode ou não ser executado após o caso de uso de consulta. Esse caso de uso é responsável pela exibição do detalhamento de um pais, a partir de um país escolhido da listagem do resultado da consulta.


O método necessário na camada de domínio para realizar o detalhamento é um que recupere um Pais de acordo com id. A camada de domínio não será alterada pois toda classe DAO já contém um método gerado que retorna a entidade de acordo com o id passado.

3.3.2 Camada de Serviço

A camada de serviço não será alterada pois iremos utilizar o método manipula que é gerado através da dependência entre PaisHandler e Pais.


1.No ArgoUML abra o diagrama de atividades “ConsultarPaisDA”.

2.Crie um estado final chamado “DetalharPais”

3.Crie uma transição entre os estados “Resultado da Consulta de Pais” e o estado final “DetalharPais”.

4.Como descrito anteriormente, associe a essa transição entre os estados um disparador do tipo “Signal Event”, com o nome “detalhar” e com um parâmetro id do tipo “Long”. Para isso:

47


a) Clique na transição criada. Na parte de baixo da tela, na aba propriedades, clique com o botão direito no campo “Disparador” e adicione um novo “Signal Event”.

b) Na tela de edição do Signal Event criado, na aba “Propriedades”, ponha o campo “Nome” com o valor “detalhar”.

c) Na mesma tela, clique com o botão direito no campo “Parâmetros” e clique em “Novo Parâmetro”.

d) Crie o parâmetro preenchendo o campo Name com o valor “id” e altere o campo “Tipo” para “Long”.

e) Na aba “Valores Marcados”, ainda na mesma janela, selecione a “Marca” “@andromda.presentation.web.view.field.type” e digite no campo “Valor”: “plaintext”.

48

5. Clique na transição criada no item 3 e, na parte de baixo da tela, na aba “Valores Marcados”, selecione a marca “@andromda.presentation.web.action.tablelink” e digite no campo “Valor”: “paises.codigo”. Esse é o nome da coluna da tabela que será composta de links. É necessário definir de que Collection o campo que será hiperlink, por isso é necessário especificar como paises.codigo.

6. Adicione ainda uma marca “@andromda.presentation.web.action.type” e digite no campo “Valor”: “hyperlink”.

O diagrama de Atividades “ConsultarPaisDA” ficará da seguinte forma:

7.Crie agora um caso de uso chamado “DetalharPais” com o estereótipo <<FrontEndUseCase>> dentro da árvore de diretórios cadastroPais.detalhaPais. O pacote detalhaPais deverá ser criado, assim como um diagrama de casos de uso (utilização).

49

8.Dentro do pacote cadastroPais.detalhaPais, crie uma classe de controle

9. Dentro do pacote cadastroPais.detalhaPais, crie um diagrama de classes com um nome qualquer;

10.Criar uma classe de controle chamada “DetalhaPaisControle” com um método chamado “recuperaPais” que recebe um id do tipo Long como parâmetro e retorna void;

50

11.No diagrama de classes “Servico2CadastroPais” inclua a classe “DetalhaPaisControle” e crie uma dependência para a classe “PaisHandler”. Para incluir a classe “DetalhaPaisControle” no diagrama basta arrastá-la.

12.Crie um diagrama de atividades chamado “DetalharPaisDA” abaixo da classe de controle.

13. Para que a classe DetalhaPaisControle possa ser referenciada no Diagrama de Atividades do caso de uso em questão, é necessário que ela seja relacionada ao diagrama.

a) Para isso, clique no diagrama de atividades e, na parte inferior da tela, na abara propriedades, mude o “Nome do Espaço” para o nome do caso de uso em questão, no caso “DetalharPais”, como mostra a figura;

51

14. No diagrama de atividades, crie um estado inicial, uma estado chamado “Recupera Pais” e crie uma transição entre elas.

15. Na aba “Propriedades” do estado “Recupera Pais”, clique com o botão direito no campo de “Eventos Deferíveis” e adicione um novo evento deferível do tipo “Evento de invocação”.

16. Associe o evento ao método “recuperaPais” da classe “DetalhaPaisControle”.

17.Crie um estado com o estereótipo “FrontEndView” chamado “Detalhamento do Pais”.

18.Crie uma transição entre os estados e crie para ela um disparador sem nome do tipo “Signal Event”.

52

19. Crie um estado final com o nome “ConsultarPais”. Isso significa que após o detalhamento o usuário poderá fazer uma nova consulta.

20. Crie uma transição entre o estado “Detalhamento do Pais” e o estado final “ConsultarPais” com um disparador do tipo “Signal Event”, chamado “Nova Consulta” e com os parâmetros: codigo, codigoAuxiliar, valor, descricao do tipo String e id do tipo Long.

53

21.Para cada parâmetro criado, na aba “Valores Marcados” selecione a opção “@andromda.presentation.web.view.field.type” e digite o valor “plaintext” para os parâmetros codigo, codigoAuxiliar, valor e descricao. E a valor “hidden” para o parâmetro id, ao invés de plaintext.

É importante observar que a opção “plaintext faz com que o parâmetro seja exibido como label no formulário web. No entanto, essa opção só funciona com parâmetros do tipo String. Caso os parâmetros sejam de outros tipos as ações do formulário podem não funcionar.

54

O diagrama de atividades ficará como a figura abaixo:

Mas, ainda há mais coisas a fazer nessa parte. Lembra da classe UnidadeFederativa? Pois bem, queremos que ela seja exibida na tela também. Para isso vamos fazer o seguinte:

1. Abra a aba de propriedades da transição do “Recupera Pais” para o “Detalhamento do pais” e dê dois cliques sobre o disparador.

2. Inclua ao disparador um novo parâmetro com o nome “ufs” do tipo “Collection”.

55

3. Agora, na aba de propriedades da transição com o disparador “Nova Consulta”, dê dois cliques no disparador e depois dois cliques no parâmetro “id”.

4. Na edição do parâmetro id, na aba “Valores Marcados”, selecione a opção “@andromda.presentation.view.table.columns” e digite o valor “codigo, descricao”.

Para ver a tela gerada, rode o comando maven install deploy no prompt de comando, inicialize o JBoss, abra um browser e acesse o endereço http://localhost:8080/<nome do projeto>/. Por exemplo:

http://localhost:8080/SuportePais

56

http://localhost:8080/SuportePais

3.3.4 Implementação do Código do Detalhamento

1.No Eclipse abra o arquivo: <DiretorioProjeto>/web/src/java/<PacoteProjeto>/web/cadastroPais/detalhaPais/DetalhaPaisControleImpl.java

O método “recuperaPais” deve ser desenvolvido de forma semelhante ao exemplo abaixo. Lembre-se de fazer os imports necessários.

public final void recuperaPais(ActionMapping mapping, br.gov.tutorial.web.cadastroPais.detalhaPais.RecuperaPaisForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

Pais pais = new PaisImpl();pais.setId(form.getId());pais = (Pais)getPaisHandler(request).manipulaPais(pais, new SelectAction()).get(0);form.setCodigo(pais.getCodigo());form.setCodigoAuxiliar(pais.getCodigoAuxiliar());form.setValor(pais.getValor());form.setDescricao(pais.getDescricao());form.setUfs(pais.getUnidadeFederativas());form.setId(pais.getId()); }

2.Salve o arquivo no Eclipse, abra um terminal e, no diretório do projeto, execute o comando maven install deploy. Inicialize o JBoss conforme descrito anteriormente e no browser teste a aplicação na url: http://localhost:8080/SuportePais/

3.4 Caso de uso “AlterarPais”

Este caso de uso pode ser invocado a partir da listagem de países resultante da consulta de países e a partir do detalhamento de um país.


Os métodos necessários na camada de domínio para realizar a alteração são: um que recupere um Pais de acordo com id e outro para alterar efetivamente um pais. A camada de domínio não será alterada pois toda classe DAO já contém esses métodos gerados automaticamente.



57


Como o caso de uso “AlterarPais” pode ser chamado a partir da listagem de países da consulta de países, devemos criar um estado final na consulta que irá invocar o caso de uso “AlterarPais”:

1.No ArgoUML abra o diagrama de atividade “ConsultarPaisDA”2.Crie um estado final com nome “AlterarPais”3.Crie uma transição entre o estado “Resultado da Consulta de Pais” e o estado final “AlterarPais” com um disparador do tipo “Sinal Event” com nome “alterar” e com um parâmetro chamado ”id” do tipo “Long”.

4.Na especificação do parâmetro id, na aba “Valores Marcados”, selecione a opção “@andromda.presentation.web.view.field.type” e digite o valor ”plaintext”

58

5. Clique na transição entre “Resultado da Consulta de Pais” e o estado final “AlterarPais” e, na parte de baixo da tela, na aba “Valores Marcados”, selecione a marca “@andromda.presentation.web.action.tablelink” e digite no campo “Valor”: “paises”.

6. Adicione ainda uma marca “@andromda.presentation.web.action.type” e digite no campo “Valor”: “form”;

O Diagrama de Atividades “ConsultarPaisDA” ficará da seguinte forma:

59

Como o caso de uso “AlterarPais” também pode ser chamado partir do detalhamento de um país, devemos também criar um estado final no detalhamento que irá invocar o caso de uso “AlterarPais”:

1.Abra o diagrama de atividades “DetalharPaisDA”2.Crie um estado final com o nome “AlterarPais”3.Crie uma transição entre o estado “Detalhamento do Pais” e o estado final “AlterarPais” com um disparador do tipo “Signal Event”, com nome “alterar” e parâmetro “id” do tipo “Long”.

4. Na tela de especificação do parâmetro “id”, na aba “Valores Marcados”, selecione a marca “@andromda.presentation.web.view.field.type” e digite no campo “Valor”: “hidden”.

Agora vamos modelar o caso de uso “AlterarPais”:

1.Crie um caso de uso chamado “AlterarPais” com o estereótipo <<FrontEndUseCase>> dentro da arvore de diretórios cadastroPais.alteraPais. A pasta “alteraPais” deve ser criada.2.Crie uma classe de controle chamada “AlteraPaisControle”3.Sob esta classe, Crie um diagrama de atividades chamado “AlterarPaisDA”.

60

4.Na classe “AlteraPaisControle” crie um método chamado “recuperaPais” que retorna “void” e recebe como parâmetro “id” do tipo “Long”.

5.Associe o diagrama de atividades (“unnamed ActivityGraph”) ao diagrama “AlterarPais”.

6.No diagrama “AlterarPaisDA”, crie um estado inicial, um estado chamada “Recupera Pais” e crie uma transição entre elas.

7.Na aba “Propriedades” do estado “Recupera Pais”, adicione um evento deferível, do tipo “Evento de Invocação”, associado ao método “recuperaPais” da classe “AlteraPaisControle”.

61

8.Crie uma ação com o estereótipo <<FrontEndView>> chamada “Preencha os Campos para Alteracao”

9.Crie uma transição entre as ações “Recupera Pais” e “Preencha os Campos para Alteração”

10.Crie uma ação chamada “Altera Pais” e crie uma transição entre a ação “Preencha os Campos para Alteracao” e a ação criada.

62

11. Nesta última transição crie um disparador do tipo “Signal Event” com o nome “Salvar” e adicione os atributos: id (Long), codigo (String), codigoAuxiliar (String), valor (String), descricao (String). Este disparador gerará um botão na tela de alteração. Os parâmetros do disparador representam os dados modificados que devem sem aplicados no objeto pais.

12. Na tela de especificação do parâmetro “id”, na aba “Valores Marcados”, selecione a marca “@andromda.presentation.web.view.field.type” e digite no campo “Valor”: “hidden”.

13. Para cada um dos outros parâmetros, na aba “Valores Marcados”, selecione a marca “@andromda.presentation.view.field.required” e digite no campo “Valor”: “true”.

63

14.Crie uma operação na classe “AlteraPaisControle” chamada “alteraPais” que retorna void e recebe como parâmetros id (Long), codigo (String), codigoAuxiliar (String), valor (String), descricao (String).

15. Crie um evento deferível do tipo “Evento de Invocação” para a ação “Altera Pais”, associado ao método “alteraPais” da classe “AlteraPaisControle”.

16.Crie um estado final com o nome “ConsultarPais”.

17.Crie uma transição entre a ação “Altera Pais” e o estado final.

64

18.No diagrama de classes “Servico2CadastroPais” inclua a classe “AlteraPaisControle” e crie uma dependência para a classe “PaisHandler”. Par incluir a classe “AlteraPaisControle” no diagrama basta arrastá-la

19.Para ver a tela gerada, rode o comando maven install deploy no prompt de comando, inicialize o JBoss, abra um browser e acesse o endereço http://localhost:8080/<nome do projeto>/.

Por exemplo:http://localhost:8080/SuportePais/

3.4.4 Implementação do Código do Alterar Pais

1. No Eclipse abra o arquivo:<DiretorioProjeto>/web/src/java/<PacoteProjeto>/web/cadastroPais/alteraPais/AlteraPaisControleImpl.java

Esta classe implementa dois métodos (recuperaPais e alteraPais) que devem ser desenvolvido de forma semelhante ao exemplo abaixo. Lembre-se de fazer os imports necessários.

65


public final void recuperaPais(ActionMapping mapping, br.gov.tutorial.web.cadastroPais.alteraPais.RecuperaPaisForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

Pais pais = new PaisImpl();pais.setId(form.getId());pais =(Pais)getPaisHandler(request).manipulaPais(pais, new SelectAction()).get(0);form.setCodigo(pais.getCodigo());form.setCodigoAuxiliar(pais.getCodigoAuxiliar());form.setDescricao(pais.getDescricao());form.setValor(pais.getValor());form.setId(pais.getId());

}

public final void alteraPais(ActionMapping mapping, br.gov.tutorial.web.cadastroPais.alteraPais.AlteraPaisForm form, HttpServletRequest request, HttpServletResponse response)throws Exception {

try { Pais pais = new PaisImpl(); pais.setId(form.getId());

pais =(Pais)getPaisHandler(request).manipulaPais(pais, new SelectAction()).get(0); pais.setCodigo(form.getCodigo()); pais.setCodigoAuxiliar(form.getCodigoAuxiliar()); pais.setValor(form.getValor()); pais.setDescricao(form.getDescricao()); getPaisHandler(request).manipulaPais(pais, new UpdateAction()); saveWarningMessage(request,"sucesso.alteracao.pais"); ((PreenchaOsCamposParaAlteracaoSalvarFormImpl)form).clean(); } catch (Exception e) { saveErrorMessage(request,"erro.alteracao.pais"); ((PreenchaOsCamposParaAlteracaoSalvarFormImpl)form).clean(); e.printStackTrace(); }}

2.Salve os arquivos no Eclipse, abra um terminal e, no diretório do projeto, execute o comando maven install deploy.

3.Inicialize o JBoss conforme descrito anteriormente e no browser teste a aplicação na url: http://localhost:8080/SuportePais/

66

3.5 Caso de uso “IncluirPais”

O caso de uso de inclusão é estendido pelo caso de uso de consulta. Isso significa que ele pode ou não ser executado após o caso de uso de consulta. Esse caso de uso recebe os valores dos atributos do país permitindo a criação de um novo país de acordo com os valores informados pelo autor.


O método necessário na camada de domínio para realizar a inserção é um que insira um pais de acordo com os campos preenchidos na tela de inserção. A camada de domínio não será alterada pois toda classe DAO já contém esse método gerado automaticamente.




1.No ArgoUML abra o diagrama de atividade “ConsultarPaisDA”.2.Crie um novo estado final chamado “IncluirPais” e crie uma transição entre a ação “Preencha os Dados da Consulta de Pais” e o estado final criado com um disparador do tipo “Signal Event” com nome “Incluir”.

67

3. Crie uma transição entre a ação “Resultado da Consulta de Pais” e o estado final com nome “IncluirPais” com um um disparador do tipo “Signal Event” com nome “Incluir”.

4.Crie um caso de uso chamado “IncluirPais” com o estereótipo <<FrontEndUseCase>> dentro da árvore de diretórios cadastroPais.incluiPais. O pacote “incluiPais” deve ser criado.

5.Crie uma classe de controle chamada “IncluiPaisControle”

6.Crie um diagrama de atividades chamado “IncluirPaisDA” sob a classe “IncluiPaisControle”.

68

7. Associe o diagrama de atividades (“unnamed ActivityGraph”) ao diagrama “IncluirPais”.

8.Na Classe “IncluiPaisControle” crie uma operação chamada “incluiPais” que retorna “void” e possui os parâmetros que serão utilizados na criação no novo país.

No nosso exemplo, inclua os parâmetros codigo (String), codigoAuxiliar (String), valor (String), descricao (String).

9.No diagrama “IncluirPaisDA”, crie um estado inicial, uma ação chamada “Preencha os Dados de Pais” com o estereótipo <<FrontEndView>> e uma transição entre elas.

10. Crie uma ação chamada “Inclui Pais”.

11. Na tela de especificação da ação “Inclui Pais”, adicione um evento deferível do tipo “Evento de Invocação” associado ao método “incluiPais” de IncluiPaisControle.

69

12. Crie uma transição entre as ações “Preencha os Dados de Pais” e “Inclui Pais” com um disparador do tipo “Signal Event”, com o nome “incluir” e parâmetros correspondentes a cada atributo da classe “IncluiPaisControle”, ou seja, codigo (String), codigoAuxiliar (String), valor (String), descricao (String).

13.Para cada parâmetro criado, na aba “Valores Marcados” selecione a opção “@andromda.presentation.view.field.required” e digite no campo “Valor”: “true”.

14.Crie uma nova ação chamada “Resultado da Insercao” com o estereótipo <<FrontEndView>>.

15.Crie uma transição entre as ações “Inclui Pais” e “Resultado da Insercao”.

16.Crie um estado final com o nome “IncluirPais”.

17.Crie uma transição entre “Resultado da Inserção” e o estado final “IncluirPais” com um disparador do tipo “Signal Event” com nome “Nova Inclusao”.

70

18.Crie um estado final com o nome “ConsultarPais”.

19.Crie uma transição entre “Resultado da Insercao” e o estado final “ConsultarPais” com um disparador do tipo “Signal Event” com nome “Nova Consulta”.

O diagrama de Atividades “IncluirPaisDA” ficará da seguinte forma:

71

20. No diagrama de classes “Servico2CadastroPais” inclua a classe “IncluiPaisControle” e crie uma dependência para a classe “PaisHandler”. Par incluir a classe “IncluiPaisControle” no diagrama basta arrastá-la.

21. Para ver a tela gerada, rode o comando maven install deploy no prompt de comando, inicialize o JBoss, abra um browser e acesse o endereço http://localhost:8080/<nome do projeto>/.


3.5.4 Implementação do Código da Inclusão

1.No Eclipse abra o arquivo: <DiretorioProjeto>/web/src/java/<PacoteProjeto> /web/cadastroPais/incluiPais/IncluiPaisControleImpl.java

Esta classe implementa o método “incluiPais” que deve ser desenvolvido de forma semelhante ao exemplo abaixo. Lembre-se de fazer os imports necessários.

public final void incluiPais(ActionMapping mapping,br.gov.tutorial.web.cadastroPais.incluiPais.IncluiPaisForm form, HttpServletRequest request, HttpServletResponse response)throws Exception{

try {Pais pais = new PaisImpl();

72

pais.setCodigo(form.getCodigo());pais.setCodigoAuxiliar(form.getCodigoAuxiliar());pais.setValor(form.getValor());pais.setDescricao(form.getDescricao());getPaisHandler(request).manipulaPais(pais, new InsertAction());saveWarningMessage(request,"sucesso.insercao.pais");

} catch (Exception e) {

saveErrorMessage(request,"erro.insercao.pais");e.printStackTrace();

}}

2.Salve os arquivos no Eclipse, abra um terminal e, no diretório do projeto, execute o comando maven install deploy. Inicialize o JBoss e teste a aplicação na url: http://localhost:8080/SuportePais/

3.6 Caso de uso “ExcluirPais”

O caso de uso de exclusão pode ser entendido como um caso de uso de Detalhamento, onde a diferença está que no caso de exclusão, o usuário só pode excluir.

Esse caso de uso exibe o detalhamento das informações de um determinado país, escolhido da listagem de países retornados pela consulta. Depois de ter entrado no detalhamento o usuário clica no botão excluir caso queira excluir algum dos registros.


O método necessário na camada de domínio para realizar a remoção é um que remova um pais. A camada de domínio não será alterada pois toda classe DAO já contém esse método gerado automaticamente.




73

1.No diagrama “ConsultarPaisDA” crie uma nova transição entre a ação “Resultado da Consulta de Pais” e o estão final “DetalharPais” com um disparador do tipo “Signal Event” com nome “excluir” com parâmetro “id” do tipo “Long”.

2.Na especificação do parâmetro id do item 1, na aba de valores marcados, adicione a marca “@andromda.presentation.web.view.field.type” com o valor “plaintext”.

3.Na janela de especificação da transição criada em 1 selecione, na aba de valores marcados, adicione a marca “@andromda.presentation.web.action.tablelink” com o valor “paises” e adicione a marca “@andromda.presentation.web.action.type” com o valor “form”.

74

4.O ConsultarPaisDA ficará da seguinte forma:

5.No Diagrama DetalharPaisDA crie uma nova ação chamada “Deleta Pais”.

6.Crie uma transição entre as ações “Detalhamento do Pais” e “Deleta Pais” com um disparador do tipo “Signal Event” com nome “excluir” e parâmetro “id” do tipo “Long”.

7.Na especificação do parâmetro “id” do item 6, na aba de valores marcados, adicione a marca “@andromda.presentation.web.view.field.type” com o valor “hidden”.

75

8.Crie uma operação chamada “deletaPais” na classe “DetalhaPaisControle” que retorna void e recebe como parâmetro “id” do tipo “Long”.

9. Na ação “Deleta Pais”, adicione um evento deferível do tipo “Evento de Invocação” associado ao método “deletaPais”.

10.Crie uma transição entre a ação “Deleta Pais” e o estado final “ConsultarPais”

76

11.Para ver a tela gerada, rode o comando maven install deploy no prompt de comando, inicialize o JBoss, abra um browser e acesse o endereço http://localhost:8080/<nome doprojeto>/.


3.6.4 Implementação do Código da Exclusão

1.No Eclipse abra o arquivo: <DiretorioProjeto>/web/src/java/<PacoteProjeto> /web/cadastroPais/detalhaPais/DetalhaPaisControleImpl.java

Esta classe implementa dois métodos. O “recuperaPais” já foi implementado neste tutorial. Resta agora implementar o “deletaPais”, que devem estar da seguinte forma:

public void deletaPais(ActionMapping mapping,DeletaPaisForm form, HttpServletRequest request,HttpServletResponse response) throws Exception {

try {Pais pais = new PaisImpl();pais.setId(form.getId());pais =(Pais)getPaisHandler(request).manipulaPais(pais, new

SelectAction()).get(0);getPaisHandler(request).manipulaPais(pais, new DeleteAction());saveWarningMessage(request,"sucesso.remocao.pais");

} catch (Exception e) {

77

saveErrorMessage(request,"erro.remocao.pais");e.printStackTrace();

}}

2.Salve os arquivos no Eclipse, abra um terminal e, no diretório do projeto, execute o comando maven install deploy. Inicialize o JBoss conforme descrito anteriormente e no browser teste a aplicação na url: http://localhost:8080/SuportePais/

3.6.5 Modo de Operação

Do jeito que está modelado até agora, o caso de uso de exclusão está idêntico ao de detalhamento. Para indicar que o botão alterar somente aparecerá no caso de uso de detalhamento, iremos usar o conceito de modo operação, tem com objetivo informar a nível de modelo o que deve ser mostrado na tela do usuário de acordo com o modo de operação. Um modo de operação é o contexto de execução de um determinado caso de uso.

1.Abra o diagrama de atividades ConsultarPaisDA.

2.Na especificação da transição que possui o disparador “detalhar”, na aba de valores marcados, adicione a marca ”@andromda.presentation.action.input.operation.mode” com o valor “detalhar”. Essa marca indica que ao acessar o caso de uso “DetalharPais” por essa transição, o modo operação será o “detalhar”.

3. Adicione ainda a marca “@andromda.presentation.action.keep.operation.mode” com valor “true”.

78


O valor da marca “Input Operation Mode” pode ser um array de String, onde é possível colocar mais de um valor. Ou seja, é possível especificar que ao chamar o caso de uso “DetalharPais” por essa transição, mas de um modo operação estará sendo setado. Para isso, basta separar por ‘,’ (vírgula). A marca “Keep Operation Mode” indica que é para manter o modo operação entre casos de uso.

4.Na especificação da transição que possui o disparador “excluir”, na aba de valores marcados, adicione a marca “@andromda.presentation.action.input.operation.mode” com o valor “excluir”.

5.Adicione ainda a marca “@andromda.presentation.action.keep.operation.mode” com valor “true”.

6.Abra o diagrama DetalharPaisDA.

7.A transição com o dispardor “nova consulta” é apresentada tanto no Detalhar quando na Remoção, assim como a transição com o disparador “excluir”. Portanto, não precisa de modo operação. Já a transição com o disparador “alterar” só estará disponível no caso de uso de detalhamento. Para isso, na especificação da transição

79

“alterar,” na aba de valores marcados, adicione a marca “@andromda.presentation.action.operation.mode” com o valor “detalhar”.

O valor dessa marca também, pode ser um array de String, onde é possível colocar mais de um valor, ou seja, é possível especificar que esse botão será apresentado para mais de um modo operação. Para isso, basta separar por ‘,’ (vírgula).

8.Para ver a tela gerada, rode o comando maven install deploy no prompt de comando, inicialize o JBoss, abra um browser e acesse o endereço http://localhost:8080/<nomedoprojeto>/.


9.O modo operação também pode ser utilizado para campos, de forma a especificar quando um campo de uma tela deve ser apresentado ou não de acordo com o modo operação. Para isso, basta acrescentar o valor marcado “@andromda.presentation.view.field.operation.mode” com o valor do modo operaçao. Este valor é um array de String, podendo conter vários modos operações. Basta colocar os valores separados por ‘,’ (vírgula).

3.6.6 Exclusão Múltipla

Agora, iremos modelar a exclusão múltipla. Ou seja, a partir da listagem de países, iremos poder selecionar vários países e remover todos ao mesmo tempo.

80


1.Abra o diagrama ConsultarPaisDA2.Crie uma ação com o nome “Remove Varios Paises”3.Crie uma transição entre a ação “Resultado da Consulta de Paises” e a ação “Remove Vários Paises” com um disparador tipo “Signal Event”, nome “remove varios” e parâmetro “id” do tipo “Long”.

4.Na especificação do parâmetro “id” do item 3, adicione a marca “@andromda.presentation.web.view.field.type” com o valor “plaintext”.

5.Na janela de especificação da transição criada em 3, na aba de valores marcados, adicione a marca “@andromda.presentation.web.action.tablelink” com o valor “paises”, e a marca “@andromda.presentation.web.action.type” com o valor “table”.

6.Na classe ConsultaPaisControle, crie uma operação chamada “removeVariosPaises” que retorna “void” e recebe como parâmetro “id” do tipo “Long”.

81

7. Na aba de propriedades da ação “Remove Varios Paises”, adicione um evento deferível do tipo “Evento de Invocação”, associado ao método “removeVariosPaises” da classe “ConsultaPaisControle”.

8.Crie uma transição entre a ação Remove Vários Paises e o estado final ConsultarPais.

82

9.Para ver a tela gerada, rode o comando maven install deploy no prompt de comando, inicialize o JBoss, abra um browser e acesse o endereço http://localhost:8080/<nome doprojeto>/.


10.No Eclipse abra o arquivo:<DiretorioProjeto>/web/src/java/<PacoteProjeto>/web/cadastroPais/consultaPais/ConsultaPaisControleImpl.java

Iremos implementar o método removeVarios da seguinte forma:

public void removeVariosPaises(ActionMapping mapping, RemoveVariosPaisesForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

try {List<Long> paises = form.getIdRowSelection();for(Long id: paises){

Pais pais = new PaisImpl();pais.setId(id);pais = (Pais) getPaisHandler(request).manipulaPais(pais, new

SelectAction()).get(0);getPaisHandler(request).manipulaPais(pais, new DeleteAction());

}saveWarningMessage(request, "sucesso.remocao.pais");

} catch (Exception e) {saveErrorMessage(request, "erro.remocao.pais");

e.printStackTrace();}

}11.Salve os arquivos no Eclipse, abra um terminal e, no diretório do projeto, execute o comando maven install deploy.

12.Inicialize o JBoss conforme descrito anteriormente e no browser teste a aplicação na url: http://localhost:8080/SuportePais/

3.7 Editando Paginas JSP

Chegamos ao fim do nosso tutorial, como ultima tarefa será feita a personalização das paginas JSP. Fazendo o tutorial, você aprendeu e viu que todas as páginas JSP do projeto são geradas automaticamente a partir do modelo UML. Ou seja: não foi preciso codificar nenhuma tag html! Seria ótimo se fosse sempre assim!

Mas há casos em que é necessário editar o código da página gerada, seja para fins específicos de programação ou até mesmo para melhor organizar os itens na tela. Precisamos seguir alguns passos para atingir esse objetivo.

83


3.7.1 Achando a localização da página

Antes de mais nada, execute o maven mda para que as pastas targets sejam criadas. Após, você deve achar a página gerada automaticamente que será personalizada. Procure-a nas subpastas da pasta seuProjeto\web\target\src\br\gov\tutorial\web\cadastroPais. Você irá encontrar as varias pastas criadas no ArgoUML, abra uma dessas e em seguida encontrará a pasta web com arquivos de vários tipos: .java, .css, .jsp, .jspf. Para saber qual o arquivo jsp você irá personalizar, vamos analisar a estrutura de páginas geradas pelo MDA.

Para cada estado de ação com o estereótipo "FrontEndView" no modelo é gerada uma página jsp correspondente, com o mesmo nome do estado de ação. Por exemplo, se temos o estado de ação, com o estereotipo "FrontEndView" no modelo, com o nome de "Consulta de pais", é gerada uma consulta-de-pais.jsp e também: consulta-de-pais-actions.jsp: contém um formulário com os campos correspondentes aos parâmetros da primeira transição que sai do "Detalhes da Empresa"; consulta-depais-javascript.jspf: contém o javascript gerado para a página; consulta-de-paishiddens.jspf: contém os campos definidos como hidden(todos os parâmetros que possuem o valor etiquetado @andromda.presentation.web.field.type selecionado como "hidden"); consulta-de-pais-collection.jspf: se a transição que chega em "Consulta de Pais" possuir uma collection que defina uma tabela, esse arquivo será gerado com o código desta tabela. A página consulta-de-pais.jsp contém tags de inclusão para todas as subpáginas acima.

Geralmente, as modificações ocorrem nos formulários. Então, usa-se a página com o sufixo "actions". Até aqui, apenas localizamos a página que foi gerada automaticamente. Abaixo, o procedimento para, de fato, modificar essa página.

3.7.2 Alterando as Paginas

Abra a pasta seuProjeto/web/src/jsp. Faça uma cópia da jsp que você localizou no passo acima, obedecendo a mesma estrutura de diretórios da pasta target.

Por exemplo, se no passo 1 eu localizei a página meuProjeto/web/target/src/br/gov/ tutorial/web/cadastroPais/detalhaPais/detalhes-do-pais-actions.jsp, devo criar uma cópia em meuProjeto/web/src/jsp/br/gov/tutorial/web/cadastroPais/detalhaPais/detalhes-do-pais-actions.jsp.

Faça as alterações necessárias na cópia que você gerou (mude o layout do form, altere o rótulo de algum campo etc.). Atenção, somente copie a pagina que você queira personalizar, pois caso contrário nenhuma pagina gerada com modificações será exibida.

84

No terminal vá ao diretório da projeto e execute um maven install deploy

3.7.3 Retrabalho

O fato da personalização dos JSP serem a última parte do tutorial não foi por acaso.Quando criamos uma página personalizada, estamos "forçando" o maven a utilizar a nossa página personalizada e não a que ele gera automaticamente. Isso quer dizer que, se você fizer alguma alteração no modelo, ela não vai aparecer na sua página personalizada, pois só quem pode mexer nela é você. É como se o maven dissesse: "OK! Crie sua página personalizada, mas ela é de sua inteira responsabilidade! Eu não vou chegar nem perto dela!". Por isso que o processo de personalização deve ser a última coisa a ser feita na etapa de desenvolvimento, pois qualquer alteração no modelo não será repassada para a sua página personalizada.Mas e se, futuramente, você realmente precisar adicionar algo no modelo? Tem como fazer com que, por exemplo, um novo campo de formulário apareça na página que foi personalizada? Sim, é claro! Basta:

Localizar a página gerada automaticamente (ela continuará sendo gerada no mesmo caminho que vimos acima, só que não será exibida na tela do sistema). Dentro da página, localize o código gerado do seu interesse e copie para a área de transferência (editar/copiar). Por exemplo, se você adicionou um novo campo no modelo, localize e copie o código desse novo campo. O nome é o mesmo que você utilizou no modelo. Cole o código na sua página personalizada, onde você quer que ele apareça.

3.7.4 Abas

Vamos fazer a ultima modificação no exemplo do sistema do tutorial, iremos inserir uma aba na pagina de detalhamento do país e colocar a exibição das unidades federativas nesta. Para inserir abas na suas páginas personalizadas, basta copiar o código abaixo e colar no local do código onde você quer que a aba seja renderizada. No nosso caso será o arquivo detalhes-do-pais-ufs.jspf que está na caminho \SeuProjeto\web\target\src\br\gov\ tutorial\web\cadastroPais\detalhaPais\. Lembrando que para alterar uma pagina jsp devemos copiar SOMENTE a pagina desejada para o diretório jsp que conterá as páginas personalizadas. O código das abas será:

<div class="SubAbaResultado">

85

<div class="BotaoMostraSubAba" onClick="mensagens.style.display=''; this.style.display ='none'; BotaoAbaDadoComplementar2.style.display ='';" id="BotaoAbaDadoComplementar1">

<bean:message key="custom.reenvio.mensagem.antecessoras"/><img src="/sgdcp/layout/sgdc/BotMostraSubAba.gif" width="16" height="12">

</div><div id="BotaoAbaDadoComplementar2" onClick="mensagens.style.display ='none';

this.style.display='none'; BotaoAbaDadoComplementar1.style.display ='';" class="BotaoMostraSubAba"style="display:none ">

<bean:message key="custom.reenvio.mensagem.antecessoras"/><img src="/sgdcp/layout/sgdc/BotEscondeSubAba.gif" width="16" height="12">

</div></div>

Como a aba fecha: Repare que existem duas divisões lógicas div dentro da divisão lógica da aba. Uma delas é responsável por abrir a aba e a outra é responsável por fechá-la. Repare nos comandos que estão no onClick, o mensagens.style.display é responsável pela mostragem da aba, se tiver “none” a aba não é mostrada e se for atribuída “” então ela será mostrada. Já o BotaoAbaDadoComplementar1.style.display e o AbaDadoComplementar2.style.display são os comandos que passam a decisão de uma divisão lógica pra outra, dessa forma sempre depois que for aberta a aba o próximo clique irá fechá-la, já o próximo abrirá de novo e assim em diante.

Vamos fazer nosso exemplo:

1.Altere mensagens.style.display , na segunda e na décima linha pelo conteúdo da tag id do bloco de página que você deseja colocar dentro da aba. No nosso caso será o bloco que tem a id “ufs”.

2.Dessa forma, você quer que todo o código envolvido pela tag <div id="ufs "> fique dentro de uma aba. Agora Substitua mensagens.style.display por ufs.style.display .

3.Caso você queira que a aba inicie fechada coloque o atributo style=“display:none" dentro da tag do local desejado, ou seja, <div id=" ufs " style="display:none">. Caso você não altere isso a aba vai iniciar aberta mostrando o conteúdo. Experimente fazer dos dois jeitos para ver funcionando.

4.O rótulo da aba está definido por uma chave. Substitua a chave custom.reenvio.mensagem.antecessoras do código pela chave que apontará para o código da sua aba. Se tiver feito tudo segundo o sugerido, o código html ficara da seguinte forma:

<div class="SubAbaResultado">

86

<div class="BotaoMostraSubAba" id="BotaoAbaDadoComplementar1" onClick="ufs.style.display =''; this.style.display ='none'; BotaoAbaDadoComplementar2.style.display ='';" >

<bean:message key="detalhar.pais.detalhamento.do.pais.param.ufs"/><img src="/SuportePais/layout/sgdc/BotMostraSubAba.gif" width="16"

height="12"></div><div class="BotaoMostraSubAba" id="BotaoAbaDadoComplementar2"

onClick="ufs.style.display ='none'; this.style.display='none'; BotaoAbaDadoComplementar1.style.display ='';" class="BotaoMostraSubAba" style="display:none " >

<bean:message key="detalhar.pais.detalhamento.do.pais.param.ufs"/><img src="/SuportePais/layout/sgdc/BotEscondeSubAba.gif" width="16"

eight="12"></div>

</div>

Depois disso abra um terminal e, no diretório do projeto, execute o comando maven install deploy.

Inicialize o JBoss conforme descrito anteriormente e no browser teste a aplicação na url:http://localhost:8080/SuportePais/

87