Vamos falar de Padrões NoSQL [Q&A]

duke-diana-min

Com a evolução da tecnologia da persistência, termo como “persistência poliglota” vem se tornando cada vez mais comum para o vocábulo do desenvolvedor. Atualmente, não basta utilizar a linguagem de programação mais apropriada para o problema, mas também utilizar o melhor banco e a melhor forma de persistir tais informações. Uma boa escolha trará certamente uma facilidade na leitura, elasticidade além de performance tanto na leitura quanto na escrita, isso variará de acordo com o objetivo e interesse de cada programa. Com isso, nem todas as aplicações utilizam ou utilizarão as soluções clássicas para persistência, os bancos relacionais. Os bancos NoSQL se tornaram uma solução muito comum para isso. O objetivo desse artigo é esclarecer algumas sobre o mais recente projeto criado, o JNoSQL, dúvidas com relação aos próximos passos dos bancos NoSQL focando na linguagem mais utilizada no mundo, Java, no formato de perguntas e respostas.

Para os detalhes iniciais como definição, já realizei um post sobre isso:

https://otaviojava.wordpress.com/2016/09/10/nosql-java/

O que é o JNoSQL?

O projeto JNoSQL é um projeto que visa a criação de ferramentas para o desenvolvimento de bancos não relacionais, os NoSQL, seu foco será padronizar os bancos NoSQL olhando para sua diversidade, ou seja, criando mecanismo para que o mesmo seja extensivo. Para facilitar o desenvolvimento dessa ferramenta foram criadas duas camadas abaixo do JNoSQL:

A camada de comunicação (aka Diana): Essa camada é responsável por realizar a comunicação entre a aplicação Java e o banco de dados. Essa API será dividida em quatro partes, uma para cada tipo de banco NoSQL. Ele será semelhante ao JDBC do mundo relacional.

A camada de abstração (aka Artemis): semelhante ao ORM ele é responsável por facilitar a abstração para o desenvolvedor Java, ela será orientada a anotações e realizará integrações com outras tecnologias como, por exemplo, o bean validation. O seu coração será o CDI.

