Um dos livros mais aguardados do ano, com o melhor dos dois mundos no desenvolvimento WEB! O poder do Java e a beleza do Flex, reunidos em uma obra onde diversas tecnologias são abordadas. Vejam só: MySql, JBoss, Tomcat, BlazeDS, Spring, Hibernate, JasperReports, RTMP!

E esta obra foi criada pela própria comunidade! Vocês pediram os assuntos e o livro foi feito assim, de programador para programador!?

Quer saber mais? Visite agora: http://loja.flex.etc.br

Aproveite as promoções de Natal, todos os livros em promoção.

Uma dúvida de quem parte para o Flex ( foi minha dúvida tempos atrás ) é os relacionamentos N para N. Por isso por meio desse post vou fazer um exemplo de Entrada, EntradaItens, e Produto. Depois do e-mail do Rener Dias resolvi criar esse post, espero que seja isso que ele queria, qualquer coisa estamos ae.

Vamos começar pelas classes do Flex.

Entrada.as

package br.com.fborella.beans
{
	import mx.collections.ArrayCollection;
	[RemoteClass(alias="br.com.fborella.beans.Entrada")]
?
	[Bindable]
	public class Entrada
	{
		public var idEntrada:Number;
		public var numeroNota:String;
		public var dataEmissao:Date;
		public var dataChegada:Date;
		public var itensEntrada:ArrayCollection;
?
		public function Entrada()
		{
                     this.idEntrada=0;
		}
?
	}
}

EntradaItem.as

package br.com.fborella.beans
{
	import mx.collections.ArrayCollection;
	[RemoteClass(alias="br.com.fborella.beans.EntradaItem")]
?
	[Bindable]
	public class EntradaItem
	{
		public var idEntradaItem:Number;
		public var quantidadeEntrada:Number;
		public var quantidadeReal:Number;
		public var valor:Number;
		public var produto:Produto;
		public var entrada:Entrada;
?
		public function EntradaItem()
		{
                  this.idEntradaItem=0;
		}
	}
}

Produto.as

package br.com.fborella.beans
{
	import mx.collections.ArrayCollection;
	[RemoteClass(alias="br.com.fborella.beans.Produto")]
?
	[Bindable]
	public class Produto
	{
		public var idProduto:Number;
		public var codigoInterno:String;
		public var descricao:String;
		public var unidadeEntrada:String;
		public var estoqueAlmoxarifado:Number;
		public var estoqueProducao:Number;
?
		public function Produto()
		{
			this.idProduto=0;
		}
	}
}

Agora faremos as do java

Entrada.java

package br.com.fborella.beans;
?
import java.io.Serializable;
?
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
?
@Entity
@Table(name="ENTRADA")
public class Entrada implements Serializable{
?
	private static final long serialVersionUID = 1L;
	@Id
    @SequenceGenerator(name="SEQ", sequenceName="GEN_ENTRADA_ID",allocationSize=1)
    @GeneratedValue(strategy=GenerationType.IDENTITY, generator="SEQ")
    private Long idEntrada;
	private String numeroNota;
	private Date dataEmissao;
	private Date dataChegada;
	@OneToMany(mappedBy = "entrada",cascade=javax.persistence.CascadeType.ALL,fetch=FetchType.LAZY)
	@Cascade({ org.hibernate.annotations.CascadeType.SAVE_UPDATE,
              org.hibernate.annotations.CascadeType.DELETE_ORPHAN})
	private List<EntradaItem> itensEntrada;
	/*get and set*/
}

EntradaItem.java

package br.com.fborella.beans;
?
import java.io.Serializable;
?
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
?
@Entity
@Table(name="ENTRADAITEM")
public class EntradaItem implements Serializable{
?
	private static final long serialVersionUID = 1L;
	@Id
    @SequenceGenerator(name="SEQ", sequenceName="GEN_ENTRADAITEM_ID",allocationSize=1)
    @GeneratedValue(strategy=GenerationType.IDENTITY, generator="SEQ")
    private Long idEntradaItem;
	private Double quantidadeEntrada;
	private Double quantidadeReal;
	private Double valor;
	@ManyToOne(fetch = FetchType.LAZY)
	private Produto produto;
	@ManyToOne(fetch = FetchType.LAZY)
	private Entrada entrada;
	/*get and set*/
}

