Bit Code

Venho a alguns meses desenvolvendo aplicações com grails e extjs, e para ter um ganho de produtividade, decidi criar um plugin de scaffolding no grails para o extjs, então neste post, vou mostrar com criar uma aplicação no grails com este plugin.

• Crie um projeto no grails: grails create-app BookStore

Entre neste ditório, e crie duas classes de domínio:

• grails create-domain-class Book e grails create-domain-class Author

Deixe ambas as classes desta maneira:

class Book {

    String title
    Double price
    Date publicationDate
    Author author
    static constraints = {
        title (nullable:false,maxSize:60 )
        price (nullable:false,maxSize:15 )
        publicationDate (nullable:false)
        author (nullable:false)
    }

    String toString() {
        return "$title" 
    }

}

class Author {

    String name
    String email
    String gender
    static constraints = {
        name (nullable:false,maxSize:60, unique:true )
        email(nullable:false,maxSize:60,email:true )
        gender(inList:["female","male"])
    }

    String toString() {
        return "$name" 
    }

}

• grails install-plugin http://blog.mauros.org/grails-gextjs-0.1.zip
• grails generate-extjs Book
• grails generate-extjs Author
• grails run-app

Abaixo um screenshot de como fica a apliacação:

Além do excelente projeto mantido pelo Urubatan o SpringAnnotation, existe também uma outra forma de configurar o Spring sem os seus terríveis XMLs, o Spring JavaConfig, apesar de não estar utilizando este projeto, e nem penso em usar enquanto o Urubatan estiver dando continuidade no SA. Mas para aqueles que querem ver outra forma de fazer isto, até mesmo para uma comparação entre os projetos, vou aqui mostrar.

A Idea deste projeto é a configuração programática do Spring, onde se tem uma classe principal anotada com @Configuration e métodos anotados com @Bean que retornam seus Beans. Fazendo uma analogia com XML, a classe principal com @Configuration seria o seu XML e os métodos anotados com @Bean seria as TAGs

Vejam um exemplo de uma classe com confguração programática.

 
@Configuration(defaultAutowire = Autowire.BY_NAME, defaultLazy = Lazy.FALSE)
public class ConfigSpring {
 
	@Bean
	public ICommand create() {
		return new CreateCommand();
	}
 
	@Bean
	public ICommand delete() {
		return new DeleteCommand();
	}
 
	@Bean
	public ICommand update() {
		return new UpdateCommand();
	}
 
	@Bean
	public Main main() {
		return new Main();
	}
}
 

E para carregar estes Beans no contexto do Spring, usa-se o código abaixo:

ApplicationContext configContext = new AnnotationApplicationContext(ConfigSpring.class.getName());


Conclusão e Comparatvo com SpringAnnotations

Apesar de este ser um projeto reconhecido pela Interface21, esta muito longe de ter as features que o SpringAnnotations tem, principalmente para JSF.

As anotações do Spring JavaConfig ficam todas numa só classe de configuração, diferentemente do AS, que as anotações estão em cada classe do projeto sendo carregadas automáticamente na carga da aplicação.

Vários usuários de Eclipse convivem constantemente com este erro, eu mesmo estes dias baixei a versão 3.3M6 para ver como anda esta versão, e com algumas horas de uso, após fazer alguns projetos WEB nele, o que me apareceu? Acertaram aqueles que disseram OutOfMemoryException.
A parametrização de memória do Eclipse está num arquivo no diretório de instalação do Eclipse, chamado eclipse.ini, vejam abaixo a configuração default dele:
-vmargs
-Xms40m
-Xmx256m
Estes parâmetros referem-se ao valor inicial e máximo do heap,aumentado-os, já conseguimos um ganho de desempenho no Eclipse, porém, ainda não se resolve nosso erro. A situação que geralmente ocorre este erro é no workbench, isto porque a VM deve ter ultrapassado o valor máximo do permSpace, onde a VM armazena as informações das classes(não são instâncias, mas sim definições de classes). Então vou colocar aqui propostas de configurações para o Eclipse para quem possuem 512M, 1G ou 4G de memória.

-vmargs
-Xms256m
-Xmx256m
-XX:PermSize=64m
-XX:MaxPermSize=64m

-vmargs
-Xms512m
-Xmx512m
-XX:PermSize=128m
-XX:MaxPermSize=128m

-vmargs
-Xms1024m
-Xmx1024m
-XX:PermSize=512m
-XX:MaxPermSize=512m

Uma das coisas legais do Hibernate, é a API Criteria, para quem não tem muita intimidade com Banco de Dados, e precisa em Java extrair informações do banco, o Hibernate torna isto bastante intuitivo com o Criteria, ela mapeia funcionalidades de SQL em Objetos, ou seja pode-se usar uma IDE como o Eclipse para code inserting para montar códigos para buscar e filtrar informações. Vou mostrar aqui alguns exemplos de busca com Criteria.

Para ter a referência da Criteria de uma classe, devemos fazer o seguinte código:

Criteria c = getSession().createCriteria(UmaClasseQualquer.class);


Bom, para seguir com nossos exemplos, vou usar duas classes mapeadas no Hibernate (Estado e Cidade), os códigos delas seguem abaixo:


