Frameworks e Componentes Java

Hoje em dia, há muitas opções de ferramentas e componentes, para facilitar o desenvolvimento em Java e outras linguagens também, mas o foco aqui será Java. O mercado de Frameworks e Componente Java é imenso. Há muitas opções boas disponíveis no mercado, das quais é importante entender para estudarmos e aplicarmos em nosso dia a dia. Vou começar falando dos Frameworks e Componente mais usados em Java e listar o restante para conhecimento.

Frameworks Web

• Spring MVC, é também  um dos frameworks Java mais conhecido e utilizado. Esse framework implementa um grande número de funções, como injeção de dependência, persistência de dados e uma implementação para o padrão MVC para a criação de aplicações WEB. É uma implementação que usa o modelo MVC (Model-View-Controller) para aplicações java com internet. Model View Controller ou Modelo-Visão-Controlador(MVC) é um padrão de arquitetura de aplicações que visa separar a lógica da aplicação (Model), da interface do usuário (View) e do fluxo da aplicação (Controller). Permite que a mesma lógica de negócios possa ser acessada e visualizada por várias interfaces.

• Struts, foi um dos frameworks mais usados em ambientes corporativos para construção de aplicações web, em especial por causa de sua versão 1.x. A versão 2.0 não tem tanta força mas é um dos mais importantes. Struts Framework é um projeto open source mantido pela Apache Software Foundation.  O nome Struts deve-se ao papel por ele desenvolvido nas aplicações WEB. Da mesma forma que a construção de uma casa, ponte, prédio necessitam de uma base mantenedora, os engenheiros de software usam o Struts para suportar cada camada de uma aplicação comercial. O Struts também é uma implementação que usar o modelo MVC.
• VRaptor, criado na USP em 2004 e mantido hoje pela Caelum e por uma grande comunidade, não tem o tamanho do mercado de outros grandes frameworks. Mas tem a vantagem da extrema simplicidade e grande produtividade, além de ser bem focado no mercado brasileiro, com documentação em português e muito material disponível. Ele também é um framework MVC para web focado no desenvolvimento ágil. Através da inversão de controle e injeção de dependências, ele diminui drasticamente o tempo de trabalho que seria perdido com o código repetitivo: validações, conversões, direcionamentos, ajax e lookups.

• JavaServer Faces, um dos frameworks mais usados hoje. Seu grande apelo é ser o framework oficial do Java EE para Web, enquanto que todos os outros são de terceiros. Em especial, o JSF é dito um framework component-based, enquanto que Struts (1 e 2) e VRaptor são ditos request-based ou action-based. A ideia principal de um framework de componentes é abstrair muitos dos conceitos da Web e do protocolo HTTP provendo uma forma de programação mais parecida com programação para Desktop. O JSF tem componentes visuais ricos já prontos, funciona através de tratamento de eventos e é stateful (ao contrário da Web "normal" onde tudo é stateless).

Provedores de JSF

• Mojorra – http://javaserverfaces.java.net/
• MyFaces – http://myfaces.apache.org/
• ADF – http://www.oracle.com/technetwork/developer-tools/adf/overview/index.htmlde persistência

Componentes JSF

• RichFaces – http://www.jboss.org/richfaces
• PrimeFaces – http://primefaces.org/
• OpenFaces – http://openfaces.org/
• IceFaces – http://www.icesoft.org/
• EasyFaces – http://www.easyfaces.com.br
• Gmaps4jsf – http://code.google.com/p/gmaps4jsf/

Frameworks de Persistência

