Baixe o app para aproveitar ainda mais
Prévia do material em texto
FVC – FACULDADE VALE DO CRICARÉ JPA – Java Persistence API Gerador de boletos bancários personalizados em Java Douglas Tybel 28/03/2012 Este artigo apresenta o componente Bopepo do projeto de código aberto JRimum, utilizando JPA (Java Persistence API). Este componente permite gerar boletos bancários para diversos bancos, de forma fácil e, com flexibilidade para personalizações 2 JPA - Java Persistence API Gerador de boletos bancários personalizados em Java Conheça o Bopepo, um componente Java, criado pelo projeto de código aberto JRimum para a geração de boletos bancário. De que se trata o artigo: Este artigo apresenta o componente Bopepo do projeto de código aberto JRimum, utilizando JPA (Java Persistence API). Este componente permite gerar boletos bancários para diversos bancos, de forma fácil e, com flexibilidade para personalizações. Em que situação o tema é útil: Os desenvolvedores, por sua vez, que desejam economizar tempo em implementações de funções para cálculos de código de barra e linha digitavel, precisam conhecer o componente Boleto que, te fornece todas as bibliotecas para a utilização de Boletos bancários em seus softwares. Resumo: Foi desenvolvido uma mini aplicação no acrônimo CRUD (Create, Read, Update, Delete) com JPA (Java Persistence API), usando os recursos de Binding com o banco de dados. O mini aplicativo serve para reproduzir um cenário que possibilita o cadastro de clientes, filiais, contas e títulos, neste sentido, após os cadastros básicos, na tela nomeada de Ficha Financeira, por sua vez, permite filtrar os títulos de um determinado cliente e emitir o boleto. Este artigo aborda os detalhes para gerar o boleto com a biblioteca Bopepo e a reprodução do cenário em JPA com CRUD. 3 JAVA PERSISTENCE API........................................................................................................................... 2 Conheça o Bopepo, um componente Java, criado pelo projeto de código aberto JRimum para a geração de boletos bancário. .............................................................................................................. 2 DE QUE SE TRATA O ARTIGO: ........................................................................................................................... 2 EM QUE SITUAÇÃO O TEMA É ÚTIL: ................................................................................................................... 2 RESUMO: .................................................................................................................................................... 2 CONCEITOS FUNDAMENTAIS ................................................................................................................. 4 CLASSE ENTITY ............................................................................................................................................. 5 Campos Transient ............................................................................................................................... 6 Campos Persitent ................................................................................................................................ 7 RELACIONAMENTOS ...................................................................................................................................... 9 Um para um ........................................................................................................................................ 9 Um para muitos ................................................................................................................................ 11 OPERAÇÕES COM O ENTITYMANAGER ............................................................................................................ 11 CRUD ...................................................................................................................................................... 12 IDE - NETBEANS ......................................................................................................................................... 13 SGDB – SISTEMA GERENCIADOR DE BANCO DE DADOS ....................................................................................... 13 DIAGRAMA DE CLASSE ......................................................................................................................... 13 DIAGRAMA DE CLASSE DO PROJETO BOLETO ........................................................................................ 14 SOBRE O PROJETO BOPEPO ................................................................................................................. 16 Bancos suportados ............................................................................................................................ 16 BIBLIOTECA ............................................................................................................................................ 17 Dependencias .................................................................................................................................... 17 Releases (versões liberadas) ............................................................................................................. 17 PROJETO BOLETO ................................................................................................................................. 19 CRIANDO O BANCO DE DADOS............................................................................................................... 19 Sincronizando modelo com o banco de dados .................................................................................. 19 CRIANDO FORMULÁRIOS CRUD ............................................................................................................. 19 Formulário Pessoas ........................................................................................................................... 19 Formulário Contas ............................................................................................................................. 22 Binding (Vinculando) – jCombobox ................................................................................................... 24 Formulário Títulos ............................................................................................................................. 31 Formulário Ficha financeira .............................................................................................................. 32 4 Conceitos fundamentais Para começar a falar de JPA (Java Persistence API), temos que estudar o conceito de “Entity” - entidade (SAMPAIO, 2011). Uma Entity é um objeto persistente de um banco de dados. Dizer que uma Entity equivale a um registro do banco de dados é inexato. Na verdade, se revisitarmos o padrão "Composite Entity" (GoF), veremos que ela pode ser composta por registros de tabelas diferentes (SAMPAIO, 2011). Quando dizemos persistência, de modo geral, significa que existe um objeto “interligado” como se fosse grudado na tabela. Este objeto gerencia e representa esta tabela ou coleção de dados através da classe Entity Manager. Assumimos a referência quando o objeto está ligado ao banco como: Contexto de Persistencia. Um Entity Manager é o responsável por gerenciar todas as instâncias Entity que temos ativas em um momento, que são conhecidas com o Persistente Context. No Java EE 6, o Container vai injetar um Entity Manager que trabalhará em um Persistence Contexto predefinido (SAMPAIO, 2011). Segundo (SAMPAIO, 2011, p. 208) as Entities podem estar em quatro estados distintos: Nova (New) - Não possui uma identidade e não está associada anenhum contexto de persistência (banco de dados); Gerenciada (magaged) - Possui identidade de persistência e está associada a um contexto de persistência. Isto significa que pode ser atualizada; Desconectada (detached) - Possui identidade de persistência, mas não está associada a um contexto de persistência. Não pode ser atualizada; Removida (removed) - Possui identidade de persistência e está associada a um contexto, mas será removida; A Entity trabalha como se existisse um cache, isso quer dizer que a ligação da entidade preenche uma lista em que a coleção fica armazenada, neste sentido, 5 mantém apenas a conexão e não manipula os dados simultaneamente, deste modo, ao final de uma transação, os dados do contexto de persistência que foram alterados pelo usuário, podem ser sincronizados com o banco de dados. Isto pode ser provocado ao invocar o método "flush" da instância do Entity Manager. O uso mais comum é de entidades desconectadas (detached), que podem ser recuperadas por uma classe com estereótipo DAO e repassadas à camada de negócio de forma desconectada. Depois, quando for necessário alterar o estado da aplicação, estas entidades pedem ser reconectadas ao contexto de persistência, isso garante a velocidade e integridade dos dados (SAMPAIO, 2011). Com essa facilidade nos possibilita gerar uma classe de entidade que represente uma tabela no banco de dados, por sua vez, contendo os estados métodos para manipulação dos dados, neste sentido, faz com que a programação seja mais produtiva, possibilitando mais velocidade no desenvolvimento sem perder a qualidade. Classe Entity As classes de entidade JPA são classes definidas pelo usuário cujas instâncias podem ser armazenados em um banco de dados. Para armazenar dados em um banco de dados usando JPA você tem que definir classes de entidade que representam o seu modelo de objeto de dados. Este tópico explica também como definir e usar as classes de entidade. 6 Uma classe de entidade cujas instâncias podem ser armazenados no banco de dados, podem ser de maneira mais fácil sua declaração iniciando com a seguinte marcação: import javax.persistence.Entity; @Entity public class NomeDaClasse { } Figura 1: Demonstração da estrutura simples de uma Entity Fonte: Própria (2012) Existem também requisitos para que não devem ser infringidos ao criar uma entidade, todavia, não é necessário contemplarmos aqui, já que, o IDE as contruírá para nós. Naturalmente assim como os atributos de uma classe, a entidade também tem que espelhar estes como atributos em sua estrutura, para isso existem notações que facilitam sua implementação, veja abaixo: Transient Persistent Inverse (Mapped By) Primary key (ID) Version Comentaremos sobre os três primeiros, depois porque, serão usados em nosso projeto. Campos Transient Campos transitórios(Transient) são campos que não participam de persistência e seus valores, uma vez que, nunca são armazenados no banco de dados. Temos como exemplo de campos transitórios as chaves primárias. Muitos programadores de forma erronea, usam a chave primária como o campo “ID” do formulário visível, contudo nunca se deve usar campos chaves como dados para o usuário. Um dos motivos é sua característica de sequencia, 7 por sua vez, ao se excluir um registro, o “ID” some e não pode ser usado novamente. Em uma tela de Ordem de Serviço por exemplo, não se pode saltar numeros, apresentando assim problemas de implementação por usar chaves como dados para o usuário. Como exemplo assuma o cenário de uma classe Cidades e veja abaixo como usá-lo: import javax.persistence.Entity; @Entity public class Cidades { @Transient private Integer codCidade; } Figura 2: Exemplo de campo Transitório (Transient) Fonte: Próprio (2012) Campos Persitent Esse ponto deve ser chamado a atenção, uma vez que, representa a ligação entre as entidades. A entidade é entendida como um objeto, naturalmente que, esses objetos estão relacionados e, mesmo que algumas IDE’s nos ajude no quesito automatizar a criação das entidades, muitas dessas relações devemos fazer manualmente devido a complexidade das regras de negócio, sendo assim, precisamos entender bem essa parte, pois é bem provavel que tenhamos que usá-la posteriormente no projeto. Cada campo persistente pode ser definido com uma das seguintes anotações: OneToOne, ManyToOne – Interligação entre tipos. OneToMany, ManyToMany – Interligação entre coleções de dados. Basic – Qualquer tipo de persistencia. Usaremos todos eles em nossos projeto, portanto procure verificar mais informações sobre os itens acima. Precisamos entender que existem os tipos de dados primitivos como int,char,float etc. E no Java é possível a declaração de variáveis destes tipos. 8 Outro ponto são as classes de gerenciamento de tipos de dados, podemos exemplificar na classe String e Integer. Veja que as iniciais são maiúsculas, indicando assim a não classificação em tipos primitivos que iniciam minúsculas, neste sentido, sabe-se que classes iniciam em maiúsculas, não tipos. Dessas premissas, alguns iniciantes em programação podem estar de boca aberta agora, uma vez que, ao saber que String é uma classe e não um tipo de dado primitivo, naturalmente, muitos programadores, por sua vez, estão ciente disto. A questão é: Qual a vantagem de uma variável de classe? A sua maior vantagem é que será possível usar uma variável com a mesma estrutura da classe, por exemplo, a classe for uma entidade, todos os atributos poderão ser acessados através da variável, uma vez que, declaração de variáveis e classe é bem comum em Java. Isso mesmo, a declaração de classe no Java é muito comum, então é por isso, que chamamos à atenção a este ponto, apenas para explicar que será preciso declarar um atributo em JPA de uma classe completa. import javax.persistence.Entity; @Entity public class Telefones { @Transient private PropertyChangeSupport changeSupport = new PropertyChangeSupport(this); private static final long serialVersionUID = 1L; @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Basic(optional = false) @Column(name = "COD_TELEFONE") private Integer codTelefone; @JoinColumn(name="COD_PESSOA",referencedColumnName="COD_PESSOA") @ManyToOne private Pessoas pessoa; @Basic(optional = false) @Column(name = "NUMERO") private String numero; @Column(name = "RAMAL") private String ramal; @Column(name = "OPERADORA") private String operadora; @Basic(optional = false) @Column(name = "TIPO_TELEFONE") private String tipoTelefone; } 9 Figura 3: Recorte de uma classe em JPA da classe Telefones Fonte: Própria (2012) Veja o destaque da figura acima: private Pessoas pessoa; Quando declarado uma variável chamada “pessoa” da classe “Pessoas”, de modo geral, nos possibilita acesso a todos os atributos da classe, essa ligação entre as entidades é provocada pela notação: @JoinColumn(name="COD_PESSOA",referencedColu mnName="COD_PESSOA") Existem diversos outros pontos a serem estudados em classe de entidade, todavia, necessitamos deste conhecimento básico para podermos desenvolver nosso projeto de estudo. Relacionamentos Quando falamos de relacionamentos entre entidades, não estamos falando de conceito novo e sim de um contexto de trabalho referente a banco de dados relacional muito antigo e de base sólida. Não é de hoje que ouvimos sobre modelo de dados relacionale modelo de classes. Podemos ter diversos tipos de relacionamentos, mas para nosso estudo verificaremos apenas alguns de certa relevância em nosso projeto. Um para um Uma classe é associada com outra classe, mas apenas uma instância para uma instância, por exemplo, o relacionamento entre funcionários e cônjuge (sem considerar poligamias e poliandrias, por favor). Este tipo de relacionamento é implementado através de chave estrangeira no banco de dados. Podemos ter relacionamento um para um, bastando apenas informar o tipo de relacionamento: @OneToOne,@OneToMany etc 2011). Para realizar uma dessas notações, seria necessário seguir os Considere o cenário acima, entre as classes Funcionários e Cônjuges. 1. Na classe Funcionários, declarar uma variável com visibilidade private para a classe Cônjuge, conforme a seguir: “ Observe que após a visibilidade teriam a primeira letra maiuscula indicando ser a Classe Conjuge e o nome da variável “conjuge". 2. Na fase de encapsulamento, passo este onde serão criadas as “cápsulas” que nada mais ao do que variáveis, sobre do encapsulamento da variável criada no item 1, ter a notação com o relacionamento: “@OneToOne(cascade={CascadeType.PERSIST})” Veja a figura abaixo sua representação: Figura 4: Exemplo de notação @OneToOne Fonte: (SAMPAIO, 2011, p. 231) O argumento “cascade cascateadas, como se fosse repassado para a entidade cônjuge quando alterações forem realizadas na entidade de Funcionários que afetassem o conjuge. É preciso pesquisar sobre os tipos de “cascade”, uma vez que temos: PERSIST,REMOVE,MERGE,REFRESH e ALL. informar o tipo de relacionamento: @OneToOne,@OneToMany etc Para realizar uma dessas notações, seria necessário seguir os passos: Considere o cenário acima, entre as classes Funcionários e Cônjuges. Na classe Funcionários, declarar uma variável com visibilidade private para a classe Cônjuge, conforme a seguir: “private Conjuge conjuge; Observe que após a visibilidade teriamos o tipo, naturalmente inicia com a primeira letra maiuscula indicando ser a Classe Conjuge e o nome da variável “conjuge". Na fase de encapsulamento, passo este onde serão criadas as que nada mais ao do que métodos públicos para acesso as sobre do encapsulamento da variável criada no item 1, ter a notação com o relacionamento: “@OneToOne(cascade={CascadeType.PERSIST})” Veja a figura abaixo sua representação: : Exemplo de notação @OneToOne (SAMPAIO, 2011, p. 231) cascade” desta notação significa que as informações serão cascateadas, como se fosse repassado para a entidade cônjuge quando m realizadas na entidade de Funcionários que afetassem o conjuge. É preciso pesquisar sobre os tipos de “cascade”, uma vez que temos: PERSIST,REMOVE,MERGE,REFRESH e ALL. 10 informar o tipo de relacionamento: @OneToOne,@OneToMany etc (SAMPAIO, passos: Considere o cenário acima, entre as classes Funcionários e Cônjuges. Na classe Funcionários, declarar uma variável com visibilidade private private Conjuge conjuge;” os o tipo, naturalmente inicia com a primeira letra maiuscula indicando ser a Classe Conjuge e o nome da Na fase de encapsulamento, passo este onde serão criadas as métodos públicos para acesso as sobre do encapsulamento da variável criada no item 1, deve ter a notação com o relacionamento: ” desta notação significa que as informações serão cascateadas, como se fosse repassado para a entidade cônjuge quando m realizadas na entidade de Funcionários que afetassem o conjuge. É preciso pesquisar sobre os tipos de “cascade”, uma vez que temos: Um para muitos O relacionamento um para muitos é o mais comum acontecer no banco de dados, apesar de existir outros, como o “muitos para muitos”, estes não serão abordados no nosso projeto. Sua notação é bem semelhante ao um para um, todavia, se diferencia na criação de uma variável coleção (Collection) ou Lista para a listagem de todas as instâncias da entidade relacional com a instâ Veja sua o exemplo na figura abaixo, em uma classe de clientes com relação N entre a classe de Pedidos. Figura 5: Exemplo de notação @OneTo Fonte: (SAMPAIO, 2011, p. 235) Operações com o EntityManager A classe de gerenciamento “Entity Manager” oferece diversas operações comuns para manipulação de dados no banco de dados. Para que a Entity sincronize seu estado co para tal serviço, abaixo são pontuadas: Persist – Utilizada para gravar um novo registro no banco de dados. Basta criar uma classe, preencher os atributos com os valores e persistir através do manager ativo, import javax.persistence O relacionamento um para muitos é o mais comum acontecer no banco de ados, apesar de existir outros, como o “muitos para muitos”, estes não serão abordados no nosso projeto. Sua notação é bem semelhante ao um para um, todavia, se diferencia na criação de uma variável coleção (Collection) ou Lista para a listagem de todas entidade relacional com a instância da entidade proprietária. Veja sua o exemplo na figura abaixo, em uma classe de clientes com relação N entre a classe de Pedidos. Exemplo de notação @OneToMany (SAMPAIO, 2011, p. 235) Operações com o EntityManager A classe de gerenciamento “Entity Manager” oferece diversas operações comuns para manipulação de dados no banco de dados. Para que a Entity sincronize seu estado com o banco de dados é necessário usar operações para tal serviço, abaixo são pontuadas: Utilizada para gravar um novo registro no banco de dados. Basta criar uma classe, preencher os atributos com os valores e persistir através do manager ativo, exemplo: persistence.Entity; 11 O relacionamento um para muitos é o mais comum acontecer no banco de ados, apesar de existir outros, como o “muitos para muitos”, estes não serão Sua notação é bem semelhante ao um para um, todavia, se diferencia na criação de uma variável coleção (Collection) ou Lista para a listagem de todas ncia da entidade proprietária. Veja sua o exemplo na figura abaixo, em uma classe de clientes com relação N A classe de gerenciamento “Entity Manager” oferece diversas operações comuns para manipulação de dados no banco de dados. Para que a Entity m o banco de dados é necessário usar operações Utilizada para gravar um novo registro no banco de dados. Basta criar uma classe, preencher os atributos com os valores e persistir 12 Livos oLivro = new Livros(); oLivro.Titulo = “UML – diagramas”; oLivro.Autor = “Ana Cristina” manager.persist(oLivro); Figura 6: Exemplo de operação Persist Fonte: Própria (2012) find – Procura uma entidade utilizando como filtro a chave primária. merge – Retorna a entidade desligado ao seu estado gerenciável sem perder os dados alterados. clear – Desliga as entidades, tornando-as “destached” e limpa o Persistent Context. remove – Quando em estado gerenciável “Managed” é possível remover a entidade do banco, registros excluídos na entidade serão excluídos do banco de dados. flush – Aplica as alterações no banco de dados. refresh – Atualiza os dados em cache (memória) com os dados do banco de dados. CRUD Para que nosso projeto foque apenas na produção do boleto com a biblioteca “Bopepo”, neste sentido, usaremos como ferramenta o CRUD. A imagem abaixo exemplifica seu significado: Figura 7: Significado CRUD Fonte: (AKITA, 2006, p. 41) 13 IDE - Netbeans O Netbeans é um ambiente de desenvolvimento, IDE (Interface Development Environment), open-source escrito totalmente em Java (GONÇALVES, 2006, p. 23). Sendo um ambiente que permite a você escrever, compilare debugar, sua evolução vem sendo visível ao longo dos anos, portanto, foi escolhida esta IDE para trabalharmos. Caso seja iniciante e ainda não saiba como instalar o Netbeans, procure mais informações em nossas referências. SGDB – Sistema gerenciador de banco de dados Segundo (FURTADO, 2002, p. 31) os sistemas Gerenciadores de Bancos de Dados (SGDB) são os softwares responsáveis pela manipulação de diferentes arquivos de dados e o relacionamento entre os mesmos de forma segura e fidedigna. O SGDB é uma ferramenta que possibilita armazenar, organizar, classificar, recuperar e manipular dados, possibilitando uma grande diversidade de aplicações. Alguns SGBD reconhecidos comercialmente são: Oracle8i da Oracle, DB2 da IBM, SQL Server da Microsoft. Outros SGDB são gratuitos, possibilitando seu uso sem custo nenhum, portanto, fizemos o uso do MySQL Workbench 5.2. DIAGRAMA DE CLASSE O diagrama de classes é a estrela principal de um sistema orientado a objetos. Neste diagrama é possível modelar detalhes das classes e seus 14 relacionamentos. Também são visíveis outros elementos como interfaces e pacotes (MELO, 2004, p. 100). De modo mais simplificado o conceito de classe é um conjunto de objetos com as mesmas características, assim, o diagrama de classe apresenta essas classes e suas relações a fim de facilitar o entendimento de como elas estão dispostas no sistema. Usaremos conceitos de diagrama de classe e relacionamentos em nosso projeto, para aqueles que ainda têm duvidas relacionados a este assunto, procure em nossas referências mais informações. DIAGRAMA DE CLASSE DO PROJETO BOLETO Nosso projeto focará em gerar boletos com a biblioteca Bopepo, neste sentido, o diagrama será simplificado em apenas três tabelas chamadas de: Pessoas Contas Titulos De modo geral, a classe Pessoas armazenará dados de clientes e da empresa, naturalmente foi usado um processo de abstração chamado “generalização” entre as classes de clientes e empresas, gerando assim a classe Pessoas. Abstrair é a capacidade de isolar os aspectos que sejam importantes a um determinado propósito e suprimir (descartar sem dó nem piedade) os que não forem. A palavra “Invenção” fica totalmente proibida. Todas as dúvidas que houver, sobre quaisquer passos, devem ser acertadas e fechadas com o usuário. Ele passará a ser o mentor e consultar do projeto (ANSELMO, 2005). Para aqueles que ainda não entendem os processos de abstração como: Classificação/Instanciação, Generalização/Especialização, Agregação/Decomposição e Associação, inicie em nossas referências. 15 A figura abaixo ilustra o diagrama de classe: Figura 8: Diagrama de classe do projeto Fonte: Própria (2012) Os relacionamentos neste caso são importantíssimos, tanto as chaves primárias quanto as chaves estrangeiras. Neste ponto, após ter sido feito o diagrama verifique se os códigos das chave primárias estão auto incremento, uma vez que, devem ser únicos e quando gerarmos a entidade, os campos com auto incremento (AI), receberão a notação @Transient, por sua vez, transitórios não são instanciados, o banco de dados se encarregará de seu preenchimento. 16 SOBRE O PROJETO BOPEPO Apresentando diretamente da fonte, em que segundo (JRIMUM, 2008) o Bopepo é uma biblioteca Java que tem por finalidade tornar simples e rápido o processo de geração de boletos bancários personalizados. Mas Bopepo não é simplesmente uma biblioteca que gera boletos bancários. Além de atender a este requisito, ele também oferece ao usuário a possibilidade de: Personalizar o layout de impressão do boleto bancário: o Definir imagens estáticas; o Definir texto estático; o Alterar a disposição das informações estáticas; o Adicionar textos dinâmicos; o Adicionar imagens dinâmicas. Estender o componente: o Fornecer informações sobre bancos ainda não suportados; o Fornecer informações sobre a composição de campos livre ainda não suportados. Utilizar a biblioteca Bopepo é bem simples. Para isto basta que tenhamos conhecimentos básicos na linguagem Java. Para saber por onde começar acesse nossas referências. Bancos suportados Confira abaixo a listagem completa de todos os bancos suportados. Banco Código Banco do Brasil 001 Banco do Nordeste 004 Banestes 021 17 Santander 033 Barisul 041 Banco Intermedium 077 Caixa Econômica 104 Nossa Caixa 151 Bradesco 237 Itaú 341 Real 356 Banco Mercantil do Brasil 389 Hsbc 399 Unibanco 409 Banco Safra 422 Banco Rural 453 Banco Sicredi 748 Banco Cooperativo - Bancoob 756 Tabela 1: Bancos suportados pela biblioteca Bopepo Fonte: (JRIMUM, 2008) Nosso projeto contemplará o banco Caixa Econômica Federal, onde fizemos testes e homologamos o boleto com código de barras, layout e linha digitável corretas. BIBLIOTECA Dependencias o Java 1.5 ou superior. o iText (versão compilada: 2.0.8) (versões já testadas 2.0.6 até 2.1.7). o Apache Commons Lang (2.4). o Apache log4j (1.2.15). o PDF: 1.5 (Acrobat 6.x ou superior), para os boletos gerados pelo Bopepo. Obs: As versões das dependências aqui descritas são aquelas testadas e utilizadas pelo componente Bopepo. Releases (versões liberadas) 18 No site do projeto (jrimum.org) existem versões liberadas, contudo a utilizada em nosso teste foi uma release estável snapshot 03/08/2010 No site de download: jrimum.org/jrimum/wiki/Projeto/Download é possível baixar as bibliotecas. No Netbeans foi criada uma nova biblioteca chamada Bopepo e, adicionado os arquivos conforme figura. Figura 9: Lista de biblioteca necessárias bopepo. Fonte: Própria (2012) 19 PROJETO BOLETO CRIANDO O BANCO DE DADOS Sincronizando modelo com o banco de dados Crie no MySQL Workbench o modelo conforme figura do diagrama de classe, em seguida, basta sincronizar com o banco para gerar fisicamente no mysql o modelo. Figura 10: Sincronizar modelo no MySQL Workbench Fonte: Própria (2012) Siga os passos do assistente e ao final o banco de dados será criado com as tabelas especificadas. Fica livre a quem preferir gerar o script e executar em um SGDB de sua preferência. CRIANDO FORMULÁRIOS CRUD Formulário Pessoas Como nosso formulário que fará o cadastro de pessoas, englobará tanto cadastro de clientes quanto de nossa filial, portanto, não é necessário se importar em desenvolver um formulário para cada um e, sim apenas um. Com a facilidade CRUD, uma vez que, ele cria a entidade com as operações básicas de (INSERT, SELECT, UPDATE, DELETE), nos economiza tempo desenhando formulários, portanto, o que faremos será usar o assistente do Netbeans para fazer esse serviço para nós. Sobre o layout dos formulários, 20 fique a vontade se quiser fazer melhorias, sendo assim, nosso layout (desenho do frame) ficará o básico aplicado pelo assistente CRUD. Para iniciar, crie um projeto no Netbeans chamado: Boleto. No menu Arquivo >> Novo projeto ... Categoria/Projetos: Java >> Aplicativo da área de trabalho Java Antes de finalizar, marque a opção: Usar pasta dedicada para armazenar bibliotecas. No campo “Pasta das bibliotecas” defina como: “.\lib” sem aspas – observe que tem um ponto antes da barra invertida. Clique no botão finalizar do assistente para gerar o projeto. Figura 11: Tela do assistente para criar um novo projeto Netbeans Fonte: Própria (2012) Nosso próximo passo é gerar o primeiro formulário CRUD, uma vez que, o primeiro formulário têm algumas particularidades que devemser observadas como, por exemplo: “Unidade de persistência”, depois porque, esta é responsável pela conexão entre o projeto e o banco de dados, neste sentido, deverá ser criada, já que o Netbeans ainda não fez conexão com o banco de dados. Para criar o CRUD (formulário de amo necessário dentre os menus, selecionar outros, na categoria: “Formulários GUI Swing” procurar por: “formulário de amostra mestre/detalhe”. Clique sobre o projeto “Boleto” com o botão direito e escolha: “Novo >> Outro...” conforme figura abaixo: Figura 12: Menu suspenso para criar outro objeto no projeto Fonte: Própria (2012) Escolha a categoria “Formulários GUI Swing” e depois em Tipos de arquivos escolha: “formulário de amostra mestre/d Figura 13: Tela de novo arquivo Netbeans Fonte: Própria (2012) No próximo passo “Nome e Local” defina o nome da classe como: “jFPessoas”, mantenho o restante com os valores Para criar o CRUD (formulário de amostra mestre/detalhe) pela primeira vez, é necessário dentre os menus, selecionar outros, na categoria: “Formulários GUI Swing” procurar por: “formulário de amostra mestre/detalhe”. Clique sobre o projeto “Boleto” com o botão direito e escolha: “Novo >> tro...” conforme figura abaixo: : Menu suspenso para criar outro objeto no projeto Escolha a categoria “Formulários GUI Swing” e depois em Tipos de arquivos escolha: “formulário de amostra mestre/detalhe”, clique em próximo. : Tela de novo arquivo Netbeans - Criar um formulário CRUD No próximo passo “Nome e Local” defina o nome da classe como: “jFPessoas”, mantenho o restante com os valores padrões, e clique no botão “Próximo”. 21 stra mestre/detalhe) pela primeira vez, é necessário dentre os menus, selecionar outros, na categoria: “Formulários GUI Clique sobre o projeto “Boleto” com o botão direito e escolha: “Novo >> Escolha a categoria “Formulários GUI Swing” e depois em Tipos de arquivos etalhe”, clique em próximo. No próximo passo “Nome e Local” defina o nome da classe como: “jFPessoas”, padrões, e clique no botão “Próximo”. 22 No passo “Tabela mestre” deixe em colunas a serem incluídas apenas os campos mais importantes como: COD_PESSOA,NOME,CPF_CNPJ. Os demais campos, pode-se transferir para a esquerda na lista “Colunas disponíveis”, após realizar esse processo, clique no botão próximo para avançar mais um passo. No passo “Opções de detalhe” mantenham todos os campos em “Campos a serem incluídos” e clique no botão Finalizar para concluir todos os passos e gerar seu formulário com as opções CRUD. Se tudo ocorrer como esperado, você deve ter um frame como a figura abaixo: Figura 14: Formulário CRUD da classe Pessoas Fonte: Própria (2012) Figura 15: Formulário Pessoas com a primeira instância. Fonte: Própria (2012) É possível melhorar o designer do formulário, manteremos o básico gerado apenas para que possamos continuar os testes. Para testar, basta clicar com botão direito do mouse sobre o frame e escolher “Executar arquivo” ou pressionar simultaneamente as teclas “Shift” e “F6”. É importante que nos teste seja informado CPF ou CNPJ válidos com as respectivas mascaras, uma vez que, o boleto validará os mesmo. Formulário Contas 23 O formulário para a classe Contas seguirá os mesmos passos, então, reflita os passos abaixo: Nome e local Tabela mestre Opções de detalhe Nome da classe: jFContas Colunas a serem incluídas: COD_CONTA COD_PESSOA LOCAL_PAGAMENTO CONTA_CEDENTE Manter padrão. Tabela 2: Configuração do frame contas Fonte: Própria (2012) Após a conclusão dos passos do assistente, deve-se obter o resultado conforme figura abaixo: Figura 16: Frame de contas recém-criado Fonte: Própria (2012) Figura 17: Frame de contas, após alterações. Fonte: Própria (2012) Nosso próximo passo é ainda na tela de contas, por sua vez, devemos tratar as chaves estrangeiras, uma vez que, precisaremos usar combos ao invés de campos texto, isso porque, o usuário escolherá de qual empresa é a conta e que este campo listará as pessoas, todavia o campo que representa o código 24 de conta pode ser excluído do formulário, pois não será necessário e está meramente para visualização. Binding (Vinculando) – jCombobox Para realizarmos a conexão do jCombobox com o banco de dados, para que possa ser possível listar as pessoas, usaremos sua opção “Binding” ou vinculação. Não é complicado, mas exige certo preparo, neste sentido, vamos aos passos: Precisaremos alterar o tipo do atributo codPessoa da entidade Contas de “int” para Pessoas. Este atributo (codPessoa) foi gerado automaticamente com o tipo “int”, na classe de Contas uma vez que, no banco de dados é assim.A alteração consiste em mudar o tipo “int” para o tipo de classe “Pessoas”, tornando o atributo codPessoa uma “ponte” para os outros atributos da classe, inclusive é possível até mesmo alterar o nome do campo se preferir, isso deixo a seu critério. O trabalho em realizar essa tarefa é que, uma vez alterado seu tipo declarado, deveremos alterá-lo também nas capsulas. Abra a classe Contas e procure pela declaração do “codPessoa”, deve estar dessa forma: private int codPessoa; Altere para: private Pessoas codPessoa; Portanto deve-se alterar o tipo “int” para “Pessoas”. Ao realizar esse passo, um “balão amarelo” na lateral do editor de código fará uma sugestão, informando que a relação da entidade ainda não foi definida, uma vez que, está efetuando esta relação manualmente, deve-se na entidade Pessoas criar um campo do tipo “List” com uma relação N-1 da entidade “Contas” para a entidade “Pessoas”, assim, basta clicar sobre o balão e escolher “Criar relacionamento bidirecional ManyToOne”. Neste momento será solicitado o 25 nome do campo “List” a ser criado em Pessoas, neste sentido, defina como “contasList” e pressione o botão <OK>, conforme imagem abaixo: Figura 18: Criar relacionamento bidirecional "ManyToOne" Fonte: Própria (2012) Estamos próximos de terminar a configuração, todavia, ainda necessitamos transformar a coluna “COD_PESSOA” em uma coluna JOIN (junção) entre contas e pessoas através do campo “COD_PESSOA”. Altere o código: @Basic(optional = false) @Column(name = "COD_ PESSOA ") Para: @JoinColumn(name="COD_PESSOA",referencedColumnName="COD_PESS OA") Todo o trecho ficará conforme figura abaixo: Figura 19: Trecho do código de relação JoinColumn Fonte: Própria (2012) Após este processo, aparecerão várias taxas vermelhas n de código, isso para indica Neste sentido, isso acontece declaradas abaixo no código para Pessoas. Quando usamos “Binding” para navegar nos registros, precisamos declarar uma variável do tipo do objeto e def que o masterTable estiver focado. Para economizar essa declaração e facilitar o desenvolvimento, basta arrastar a classe que necessita, em nosso caso a “Contas” para dentro do Frame, assim declarando automaticamente variável chamada “nome da classe1” no projeto atual seria: “contas1”. As figuras abaixo, demonstram respectivamente os movimentos a serem realizados: Figura 20: Recorte do movimento Fonte: Própria (2012) Na figura abaixo, mostra a sequencia em arrastar a classe e soltá área em branco do frame. : Trecho do código de relação JoinColumn Após este processo, aparecerão várias taxas vermelhas nas laterais do indicar que o tipo da variável codPessoa acontece porque existem outras variáveis no código com o tipo “int”, basta ir uma a uma e alterando Quando usamos “Binding” para navegar nos registros, precisamosdeclarar uma variável do tipo do objeto e defini-lo com a coleção dos dados atuais em que o masterTable estiver focado. Para economizar essa declaração e facilitar o desenvolvimento, basta arrastar a classe que necessita, em nosso caso a “Contas” para dentro do Frame, assim declarando automaticamente variável chamada “nome da classe1” no projeto atual seria: “contas1”. As figuras abaixo, demonstram respectivamente os movimentos a serem : Recorte do movimento - mover classe para o Frame. Na figura abaixo, mostra a sequencia em arrastar a classe e soltá área em branco do frame. 26 s laterais do editor codPessoa não confere. porque existem outras variáveis codPessoa ”, basta ir uma a uma e alterando Quando usamos “Binding” para navegar nos registros, precisamos declarar lo com a coleção dos dados atuais em que o masterTable estiver focado. Para economizar essa declaração e facilitar o desenvolvimento, basta arrastar a classe que necessita, em nosso caso a “Contas” para dentro do Frame, assim declarando automaticamente uma variável chamada “nome da classe1” no projeto atual seria: “contas1”. As figuras abaixo, demonstram respectivamente os movimentos a serem Na figura abaixo, mostra a sequencia em arrastar a classe e soltá-la em uma Figura 21:Recorte do movime Fonte: Própria (2012) Agora precisaremos ligar os campos da classe aos respectivos campos do masterTable. Abaixo na figura a seguir, segue a demonstração de como vincular cada campo. Figura 22: Vincular campos da classe ao masterTable. Fonte: Própria (2012) Após esse passo surgirá a caixa de vinculo, neste sentido, em “Código vinculação” defina como o masterTable do JFrame e “Expressão de vinculação” defina como selectedElement >> o respectivo campo neste caso do exemplo a agencia. Recorte do movimento - mover classe para o Frame, segundo movimento. os ligar os campos da classe aos respectivos campos do Abaixo na figura a seguir, segue a demonstração de como vincular cada : Vincular campos da classe ao masterTable. Após esse passo surgirá a caixa de vinculo, neste sentido, em “Código vinculação” defina como o masterTable do JFrame e “Expressão de vinculação” defina como selectedElement >> o respectivo campo neste caso do exemplo a 27 mover classe para o Frame, segundo movimento. os ligar os campos da classe aos respectivos campos do Abaixo na figura a seguir, segue a demonstração de como vincular cada Após esse passo surgirá a caixa de vinculo, neste sentido, em “Código-fonte de vinculação” defina como o masterTable do JFrame e “Expressão de vinculação” defina como selectedElement >> o respectivo campo neste caso do exemplo a Figura 23: Caixa de vincular Fonte: Própria (2012) Faça o mesmo com todos os outros campos, considerando que para as chaves estrangeiras, aparecerão umas pastas amarelas no nome do campo, não se preocupe é assim mesmo, isso significa que tudo deu Estamos prontos para prosseguir, portanto, vá até o frame jFContas no lacuna “Cod Pessoa”, altere o componente, deletando o anterior e substituindo por um JCombobox. Para vincular o JCombobox botão direito do mouse escolher Vincular >> Elements. Clicar em “Importar dados para o formulário...” e escolher a entidade Pessoas, pressionar OK e pronto. Para vincular a coleção de dados é simples, agora p selecionado do JCombobox lembra-se ? Também com um clique com botão direito do mouse sobre o swing jCombobox referente a lista de empresas >> Vincular >> selectedItem. Agora o primeiro campo ficará definido para “contas1” e a expressão em: “${codPessoa}”. Seguindo ainda a ideia anterior, falta apenas um passo para concluirmos, pois da maneira como está já funcionaria, contudo o render do funciona adequadamente corrigindo o escolha, neste sentido, será necessário na propriedade código manualmente. Faça o mesmo com todos os outros campos, considerando que para as chaves estrangeiras, aparecerão umas pastas amarelas no nome do campo, não se preocupe é assim mesmo, isso significa que tudo deu certo. Estamos prontos para prosseguir, portanto, vá até o frame jFContas no lacuna “Cod Pessoa”, altere o componente, deletando o anterior e substituindo por um JCombobox ao dados da lista de pessoas, basta clicar com mouse escolher Vincular >> Elements. Clicar em “Importar dados para o formulário...” e escolher a entidade Pessoas, pressionar OK e Para vincular a coleção de dados é simples, agora precisaremos definir o item JCombobox para focar em nossa classe que arrastamos se ? Também com um clique com botão direito do mouse sobre o swing referente a lista de empresas >> Vincular >> selectedItem. Agora mpo ficará definido para “contas1” e a expressão em: Seguindo ainda a ideia anterior, falta apenas um passo para concluirmos, pois da maneira como está já funcionaria, contudo o render do JCombobox funciona adequadamente corrigindo o bind para o campo deveríamos ter escolha, neste sentido, será necessário na propriedade rendered 28 Faça o mesmo com todos os outros campos, considerando que para as chaves estrangeiras, aparecerão umas pastas amarelas no nome do campo, não se Estamos prontos para prosseguir, portanto, vá até o frame jFContas no lacuna “Cod Pessoa”, altere o componente, deletando o anterior e substituindo por um ao dados da lista de pessoas, basta clicar com mouse escolher Vincular >> Elements. Clicar em “Importar dados para o formulário...” e escolher a entidade Pessoas, pressionar OK e recisaremos definir o item para focar em nossa classe que arrastamos se ? Também com um clique com botão direito do mouse sobre o swing referente a lista de empresas >> Vincular >> selectedItem. Agora mpo ficará definido para “contas1” e a expressão em: Seguindo ainda a ideia anterior, falta apenas um passo para concluirmos, pois JCombobox não para o campo deveríamos ter rendered alterar o 29 Na propriedade “renderer” do JCombobox, basta definir um código específico abaixo: new DefaultListCellRenderer() { @Override public Component getListCellRendererComponent( JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); if (value instanceof Pessoas) { Pessoas mec = (Pessoas)value; setText(mec.getNome()); } return this; } } Após ter lançado este código, será necessário corrigir as importações através do editor de códigos. Veja na figura abaixo como ficou o formulário para cadastro de contas: 30 Figura 24: Tela de cadastro de contas Fonte: Própria (2012) O código rendered usado é passado pelo próprio suporte do Netbeans, pois ainda não tem no swing jCombobox a opção em que possa definir o campo que deseja-se mostrar, deste modo, essa é a “solução” enviada por eles, se não houvesse isso, seria possível fazer todo este projeto sem código algum. 31 Formulário Títulos Seguindo as mesmas premissas faça o frame JFTitulos. Algumas particularidades serão encontradas desta vez, uma vez que, existem três chaves estrangeiras e campos com mascaras para serem vinculados. Lembre-se: Realizar os join conforme explicado no artigo e nos campos chaves da entidade alterar a notação @Column para @JoinColumn. Arrastar a classe de títulos para o frame e vincular os campos com o masteTable. Substituir os componentes de chaves FK (estrangeira) por JCombobox e realizaros bindind(vinculação). Na entidade Pessoas, será necessário encapsular o titulosList() para que sua visibilidade torne public. A figura abaixo ilustra como a tela deve ficar: Figura 25: Tela de Titulos. Fonte: Própria (2012) Sinta-se a vontade para alterar a tela conforme necessidade, por exemplo, é comum nesta tela o cliente escolher a quantidade desejada para assim gerar tudo automaticamente, não como está uma a uma, todavia, para nosso projeto, atende perfeitamente. Formulário Ficha financeira O formulário de ficha financeira será o formulário em que visualizaremos as parcelas de cada cliente, podendo assim imprimir o boleto. Para criar essa tela, deve para concluir será necessário uma pequena alteração nas opções de detalhe, veja figura abaixo: Figura 26: Tela de formulário mestre/detalhe Fonte: Própria (2012) Na opção de detalhe não escolha campos e sim uma nova grade,se chamará detailTable. O Frame será divido em duas partes, acima terá a tabela principal, chamada de masterTable, listando as pessoas e abaixo detailTable listando as parcelas, será necessário arrastas as classes de “Pessoas” e “Titulos” e vincular os campos conforme já explicado, porém, deve “Títulos” vinculará com a detailTable. Após colocar um novo botão propositalmente chamado “Boleto” para imprimir o boleto e usar as funções da biblioteca “bopepo” a tela ficará conforme imagem abaixo: tudo automaticamente, não como está uma a uma, todavia, para nosso projeto, Formulário Ficha financeira O formulário de ficha financeira será o formulário em que visualizaremos as parcelas de cada cliente, podendo assim imprimir o boleto. Para criar essa tela, deve-se seguir a mesma ideia, todavia, no ultimo passo para concluir será necessário uma pequena alteração nas opções de detalhe, : Tela de formulário mestre/detalhe - opções de detalhe Na opção de detalhe não escolha campos e sim uma nova grade,se chamará O Frame será divido em duas partes, acima terá a tabela principal, chamada de masterTable, listando as pessoas e abaixo detailTable listando as parcelas, rastas as classes de “Pessoas” e “Titulos” e vincular os campos conforme já explicado, porém, deve-se observar que a classe de “Títulos” vinculará com a detailTable. Após colocar um novo botão propositalmente chamado “Boleto” para imprimir o as funções da biblioteca “bopepo” a tela ficará conforme imagem 32 tudo automaticamente, não como está uma a uma, todavia, para nosso projeto, O formulário de ficha financeira será o formulário em que visualizaremos as se seguir a mesma ideia, todavia, no ultimo passo para concluir será necessário uma pequena alteração nas opções de detalhe, Na opção de detalhe não escolha campos e sim uma nova grade,se chamará O Frame será divido em duas partes, acima terá a tabela principal, chamada de masterTable, listando as pessoas e abaixo detailTable listando as parcelas, rastas as classes de “Pessoas” e “Titulos” e vincular os se observar que a classe de Após colocar um novo botão propositalmente chamado “Boleto” para imprimir o as funções da biblioteca “bopepo” a tela ficará conforme imagem 33 Figura 27: Tela ficha financeira - Impressão de boletos Fonte: Própria (2012) Abaixo segue o código do botão boleto, usando a biblioteca para a impressão: //SCRIPT FUNCIONANDO CAIXA TESTADO DESDE 26/02/2011 //Snap 20100805 //commons-lang-2.4,log4j-1.2.15,iText-2.1.5 //Buscar dados da conta Contas oConta = new Contas(); oConta = entityManager.find(Contas.class, titulos1.getCodConta().getCodConta()); //Buscar empresa Pessoas oEmpresa = new Pessoas(); oEmpresa = entityManager.find(Pessoas.class, titulos1.getCodEmpresa().getCodPessoa()); //Boleto da caixa e banco do brasil if (( !oConta.getNumBanco().equals("104") ) && (!oConta.getNumBanco().equals("1"))) { JOptionPane.showMessageDialog(null, "Boletos disponíveis apenas para CAIXA ECONOMICA e BANCO DO BRASIL.", "ATENÇÃO!", JOptionPane.WARNING_MESSAGE); return; } try { // TODO add your handling code here: 34 /* * INFORMANDO DADOS SOBRE O CEDENTE. */ Cedente cedente = new Cedente( oEmpresa.getNome() , oEmpresa.getCpfCnpj() ); // Informando dados sobre a conta bancária do cendente. Banco banco = BancoSuportado.CAIXA_ECONOMICA_FEDERAL.create(); ContaBancaria contaBancariaCed = new ContaBancaria(banco); contaBancariaCed.setBanco(banco); //Alterar o numero da conta para codigo do cedente em caso da CEF contaBancariaCed.setNumeroDaConta(new NumeroDaConta( Integer.parseInt( oConta.getContaCedente().toString() ) , oConta.getDigitoConta() )); contaBancariaCed.setCarteira(new Carteira( oConta.getCarteira() , TipoDeCobranca.SEM_REGISTRO)); contaBancariaCed.setModalidade(new Modalidade(4)); contaBancariaCed.setAgencia(new Agencia( Integer.parseInt( oConta.getAgencia().toString() ) , oConta.getDigitoAgencia() )); cedente.addContaBancaria(contaBancariaCed); /* * INFORMANDO DADOS SOBRE O SACADO. */ Sacado sacado = new Sacado( pessoas1.getNome() , pessoas1.getCpfCnpj() ); // Informando o endereço do sacado. Endereco enderecoSac = new Endereco(); enderecoSac.setUF(UnidadeFederativa.ES); enderecoSac.setLocalidade( pessoas1.getCidade() ); enderecoSac.setCep(new CEP(pessoas1.getCep())); enderecoSac.setBairro(pessoas1.getBairro()); enderecoSac.setLogradouro(pessoas1.getEndereco()); enderecoSac.setNumero(pessoas1.getNumero()); sacado.addEndereco(enderecoSac); /* * INFORMANDO DADOS SOBRE O SACADOR AVALISTA. */ // Pessoa sacadorAvalista = new Pessoa("Nordeste FomentoMercantil", "00.000.000/0001-91"); // // Informando o endereço do sacador avalista. // Endereco enderecoSacAval = new Endereco(); // enderecoSacAval.setUF(UnidadeFederativa.ES); // enderecoSacAval.setLocalidade("Brasília"); // enderecoSacAval.setCep(new CEP("00000-000")); // enderecoSacAval.setBairro("Grande Centro"); // enderecoSacAval.setLogradouro("Rua EternamentePrincipal"); // enderecoSacAval.setNumero("001"); // sacadorAvalista.addEndereco(enderecoSacAval); /* * INFORMANDO OS DADOS SOBRE O TÍTULO. */ Titulo titulo = new Titulo(contaBancariaCed, sacado, cedente); titulo.setNumeroDoDocumento( titulos1.getNumDocOrigem() ); 35 //SIGCB 15 digitos titulo.setNossoNumero(funcoes.getZeroEsq(titulos1.getCodTitulo() , 15)); //"270005000000781" titulo.setDigitoDoNossoNumero(String.valueOf(funcoes.getMod11(contaBan cariaCed.getCarteira().getCodigo().toString() + titulo.getNossoNumero().toString(), 9, 1))); titulo.setValor(BigDecimal.valueOf( titulos1.getValorTitulo() )); titulo.setDataDoDocumento(new Date()); titulo.setDataDoVencimento( titulos1.getDatVenc() );titulo.setTipoDeDocumento(TipoDeTitulo.DM_DUPLICATA_MERCANTIL); titulo.setAceite(EnumAceite.A); titulo.setDesconto(new BigDecimal( 0 )); /* * INFORMANDO MAIS DADOS BANCÁRIOS, QUANDO NECESSÁRIO. * Dependendo do banco, talvez seja necessário informarmais dados além de: * * > Valor do título; * > Vencimento; * > Nosso número; * > Código do banco * > Data de vencimento; * > Agência/Código do cedente; * > Código da carteira; * > Código da moeda; * * Definidos como padrão pela FEBRABAN. * Verifique na documentação. */ //titulo.setDadosBancarios(new DadoBancario(){}); dougcomentou /* * INFORMANDO OS DADOS SOBRE O BOLETO. */ Boleto boleto = new Boleto(titulo); boleto.addTextosExtras("txtRsNossoNumero", contaBancariaCed.getCarteira().getCodigo().toString() + titulo.getNossoNumero() +"-"+ titulo.getDigitoDoNossoNumero()); boleto.addTextosExtras("txtFcNossoNumero", contaBancariaCed.getCarteira().getCodigo().toString() + titulo.getNossoNumero() +"-"+ titulo.getDigitoDoNossoNumero()); boleto.setLocalPagamento( "ATE O VENCIMENTO, PREFERENCIALMENTE "+ oConta.getLocalPagamento() ); boleto.setInstrucaoAoSacado("APOS O VENCIMENTO, SOMENTE "+ oConta.getLocalPagamento() ); boleto.setInstrucao1( oConta.getInstrucao1() ); boleto.setInstrucao2( oConta.getInstrucao2() ); boleto.setInstrucao3( oConta.getInstrucao3() ); boleto.setInstrucao4(""); boleto.setInstrucao5( oConta.getInstrucao4() ); boleto.setInstrucao6( oConta.getInstrucao5() ); boleto.setInstrucao7( oConta.getInstrucao6() ); boleto.setInstrucao8(""); /* * GERANDO O BOLETO BANCÁRIO. */ // Instanciando um objeto "BoletoViewer", classeresponsável pela geração // do boleto bancário. BoletoViewer boletoViewer = new BoletoViewer(boleto); // Gerando o arquivo. No caso o arquivo mencionado serásalvo na mesma // pasta do projeto. Outros exemplos: // WINDOWS: boletoViewer.getAsPDF("C:/Temp/MeuBoleto.pdf"); // LINUX: boletoViewer.getAsPDF("/home/temp/MeuBoleto.pdf"); File arquivoPdf = boletoViewer.getPdfAsFile( oConta.getNomeArquivo() ); // Mos funcoes.mostreBoletoNaTela(arquivoPdf); } catch (ParseException ex) { JOptionPane.showMessageDialog(null, ex, "ATENÇÃO!", JOptionPane.WARNING_MESSAGE); Logger.getLogger(jFFichaFinanceira.class.getName()).log(Level.SEVERE, null, ex); } O código está totalmente comentado e não está difícil sua compreensão. Foram usados algumas funções específicas, criadas a parte em uma classe chamada “funcoes” que deve Figura 28: Boleto criado pela biblioteca Bopepo Fonte: Própria (2012) // Instanciando um objeto "BoletoViewer", classeresponsável pela geração // do boleto bancário. BoletoViewer boletoViewer = new BoletoViewer(boleto); // Gerando o arquivo. No caso o arquivo mencionado // pasta do projeto. Outros exemplos: // WINDOWS: boletoViewer.getAsPDF("C:/Temp/MeuBoleto.pdf"); // LINUX: boletoViewer.getAsPDF("/home/temp/MeuBoleto.pdf"); File arquivoPdf = boletoViewer.getPdfAsFile( oConta.getNomeArquivo() ); // Mostrando o boleto gerado na tela. funcoes.mostreBoletoNaTela(arquivoPdf); } catch (ParseException ex) { JOptionPane.showMessageDialog(null, ex, "ATENÇÃO!", JOptionPane.WARNING_MESSAGE); gger(jFFichaFinanceira.class.getName()).log(Level.SEVERE, O código está totalmente comentado e não está difícil sua compreensão. Foram usados algumas funções específicas, criadas a parte em uma classe chamada “funcoes” que deve acompanhar o artigo. : Boleto criado pela biblioteca Bopepo 36 // Instanciando um objeto "BoletoViewer", BoletoViewer boletoViewer = new BoletoViewer(boleto); // Gerando o arquivo. No caso o arquivo mencionado File arquivoPdf = boletoViewer.getPdfAsFile( JOptionPane.showMessageDialog(null, ex, "ATENÇÃO!", gger(jFFichaFinanceira.class.getName()).log(Level.SEVERE, O código está totalmente comentado e não está difícil sua compreensão. Foram usados algumas funções específicas, criadas a parte em uma classe
Compartilhar