Contribuição de Craig Conover e
Abril de 2008 [Número da revisão: V1-2].
Esta publicação se aplica à versão completa do NetBeans 6.1.
O mecanismo de geração de código interno é uma adição importante ao recurso UML da versão NetBeans 6.1.
Quando você cria uma classe Java usando o assistente para Novo projeto, o NetBeans IDE usa modelos de geração de código para gerar código-fonte, variáveis token de substituição com as informações corretas: nome do autor, data de criação, licença, nome da classe, nome do construtor e outros atributos. Antes do NetBeans 6.1, esses modelos de geração de código não davam suporte a comportamentos personalizados que você poderia fornecer como um desenvolvedor.
Entretanto, o NetBeans 6.1 utiliza um mecanismo de modelo de código-fonte aberto chamado Freemarker que ajuda na geração do código personalizado. A diferença entre os modelos antigos do NetBeans e os que empregam modelos do Freemarker reside na habilidade de personalizar a geração de conteúdo usando código de script nos modelos. Embora essa habilidade possa se aplicar a outros recursos do NetBeans, agora você pode usar modelos para personalizar o código através do recurso de geração de código do módulo UML, fornecendo a você, portanto, uma grande flexibilidade no código gerado por meio do recurso UML.
Os modelos permitem a geração de arquivos de código-fonte Java padrão (classes, interfaces e enumerações) a partir de elementos de modelo, usando modelos de arquivo de código-fonte Java. Os modelos do Freemarker estão acessíveis para fins de personalização de qualquer outro modelo no NetBeans. Consulte também http://wiki.netbeans.org/FaqFreeMarker .
Desenvolvimento orientado a modelo
Grande parte da força que vem do uso de UML com Freemarker é a habilidade de fazer o desenvolvimento orientado a modelo (MDD). MDD significa que você pode realizar o desenvolvimento, mapeando atributos de elemento para modelos do Freemarker e, portanto, você pode criar elementos de modelo marcados com estereótipos que permitem a geração de padrões de design de programação complexos.
Por exemplo, você pode usar um único elemento Classe com o estereótipo ejb-sem estado para gerar a classe Bean, os arquivos de código-fonte da interface inicial e da interface remota de um aplicativo EJB.
Você pode estereotipar métodos individuais como comercial para indicar os métodos a serem expostos para o cliente. Para o domínio ser mais específico, você pode usar um estereótipo chamado carrinho de compras para representar uma implementação completa de um EJB de carrinho de compras. Cada um desses estereótipos pode mapear para modelos específicos que geram o código necessário.
Plano de fundo para a criação de modelo Freemarker bem-sucedida
Embora este artigo não focalize o script em si, três habilidades são úteis para escrever scripts personalizados bem-sucedidos e a criação de modelo correspondente:
Conhecimento de script do Freemarker
Conhecimento do seu modelo de dados de origem
Familiaridade com o domínio de formato de saída de destino.
Script do Freemarker
A primeira habilidade está razoavelmente em conformidade com a linguagem de script do Freemarker. O Freemarker é semelhante às linguagens de script. Você pode consultar o manual online do Freemarker no site SourceForge para obter mais informações sobre o Freemarker.
Modelo de dados de origem
Os modelos de dados de origem podem variar em complexidade. No modelo de dados UML, existem dois elementos, um elemento no tipo ClassInfo com classInfo como o nome do elemento do modelo ou do tipo Classifier com modelElement como o nome do modelo. Você reconhecerá esses elementos quando observar o script disponível através dos modelos.
Domínio do formato de saída de destino
O formato de saída é o resultado da geração do seu código. Focalizar as linguagens de programação não é uma tarefa trivial. Você deve pensar como um analisador de linguagem pensaria. Em Java, você deve começar o seu objetivo com uma declaração de pacote, em seguida, declarações de importação. A declaração de classe possui muitas variáveis a serem consideradas: escopo, nome de classe, cláusula de extensões e implementações.
Os comentários também devem acompanhar a declaração de classe. Você também precisa considerar os atributos e os métodos e suas assinaturas e comentários. O espaço em branco também precisa ser considerado.
Entretanto, se estiver dedicado à modelagem e souber qual é a saída do destino, você avançará facilmente em sua implementação ao gerar o código-fonte e, portanto, obterá os benefícios do desenvolvimento orientado a modelo.
Usando o projeto BankApp com geração de código personalizada
Antes de prosseguir, você deve garantir que possui a distribuição do zip, como indicado em Software necessário. Essa distribuição inclui os modelos de geração de código do Freeemarker e os projetos do NetBeans. Você também usará o projeto de amostra BankApp que vem incluído no IDE.
Este artigo inclui um tutorial sobre a geração de código personalizado. Para criar um ponto inicial para o tutorial de geração de código personalizado, você pode usar os projetos de amostra incluídos no recurso UML no IDE.
Para começar, você precisa criar um projeto Java e UML para o projeto de amostra BankApp incluído:
No menu principal do IDE, escolha Arquivo > Novo projeto.
Na página Escolher projeto, expanda o nó Amostras no painel Categorias e selecione o nó UML. O painel Projetos é atualizado com o projeto de UML amostra.
No painel Projetos, selecione UML Bank App Sample e clique em Próximo.
Na página Nome e localização, deixe o valor padrão UMLBankAppSample para o nome do projeto Java, ou modifique-o se o projeto já existir.
Clique em Terminar. O NetBeans IDE cria dois projetos: um projeto Java e um projeto UML. Se você escolher o nome padrão, o projeto Java se chamará UMLBankAppSample e o projeto UML se chamará UMLBankAppSample-Model.
Expanda o projeto UML para expor todos os subnós do nó Modelo. Existe um pacote, bankpack, e vários elementos Classe e um elemento Interface. Esses elementos sofreram engenharia reversa a partir do projeto Java.
Clique com o botão direito do mouse em qualquer um desses elementos e selecione Navegar para código-fonte e o arquivo de código-fonte no projeto Java é aberto no editor do NetBeans.
Faça alterações nesses elementos e execute Gerar código -- os arquivos de código-fonte no projeto Java são atualizados apropriadamente. (Conhecer o relacionamento entre o projeto Java e o projeto UML é útil.) O foco agora será como o código é gerado para cada um desses elementos e, segundo, como você pode personalizar a geração de código.
Agora que você criou o projeto Java e UML a ser usado, observe as ferramentas usadas no processo de geração de código UML.
Ferramentas UML do NetBeans usadas no processo de geração de código UML
Antes de começar a criar modelos personalizados e mapeá-los para elementos de modelo, é importante entender as ferramentas do NetBeans IDE que você estará usando e seu relacionamento.
Essas ferramentas incluem painéis, personalizadores e uma caixa de diálogo:
O gerenciador de modelos do NetBeans: use essa ferramenta para acessar os modelos em suas pastas.
O painel Opções de modelo UML do NetBeans: use essa ferramenta para mapear arquivos para elementos de modelo.
O personalizador de projetos UML do NetBeans (para propriedades do projeto): use essa para ativar modelos de domínio
Caixa de diálogo Gerar código: use essa caixa de diálogo para criar código a partir de modelos.
Cada uma dessas ferramentas tem uma função na configuração e uso de modelos no processo de geração de código UML.
Gerenciando arquivos de modelo usando o gerenciador de modelos do NetBeans
Todos os modelos do NetBeans 6.1 são baseados no mecanismo de modelo do Freemarker.
No IDE, você pode gerenciar modelos do Freemarker com o gerenciador de modelos do NetBeans. Para acessar os modelos:
No menu principal do IDE, escolha Ferramentas > Modelos. O IDE abre a caixa de diálogo Gerenciador de modelos. Você verá muitas pastas que servem para categorizar os modelos.
Expanda a pasta UML e suas subpastas.
Os arquivos de modelo que você adiciona ao IDE não precisam conter script do Freemarker, portanto, não existe um formato de arquivo esperado quando você adiciona arquivos no gerenciador de modelos. Os modelos para geração de código Java são criados para reutilização máxima de código.
Quando você adiciona arquivos de modelo, tenha o seguinte em mente:
O arquivo CompilationUnit.java serve como o único arquivo de modelo para gerar classe, interface e arquivos-fonte de enumeração Java.
Os arquivos adicionais (*Declaration.java e DeclLib.ftl) são vinculados a partir do arquivo CompilationUnit.java.
Existem muitos outros modelos em outras pastas. Alguns podem conter exemplos de script valiosos que você pode usar em seus modelos personalizados para a criação de código UML. Entretanto, o processo de geração de código UML usa somente os modelos que estão listados na pasta UML/Geração de código e suas subpastas
Você pode criar suas próprias subpastas personalizadas sob a pasta UML/Geração de código para armazenar seus modelos e eles ainda ficarão disponíveis para uso pelo processo de geração de código UML.
Neste artigo, você usará um script de modelo do Freemarker muito simples que tira vantagem desses recursos que o processo de geração de código UML do NetBeans fornece por padrão para o mecanismo de modelo do Freemarker.
Mapeando modelos de domínio com o painel Opções UML do NetBeans
Criar arquivos de modelo personalizados do Freemarker foi o primeiro passo. Alguns modelos já estão disponíveis para a geração de código Java.
Entretanto, ao usar os arquivos de modelo, você depois precisa mapear esses arquivos de modelo para os elementos de modelo em seu modelo. Você pode configurar esse mapeamento no painel Opções UML do NetBeans, fazendo o seguinte:
No menu principal do IDE, escolha Ferramentas > Opções.
Clique na categoria de opções UML.
Clique na aba Modelos.
Selecione o nó Classe básica na árvore.
O IDE exibe as propriedades do modelo de domínio Java/Classe básica mostrando que qualquer elemento em um modelo que seja do tipo Classe e que não possui estereótipo é mapeado para o arquivo de modelo sob UML/Geração de código/Java/CompilationUnit.java , e que a saída será um arquivo com o mesmo nome que o elemento com a extensão de arquivo .java.
Usando arquivos de modelo de código personalizado para gerar código de objetos de domínio
O recurso UML possui vários tipos de elementos (tais como Classe, Interface, Ator). Esses elementos podem ser estereotipados para identificar o elemento para servir um propósito específico ou possuir determinados comportamentos. Um objeto de domínio é um objeto específico de uma DSL (Domain Specific Language).
Por exemplo, em um domínio de caixa eletrônico (um domínio não usado neste tutorial), alguns objetos de domínio poderiam ser:
Customer (Cliente)
Account (Conta)
Deposit (Depósito)
Withdrawal (Saque)
Bank (Banco)
Esses objetos de domínio podem ser representados em um diagrama de classe UML como elementos Classe com os seguintes estereótipos, respectivamente:
customer
account
deposit
withdrawal
bank
Para gerar código para objetos de domínio, você deve criar arquivos de modelo de código personalizado. Os modelos de arquivo de código personalizado contêm os atributos e métodos necessários que serão gerados nos arquivos de código-fonte.
Quando você cria os arquivos de modelo, precisa mapear os pares elemento/estereótipo para os arquivos de modelo apropriados durante o processo de geração de código. Um modelo de domínio fornece o mapeamento de um tipo de elemento de modelo e o estereótipo para um ou mais arquivos de modelo.
Com o painel Opções de modelo UML, você pode criar pastas de categoria, conforme necessário, e adicionar modelos de domínio a essas categorias. A forma de organizar suas categorias e modelos de domínio depende de você, mas você deve seguir o layout criado no gerenciador de modelos do NetBeans onde acessa os arquivos de modelo.
Ativando modelos de domínio para projetos UML com o painel Opções de modelo UML
Quando tiver criado modelos de domínio, você precisa ativá-los ou desativá-los por projeto UML. Os modelos de domínio Java padrão são ativados automaticamente para cada projeto UML. Entretanto, se você criou modelos de domínio personalizados no painel Opções de modelo UML, esses modelos de domínio não são ativados para qualquer um dos seus projetos UML por padrão.
Use o Personalizador de projetos UML (propriedades do projeto) para personalizar os modelos ativados dos seus projetos UML.
Para ativar modelos de domínio para projeto UML:
Clique com o botão direito do mouse no nó do projeto UML (o nome padrão é UMLBankAppSample-Model).
Selecione Propriedades para abrir o Personalizador de projetos UML.
Quando a caixa de diálogo do personalizador for exibida, selecione a categoria Geração de código.
Expanda o nó Java no painel inferior.
Compreendendo e usando o painel Propriedades do projeto
Neste exemplo, o campo Projeto de destino fica vazio. Isso acontece porque você reverteu a engenharia do projeto UML a partir do projeto Java UMLBankAppSample.
A primeira vez que você gera o código, o IDE não configura o projeto de destino e a mensagem de status nos avisos inferiores que um projeto válido deve ser selecionado.
Para usar o painel Propriedades do projeto:
Clique em OK para salvar as propriedades, sem especificar o projeto de destino.(Você vê a mesma interface de usuário mais tarde em seu fluxo de trabalho na caixa de diálogo Gerar código, mas nesse ponto no fluxo de trabalho todos os campos obrigatórios, incluindo Projeto de destino, devem ser preenchidos antes de você clicar em OK para gerar o código.)
Expanda o nó Java no painel Modelos na parte inferior, para ver três modelos de domínio padrão:
Classe básica
Interface básica
Enumeração básica
Você pode desativar a geração de código para elementos específicos por modelo. Por exemplo, se não quiser gerar código para elementos Enumeração que não tenham um estereótipo em seu modelo, você poderia desmarcar esse modelo de domínio no painel Propriedades.
Se adicionou modelos de domínio personalizados, você poderia ativá-los para geração de código neste painel. Todas essas opções também estão disponíveis para configuração instantânea quando você chama o processo de geração de código, desde que você tenha ativado a opção Avisar antes da geração de código no Personalizador de projetos. (Por padrão, o IDE ativa essa opção de caixa de diálogo.)
Gerando código a partir do seu modelo
Quando tiver todos os seus modelos de domínio e eles estiverem corretamente ativados para seu projeto UML, você pode gerar código a partir do seu modelo. Para fazer isso,
clique com o botão direito do mouse no nó do projeto UML e selecione a ação Gerar código. O IDE exibe a caixa de diálogo Gerar código para você confirmar se as propriedades estão configuradas corretamente. Por padrão, o painel Modelos fica oculto.
Clique no botão Mostrar modelos para mostrar os modelos de domínio, como na imagem.
Clique no botão OK para iniciar a geração do código. As mensagens serão exibidas na janela Saída do NetBeans em uma aba rotulada Gerar código. O status do processo de gerar código é exibido aqui. Consulte essas mensagens para confirmar se o código foi gerado corretamente.
Na próxima seção, você usa os modelos EJB que são criados através da simplificação dos modelos Java atuais. As etapas para criar esses modelos não são abordadas aqui, mas os modelos concluídos, simplificados, fornecem um exemplo mais simples do que os modelos Java.
Criando modelos personalizados do Enterprise Java Bean 3.0
Quando tiver configurado os modelos de código Java padrão para gerar código Java a partir dos seus projetos UML, você pode usar modelos personalizados para gerar arquivos de código-fonte para artefatos de aplicativo, tal como uma sessão EJB sem estado típica.
Criar modelos de geração de código robustos pode ser uma tarefa extremamente complexa. Para facilitar o seu aprendizado de como usar modelos personalizados, os três modelos de geração de código necessários para EJBs de sessão sem estado foram criados para você e fornecidos na distribuição compactada. Esses modelos não são soluções completas para gerar EJBs de sessão sem estado. Eles somente geram a classe do bean e as interfaces inicial e remota, se estiverem marcados corretamente, com métodos do elemento Classe.
Uma implementação mais completa fornece a habilidade de estereotipar cada operação individual como local, remota ou ambos para indicar em que interface a operação deve ser declarada.
Obtendo os modelos de geração de código e adicionando-os ao IDE
Para adicionar os modelos de geração de código ao IDE, baixe os modelos e use o gerenciador de modelos para adicioná-los ao IDE:
Verifique se você descompactou o código-fonte fornecido com este artigo para obter os seguintes modelos:
StatelessBean.flt
StatelessRemote.ftl
StatelessLocal.ftl
Adicione os modelos ao IDE. No menu principal do IDE, selecione Ferramentas > Modelos. O gerenciador de modelos do NetBeans se abre.
Navegue e selecione a pasta UML/Geração de código.
Clique no botão Nova pasta e nomeie a pasta de EJB 3.0.
Clique no botão Adicionar.
Navegue para a localização da pasta em que você descompactou os arquivos do modelo.
Selecione um dos arquivos a serem adicionados ao IDE.
Repita as etapas 5-7 para os dois outros arquivos de modelo.
Selecione todos os três modelos. Clique no botão Abrir no editor. O IDE abre os novos arquivos de modelo em uma janela do editor do NetBeans.
Explore os scripts de modelo para saber o que está sendo feito. Esses três arquivos de modelo foram criados através da combinação dos três arquivos de modelo separados para gerar as classes Java e são vinculados de forma que os scripts possam ser reutilizados. Combinando os scripts em um modelo, é mais fácil seguir o fluxo do script.
Novamente, são usados três dos novos modelos básicos. Dentre eles estão:
DeclLib.ftl
CompilationUnit.java
NormalClassDeclaration.java
Existem três arquivos de modelo separados porque você usará um único elemento de modelo no projeto UML para gerar três arquivos de código-fonte separados, e deve haver pelo menos um arquivo de modelo por arquivo de código-fonte gerado: um elemento de modelo usa diretamente um arquivo de modelo para gerar um arquivo de código-fonte.
Com os tipos Java padrão, cada tipo usa o arquivo de modelo CompilationUnit.java, que faz referência a outros arquivos de modelo ( DeclLib.ftl e um dos três outros arquivos *Declaration.java) para gerar outro arquivo de código-fonte.
Gerando modelos para os EJBs
O arquivo zip contém três modelos que permitem gerar EJBs. Com esses modelos, um elemento de modelo usará diretamente três arquivos de modelo diferentes para gerar três arquivos de código-fonte.
A imagem seguinte ajudará você a visualizar as diferenças de relação entre a geração de código de classe Java padrão e a geração de classe de bean EJB.
Na imagem abaixo:
Existem três elementos no modelo: uma Classe, uma Interface e uma Enumeração.
Cada elemento Classe é mapeado para usar o modelo de domínio Classe básica (qualquer elemento Classe se um estereótipo) que por sua vez usa o modelo de arquivo CompilationUnit.java.
O script no arquivo de modelo CompilationUnit.java determina que esse elemento é do tipo Classe e se vincula ao modelo NormalClassDeclaration.java para realizar a geração de código específico de classe Java.
Semelhantemente, para os tipos de elemento Interface e Enumeração, o script em CompilationUnit.java determina que o elemento é de um típico específico e se vincula ao modelo apropriado para facilitar a geração de código específica de Java, Interface ou Enumeração.
Mapeando elementos Classe sem estado
Os elementos Classe estereotipados como sem estado são mapeados para o modelo de domínio Sem estado, que possui três arquivos de modelo.
Cada arquivo de modelo gera um arquivo de código-fonte separado: uma classe Java e duas interfaces Java. Consulte a figura abaixo.
Adicionando os novos modelos
Quando tiver adicionado os novos modelos ao IDE, você precisa adicioná-los como Modelos de domínio por meio do painel Opções. Para fazê-lo:
No menu principal do IDE, escolha Ferramentas -> Opções.
Clique em Categorias.
Clique em Adicionar para adicionar a nova categoria.
Renomeie a categoria padrão para EJB 3.0.
Clique no botão Adicionar para adicionar um novo domínio.
Nomeie o domínio padrão de Sem estado.
Selecione Sem estado.
Selecione Classe no menu suspenso do tipo Elemento.
Digite sem estado no campo Estereótipo.
Selecione Adicionar modelos.
Preencha a caixa de diálogo com estas entradas sugeridas:
Formato de nome de arquivo: {nome}Bean
Extensão: .java
Pasta: deixe em branco a menos que você queira que o arquivo seja gerado em algum outro local
Arquivo de modelo: EJB 3.0/StatelessBean.ftl
Repita essas entradas, mas forneça os nomes dos outros dois modelos.
Mapeando modelos EJB
Depois de adicionar os modelos ao IDE e anexá-los ao painel Opções, você precisa mapear os modelos para os elementos modelo em seu modo usando o painel de opções UML.
No menu principal do IDE, escolha Ferramentas > Opções.
Clique na categoria de opções UML.
Clique na aba Modelos.
Expanda o nó EJB 3.0 no painel Opções.
O IDE exibe as propriedades do modelo de domínio EJB. Como a ilustração seguinte mostra, no modelo de domínio EJB 3.0, você terá um modelo de domínio Sem estado da classe de tipo Elemento, com Estereótipo sem estado.
Esses são os três parâmetros de saída, Bean, Local e Remote, cada um com uma extensão .java
Modelos de domínio múltiplos para elementos de modelo únicos
Os modelos de domínio múltiplos possuem um único elemento modelo mapeados para eles. Por exemplo, o modelo de domínio Classe básica na categoria Java pode ser mapeado para qualquer elemento do tipo Classe sem um estereótipo.
Você poderia criar outra categoria chamada C++ com um modelo de domínio que também se chama Classe básica (ou qualquer outro nome que você queira dar) que também é mapeado para elementos do tipo Classe sem estereótipo, O arquivo de modelo pode gerar uma classe C++ em vez de Java.
Se ambos os modelos estiverem ativados quando a ação Gerar código for chamada, você obterá dois arquivos a partir de um elemento, um sendo uma classe Java e outro sendo uma classe C++. Embora esse último exemplo possa ser um caso extremo, ele ainda é possível.
Criando um EJB de sessão sem estado de calculadora
Quando tiver criado corretamente os modelos no NetBeans e configurado o modelo de domínio correto, você pode criar um projeto de modelo UML que irá tirar vantagem do novo modelo para gerar o código Enterprise Java Bean do Enterprise Java Bean.
Depois de criar o projeto de modelo UML, você cria um elemento Calculadora e adiciona os métodos a ele.
A primeira etapa é criar o projeto UML:
No menu principal, escolha Arquivo > Novo projeto.
Selecione UML, depois selecione Modelo da plataforma Java
Clique em Próximo e em Terminar.
Quando a caixa de diálogo Criar diagrama aparecer, selecione Diagrama de classe e clique em Terminar. Você criou um projeto UML com um diagrama de classe.
Em seguida, você criará o elemento Calculadora. Para criar o elemento Calculadora:
Adicione um elemento Classe ao diagrama e chame-o de Calculadora (os modelos garantirão que os sufixos sejam criados corretamente: ou seja, os modelos criam Bean, Local e Remote para os nomes de arquivo de código-fonte apropriados).
Com o elemento Calculadora selecionado, edite a propriedade Estereótipo e adicione sem estado.
O processo Gerar código agora identificará o elemento Calculadora, para mapeá-lo para o modelo de domínio Sem estado. Entretanto, antes de poder realizar a geração de código, você precisa adicionar alguns modelos ao elemento Calculadora.
Adicionando métodos ao elemento Calculadora
Crie as três operações listadas abaixo no elemento Calculadora no editor de diagramas UML. Para criar uma operação, clique com o botão direito do mouse no elemento Calculadora na área do compartimento Operação e selecione Adicionar operação. Adicione as seguintes operações:
public int add(int a, int b)
public int subtract(int a, int b)
public int multiply(int a, int b)
Talvez você queira expor todos os três métodos em ambas as interfaces. Somente métodos públicos podem ser declarados nas interfaces, portanto, se você não queria expor todos esses métodos, seria preciso filtrar métodos não públicos.
Além disso, talvez você queira que todos os métodos públicos sejam declarados em ambas as interfaces, ou uma delas. Você precisa de um mecanismo para o script determinar quais métodos serão gerados em cada um dos três arquivos de código-fonte. Novamente, você pode usar estereótipos para indicar quais métodos devem ser adicionados.
Criando um projeto Java
Agora que o elemento Calculadora está completo, você precisa criar um projeto Java para o qual possa gerar o código. Para fazê-lo:
No menu principal do IDE, escolha Arquivo > Novo projeto.
Selecione Java, Aplicativo Java e clique em Próximo.
Na página Escolher projeto, selecione Java e Aplicativo Java.
Desmarque a opção Criar classe principal e clique em Terminar.
Clique com o botão direito do mouse no elemento Calculadora e selecione Gerar código.
Selecione o projeto Java recém-criado como o projeto de destino.
Clique no botão Mostrar modelo e expanda o nó EJB 3.0 na árvore.
Clique no modelo de domínio Sem estado. Clique em OK para iniciar a geração do código.
A janela Saída exibe mensagens, informando que o IDE usou três arquivos de modelo separados para gerar código para o elemento Calculadora.
Quando a execução do processo de geração de código estiver concluída, expanda a pasta do código-fonte do projeto Java para inspecionar os novos códigos-fonte da Calculadora. Você verá os três arquivos gerados:
CalculatorBean.java
CalculatorLocal.java
CalculatorRemote.java
Abra cada arquivo para verificar se você gerou os três métodos na classe e nas duas interfaces. Talvez você veja erro de compilação ou outros porque o projeto Java padrão não inclui automaticamente a biblioteca Java Enterprise ou outras classes. Você pode ignorar esses erros, já que o objetivo deste tutorial não é compilar nem executar esse projeto que você criou.
Observando as alterações do editor de diagramas no código gerado
Você pode ver como o código gerado é mantido sincronizado com o elemento Calculadora conforme você faz alterações no elemento com o editor de diagramas. No editor de diagramas:
Adicione um novo componente:
public float divide(int a, int b)
Exclua a operação de multiplicação.
Adicione um terceiro parâmetro à operação de adição:
int c
Clique com o botão direito do mouse no elemento Calculadora e selecione Gerar código.
Examine os três arquivos de código-fonte, como você fez anteriormente quando inspecionou os novos códigos-fonte, e observe que o IDE atualizou todos eles para estar sincronizados com as alterações feitas no elemento Calculadora no editor de diagramas.
Resumo
O ambiente de script do Freemarker fornecem uma adição poderosa à geração de código UML do NetBeans, permitindo que você personalize o código que gera. Este artigo forneceu informações conceituais e de tutorial para permitir que você crie, adicione e personalize modelos de geração de código, a geração de código em geral e a geração de código com referência específica a artefatos EJB. Usando os modelos de geração de código, você pode aproveitar a força dos modelos do framework da geração de código UML do NetBeans e simplesmente modificar alguns elementos para manter o código-fonte de muitos arquivos de código-fonte. Os modelos de geração de código personalizados fornecem uma forma fácil e eficaz de gerar código que pode ser usado em seus projetos de aplicativo.
Próximas etapas
Para enviar comentários e sugestões, obter suporte e manter-se informado sobre as alterações mais recentes nos recursos de desenvolvimento UML do NetBeans IDE, junte-se à lista de usuários em
.