• Hibernate, é o framework mais usado em relação a persistência e bancos de dados, se a variedade dos frameworks Web é grande, aqui não temos esse problema. O Hibernate é praticamente unanimidade no mercado Java, principalmente se usado como implementação da JPA. Há outras possibilidades, como o Toplink, o EclipseLink, o OpenJPA, o DataNucleus, o JDO, o iBatis etc. Mas o Hibernate é o mais importante. E dificilmente você vai usar outro Framework que não seja o Hibernate no mercado de trabalho, por isso só vou falar dele, e dar uma descrição mais detalhada.
  O que o hibernate realmente faz?Basicamente o  hibernate realiza o mapeamento do objeto relacional, ou seja, as tabelas do seu banco de dados são representadas através de classes na sua aplicação e as operações de recuperação e persistência dos dados são realizadas através de métodos do hibernate, sendo assim, o programador não precisa de se preocupar com instruções SQL como selects, join e etc, sendo o framework capaz até de resolver as peculiaridades que cada SGDB impõe.
  Qual motivo de utilizar o hibernate e não minhas instruções sql diretamente no banco ?Possível migrar para a maioria dos Banco de Dados disponíveis no mercado apenas modificando o arquivo de configuração do framework, sem necessidade de alterar uma linha de código do sua aplicação.
  Totalmente orientado a objetos.O hibernate executa as instruções sql para recuperar apenas as informações necessárias, evitando executar consultas complexas apenas para obter um determinado dado. Detecta automaticamente qualquer alteração ou inclusão das classes mapeadas e executa as alterações devidas no banco de dados. Realiza cache das operações, aumentando a performance do seu software. E o mais importante, é 100% software livre.  
• Spring Data – http://www.springsource.org/
• iBatis – http://www.mybatis.org/
• Torque – http://db.apache.org/torque/
• Castor – http://www.castor.org/
• Cayenne – http://cayenne.apache.org/

Container IoC

• Spring – http://www.springsource.org/
• Guice – http://picocontainer.codehaus.org/
• PicoContainer – http://code.google.com/p/google-guice/
• EJB – http://www.oracle.com/technetwork/java/javaee/ejb/index.html
• CDI – http://www.oracle.com/technetwork/articles/java/cdi-javaee-bien-225152.html

Validação

• Commons Validator – http://commons.apache.org/validator/
• Java Bean Validator – http://docs.oracle.com/javaee/6/tutorial/doc/gircz.html

Autenticação e autorização web

• Spring Security – http://www.springsource.org/
• JGuard – http://jguard.xwiki.com/xwiki/bin/view/Main/WebHome
• JEE Container Managed Security (Configuração especifica para cada provedor de container JEE). Veja o Tomcat – http://tomcat.apache.org/tomcat-7.0-doc/realm-howto.html

JEE web container standalone

• Tomcat – http://tomcat.apache.org/
• Jetty – http://jetty.codehaus.org/jetty/
• JBoss – http://www.jboss.org/

Manipulaçao de arquivos MS Office

• Apache POI – http://poi.apache.org . Eu já falei um pouco aqui sobre o Apache POI e fiz até um exemplo de como gerar um Excel com Apache POI e Java
• JExcelApi – http://jexcelapi.sourceforge.net
• Docx4j – http://dev.plutext.org/trac/docx4j
• Java Docx – http://www.javadocx.com

Web Services SOAP

• Metro – http://jax-ws.java.net/
• Axis – http://axis.apache.org/axis/
• XFire – http://xfire.codehaus.org/
• CXF – http://cxf.apache.org/

JavaScript

• DOJO Toolkit – http://dojotoolkit.org/
• JQuery – http://jquery.com/
• Ext-JS – http://docs.sencha.com/ext-js/4-0/
• DWR – http://directwebremoting.org/dwr/index.html

Integração com redes sociais

• Spring Social – http://www.springsource.org/

Cache

• Space4J – http://www.space4j.org/
• Memcache – http://memcached.org/
• Ecache – http://ehcache.org/
• Prevayler – http://prevayler.org/
• JBoss Infinispan – http://www.jboss.org/infinispan.html

NoSQL

• MongoDB – http://www.mongodb.org/
• Neo4j – http://neo4j.org/
• Db4o – http://www.db4o.com/
• MemcachedDB – http://memcachedb.org/
• CouchDB – http://couchdb.apache.org/
• Project Voldemort – http://project-voldemort.com/
• MarkLkogic Server – http://www.marklogic.com/
• BaseX – http://basex.org/
• SimpleDB – http://aws.amazon.com/simpledb/
• HBase – http://hbase.apache.org/
• Casandra – http://cassandra.apache.org/
• Hypertable – http://hypertable.org/
• OrientBD – http://www.orientechnologies.com/