@Entity
public class Estados {

Agora vamos começar com nossos exemplos, primeiro vou mostrar o mais simples, listar todos estados.


Criteria c = getSession().createCriteria(Estados.class);
List todosEstados = c.list();


Fazer filtros fica bastante intuitivo com Criteria, no exemplo abaixo, vou listar todas as cidades do Estado de São Paulo.


Criteria c = getSession().createCriteria(Cidades.class);
c.add( Restrictions.eq("estado.uf", "SP") );
List cidadesDeSaoPaulo = c.list();


Bom, muitos já devem estar pensando como mostrar estas cidades por ordem crescente do nome, vejam como fica:


Criteria c = getSession().createCriteria(Cidades.class);
c.add( Restrictions.eq("estado.uf", "SP") );
c.addOrder( Order.asc("descricao") );
List cidadesDeSaoPaulo = c.list();


E tem mais... É muito comum em SQL usar-mos GROUP BY, então vou mostrar agora com Criteria uma listagem que soma as quantidades de cidades de cada Estado.


Criteria c = getSession().createCriteria(Cidades.class);
c.createAlias("estado", "est");
c.setProjection(
Projections.projectionList()
.add( Projections.groupProperty("est.uf") )
.add( Projections.groupProperty("est.descricao") )
.add( Projections.rowCount() ,"qtdeCidades" )
);
List totalDeCidades = c.list();


Agora, o que eu acho mais legal no Criteria, é o Example Queries, onde a Criteria vai fazer um filtro a partir dos dados da instância da classe passada para ela, vejam como fica para listar todas as cidades onde o nome inicia com a letra "S":


Cidades cidade = new Cidades();
cidade.setDescricao("S%");

Criteria c = getSession().createCriteria(Cidades.class);
c.add(Example.create(cidade).enableLike());
List cidadesInitS = c.list();


Para quem quiser ver estes exemplos rodando na sua própria máquina, aqui tem o projeto fonte com todos estes exemplos acima. Neste projeto o Hibernate esta configurando para usar o Banco de Dados Derby. E e como não gosto de ficar escrevendo XMLs, fiz uso do Spring Annotations para carregar os Bean do HIbernate no contexto de forma fácil e prática. Então, neste projeto além de aprender Criteria é uma ótima oportunidade nestes exemplos de ver o Spring Annotations com hibernate funcionando como também o Derby.

Vou mostrar aqui como fazer uma aplicação para WEB (Servlet e JSP) com SpringAnnotation, usando o módulo básico. O objetivo deste exemplo é mostrar de uma forma bem simples a configuração e uso do SA (SpringAnnotation) na WEB, para isto vou fazer um formulário para digitar o Nome e Telefone e guardá-los na sessão. Não vou abordar aqui assuntos como, o que é IoC ou para que serve o Spring, vou focar somente no SA.
Para quem ainda não definiu um ambiente para desenvolver para WEB, aqui vai um sugestão.
A primeira coisa que deve ser feita, é o download do módulo básico do SA, vá aqui e faça o download do basemodule.zip, descompacte-o, e jogue os .jar dentro da pasta WEB-INF/lib.
Agora, vamos escrever nossa classe que vai armazenar e gerenciar os contatos digitados no formulário.

public class SessionSave {

}


Vamos agora informar ao SA que esta classe deve ser carregada no contexto do Spring, colocando a annotations @Bean, e que ele dure enquanto existir a sessao com o client, colocando scope=Scope.SESSION


@Bean(name="sessionSave", scope=Scope.SESSION)


No nosso Servlet, vamos ter um método para buscar a classe acima no contexto do Spring.


private SessionSave getSessionSave() {
ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext( getServletContext());
SessionSave sessionSave = (SessionSave) ctx.getBean( "sessionSave" );
return sessionSave;
}


No doPost, vamos ter a rotina que vai receber as informações do formulário, e mandar para a nossa classe que vai guardá-los.

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String nome = request.getParameter("nome");
String fone = request.getParameter("fone");
getSessionSave().addNome(nome, fone);
response.sendRedirect("index.jsp");
}


E no doGet os códigos para listar os contatos digitados

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
PrintWriter pw = response.getWriter();
for (String[] reg:getSessionSave().listAll()) {
pw.print( "Nome: " + reg[0] );
pw.print( " - " );
pw.print( "Telefone: " + reg[1] );
pw.print( "
" );
}
pw.print("Voltar");
}


E abaixo o formulário em JSP








Para finalizar, vamos fazer as alterações necessárias no web.xml e criar o applicationContext.xml
No web.xml precisamos informar as configurações necessárias para o Spring



E aqui o applicationContext.xml que deve ficar no classpath da aplicação


xmlns:aop="http://www.springframework.org/schema/aop" xmlns:sa="http://sannotations.sourceforge.net/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://sannotations.sourceforge.net/context http://sannotations.sourceforge.net/context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"
default-autowire="byName">




Para quem quiser fazer download da aplicação completa, clique aqui

Olá pessoal, pretendo aqui escrever muitas coisas sobre programação, e tecnologia, como dicas e tutoriais, isto nas mais diversas áreas de programação e desenvolvimento, como Java, PHP, Banco de Dados, shell script, etc.

Um Abraço, e até ao próximo post.

Mauro Schneider

Meu nome é Mauro Schneider, iniciei meus estudos em desenvolvimento de software em 1988 com Basic e C, em 1991, comecei então a trabalhar com Clipper e Dataflex, depois Visual Basic e Dephi, e atualmente com Java (JEE e JME). Sou formado em Engenharia da Computação e autodidata em desenvolvimento de software.