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.