Prof.

Marcos Ferreira
Unidade curricular: Desenvolvimento Baseado em FrameWorks 2
Curso: Tecnólogo em Análise e
Desenvolvimento de Sistemas

Período: 6º/2019
Aluno: Adriano Aparecido de Souza Silva

O Apache Maven é uma ferramenta de automação e gerenciamento de

projetos Java, embora também possa ser utilizada com outras
linguagens. Ela fornece às equipes de desenvolvimento uma forma
padronizada de automação, construção e publicação de suas
aplicações, agregando agilidade e qualidade ao produto final. Por
ser extremamente flexível, permite que sejam adicionados plugins a
si, para estender suas funcionalidades nativas.
Fonte: 25128

Atividade 01
Realize uma pesquisa e apresente outros automatizadores e
gerenciadores de projetos (mínimo dois), utilizados na plataforma
JavaEE.

Ant

O Ant é o padrão ocial para compilar projetos Java. Assim como o

Make, ele
trabalha com targets, dependências e comandos, porém a sintaxe é
completamente diferente do Make.
Além disso, o Ant utiliza um documento no padrão XML para cada
projeto e
elementos XML para listar comandos.
Segue na Listagem 4 um exemplo de um arquivo Ant.
<?xml version="1.0"?>
<project name="TesteJavaAnt" default="build">
<property name="src.dir" location="src" />
<property name="build.dir" location="build/classes" />
<target name="mkdir">
<mkdir dir="${build.dir}" />
<mkdir dir="${build.dir}/JARs" />
</target>
<target name="build" depends="mkdir">
<javac srcdir="${src.dir}" destdir="${build.dir}"/>
</target>
<target name="gerajar" depends="build">
<jar destfile="${build.dir}/JARs" basedir="${build.dir}"
</target>
</project>
Listagem 4. Exemplo de um arquivo Ant.
Este arquivo é nomeado como build.xml e deve ser colocado na raiz
do projeto.
Neste exemplo primeiramente será executada a tag mkdir, depois
build, que
depende de mkdir e, por m, gerajar, que depende da execução do
build.
Para invocar o documento basta digitar "ant" na linha de comando.
O arquivo apresentado mostra diversas propriedades, targets,
dependências e
comandos que podem ser utilizados no arquivo XML do Ant, onde as
propriedades são denidas no topo do arquivo, mas também podem estar
em um
arquivo separado e ser importado por outro arquivo através da task
<import>.

Gradle
Apenas para uma breve introdução, o Gradle trata-se de uma
ferramenta de build open source bastante poderosa que nos permite
configurar arquivos de build por meio da sua DSL (Domain Specific
Language) baseada na linguagem Groovy.
“Então pra eu aprender Gradle eu preciso saber Groovy?”
Não necessariamente, pois o motivo de escolherem uma linguagem
dinâmica para a configuração é justamente para evitar a verbosidade
da estrutura XML que é muito comum em ferramentas como essa.
Claro, se você conhecer um pouco de Groovy vai tirar bastante
proveito da syntax do código.
Orientado a tasks
Além da DSL, a ideia do Gradle é permitir configurações baseando-se
em tasks, ou seja, quando queremos criar algum novo comportamento
durante o build, vamos criar uma task!

CMake
CMake é um sistema multiplataforma para realizar geração
automatizada. É comparável com o programa Unix Make no qual o
processo de geração é, ao final, controlado pelos arquivos de
configuração, no caso do CMake chamados de arquivos CMakeLists.txt.
Diferente de Make, ele não gera diretamente o software final, mas
em vez disso gera arquivos de geração padrões (por exemplo,
makefiles em Unix e projetos/espaços de trabalho no Visual C++ no
Windows) os quais são usados de modo comum. Isto permite que
desenvolvedores familiarizados com um ambiente de desenvolvimento
particular (tal como as várias IDEs) utilizem-o no modo padrão. É
esta utilização do ambiente de geração nativo que distingue CMake
dos outros sistemas mais conhecidos como o SCons. CMake pode
compilar código fonte, cria bibliotecas, gerar empacotadores e
construir executáveis em combinações variáveis. Ele também suporta
gerações ordenadas (in-place) e desordenada (out-of-place) e pode
portanto suportar múltiplas gerações de uma única árvore fonte.
CMake também suporta gerações estática e dinâmica de biblioteca.
O nome "CMake" é uma abreviação de "cross plataform make", ou em
português make multiplataforma. Apesar do uso de "make" no nome,
CMake é um conjunto de aplicações de alto nível e separado do
sistema make, comum no desenvolvimento em Unix.

Atividade 02
Utilizando a documentação do CDI e o projeto realizado em sala,
apresente um roteiro para quando houver uma chamada a um método de
CRUD.

