Java é independente de plataforma, ambiente de programação multithreaded. É a base para a Web e os serviços de rede, aplicativos, desktops e independente de plataforma, robótica e outros dispositivos embarcados.
Versão do Java para desenvolvimento de aplicações Web e enterprise que rodam em servidor padronizados.
Ambiente de desenvolvimento
Esta IDE possui ferramentas para desenvolvimento Java para criar aplicações Java EE e aplicações Web, incluindo Java IDE, ferramentas para Java EE, JSF e outras. O Eclipse tem sua estrutura baseada em plug-ins.
Recursos e softwares para desenvolvimento:
- Eclipse Galileo IDE
- Java Development Kit (JDK) Versão 6 ou versão 5
- Componentes do Java Server Faces e RichFaces
- Plataforma Java EE 1.2 com Java EE 5* ou 1.1 com J2EE 1.4
- Servidor da aplicação Tomcat 6.0
- Hibernate 3.2.5 ga
- Banco de dados PostgreSQL 8.1-404 ou Mysql
Integrando o Apache Tomcat (Servidor de Aplicação) ao Eclipse.
Acesse o menu “Window”, “Preferences”. Na tela que se abre, clique em “Server” e depois em “Runtime Environments”.
Clique no botao "Add" e clique em next.Na outra janela a ser exibida clica na versao "tomcat v6.0 "
E em seguida clique no botao" Browse "e localize o diretorio do Apache tomcat e clique" Finish".
Para verificar a integração do tomcat com o Eclipse clique na aba "Server" como mostra a figura abaixo:
Um pouco de JSF (Java Server Faces) - Parte I
O Que é Java Server Faces?
O Java Server Faces é um framework MVC que provê componentes UI, mecanismos de ações, validadores e toda a estrutura necessária para que seja criada uma aplicação Web complexa.
Por que usar JavaServer Faces?
Possui uma poderosa arquitetura para o desenvolvimento de aplicações de grande porte com qualidade, e fornece recursos e componentes web 2 tornando assim possível a criação de mais produtos interativos.
Caracteristicas JSF:
- Incorpora caracteristicas de um framework MVC (separa entre a visualização e regras de negócio);
- Amplo Suporte a IDEs (utilizarei o Eclipse);
- Diversas bibliotecas de componentes de UI de terceiros.
- Componentes podem ser renderizados em diversas formas para vários tipos de clientes, como por exemplo para um browser da web, celular, etc.
Criando uma aplicação em três camadas (MVC)
O framework JavaServer Faces utiliza o padrão MVC o qual separa o sistema em três camadas (modelo, visualização e controle), onde o modelo representa os objetos de negócios, fornecer ao controlador o acesso aos dados e de manter o estado da aplicação.A visualização apresenta a interface do usuário, o qual define a forma de como os dados são apresentados e direciona as ações do usuário para o controlador.O controlador é responsável de ligar a camada de visualização a camada de modelo.
Em JavaServer Faces, o controle é realizado através de um Servelet chamado Faces Servlet por arquivos XML de configuração e por manipuladores de ações.O Faces Servlet que recebe as requisições do cliente, e redireciona para o modelo e envia uma resposta. Os arquivos de Configurações contem informações de mapeamentos e regras de navegação.
OBS: Mas a frente deste tutorial serão mostrados a estrutura e os códigos das classes de exemplo que seguem abaixo, em todas as classes deve-se incluir os pacotes corretos e adicionar os imports necessários. Observe a divisão do Projeto criado abaixo:
Estrutura do Projeto com o padrão MVC
Continuação...
As Camadas do Projeto
GUI (Visão)
Controller (Controle)
Modelo (persistência)
Dominio (modelo)
Bibliotecas JavaServer Faces
É necessário baixar e adicionar as bibliotecas do JSF que não vem no Tomcat, para garantir o funcionamento de sua aplicação, assegure-se de que todas as bibliotecas indispensáveis estejam localizadas no diretório lib/ da escrutura do arquivo.WAR, que são os jars JSF-api.jar, JSF-impl.jar, Jstl.jar .
Não esquecendo de adicionar as bibliotecas do Hibernate no diretorio WEB-INF/lib da aplicação, o hibernate3.jar, hibernate-annotations.jar e hibernate-commons-annotations.jar
Bibliotecas indispensáveis no projeto JSF usando Hibernate:
persistence-api.jar
hibernate.jar
hibernate-entitymanager.jar
hibernate-validator.jar
hibernate-annotations.jar
dom4j.jar
jta.jar
hibernate-commons-annotations.jar
cglib-2.1.3.jar
antlr.jar
jsf-api.jar
jsf-impl.jar
commons-logging-1.1.1.jar
commons-collections-3.2.1.jar
commons-beanutils-1.5.jar
log4j-1.2.11.jar
postgresql-8.1-404.jdbc3.jar
Para a conexão com Java
A conexão do PostgreSQL com Java é utilizada por diversos clientes de gerenciamento ou modelagem do PostgreSQL. Neste caso utiliza-se o driver JDBC do PostgreSQL. Baixar de acordo com sua versão do PostgreSQL aqui usei a versão do PostgreSql 8.1-404, o driver JDBC para o PostgreSQL daqui:
http://jdbc.postgresql.org/download.html#jdbcselection
Aqui para o PostgreSQL versão 8.1-404 baixei o arquivo 8.1-405 JDBC 3.
Obs: Adicionar o Jar do conector na pasta lib.
Depois de ter adicionado todos os jars, vejamos os passos a seguir:
Editando o arquivo de configuração do Hibernate
Quando Criamos um Projeto usando o Hibernate, é criado automaticamente o arquivo de configuração hibernate.cfg.xml na raiz do classpath do contexto da aplicação (na janela arquivos, WEB-INF/classes). Este aqrquivo contém informações sobre a conexão com o bancos de dados, os mapeamentos de recurso e outras propriedades da conexão.
È preciso editar as propriedades padrão especificadas em hibernate.cfg.xml para ativar o log de depuração para instruções SQL e para ativar o gerenciamento de contexto da sessão do Hibernate
Arquivo Hibernate.cfg.xml
- Abra hibernate.cfg.xml na aba Design e adicione as configurações a seguir :
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE hibernate-configuration (View Source for full doctype...)>
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
<property name="hibernate.connection.url">jdbc:postgresql://127.0.0.1:5432/academica?charSet=LATIN1</property>
<property name="hibernate.connection.username">postgres</property>
<property name="hibernate.connection.password">postgres</property>
<property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
<property name="current_session_context_class">thread</property>
<property name="hibernate.format_sql">true</property>
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<property name="show_sql">false</property>
<property name="hibernate.c3p0.min_size">5</property>
<property name="hibernate.c3p0.max_size">20</property>
<property name="hibernate.c3p0.timeout">180</property>
<property name="hibernate.c3p0.item_test_period">100</property>
// serão mapeadas as entidades//
<mapping class="academica.dominio.Usuario" />
</session-factory>
</hibernate-configuration>
Obs: Este arquivo hibernate.cfg.xml foi configurado para conexão com PostgreSQL, lembrando que pode ser o MYSQL ou qualquer outro banco de dados, basta configurá-los corretamente.
Criando Projeto em JavaServer Faces - Parte II
Para começar vai no menu "File" e em New escolhe “Dynamic Web Project” no menu da ferramenta.
Digite o nome do projeto e na seção “Configuration” selecione “JavaServer Faces v1.2 Project”. Pressione o botão “Next”.
Proseguindo clicando em "next", na janela de configurações da JSF. Em “JSF Libraries”, clique no icone ao lado da caixa de texto em "Manager libraries"
Clicando no botão "New" informe um nome para a biblioteca, como por exemplo, clique sobre o botão “Add...” e selecione os arquivos “jsf-api.jar” e “jsf-impl.jar”, que se encontram dentro do diretório “lib” distribuído no arquivo de instalação da Mojarra. Clique novamente em “Add...” e inclua o arquivo “jstl.jar”. Clique no botão “Ok”.
Seleciona o nome da biblioteca contendo os Jars e clique em "Finish"
Projeto depois de Criado na aba “Project Explorer”.:
Obs: Caso já adicionou os jars necessários do JSF na pasta Lib do seu projeto, nao é necessário seguir esses passos.
