Grails: do Groovy à Web – Terceiro artigo publicado na Java Magazine 77

Acabou de sair a edição digital (a versão impressa deve estar para ser liberada nos próximos dias) da Java Magazine 77 na qual o meu terceiro artigo da série “Grails: do Groovy à Web” foi publicado.

Desta vez, o foco é a camada de controle do Grails. Veremos como funciona o mecanismo de requisições adotado pelo framework. Aguardo o retorno de vocês.

O próximo artigo, a ser publicado na edição de número 78 é sobre GORM, aonde exponho as entranhas do mecanismo de persistência do Grails.

Aguardo o feedback de vocês!

Grails é inegavelmente bonito

Hoje dei manutenção em um antigo projeto feito em JSF. Ao alterar o meu arquvo jsp para expor a data no formato que eu precisava, precisei escrever algo assim:

<h:outputText value="#{bean.data}">
     <f:convertDateTime pattern="dd/MM/yyyy"/>
 </h:outputText>

Ô saudade do Grails, aonde eu só preciso escrever:

<g:dateFormat date="${bean.data}" format="dd/MM/yyyy"/>

Divulgando os brasileiros que trabalham com Grails

Recentemente iniciei um novo projeto no Grails Brasil: o {Blogs}. Trata-se de um agregador de blogs escritos por brasileiros (ou em português) que trabalhem com Grails e curtem compartilhar suas experiências neste processo.

A razão de ter iniciado o projeto é simples: há profissionais excelentes no Brasil trabalhando com Grails, pessoas que ajudam demais a comunidade (seja em fórums ou publicando material em seus blogs) e cujo trabalho deve ser o mais divulgado possível, visto que são profissionais raros!

Além disto, é também um incentivo para que mais material seja publicado em português, tornando assim ainda mais conhecido o nosso framework favorito. Acredito que iniciativas como estas criam um ciclo que beneficia a todos: quem publica material o tem divulgado, e quem está aprendendo é incentivado a também escrever a respeito para que seja valorizado.

Infelizmente (ou seria felizmente?) este projeto não será bem sucedido se for executado por apenas uma entidade (itexto): sendo assim, gostaria de lhes pedir que me ajudassem de uma das formas abaixo:

  • Possui um blog? Cadastre-o no Grails Brasil {Blogs}!
  • Curte twitter? “Tuite” a respeito!
  • Não gostou de algo no Grails Brasil {Blogs}? Meta o ferro! Envie-me um e-mail dizendo o que pode ser melhorado e eu o farei o mais rápido possível: kicolobo@itexto.net (se quiser pode comentar neste post também)
  • Fale para os seus amigos a respeito
  • E se quiser apoiar de outra forma, mande-me a sua idéia por e-mail!

Confesso estar bastante animado com o projeto, pois conheci alguns blogs que ainda não conhecia e tive a oportunidade de ler alguns posts que havia deixado escapar, e espero que a ferramenta lhe seja útil também.

Ah, e o endereço do site? http://blogs.grailsbrasil.com

PS: não é brasileiro mas escreve/lê em português? Seja bem vindo!

Não quer acessar o site toda hora? Tudo bem: assine o feed :)

Grails: detalhes pouco conhecidos dos ambientes de execução (environments)

Um dos recursos mais bacanas do Grails é a possibilidade de se possuir mais de um ambiente de execução (environment). A grosso modo, pode-se dizer que o environment representa uma configuração específica de banco de dados usada em determinada situação. Neste post não irei explicar como configurar seu acesso às suas bases de dados, mas sim alguns pontos pouco divulgados a respeito deste recurso.

Você pode ter quantos ambientes quiser!

Por padrão Grails nos fornece três ambientes: test, development e production que, respectivamente, são usados quando executamos nossos testes unitários/de integração, estamos programando e, finalmente, enviamos para o servidor de aplicações no qual o produto final do nosso trabalho será usado. O que poucos sabem é que na realidade podemos ter quantos ambientes de execução quisermos!

Para adicionar um novo ambiente de execução, basta adicionar mais um bloco de código dentro da seção environments como no exemplo abaixo:

environments {
	development {
		dataSource {
			dbCreate = "update" // one of 'create', 'create-drop','update'
			url = "jdbc:mysql://localhost/development"
		}
	}
	test {
		dataSource {
			dbCreate = "update" // one of 'create', 'create-drop','update'
			url = "jdbc:mysql://localhost/test"
		}
	}
	production {
		dataSource {
			dbCreate = "update" // one of 'create', 'create-drop','update'
			url = "jdbc:mysql://localhost/production"
		}
	}
       meu_ambiente {
               dataSource {
                      dbCreate = "update"
                      url = "jdbc:mysql://localhost/meu_BD_Louco"
                }
       }
}

Para usar estes ambientes de execução adicionais na linha de comando, basta usar a sintaxe abaixo:

grails [nome do ambiente] [comando]
Exemplo:
grails meu_ambiente run-app

Simples assim.

Descobrir qual o ambiente escolhido em tempo de execução