Produto.java

package br.com.fborella.beans;
?
import java.io.Serializable;
?
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
?
@Entity
@Table(name="PRODUTO")
public class Produto implements Serializable{
?
	private static final long serialVersionUID = 1L;
	@Id
    @SequenceGenerator(name="SEQ", sequenceName="GEN_PRODUTO_ID",allocationSize=1)
    @GeneratedValue(strategy=GenerationType.IDENTITY, generator="SEQ")
    private Long idProduto;
	private String numeroNota;
	private String codigoInterno;
	private String descricao;
	private String unidadeEntrada;
	private Double estoqueAlmoxarifado;
	private Double estoqueProducao;
	/*get and set*/
}

Para gravar tudo isso usando Aactions Scprit ( obviamente mandano para o java fazer a persistencia ), é mais ou menos assim, supondo que vc ja preencheu o objeto entrada.
O código abaixo é para o botao de salvar do item e vai agregar ele a entrada onde temos um atributo itensEntrada, depois é só mandar persistir e entrada.

private function confirmItem():void
{
	item.quantidadeEntrada=1;
	item.quantidadeReal=2;
	item.valor=250;
	item.produto=cbxProd.selectedItem as Produto;
	item.entrada=entrada; //objeto entrada que vc deve ter para dados de entrada
?
	//faça algum metodo para controlar se ele ta inserindo um item ou alterando
	if(model.acaoItem =='alterar'){
		entrada.itensEntrada.removeItemAt(itemIndex);
		entrada.itensEntrada.addItem(item);
	}else{
		entrada.itensEntrada.addItem(item);
	}
}

Espero que seja útil.

Felipe o/

O livro Dominando Flex e Java está muito perto de ser lançado! Você tem interesse na sua compra?? Preencha este pequeno formulário para receber em seu email uma oferta exclusiva, no dia de lançamento da obra:

http://bit.ly/CadastroFlexJava

Algumas informações sobre o livro:

• Quantidade de páginas: 256
• Principais Tecnologias abordadas
• Flex
• Java
• Eclipse
• MySql
• JBoss
• Tomcat
• Blazeds
• Spring
• Hibernate
• RTMP (Messaging)
• JasperReports e iReports
• Requisitos
• Saber programar
• Não é mostrado o que é if, for, essas coisas…
• Capítulos
• 1) Introdução
• 2) Preparando o ambiente
• 3) BlazeDS
• 4) CRUD com Flex e Java
• 5) Spring e Hibernate
• 6) Criando um sistama real
• 7) Criando aplicações RMTP
• Relatórios

Sumário completo: http://dl.dropbox.com/u/6740457/flex-java/Sumario-Livro-Dominando-Flex-Java.pdf

Um dica de 1 itém para configurar após a instalação do Oracle XE, caso você trabalhe com desenvolvimento web, principalmente em java, onde seu Apache Tomcat utiliza a porta 8080…

No meu caso que desenvolvo aplicações Java Web, localmente a porta 8080 já pertence ao Apache Tomcat, então instalando o Oracle XE, temos um problema, o pessoal da Oracle por algum motivo resolveu definir a porta padrão do Oracle XE também na porta 8080, então o que fazer? Simples, só mudar a porta…

Mas como mudar a porta HTTP padrão do Oracle XE?

Após a instalação do Oracle XE, muito provavelmente ele já irá iniciar o administrador da base, executando a URL: http://127.0.0.1:8080/apex/

Então acesse a área para executar um comando SQL, e execute o respectivo comando:

^?View Code SQL

1 2 3 4

begin dbms_xdb.sethttpport('90'); dbms_xdb.setftpport('2100'); end;

No meu caso resolvi mudar as portas para:

HTTP:  90 – tenho certeza que não uso para nada

FTP: 2100 – se bem que a princípio não usarei, então poderia ter deixado em 0

SQL para verificar as portas definidas:

^?View Code SQL

1 2 3 4

select dbms_xdb.gethttpport as "HTTP-Port", dbms_xdb.getftpport as "FTP-Port" from dual;

Uma vez executado o comando, se você tentar executar qualquer outra SQL, através a URL atual na porta 8080, não irá funcionar, então você terá que acessar novamente o administrador, através da nova porta definida: http://127.0.0.1:90/apex/

