quarta-feira, 29 de setembro de 2010

ResultTransformer Inteligente =)

Pessoal .. estou passando aki p vcs um result transformer inteligente ! ....


 /**  
  *   
  * Result transformer inteligente  
  *   
  * @author Sergio , Alterado por Caio Rodrigo Paulucci  
  *   
  * @see AliasToBeanResultTransformer  
  *   
  *   
  *   
  *   
  *   
  *   Similar ao AliasToBeanResultTransformer poróm ele aceita o uso de  
  *   "nestedProperties" (aquela que vocó usa na JSTL ou EL)  
  *   
  *   no criteria e pode instanciar mais de um tipo de classe.  
  *   
  *   Inclusive uma parte do código foi copiado da classe original.  
  *   
  * <br />  
  *   
  *   <b>1ó Forma de utilização</b>  
  *   
  *   caso mais comum criar uma lista de objetos do mesmo tipo  
  *   (HistoricoRegistroVO)  
  *   
  * <br />  
  *   
  *   <code>  
 Criteria crit= createCriteria(HistoricoRegistroVO.class);  
 criteria.add(Restrictions.eq("this.registroVO.id", idDemanda));  
 ProjectionList projectionList = Projections.projectionList();  
 //seleciono somente os campos que me interessam, na estrutura real dos objetos (sem a necessidade de criação dos DTOs)  
 projectionList.add(Projections.property("this.ativo"), "ativo");  
 projectionList.add(Projections.property("this.descricao"), "descricao");  
 projectionList.add(Projections.property("this.encaminhamentoInterno"), "encaminhamentoInterno");  
 criteria.createAlias("this.usuarioVO", "usr");  
 criteria.createAlias("usr.unidadeVO", "unr");  
 projectionList.add(Projections.property("usr.login"), "usuarioVO.login");  
 projectionList.add(Projections.property("usr.nome"), "usuarioVO.nome");  
 projectionList.add(Projections.property("usr.id"), "usuarioVO.id");  
 projectionList.add(Projections.property("unr.descricao"), "usuarioVO.unidadeVO.descricao");  
 projectionList.add(Projections.property("this.dataUltimoMovimento"), "dataUltimoMovimento");  
 criteria.setProjection(projectionList);  
 //transformo o resultado no objeto passado e somente as propriedades e objetos que selecionei estóo preenchidas  
 criteria.setResultTransformer(new InteligentResultTransformer(HistoricoRegistroVO.class));  
 List resultado = criteria);  
 </code>  
  *   
  *   
  *   
  *   
  *   
  *   <b>2ó Forma de utilização</b>  
  *   
  *   Criar uma lista de objetos com um tipo definido pelo usuório  
  *   (programmer)  
  *   
  *   <code>  
 //Considerando que temos uma classe RegistroDenunciaReclamacaoVO que ó filho do RegistroVO  
 //preciso instónciar a classe correta de acordo com uma determinada condição  
 Criteria crit= createCriteria(RegistroVO.class);  
 criteria.createAlias("this.tipoRegistroVO", "tir");  
 criteria.createAlias("this.instituicaoFinanceiraVO", "ifr", Criteria.LEFT_JOIN);  
 ProjectionList projectionList = Projections.projectionList();  
 //seleciono os campos que me interessam  
 projectionList.add(Projections.property("this.enderecoVO"), "enderecoVO");  
 projectionList.add(Projections.property("ifr.nomeFantasia"), "instituicaoFinanceiraVO.nomeFantasia");  
 projectionList.add(Projections.property("tir.descricao"), "tipoRegistroVO.descricao");  
 projectionList.add(Projections.property("tir.id"), "tipoRegistroVO.id");  
 projectionList.add(Projections.property("tir.comportamentoTipoRegistroVO"), "tipoRegistroVO.comportamentoTipoRegistroVO");  
 projectionList.add(Projections.property("this.id"), "id");  
 projectionList.add(Projections.property("this.idCrm"), "idCrm");  
 projectionList.add(Projections.property("this.idConsulta"), "idConsulta");  
 //esses dois campos pertencem a classe RegistroDenunciaReclamacaoVO somente  
 projectionList.add(Projections.property("this.dataRanking"), "dataRanking");  
 projectionList.add(Projections.property("this.rankingCarimbo"), "rankingCarimbo");  
 criteria.setProjection(projectionList);  
 //ao invós de passar a classe como no exemplo anterior  
 //eu passo uma classe que implementa a interface ResultClass  
 InteligentResultTransformer rt = new InteligentResultTransformer(new ResultClass(){  
 //aqui eu recebo um Map onde tenho como chave os alias adicionados no projectionList  
 //e como valores os resultados retornados pela consulta  
 public Class getResultClass(Map resultMap) {  
 //faóo uma comparação e retorno o tipo da classe que quero criar a instóncia para essa linha  
 ComportamentoTipoRegistroVO comportamento = (ComportamentoTipoRegistroVO) resultMap.get("tipoRegistroVO.comportamentoTipoRegistroVO");  
 if(DadosConstantes.COMPORTAMENTO_INFORMACAO.equals(comportamento.getId())){  
 return RegistroVO.class;  
 }  
 if(DadosConstantes.COMPORTAMENTO_IRREGULARIDADE.equals(comportamento.getId())){  
 return RegistroDenunciaReclamacaoVO.class;  
 }  
 return null;  
 }  
 });  
 criteria.setResultTransformer(rt);  
 criteria);  
 </code>  
  *   
  *   
  *   
  *   
  *   
  *   
  */  
 public class InteligentResultTransformer implements ResultTransformer {  
      private static final long serialVersionUID = -7124932916590109519L;  
      /**  
       *   
       * Classe de resultado (se o tipo da classe for fixo)  
       */  
      private Class resultClass;  
      /**  
       *   
       * objeto para acessar as propriedades de um tipo de classe  
       */  
      private PropertyAccessor propertyAccessor;  
      /**  
       *   
       * Implemntaóao que deveró fornecer java.lang.Class a ser instónciado para a  
       * linha atual do registro  
       */  
      private ResultClass rc;  
      /**  
       *   
       * Cache de propertyAccessor, para evitar de ficar instónciando esse fiduma  
       * toda hora.  
       *   
       * Se nóo fosse pesado instanciar ele o hibernate nóo usaria uma varióvel de  
       * instóncia  
       *   
       * para guardar ele  
       */  
      private HashMap propertyAccessors = new HashMap();  
      /**  
       *   
       * Tupla de registros retornados pela consulta  
       */  
      private Object[] tuple;  
      /**  
       *   
       * Alias adicionados no Projections.projectionList()  
       */  
      private String[] aliases;  
      /**  
       *   
       * Tipo dinamico para a coleção a ser criada  
       *   
       * @param rc  
       */  
      public InteligentResultTransformer(ResultClass rc) {  
           this.rc = rc;  
      }  
      /**  
       *   
       * A coleção a ser criada seró de um tipo somente  
       *   
       *   
       *   
       * @param resultClass  
       */  
      public InteligentResultTransformer(Class resultClass) {  
           if (resultClass == null)  
                throw new IllegalArgumentException("resultClass cannot be null");  
           this.resultClass = resultClass;  
      }  
      /*  
       *   
       * (non-Javadoc)  
       *   
       * @see  
       * org.hibernate.transform.ResultTransformer#transformTuple(java.lang.Object  
       * [], java.lang.String[])  
       */  
      public Object transformTuple(Object[] tuple, String[] aliases) {  
           this.tuple = tuple;  
           this.aliases = aliases;  
           Object result;  
           try {  
                // instancia a classe de resultado  
                result = getResultClass().newInstance();  
                for (int i = 0; i < aliases.length; i++) {  
                     String alias = aliases[i];  
                     if (alias != null) {  
                          if (tuple[i] == null) {  
                               continue;  
                          }  
                          /*  
                           * se o alias contóm ponto ó porque a propriedade a ser  
                           * setada deveró ser  
                           *   
                           * navegada ató o final para ser preenchida  
                           *   
                           * (Ex: registroVO.tipoRegistroVO.descricao  
                           *   
                           * - instancia uma vez o tipoRegistroVO  
                           *   
                           * - seta a descricao com o valor da tupla)  
                           */  
                          if (alias.indexOf(".") != -1) {  
                               String[] split = alias.split("\\.");  
                               Object resultado = result;  
                               for (int j = 0; j < split.length; j++) {  
                                    String property = split[j];  
                                    // se for a óltima propriedade o valor da tupla  
                                    // deveró ser setado nela  
                                    if (j == (split.length - 1)) {  
                                         PropertyUtils.setProperty(resultado, property,  
                                                   tuple[i]);  
                                         break;  
                                    }  
                                    // do contrório instancio o tipo da propriedade se  
                                    // necessório e passo para o próximo  
                                    Object valor = PropertyUtils.getProperty(resultado,  
                                              property);  
                                    if (valor == null) {  
                                         Class tipo = PropertyUtils.getPropertyType(  
                                                   resultado, property);  
                                         valor = tipo.newInstance();  
                                         PropertyUtils.setProperty(resultado, property,  
                                                   valor);  
                                    }  
                                    resultado = valor;  
                               }  
                          } else {  
                               // se estiver em modo inteligente  
                               if (this.isInInteligentMode()) {  
                                    // pode ser que a propriedade nóo exista na classe  
                                    // que foi retornada pelo ResultClass  
                                    if (PropertyUtils.isWriteable(result, alias)) {  
                                         Setter mainSetter = getPropertyAcessor()  
                                                   .getSetter(getResultClass(), alias);  
                                         mainSetter.set(result, tuple[i], null);  
                                    }  
                               } else {  
                                    // do contrório nóo ó admissóvel que a propriedade  
                                    // nóo exista na classe informada  
                                    Setter mainSetter = getPropertyAcessor().getSetter(  
                                              getResultClass(), alias);  
                                    mainSetter.set(result, tuple[i], null);  
                               }  
                          }  
                     }  
                }  
           } catch (Exception e) {  
                throw new HibernateException(e);  
           }  
           return result;  
      }  
      /**  
       *   
       * Retornar a classe que deveró ser instanciada e preenchida com o resultado  
       *   
       * @return  
       */  
      private Class getResultClass() {  
           // se o rc ó nulo nóo estó em modo inteligente  
           if (!this.isInInteligentMode()) {  
                return this.resultClass;  
           }  
           // recupero um mapa com o resultado cró retornado pelo hibernate  
           Map propriedades = getMap(tuple, aliases);  
           // invoco o result class que foi passado com as propridades  
           Class resultClass2 = rc.getResultClass(propriedades);  
           // e ele deveró me passar o tipo da classe a ser instanciada  
           return resultClass2;  
      }  
      /**  
       *   
       * Cria um mapa de propriedades para passar para a instóncia da ResultClass  
       *   
       * @param tuple  
       *   
       * @param aliases  
       *   
       * @return  
       */  
      private Map getMap(Object[] tuple, String[] aliases) {  
           HashMap map = new HashMap();  
           for (int i = 0; i < aliases.length; i++) {  
                map.put(aliases[i], tuple[i]);  
           }  
           return map;  
      }  
      /*  
       *   
       * (non-Javadoc)  
       *   
       * @see  
       * org.hibernate.transform.ResultTransformer#transformList(java.util.List)  
       */  
      public List transformList(List collection) {  
           return collection;  
      }  
      /**  
       *   
       * Retorna o property acessor de acordo com a classe que seró instónciada  
       *   
       * @return  
       */  
      public PropertyAccessor getPropertyAcessor() {  
           if (propertyAccessor == null && !this.isInInteligentMode()) {  
                propertyAccessor = new ChainedPropertyAccessor(  
                          new PropertyAccessor[] {  
                                    PropertyAccessorFactory.getPropertyAccessor(  
                                              resultClass, null),  
                                    PropertyAccessorFactory  
                                              .getPropertyAccessor("field") });  
           }  
           if (this.isInInteligentMode()) {  
                Class resultClass2 = this.getResultClass();  
                String className = resultClass2.getName();  
                Object propertyAcessor = this.propertyAccessors.get(className);  
                if (propertyAcessor == null) {  
                     this.propertyAccessors.put(  
                               className,  
                               new ChainedPropertyAccessor(new PropertyAccessor[] {  
                                         PropertyAccessorFactory.getPropertyAccessor(  
                                                   resultClass2, null),  
                                         PropertyAccessorFactory  
                                                   .getPropertyAccessor("field") }));  
                }  
                return (PropertyAccessor) this.propertyAccessors.get(className);  
           }  
           return this.propertyAccessor;  
      }  
      /**  
       *   
       *   
       *   
       * @param resultClass  
       */  
      public void setResultClass(ResultClass resultClass) {  
           this.rc = resultClass;  
      }  
      /**  
       *   
       * Quando o {@link InteligentResultTransformer} ó instanciado para criar um  
       * tipo de objeto  
       *   
       * Esse mótodo retorna false.  
       *   
       * Quando essa classe ó instanciada com uma instancia do ResultClass  
       *   
       * Ele retorna true.  
       *   
       * @return  
       */  
      private boolean isInInteligentMode() {  
           return this.rc != null;  
      }  
 }  

