JPA - Java Persistence API

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