Resumo do Curso de Java

Leonardo Moura Leitão

Conteúdo
1. Resumo Eclipse Galileo ................................................................................................................................................ 2
1. Resumo Eclipse Galileo
1.1. Criar um novo projeto Java
1.2. Associar o TOMCAT ao Eclipse
• IMPORTANTE: Para executar essa configuração o TOMCAT deve está instalado.
1.3. Criar um novo projeto Web com JSF
 • Alterar dentro de WebContent/WEB-INF/web.xml

• Copiar as bibliotecas do JSF (opcionalmente do Richfaces, JPA, JasperReport...) para a pasta

WebContent/WEB-INF/lib.

1.4. Associar o Projeto Web ao TOMCAT

1.5. Importar um projeto existente
1.6. Exportar um projeto existente
Não há necessidade de exportar o projeto se você quiser transferi-lo para outro computador, basta
copiar o projeto dentro do workspace para o pendrive, por exemplo, e no eclipse de destino usar a opção de
Import. Entretanto se o objetivo for disponibilizar uma aplicação web no servidor siga os passos do tópico
abaixo.

1.7. Exportar o projeto para o TOMCAT

 • IMPORTANTE: Antes de executar os passos abaixo o TOMCAT deve ser iniciado fora do eclipse.

1.8. Telas de talhos

• Crtl + Shift + R: Procura os recursos (classes, arquivos de configuração...) dentro do workspace.

• Crtl + Shift + F: Usado para formatar o código

• Crtl + Shift + O: Organiza os imports
2. Resumo Java
2.1. Exceções

2.1.1. Exceção Não-Verificada

• Estende (direta ou indiretamente) RuntimeException.
• A linguagem não obriga o tratamento da exceção, ou seja, fica a cargo do desenvolvedor tratar ou
não a exceção.
• Exemplo
 2.1.2.Exceção Verificada
• Estende (direta ou indiretamente) Exception.
• A linguagem obriga o tratamento da exceção ou a declaração na assinatura do método de que a
exceção pode ser gerada.
• Exemplo

3. Resumo JPA
O JPA (Java Persistence API) é o framework Java para acesso ao banco de dados baseado em mapeamento
objeto-relacional (ORM).
O mapeamento objeto-relacional consiste em relacionar os meus objetos de domínio (entidades) com as
tabelas no banco de dados objetivando uma convivência harmoniosa entre dois paradigmas (OO x ER) bastante
diferentes. Esse mapeamento é feito através de anotações (e.g. @Column).
3.1. As principais anotações
• @Entity – Anotação que define uma classe de entidade da JPA. Só é possível mapear um objeto para
uma tabela no banco de dados se a classe possuir essa anotação. Toda classe marcada com @Entity
deve possuir pelo menos um atributo marcado com @Id;
• @Table – Anotação usada principalmente quando o nome da tabela do banco de dados é diferente do
nome da classe;

• @MappedSuperclass – Anotação usada em uma classe que não irá para o banco de dados, mas que
será mapeada objetivando o reuso por herança;

• @Id – Anotação que define qual atributo na classe representa a chave primária da tabela
correspondente;
 • @GeneretedValue – Anotação que define a geração automática do valor do atributo. Normalmente
essa anotação é usada no contexto da chave primária quando o campo é auto-incremento;

• @Column – Anotação usada para mapear um atributo da classe para uma coluna na tabela. Quando
essa anotação é omitida o atributo da classe será mapeado para uma coluna que possui o mesmo
nome do atributo, que aceita valor nulo e que possui o tamanho de 255 quando for do tipo string.

• @Transient – Anotação usada para excluir um atributo do mapeamento, ou seja, o atributo marcado
com essa anotação não irá para o banco de dados;

• @Enumeration – Anotação usada para mapear enumerações para o banco de dados;

• @Temporal – Anotação usada para mapear objetos do tipo data. Possui três configurações, quais
sejam: TIME – usado para armazenar somente a hora, DATE – usado para armazenar somente a data e
TIMESTAMP – usado para armazenar data e hora.