e o ResultClass :

 import java.util.Map;  
 /**  
  *   
  * Classe de resultado, deveró retornar o tipo do objeto para ser instanciado  
  * de acordo com o resultMap passado como parómetro  
  *   
  * @see InteligentResultTransformer  
  * @author deinf.sdantas  
  *   
  */  
 public interface ResultClass {  
      public Class getResultClass(Map resultMap);  
 }  

sexta-feira, 24 de setembro de 2010

Emulando IE7 no richfaces jsf (Problemas no IE8)

Tem varias formas de fazer a emulação do ie7 ...
 import javax.servlet.Filter;  
 import javax.servlet.FilterChain;  
 import javax.servlet.FilterConfig;  
 import javax.servlet.ServletException;  
 import javax.servlet.ServletRequest;  
 import javax.servlet.ServletResponse;  
 import javax.servlet.http.HttpServletResponse;  
 /**  
  * Servlet Filter implementation class IE8CompatablityFixServlet  
  */  
 public class IE8CompatablityFixServlet implements Filter {  
      /**  
       * Default constructor.  
       */  
      public IE8CompatablityFixServlet() {  
      }  
      /**  
       * @see Filter#destroy()  
       */  
      public void destroy() {  
      }  
      /**  
       * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)  
       */  
      public void doFilter(ServletRequest request, ServletResponse response,  
                FilterChain chain) throws IOException, ServletException {  
           ((HttpServletResponse) response).setHeader("X-UA-Compatible",  
                     "IE=EmulateIE7");  
           chain.doFilter(request, response);  
      }  
      /**  
       * @see Filter#init(FilterConfig)  
       */  
      public void init(FilterConfig fConfig) throws ServletException {  
      }  
 }  