Essa divisão tem algumas vantagens:

  • Divisão de problemas (Assim, os bancos de dados darão atenção apenas a camada de comunicação enquanto desenvolvedores de framework darão atenção numa camada superior.
  • Facilidade na implementação, uma vez um novo banco de dados interessado em implementar a API do JNoSQL será necessário apenas implementar a API de comunicação não se preocupando com as outras camadas.
  • Facilidade em componentização, com essa estratégia será possível trocar um dos dois componentes sem que necessariamente exista impacto no outro lado.

Vamos padronizar?

Sim, a ideia é que o resultado do trabalho dentro do JNoSQL seja o foco de padronização. Inicialmente, apenas a camada de comunicação será levada como uma JSR. Esse é um dos motivos que esse projeto tem como parcerias diversos provedores de banco de dados, por exemplo, Cassandra, Hazelcast, OrientDB, couchbase, ArangoDB, MongoDB, HBase além da participação da comunidade (SouJava, LondoJC, ThinkerPOP, dentre outros).

É possível padronizar 100%?

Mesmo os bancos relacionais que já estão a décadas no mercado, não é possível padronizar todo o processo. O mesmo acontece com os bancos NoSQL, inicialmente serão padronizadas as entidades, as hierarquias e algumas ações. Existirão quatro tipos de API, detalhado anteriormente. Mesmo com bancos de dados do mesmo tipo, por exemplo família de coluna com Cassandra e o hbase, existem comportamentos diferentes, por exemplo o nível de consistência e o Cassandra Query Language que existem apenas no Cassandra, para isso a API deverá fornecer a extensibilidade para que seja possível realizar tal operação, no entanto, mesmo com esses comportamentos diferentes o Cassandra continuará lidando as mesmas entidades que o Hbase (Família de Colunas, Colunas, chave da família de coluna, etc.). Por exemplo:

//both implementations (Hbase and Cassandra)
ColumnFamilyEntity entity = …/
entityManager.save(entity);
//just on Cassandra
cassandraEntityManager.save(entity, ConsistencyLevel.ALL);
List entities = entityManager.cql(¨select * from entity¨);

Existirão casos também na qual a API retornará uma exceção de operação não suportada, caso o banco de dados não suporte algumas operações.

Quais métodos serão padronizados?

Nessa primeira versão o foco será padronizar apenas os modelos além de métodos de operação básicas, são eles:

  • Inserir de maneira síncrona, assíncrona, assíncrona com calback além do uso de TTL
  • Atualizar de maneira síncrona, assíncrona, assíncrona com calback além do uso de TTL
  • Deletar de maneira síncrona, assíncrona, assíncrona com calback além do uso de TTL
  • Realizar queries de maneira síncrona e assíncrona

Ou seja, inicialmente as APIs conseguirão realizar as operações de CRUD.

A única exceção será a API de grafos, na verdade, o modelo de grafos já existe uma padronização já conhecida: o ThinkerPOP. A ideia é que a API contenha as partes mais estáveis desse projeto e sua implementação de referência seja uma simples adapter entre os projetos, em outras palavras, todos os bancos que suportam o ThinkerPOP, automaticamente suportarão o Diana.

Mesmo sem padronizar tudo ainda vale a pena?

Nós acreditamos, que sim! Será necessário realizar o primeiro passo e o JNoSQL realizará esse passo. Utilizaremos a estratégia incremental, ou seja, serão dados pequenos passos e pequenos releases para que recebemos rápidos feedbacks sobre a API.

O que acontece com um banco de dados que suporta dois tipos de bancos de dados?

Ele terá que implementar uma API para cada banco de dados que ele suporte. A ideia também é que existe um TCK, que terá como objetivo verificar se a banco de dados suporta ou não corretamente essa API.

Qual é o seu atual status?

O projeto foi recentemente aceito para Eclipse Foundation e estamos recebendo alguns feedbacks sobre a API. Também foi realizada uma apresentação do projeto para o JCP no F2F em Londres: https://goo.gl/2pKwrd

Como faço para ajudar?

Atualmente existem diversas maneiras de ajudar o projeto:

  • Documentação
  • Revisar a documentação já existente
  • Feedback na API
  • Encontrar bugs na implementação
  • Implementar novos drivers
  • Criar exemplos
  • Ajudar na tradução do material para o seu idioma
  • Realizar a palestra sobre esse projeto no seu JUG.

Quais referências estou utilizando?

Estamos utilizando como base diversos projetos existentes, inclusive, além da nomeclatura. Sempre que possível utilizaremos a mesma nomenclatura já existente em outras especificações para facilitar o aprendizado dos desenvolvedores Java.

MicroProfile 1.0

micro-profile-logo

O termo microsserviço, no mundo do desenvolvimento de software, se tornou um termo muito popular. Assim, diversos artigos e diversas ferramentas vem surgindo relacionado a esse tópico. No mundo Java, o Spring vem discutindo sobre esse tópico principalmente após a versão 4.0 e o Spring Boot. Porém, essa é a única solução existente? A resposta é não, recentemente foi lançado uma nova ferramenta no mundo Java, o MicroProfile, e esse foi um dos tópicos mais comentados no JavaOne 2016.

Existem diversos termos e pontos de vista em relação ao o que significa microsserviço. Segundo o Henrique Lobo o microsserviço é: mais uma solução para o problema do alto acoplamento em aplicações corporativas. A diferença é que desta vez estamos atacando aplicações monolíticas.

Ou seja, de uma maneira geral o microsserviço é o oposto de uma arquitetura monolítica, que visualiza a aplicação como um único componente. Uma vez que o componente é a menor unidade dentro do software que pode ser substituída de forma independente. A arquitetura monolítica trabalha numa aplicação com um único componente, ou seja, em termo de escalabilidade caso seja necessário crescer a aplicação, é necessário criar uma instância de todo o componente. Porém, sua arquitetura é mais simples, um grande desafio do microsserviço é separar a aplicação em uma menor unidade, uma separação errônea significa um grande desastre na vida de uma aplicação.

Uma vez conseguindo separar um software em menor componentes ou serviços (o serviço seria um tipo de componente especial que realiza a comunicação utilizando mecanismo remoto como webservice). O microsserviço tem algumas vantagens:

  • Consegue entregar novos recursos mais rapidamente, uma vez que apenas o componente que foi alterado precisará ser atualizado.
  • Com componentes menores, os times também podem ser, seguindo o estilo e a metodologia ágil.
  • A escalabilidade se torna mais simples, no caso, caso o serviço A precise escalar, é necessário apensar que tenha mais uma instância desse recurso A.

Uma vez definido, rapidamente, os conceitos ao redor de aplicações de microsserviços, aplicações monolíticas, componentes, etc. O próximo passo desse post é falar um pouco sobre a iniciativa do MicroProfile.


Q&A MicroProfile

O que é Microprofile?

O Microprofile é uma iniciativa formada por alguns fornecedores Java EE (Red Hat, Payara, Tomitribe, IBM) e Java User Groups (SouJava e London Java Community) cujo o principal objetivo é trazer inovações do microsserviços ao redor ou próximo do mundo Java EE. Atualmente, os servidores, com o comportamento lazy, e as tecnologias elas estão prontas para aplicações de microsserviços, porém, a ideia é tornar a experiência ainda melhor.

microprofile-logos

O seu propósito é bastante simples:

  • Ser um ambiente simples para iterar, testar, inovar e principalmente falhar rapidamente.
  • Após testes, experiência chegar em um comum acordo entre todos.
  • Uma vez, nesse comum acordo e um código estável o próximo passo, e o último, é o processo de padronização.

micro-profile-process

E o Java EE?

O Java EE continua sendo uma série de especificações ou guarda-chuva de especificações bem definidas cujo o foco principal são aplicações focadas ao mundo Web. O Java EE em sua sexta versão trouxe um grande número de novidades, principalmente com o CDI, e sua versão atual, a sétima versão, trouxe ainda mais novidades e melhorias nos recursos existentes.

A próxima versão está sendo trabalhada sob a JSR 366 no qual o líder da especificação é a Oracle.

microprofile-java-ee-road-map

MicroProfile é Java EE?

Não, apesar do envolvimento de diversos fornecedores do mundo Java EE o MicroProfile não é e não tem nada relacionado com o mundo Java EE. Como foi dito previamente, a Oracle é a líder da especificação do Java EE e detentora da sua propriedade intelectual, assim apenas ela pode definir o que é Java EE ou não. Da mesma forma que o CDI a Red Hat é líder da especificação. O fato do MicroProfile utilizar algumas especificações do mundo Java EE não o remete a um proflie do Java EE, do contrário, uma vez que o Spring suporte algumas especificações ele também o seria.

JCP e MicroProfile?

Apesar da exaustiva tentativa de comprar o JCP com todos e qualquer movimento Java, são movimentos totalmente diferentes. O JCP é focado em padrão e o MicroProfile a ideia é que seja um local para inovação. Inovação é o primeiro passo para um padrão, é necessário testar, experimentar e caso seja um sucesso padronizar. Afinal, como padronizar algo que não existe ainda? Faria sentido padronizar a internet na idade média?

Essa resposta também é válida para os framworks do Spring, o JCP não tem nenhuma posição contra o Spring, afinal, eles são muito importantes dando esse primeiro passo, a inovação. Inclusive vários membros do mundo Spring participaram e participam das JSRs, especificação Java, é o caso da JSR 330 que teve a participação do Rod Johnson, conhecido mundialmente como o pai do Spring.

Uma informação importante é que boa parte das instituições que começaram o MicroProfile faz parte do Comitê executivo do JCP.

A ideia do MicroProfile é ser um subset do Java EE?

Não. Como foi dito previamente, o Java EE é uma umbrela de especificação, ou seja, algo estável e fora do mundo de inovação. Além do problema de apenas a Oracle como Spec Leader definir o que é Java EE ou não. Por exemplo, umas das ideias é que nas próximas versões do MicroProfile o Jcache, JSR 107, fazer parte do MicroProfile e essa especificação não está presente no full profile do Java EE 7 e nem se tem previsão de se adicionar essa especificação na próxima versão do Java EE.

JCP + Microprofile

Uma vez bem detalhado os papéis de cada organização/iniciativa, uma para padrão e outro para inovação. Ambos tem algo em comum: O feedback contínuo da comunidade.

O último passo do processo do Microprofile é definir padrões e nesse passo será um trabalho em conjunto com o JCP. Vale lembrar que o padrão traz algumas vantagens:

  • A escolha do fornecedor e/ou escolha da implementação
  • Portabilidade da aplicação
  • Retrocompatibilidade
  • Uma vez estável, reduz o risco do projeto

MicroProfile 1.0

Lançado na proximidade do JavaOne 2016 a versão 1.0 do microprofile vem com três recursos:

  • JAX-RS: Java API for RESTful Web Services (JAX-RS) uma API especificada que traz suporte para a criação de serviços REST.
  • CDI: Contexts and Dependency Injection ferramente especificada para injeção de dependência com contexto.
  • JSON-P: Uma API especificada para realizar parse, gerar, transformar e buscar JSON.

Próximos passos

roadmap-microprofile

Uma vez lançada a sua primeira versão os próximos passos estão em mover para uma fundação e o trabalho para a versão 1.1 do MicroProfile. A ideia original é que seja lançado uma versão a cada seis meses. O backlog para as próximas versões está vasto.

  • Container API
  • Microservic-y annotations (Ex: @CircuitBreaker)
  • Testing
  • Distributed Logging
  • Distributed Tracing
  • OAuth2/OpenID Connect
  • Microservice Security
  • Service Discovery
  • Health Check
  • Configuration
  • Metrics/Monitoring
  • WebSockets
  • JSON-B
  • Bean Validation
  • JPA
  • JTA
  • Concurrency Utilities for Java EE
  • Messaging / Eventing
  • Asynchronous/Reactive Support / Patterns
  • Integration with Reactive / Eventing systems
  • Big Data/NoSQL strong & weak consistency support
  • NetFlix OSS Integration
  • JCache
  • JDK 8 Lambda+Streams
  • EJB Lite
  • Servlets
  • HTTP/2
  • Startup Time
  • Disk Space
  • Memory
  • Uber-jar
  • Java 9 Modularity

JCP é lento em relação ao MicroProfile

Tal comparação não faz sentido algum! Como foi explicado, previamente, são organizações de propósito totalmente diferente. Comparar o JCP só faz sentido se for para outro órgão de padronização como o W3C com o HTML 5, começou o seu trabalho em 2004 e até o presente momento nenhum navegador dá suporte total ao Html 5.

Show me the Code

Dentro do organization do github do microprofile existe alguns exemplos de código o mais recente foi o exemplo utilizado no JavaOne, o microprofile-conference. Porém, também será criado uma simples aplicação demo utilizando microprofile, cujo a implementação será o tomee e maven.

Essa aplicação será realmente simples:

Será um serviço de votos, basicamente, dado uma pergunta a API permitirá uma resposta com sim ou não, sim será algo bem simples já que o principal objetivo é criar um simples serviço.

O primeiro passo é a criação do contador de voto, basicamente ele terá um contador para sim e outro para não, esse recurso terá único para toda aplicação, ou seja, um escopo de aplicação.

@ApplicationScoped
public class VoteCounter {

private final AtomicInteger yes = new AtomicInteger();

private final AtomicInteger no = new AtomicInteger();

public void voteYes() {
yes.incrementAndGet();
}

public void voteNo() {
no.incrementAndGet();
}

public Map<String, Integer> getResult() {
Map<String, Integer> votes = new HashMap<>();
votes.put("yes", yes.get());
votes.put("no", no.get());
return votes;
}
}

Após criar o contador o próximo passo é criar a API para exibir esse recurso.

@ApplicationScoped
@Path("votes")
@Produces(MediaType.APPLICATION_JSON)
public class VoteResource {

@Inject
private VoteCounter voteCounter;

@GET
@Path("question")
public String getQuestion() {
return "Did you like the post?";
}

@POST
@Path("/yes")
public void voteYes() {
voteCounter.voteYes();
}

@POST
@Path("/no")
public void voteNo() {
voteCounter.voteNo();
}

@GET
public Map<String, Integer> getResult() {
return voteCounter.getResult();
}
}

Após feito o código, o próximo passo são os códigos de configuração. Com o JAXRS, definir o caminho que serve como base de todos os URI.

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;

@ApplicationPath("/resource")
public class ApplicationConfiguration extends Application {
}

Também tem as configurações do web descriptor e do beans.xml para o CDI. Até o momento nada diferente tanto em código quanto em configuração que o desenvolvedor Java EE conhece.

Olhando para o arquivo de configuração do maven, o pom.xml, além de definir a API do Java EE 7 como provida é adicionado um plugin para o tomee:

  • O parâmetro tomeeClassifier define o profile do tomee que será selecionado. Os tipos disponíveis são: webprofile, plus, plusme
  • O parâmetro context define o nome do contexto.

 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.soujava</groupId>
    <artifactId>microprofile-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>microprofile-demo</name>

    <url>https://soujava.org.br/</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.ee.version>7.0</java.ee.version>
        <java.se.version>1.8</java.se.version>
        <version.tomee>7.0.1</version.tomee>
        <version.jackson>2.8.2</version.jackson>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>${java.ee.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${version.jackson}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.jaxrs</groupId>
            <artifactId>jackson-jaxrs-json-provider</artifactId>
            <version>${version.jackson}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>${java.se.version}</source>
                    <target>${java.se.version}</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.0.0</version>
            </plugin>
            <plugin>
                <groupId>org.apache.tomee.maven</groupId>
                <artifactId>tomee-maven-plugin</artifactId>
                <version>${version.tomee}</version>
                <configuration>
                    <tomeeClassifier>webprofile</tomeeClassifier>
                    <context>${project.artifactId}</context>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

 

Feito isso basta empacotar e em seguida executar o exemplo com os seguintes comandos:

  • mvn clean package tomee:exec -DskipTests
  • java -jar target/microprofile-demo-1.0-SNAPSHOT-exec.jar

Com isso temos os seguintes recursos:

 

Assim, concluímos o material sobre essa novidade para o mundo dos frameworks para microsserviços.

Referências:

O que é arquitetura baseada em micro serviços?

http://www.itexto.net/devkico/?p=1755

Microservices for Java Developers: A Hands-On Introduction to Frameworks and Containers.: http://developers.redhat.com/promotions/microservices-for-java-developers/
Arquitetura de microserviços ou monolítica?

http://blog.caelum.com.br/arquitetura-de-microservicos-ou-monolitica/

Microservices

http://martinfowler.com/articles/microservices.html

Java EE 7 spec:

https://java.net/downloads/javaee-spec/WebProfile.pdf

MicroProfile Site:

http://microprofile.io/

Código exemplo:

https://github.com/soujava/microprofile-demo

Vamos de falar de padrões para o NoSQL em Java

duke-diana

JNoSQL Project

Os bancos NoSQL são bancos de dados que realizam operação de inserção e recuperação de dados utilizando outro modelo que não seja o relacional. Esses tipos de bancos se caracterizam pela velocidade e alta taxa de escalabilidade e vem sendo utilizado com maior frequência em diversos tipos de aplicações, inclusive, aplicações para as instituições financeiras. Como consequência, cresce também o número de vendors ou distribuidores para esse tipo de banco de dados.

Os bancos de dados NOSQL são definidos basicamente pelo seu modelo de armazenamento que são cinco:

Chave-valor: Possui uma estrutura muito semelhante à do java.util.Map, onde podemos armazenar uma chave e seu valor. Normalmente esse valor pode ser qualquer informação.

  • AmazonDynamo
  • AmazonS3
  • Redis
  • Scalaris
  • Voldemort

Orientado a documentos: Este modelo permite armazenar qualquer documento, sem ter a necessidade de definir previamente sua estrutura. O documento e composto por inúmeros campos, com tipos de dados diversos, inclusive um campo pode conter um outro documento, possui uma estrutura semelhante a um arquivo XML.

  • AmazonSimpleDb
  • ApacheCouchdb
  • MongoDb
  • Riak

Família de colunas: Esse modelo se tornou popular através do paper BigTable do Google, com o objetivo de montar um sistema de armazenamento de dados distribuído, projetado para ter um alto grau de escalabilidade e de volume de dados.

  • Hbase
  • Cassandra
  • Scylla
  • Clouddata
  • SimpleDb
  • DynamoDB

Grafos: é uma estrutura de dados que conecta um conjunto de vértices através de um conjunto de arestas. Os bancos de dados de grafo modernos suportam estruturas de grafo multi-relacionais, onde existem tipos diferentes vértices (representando pessoas, lugares, itens) e diferentes tipos de arestas.

  • Neo4j
  • InfoGrid
  • Sones
  • HyperGraphDB

Muli-model database: Alguns bancos de dados possuem a comum característica de ter suporte de um ou mais modelos apresentados anteriormente.

  • OrientDB
  • Couchbase

Comparando com as aplicações Java que utilizam bancos relacionais. É uma boa prática ter uma camada que é responsável por realizar a comunicação entre o banco de dados e o modelo, o bom e velho Data Acess Object ou DAO. Essa camada contém toda a API de comunicação com o banco de dados, olhando no mundo relacional, existem diversos vendors desse tipo de banco de dados, porém, com o padrão JPA o desenvolvedor Java tem algumas vantagens:

  • Não existe lock-in vendor, ou seja, com o padrão a mudança acontece de maneira bem simples e transparente, apenas é necessário trocar o driver.

  • Não é necessário aprender uma nova API para um novo banco de dados uma vez que a API é comum entre todos os bancos de dados.

  • Impacto praticamente zero em realizar a mudança de banco de dados, em alguns momentos é necessário utilizar um recurso específico de um banco de dados.

Nos bancos de dados NOSQL como não existe nenhum padrão pré estabelecido atualmente, assim os desenvolvedores Java enfrentam os seguintes problemas:

  • Lock-in verdor

  • Para um novo banco de dados é necessário aprender uma nova API.

  • Para qualquer mudança de banco de dados o impacto é altíssimo, se perde praticamente toda a camada DAO uma vez que a API muda completamente. Isso acontece mesmo que a mudança seja para o mesmo tipo de banco NOSQL, família de coluna para família de coluna.

Com esse problema, existe um grande esforço ao criar uma API comuns entre esses bancos de dados. É o caso do Spring Data, Hibernate ORM e o TopLink. Como a API JPA já é uma camada muito conhecida entre os desenvolvedores Java, ele é comumente utilizada para facilitar o mapeamento, porém, o seu foco é para os bancos relacionais, assim ele não é suficiente para cobrir todos os casos desses bancos, por exemplo, muitos bancos NOSQL não tem transação ou com essa API não é possível realizar a inserção de forma assíncrona. Assim, infelizmente apesar de o JPA ser uma boa Api ela não contempla todos os comportamentos existentes nos bancos não relacionais. A melhor analogia para esse caso é: Não se pode controlar um avião com os mesmos controles, uma API, de um carro.

A solução para esse caso seria finalmente criar uma especificação que visa cobrir os quatro tipos de bancos de dados citados. A ideia é que essa nova especificação possua sua API bem semelhante ao JPA, uma vez que o desenvolvedor java já está acostumado com o mesmo, além de adicionar novos recursos na API (Suporte a inserção e recuperação de forma assíncrona) e exceções (por exemplo, quando o banco de dados não suportar determinado recurso).

Além da API, a ideia é que exista também a integração com as outras especificações Java, é o caso do bean validation e CDI. Assim, será possível validar os modelos, realizar a injeção de controle de persistência além de criar ciclo de vida de persistência a partir de eventos.

Os bancos não relacionais ou NoSQL são uma tendência e muitos novos vendors existirão, porém, com a criação de uma nova API o desenvolvedor Java não precisará se preocupar em criar uma API e/ou perder toda uma camada quando isso acontecer.

O motivo de se criar uma API é que as já existentes como JPA e JDO não cobrem todo o comportamento esperado para os bancos não relacionais, por exemplo, inserção assíncrona, recuperação assíncrona. Porém, o objetivo é que essa nova API seja o mais próximo semântica mente com as já existentes.

Muitos bancos não relacionais vem surgindo no mundo do desenvolvimento de software, além do seu uso no mundo Java, por exemplo, na última pesquisa sobre Java EE o número de aplicações que usavam essa tecnologia para armazenamento chegava a quase 50%. Permitir a criação do padrão facilitará a visa do desenvolvedor Java, uma vez que não será necessário aprender uma nova API ou a facilitar em realizar a mudança do banco de dados sem ser necessário aprender uma nova API. Porém, assim como nos bancos relacionais, utilizar recursos específicos dos bancos de dados não trará suporte para API, mas o que acontece nas aplicações normais é que boa parte do código é padronizável, ou seja, mesmo que o custo da migração não seja zero, será um número bem menor comparado o atualmente.

Referências:

 

Moneta 1.2 e nova JSR [Próximos passos]

Uma vez entregue a versão 1.1, que dentre diversas coisas corrige diversos bugs, o próximo passo será a modularização da money-api, tanto na sua API como na implementação. Atualmente lidamos com os seguintes pacotes:

  • javax.money – local aonde fica o core da API
  • javax.money.convert – Responsável por realizar a converção de valores, cotação
  • javax.money.format – Responsável pela formatação do Currency e MonetaryAmount
  • javax.money.spi – Service Provider Interface

Com essa nova proposta a ideia é tornar alguns pacotes opcionais:

  • javax.money : obrigatório
  • javax.money.convert: opcional
  • javax.money.format: opcional
  • javax.money.spi: opcional

Do lado da implementação, seguiríamos um passo semelhante, porém, dentro do módulo do convert ele será subdivido em cada implementação, ou seja, um módulo para convert IMF e um para convert ECB.

  • Módulo obrigatório
  • Módulo formatação
  • Módulo SPI
  • Módulo de convert IMF
  • Módulo de convert ECB

Lançamento do Moneta 1.1

 

A implementação de referência da JSR 354, money-api. Lança uma nova versão. O moneta, o nome da implementação de referência do money-api, vem algumas novidades além da correção de mais de vinte bugs. Dentre eles podemos destacar:

Além das correções foram adicionados novos métodos construtores para as implementações do MonetaryAmount.

  • zero(CurrencyUnit currency) – retorna um valor monetário igual a zero com a moeda informada.
  • ofMinor(CurrencyUnit currency, long amountMinor) – retorna o valor monetário a partir da moeda informada e do valor em centavos, por exemplo, o ofMinor(USD, 1234) retorna uma instância USD 12,34.
  • ofMinor(CurrencyUnit currency, long amountMinor, int factionDigits) – retorna o valor monetário a partir da moeda informada e do valor em centavos, por exemplo, o ofMinor(USD, 1234, 2) retorna uma instância USD 12,34. Diferente do método de criação anterior, utiliza o número de dígitos informado ao invés do número de dígitos da moeda.

 

MonetaryAmount money = Money.zero(dollar);
MonetaryAmount oneDollar = Money.ofMinor(dollar, 12_34);

MonetaryAmount money = FastMoney.zero(dollar);
MonetaryAmount oneDollar = FastMoney.ofMinor(dollar, 12_34);

MonetaryAmount money = RoundedMoney.zero(dollar);
MonetaryAmount oneDollar = RoundedMoney.ofMinor(dollar, 12_34);

Outro ponto é que a classe MonetaryUtil foi depreciada, o maior motivo é a duplicidade do nome, afinal, o termo util cabe qualquer coisa. Ao invés disso, foram criadas duas classes utilitárias:
A classe MonetaryOperators : utilitária da interface MonetaryOperator, nele contém diversas implementações interessantes que fazem a vida do desenvolvedor mais fácil, como por exemplo,

MonetaryAmount amount = ////USD 12.23
amount.with(MonetaryOperators.majorPart());//USD 12
amount.with(MonetaryOperators.minorPart());//USD 0.23
amount.with(MonetaryOperators.percent(10));//USD 1.223

MonetaryQueries: utilitária da interface MonetaryQuery, nele contém diversas implementações interessantes e que facilita a extração de informações do montante financeiro.

MonetaryAmount amount = //USD 12.32
amount.query(MonetaryQueries.convertMinorPart());//1232
amount.query(MonetaryQueries.extractMajorPart());//12
amount.query(MonetaryQueries.extractMinorPart());//32

Outra novidade está relacionado a cotação, agora é possível realizar buscas de cotação no IMF.

CurrencyUnit dollar = Monetary.getCurrency("USD");
CurrencyUnit real = Monetary.getCurrency("BRL");

MonetaryAmount money = FastMoney.of(10, dollar);
MonetaryAmount money2 = FastMoney.of(10, real);

LocalDate localDate = Year.of(2009).atMonth(Month.JANUARY).atDay(9);
ExchangeRateProvider provider = MonetaryConversions.getExchangeRateProvider(ExchangeRateType.IMF_HIST);
ConversionQuery query = ConversionQueryBuilder.of().setTermCurrency(dollar).set(localDate).build();

CurrencyConversion currencyConversion = provider.getCurrencyConversion(query);
MonetaryAmount result = currencyConversion.apply(money2);
MonetaryAmount monetaryAmount = money.add(result);

Também foi adicionado um novo recurso para formatar o MonetaryAmount.

MonetaryAmountFormat defaultFormat = MonetaryAmountDecimalFormatBuilder.newInstance().build();
MonetaryAmountFormat patternFormat = MonetaryAmountDecimalFormatBuilder.of("¤ ###,###.00").build();
MonetaryAmountFormat localeFormat = MonetaryAmountDecimalFormatBuilder.of(Locale.US).build();

CurrencyUnit currency = Monetary.getCurrency("BRL");
MonetaryAmount money = Money.of(12, currency);
String format = defaultFormat.format(money);//$12.00
MonetaryAmount moneyParsed = Money.parse(format, defaultFormat);//or using defafult.parse(format);

Com isso foi discutido sobre a nova versão do moneta, a versão 1.1. Nessa versão além de ter realizado diversas correções, foram adicionados novos recursos para formatação, cotação e deixar API cada vez mais fácil. Com essa versão finalizada, os esforços já foram iniciados para a próxima versão que o maior benefício é a modularização do moneta.

Novidades do CDI 2.0

cdi_herologo

A especificação de injeção de contexto e dependência, o CDI, certamente foi umas das grandes novidades que surgiram com o Java EE 6. Ele funciona basicamente como uma “cola” para o Java EE, realizando integrações entre os seus beans, recurso, dentro do servidor de aplicação. Nessa nova versão, o CDI 2.0, que está previsto para junho de 2016 teremos algumas novidades. E esse post tem o objetivo de dar uma visão delas. Vale lembrar como ainda se tem tempo para o lançamento muitas dessas novidades ainda estão sendo discutidas e codificadas.

  • A API foi subdividida, agora é possível utilizar uma pequena parte dela, ao invés, de todo o contexto. Assim, será possível rodar em dispositivos que tem menos memória e processamento, por exemplo, a IoT, plataformas embarcadas e até mesmo no Android. Sim, a ideia é realizar um CDI lite, assim irão o básico de injeção de dependência (definição de bean, @Inject, qualificadores, produtores, evento) até todos os recurso.
  • Melhorias nos eventos: definir ordem para os eventos além de poder lançar eventos de forma assíncrona.
  • O uso de programação orientada a aspecto para melhorar os interceptors e decoradores.

Para exemplificar o uso de CDI, será imaginado um simples aplicativo, venda de livros, utilizando apenas o Java SE. O primeiro passo será a criação de um projeto maven e será adicionado a dependência do CDI 2.0, ainda na fase de desenvolvimento, com a sua implementação de referência, o weld.

    <dependencies> 
        <dependency> 
            <groupId>org.jboss.weld.se</groupId> 
            <artifactId>weld-se-core</artifactId> 
            <version>3.0.0.Alpha15</version> 
        </dependency> 
    </dependencies>

Adicionado a dependência, o próximo passo é container do CDI, uma característica interessante é que ele implementa o AutoCloseable, recurso oriundo do Java 7 que permite que a JVM feche o recurso tão logo sai do bloco try. Assim ao executar o código abaixo é possível ver no log o Weld SE container STATIC_INSTANCE shut down.

import org.jboss.weld.environment.se.Weld; 
import javax.enterprise.inject.spi.CDI; 

public class App { 
    public static void main(String[] args) { 

        try (CDI<Object> container = new Weld().initialize()) { 

        } 
    } 
} 

É possível fazer as mesmas coisas como no Java EE, assim é possível realizar injeção de dependência apenas com a anotação @Inject.

public class PaymentMethod { 

    public void payment() { 
        System.out.println("Doing payment"); 
    } 
} 

public class Checkout { 

    @Inject 
    private PaymentMethod paymentMethod; 

    public void checkout() { 
        System.out.println("doing checkout "); 
        paymentMethod.payment(); 
    } 
} 

Retornando a classe App, é possível iniciar uma classe a partir do container do CDI, nesse exemplo será a classe Checkout. O CDI será responsável por iniciar a classe e injetar todas as suas dependências.

public class App { 
    public static void main(String[] args) { 

        try (CDI<Object> container = new Weld().initialize()) { 
            Checkout checkout = container.select(Checkout.class).get(); 
            checkout.checkout(); 
        } 
    } 
} 

Também é possível ensinar o CDI a criar uma instância utilizando o método produtor, por exemplo:

public class User implements Serializable {

private String name;

private String email;

public User(String name, String email) {
this.name = name;
this.email = email;
}

String getName() {
return name;
}

String getEmail() {
return email;
}

@Override
public String toString() {
final StringBuilder sb = new StringBuilder("User{");
sb.append("name='").append(name).append('\'');
sb.append(", email='").append(email).append('\'');
sb.append('}');
return sb.toString();
}
}

public class UserProducer {

@Produces
public User getUser() {
return new User("Otavio", "otaviojava@domain.com");
}
}

Nesse exemplo, a classe User não possui um construtor default, assim o CDI não sabe como instanciar, assim foi utilizado o @Produces dentro da classe UserProducer para ensinar o CDI como instanciar a classe usuário. Assim é possível injetá-lo, por exemplo, dentro da classe Checkout:

public class Checkout {

@Inject
private PaymentMethod paymentMethod;
@Inject
private User user;

public void checkout() {
System.out.println("doing checkout: " + user);
paymentMethod.payment();
}
}

O outro recurso que também estará disponível para SE são os qualificadores. Imagine que agora será possível ter dois métodos de pagamento:

  • Cartão de crédito
  • Dinheiro

Assim o método de pagamento passará a ser uma interface com duas implementações. Umas das maneiras para ensinar qual implementação o CDI utilizará seria a partir dos qualificadores.

public enum PaymentType {
CREDIT_CARD, CASH
}

@Qualifier
@Retention(RUNTIME)
@Target({TYPE, METHOD, FIELD, PARAMETER})
public @interface Payment {
PaymentType value();
}

public interface PaymentMethod {

void payment();
}

@Payment(PaymentType.CREDIT_CARD)
public class CreditCard implements PaymentMethod {
@Override
public void payment() {
System.out.println("Payment with credit card");
}
}

@Payment(PaymentType.CASH)
@Default
public class Cash implements PaymentMethod {
@Override
public void payment() {
System.out.println("Payment with cash");
}
}

Nesse exemplo, foi criado a anotação Payment que possui um atributo, o enum PaymentType, que define os tipos de pagamento. Na implementação Cash, além do qualificador ele possui a anotação @Default, quer dizer que caso não seja definido nenhuma qualificação o CDI o injetará como padrão.

@Inject
@Payment(PaymentType.CREDIT_CARD)
private PaymentMethod paymentMethod;

Será injetado a implementação de cartão de crédito.

@Inject
@Payment(PaymentType.CASH)
private PaymentMethod paymentMethod;

@Inject
private PaymentMethod paymentMethod;

Será injetado a implementação de pagamento em dinheiro.

Uma outra possibilidade dos qualificadores é definir qual instância será utilizada em tempo de execução, basta utilizar Instance com selector.

public class Checkout {

@Inject
@Any
private Instance payments;
@Inject
private User user;

public void checkout(PaymentType type) {
System.out.println("doing checkout: " + user);
PaymentMethod paymentMethod = payments.select(new PaymentSelector(type)).get();
paymentMethod.payment();
}
}

public class PaymentSelector extends AnnotationLiteral implements Payment {

private final PaymentType type;

PaymentSelector(PaymentType type) {
this.type = type;
}

@Override
public PaymentType value() {
return type;
}
}

Definido a forma de pagamento, o próximo passo será o envio de e-mail e entregar o livro. Assim, se pode trabalhar com eventos.

public class SendEmail {

public void sendEmail(@Observes User user) {
System.out.println("Sending email to user: " + user);
}
}

public class DeliveryBook {

public void delivery(@Observes User user) {
System.out.println("Delivering a book to: " + user);
}
}

public class Checkout {

@Inject
@Any
private Instance payments;
@Inject
private User user;
@Inject
private Event userEvent;

public void checkout(PaymentType type) {
System.out.println("doing checkout: " + user);
PaymentMethod paymentMethod = payments.select(new PaymentSelector(type)).get();
paymentMethod.payment();
userEvent.fire(user);
}
}

Um recurso possível agora no 2.0 é definir a ordem em que os eventos serão chamados.

public class DeliveryBook {

public void delivery(@Observes @Priority(Interceptor.Priority.APPLICATION+2) User user) {
System.out.println("Delivering a book to: " + user);
}
}

public class SendEmail {

public void sendEmail(@Observes @Priority(Interceptor.Priority.APPLICATION+1) User user) {
System.out.println("Sending email to user: " + user);
}
}

Outra possibilidade é realizar a chamada de forma assíncrona, para isso basta trocar a nos observadores para ObservesAsync e chamar o método do evento.

public class SendEmail {

public void sendEmail(@ObservesAsync User user) {
System.out.println("Sending email to user: " + user);
}
}

public class DeliveryBook {

public void delivery(@ObservesAsync User user) {
System.out.println("Delivering a book to: " + user);
}
}

public class Checkout {

@Inject
@Any
private Instance payments;
@Inject
private User user;
@Inject
private Event userEvent;

public void checkout(PaymentType type) {
System.out.println("doing checkout: " + user);
PaymentMethod paymentMethod = payments.select(new PaymentSelector(type)).get();
paymentMethod.payment();
userEvent.fireAsync(user);
}
}

Com isso foram apresentados os novos recursos do CDI 2.0, vale lembrar que muitos ainda estão sendo trabalhados, assim esperem por mais novidades até o dia do lançamento.

Link para o código

Java 8: Stream API – Parte 3, conhecendo a API

17_1

Esse artigo será a continuação da visão geral da API de Stream API. No post anterior, tivemos os primeiros contatos com a API. Nesse post, nosso objetivo é continuar falando um pouco mais. Manteremos o mesmo modelo dos capítulos anteriores.

public class Team {
private List players;
…
}

public class Player {

private String name;

private int gols;

private Position position;

//...
}

public enum Position {
GOALKEEPER,DEFENDER, FORWARDS
}

É possível verificar se um, todos ou nenhum elemento dentro da estrutura atende a uma condição, para isso, se pode utilizar os métodos anyMath, allMatch ou noneMach respectivamente.

public boolean hasDefender() {
return players.stream().anyMatch(Player::isDefender);
}

public boolean noHasDefender() {
return players.stream().anyMatch(Player::isDefender);
}

public boolean justHasDefender() {
return players.stream().anyMatch(Player::isDefender);
}

Com o min e max retorna o maior e o menor elemento respectivamente como critério ele usa um Comparator que é passado como parâmetro.

public Player getGoalscorer() {
return players.stream().max(Comparator.comparing(Player::getGols).reversed()).get();
}

public Player getLessGoalscorer() {
return players.stream().min(Comparator.comparing(Player::getGols).reversed()).get();
}

Caso a nossa classe Player, tenha implementado o equals e hashCode, que é uma boa prática em Java, é possível usar o distinct, que semelhante ao comportamento do banco de dados, garante que os dados não se repitam.

public List getGoalscorer() {
return players.stream().distinct().collect(Collectors.toList());
}

Além do mapeamento normal, que é por referência, é possível realizar o mapeamento para três tipos primitivos: int, double, long com os métodos mapToInt, mapToDouble e mapToLong respectivamente. Não é necessário se preocupar caso esteja trabalhando com o wrapper, os objetos Long, Double, e Integer terão a conversão automática, autoinboxing. Com o IntStream, LongStream e DoubleStream é possível realizar algumas operações dentro da coleção como valor máximo, mínimo e média.

public int getMaxGoalsFromPlayer() {
return players.stream().mapToInt(Player::getGols).max().getAsInt();
}

public int getMinGoalsFromPlayer() {
return players.stream().mapToInt(Player::getGols).min().getAsInt();
}

public double getAverageGoalsFromPlayer() {
return players.stream().mapToInt(Player::getGols).average().getAsDouble();
}

Também é possível retornar o stream primitivo para o seu respectivo wrapper (Stream<Integer>, Stream<Double> ou Stream<Long>). Além da possibilidade realizar conversão entre os tipos primitivos.

public LongSummaryStatistics getMinGoalsFromPlayerAsLong() {
return players.stream().mapToInt(Player::getGols).asLongStream().summaryStatistics();
}

public List getGolsAsDouble() {
return players.stream().mapToInt(Player::getGols).asDoubleStream().boxed().collect(Collectors.toList());
}

Como último tópico será discutido o recurso flatmap. Com o flatmap é possível extrair um Stream dentro de outro Stream. Para exemplificar será adicionado mais um modelo: A seleção. Uma seleção é composta por diversos times de um país.

public class NationalTeam {

private List teams;

public NationalTeam(List teams) {
this.teams = teams;
}
}

Para um exemplo simples serão retornados todos os jogadores dos times, porém limitados por onze jogadores.

public List getPlayers() {
return teams.stream().flatMap(t -> t.getPlayers().stream()).limit(11L).collect(Collectors.toList());
}

Naturalmente, durante a competição a seleção seleciona os melhores onze jogadores para os campeonatos, assim como critério será selecionado os onze que fizeram mais gols.

public List getPlayers() {
return teams.stream().flatMap(t -> t.getPlayers().stream())
.sorted(Comparator.comparing(Player::getGols).reversed())
.limit(11L).collect(Collectors.toList());
}

Java 8: Stream API – Parte 2, conhecendo a API

17_1

Após falar sobre a motivação para usar o Stream API, o foco desse artigo será mostrar uma visão geral da API. Para exemplificar, será utilizado o mesmo modelo do artigo anterior, um time de futebol.

public class Team {
private List players;
//…
}

public class Player {

private String name;

private int gols;

private Position position;

//...
}

public enum Position {
GOALKEEPER,DEFENDER, FORWARDS
}

Mapeamento

É possível realizar o mapeamento e retornar apenas um campo desejável, por exemplo, retornar a listas de nomes dos jogadores.

public List getNames() {
return players.stream().map(Player::getName).
collect(Collectors.toList());
}

Collector vs Collectors

A interface Collector que realiza uma operação de redução mutável colocando os resultados em uma representação e a classe Collectors tem várias implementações úteis da interface.

Retornando Set
public List getPlayers() {
return players.stream().collect(Collectors.toList());
}
Retornando List
public Set getPlayers() {
return players.stream().collect(Collectors.toSet());
}
Criando o seu próprio retorno
public Queue getPlayers() {
return players.stream().collect(Collectors.toCollection(LinkedList::new));
}

Ordenação

É possível ordenar de forma natural, implementando o Comparable. Para exemplificar isso, a classe Player será modificado comparando os jogadores pelo nome.

public class Player implements Comparable {
@Override
public int compareTo(Player player) {
return name.compareTo(player.name);
}
}

Assim é possível ordenar pelo nome:

public List getPlayers() {
return players.stream().sorted()
.collect(Collectors.toList());
}

Ou:

public List getPlayers() {
return players.stream().sorted(Comparator.naturalOrder())
.collect(Collectors.toList());
}

Também é possível definir uma ordenação, para isso, basta usar o método comparing dentro do Comparator.

public List getPlayers() {
return players.stream().sorted(Comparator
.comparing(Player::getGols))
.collect(Collectors.toList());
}

Foma descendente.

public List getPlayers() {
return players.stream().sorted(Comparator
.comparing(Player::getGols).reversed())
.collect(Collectors.toList());
}

Juntar ordenações:

public List getPlayers() {
return players.stream().sorted(Comparator.comparing(Player::getName)
.thenComparing(Comparator.comparing(Player::getGols)))
.collect(Collectors.toList());
}

Filtragem.

Já discutido no primeiro post, vale adicionar que é possível, assim como as ordenações, realizar mais de uma condição. É possível combinar utilizando os operadores or ou and, além de negar o predicate usando o negate. Para o exemplo, serão listados todos os atacantes que fizeram mais de 3 gols.

public List getGoodFowarder() {
Predicate isFowarder = Player::isFowarder;
Predicate hasMoreThanThreeGolds = p -> p.getGols() >3;
return players.stream().filter(isFowarder.and(hasMoreThanThreeGolds)).collect(Collectors.toList());
}

public List getNotFowarder() {
Predicate isFowarder = Player::isFowarder;
return players.stream().filter(isFowarder.negate()).collect(Collectors.toList());
}

Caso se queria limitar o número de elementos na lista, pular elementos e também retornar o primeiro ou algum resultado existe os métodos limit, skip, findFirst e findAny respectivamente.

public List getThreeGoodFowarder() {
Predicate isFowarder = Player::isFowarder;
Predicate hasMoreThanThreeGolds = p -> p.getGols() >3;
return players.stream().filter(isFowarder.and(hasMoreThanThreeGolds)).limit(3).collect(Collectors.toList());
}

public Player getSecondGoodFowarder() {
Predicate isFowarder = Player::isFowarder;
Predicate hasMoreThanThreeGolds = p -> p.getGols() >3;
return players.stream().filter(isFowarder.and(hasMoreThanThreeGolds)).skip(1).findFirst().get();
}

public Player getAGoodFowarder() {
Predicate isFowarder = Player::isFowarder;
Predicate hasMoreThanThreeGolds = p -> p.getGols() >3;
return players.stream().filter(isFowarder.and(hasMoreThanThreeGolds)).findAny().get();
}

public List getFowarderOrDefenter() {
Predicate isFowarder = Player::isFowarder;
Predicate isDefener = Player::isDefender;
return players.stream().filter(isFowarder.or(isDefener)).limit(3).collect(Collectors.toList());
}

 

Java 8: Stream API – Parte 1, a motivação

17_1

Umas das novidades que entraram no Java 8, foi o stream, com esse recurso é possível realizar interações de maneira bastante fácil com as suas coleções. O primeiro item a ser explorado do Stream é a sua motivação, com isso será criado um exemplo prático com um modelo simples, um time de futebol.

public class Team {
private List players;
…
}

public class Player {

private String name;

private int gols;

private Position position;

...
}

public enum Position {
GOALKEEPER,DEFENDER, FORWARDS
}

Com isso, será realizado algumas manipulações dos jogadores, inicialmente o código será utilizando o Java 7. Como primeiro método, teremos um que retorne apenas os atacantes.

public List getForwarders() {
List forwarders = new ArrayList<>();
for (Player player : players) {
if(player.isFowarder()) {
forwarders.add(player);
}
}
return Collections.unmodifiableList(forwarders);
}

Seguindo esse raciocínio, o próximo método será um que retorne apenas os defensores.

public List getDefenders() {
List defenders = new ArrayList<>();
for (Player player : players) {
if(player.isDefender()) {
defenders.add(player);
}
}
return Collections.unmodifiableList(defenders);
}

Ao analisar o código existe uma forte semelhança entre os dois códigos, na verdade existe uma única diferença: a condição para adicionar o jogador na lista. Possivelmente os próximos métodos seguirão o mesmo raciocínio. Assim, será refatorado esse código criando uma interface Filtro.

public interface PlayerFilter {
boolean filter(Player player);
}

Com a refatoração, utilizando o PlayerFilter se obtém o seguinte código:

public List getForwarders() {
return getFilteredPlayers(new PlayerFilter() {
@Override
public boolean filter(Player player) {
return player.isFowarder();
}
});
}

public List getDefenders() {

return getFilteredPlayers(new PlayerFilter() {
@Override
public boolean filter(Player player) {
return player.isDefender();
}
});
}

private List getFilteredPlayers(PlayerFilter filter) {

List filteredPlayers = new ArrayList<>();
for (Player player : players) {
if(filter.filter(player)) {
filteredPlayers.add(player);
}
}
return Collections.unmodifiableList(filteredPlayers);

}

Ainda é possível realizar mais uma refatoração sem utilizar o Stream, é possível reparar que o código desejável é a lógica dentro das implementações de PlayerFilter, assim com lambda é possível deixar o código ainda mais legível.

public List getForwarders() {
return getFilteredPlayers(player -> player.isFowarder());
}

public List getDefenders() {
return getFilteredPlayers(player -> player.isDefender());
}

Se pode deixar ainda mais simples utilizando o method reference. Da seguinte forma:

public List getForwarders() {
return getFilteredPlayers(Player::isFowarder);
}

public List getDefenders() {
return getFilteredPlayers(Player::isDefender);
}

Será que ninguém pensou nisso antes? A API de Stream é uma nova estrutura de dados que nasceu no Java 8 para trabalhar com fluxos de dados de modo sequencial ou paralelo de maneira muito fácil e intuitiva. De maneira geral segue algumas vantagens dessa API:

  • Maneira fácil e intuitiva para manipular sequencia de dados (Sequencial ou paralelo).
  • A Stream não impacta a lista já existente, assim toda operação de filtragem, por exemplo, não removerá elementos da lista original.
  • Um Stream só será executado quando tiver um método que encerra o pipeline[1].

 

Tão logo é criado o Stream e realizado a filtragem, o próximo passo é retornar as informações, para fazer isso é esperado a interface Collector, um padrão muito comum no Java é criar uma classe utilitária de interface apenas acrescentando o ‘s‘, assim a classe utilitária de <i>Collector</i> é <i>Collectors</i> tem alguns métodos que são muito úteis.

public List getForwarders() {
return players.stream().filter(Player::isFowarder).collect(Collectors.toList());
}

public List getDefenders() {
return players.stream().filter(Player::isDefender).collect(Collectors.toList());
}

Um ponto é que mesmo criando uma nova lista, talvez não seja uma boa ideia deixar o usuário da API modificar a lista oriunda da classe Team, ou seja, queremos deixar a lista apenas como read-only, exatamente como estava como código em Java. Um método que existe dentro do Collectors para resolver isso é o “collectingAndThen”. No nosso caso, será passado a conversão para a lista e em seguida utilizaremos o mesmo método para a deixar-lha imodificável.

<br />public List getForwarders() {

return players.stream().filter(Player::isFowarder).collect(Collectors.
collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
}

public List getDefenders() {
return players.stream().filter(Player::isDefender).collect(Collectors.
collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
}

Com isso, foi discutido de forma resumida a motivação de utilizar o Stream API, para manter os posts de forma curto, mais detalhes sobre a API serão feitas num próximo post.

public class Player {

private String name;

private int gols;

private Position position;

public Player(String name, int gols, Position position) {
this.name = name;
this.gols = gols;
this.position = position;
}

public String getName() {
return name;
}

public int getGols() {
return gols;
}

public Position getPosition() {
return position;
}

public boolean isFowarder() {
return FORWARDER.equals(position);
}

public boolean isDefender() {
return DEFENDER.equals(position);
}

}
public class Team {

private List players;

public Team(List players) {
this.players = players;
}

public List getForwarders() {

return players.stream().filter(Player::isFowarder).collect(Collectors.
collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
}

public List getDefenders() {
return players.stream().filter(Player::isDefender).collect(Collectors.
collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
}

}
public class App
{
public static void main( String[] args )
{
List players = new ArrayList<>();
players.add(new Player("Bobo", 10, Position.FORWARDER));
players.add(new Player("Zé Carlos", 8, Position.FORWARDER));
players.add(new Player("Lima", 4, Position.DEFENDER));
players.add(new Player("Lima", 14, Position.DEFENDER));
players.add(new Player("Ronaldo", 1, Position.GOALKEEPER));
Team bahia = new Team(players);
List defenders = bahia.getDefenders();
List forwarders = bahia.getForwarders();
}
}
public enum Position {
GOALKEEPER,DEFENDER, FORWARDS
}

Referência:

Trabalhando com dinheiro no Mundo Java EE [MONEY-API]

jobtrends

As aplicações Java EE estão ficando cada vez mais comuns no mundo do desenvolvimento do software para web utilizando Java. Esse crescimento se deu principalmente em 2009 com o lançamento do Java EE 6 e o nascimento do Contexto de injeção de independência, o CDI. Umas das grandes vantagens do uso do Java EE, é que ela é uma especificação Java, assim não existe o vendor lock-in, em outras palavras, não é necessário ficar preso em um fabricante. Outro ponto interessante é que caso não seja necessário usar todo o container do Java EE, é possível utilizar alguns recursos em um servidor simples, por exemplo, no caso é possível rodar o CDI, JSF, Bean validator, etc. em um container como o Tomcat. Outro ponto importante que vale ressaltar é que cada componente, citado anteriormente, é especificado separadamente, uma JSR, essas JSRs são regidas pelo JCP e todos podem participar, dar feedback, reportar bugs, etc. na concepção até o final dessa especificação Java.

O Java EE é certamente a plataforma mais popular para softwares no mundo corporativo, esses softwares têm diversos objetivos. O que eles normalmente tem em comum é o fato de lidar com dinheiro. O valor monetário é muito comum em diversos softwares, por exemplo, sistemas financeiros, locadoras, livraria, sistemas de recursos humanos, contabilidade etc. Porém não existia um padrão para trabalhar com dinheiro no mundo Java, por anos vários desenvolvedores usavam os tipos primitivos ou tipos oriundos do Java para resolver este problema, por exemplo, Long, Double, Integer, String, etc. Utilizar tipos primitivos traz diversos problemas para um software, dentre eles, falta de encapsulamento, problemas no design da API numa aplicação, quebra do SOLID, dentre outros motivos (Como falar das desvantagens do tipo primitivos para representar dinheiro não é o foco desse artigo, ficaremos apenas com esses exemplos, para mais informações existe o money-api book o link estará abaixo desse artigo). Com o intuito de solucionar esse problema existe a JSR 354, o money-api, essa especificação foi desenvolvida por diversas empresas que lidam diretamente com dinheiro, dentre elas, o Credit Suisse, uns dos maiores e mais famosos banco do mundo, e o Paypal, um dos maiores providers de pagamento do mundo.

Para tornar o artigo mais didático, será imaginado um simples exemplo de uma aplicação Java EE, um sistema de compra de livros. Nesse aplicativo, se falará de cada componente do Java EE separadamente. Se utilizará a versão atual do Java EE, JavaEE 7. O foco desse artigo não será falar sobre a API de dinheiro, apenas sua integração com o Java EE.

JPA

Para o exemplo ficar simples, o modelo livro basicamente terá três atributos:

  • Id, que será um número sequencial
  • Nome, o nome do livro
  • Valor, o valor do livro
@Entity 
public class Book implements Serializable { 

@Id 
@GeneratedValue(strategy = GenerationType.IDENTITY) 
private Long id; 

@Column 
private String name; 

@Column 
private MonetaryAmount value; 

//getter and setter 
    
}

Um problema comum em lidar com tipos únicos, como o dinheiro, é que normalmente os bancos não tem suporte nesse tipo de informação. Uma solução para esse problema nasceu no JPA 2.1 com os converters. A criação de um converter é bastante simples, basta implementar a interface AttributeConverter.

public class MonetaryAmountConveter implements  AttributeConverter&amp;amp;lt;MonetaryAmount, BigDecimal&amp;amp;gt;{ 

    private static final CurrencyUnit CURRENCY = Monetary.getCurrency(&amp;quot;BRL&amp;quot;); 
    
    private static final MonetaryQuery&amp;amp;lt;BigDecimal&amp;amp;gt; EXTRACT_BIG_DECIMAL = (m) -&amp;amp;gt; m.getNumber() 
            .numberValue(BigDecimal.class); 
            
    @Override 
    public BigDecimal convertToDatabaseColumn(MonetaryAmount attribute) { 
       return Optional.ofNullable(attribute).orElse(FastMoney 
               .zero(CURRENCY)) 
               .query(EXTRACT_BIG_DECIMAL); 
    } 

    @Override 
    public MonetaryAmount convertToEntityAttribute(BigDecimal dbData) { 
        return Money.of(dbData, CURRENCY); 
    } 
} 

Converter do JPA que persiste apenas o valor numérico.

E definir no campo como ele será convertido, para isso existe a anotação Convert.

@Column
@Convert(converter = MonetaryAmountConveter.class)
private MonetaryAmount value;

No JPA 2.1 os converters trabalham com um campo com um campo único, assim se pode trabalhar com algumas opções:

  • Persistir apenas o número: em sistemas que trabalham apenas com uma única moeda, é possível, por exemplo, definir a moeda em uma constante, que sempre será a mesma, e assim persistir o valor numérico. Assim é possível realizar operações no próprio banco de dados, como soma, porém caso o projeto cresça e precise internacionalizar haverá um grande problema. Uma solução para contornar esse problema seria ter um tenancy para cada país/moeda.

  • Persistir o número e a moeda como String: Utilizando essa estratégia seria o suficiente para manter o sistema internacionalizável. Se teria as informações suficientes para poder recuperar tanto a moeda quanto o valor numérico, porém, seria mais difícil, por exemplo, usar recursos do banco de dados, por exemplo, realizar somatório, assim um somatório teria que ser serializado para o modelo e assim a operação ser realizada.

  • Persistir o número e a moeda em campos diferentes: Essa opção, infelizmente, não está disponível no JPA, conforme foi discutido anteriormente no JPA 2.1 o converter apenas aceita um único campo como converção. Porém, é possível utilizar o hibernate diretamente para realizar essa operação, algo bem semelhante ao JPA 2.1, porém implementando a interface CompositeUserType. Com isso é possível, realizar operações de soma dentro do banco de dados, porém, existe a possibilidade de somar sem levar em consideração da moeda, ou não levar em consideração o modo de arredondamento desejado, que as implementações do MonetaryAmount podem garantir.

O Jadira é um framework que possui diversas implementações do UserType, interface que define o tipo que será persistido no banco de dados semelhante ao AttributeConverter. O Jadira já possui suporte tanto para as JSR 310, time-api, quanto o JSR 354, money-api.

CDI

Não é interessante que a entidade Livro seja responsável por definir a moeda que o objeto vai utilizar, afinal, não é sua responsabilidade. Outro ponto é que existem diversas estratégias para a criação de uma moeda: Definir a moeda a partir do usuário ou definir a moeda a partir do tenancy, por exemplo, caso o usuário utilize as máquinas do “.com.br” a moeda será real, “.com.us” dollar etc. Em nenhum desses casos deixar essa lógica espalhada no código não é uma boa estratégia, ou deixar o livro responsável por isso, nesse caso haverá quebra do SOLID. Para isso, poderíamos utilizar o CDI. O contexto de injeção de dependência, CDI, funciona basicamente como cola no mundo Java EE.

public class MoneyProducer { 

    @Inject 
    private HttpServletRequest request; 

    @Produces 
    @RequestScoped 
    public CurrencyUnit getCurrency() { 
        return Monetary.getCurrency(request.getLocale()); 
    } 
} 

Criar uma moeda a partir do request

public class MoneyProducer { 

    @Inject 
    @Named(&amp;quot;money_from_configurations&amp;quot;) 
    private String money; 

    @Produces 
    @RequestScoped 
    public CurrencyUnit getCurrency() { 
        return Monetary.getCurrency(money); 
    } 
}

Pegando a informação da moeda a partir de uma configuração.

Com um produtor de moeda definida pelo CDI, se pode injetar a moeda e “magicamente” ela será instanciada. Para não ter diversos pontos injetando moeda e criando dinheiro com ‘n’ implementações, uma recomendação é ter uma classe especializada na criação do dinheiro, caso seja necessário, criar um qualificadores para definir cada tipo de implementação.

public class MonetaryAmountFactory { 

    @Inject 
    private CurrencyUnit currency; 
    
    
    public MonetaryAmount create(Number number) { 
        return Money.of(number, currency); 
    } 

} 

 

JAX-RS

É muito comum, realizar integração com outros sistemas e para realizá-lo, o modo mais comum, é via uma API rest, dessa forma a integração será transparente pela tecnologia, linguagem, etc. que o outro sistema utilize. No mundo Java EE existe a especificação que lida com isso, o JAX-RS. Assim como na implementação de JPA, não existe um converter nativo para a moeda, a interface CurrencyUnit, e para o dinheiro, a interface MonetaryAmount. Na nova versão do JAX-RS é possível criar os próprios converters, para isso é necessário:

Implementar a interface ParamConverterProvider e anota-la com a anotação @Provider. Essa interface tem apenas um método e como saida espera como saida a interface ParamConverter.

@Provider 
public class MonetaryAmountConverterProvider implements ParamConverterProvider { 


    @Override 
    public &amp;amp;lt;T&amp;amp;gt; ParamConverter&amp;amp;lt;T&amp;amp;gt; getConverter(Class&amp;amp;lt;T&amp;amp;gt; rawType, Type genericType, Annotation[] annotations) { 
        if (MonetaryAmount.class.isInstance(rawType)) { 
            return new ParamConverter&amp;amp;lt;T&amp;amp;gt;() { 
                @Override 
                public T fromString(String value) { 
                    if(value == null || value.isEmpty()) { 
                        return null; 
                    } 
                    return rawType.cast(Money.parse(value)); 
                } 

                @Override 
                public String toString(T value) { 
                    if(value == null) { 
                        return null; 
                    } 
                    return value.toString(); 
                } 
            }; 
        } 
        return null; 
    } 
} 


@Provider 
public class CurrencyUnitConverterProvider implements ParamConverterProvider { 

    private CurrencyUnitParamConverter converter = new CurrencyUnitParamConverter(); 

    @Override 
    public &amp;amp;lt;T&amp;amp;gt; ParamConverter&amp;amp;lt;T&amp;amp;gt; getConverter(Class&amp;amp;lt;T&amp;amp;gt; rawType, Type genericType, Annotation[] annotations) { 
        if (CurrencyUnit.class.isInstance(rawType)) { 
            return new ParamConverter&amp;amp;lt;T&amp;amp;gt;() { 
                @Override 
                public T fromString(String value) { 
                    if(value == null || value.isEmpty()) { 
                        return null; 
                    } 
                    return rawType.cast(Monetary.getCurrency(value)); 
                } 

                @Override 
                public String toString(T value) { 
                    if(value == null) { 
                        return null; 
                    } 
                    return value.toString(); 
                } 
            }; 
        } 
            return null; 
    } 
}

JSF

A interação com o usuário é um ponto muito importante nas aplicações, assim é necessário representar o dinheiro e permitir que o usuário informe a moeda ou dinheiro. Assim como as outras especificações do mundo Java EE, não existe suporte para a money-api, porém existe converters dos componentes do JSF. Para isso basta implementar a interface Converter.

@FacesConverter(&amp;quot;money.midas.CurrencyConverter&amp;quot;) 
public class CurrencyConverter implements Converter { 

	@Override 
	public Object getAsObject(FacesContext context, UIComponent component, 
			String value) { 
		 
		if (Objects.isNull(value)) { 
			return null; 
		} 
		return Monetary.getCurrency(value); 
	} 

	@Override 
	public String getAsString(FacesContext context, UIComponent component, 
			Object value) { 
		if (Objects.isNull(value)) { 
			return null; 
		} 
		return value.toString(); 
	} 

} 

@FacesConverter(&amp;quot;money.midas.MoneyConverter&amp;quot;) 
public class MoneyConverter implements Converter { 

	@Override 
	public Object getAsObject(FacesContext context, UIComponent component, 
			String value) { 
		 
		if (Objects.isNull(value)) { 
			return null; 
		} 
		return Money.parse(value); 
	} 

	@Override 
&amp;amp;lt;strong&amp;amp;gt;	public String getAsString(FacesContext context, UIComponent component, 
			Object value) { 
		if (Objects.isNull(value)) { 
			return null;
		} 
		return value.toString(); 
	} 
}

O Projeto Midas

Com o intuito de realizar a integração entre as especificaçõeshttp://jadira.sourceforge.net/ e outros frameworks e o money-api existe o projeto Midas, dentre os projetos que estão no midas dar suporte estão:

  • JSF
  • Bean Validation
  • JPA
  • JAX-RS
  • CDI
  • Google Guice
  • Spring

No midas, todos os converters do JSF, JPA, JAX-RS que foram citatos nesse artigo estão nesse projeto. Além dessas especificações, o midas tem suporte para o bean validation.

  • CurrencyAccepted: Define as moedas que serão aceitas dentro da moeda, CurrencyUnit, e do dinheiro, MonetaryAmount. É possível informar as moedas permitidas ou usando o código da moeda ou de * o Locale de onda a moeda veio.
  • CurrencyRejected: Define as moedas que não serão aceitas, rejeitadas, dentro da moeda, CurrencyUnit, e do dinheiro, MonetaryAmount. É possível informar as moedas permitidas ou usando o * código da moeda ou de o Locale de onda a moeda veio.
  • MonetaryMax: Define o valor máximo para o dinheiro.
  • MonetaryMin: Define um valor mínimo para o dinheiro.
@CurrencyAccepted(currencies = &amp;quot;BRL&amp;quot;) 
private CurrencyUnit currencyUnit; 

@CurrencyAccepted(currencies = &amp;quot;BRL&amp;quot;) 
@MonetaryMax(&amp;quot;10.12&amp;quot;) 
private MonetaryAmount money;

Com isso foi apresentado a integração entre o money-api e o Java EE. Ainda existe muito mais integrações para serem desenvolvidas com essa espificação que trabalha com dinheiro e , certamente, toda ajuda será bem-vinda por todos os membros da comunidade.

Referências