SGDB Java embutidos

• HyperSQL – http://hsqldb.org/
• JavaDB – http://www.oracle.com/technetwork/java/javadb/overview/index.html
• Apache Derby – http://db.apache.org/derby/
• H2Database – http://www.h2database.com

Testes

• DBUnit – http://www.dbunit.org/
• JUnit – http://www.junit.org/
• EJBUnit – http://ejb3unit.sourceforge.net/
• JSFUnit – http://www.jboss.org/jsfunit/

Loggin

• jse – http://docs.oracle.com/javase/7/docs/api/java/util/logging/package-summary.html
• Log4J – http://logging.apache.org/index.html

Testes cargas e perfomance

• JMeter – http://jmeter.apache.org/
• WebLoad – http://www.webload.org/

JSON

• JSON – http://www.json.org/java/
• XStream – http://xstream.codehaus.org/json-tutorial.html
• Google-JSON – http://code.google.com/p/google-gson/

Boletos bancário

• Boletos Bancário – http://www.boletobancario.com.br
• Bopepo – http://www.jrimum.org/bopepo/
• Stella – http://github.com/caelum/caelum-stella/wiki/Gerando-boleto

Gerais

• Maven – Gerenciador de dependências, do qual já falei sobre aqui: O que é o Maven,  Projeto Mavem e em outras postagem, vocês podem conferir nos posts anteriores. – http://maven.apache.org/

Ciclo de vida de uma requisição JSF

O ciclo de vida de uma requisição JSF compreende um conjunto de etapas realizadas pelo Framework para a criação/restauração e exibição das páginas ao usuário. Essas etapas são responsáveis por capturar os dados enviados pela UI, verificar a validade dos mesmos, aplicar esses dados às regras de negócio e exibir o resultado do processamento. Assim, o entendimento deste ciclo é de extrema importância para o desenvolvedor que precisa lidar com este Framework. A Figura abaixo representa as etapas de uma requisição JSF.

Baseando-se no fluxo mostrado, podemos descrever as ações realizadas em cada fase da seguinte maneira:

• RESTORE_VIEW (Criar ou Restaurar a view): é a primeira fase do JSF e visa criar ou restaurar (no caso de uma página já requisitada) a árvore de componentes de uma página. Caso seja a primeira requisição à página, o framework cria uma nova árvore de componentes e associa a ela e caso não seja a primeira requisição, o framework restaura a árvore de componente já existente.
• APPLY_REQUEST_VALUES (Aplica valores do usuário): nesta fase são atribuídos os valores que foram enviados na requisição para seus respectivos componentes da árvore de componentes. Como os dados coletados no formulário HTML são transferidos na requisição como String, o JSF também armazena essas informações na árvore de componentes como String;
• PROCESS_VALIDATIONS (Certifica que os valores estão corretos): depois de completada a fase anterior, é iniciada a fase de processar conversões e validações como, por exemplo, validar uma formatação de uma data ou até mesmo verificar se determinado campo está sendo informado. Assim, caso ocorra algum erro, as informações são armazenadas no FacesContext e o fluxo é direcionado para a fase Renderiza a view para construir a resposta. Caso contrário, o fluxo segue para a próxima fase.
• UPDATE_MODEL_VALUES (Atualiza o modelo com valores válidos): se tudo ocorreu bem na fase anterior, o JSF já tem certeza que pode atualizar os valores dos atributos do bean gerenciado com os valores contidos na árvore de componentes através da utilização dos métodos get e set;

• INVOKE_APPLICATION (Busca uma nova view se necessário): depois de passar por todas as fases anteriores, é nesta fase que serão tratados as ações e os eventos da lógica de negócio da aplicação. É aqui que o desenvolvedor vai determinar o que será feito com o que foi aplicado ao modelo. Assim, podemos determinar nesta fase qual será a próxima página que será exibida para o usuário;
• RENDER_RESPONSE (Renderiza a view): finalmente o ciclo de vida chega ao fim. Nesta fase será feita a codificação da árvore de componentes, transformando-a em HTML (+ CSS e JS) e exibindo-a no navegador do cliente.