E no web.xml : 

<filter>
    <display-name>IE8CompatablityFixServlet</display-name>
    <filter-name>IE8CompatablityFixServlet</filter-name>
    <filter-class>br.com.sintel.plan.presentation.utils.IE8CompatablityFixServlet</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>IE8CompatablityFixServlet</filter-name>
    <url-pattern>/IE8CompatablityFixServlet</url-pattern>
  </filter-mapping>


Opção 2 : 

<head>
<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" />
...
<head/>


Particularmente .. a Opção 1 funciona melhor ! 

Abraços ...

Sem mais !

Criando um persistence unit na mão !

A Configuração :
 Ejb3Configuration ejbconf = new Ejb3Configuration();  
   ejbconf.setProperty("hibernate.connection.datasource", "java:/" + datasourceName);  
   ejbconf.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLInnoDBDialect");  
   ejbconf.setProperty("hibernate.show_sql", "false");  
   ejbconf.setProperty("hibernate.ejb.naming_strategy","com.fcl.greenfield.naming.FCLNamingStrategy");  
   ejbconf.setProperty("hibernate.hbm2ddl.auto", "update");  

Usando :

 Logger.info("Building SessionFactory");
    EntityManagerFactory emf = ejbconf.createEntityManagerFactory();
    EntityManager em = emf.createEntityManager(); 