Grails só permite que um ambiente seja usado por vez. Sendo assim, esta é uma informação importante que podemos usar a nosso favor quando estamos programando. Suponhamos que seja interessante habilitar comportamentos apenas em alguns ambientes de execução. Como você faria? Assim:

import grails.util.Environmentswitch(Environment.current) {
	case Environment.DEVELOPMENT:
	  "Apenas para desenvolvimento"
	break
	case Environment.PRODUCTION:
	   "Apenas para proução"
	break
        case "meu_environment"
            "Olha o meu environment aqui!"
        break

}

Environments na inicialização da aplicação

No arquivo grails-app/conf/Bootstrap.groovy incluimos o código que desejamos ser executado quando nossa aplicação é inicializada. Como tirar proveito dos ambientes de execução nesta situação? De novo, como no código abaixo:

def init = { ServletContext ctx ->
        environments {
            production {
                // em produção
            }
            development {
              // em desenvolvimento
            }
        }
        ctx.setAttribute("foo", "bar")
}

Como instalar o Apache Cassandra

Recentemente enfrentei alguns problemas ao tentar instalar o Apache Cassandra. Como o getting started do projeto não me ajudou muito, aqui segue um guia rápido sobre como instalar o bichinho no seu computador/servidor.

1. Faça o download da última versão no site oficial: http://incubator.apache.org/cassandra/

2. Verifique os seus requisitos de sistema.

Como o Cassandra é feito em Java, o ideal é que você tenha a última versão do JRE instalado na sua máquina. No meu caso, usei o JDK 1.6.0_18. Caso você tenha no seu computador tanto o JDK quanto o JRE convencional instalado, recomendo que você defina a sua variável JAVA_HOME apontando para o diretório do JDK – ainda não está claro na documentação do Cassandra se o JDK é obrigatório.

3. Descompacte o conteúdo do arquivo baixado em um diretório de sua escolha

4. Crie uma variável de ambiente chamada CASSANDRA_HOME que aponte para o seu diretório de instalação do Cassandra

5. Edite o arquivo storage-conf.xml, que se encontra em CASSANDRA_HOME/conf

Neste arquivo encontram-se pré-configurados os diretórios nos quais o Cassandra irá armazenar os seus dados. O problema é que muito provávelmente estes diretórios não existem ainda no seu computador. Procure pelas tags CommitLogDirectory (que armazena o log de commits do Cassandra), DataFileDirectories (aonde seus dados serão armazenados), CalloutLocation e StagingFileDirectory

Como você verá, eles estão configurados para diretórios do tipo /var/cassandra, ou seja, já vieram pré-configurados para Linux. Se você está usando Windows, com certeza o Cassandra não irá funcionar de cara.

Há dois caminhos para solucionar o problema: Você pode criar a estrutura de diretórios exposta por estas tags ou simplesmente editá-las definindo aonde suas informações deverão ser armazenadas.

Feito isto o Cassandra executará perfeitamente no seu computador.

PS: bem que podia haver um instalador hein? Hmm…. (estalo na cabeça) :)

Grails Brasil {Blogs}

Este é um post bem rápido só para contar sobre o novo projeto da itexto: o Grails Brasil {Blogs}, que será o agregador de blogs da comunidade Grails Brasileira (e de língua portuguesa).
Os interessados em participarem do projeto (seja na codificação do crawler, seja divulgando seu blog) devem ler o post de lançamento no site [...]

Grails: lista de recursos

De tempos em tempos alguém me pergunta aonde é possível aprender mais sobre Grails. Como basicamente sempre envio a mesma resposta – e o número destes e-mails tem crescido considerávelmente – acho que é uma boa idéia postar aqui uma pequena lista de sites/autores relacionados ao assunto para que vocês possam se aprofundar mais no [...]

Pascal e o nerd tiraninho

E não é que Pascal, no século XVII, ao expor o seu conceito de tirania sem querer descreve os nerds tiraninhos que implicam com todos aqueles que usam tecnologias diferentes das suas favoritas em pleno século XXI?
A definição é feita no fragmento 58 da sua obra inacabada “Pensées” (em português “Pensamentos”). Segue o fragmento:
“A tirania [...]

Segundo artigo da série “Grails: do Groovy à Web” publicado na Java Magazine

Meu segundo artigo da série “Grails: do Groovy à Web” acaba de ser publicado na edição digital da Revista Java Magazine, o que quer dizer que a versão impressa já deve (provávelmente já está) estar sendo distribuida neste momento.
Continuando a nossa jornada, desta vez exponho uma visão panorâmica do framework. Será apresentado o projeto que [...]

Off:como transformar o seu Macbook em um adaptador wireless para Xbox 360

Enquanto digito este post meu XBox 360 está baixando atualizações da Internet. Tudo normal se não fosse por um pequeno detalhe: meu “adaptador wireless” para o Xbox é o meu Macbook. Se você não quer gstar uma fortuna naqueles adaptadores, pode usar o seu notebook para este fim. Acredito que com algumas pequenas alterações o [...]

Get Adobe Flash playerPlugin by wpburn.com wordpress themes