O que é o JavaServer Faces ?

O JSF é um Framework MVC para sistemas web baseado em componentes que auxilia bastante a construção de aplicações desse tipo com a tecnologia Java. Esses componentes são colocados em formulários de páginas e ligados a objetos Java de forma a prover suporte a várias características presentes no Framework, tais como: mecanismos de manipulação de eventos, validações de informações enviadas pelos clientes, navegação entre páginas, entre outras. Assim, com essa tecnologia torna-se mais fácil a construção de interfaces com o usuário pelo fato de o desenvolvedor poder implementar as aplicações simplesmente utilizando componentes visuais reusáveis.

Devido à existência destes componentes na interface, toda página JSF é um documento XML com namespaces, recurso utilizado para importar e possibilitar o uso de componentes HTML do JSF. Alguns exemplos de namespaces são: xmlns:h, xmlns:f e xmlns:ui.

A partir da declaração destes os componentes são utilizados na interface com o usuário e ligados a objetos Java – conhecidos como JavaBeans – através da utilização da tag <h:form/> e dos métodos get e set das classes. Dessa forma, os componentes de UI que serão vinculados às propriedades de um JavaBean devem, necessariamente, fazer parte de um formulário JSF, pois é através dele que o JSF envia e recebe dados do servidor. A seguir é apresentada a declaração da tag <h:form/>:

   <h:form id="form1">
       <!-- componentes JSF de interface com o usuário devem ser colocados aqui -->
  </h:form> 

No lado do servidor, cada JavaBean que tenha atributo vinculado a alguma página deve possuir a anotação @ManagedBean sobre o nome da classe, para que seja gerenciado pelo framework JSF e permita a ligação entre as regras de negócio da aplicação e a camada de visualização. Essa anotação possui ainda um atributo chamado name, não obrigatório, que representa o nome dado ao bean gerenciado. Ademais, para definir o ciclo de vida de cada um dos beans conforme a necessidade do projeto, é possível especificar o seu escopo fazendo uso de uma das anotações analisadas a seguir:

@ApplicationScoped: especifica que existirá somente uma instância da classe em toda a aplicação, ou seja, todos os usuários terão acesso à mesma instância;

@SessionScoped: garante a existência de uma instância para cada usuário que utiliza a aplicação;

@ViewScoped: relaciona a instância do bean gerenciado à página. Assim, enquanto essa página estiver sendo manipulada pelo usuário, o bean estará disponível;

@RequestScoped: garante que existirá uma instância pelo tempo de duração da requisição feita pelo usuário;

@NoneScoped: cada vez que houver uma chamada a uma propriedade ou método da classe bean, será criada uma nova instância. Neste caso a instância não terá ligação com qualquer escopo da aplicação;

@CustomScoped: essa anotação permite a criação de escopos personalizados. Para isso, a instância de uma classe bean é armazenada em uma interface do tipo java.util.Map <K,V> e disponibilizada para uma página ou um conjunto de páginas da aplicação.

O que é o Spring Framework?

O Spring é um framework open source para a plataforma Java criado por Rod Johnson e descrito em seu livro "Expert One-on-One: JEE Design e Development". Trata-se de um framework não intrusivo, baseado nos padrões de projeto Inversão de controle (IoC) e injeção de dependência.

No Spring o container se encarrega de "instanciar" classes de uma aplicação Java e definir as dependências entre elas através de um arquivo de configuração em formato XML, inferências do framework, o que é chamado de auto-wiring ou ainda anotações nas classes, métodos e propriedades. Dessa forma o Spring permite o baixo acoplamento entre classes de uma aplicação orientada a objetos.

O Spring possui uma arquitetura baseada em interfaces e POJOs (Plain Old Java Objects), oferecendo aos POJOs características como mecanismos de segurança e controle de transações. Também facilita testes unitários e surge como uma alternativa à complexidade existente no uso de EJBs. Com Spring, pode-se ter um alto desempenho da aplicacao.

