I’m big fan of JRuby. The Ruby language’s flexibility with the JVM’s power give to us a big weapon to create amazing applications. 

http://www.jruby.org/2013/01/04/jruby-1-7-2.html

Durante esse feriado de natal, estive testando o suporte a JRuby no Google App Engine. Conseguir rodar tanto uma aplicação feita com Sinatra quanto uma feita em Rails 2.3.10. Infelizmente a gem google-appengine ainda não suporta o Rails 3, mas esse suporte já está sendo desenvolvido.

Então pesquisando no Github achei um gist mostrando como gerar uma aplicação com Rails 2.3.10 e DataMapper, infelizmente não funcionou como deveria. Mas ao analisar percebi que o problema era não está incluindo o DataMapper::Resource no model, então fiz um fork do gist e modifiquei, testei e agora tudo está funcionando. Para acessar o gist clique aqui e divirta-se.

Esse é o primeiro post de uma séria voltada para como melhorar o desempenho de seu site/sistema web. Hoje em dia, trabalhar com desenvolvimento web envolve vários fatores. Um deles é o desempenho, desenvolver um sistema/site que tenha uma performance boa também envolve diversos aspectos. Existem algumas extensões para o firefox capaz de testar o desempenho da sua camada de visão, são eles o yslow do Yahoo! e o Page Speed do Google. Ambos tem basicamente as mesmas funcionalidades, que no geral se resume a testar a performance da sua camada de visão e lhe dá dicas de como melhora-las. Ele lhe avisa, por exemplo, quando você tem uma imagem grande e está reduzindo sua visualização no html ou css. Dentre outras coisas, tais como: habilitar a compressão GZIP, diminuir o tamanho dos cookies, habilitar o cache para determinadas áreas/arquivos. Enfim, é uma extensão super simples de usar e que não pode faltar a um Desenvolvedor web.

Um das principais fontes de dúvida para quem está começando a aprender JSF é o componente SelectOneMenu. Basta uma simples garimpada no google e você confirmará isso. Diversas soluções para o uso do SelectOneMenu são indicadas, uma das que mais vejo é utilizar um converter para converter o objeto selecionada na SelectOneMenu no objeto desejado. Porém eu prefiro uma maneira que acho mais simples, que irei mostrar a seguir. No nosso exemplo, terei um objeto do tipo “Classe” que representará uma classe de alunos, cada classe contem um objeto do tipo “Professor”. Ao cadastrar uma classe o usuário deverá selecionar o professor em uma determinada lista. Então vamos lá: Teremos um backing bean chamado ClasseBean que conterá uma objeto do tipo classe.

public class ClasseBean {

    private Classe classe;
    private ClasseDao classeDao;
    private List<SelectItem> listaItem;
    private int professorSelecionado;

public ClasseBean() {
        classe = new Classe();
        classeDao = new ClasseDao();
        listaItem = getLista();
    }

 public List<SelectItem> getLista() {
        ArrayList<SelectItem> lista = new ArrayList<SelectItem>();
	ProfessorDao professorDao = new ProfessorDao();
        List<Professor> resultado = (List<Professor>) professorDao.listAll();

        for (Professor teste : resultado) {
            SelectItem item = new SelectItem(teste.getId(), teste.getNome());
            lista.add(item);
        }
        return lista;
    }

 public String salvar() {

	 ProfessorDao professorDao = new ProfessorDao();
         professor = professorDao.procurar(professorSelecionado);
         this.classe.setProfessor(professor);
         classeDao.salvar(classe);

        classe = new Classe();
        return "listarClasses";
    }

	//métodos getters e setters omitidos

}

<h:selectOneMenu value="#{classeBean.professorSelecionado}">
classeBean.listaItem}">
                            <f:selectItems value="#{classeBean.listaItem}"/>
</h:selectOneMenu>

Esse post faz parte de uma série que estou preparando sobre o hibernate, o primeiro foi sobre a extensão especial Hibernate Spatial e esse segundo irei falar sobre um pouco sobre um poderoso recurso do Hibernate, a API Criteria. Nesse tutorial não irei entrar em detalhes sobre configuração do Hibernate, assume-se que você tem o hibernate pré-configurado, irei apenas falar da API. Primeiro criaremos nossa entidade exemplo “Cliente” :

package modelo;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

/**
 *
 * @author lucas
 */
@Entity
public class Cliente implements Serializable {

    @Id
    @GeneratedValue
    private int id;
    private String nome;
    private int idade;
    private String cpf;
    private double saldo;

    public String getCpf() {
        return cpf;
    }

    public int getIdade() {
        return idade;
    }

    public void setIdade(int idade) {
        this.idade = idade;
    }

    public void setCpf(String cpf) {
        this.cpf = cpf;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public double getSaldo() {
        return saldo;
    }

    public void setSaldo(double saldo) {
        this.saldo = saldo;
    }
}

package util;


import org.hibernate.Session;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.SessionFactory;

/**
 * Hibernate Utility class with a convenient method to get Session object.
 *
 * @author lucas
 */
public class HibernateUtil {
    private static final SessionFactory sessionFactory;