Feito isso, você, assim como eu poderá continuar utilizando a porta 8080 para o Apache Tomcat.

Via: daust_de

Veja também:

• WebLogic 10.x + Hibernate 3 (JPA) e base Oracle 9+
• [Adobe Flex] comparando datas de maneira rápida e fácil
• Oracle, Java e um problema com a URL de conexão
• Oracle SQL : Selecionando um intervalo similar a cláusula LIMIT
• Tomcat + Oracle: como configurar um datasource

Twitter!

Olá pessoal, nesse post eu pretendo falar sobre “FULL TEXT SEARCH” e como isso pode melhor a performace do seu sistema e ao mesmo tempo dar mais poder ao usuário na hora de fazer alguma pesquisa. Se você esta com problema para implementar algum tipo de pesquisa um pouco mais avançada aqui você pode encontrar a solução dos seus problemas!

Pesquisa

De forma simples podemos definir “Pesquisa” como o ato de procurar alguma informação em um conjunto de dados. Isso pode ser uma coisa simples ou extremante complexa. Tudo vai depender do que você esta procurando e como esta procurando.

Outra coisa que precisamos ter em mente é que existe dois tipos de pesquisa, uma é quando você sabe exatamente o que esta procurando e tem informação necessária para encontrar. A outra é quando você não sabe exatamente o que esta procurando, isso ocorre por exemplo quando fazemos uma pesquisa no Google apenas digitamos algo que esta relacionado os que desejamos.

Podemos encontrar o primeiro caso quando utilizamos sistemas para encontrar uma pessoa pelo seu CPF. Não existe duas pessoas com o mesmo CPF então quando digitamos um CPF na busca sabemos exatamente quem nós estamos procurando, diferente de procurar uma pessoa pelo nome. Esse tipo de busca é facil e simples de implementar.

Vamos agora para a parte complexa, imagina que agora nós estamos tentando encontrar um livro que fale sobre culinária. Para tentar deixar um pouco mais simples vamos trabalhar apenas com o título dos livros. No caso nos não sabemos exatamente qual livro estamos procurando, nós temos apenas o assunto ao qual nos estamos interessado, por exemplo: “Culinária havaiana para iniciantes”.

Pode existir vários livros cadastrados no sistema que estão relacionados ao assunto que estamos procurando, porém com o título diferente do que nos digitamos. Portanto a solução utilizada para encontrar uma pessoa pelo seu CPF não pode ser utilizada aqui, já que fazer a comparação entre os títulos não nos traria os resultados desejado.

Mas como nos podemos encontrar o que desejamos?
Podemos considerar que o título do livro que tem mais ocorrências de palavras digitadas na pesquisa esta mais próximo do que nos estamos procurando. Ou seja, vários livros podem aparecer no resultado de nossa pesquisa, mas os primeiros resultados estariam mais relacionados ao que nos estamos procurando. Isso é chamado de “Relevance”.

Esse tipo de pesquisa parece ser o ideal, mas precisamos considerar mais alguns pontos. Por exemplo, o usuário pode digitar na busca “Livro de culinária havaiana para iniciantes”. Nem todas as palavras digitadas pelo usuário deveriam ser consideradas na pesquisa, se olharmos com mais cuidado vamos notar que “Livro”, “de” e “para” não tem nenhum significado quando estamos falando de livros. Essas palavras sem significado são conhecidas como “Noise”.

Outro problema relacionado a palavras é que o usuário pode digitar (havaiana, avaiana, hawaiana), são palavras diferentes, mas que no final poderiam ter o mesmo significado na nossa pesquisa. Para resolver esse problema precisamos fazer uma comparação fonética das palavras.

Depois de ver todos esse problemas relacionados a pesquisa você ainda acha que seria simples resolver todos esses problemas utilizando apenas SQL padrão?

Não fique desesperado existe uma luz no fim do túnel! Existe algumas soluções para nos problema e uma delas se chama “FULL-TEXT SEARCH” ou “FREE-TEXT SEARCH“.

FULL-TEXT SEARCH