Esse framework oferece diversos módulos que podem ser utilizados de acordo com as necessidades do projeto, como módulos voltados para desenvolvimento Web, persistência, acesso remoto e programação orientada a aspectos.

O que é o Bootstrap? Primeiros Passos

Bootstrap é um framework front-end que facilita a vida dos desenvolvedores web a criar sites com tecnologia mobile (responsivo). Além disso, o Bootstrap possui uma diversidade de componentes (plugins) em JavaScript (jQuery) que auxiliam o designer a implementar: tootlip, menu-dropdown, modal, carousel, slideshow, entre outros sem a menor dificuldade, apenas acrescentando algumas configurações no código, sem a necessidade de criar scripts e mais scripts.

Características:

• Possui uma interface super amigável e moderna;
• Atualmente possui uma grande diversidade de templates;
• Grande quantidade de plugins adaptados ou desenvolvidos para o framework;
• Sistema responsivo;
• Um dos frameworks mais utilizados no desenvolvimento de portais e sistemas do mundo;
• Guia de aplicação;
• Download facilitado e totalmente FREE!

Primeiros Passos com Bootstrap:

1. Faça o download do framework no site do desenvolvedor getbootstrap.com
2. Após realizar o download, você terá os seguintes arquivos:
   
   

   bootstrap/
     ├── css/
     │   ├── bootstrap.css
     │   ├── bootstrap.min.css
     ├── js/
     │   ├── bootstrap.js
     │   ├── bootstrap.min.js
     └── img/
         ├── glyphicons-halflings.png
         └── glyphicons-halflings-white.png

3. Adicione os arquivos  nas respectivas pastas do seu projeto.
4. Chame o CSS e o JS dentro da tag <head> do seu HTML
   

   	<html> <head> <title>Bootstrap - Primeiros Passos</title>
   	<!-- Incluindo o CSS do Bootstrap -->
   	<link href="css/bootstrap.min.css" rel="stylesheet" media="screen">
   	</head>

Ao usar o bootstrap.js é necessário como requisito o famoso e poderoso jQuery, lembre-se de incluí-lo antes do Bootstrap

	<body> ...
	<!-- Incluindo o jQuery que é requisito do JavaScript do Bootstrap -->
	<script src="http://code.jquery.com/jquery-latest.js"></script>
	<!-- Incluindo o JavaScript do Bootstrap -->
	<script src="js/bootstrap.min.js"></script>
	</body>
	</html>

E pronto!

Não existe um arquivo executável, pois ele é somente um emaranhado de códigos que são aplicados ao seu projeto através da chamada no html.

O Bootstrap não é nada mais do que esses arquivos. Lembrando que para ambiente de desenvolvimento o melhor é incluir no seu HTML os arquivos identados: bootstrap.css e bootstrap.js, entretanto em ambiente de produção o indicado são os arquivos com o final .min pois são comprimidos e economizam muitos bytes o que melhora o carregamento das páginas HTML (principalmente em conexões 3G). Os arquivos no diretório img/ são os icones padrões do Bootstrap e são incluídos pelo arquivo css.

Código Fonte: Bootstrap Examples.


Crie uma página de login com: Modais do Bootstrap  

Melissa Lobo.

Criando um projeto Web no Eclipse com Maven

1° Passo: New > Other >

 Maven > Maven Project > Next

Em seguida ignore o archetype, (Archetype: Template do projeto, geralmente utilizado em empresas para criar um Template padrão) > Next :

2° Passo - Configurando o Projeto: 

Grupo Id: Geralmente colocamos o nome do nosso domínio, pois o Grupo Id precisa ser único, se é um projeto pessoal coloque o nome do domínio de trás para frente (esse é o padrão usado), por exemplo: br.com.loboMarinho

Artifact Id: Nome do Projeto, no meu caso:  ProjetoMaven

Version: Versão usada (geralmente a ultima). SNAPSHOT é um padrão usado, que significa que ainda estamos trabalhando nessa versão.

