Joás Garcia

Grails: Executando métodos apenas em produção usando AOP

Durante o desenvolvimento de uma aplicação Grails surgiu a necessidade de alguns métodos serem executados somente em ambiente de produção. Notei que acabávamos tendo que repetir o mesmo código no início de todo método que gostaríamos que tivesse esse comportamento.

Pesquisei como poderia interceptar um método através de uma anotação customizada. Encontrei algumas soluções, mas a que mais achei interessante foi utilizando Spring AOP. Vamos lá!

1. Crie uma anotação

Crie uma anotação customizada. Se ainda não está familiarizado com anotações esse post vai te ajudar.

package com.joasgarcia.productiononlyannotation

import java.lang.annotation.ElementType
import java.lang.annotation.Retention
import java.lang.annotation.RetentionPolicy
import java.lang.annotation.Target

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface ProductionOnly {

}

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@interface ProductionOnly {

2. Aplique a anotação no método a ser interceptado

Aplique a anotação nos métodos que deseja que sejam executados apenas em produção.

package com.joasgarcia.productiononlyannotation.productiononlyannotation

import com.joasgarcia.productiononlyannotation.ProductionOnly
import grails.transaction.Transactional

@Transactional
class MessageService {

    @ProductionOnly
    public String runProductionOnly(String message) {
        return "OK - ${message}"
    }

    public String alwaysRun() {
        return "OK"
    }
}

9 10	@ProductionOnly public String runProductionOnly(String message) {

3. Crie o interceptador

@Aspect // (1)
class ProductionOnlyInterceptor {

    // (2)
    @Around("@annotation(com.joasgarcia.productiononlyannotation.ProductionOnly)")
    def foo(ProceedingJoinPoint joinPoint) {
        // (3)
        if (!Environment.getCurrent().equals(Environment.PRODUCTION)) return "NOK"

        joinPoint.proceed() // (4)
    }
}

@Aspect // (1)

class ProductionOnlyInterceptor {

// (2)

@Around("@annotation(com.joasgarcia.productiononlyannotation.ProductionOnly)")

def foo(ProceedingJoinPoint joinPoint) {

// (3)

if (!Environment.getCurrent().equals(Environment.PRODUCTION)) return "NOK"

joinPoint.proceed() // (4)

}

(1) Indique que a classe é um aspecto do Spring AOP usando a anotação @Aspect
(2) A anotação @Around indica o tipo de advice utilizado. O Around Advice permite manipularmos o antes e o depois da execução do método interceptado. Essa anotação recebe como argumento um expressão. Chamamos essas expressões de pointcut expressions. No nosso caso a expressão indica que todos os métodos anotados com @ProductionOnly serão interceptados pelo método foo . Veja outros exemplos de pointcut expressions aqui.
(3) Verifica se o atual ambiente não é produção. Em caso verdadeiro não executa o método interceptado.
(4) Se o ambiente for de produção chama-se o método proceed para executar o método interceptado.

4. Registre o bean interceptador

Para tudo funcionar registre o bean no resources.groovy da sua aplicação Grails

import com.joasgarcia.productiononlyannotation.ProductionOnlyInterceptor

beans = {
    productionOnlyInterceptor(ProductionOnlyInterceptor)
}

import com.joasgarcia.productiononlyannotation.ProductionOnlyInterceptor

beans = {

productionOnlyInterceptor(ProductionOnlyInterceptor)

}

5. Teste

Rode a aplicação de exemplo e acesse /message/productionOnly em ambiente de desenvolvimento e depois em ambiente de produção. Você notará que somente em ambiente de produção será renderizado OK indicando que o método interceptado rodou normalmente.

*

Spring AOP é mais uma das cartas na manga que você pode ter enquanto desenvolvedor Grails. Está ai mais um bom motivo para você começar a estudar Spring e entender melhor como funcionam algumas coisas ~~mágicas~~ no Grails. Um material muito bacana é o guia de Spring da itexto. Leia também a documentação oficial do Grails a respeito do Spring.

E ai? Já havia usado Programação Orientada a Aspecto? Deu para provar um pouco do poder desse recurso? Então compartilhe nos comentários outros usos da AOP 😉

Referências:

Simple Aspects using Annotations in Grails

Intercept Grails Service class method calls

10 dicas práticas para ser um desenvolvedor melhor

Ultimamente tenho pensado em como posso me aperfeiçoar como desenvolvedor. O que posso fazer para ser um programador melhor? Resolvi listar algumas dicas que você pode começar a colocar em prática agora mesmo.

#1 Leia livros

Esse é o meu desafio pessoal, mas ler é essencial para adquirirmos novos conhecimentos.

Programa-se para ler todos os dias. A constância te dará uma sensação de progresso e isso te ajudará.

Tenha uma lista de livros que você pretende ler. Defina uma ordem de leitura e comece! Aqui tem uma lista de sugestão

#2 Tenha um blog

Compartilhe suas descobertas num blog pessoal. Além de ser uma ótima forma de marketing pessoal, isso o ajudará a fixar o conhecimento adquirido. Ao escrever você se obrigará a buscar mais embasamento sobre o assunto e isso te permitirá ir mais a fundo.

Desenvolvedores estão acostumados a escrever código e não posts. Confira essas dicas que te ajudarão a escrever de forma ágil.

#3 Participe de eventos de desenvolvedores

Nesses eventos você terá a oportunidade de sentar para programar com outros desenvolvedores. Você irá descobrir novas formas de resolver problemas conhecendo a forma como outros trabalham. Esses eventos não precisam ser necessariamente presenciais. Uma dica legal é o iMasters Planrockr que promove hangouts com várias empresas que compartilham a forma como gerenciam os seus projetos de software.

Encontre grupos de desenvolvedores da sua cidade e participe. Aqui na minha cidade temos alguns como a Comunidade de Artesania de Software de Joinville e o FEMUG-JLLE. Quem sabe em algum desses encontros você possa colocar em prática uma outra dica: Palestrar.

#4 Palestre

Além de escrever, uma ótima ideia é criar uma palestra sobre o assunto. Não espere ser convidado para palestrar em um megaevento. Tente encontrar na sua empresa possibilidades de promover palestras para os membros do seu time.

Na empresa onde trabalho organizamos techlunchs para compartilhar esses conhecimentos através de palestras e para ficar ainda melhor depois aproveitamos para almoçarmos juntos. Como aqui no prédio existem duas empresas de desenvolvimento conseguimos junta-las nesses techlunchs, o que deixa o momento mais enriquecedor.

Palestrar te ajudará a desenvolver capacidades de comunicação essenciais no dia-a-dia do seu time.

#5 Faça cursos online

Creio que ser autodidata é uma qualidade para se diferenciar. Existem ótimos cursos online que vão poder te ajudar a adquirir determinado conhecimento, seja sobre aquela nova tecnologia que você quer aprender ou sobre metodologias de desenvolvimento para aplicar no seu time. Coursera, edX e Udemy oferecem ótimos cursos para o seu desenvolvimento.

#6 Mantenha-se atualizado

Escolher ser desenvolvedor é escolher estar aprendendo constantemente.

Faça uma lista de todos os profissionais, empresas e blogs de software que você admira. Acesse seu Facebook e curta as páginas deles. Acesse seu twitter e passe a segui-los. Isso te ajudará a manter-se atualizado e ter acesso fácil a bons conteúdos.

Através disso você poderá ter recomendações de bons livros para ler, bons cursos para cursar, eventos para participar, novas tecnologias para estudar e etc.

Aqui uma sugestão de lista de quem seguir:

Se pintou um post de interessante que não deu para ler no momento, salve-o no Pocket e leia mais tarde.

#7 Treine sua capacidade de resolver problemas

É hora de praticar! Somos pagos para resolver problemas, por isso precisamos constantemente afiar o nosso machado. Você pode fazer isso resolvendo katas, ferramentas como o Codewars podem te ajudar nisso. O contante treino te ajudará aumentar a performance no seu trabalho, como já diria Uncle Bob:

Fazer seu trabalho diário é performance, e não prática (Uncle Bob)

#8 Aperfeiçoe seu inglês

Está ai um ponto chave para se diferenciar. Provavelmente você escreve seus códigos em inglês (ou pelo menos deveria), e me diga… eles são fáceis de entender? São bem nomeados? Boa parte do nosso tempo passamos dando nome as coisas e somente vamos fazer essa tarefa bem se tivermos o domínio do idioma

Com um bom inglês você poderá consumir conteúdos de alta qualidade que nem todo desenvolvedor tem acesso. Você eliminará uma barreira das literaturas que existem somente em inglês.

Certa vez fui a um evento de Javascript com palestrantes internacionais. No saguão de entrada do auditório os palestrantes ficavam disponíveis para conversar com a galera. Meu amigo conversou com alguns enquanto eu ficava do lado dele com aquela cara de não quem não entende nada. Perdi, uma oportunidade rara 🙁 A partir de então, resolvi que iria estudar inglês.t

#9 Não seja workaholic

Não foque apenas no seu crescimento profissional. Reserve tempo para você e para sua família. Exercite-se, quem sabe seja a hora de você voltar a praticar aquele seu esporte favorito. Tire tempo junto com a sua família. Visite amigos.

O apoio da família, um corpo saudável e bem-estar emocional te ajudarão a ser um profissional mais disposto e criativo.

#10 Planeje-se

Não é o último item por acaso. Talvez você chegue a conclusão que nem todos os itens fazem sentido para você.

Agora anote as que deseja começar a pôr em prática. Planeje-se para ver qual é a melhor forma de incorpora-las à sua rotina. Estabeleça datas e horários, o Google Calendar me ajuda nessa tarefa.

Sendo melhor…

Essa lista não tem a intenção de ser exaustiva, mas creio que algumas dessas dicas você pode começar aplicar agora mesmo. Compartilhe ai como está aplicando algumas elas e também conte outras formas que você usa para ser um programador melhor.

Referências:

Ebook 13 super dicas de como se diferenciar como Dev!

Como aprender mais rápido e melhor: um guia completo!

Livro O Codificador Limpo

Java Annotations na prática

View Code

As anotações são um recurso disponível desde a versão 5 do Java. Tratam-se de metadados que não fazem parte do próprio programa e não tem efeito direto na sua execução. Mas então para quê elas são úteis? Podemos manipula-las em tempo de execução. Veremos como tirar vantagem disso numa situação problema.

Anotações podem ser manipuladas em tempo de execução

O Problema

Imagine a situação onde temos uma entidade chamada Customer e que precisamos registrar o histórico de alterações de determinados campos dessa tabela. Apenas os campos phone e address precisam ter o histórico. Precisaremos saber qual o campo alterado, o seu valor antigo e o seu novo valor.

A Solução

A nossa receita de solução envolve dois ingredientes importantes: anotações e a API Reflection do Java. Essa dupla dinâmica atuará da seguinte maneira: As anotações indicarão quais campos precisam ter o histórico registrado e a API Reflection nos permitirá verificar em tempo de execução a presença ou não dessas anotações nos campos. Mãos ao código!

Criando a anotação

Vamos começar definindo nossa própria anotação. Vamos chama-la de Auditable .

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Auditable {

}

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

@interface Auditable {

}

Olha que interessante, utilizamos anotações para definir a nossa anotação. A anotação Target indica qual elemento do programa a nossa anotação pode ser aplicada. No nosso caso a anotação Auditable será aplicada em campos de classe. A anotação Retention recebendo o parâmetro RetentionPolicy.RUNTIME indica que ela estará disponível para ser acessada em tempo de execução que é o que vamos precisar.

Aplicando a anotação na classe

Com a nossa anotação criada é hora de utiliza-la. Como definimos ela será aplicada em campos da classe. Como queremos que apenas os campos address e phone armazenem seu histórico, colocamos a annotation somente para esses campos.

package com.joasgarcia.auditlog

class Customer {

    String name

    @Auditable
    String phone

    Date birthDate

    @Auditable
    String address

    static constraints = {
        name nullable: false
        birthDate nullable: false
        address nullable: true, blank: false
        phone nullable: true, maxSize: 11
    }
}

7 8	@Auditable String phone

Usando a API Reflection

A API Reflection nos oferece o método isAnnotationPresent . O trecho de código abaixo é auto-explicativo: a instrução retorna verdadeiro se o campo phone é anotado com a anotação Auditable

Customer.getDeclaredField("phone").isAnnotationPresent(Auditable)

1	Customer.getDeclaredField("phone").isAnnotationPresent(Auditable)

Juntando tudo

No nosso método de update vamos utilizar a API Reflection do Java para verificar se os campos alterados possuem precisam armazenar o histórico de alterações.

package com.joasgarcia.auditlog

class CustomerService {

    def customerHistoryService

    public void update(Long customerId, Map params) {
        Customer customer = Customer.get(customerId)

        customer.properties = params

        //#1
        List<Map> listOfUpdatedFields = getUpdatedFields(customer)

        customer.save(flush: true, failOnError: true)

        //#2
        listOfUpdatedFields.removeAll{ !Customer.getDeclaredField(it.fieldName).isAnnotationPresent(Auditable) }

        //#3
        for (Map updatedField : listOfUpdatedFields) {
            customerHistoryService.save(customer, updatedField.fieldName, updatedField.oldValue, updatedField.newValue)
        }
    }

    private List<Map> getUpdatedFields(domainInstance) {
        List listOfUpdatedFields = []

        for (String fieldName : domainInstance.dirtyPropertyNames) {
            listOfUpdatedFields += [
                    fieldName: fieldName,
                    oldValue: domainInstance.getPersistentValue(fieldName).toString(),
                    newValue: domainInstance[fieldName].toString()
            ]
        }

        return listOfUpdatedFields
    }
}

public void update(Long customerId, Map params) {

Customer customer = Customer.get(customerId)

customer.properties = params

//#1

List<Map> listOfUpdatedFields = getUpdatedFields(customer)

customer.save(flush: true, failOnError: true)

//#2

listOfUpdatedFields.removeAll{ !Customer.getDeclaredField(it.fieldName).isAnnotationPresent(Auditable) }

//#3

for (Map updatedField : listOfUpdatedFields) {

customerHistoryService.save(customer, updatedField.fieldName, updatedField.oldValue, updatedField.newValue)

}

(#1) Armazeno uma lista de Map contendo o nome do campo, o valor antigo e o valor novo

(#2) Tirando vantagem do açúcar sintático do Groovy, nós removemos da lista todos os campos que não possuem a anotação.

(#3) Iteramos todos os campos e salvamos o histórico deles na base

Concluindo

Uma outra solução seria ao salvar um novo registro na nossa tabela Customer verificar se o campo alterado precisa ser registrado no histórico. Isso geraria uma implementação com estruturas condicionais que deixariam o código verboso.

As anotações podem nos ajudar a construir soluções elegantes para os nossos problemas do dia-a-dia. Elas também podem ser utilizadas pelo compilador para detectar erros ou por ferramentas para geração de código ou estruturas XML. O Java já possui anotações pré-definidas como o @Test do JUnit, o @Override , o @SuppresWarnings . Frameworks consolidados no desenvolvimento Java como Hibernate e Spring utilizam poderosamente das annotations. Lembra da @Entity do Hibernate?

Referências

https://docs.oracle.com/javase/tutorial/java/annotations/basics.html
http://docs.oracle.com/javase/7/docs/api/java/lang/annotation/Target.html
http://www.caelum.com.br/apostila-java-testes-xml-design-patterns/reflection-e-annotations/#9-5-usando-bem-anotacoes