Dado um conjunto de palavras o objetivo principal do full-text search é prover acesso a todos os registros que estão relacionados a esse conjunto. Já que fazer uma busca sequencial não é muito eficiente o full-text search quebra seu trabalho em duas partes: Guardar a informação em uma formato eficiente e depois fazer a busca utilizando essa estrutura.

As palavras são o coração do full-text search e elas serão utilizadas em duas operações.

Indexing
Indexing é o trabalho de construir uma estrutura que torne a pesquisa rápida e fácil. O segredo disso esta em organizar cada uma das palavras do título de um livro, como podemos ver no exemplo abaixo:


Tabela Relacional

Index

Searching
Aqui é onde ocorre o processo de pegar o que o usuário digitou e transformar em parâmetros para busca. A primeira coisa a ser feita é uma analise no que foi digitado, essa analise deve ser a mesma utilizada para gerar o index. Quanto utilizamos a mesma técnica para gerar o index e depois para fazer a busca nos temos uma linguagem comum entre o index e a busca. O passo seguinte seria recuperar do index todos os registros que estão relacionados com as palavras digitadas na busca. Nesse momento o registro em si não é carregado, apenas recuperamos o id de cada registro. Os próximos passos serão filtrar os registros encontrados, ordena-los conforme seu grau de relevância, carregar os dados dos registros encontrados e disponibilizar o resultado para o cliente.

Colocando a mão na massa

Até aqui procurei, de modo superficial, apresentar os problemas que estão relacionados a implementação de uma pesquisa em um sistema. Se os requisitos do seu sistema exigem apenas pesquisas simples você não tem que se preocupar muito, mas se você precisa implementar pesquisas mais complexas você provavelmente vai encontrar esse problemas.
E para não ficarmos apenas na teoria vou apresentar a você algumas ferramentas que podemos utilizar para fazer essas pesquisas mais avançadas.

Uma delas é o Lucene, um projeto open source escrito em Java que implementa o full-text search.

Outra ferramenta é o Hibernate Search que faz a ponte entre o full-text search e a suas entidades de negocio.

Para ver como configurar essas duas ferramentas em seu projeto assista o screencast:

Twitter!

Objetivo:

Olá pessoal, neste poste eu pretendo falar um pouco mais sobre o Spring Roo e como criar um modelo de entidades complexo.
Pretendo falar da configurar o banco de dados até a criação de relacionamentos, também vou explicar
cada um dos comando utilizado na criação de entidades e configuração de banco de dados.

Abaixo segue uma lista dos principais comando, e seus parâmetros, utilizados na criação de entidades pelo Spring Roo. Procurei colocar todos os parâmetros de cada comando, mas como alguns parâmetros são utilizados em vários comandos vou colocar a descrição deles apenas uma vez.

Persistence setup:

–provider: Utilizado para configurar o provaider do JPA, os possíveis valores para esse parâmetro são:
Hibernate,
EclipseLink,
OpenJPA
DataNucleus

–database: Utilizado para configurar qual o bando de dados será utilizado na aplicação, os possíveis valores são:
HSQL(em memória),
HSQL,
H2(em memória),
MySql,
Postgres,
MS SQL Server,
Sysbase,
Oracle,
DB2,
Google App Engine,
Derby

–applicationId: Identificador de aplicativo do Google App
–databaseName: Utilizado para configurar o nome do banco de
–jndiDataSource: Utilizado para referênciar um DataSource configurado na árvore
–password: Utilizado para configurar a senha do usuário do banco de dados
–userName: Utilizado parar configurar o usuário do banco de dados

Os parâmetros (databaseName, password, userName) podem ser configurados diretamente no arquivo “database.properties”.
Este arquivo se encontra em src/main/resources/META-INF/spring/database.properties.
O comando persistence setup pode ser utilizado mais de uma vez. Você pode, por exemplo, utilizar HSQL e Hibernate em desenvolvimento e depois trocar para Oracle
e EclipseLink quando for colocar em produção.

Resumo:
Quando rodamos o comando “persistence setup” o Spring Roo se encarrega das seguintes configurações
1 – Configuração de dependência de JPA, ORM provaider, Drivers, Spring ORM, Spring JDBC, Commons DBCP, Commons Pool no arquivo pom.xml
2 – Configuração do arquivo “persistence.xml”
3 – Arquivo de configuração para o banco de dados “database.properties”
4 – Configuração de DataSource e Transação no arquivo de configuração do Spring

