Configurando WildFly Eclipse Keppler

Ambiente a ser configurado:

1. Servidor WildFly
2. Eclipse Keppler

Tarefas:

Configurando o Eclipse

Acesse o menu Help >> Eclipse Marketing. Na tela que aparecerá digite “JBOSS Tools”.
Selecione “JBoss Tools (Keppler) 4.1.2.Final”

Selecione apenas a opção “JBossAS Tools”:

Aceite o termo de uso:

Aguarde o download e instalação. Ao final o eclipse irá solicitar para reiniciar. Reinicie o Eclipse.

Vá até a Aba Server que fica no canto inferior do Eclipse.

Se a aba Server não estiver aparecendo no seu eclipse:
 Acesse Window >> Show View >> Outher... Digite "Servers". Selecione a opção "Servers" e selecione OK.

Clique com o botão direito: new >> Server >>
Digite Wildfly na caixa “Select the server type”

Pronto. Agora o WildFly está configurado no seu Eclipse! Configurando WildFly Eclipse Keppler será mais simples trabalhar com aplicações corporativas JEE.

Links Relacionados

Gostou do post? Agradeça o autor compartilhando nas redes sociais. Clique nos links abaixo:

The post Configurando o WildFly no Eclipse Keppler appeared first on Aprenda Java.

Hoje finalizaremos a inclusão de Fila JMS no AcademicNet. Agora vamos incluir uma fila topic.
Se você não leu o artigo anterior acesse aqui. Nele são feitas as configurações iniciais.

Veja como será o exemplo:

Tarefas:

– Criação de componentes 3 MDBs para consumir as filas
– Criação do Servlet que enviará uma mensagem para a fila

Criação dos consumidores MDB (Message Drive Bean)

Nesta parte criaremos 3 MDBs que consumirão a fila de Professores. Para cada mensagem incluída na Fila do tipo TOPIC todos os MDBs que estão configurando para consumir a fila receberão a mesma mensagem.

package br.com.feltex.academicnet.mdb;

import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.TextMessage;

import br.com.feltex.academicnet.entidade.Professor;

/**
 * Message-Driven Bean implementation class for: ProfessorMDB
 */
@MessageDriven(activationConfig = {
		@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
		@ActivationConfigProperty(propertyName = "destination", propertyValue = "java:/topic/professorTopic") }, mappedName = "java:/topic/professorTopic")
public class ProfessorTopicMDB1 implements MessageListener {

	public ProfessorTopicMDB1() {

	}