Facil né ? ! aeuUAEhuaehuaheuHEuae

Sem mais !

segunda-feira, 13 de setembro de 2010

Painel modal de status “loading” ou processando ... com a4j:status


Problema:

Como implementar uma tela modal de status “loading” com Ajax?

Solução:

Achei um post bem bom que mostra como fazer, abaixo segue uma copia de trechos do post (necessário para garantir a permanecia da informação):

O a4j:status é um indicador de uma solicitação Ajax. Apresenta um aviso ao usuário enquanto o sistema está processando sua solicitação.
Este componente tem dois estados: start e stop.
O estado start indica que uma solicitação Ajax está em andamento.
O componente muda para o estado stop quando a solicitação Ajax é finalizada.
Quando uma solicitação Ajax é enviada o evento onstart do componente a4j:status é acionado, então ele abre o ModalPanel com o id “panel_loading”.
Quando a solicitação é finalizada, o componente muda seu estado para onstop e chama a função responsável em fechar o ModalPanel.


<rich:modalPanel id="panel_loading" autosized="true">

<h:graphicImage url="/img/loading.gif" style="border:0px; vertical-align: middle;" />

<rich:spacer width="20" />

<h:outputText value="Aguarde..." />

</rich:modalPanel>

<a4j:status id="loading" onstart="Richfaces.showModalPanel('panel_loading')" onstop="Richfaces.hideModalPanel('panel_loading')" />
Ate mais ! ;)