Packaging: war, é o tipo de empacotamento que será utilizado, no nosso caso será um WAR, arquivo Web. 

Campos preenchidos > Next

Ao criar o primeiro projeto, o Maven vai baixar todos os seus Plugins, levando alguns segundo/minutos para abrir o projeto.

Estrutura do Projeto Maven:

O padrão do Maven, já cria uma estrutura de pastas, onde organizaremos o nosso projeto, separando ele por classes, testes, arquivos web, etc.

src/main/java: É onde iremos criar as nossas classes

src/main/resources: É onde se encontra os arquivos de propriedades, recursos, etc.

src/test/java: Classes para testes

src/test/resources: Arquivos de teste

src > main > webapp: É onde fica os arquivos Web, como o CSS, HTML, imagens, JavaScript, etc.

Target: É onde é gerado os códigos compilados:

3° Passo: Criando um JSP para verificar se o programa está okay.

• Dentro do webapp, clique no botão direito: New > Other > JSP FILE > Next 
• Nomeie o jsp como: index.jsp > Finish

No arquivo criado, coloque um "Meu primeiro projeto Maven", ou qualquer coisa inicialmente somente para teste.

Salve feche, e antes de rodar o tomcat, vamos dar uma olhada no arquivo pom.xml. Abra e clique em pom.xml :

O pom.xml é o nosso arquivo de configuração do nosso projeto, é nele onde vamos definir as dependências (Framework, ferramentas, banco de dados) que vamos utilizar em nosso projeto.
Em seguida falarei mais sobre ele. Agora que já conhecemos todo o modelo do projeto Maven, podemos rodar o nosso projeto.

Adicionando o Tomcat:

Clique em Servers > e no link mostrado >

Adicione o Tomcat > Finish

Clique no projeto e arraste ele para dentro do Tomcat:

Clique no botão de play no canto direito da tela do Eclipse:

O Tomcat vai rodar, e o seu projeto ficara disponível na porta local: localhost:8080/NomeDoProjeto, no nosso caso localhost:8080/ProjetoMaven

obs: Como o padrão inicial é o index você não precisa digitar na url, mas não tem problema digitar também, vai funcionar dos dois jeitos, paginas com outros nomes, é preciso chamar na url. 

Pronto! Primeiro projeto Maven criado, em seguida é só trabalhar no mesmo, seguindo os padrões sitados e as orientações que darei futuramente nos próximos post, como por exemplo sobre as dependências do projeto e como importá-las de maneira fácil e pratica no Maven.

Melissa Lobo.

Frameworks para Injeção de Dependência

Segue opções de frameworks para Injeção de Dependência:

Spring – http://www.springsource.org/
Guice – http://code.google.com/p/google-guice/
PicoContainer – http://picocontainer.codehaus.org/
MetaContainer – http://www.seducaotecnologica.com.br/mentacontainer-ioc-simples-rapido/
EJB – www.oracle.com/technetwork/java/javaee/ejb/index.html
CDI – http://www.oracle.com/technetwork/articles/java/cdi-javaee-bien-225152.html

Provedores de CDI
Spring – http://www.springsource.org/
Weld – http://www.seamframework.org/Weld/Downloads
OpenWebBeans – http://openwebbeans.apache.org/

Buttons - Bootstrap

Foi um bom ano, aprendi muitas coisas novas, e compartilhei parte desse conhecimento aqui. Pude ajudar e conhecer algumas pessoas. Mudei alguns conceitos, o emprego, a vida. E aos poucos venho me tornando a tal da Desenvolvedora. Agradeço a todos os leitores pelo apoio dicas, e pelas duvidas que me motivaram muito a escrever, ajudar e estudar ainda mais. Espero ter ajudado de alguma forma algum leitor ou futuro desenvolvedor. Aos poucos o Blog vai avançando, os assuntos e o nível de sabedoria também. Espero que em 2015 possamos aprender ainda mais. Que haja mais dicas, duvidas, sugestões e novos posts com novos temas. Pra finalizar segue abaixo uma dica que encontrei e  venho aqui compartilhar com vocês. Que venha 2015!