    static {
        try {
            sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static Session getSession() {
        return sessionFactory.openSession();
    }
}

package Dao;

import org.hibernate.Session;
import org.hibernate.Transaction;
import util.HibernateUtil;

/**
 *
 * @author lucas
 */
public class Dao<T> {

    private Class classe;
    private Session session;

    protected Session getSession() {
        return session;
    }


    public Dao(Class classe) {
        this.session = HibernateUtil.getSession();
        this.classe = classe;
    }

    public void salvar(T objeto){
        session.save(objeto);
    }

    public void remover(T objeto){
        Transaction ts = session.beginTransaction();
        session.save(objeto);
        ts.commit();
    }

    public void atualizar(T objeto){
        Transaction ts = session.beginTransaction();
        session.update(objeto);
        ts.commit();
    }

    public T load(long id){
        return (T) session.load(classe, id);
    }
}

package Dao;

import java.util.Collection;
import modelo.Cliente;
import org.hibernate.Criteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;

/**
 *
 * @author lucas
 */
public class ClienteDao extends Dao<Cliente> {


    public ClienteDao(){
        super(Cliente.class);
    }

    public Collection<Cliente> buscaPorNome(String nome){
        Criteria c = getSession().createCriteria(Cliente.class);
        c.add(Restrictions.ilike("nome", nome));
        c.addOrder(Order.asc("idade"));
        return c.list();
    }

    public int qtdeTotalCliente(){
        Criteria c = getSession().createCriteria(Cliente.class);
        c.setProjection(Projections.rowCount());
        return (Integer) c.uniqueResult();
    }

    public int totalSaldo(){
        Criteria c = getSession().createCriteria(Cliente.class);
        c.setProjection(Projections.sum("saldo"));
        return (Integer) c.uniqueResult();
    }
}

Esse tutorial tem como objetivo fazer uma introdução ao uso do Hibernate Spatial juntamente com o banco de dados postgresql e a extensão espacial postgis. Nesse exemplo estarei utilizando o netbeans 6.8. Para começar, crie um projeto Java no netbeans, clique com o botão direito sobre o projeto e adicione as bibliotecas do “Hibernate” e “Hibernate JPA” ambas disponíveis no netbeans. Você também irá precisar das seguintes bibliotecas:

• JTS-1.8.jar
• Hibernate-Spatial-1.0-M2.jar
• Hibernate-Spatial-postgis-1.0-M2.jar
• postgis-1.5.0SVN.jar
• postgresql-8.4-701.jdbc3.jar

Excelente video tutorial feito pela própria equipe do GeoServer para quem está começando. Mostra como configurar o GeoServer para trabalhar com os Shapefile.

Introdução ao GeoServer

O Hibernate Spatial é uma extensão do famoso framework de persistência Hibernate. Ele faz o mapeamento objeto relacional de tipos de dados geográficos. Para quem trabalha com desenvolvimento de SIG é uma excelente idéia dá uma conferida.
Ele suporta a maioria das funções da OGC (Open Geospatial Consortium) além de suportar também os SGBD Oracle 10g/11g, Postgresql/Postgis, and MySQL.

O site oficial é http://www.hibernatespatial.org/ e para quem trabalha com a plataforma .NET NHibernate

Uma coisa que sempre gosto de fazer quando estou programando usando JSF, é criar uma classe mensageira para facilitar o trabalho com mensagens (de erro, informação e etc..).

Essa classe, me livra do trabalho de:

• Obter repetidamente o FacesContext.
• Criar repetidamente o objeto FacesMessage.
• Escrever repetidamente as mensagens.

1. Primeiro nós temos o objeto estático ResourceBundle que utilizaremos para efetuar as buscas das mensagens através dos valores passado no arquivo messages.properties. Repare que eu passo o nome do arquivo sem a extensão .properties e a localização dele, no nosso caso utilizamos o método getViewRoot do FacesContext para obter a localização. O interessante é que todas essas mensagens possuem suporte a internacionalização, você pode definir dentro do messages.properties mensagens personalizadas para cada locale, por isso utilizamos o método getLocale.
2. Os métodos: infoMsg e errorMsg são os responsáveis pelas mensagens, recebem como parâmetro uma string, que será utilizada como chave para encontrar o valor da mensagem.
3. Na linha seguinte ele faz com que a variável ‘msg’ que antes possuía a chave receba como valor a própria mensagem que é buscada através do método getString do objeto ResourceBundle.
4. Nas próximas linhas não tem muito o que explicar, crio o objeto FacesMessage com a mensagem conseguida anteriormente, obtenho a instancia do FacesContext e adiciona a mensagem.
5. E fim, você está pronta p usar o seu mensageiro.

Se é boato ou verdade eu não sei, o fato é: o rails vem crescendo de maneira assustadora e é claro que grandes empresas como RedHat, SUN e etc… não iam ficar de fora disso.

Não é atoa que em 2006 a SUN contratou o Charles Nutter e Tom Enebo para colocar pra frente o projeto JRuby, o que deve permitir codigos Ruby serem executados na JVM.

Agora é esperar para ver.

Fonte:

http://blog.seatecnologia.com.br/articles/2008/10/20/jboss-on-rails