	public void onMessage(Message message) {
		System.out.println(getClass() + " Inicio");
		try {

			if (message instanceof TextMessage) {
				TextMessage mensagem = (TextMessage) message;
				System.out.println("Mensagem recebida: " + mensagem.getText());
			} else if (message instanceof ObjectMessage) {
				try {
					ObjectMessage obj = (ObjectMessage) message;
					Professor professor = (Professor) obj.getObject();
					System.out.println("Objeto Recebido: " + professor);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(getClass() + " Fim");
	}
}

package br.com.feltex.academicnet.mdb;

import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.TextMessage;

import br.com.feltex.academicnet.entidade.Professor;

/**
 * Message-Driven Bean implementation class for: ProfessorMDB
 */
@MessageDriven(activationConfig = {
		@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
		@ActivationConfigProperty(propertyName = "destination", propertyValue = "java:/topic/professorTopic") }, mappedName = "java:/topic/professorTopic")
public class ProfessorTopicMDB2 implements MessageListener {

	public ProfessorTopicMDB2() {

	}

	public void onMessage(Message message) {
		System.out.println(getClass() + " Inicio");
		try {

			if (message instanceof TextMessage) {
				TextMessage mensagem = (TextMessage) message;
				System.out.println("Mensagem recebida: " + mensagem.getText());
			} else if (message instanceof ObjectMessage) {
				try {
					ObjectMessage obj = (ObjectMessage) message;
					Professor professor = (Professor) obj.getObject();
					System.out.println("Objeto Recebido: " + professor);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(getClass() + " Fim");
	}
}

package br.com.feltex.academicnet.mdb;

import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.TextMessage;

import br.com.feltex.academicnet.entidade.Professor;

/**
 * Message-Driven Bean implementation class for: ProfessorMDB
 */
@MessageDriven(activationConfig = {
		@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
		@ActivationConfigProperty(propertyName = "destination", propertyValue = "java:/topic/professorTopic") }, mappedName = "java:/topic/professorTopic")
public class ProfessorTopicMDB3 implements MessageListener {

	public ProfessorTopicMDB3() {

	}

	public void onMessage(Message message) {
		System.out.println(getClass() + " Inicio");
		try {

			if (message instanceof TextMessage) {
				TextMessage mensagem = (TextMessage) message;
				System.out.println("Mensagem recebida: " + mensagem.getText());
			} else if (message instanceof ObjectMessage) {
				try {
					ObjectMessage obj = (ObjectMessage) message;
					Professor professor = (Professor) obj.getObject();
					System.out.println("Objeto Recebido: " + professor);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(getClass() + " Fim");
	}
}

Observe que o código dos nossos MDBs são iguais. Todos recebem um objeto professor e exibem os dados. Podemos determinar que cada um deles execute uma atividade diferente. Imagine que definimos 3 tarefas diferentes com a mensagem recebida:
enviar e-mail,
gravar em um Banco de Dados
chamar um serviço externo passando o objeto Professor
Esta situação seria atendida pelo nosso exemplo, pois a mesma mensagem gravada na fila

Agora vamos criar o Servlet que irá gravar a mensagem na fila. Esta mensagem conterá um objeto Professor.

package br.com.feltex.academicnet.servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.annotation.Resource;
import javax.inject.Inject;
import javax.jms.JMSConnectionFactory;
import javax.jms.JMSContext;
import javax.jms.JMSException;
import javax.jms.ObjectMessage;
import javax.jms.Topic;
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.academicnet.entidade.Professor;

@WebServlet("/ProfessorServletJMS2")
public class ProfessorServletJMS2 extends HttpServlet {
	private static final long serialVersionUID = 1L;

	@Resource(mappedName = "java:/topic/professorTopic")
	private Topic topic;

	@Inject
	@JMSConnectionFactory("java:/ConnectionFactory")
	private JMSContext context;

	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		doPost(request, response);
	}

	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		System.out.println(getClass() + "Inicio........");
		Professor professor = new Professor();
		professor.setMatricula(2221L);
		professor.setNome("Maria da Silva");
		enviarObjetoForma1(professor);
		System.out.println(getClass() + "Fim........");

		PrintWriter out = response.getWriter();
		out.print("
Objeto enviado com sucesso! JMS TOPIC 2.0
");
	}

	/**
	 * Envia um objeto complexo para a fila JMS
	 * 
	 * 
	 */
	public void enviarObjetoForma1(Professor professor) {
		try {
			ObjectMessage objMessage = context.createObjectMessage();
			objMessage.setObject(professor);
			context.createProducer().send(topic, objMessage);

		} catch (JMSException ex) {
			ex.printStackTrace();
		}
	}
}

Execução do projeto
Rode o projeto completo. Acesse o menu principal e escolha as opções de envio JMS
“Envio de Mensagem JMS 2.0 (Topic) – Professor”

Links relacionados

The post Exemplo completo com JSF Primefaces + EJB + Hibernate + MySQL + JMS (Topic) appeared first on Aprenda Java.

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

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.

	

	
 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.

 





	

		
Seja bem vindo ao sistema AcademicNet!
		Manter Aluno

		Listar Alunos

	

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”

O Atributo “autofocus” no campo nome determina que este campo receberá o cursor assim que a página for carregada no seu browser.
O atributo “placeholder” é o valor que será exibido nos campos quando eles estiverem vazios. Isso serve para informar ao usuário um valor possível a ser utilizado.

As linhas

Informam que temos um botão “submit” que envia os dados ao servidor e também um botão “reset” que limpa os valores exibidos nos campos do formulário.

	

		
			

				
Cadastro de Alunos
				Matrícula: 
 
				Name:

					
				 Telefone:

				 Email:
	
				Data Cadastro:
 Ação 
					Incluir
					Alterar
					Excluir
					Consultar
				
   

			
		
	

alunoLista.jsp É uma página dinâmica que utilizamos vários recursos de JSTL. Nas primeiras linhas são declaradas as tags que serão utilizadas. Isso é feito com as marcações
“@ taglib” para cada linha dessa há um “prefix” que será utilizado como abreviação no uso da TagLib.

A tag a seguir realiza um loop. Neste caso é lido o atributo “listaAluno” que foi enviado do AlunoServlet e será realizado um loop adicionando cada elemento a variável “aluno”.

Já na linha ““ utilizamos TagLib para realizar a formatação de data no padrão dia/mês/ano (10/10/2014).

<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>






	

		
Lista de Alunos
		
				

			

				
Matricula
				
Nome
				
Telefone
				
Data Cadastro
				
Comandos
			
			

					
${aluno.matricula}
					
${aluno.nome}
					
${aluno.telefone}
					
  
					
Excluir
				
			
		
		
   		Existem ${fn:length(listaAluno)} alunos!
 		
 		
	
	Voltar
	

sucesso.jsp Esta página é exibida quando há uma atualização bem sucedida no banco de dados. É feito o uso de JSTL aqui.
Temos o uso do que é usado para exibir o atributo mensagem que recebido do AlunoServlet. Na linh “”
é realizado um include dinâmico da página de lista de alunos. Isso significa que será exibida a listagem de alunos ao carregar esta página.

 
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>





Mensagem JSTL:	
	



  

A página erro.jsp é responsável por receber a variável “mensagem” e exibi-la. Esta página é mostrada sempre que há um problema de atualização de dados dos no Banco de dados.

Verifique o erro: ${mensagem}

Voltar

Por fim temos o nosso arquivo web.xml que é bem simples para o nosso projeto. Ele apenas define qual será a página inicial da nossa aplicação. Atualmente é index.jsp. Caso você queira uma página diferente, por exemplo, a de login. basta alterar a linha “index.jsp” para menu.jsp

	
		index.jsp
	

Observe que temos também, nas pasta WEB-INF\lib os arquivos:
jstl.jar e standard.jar (Contém as tags que precisamos para uso de JSTL)
postgresql-9.3-1100.jdbc4.jar (Driver para realizar a conexão como Banco de dados PostgreSQL)

Esses arquivos são necessário para que o nosso projeto funcione.

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 é um projeto simples que explica os conceitos necessários para construção de um aplicativo completo para Java Web.
Ele pode ser utilizado em qualquer Servidor Web (JBoss, Tomcat, Websphere, Weblogic), pois não há nenhuma configuração específica para uma implementação de servidor.
Para utilizar este projeto com outros bancos de Dados (MySQL, SQL Server, Oracle, DB2) basta alterar a forma de conexão na classe “DAO”.

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
Java Web
JDBC

Projetos Completos em Java – aprenda na prática

Exemplo completo com JSF Primefaces + EJB + Hibernate + MySQL + JMS

Exemplo completo com JSF Primefaces + EJB + Hibernate + MySQL + JMS (Topic)

Abraços e bons estudos.

Não esqueça de curtir este post nas rede sociais. Dê a sua contribuição social e ajude o autor:

The post Exemplo completo com JSP JSTL Servlet JDBC PostGreSQL appeared first on Aprenda Java.

Lançamento do Servidor WildFly

Olá amigos como vão? Queremos anunciar o lançamento oficial do Servidor de aplicação WildFly que substituirá o consolidado e famoso JBOSS. Como não podia deixar de ser ele é “Java EE7 Certified”, ou seja, um servidor que segue o requisidos da especificação Java EE7. Diferente da última versão estável do JBOSS7 que é JEE 6 certified.

Bem, vamos ao que interessa. O WildFly traz muitas melhorias de performance, trabalhando de uma forma mais robusta com Servlet comuns e assíncronos, web sockets. O controle de
delegação de requisições aos WebServers também foi melhorado. Isso desonera as aplicações. Outra ponto muito importante são as melhorias de segurança! Afinal
Segurança e canja de galinha não faz mal a niguém!

– Há apenas 2 portas para gerenciar o servidor. Isso aumenta a compatibildiade com a plataforma Cloud Computing – OpenShift da JBoss.

– O controle de acesse por papéis também sofreu mudanças significativas facilitando a integração com LDAP e geranção de cache das estrageias de roles.

– Novo Log de auditoria do servidor.

– Suporta a configuração de segurança tanto no arquivo padrão da espefificação JEE quando no arquivo jboss-permissions.xml (Um arquivo espefífico do servidor, aqueles que não devemos utilizar quando
desejamos que nossa aplicação seja portável entre vários servidores – que é o caso de Sistema de prateleira). Lembre-se sempre: Java Write Once Run Everywhere!

Logging – É possível definir formatadores personalizados que complementem o formatador padrão.
JCA & Datasources – Java Cryptography Architecture agora suporte lazy connection manager.
Clustering – Esta parte foi completamente refatorada. Esse é o caminho natural para possibilitar a utilização do OpenShift. Uma das mudanças muito importantes
é a implemantação de cache distribuído de um Statefull EJB. (Lembre-se esse é o EJB que guarda estado)

Patching – Permite inclusão e alteração de módulo remotamente via um novo protocolo de gerenciamento

Minimalistic “Core” Distribution – Implemantação ao pé da letra da especificação. Neste ponto eles garante fazer tudo e mais um pouco
do que foi especificado.
Cria uma camada para hot deploy – Quando desejamos atualizar apenas partes do nosso sistema, uma página XHTML, por exemplo.
Class Loader Modular – Controlar o carregamento de classes por aplicação

Improved JDK8 Compatibility
Web Services
REST – Novidades no uso de JSON, pois contém várias APIS (Web Encryption, Jackson, Yaml, JSON-P, and Jettison)
Hibernate Search – Agora é integrada ao servidor. Ótima alternativa para buscas textuais.

Foram corrigidos 211 problemas

Atualização de Módulos
Podemos destacar:
– Implementações em JPA aumentando a performance suporte a OpenJPA e EclipseLInk
– Hibernate 4.3.1.Final
– Jackson 1.9.13
– Log4j JBoss LogManager 1.1.0.Final
– Mojarras 2.2.5-jbossorg-3

Já estou fazendo alguns testes por aqui. Se estiver estável mesmo nas próximas aulas já teremos novidades utilizando o WildFly!

O link oficial do lançamento é:
– http://wildfly.org/news/2014/02/11/WildFly8-Final-Released/

Amigos por hoje é só. E vida que segue!

The post Lançamento do Servidor WildFly appeared first on Aprenda Java.