quinta-feira, 9 de setembro de 2010

Chamar uma funcao da pagina pai dentro de um iframe !


Página Pai

<script language="Javascript">
function test() { alert('teste de mensagem'); };
</script>

..  html ...

<iframe src="http://siteY.com/page_y.htm"></iframe>
 Página IFrame

<script language="Javascript">
parent.test();
</script>
Página em servidores diferentes
Se as páginas ficarem em servidores diferentes deve usar essa linha de comando para evitar o erro de Permissão Negada

<script language="Javascript">
document.domain = "microsoft.com"
</script>

E digo mais ainda ... da para usar isso com o JSF + Rich .... por exemplo.... se vc esta abrindo um iframe dentro de um modal panel.... e quer fechar e nao sabe como ... hehehehe .. facil ... no onclick do button
coloca assim : window.parent.Richfaces.hideModalPanel('nome');  q funciona :D :D :D :D :D


EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE !!!!!

Sem mais !!!

segunda-feira, 6 de setembro de 2010

JfreeChart & iReport


O que é JFreeChart?

Visão Geral
JFreeChart é uma biblioteca livre para a  plataforma Java(tm). Foi desenvolvida para ser utilizada em Aplicações Desktop, Applets, Servlets e JSP.

jfreechartfig01.JPG
Figura 1 – Exemplo de gráfico do JFreeChart.

