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/

CascadeType.

O CascadeType é uma maneira de definir a forma como serão propagadas as operações em cascata de uma Entity para suas referencias. A vantagem do Cascade é a propagação automaticamente da ação configurada nos relacionamentos da entidade.

As definições do Cascade são passadas dentro das anotações @OneToOne, @OneToMany e @ManyToMany, e as possibilidades de valores para o Cascade podem ser encontradas dentro de um enum javax.persistence.CascadeType.

Tipos:

• CascadeType.PERSIST– disparado toda vez que uma nova entity for inserida no banco de dados pelo comando entityManager.persist();
• CascadeType.DETACH – disparado toda vez que uma entity é retirada do Persistence Context. Comandos que podem disparar essa ação: entityManager.detach(), entityManager.clear(). Ocorrerá um detach também quando o Persistence Context deixar de existir;
• CascadeType.MERGE – disparado toda vez que uma alteração é executada em uma entity. Essa alteração pode acontecer ao final de uma transação com a qual uma managed Entity foi alterada (4.2), ou pelo comando entityManager.merge();
• CascadeType.REFRESH – disparada quando uma entity for atualizada com informações no banco de dados. Comando: entityManager.refresh();
• CascadeType.REMOVE – disparado quando uma entity é removida (apagada) do banco de dados, os relacionamentos marcados também serão eliminados O comando utilizado é o entityManager.remove();
• CascadeType.ALL – todos os eventos anteriores serão sempre refletidos nas Entities relacionadas.

Exemplo para setar apenas um tipo de Cascade:

@OneToMany(cascade = CascadeType.ALL)
private List usuarios;

Exemplo para setar um ou mais tipos, (porém não todos):

@OneToMany(cascade ={CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REMOVE })
private List usuarios;

Observações sobre o Cascade:

• É preciso ter bastante cuidado ao anotar um relacionamento com CascadeType.ALL. Uma vez que se a entidade fosse removida o seu relacionamento também seria removido do banco de dados.
• CascadeType.ALL (ou opções únicas) pode causar lentidão em todas as ações realizadas na entidade. Caso a entidade tenha muitas listas um merge() poderia causar todas as listas a receberem merge().

Relacionamento OneToOne

Confesso que sempre me confundo um pouco com os relacionamentos do Hibernate, por isso hoje vou falar do Relacionamento @OneToOne (com annotation) e posteriormente sobre os demais.

Relacionamento convencional @OneToOne

O relacionamento convencional um-para-um trata-se de um relacionamento onde os atributos das entidades relacionadas serão persistidas em tabelas distintas. O relacionamento das classes Pessoa e Endereço em um relacionamento convencional um-para-um é declarado da seguinte forma:

package testes;

import javax.persistence.*;

@Entity

public class Pessoa {

@Id@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String nome;

@OneToOne(cascade = CascadeType.ALL)

private Endereco endereco;

//get's e set's
}

package testes; 

import javax.persistence.*;

@Entity

public class Endereco { 

@Id@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String logradouro;

@OneToOne(mappedBy = "endereco")

private Pessoa pessoa;

//get's e set's
}

O annotaion @OneToOne(mappedBy = "endereco") serve para indicar um relacionamento bidirecional, informando que Endereço é o final do relacionamento entre Pessoa-Endereço e que é mapeado em Pessoa pelo atributo endereço. Ou seja, a tabela Pessoa terá a chave estrangeira para Endereço. Com esses Annotations, o Hibernate irá criar duas tabelas: Pessoa e Endereço com os seguintes atributos:

Pessoa
id bigint not null
nome varchar(255)
endereco_id bigint

Endereco
id bigint not null
logradouro varchar(255)

Podemos também declarar um relacionamento unidirecional. Para isso basta não declarar o atributo Pessoa em Endereço:

package testes; 

import javax.persistence.*; 

@Entity

public class Endereco { 

@Id@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String logradouro;
//get's e set's}

Embedded

O relacionamento "embedded one-to-one" trata-se de um relacionamento onde os atributos das entidades relacionadas serão persistidas na mesma tabela.
Por exemplo temos uma classe Pessoa que tem um relacionamento um-para-um com a classe Endereço, esse relacionamento será definido da seguinte forma:

package testes;
import javax.persistence.*;
@Entity

public class Pessoa { 

@Id@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String nome; 

@Embedded

private Endereco endereco;
//get's e set's
}

package testes;

import javax.persistence.Embeddable;

@Embeddable 

public class Endereco {

private String logradouro;

//get's e set's

}

Com esses 'Annotations', o Hibernate irá criar uma tabela Pessoa com os seguintes atributos:

id bigint not nulllogradouro varchar(255)
nome varchar(255)  

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.