Entity:

–class: Nome da classe
–abstract: Configura a entidade como abstrata
–extends: Identifica qual classe a entidade extende
–identifierColumn: Nome da coluna que é a chave primário da tabela
–identifierField: Nome do field que será mapeado para o campo de chave primária da tabela
–identifierType: Tipo do field que será utilizado como chave primária
–inheritanceType: Utilizado para configurar a annotation “@Inheritance”
–mappedSuperclass: Indica se a entidade deve ter a annotation “@MappedSuperclass”
–permitReservedWords: Indica se o Roo deve ignorar palavras reservadas
–serializable: Indica se a entidade deve implementar a interface “java.io.Serializable;”
–table: Nome da tabela que será mapeada pela Entidade.
–testAutomatically: Indica se deve ser criado testes unitários para a Entidade

field boolean:

–fieldName: Nome do field
–class: Classe onde o field será criado
–assertFalse: Configura o field com o annotation “@AssertFalse” da especificação Bean Validation
–assertTrue: Configura o field com o annotation “@AssertTrue” da especificação Bean Validation
–class: Nome da entidade onde o field vai ser criado.
–column: Nome da coluna da tabela do banco de dados
–comment: Comentário
–notNull: Não permite valor null
–nullRequired: Configura o field para ser null.
–permitReservedWords: Permite utilizar palavras reservadas no nome dos fields
–primitive: Indica se o typo do field vai ser “boolean” ou “”Boolean
–transient:

field date

–fieldName:
–class:
–type: Configura o tipo do field Date ou Calendar;
–column:
–comment:
–dateFormat: Indica o estilo de formatação da data;
–future: Indica que a data deve ser sempre no futuro
–notNull:
–nullRequired:
–past: Indica que a data deve ser sempre no passado
–permitReservedWords:
–persistenceType: Configura como a data vai ser salva no banco de dados (DATE, TIME, TIMESTANP)
–timeFormat: Configura o tipo de formatação do field
–transient:

field enum:

–fieldName:
–class:
–type:
–column:
–comment:
–enumType: Indica como o field será persistido no banco (ORDINAL, STRING)
–notNull:
–nullRequired:
–permitReservedWords:
–transient:

field number

–fieldName:
–class:
–type:
–column:
–comment:
–decimalMax: Valor máximo
–decimalMin: Valor máximo
–digitsFraction: Quantidade máxima de números depois da virgula
–digitsInteger: Quantidade máxima de dígitos inteiros
–max: Valor máximo
–min: Valor minimo
–notNull:
–nullRequired:
–permitReservedWords:
–primitive: Indica que o field deve ser primitivo
–transient:

field reference:

–fieldName:
–class:
–type:
–comment:
–cardinality:Cardinalidade do relacionamento, default MANY_TO_ONE
–fetch: Configuracao de fetch (EAGER, LAZY)
–joinColumnName: Nome da coluna que será utilizada no relacionamento
–notNull:
–nullRequired:
–permitReservedWords:
–transient:

field set:

–fieldName:
–class:
–element: Tipo da entidade do relacionamento
–cardinality:Cardinalidade do relacionamento, default MANY_TO_MANY
–comment:
–fetch:
–mappedBy: Nome do field na entidade de referência que é dono do relacionamento
–notNull:
–nullRequired:
–permitReservedWords
–sizeMax: Numero máximo de elementos que pode existir no relacionamento
–sizeMin: Número mínimo de elementos que pode existir no relacionamento
–transient:

field string:

–fieldName:
–class:
–column:
–comment:
–decimalMax:
–decimalMin:
–notNull:
–nullRequired:
–permitReservedWords:
–regexp: Obriga o valor do field ser compatível com a expressão regular
–sizeMax: Tamanho máximo da string
–sizeMin: Tamanho mínimo da string
–transient

Segue também um screencast com exemplos de criação de entidades.

Twitter!

Olá Pessoal, vou mostrar a vocês como criar relatório com o IReport. Mas antes de mais nada o que é a IReport.

IReport