Características
Jfreechart pode ser usado para gerar gráficos de Pizza, gráficos de Barra, gráficos de linha (com ou sem efeito 3D), gráficos combinados, dentre diversos outros tipos de gráficos. Exporta dados para o formato PNG ou JPEG, Exporta para qualquer formato usando a implementação de Graphics2D incluindo:
– PDF via iText (http://www.lowagie.com/iText/);
– SVG via Batik (http://xml.apache.org/batik/);

Jfreechart é inteiramente escrito em Java e pode ser utilizado em qualquer implementação da plataforma Java 2 (JDK 1.2.2 ou superior).

Obtendo o JfreeChart
JfreeChart pode ser baixado a partir do endereço:


Neste endereço você poderá obter as ultimas informações sobre JfreeChart, exemplos de gráficos, downloads, documentação e até um fórum.

Sobre este Tutorial
Neste tutorial, procurarei mostrar como se faz para criar um gráfico a partir de uma fonte de dados e mostrar este gráfico em um relatório gerado no iReport a partir de um Servlet. Usando como exemplo um relatório comparativo de vendas de CDs e DVDs durante um certo período.

Não daremos muitas explicações sobre iReport, pois este não é o objetivo deste tutorial. Apresentaremos apenas como montar um modelo no iReport para receber o gráfico gerado.

Veremos também que o código necessário para a chamada do relatório é mínimo.

Para este tutorial usei o JfreeChart 1.0.1 que é a ultima versão disponível para Download.

Servlets
A API de Java Servlets é uma tecnologia muito usada para a criação de Aplicações Web e  JfreeChart é um serviço muito bom para ser usado também por Servlets.

Neste tutorial vamos mostrar um Servlet gerando um gráfico e em seguida chamando um relatório criado no iReport mostrando o gráfico gerado.

O método doGet(...)
O método doGet(...) é chamado pelo Servlet quando uma requisição é enviada pelo cliente (geralmente através de um browser). Em resposta à requisição o Servlet que iremos criar irá realizar os seguintes passos:

  • Obtém uma referencia de OutputStream para retornar uma saída ao cliente;
  • Cria o gráfico;
  • Um content type para a resposta é settado para Application/Pdf para exibir o relatório em formato PDF;
  • Criar o relatório passando para ele os dados que geraram o gráfico e a imagem do gráfico gerada.
  • Fechar o OutputStream.
Adicionando os Jar’s
Os .jar’s do JfreeChart que utilizei são jcommon-1.0.0.jar e jfreechart-1.0.1.jar. Primeiramente vamos adicioná-los ao lib do nosso projeto.

jfreechartfig021.JPG
Figura 2 – Adicionando os jar’s do JFreeChart.

Os Jar’s do iReport que utilizei são: jasperreports-1.2.0.jar, commonslogging-api-1.0.2.jar, commons-collections-3.1.jar, barbecue-1.1.jar, iReport.jar, commons-beanutils-1.5.jar, itext-1.3.1.jar.

jfreechartfig03.JPG
Figura 3 – Adicionando os jar’s do iReport.

Gerando os Gráficos
Primeiramente, vamos criar as classes ModeloGraficoItem que armazenará os dados que darão origem ao gráfico e ComposicaoDadosItemGrafico que gerará valores arbitrários que serão exibidos no gráfico:

ModeloGraficoItem.java

 import java.io.Serializable;  
 import java.util.ArrayList;  
 public class ModeloGraficoItem implements Serializable {  
   private String mes;  
   private String produto;  
   private int quantidade;  
   public ModeloGraficoItem() {  
   }  
   public ModeloGraficoItem(String mes, String produto, int quantidade) {  
     this.mes = mes;  
     this.produto = produto;  
     this.quantidade = quantidade;  
   }  
   public String getMes() {  
     return mes;  
   }  
   public void setMes(String mes) {  
     this.mes = mes;  
   }  
   public String getProduto() {  
     return produto;  
   }  
   public void setProduto(String produto) {  
     this.produto = produto;  
   }  
   public int getQuantidade() {  
     return quantidade;  
   }  
   public void setQuantidade(int quantidade) {  
     this.quantidade = quantidade;  
   }  
 }  

ComposicaoDadosItemGrafico.java

 import java.util.ArrayList;  
 public class ComposicaoDadosItemGrafico {  
   protected ArrayList array = new ArrayList();  
   public ComposicaoDadosItemGrafico() {  
     array.add(new ModeloGraficoItem("JANEIRO", "CD", 20));  
     array.add(new ModeloGraficoItem("FEVEREIRO", "CD", 30));  
     array.add(new ModeloGraficoItem("MARCO", "CD", 40));  
     array.add(new ModeloGraficoItem("ABRIL", "CD", 50));  
     array.add(new ModeloGraficoItem("MAIO", "CD", 60));  
     array.add(new ModeloGraficoItem("JUNHO", "CD", 70));  
     array.add(new ModeloGraficoItem("JANEIRO", "DVD", 10));  
     array.add(new ModeloGraficoItem("FEVEREIRO", "DVD", 70));  
     array.add(new ModeloGraficoItem("MARCO", "DVD", 140));  
     array.add(new ModeloGraficoItem("ABRIL", "DVD", 10));  
     array.add(new ModeloGraficoItem("MAIO", "DVD", 54));  
     array.add(new ModeloGraficoItem("JUNHO", "DVD", 23));  
   }  
   public ArrayList getArray() {  
     return array;  
   }  
   public void setArray(ArrayList array) {  
     this.array = array;  
   }  
 }  

A seguir a classe GeradorGrafico implementa 2 tipos de gráficos: Gráfico de Barras e Gráfico de Linha com e sem efeito 3D.

 import java.awt.image.BufferedImage;  
 import java.util.ArrayList;  
 import java.util.Iterator;  
 import org.jfree.chart.ChartFactory;  
 import org.jfree.chart.JFreeChart;  
 import org.jfree.chart.plot.PiePlot;  
 import org.jfree.chart.plot.PlotOrientation;  
 import org.jfree.data.category.DefaultCategoryDataset;  
 import org.jfree.data.general.DefaultPieDataset;  
 import java.awt.Color;  
 public class GeradorGrafico {  
   public GeradorGrafico() {  
   }  
   /**  
    * Gera um gráfico de barras 3D Vertical  
    * @param tituloGrafico String, o titulo do gráfico  
    * @param tituloEixoX String, o titulo do eixo X  
    * @param tituloEixoY String, o titulo do eixo Y  
    * @param arrayValores ArrayList, a lista com os valores para o gráfico  
    * @return BufferedImage, a imagem do Gráfico gerada  
    *  
    * A classe DefaultCategoryDataset recebe os valores que irão gerar o gráfico  
    * DefaultCategoryDataset.addValue(Number, Comparable, Comparable)  
    * DefaultCategoryDataset.addValue(Double, Comparable, Comparable)  
    */  
   public static BufferedImage gerarGraficoBarraVertical3D(String tituloGrafico, String  
         tituloEixoX, String tituloEixoY, ArrayList arrayValores) throws Exception {  
     BufferedImage buf = null;  
     try {  
       DefaultCategoryDataset defaultCategoryDataset = new DefaultCategoryDataset();  
       Iterator iterator = arrayValores.iterator();  
       while (iterator.hasNext()) {  
         ModeloGraficoItem modelo = (ModeloGraficoItem) iterator.next();  
         defaultCategoryDataset.addValue(modelo.getQuantidade(),  
                   modelo.getProduto(), modelo.getMes().substring(0, 3));  
       }  
       JFreeChart chart = ChartFactory.createBarChart3D(tituloGrafico, tituloEixoX,  
              tituloEixoY, defaultCategoryDataset, PlotOrientation.VERTICAL,  
              true, false, false);  
       chart.setBorderVisible(true);  
       chart.setBorderPaint(Color.black);  
       buf = chart.createBufferedImage(400, 250);  
     } catch (Exception e) {  
       throw new Exception(e);  
     }  
     return buf;  
   }  
   /**  
    * Gera um gráfico de barras Vertical  
    */  
   public static BufferedImage gerarGraficoBarraVertical(String tituloGrafico, String  
         tituloEixoX, String tituloEixoY, ArrayList arrayValores)throws Exception {  
     BufferedImage buf = null;  
     try {  
       DefaultCategoryDataset defaultCategoryDataset = new DefaultCategoryDataset();  
       Iterator iterator = arrayValores.iterator();  
       while (iterator.hasNext()) {  
         ModeloGraficoItem modelo = (ModeloGraficoItem) iterator.next();  
         defaultCategoryDataset.addValue(modelo.getQuantidade(),  
                   modelo.getProduto(), modelo.getMes().substring(0, 3));  
       }  
       JFreeChart chart = ChartFactory.createBarChart(tituloGrafico, tituloEixoX,  
     tituloEixoY, defaultCategoryDataset, PlotOrientation.VERTICAL, true, false, false);  
       chart.setBorderVisible(true);  
       chart.setBorderPaint(Color.black);  
       buf = chart.createBufferedImage(400, 250);  
     } catch (Exception e) {  
       throw new Exception(e);  
     }  
     return buf;  
   }  
   /**  
    * Gera um Grafico de Linhas  
    */  
   public static BufferedImage gerarGraficoLinha(String tituloGrafico, String tituloEixoX,  
                String tituloEixoY, ArrayList arrayValores) throws Exception {  
     BufferedImage buf = null;  
     try {  
       DefaultCategoryDataset defaultCategoryDataset = new DefaultCategoryDataset();  
       Iterator iterator = arrayValores.iterator();  
       while (iterator.hasNext()) {  
         ModeloGraficoItem modelo = (ModeloGraficoItem) iterator.next();  
         defaultCategoryDataset.addValue(modelo.getQuantidade(),  
                    modelo.getProduto(), modelo.getMes().substring(0, 3));  
       }  
       JFreeChart chart = ChartFactory.createLineChart(tituloGrafico, tituloEixoX,  
                tituloEixoY, defaultCategoryDataset, PlotOrientation.VERTICAL,  
                true, false, false);  
       chart.setBorderVisible(true);  
       chart.setBorderPaint(Color.black);  
       buf = chart.createBufferedImage(400, 250);  
     } catch (Exception e) {  
       throw new Exception(e);  
     }  
     return buf;  
   }  
   /**  
    * Gera um grafico de linhas 3D  
    */  
   public static BufferedImage gerarGraficoLinha3D(String tituloGrafico, String  
         tituloEixoX, String tituloEixoY, ArrayList arrayValores)throws Exception {  
     BufferedImage buf = null;  
     try {  
       DefaultCategoryDataset defaultCategoryDataset = new DefaultCategoryDataset();  
       Iterator iterator = arrayValores.iterator();  
       while (iterator.hasNext()) {  
         ModeloGraficoItem modelo = (ModeloGraficoItem) iterator.next();  
         defaultCategoryDataset.addValue(modelo.getQuantidade(),  
                    modelo.getProduto(), modelo.getMes().substring(0, 3));  
       }  
       JFreeChart chart = ChartFactory.createLineChart3D(tituloGrafico, tituloEixoX,  
                tituloEixoY, defaultCategoryDataset, PlotOrientation.VERTICAL,  
                true, false, false);  
       chart.setBorderVisible(true);  
       chart.setBorderPaint(Color.black);  
       buf = chart.createBufferedImage(400, 250);  
     } catch (Exception e) {  
       throw new Exception(e);  
     }  
     return buf;  
   }  
 }  
Fonte : http://www.devmedia.com.br

SelectOneRadio em linha ou coluna


Ta ai galera .. :D

<h:selectOneRadio layout="pageDirection" /> <%-- Vertical --%>
<h:selectOneRadio layout="lineDirection" /> <%-- Horizontal --%>