Agendador de Tarefas Quartz Read More »
The post Agendador de Tarefas Quartz appeared first on Aprenda Java.
]]>Agendador de Tarefas Quartz
Olá Amigos,
Hoje faremos um agendador de Tarefas Quartz Framework. Um agendador de tarefas é um processo que será executado em uma determinada data e horário específico. Esse momento de execução pode ser cíclico, ou seja, há uma repetição (diária, semanal, mensal, anual) ou em intervalos menores como (segundos, minutos ou horas).
Utilizaremos a versão 2.2.
Para iniciar faça o download dos arquivos no site oficial. Esses são os arquivos necessário que você deve adicionar no class path da aplicação.
c3p0-0.9.1.1.jar log4j-1.2.16.jar quartz-2.2.1.jar quartz-jobs-2.2.1.jar slf4j-api-1.6.6.jar slf4j-log4j12-1.6.6.jar
No código abaixo criaremos a classe que conterá a regra de negócio que vai ser agendada para execução.
package br.com.feltex.quartz;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class AtualizaCadastroJOB implements Job {
//Aqui fica o código que será executado pelo agendamento.
// Caso ocorra um erro de execução uma exceção será lançada.
public void execute(JobExecutionContext context)
throws JobExecutionException {
System.out.println("Cadastro atualizado com sucesso!");
}
}
Em seguida criaremos a classe que dispara o JOB. Fiz comentário em cada linha para que fique bem claro o que está sendo feito.
package br.com.feltex.quartz;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
// Classe que dispara o JOB
public class AgendaTrigger {
public static void main(String[] args) {
try {
// Registrando a classe que execurá meus métodos de negócio
JobDetail job = JobBuilder.newJob(AtualizaCadastroJOB.class)
.withIdentity("nomeMeuJOB", "grupoCadastro").build();
// Criado um objeto de intervalo de repetição
// No nosso caso será de 2 segundos
SimpleScheduleBuilder intervalo = SimpleScheduleBuilder
.simpleSchedule().withIntervalInSeconds(2).repeatForever();
// Criado um disparador
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity("nomeDisparador", "grupoCadastro")
.withSchedule(intervalo).build();
// Finalmente é criado um objeto de agendamento
// que recebe o JOB e o disparador!
Scheduler scheduler = new StdSchedulerFactory().getScheduler();
scheduler.start();
scheduler.scheduleJob(job, trigger);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Pronto. Basta executar a classe “AgendaTrigger” que você verá a execução a cada 2 segundos.
Veja um exemplo de saída:
Cadastro atualizado com sucesso! Cadastro atualizado com sucesso! Cadastro atualizado com sucesso! Cadastro atualizado com sucesso! Cadastro atualizado com sucesso!
Links relacionados
Site oficial Quartz
Gostou do post? Agradeça o autor compartilhando nas redes sociais. Clique nos links abaixo:
The post Agendador de Tarefas Quartz appeared first on Aprenda Java.
]]>Criando XML em Java XStream Read More »
The post Criando XML em Java XStream appeared first on Aprenda Java.
]]>Criando XML em Java XStream
Olá Amigos,
Trabalhar com XML em Java pode ser uma tarefa bem fácil. Isso porque existem vários frameworks que nos auxiliam nessa atividade. Hoje mostraremos como usar o XStream .
Criação das classes
package br.com.feltex.webservice.xstream;
import java.util.Date;
public class Cliente {
private String nome;
private int codigo;
private String cpf;
private double salario;
private Date dataNascimento;
public Cliente(int codigo, String nome) {
this.codigo = codigo;
this.nome = nome;
}
public int getCodigo() {
return codigo;
}
public String getCpf() {
return cpf;
}
public Date getDataNascimento() {
return dataNascimento;
}
public String getNome() {
return nome;
}
public double getSalario() {
return salario;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
public void setDataNascimento(Date dataNascimento) {
this.dataNascimento = dataNascimento;
}
public void setNome(String nome) {
this.nome = nome;
}
public void setSalario(double salario) {
this.salario = salario;
}
@Override
public String toString() {
return "Cliente [nome=" + nome + ", codigo=" + codigo + ", cpf=" + cpf
+ ", salario=" + salario + ", dataNascimento=" + dataNascimento
+ "]";
}
}
Em seguida crie a classe XStreamParser que transformará o objeto Cliente em XML e transformará de xml para objeto.
package br.com.feltex.webservice.xstream;
import java.io.File;
import java.io.FileWriter;
import java.util.Date;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
public class XStreamParser {
public static void main(String arg[]) {
try {
// Criação do objeto
Cliente cli = new Cliente(1, "Maria da Silva");
cli.setDataNascimento(new Date());
cli.setSalario(223.09);
XStream xstream = new XStream(new DomDriver());
xstream.alias("cliente", Cliente.class);
String xml = xstream.toXML(cli);
// Saída do resultado
System.out.println(xml);
FileWriter fw = new FileWriter("meuCliente.xml");
fw.write(xml);
fw.close();
// Retorno de um XML para uma classe
Cliente novoCliente = (Cliente) xstream.fromXML(new File(
"meuCliente.xml"));
System.out.println(novoCliente);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Pronto. Agora você já sabe criar XML de forma simples e prática.
Conclusão:
Utilizar o xStream é uma ótima solução para manipulação de XML em Java. Aproveite esta poderosa ferramenta e construa suas exportações para XML de forma prática e simples.
Há também a possibilidade de construção de arquivos no formato JSON.
Links relacionados:
Acesse o site oficial do xStream clique aqui.
Gostou do post? Agradeça o autor compartilhando nas redes sociais. Clique nos links abaixo:
The post Criando XML em Java XStream appeared first on Aprenda Java.
]]>Exportando um projeto Web no Eclipse Read More »
The post Exportando um projeto Web no Eclipse appeared first on Aprenda Java.
]]>Hoje iremos aprender como realizar a exportação de um arqui projeto Java Web no Eclipse.
Exportando um projeto Web no Eclipse
Abra o seu eclipse e siga as etapas:
1. Selecione o projeto. Utilize o projeto “AcademicNetWeb”
2. Clique com o botão direito e selecione “Export >> WAR file”, conforme imagem abaixo:
3. Aparecerá a seguinte tela.
4. Em “Destination” aponte para uma pasta de sua escolha.
5. Selecione “Optimize for a specific server runtime” quando souber o tipo de servidor que rodará o projeto.
6. Selecione a opção “Export source files” para exporta os arquivos “.java” do projeto.
Atenção! Não esqueça de marcar esta opção para enviar o código fonte.
7. Se marcar a opção “Overwrite existing file” o Eclipse irá sobre-escrever o arquivo de destino com o mesmo nome.
8. Clique em “Finish”.
Agora você tem o seu projeto exportado. Parabéns!
“Vida que segue!”
Links relacionados
Como aprender Java
Tutorial da Oracle – WAR
The post Exportando um projeto Web no Eclipse appeared first on Aprenda Java.
]]>Criar DataSource para MySQL no NetBeans Read More »
The post Criar DataSource para MySQL no NetBeans appeared first on Aprenda Java.
]]>Criar DataSource para MySQL no NetBeans
Olá Amigos, hoje é dia da criar um DataSource no NetBeans. Assim a configuração de acesso a Banco de Dados, MySQL no exemplo, ficará fora da nossa aplicação.
Criar DataSource MySQL NetBeans
Para começar vamos criar o Data Source que é um componente de acesso a banco de dados.
1. Acesse a Aba “Serviços”, conforme imagem abaixo. (Caso a aba não esteja sendo exibida digite (Ctrl + 5))
2. Clique com o botão direito do mouse e selecione “nova conexão”. Aparecerá a seguinte tela:
3. Selecione o driver do MySQL. No campo “Driver” ele informará o caminho onde está disponível o driver.
4. Selecione próximo.
5. Nesta tela você deve preencher os dados de conexão com o banco. Lembre-se de criar o banco de dados através da interface de gerenciamento do Banco de Dados (MySQL Workbench)
6. Agora selecione Testar Conexão. O resultado deve ser “Conexão Bem-Sucedida”
7. Selecione Próximo.
8. A tela acima informa que há um esquema padrão de banco de dados selecionado. Selecione próximo.
9. Escreva o nome que será utilizado para o nosso dataSource “AcademicNetDS”
10. Então Finalize a operação.
11. Teremos o item de datasource “AcademicNetDS” conforme imagem abaixo.
12. Pronto Data Source criado.
Abraços e bons estudos.
Links relacionados
Aplicação de Exemplo NetBeans
Criando um primeiro Projeto Enterprise no Netbeans
Tutorial sobre DataSource
The post Criar DataSource para MySQL no NetBeans appeared first on Aprenda Java.
]]>Exemplo completo com JSF Primefaces + Hibernate + MySQL Read More »
The post Exemplo completo com JSF Primefaces + Hibernate + MySQL appeared first on Aprenda Java.
]]>Exemplo completo com JSF Primefaces + Hibernate + MySQL
Olá Amigos,
Hoje criaremos um projeto completo com as tecnologias java: JSF (Primefaces) + Hibernate + MySQL ou PostgreSQL.
E como de costume iniciaremos com uma breve descrição de cada uma delas.
Vamos utilizar o nosso sistema acadêmico chamado de AcademicNet para aplicar os conceitos.
Tecnologias utilizadas no exemplo
O exemplo funciona tanto com MySQL quanto com PostgreSQL
Nossa aplicação funcionará da seguinte maneira.
A página inicial é a index.jsp Ela faz a apresentação do projeto e quando clicamos na imagem será exibido o menu.jsp nesse menu podemos escolher várias opções de CRUD. A primeira é a mais importante para nós. “Manter Aluno JSF”.
Veja o código abaixo:
Menu de opções
Seja bem vindo ao sistema AcademicNet!
Manter Aluno JSF
Manter Aluno
Listar Alunos
Manter Professor
Listas Professor
Manter Usuario
Listar Usuario
Manter Turma
Listar Turma
Essa opção de menu nos levará até a página de cadastro utilizando JSF.
As primeiras linhas determinam que vamos utilizar JFS, com as URIs dentro da tag . A URI xmlns:p=”http://primefaces.org/ui” informa que utilizaremos o framework Primefaces.
Observe que para cada campo texto temos um atributo value apontando para uma propriedade da entidade aluno. Veja o exemplo de matrícula:
Lista de Alunos
No arquivo web.xml fazemos algumas configurações para que o nosso projeto esteja preparado para executar JSF. Essas configurações são opcionais para utilização do Framework Primefaces.
AcademicNetWebEJB
index.jsp
javax.faces.PROJECT_STAGE
Development
Faces Servlet
javax.faces.webapp.FacesServlet
1
Faces Servlet
*.jsf
*.faces
*.xhtml
Veja o código do nosso “alunoMB”. A novidade aqui é a anotação @ManagedBean. Isso determina que nossa classe é um tipo especial e que pode ser associada a uma
tela. Neste caso este Managed Bean está associado à tela de aluno. Ela tem os métodos necessários para incluir, alterar, consultar, excluir e listar alunos.
package br.com.feltex.academicnet.mb;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.context.FacesContext;
import br.com.feltex.academicnet.dao.AlunoDAO;
import br.com.feltex.academicnet.dao.DAOFactory;
import br.com.feltex.academicnet.entidade.Aluno;
@ManagedBean(name = "alunoMB")
public class AlunoMB implements Serializable {
private static final long serialVersionUID = 8103328274400432976L;
private Aluno aluno;
private List lista = new ArrayList<>();
AlunoDAO dao = DAOFactory.getAlunoDAO();
public AlunoMB() {
aluno = new Aluno();
listar();
}
public void alterar() {
System.out.println("Alterar aluno");
dao.alterar(aluno);
listar();
FacesContext.getCurrentInstance().addMessage(
null,
new FacesMessage(FacesMessage.SEVERITY_INFO,
"Manutenção de usuário: ",
"Usuario alterado com sucesso!"));
}
public void consultar() {
long matriculaConsulta = aluno.getMatricula();
System.out.println("Consultar");
aluno = dao.consultar(aluno);
if (aluno == null || aluno.getMatricula() == 0) {
FacesContext.getCurrentInstance().addMessage(
null,
new FacesMessage(FacesMessage.SEVERITY_ERROR,
"Manutenção de usuário: ",
"Usuario não encontrado matrícula:" + matriculaConsulta + "!"));
}
listar();
}
public void excluir() {
System.out.println("Excluir aluno");
dao.excluir(aluno);
listar();
FacesContext.getCurrentInstance().addMessage(
null,
new FacesMessage(FacesMessage.SEVERITY_INFO,
"Manutenção de usuário: ",
"Usuario excluído com sucesso!"));
}
public Aluno getAluno() {
return aluno;
}
public List getLista() {
return lista;
}
public void incluir() {
System.out.println("Incluir aluno");
dao.inserir(aluno);
listar();
FacesContext.getCurrentInstance().addMessage(
null,
new FacesMessage(FacesMessage.SEVERITY_INFO,
"Manutenção de usuário: ",
"Usuario incluido com sucesso!"));
}
public void limpar() {
System.out.println("Limpar");
System.out.println(aluno);
aluno = new Aluno();
}
public void listar() {
System.out.println("Listar aluno");
lista = dao.listar();
}
public void setAluno(Aluno aluno) {
this.aluno = aluno;
}
public void setLista(List lista) {
this.lista = lista;
}
}
Depois compare esse managedBean com o servlet “AlunoServlet”.
O nosso ManagedBean utilizar um padrão de projeto DAOFactory, ou seja, existe uma classe que gera uma instância de um objeto que acessa o Banco de dados.
AlunoDAO dao = DAOFactory.getAlunoDAO();
Código abaixo:
package br.com.feltex.academicnet.dao;
import br.com.feltex.academicnet.dao.hibernate.AlunoHibernateDAO;
import br.com.feltex.academicnet.dao.jdbc.ProfessorDAO;
import br.com.feltex.academicnet.dao.jdbc.ProfessorJDBCDAO;
import br.com.feltex.academicnet.dao.jdbc.TurmaDAO;
import br.com.feltex.academicnet.dao.jdbc.TurmaJDBCDAO;
import br.com.feltex.academicnet.dao.jdbc.UsuarioJDCBDAO;
public class DAOFactory {
public static AlunoDAO getAlunoDAO() {
return new AlunoHibernateDAO();
}
public static ProfessorDAO getProfessorDAO() {
return new ProfessorJDBCDAO();
}
public static TurmaDAO getTurmaDAO() {
return new TurmaJDBCDAO();
}
public static UsuarioDAO getUsuarioDAO() {
return new UsuarioJDCBDAO();
}
}
Por exemplo o método “getAlunoDAO” nos retorna um objeto que acessa o banco de dados via Hibernate e o método getProfessorDAO retorna um acesso ao mesmo Banco de Dados via JDBC. Você pode pensar, mas quando isso seria útil de verdade?
Imagine um sistema que temos Sistema de PDV (Ponto de Vendas). Meu sistema deve estar preparado para acessar qualquer banco de dados. Para isso o meu DAOFactory pode nos atender gerando objetos diferentes de acordo com parâmetros que eu informar.
Minha classe “AlunoHibernateDAO” implementa a interface “AlunoDAO” que define a assinatura de todos os métodos necessários para acesso a banco de dados para a tabela aluno. Neste exemplo todo o controle de transação é gerenciado por nossa aplicação. É o chamado Bean Transation Management.
package br.com.feltex.academicnet.dao.hibernate;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import br.com.feltex.academicnet.dao.AlunoDAO;
import br.com.feltex.academicnet.entidade.Aluno;
import br.com.feltex.hibernate.util.HibernateUtil;
public class AlunoHibernateDAO implements AlunoDAO {
private Session session;
public void alterar(Aluno p) {
try {
session = HibernateUtil.getSession();
session.beginTransaction();
session.update(p);
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
e.printStackTrace();
} finally {
session.close();
}
}
public Aluno consultar(Aluno aluno) {
Aluno retorno = new Aluno();
try {
session = HibernateUtil.getSession();
session.beginTransaction();
retorno = (Aluno) session.get(Aluno.class, aluno.getMatricula());
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
e.printStackTrace();
} finally {
session.close();
}
return retorno;
}
public void excluir(Aluno p) {
try {
session = HibernateUtil.getSession();
session.beginTransaction();
session.delete(p);
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
e.printStackTrace();
} finally {
session.close();
}
}
public boolean existe(Aluno aluno) {
Aluno a = consultar(aluno);
return (a.getMatricula() != null);
}
public void inserir(Aluno p) {
try {
session = HibernateUtil.getSession();
session.beginTransaction();
session.save(p);
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
e.printStackTrace();
} finally {
session.close();
}
}
@SuppressWarnings("unchecked")
public List listar() {
List lista = new ArrayList();
try {
session = HibernateUtil.getSession();
session.beginTransaction();
lista = (List) session.createCriteria(Aluno.class).list();
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
e.printStackTrace();
} finally {
session.close();
}
return lista;
}
@SuppressWarnings("unchecked")
public List listar(Aluno aluno) {
Criteria c = session.createCriteria(Aluno.class);
if (aluno.getNome().length() > 0) {
c.add(Restrictions.like("nome", aluno.getNome() + "%"));
}
c.addOrder(Order.asc("nome"));
return (List) c.list();
}
}
O arquivo de configuração hibernate.cfg.xml. É nele que informação os dados de configuração de acesso ao banco de dados. Servidor, Porta, Nome do Banco, usuário e senha são as informações básicas para acesso do nosso Banco.
hibernate.dialect => Define qual o "dialeto" será utilizado no banco de dados. Neste caso o dialeto para MySQL. Veja no final deste artigo o link para o catálogo de dialects
hibernate.show_sql => Define se os comandos SQL gerados pelo Hibernate devem ser mostrados. (true ou false)
hibernate.format_sql => Define se os comando SQL terão quebra de linha a parte significativa do script
hibernate.jdbc.batch_size => Define a gravação de dados em lote.
hibernate.hbm2ddl.auto => Possíveis valores e ações
validate: validar o esquema, não faz alterações para o banco de dados.
update: atualizar o esquema.
create: cria o esquema, destruindo dados anteriores.
create-drop: remover o esquema no final da sessão.
No final a tag
ATENÇÃO> Não esqueça de adicionar a annotation @Entity a todas classes que foram informadas nas tags mapping
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/bdacademicnet
root
teco01
org.hibernate.dialect.MySQLDialect
true
true
20
update
DICA: Existem 2 arquivos extras de configuração do Hibernate. Esses arquivos
Caso você queria ver exemplos de configuração para PostgreSQL(hibernate.postgresql.cfg.xml) ou MySQL(hibernate.mysql.cfg.xml).
Servem como apoio para alterações do arquivo: hibernate.cfg.xml
Deixei disponível o projeto completo com o código fonte para auxiliar a todos no processo de aprendizado. Para baixar: Clique aqui
Conclusão
Este artigo mostra como fazer um CRUD simples com utilização do JSF utilizando o framework Primefaces junto com MySQL e Hibernate. Este mesmo exemplo funciona com JSP, JDBC e Servlet. Assim o leitor poderá fazer comparações de como funcionam essas tecnologias.
Links relacionados
Recomendo que leia: Como gerenciar a transação JPA com Hibernate via Filtro em projeto Web
Leia também: Exemplo completo com JSF Primefaces + EJB + Hibernate + MySQL + JMS (Topic)
Você irá gostar:Bean Transaction Management
Hibernate Manual
Hibernate Dialects
Abraços e bons estudos.
Não se esqueça de curtir este post nas redes sociais. Dê a sua contribuição social e ajude o autor:
The post Exemplo completo com JSF Primefaces + Hibernate + MySQL appeared first on Aprenda Java.
]]>Exemplo completo com JSP JSTL Servlet JDBC PostGreSQL Read More »
The post Exemplo completo com JSP JSTL Servlet JDBC PostGreSQL appeared first on Aprenda Java.
]]>Hoje criaremos um projeto completo com as tecnologias java: JSP + JSTL + Servlet + JDBC + PostgreSQL.
Claro que iniciaremos com uma breve descrição de cada uma delas.
Tecnologias utilizadas no exemplo
1. Introdução
Este exemplo começa uma página inicial index.jsp que exibe as informações de funcionamento do projeto. Ao clicar na imagem principal é exibido o menu.jsp.
Esta página tem a opção de listagem de alunos ou realizar a manutenção (Inclusão, alteração, consulta ou exclusão de um Aluno). Se escolhermos a opção de cadastro será exibida a tela de manutenção.
Veja os campos disponíveis.
img 1 – Visão macro do nosso projeto
Para maior facilidade as classes e páginas também foram comentadas para auxiliar no entendimento e estudo do código.
Você deverá ter conhecimento prévio de Aplicação Web Java e utilização do Tomcat.
Caso ainda não tenha, acesse os links informados no final deste artigo.
2 . Criação da tabela no banco de dados
Script de criação da tabela no Banco de dados:
CREATE TABLE IF NOT EXISTS tbaluno(
matricula bigint NOT NULL,
nome character varying(255),
telefone character varying(255),
email character varying(255),
datacadastro date,
CONSTRAINT tbaluno_pkey PRIMARY KEY (matricula)
);
É criado o comando que gera a tabela caso ela ainda não exista.
3 . Construção do projeto
Para começar vamos construir a estrutura do nosso projeto. Ao final deste tutorial o seu projeto deve estar como mostrado na imagem abaixo:
Nela temos o nome do projeto (AcademicNetWeb)
Abaixo os nós mais importantes são:
-> Java Resources (src) (Aqui teremos os códigos fontes arquivos .java)
-> WebContent (Aqui ficam os arquivos web JSPs, imagens, JavaScript).
Para criar o projeto, no Eclipse, acesse o menu File >> Other…>> Na tela que aparece escolha Web >> Dynamic Web Project.
Dê o nome de “AcademicNetWeb” … Next >> Next … Na última tela Selecione a opição “Generate web.xml deployment descriptor”. >> Finish
Para saber mais sobre criação de projeto web no Eclipse Clique Aqui
Vamos criar a classe de entidade Aluno. O conteúdo deve ser o seguinte:
package br.com.feltex.entidade;
import java.io.Serializable;
import java.util.Date;
/**
*
* Classe de entidade que possui os atributos do aluno
*
*/
public class Aluno implements Serializable {
private static final long serialVersionUID = -309513637403441918L;
private Long matricula;
private String nome;
private String telefone;
private String email;
private Date dataCadastro;
public Aluno() {}
public Aluno(Long matricula) {
super();
this.matricula = matricula;
}
public Aluno(Long matricula, String nome) {
super();
this.matricula = matricula;
this.nome = nome;
}
public Date getDataCadastro() {
return dataCadastro;
}
public String getEmail() {
return email;
}
public Long getMatricula() {
return matricula;
}
public String getNome() {
return nome;
}
public String getTelefone() {
return telefone;
}
public void setDataCadastro(Date dataCadastro) {
this.dataCadastro = dataCadastro;
}
public void setEmail(String email) {
this.email = email;
}
public void setMatricula(Long matricula) {
this.matricula = matricula;
}
public void setNome(String nome) {
this.nome = nome;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
@Override
public String toString() {
return "Aluno [matricula=" + matricula + ", nome=" + nome
+ ", telefone=" + telefone + ", email=" + email
+ ", dataCadastro=" + dataCadastro + "]";
}
}
A Classe DAO é a classe que utilizamos para conectar como Banco de Dados PostgreSQL.
package br.com.feltex.dao;
import java.sql.Connection;
import java.sql.DriverManager;
/**
* Classe responsável pela Conexão com o Banco de dados. É utilizada por outras
* classes de persistência de dados.
*
*/
public class DAO {
public Connection getConexao() {
Connection conexao = null;
String usuario = "postgres";
String senha = "teco01";
String nomeBancoDados = "bdacademicnet";
try {
Class.forName("org.postgresql.Driver");
conexao = DriverManager.getConnection("jdbc:postgresql://localhost:5432/" + nomeBancoDados,
usuario, senha);
} catch (Exception e) {
e.printStackTrace();
}
return conexao;
}
}
A classe AlunoDAO é responsável por realizar todas as operações com Banco de dados.
Nela encontramos os métodos de persistência (
alterar – alteração de um registro no banco de dados
excluir – exclui um registro no banco de dados
existe – Verifica a existência de uma matrícula informada no banco de dados
inserir – incluirá os dados de um aluno no banco de dados
listar – retorna todos os registros existentes no banco de dados
consultar – retorna um registro identificado com a matrícula informada
)
package br.com.feltex.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import br.com.feltex.entidade.Aluno;
/**
*
* Classe de Persistência de dados dos objetos de Aluno
* é "filha" da Classe DAO.
*
*/
public class AlunoDAO extends DAO {
public void alterar(Aluno aluno) {
try {
Connection conexao = getConexao();
PreparedStatement pstmt = conexao
.prepareStatement("Update tbaluno SET nome = ?, telefone = ?, email = ?, datacadastro = ?"
+ " WHERE matricula = ? ");
pstmt.setString(1, aluno.getNome());
pstmt.setString(2, aluno.getTelefone());
pstmt.setString(3, aluno.getEmail());
pstmt.setDate(4, new java.sql.Date(aluno.getDataCadastro().getTime()));
pstmt.setLong(5, aluno.getMatricula());
pstmt.execute();
pstmt.close();
conexao.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public void excluir(Aluno aluno) {
try {
Connection conexao = getConexao();
PreparedStatement pstm = conexao
.prepareStatement("Delete from tbaluno where matricula = ? ");
pstm.setLong(1, aluno.getMatricula());
pstm.execute();
pstm.close();
conexao.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public boolean existe(Aluno aluno) {
boolean achou = false;
try {
Connection conexao = getConexao();
PreparedStatement pstm = conexao
.prepareStatement("Select * from tbaluno where matricula = ?");
pstm.setLong(1, aluno.getMatricula());
ResultSet rs = pstm.executeQuery();
if (rs.next()) {
achou = true;
}
pstm.close();
conexao.close();
} catch (Exception e) {
e.printStackTrace();
}
return achou;
}
public void inserir(Aluno aluno) {
try {
Connection conexao = getConexao();
PreparedStatement pstm = conexao
.prepareStatement("Insert into tbaluno (matricula, nome, telefone, email, datacadastro) values (?,?,?,?,?)");
pstm.setLong(1, aluno.getMatricula());
pstm.setString(2, aluno.getNome());
pstm.setString(3, aluno.getTelefone());
pstm.setString(4, aluno.getEmail());
pstm.setDate(5, new java.sql.Date(aluno.getDataCadastro()
.getTime()));
pstm.execute();
pstm.close();
conexao.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public List listar() {
List lista = new ArrayList<>();
try {
Connection conexao = getConexao();
Statement stm = conexao.createStatement();
ResultSet rs = stm.executeQuery("Select * from tbaluno");
while (rs.next()) {
Aluno aluno = new Aluno();
aluno.setMatricula(rs.getLong("matricula"));
aluno.setNome(rs.getString("nome"));
aluno.setTelefone(rs.getString("telefone"));
aluno.setEmail(rs.getString("email"));
aluno.setDataCadastro(new java.util.Date(rs.getDate("datacadastro").getTime()));
lista.add(aluno);
}
stm.close();
conexao.close();
} catch (Exception e) {
e.printStackTrace();
}
return lista;
}
public Aluno consultar(Aluno aluno) {
try {
Connection conexao = getConexao();
PreparedStatement pstm = conexao
.prepareStatement("Select * from tbaluno where matricula = ?");
pstm.setLong(1, aluno.getMatricula());
ResultSet rs = pstm.executeQuery();
if (rs.next()) {
aluno.setMatricula(rs.getLong("matricula"));
aluno.setNome(rs.getString("nome"));
aluno.setTelefone(rs.getString("telefone"));
aluno.setEmail(rs.getString("email"));
aluno.setDataCadastro(new java.util.Date(rs.getDate("datacadastro").getTime()));
}
pstm.close();
conexao.close();
} catch (Exception e) {
e.printStackTrace();
}
return aluno;
}
}
AlunoServlet a principal classe do nosso projeto. Ela é a controladora da navegação. Todas as requisições de acesso ao banco de dados, controle de navegação, leitura de dados da tela ou envio para o destino de erro ou sucesso é responsabilidade desta classe. Seguindo o padrão MVC ela é o Contoller.
package br.com.feltex.servlet;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import br.com.feltex.dao.AlunoDAO;
import br.com.feltex.entidade.Aluno;
@WebServlet("/AlunoServlet")
public class AlunoServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
doPost(request, response);
}
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
String acao = request.getParameter("acao");
String destino = "sucesso.jsp";
String mensagem = "";
List lista = new ArrayList<>();
Aluno aluno = new Aluno();
AlunoDAO dao = new AlunoDAO();
try {
//Se a ação for DIFERENTE de Listar são lidos os dados da tela
if (!acao.equalsIgnoreCase("Listar")) {
aluno.setMatricula(Long.parseLong(request.getParameter("matricula")));
aluno.setNome(request.getParameter("nome"));
aluno.setTelefone(request.getParameter("telefone"));
aluno.setEmail(request.getParameter("email"));
//Faz a leitura da data de cadastro. Caso ocorra um erro de formatação
// o sistema utilizará a data atual
try {
DateFormat df = new SimpleDateFormat("dd/MM/yyyy");
aluno.setDataCadastro(df.parse(request.getParameter("dataCadastro")));
} catch (Exception e) {
aluno.setDataCadastro(new Date());
}
}
if (acao.equalsIgnoreCase("Incluir")) {
// Verifica se a matrícula informada já existe no Banco de Dados
// Se existir enviar uma mensagem senão faz a inclusão
if (dao.existe(aluno)) {
mensagem = "Matrícula informada já existe!";
} else {
dao.inserir(aluno);
}
} else if (acao.equalsIgnoreCase("Alterar")) {
dao.alterar(aluno);
} else if (acao.equalsIgnoreCase("Excluir")) {
dao.excluir(aluno);
} else if (acao.equalsIgnoreCase("Consultar")) {
request.setAttribute("aluno", aluno);
aluno = dao.consultar(aluno);
destino = "aluno.jsp";
}
} catch (Exception e) {
mensagem += e.getMessage();
destino = "erro.jsp";
e.printStackTrace();
}
// Se a mensagem estiver vazia significa que houve sucesso!
// Senão será exibida a tela de erro do sistema.
if (mensagem.length() == 0) {
mensagem = "Aluno Cadastrado com sucesso!";
} else {
destino = "erro.jsp";
}
// Lista todos os registros existente no Banco de Dados
lista = dao.listar();
request.setAttribute("listaAluno", lista);
request.setAttribute("mensagem", mensagem);
//O sistema é direcionado para a página
//sucesso.jsp Se tudo ocorreu bem
//erro.jsp se houver algum problema.
RequestDispatcher rd = request.getRequestDispatcher(destino);
rd.forward(request, response);
}
}
4. Criação das páginas
index.jsp Página inicial do nosso projeto. Utilizamos aqui conteúdo HTML5 puro. Uma página simples, sem conteúdo dinâmico e que possui os links para o menu da aplicação quando clicamos na imagem.
Página Inicial
Seja bem vindo ao sistema AcademicNet!
Nesta versão utilizaremos as tecnologias: JSP + JSTL + Servlet + JDBC + PostGreSQL.
http://www.feltex.com.br
menu.jsp Página que conterá as opções de cadastros no nosso sistema. Também uma página simples, sem conteúdo dinâmico e que possui os links para o menu da aplicação quando clicamos nos links. O primeiro chamará a página aluno.jsp. O Segundo chamará o Servlet AlunoServlet com a opção de listar todos os usuários cadastrados no Banco de Dados.
Página Inicial
aluno.jsp Página que contém código dinâmico. Quando encontramos a marcação “${…}” significa que é um conteúdo que deve ser recebido pela página e que será exibido. Nos campos de texto recebemos os dados de aluno, veja o exemplo: value=”${aluno.nome}” que recebe o campo nome do aluno.
Nesta página utilizamos HTML5. Então podemos ver no campo matrícula a palavra required. Isso informa que este campo é obrigatório. Não será possível enviar os dados ao servidor sem o preenchimento dele.
Na linha abaixo definimos que o método de envio dos dados para o servidor será “post” e o destino no servidor será a nossa Classe Servlet: “AlunoServlet”
Alô Mundo Java Web – Eclipse Read More »
The post Alô Mundo Java Web – Eclipse appeared first on Aprenda Java.
]]>
1. Eclipse Keppler
2. Apache Tomcat – 7
Abra o seu Eclipse e vamos seguir o passo a passo a seguir:
1. (Ctrl + N) ou Menu File => New => Other => Dynamic Web Project
Em seguida preencha os campos:
Observe as configurações existentes.
Target Runtime = Servidor de aplicação que será utilizado
(Caso você não tenha um servidor instalado veja o capítulo “Instalação e configuração do TOMCAT”)
Dynamic web module version = Versão utilizada para especificação da Servlet/jsp.
Configutação associa ao projeto as configurações do servidor informado.
EAR membership = Caso queira associar o projeto a um projeto corporativo.
Selecione next
Configuração onde serão criadas as classes.
ContextRoot é o nome que será chamada a sua aplicação.
Ex. http://localhost:8080/ControleFinanceiro
Content directory = onde serão criadas as páginas.
Caso você marque a opção “Generate web.xml deployment descriptor” será criado um arquivo onde serão adicionadas algumas configurações da aplicação como Servlet, Filter, Página Inicial padrão, controle de erros entre outras. Este arquivo é muito importante para configuração de frameworks como Struts, JSF, Spring
Deixe esta opção marcada.
Selecione Finish.
O resultado esperado é a seguinte tela:
Pronto. Projeto Criado.
Vamos criar nossa página principal. Chamada “index.jsp”.
Selecione o projeto, clique com o botão direito New => JSP File
Apenas digite o nome do arquivo e selecione “Finish”
No arquivo index.jsp que foi aberto escreve uma mensagem conforme a imagem abaixo.
Vamos executar o projeto com a saudação inicial.
Selecione sua página index.jsp com o botão direito Run As” => “Run on Server”
Marque a opção “Always use this server when running this project” isso fará que o Eclipse sempre utilize esse mesmo servidor nas próximas execuções.
O resultado deve ser algo como a tela abaixo:
***Dica: Para visualizar o resultado no Browser padrão selecione “Windows => Web Browser” Você pode escolher o Browser padrão na opção “Default system web Browser” ou outro da lista.
Execute novamente o projeto e sua aplicação será aberta em outro Browser.
Muito bem. Projeto criado e agora é hora de iniciar a construção dos elementos básicos do projeto. Vamos agora criar um Servlet. Que é, de forma resumida, uma classe Java que recebe e responde a requisições HTTP
Mãos à obra: Clique com o botão direito no projeto.
*Alternativamente você pode digitar Ctrl + N. Em seguida digite Servlet.
Será aberta a seguinte tela:
Simples. Selecione Next.
Preencha os campos como a tela abaixo, conforme a imagem:
Selecione Next.
Caso seja necessário passar parâmetro de inicialização adicione através do botão Add.
O campos “description” pode ficar vazio, pois representa uma informação sobre a o parâmetro.
Selecione Next. Nesta tela deixe marcada as opções de “doGet” e “doPost” conforme imagem abaixo.
Agora selecione “Finish”. Então sua classe Servlet será criada.
No método “doGet” adicione o seguinte código:
doPost(request, response);Isso fará com que toda requisição recebida via HTTP GET seja repassada para o método doPost que processará os dados.
No doPost adicione o seguinte código:
PrintWriter out = response.getWriter(); out.print("Mensagem do Dia!");Não esqueça de salvar as alterações. “Ctrl + S”
Pronto! Código finalizado. Vamos rodar!
Selecione o seu servlet. Clique com o o botão Direito e selecione “Run As => Run on Server”
Você verá o seguinte resultado:
Amigos por hoje é só. E vida que segue!
Links relacionados
The post Alô Mundo Java Web – Eclipse appeared first on Aprenda Java.
]]>