• @OneToOne – Anotação usada para estabelecer o relacionamento um-para-um entre duas entidade;
• @OneToMany – Anotação usada para estabelecer o relacionamento um-para-muitos entre duas
entidade;
• @ManyToOne – Anotação usada para estabelecer o relacionamento muitos-para-um entre duas
entidade;
• @ManyToMany – Anotação usada para estabelecer o relacionamento muitos-para-muitos entre duas
entidade;
3.2. Os relacionamentos
3.2.1. Relacionamento um-para-um (unidirecional)
3.2.2. Relacionamento um-para-um (bidirecional)
3.2.3. Relacionamento um-para-muitos(unidirecional)
3.2.4. Relacionamento um-para-muitos (biidirecional)
3.2.5. Relacionamento muitos-para-muitos (unidirecional)
3.2.6. Relacionamento muitos-para-muitos (bidirecional)
3.2.7. Relacionamento muitos-para-muitos c/ entidade intermediária
3.3. persistence.xml
O arquivo persistence.xml tem por responsabilidade principal configurar a(s) conexão(ões) com o
banco de dados. Cada conexão possui um nome (persistence-unit name=”...”) que é usado dentro o código
Java para referenciar a conexão desejada.
 Esse arquivo SEMPRE deve ser colocado dentro da pasta META-INF no diretório de código fonte
(normalmente chamado de src).

3.4. Padrão de projeto DAO (Data Access Object)

O padrão de projeto DAO é responsável por encapsular (esconder) todo o acesso a banco de dados.
Dentro do contexto do JPA o DAO trabalha prioritariamente com três objetos, quais sejam:
• EntityManager – Responsável por todas as operações do CRUD (C – Create, R – Read, U – update e D-
Delete).
• EntityManagerFactory – Responsável por criar o EntityManager. Na criação do EntityManagerFactory é
necessário informar o nome da persistence-unit.
• EntityTransaction – O JPA exige que todas as operações que alteram o banco de dados (insert, update
e delete) estejam dentro de uma transação.

4. Resumo Web
4.1. Servlet
• Classe Java;
• Estende HttpServlet;
• Deve implementar algum dos métodos correspondentes do HTTP, como por exemplo o doGet, do Post...;
• Funciona como um pequeno servidor web, pois trabalha com requisição/resposta;
• Deve ser declarado dentro do web.xml;
• Gera HTML dinamicamente, mas não é mais usado (diretamente) para geração de interface gráfica;

4.2. JSP
• Página HTML que suporta código Java para geração de conteúdo dinâmico;
• Será convertido em um servlet automaticamente pelo servidor (TOMCAT);
• Existem diversas maneiras de adicionar código Java dentro de uma página .jsp a principal é usando o
scriptlet (<% %>);
• Dentro do contexto do scriptlet existem oito objetos implícitos que podem ser acessados, como por
exemplo, o request, response, session, out...;
• O uso de código Java diretamente dentro da página é desaconselhado, para geração de conteúdo
dinâmico são usadas as bibliotecas de tags (TAGLIB);

4.3. TAGLIB
• Representa uma biblioteca de tags;
• Deve ser declaradas dentro de uma página usando uma declaração <%@taglib uri=”” prefix=”” %>;
• Para usar uma tag de uma biblioteca, basta usar a seguinte sintaxe: <prefixo:nomeDaTag ... />
5. Resumo JSF
5.1. Modelo MVC

5.2. Regras de navegação

• Regra de navegação local
 • Regra de navegação global

5.3. Managed Bean

6. Resumo JasperReport
7. Resumo aplicação da Biblioteca
7.1. Padrão Layers (Camadas)

7.2. MVC + Layers

7.3. Camada Comum

• Visão geral
 • Entidades

7.4. Camada Infraestrutura

7.5. Camada de Negócio

7.6. Camada de apresentação