Pra quem constrói Sites e não quer perder tempo com alguns detalhes, segue opções de botões, baseado em CSS puro e utilizando o Framework de css mais famoso do mundo, o bootstrap, bem bonitinhos e fofinhos, rápidos e fáceis de se utilizar. 

Download

Melissa Lobo.

O que é o Dojo?

Dojo é um Framework JavaScript open source, uma coleção gratuita de funções e Widgets de cross-browser compatível, lançado pela primeira vez em 2006. Cada arquivo JavaScript é um objeto com vários atributos e funções, referido como um módulo Dojo. Por exemplo, dijit.form.TextBox é um módulo Dojo que converte um tag HTML de entrada para uma caixa de texto Dojo de estilo. Os módulos podem também estender outros módulos Dojo, então dijit.form.ValidationTextBox e dijit.form.NumberTextBox tanto estender dijit.form.TextBox . Isto permite aos desenvolvedores adicionar funcionalidade, criando suas próprias extensões sem a necessidade de modificar os arquivos pré-instalados. Um dos pontos fortes destes módulos Dojo é que eles são projetados especificamente para apoiar os desenvolvedores a lidar com requisitos de acessibilidade.

Melissa Lobo.

Soluções Web

Hoje vou disponibilizar para vocês uma lista com opções de framework para o desenvolvimento de soluções web:

• Click – http://click.apache.org/
• Wicket – http://wicket.apache.org/
• Spring MVC – http://www.springsource.org/
• Struts – http://struts.apache.org/
• Mentawai – http://www.mentaframework.org/
• JSF – www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html
• VRaptor – http://vraptor.caelum.com.br/
• Playframework – http://www.playframework.com

RIA*

• GWT – https://developers.google.com/web-toolkit/
• Vaadin – https://vaadin.com/home 
• ZK Framework – http://www.zkoss.org/

Full Stack Gerador

• Grails – http://grails.org/
• JRuby On Rails – http://jruby.org/
• OpenXava – http://www.openxava.org/ 
• Portifolio – http://www.manydesigns.com/en/portofino
• AgilePlataform – http://www.outsystems.com/agile-platform/

*RIA - Rich Internet Application: São Aplicações Web que tem características e funcionalidades de softwares tradicionais do tipo Desktop. RIA típicos transferem todo o processamento da interface para o navegador da internet, porém mantém a maior parte dos dados (como por exemplo, o estado do programa, dados do banco) no servidor de aplicação.

Melissa Lobo.

O que é JPA?

O JPA nada mais é do que um conjunto de especificações (muitos textos, normas e interfaces do Java) de como uma implementação deve se comportar. Existem diversas implementações no mercado que seguem as especificações do JPA. Podemos citar o Hibernate, OpenJPA, EclipseLink e o “recente” Batoo.
As implementações tem a liberdade de adicionar anotações e códigos a mais que desejarem, mas tem que implementar o básico que o JPA requeira.
O que o JPA nos propõem, é que seja possível trabalhar diretamente com as classes e não ter que utilizar as consultas nativas de cada banco de dados; o JPA irá fazer esse trabalho pelo desenvolvedor.

Hibernate e JPA

O Hibernate é uma ferramenta ORM open source e é a líder de mercado, sendo a inspiração para a especificação Java Persistence API (JPA). O Hibernate nasceu sem JPA mas hoje em dia é comum acessar o Hibernate pela especificação JPA. Como toda especificação, ela deve possuir implementações. Entre as implementações mais comuns, podemos citar: Hibernate da JBoss, EclipseLink da Eclipse Foundation e o OpenJPA da Apache. Apesar do Hibernate ter originado a JPA, o EclipseLink é a implementação referencial.

O Hibernate abstrai o seu código SQL, toda a camada JDBC e o SQL será gerado em tempo de execução. Mais que isso, ele vai gerar o SQL que serve para um determinado banco de dados, já que cada banco fala um "dialeto" diferente dessa linguagem. Assim há também a possibilidade de trocar de banco de dados sem ter de alterar código Java, já que isso fica de responsabilidade da ferramenta.