IReport é uma ferramenta de designer para relatórios, que utiliza a biblioteca Java para relatórios a JasperReports. Com ele é possível fazer layots sofisticados, contendo gráficos, imagens, sub-relatórios, tabelas de referência cruzada e muito mais. Os dados podem ser acessado via JDBC, TableModels, JavaBeans, XML, Hibernate e CSV. Depois podendo fazer relatórios em PDF, RTF, XML, XLS, CSV, HTML, XHTML, textos, DOCX ou OpenOffice.

É um projeto open-source da equipe JasperForge que possui ferramentas para produção de relatórios, elaboração de relatórios operacionais etc. Mais informações estão disponíveis no www.jasperforge.org.

Ciclo de Vida do Relatório

O arquivo criado pelo IReport é um jrxml, arquivo XML que contém a definição do relatório, como o relatório é desenhado completamente de uma forma visual não é necessário saber a estrutura desse arquivo XML. Depois o jrxml deve ser compilado em um objeto binário chamado Jasper, e é o que você precisa enviar para sua aplicação para executar os relatórios.

Na execução do relatório você precisará do arquivo Jasper e uma fonte de dados para o JasperReports. Há muitos tipos de fontes de dados como: arquivo XML, consulta SQL, arquivo CSV, uma HQL (Hibernate Query Language), uma consulta com JavaBeans, etc. O JasperReports é bem flexível proporcionando a você criar sua propria fonte de dados. Com o arquivo Jasper e a fonte dados o JasperReports é capaz de gerar o documento final em vários formatos.

Atualmente se encontra na versão 3.7.5 e pode ser baixado no site:
http://jasperforge.org//website/ireportwebsite/IR%20Website/ir_download.html?header=project&target=ireport

Fonte

http://jasperforge.org/projects/ireport

Exemplo

No screencast abaixo é explificado o uso do IReport, para fonte de dados utilizei um arquivo xml.

Arquivos Fontes

http://office-sp.dclick.com.br/devblog/wp-content/uploads/2010/arquivos-fontes-relatorio.zip

http://office-sp.dclick.com.br/devblog/wp-content/uploads/2010/lib-relatorio.zip

Templantes de relatórios

http://office-sp.dclick.com.br/devblog/wp-content/uploads/2010/templates-relatorios.zip

Quando o programador necessita de recursos do SGBD também pode ser feito m query nativa no Hibernate. Existem muitas maneiras de se fazer isso. Vou colocar aqui um exemplo bem pratico.

Exemplo:

List<Cidade> lista = this.getSession().
      createSQLQuery("select id, nome from Cidade").addEntity(Cidade.class).list();

Felipe

Ao pesquisar em um tabela do banco de dados, não necessariamente pesquisa também pelas tabelas que estão relacionadas, você pode estar carregando informações que não são necessárias neste contexto da sua aplicação. O Hibernate também não inicializa os relacionamentos 1:N e N:N automaticamente, porque ele pode estar caindo nesse caso de carregar objetos que não são necessários neste caso.
O que eu uso é um “left join fecth” entre os objetos, em uma busca HQL, assim vai carregar somente a coleção quando for iniciada.

Exemplos

carregar um objeto aluno e suas matriculas já inicializados.

Aluno aluno = this.getSession().createQuery("from Aluno a " +
     "left join fetch a.matricula where a.id = 1").uniqueResult();

carregar um Set com objetos aluno e susa matriculas já inicializados:

Set set = new HashSet(this.getSession().createQuery( "from Aluno a" +
  " left join fetch a.matricula "where a.id < 5").list());

Espero que seja útil para alguém.

Felipe

Chegou o momento de um dos livros mais aguardados e pedidos pelos leitores: Dominando Flex e Java. Nesta obra, iremos abordar o desenvolvimento de sistemas utilizando o Flex 4 e o Java, utilizando o BlazeDS como ponte entre as duas tecnologias.

Chegou o seu momento de colaborar! Estamos construindo o sumário do livro e definindo o que iremos utilizar. Tomcat? Jboss? Hibernate? Springs? Quem define são vocês, desenvolvedores, que sabem o que é melhor e o que é mais usado.

A ajuda da comunidade é fundamental e já foi aprovada nos livros Dominando Flex e Zend, Dominando Adobe Flex 4 e Dominando Action Script 3.

Apreveite e deixe o seu comentário!