DAO para comunicação com o banco de dados

O próximo passo é criar uma classe DAO (Data Access Object) que
fará a comunicação com o banco de dados, realizando as operações
básicas (CRUD). Toda a chamada para da aplicação será feita para
nosso DAO que se responsabilizará pela comunicação com o banco de
dados.
Nosso DAO irá fazer CRUD com uma classe chamada Cliente, para isso
vejamos como mapear nossa classe Cliente com a Listagem 2.
package br.com.crudhibernate;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "cliente")
public class Cliente {

@Id
private int id;
@Column
private String nome;
@Column
private String cpf;
 @Column
private String rg;

public int getId() {

return id;
}
public void setId(int id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
public String getRg() {
return rg;
}
public void setRg(String rg) {
this.rg = rg;
}
}
Listagem 2. Classe Cliente, JPA Annotation
Além da criação padrão da classe Cliente que possui os
atributos id, nome, CPF e RG com os seus
respectivos getters e setters, temos também algumas anotações
definidas pelo JPA:
@Entity
@Table(name = "cliente")
public class Cliente {
A anotação @Entity faz com que o JPA saiba que aquela classe deve
ser manipulada por ele, e a anotação @Table define que esta classe
possui uma tabela chamada cliente no banco de dados.
O primeiro atributo “id” é uma chave primaria e precisamos
obrigatoriamente definir a anotação @Id para que o JPA não
apresente erros ao tentar inicializar a aplicação, as próximas
propriedades possuem a anotação @Column que descrevem que estas
propriedades possuem uma coluna correspondente no banco de dados.
Saiba mais: Como usar a anotação @Id no JPA
Você nem precisa ter criado a tabela cliente com estas colunas,
apenas precisa ter o banco de dados em execução. Quando a aplicação
for inicializada o próprio JPA irá se responsabilizar por criar
essa tabela com suas colunas caso ela não exista, isso porque
estamos usando o valor “update” para a
propriedade hibernate.hbm2ddl.auto.
Definida a nossa classe Cliente, podemos construir a classe DAO
responsável por fazer a comunicação com o banco de dados, como
mostra a Listagem 3.
package br.com.crudhibernate;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class ClienteJpaDAO {

private static ClienteJpaDAO instance;

protected EntityManager entityManager;

public static ClienteJpaDAO getInstance(){

if (instance == null){
instance = new ClienteJpaDAO();
 }

return instance;
}

private ClienteJpaDAO() {
entityManager = getEntityManager();
}

private EntityManager getEntityManager() {

EntityManagerFactory factory =
Persistence.createEntityManagerFactory("crudHibernatePU");
if (entityManager == null) {
entityManager = factory.createEntityManager();
}

return entityManager;
}

public Cliente getById(final int id) {

return entityManager.find(Cliente.class, id);
}

@SuppressWarnings("unchecked")
public List<Cliente> findAll() {
return entityManager.createQuery("FROM " +
Cliente.class.getName()).getResultList();
}

public void persist(Cliente cliente) {

try {
entityManager.getTransaction().begin();
 entityManager.persist(cliente);
entityManager.getTransaction().commit();
} catch (Exception ex) {
ex.printStackTrace();
entityManager.getTransaction().rollback();
}
}

public void merge(Cliente cliente) {

try {
entityManager.getTransaction().begin();
entityManager.merge(cliente);
entityManager.getTransaction().commit();
} catch (Exception ex) {
ex.printStackTrace();
entityManager.getTransaction().rollback();
}
}

public void remove(Cliente cliente) {

try {
entityManager.getTransaction().begin();
cliente = entityManager.find(Cliente.class,
cliente.getId());
entityManager.remove(cliente);
entityManager.getTransaction().commit();
} catch (Exception ex) {
ex.printStackTrace();
entityManager.getTransaction().rollback();
}
}
 public void removeById(final int id) {
try {
Cliente cliente = getById(id);
remove(cliente);
} catch (Exception ex) {
ex.printStackTrace();
}
}

}
Listagem 3. Classe DAO
Nossa classe ClienteJpaDAO segue o padrão de projeto Singleton que
garante que apenas uma instância dessa classe será criada durante
toda a aplicação. Ao realizar a criação da classe pela primeira vez
o método getEntityManager() é chamado, responsável por criar uma
instância de EntityManager.
A linha Persistence.createEntityManagerFactory(crudHibernatePU) usa
as configurações presentes no arquivo persistence.xml para criar
uma instância de EntityManagerFactory. Depois disso verificamos se
o atributo entityManager é nulo, ou seja, nunca foi criado, sendo
assim usamos o createEntityManager() para criar uma instância
de EntityManager que é responsável por realizar as operações
de CRUD no banco de dados.