CDI, MVC e outras novidades do Java EE 8

Estamos acompanhando de perto as novidades do Java EE 8, e recentemente excelentes atualizações foram divulgadas. O lançamento do primeiro draft do CDI 2.0 é uma delas, seguida de novidades no status do MVC 1.0, JSON-P, JMS 2.1, entre outras. Aqui vão algumas delas:

CDI 2.0: Melhorias na API de Eventos e suporte para Java SE

Nessa nova versão, a API de eventos ganhou diversas melhorias, como uso assíncrono e ordenação — duas features bastante solicitadas pela comunidade. Na prática, o exemplo que utilizamos nesse post sobre eventos do CDI poderia ficar assim:

public class FinalizaCompra {

    @Inject private Event<Compra> eventoCompra;

    public void finalizaCompra() {
       Compra compra = new Compra(produto, cliente);
       eventoCompra.fireAsync(compra);
    }
}

A classe FinalizaCompra notifica assíncronamente que o evento aconteceu, enquanto outras classes, como a Estoque, poderão observar esse evento — também assíncronamente.

public class Estoque {

    public void reservaMercadoria(@ObservesAsync Compra compra) {
        // reserva produto no estoque
    }
}

Legal, não é? Outro ponto é que se estivermos trabalhando de forma síncrona, e por alguma necessídade de regra de negócio precisarmos que a classe Notificacoes seja a ultima a observar o evento de compra, podemos priorizar toda ordem de execução:

public class Estoque {

    public void reservaMercadoria(@Observes @Priority(1) Compra compra) {
        // reserva produto no estoque
    }
}

public class Notificacoes {

    public void enviaNotificacao(@Observes @Priority(2) Compra compra) {
        // envia email, sms, notificando a campra
    }
}

Se quiser, você pode ver mais detalhes sobre o funcionamento assíncrono e ordenação de observers no capítulo de eventos da nova versão da spec. Muitas dessas novidades serão aplicadas e suportadas no VRaptor 4, que tem sua nova versão totalmente integrada ao CDI. Vale comentar que todo o fluxo de uma request do VRaptor é tratado com eventos do CDI!

Por fim, seria injusto falar do CDI 2.0 sem falar do suporte ao Java SE. Utilizando a classe CDI, que já conhecemos nesse outro post do CDI 1.0, juntamente com a iterface CDIProvider, agora podemos fazer:

public static void main(String... args) {
    try(CDI<Object> cdi = CDI.getCDIProvider().initialize()) {
        // inicia o container do CDI
        Estoque estoque = cdi.select(Estoque.class).get();
        estoque.reservaMercadoria(new Compra("Livro da CDC"));
    }
    // container stopado automaticamente depois do bloco do try
}

MVC 1.0: Novos recursos e melhorias na API de Validação

O MVC também recebeu novos recursos desde nosso último post, em especial um mecanismo de proteção CSRF (Cross-Site Request Forgery). Entre outras variações, você pode ativar o recurso globalmente pela sua classe Application.

@ApplicationPath("mvc")
public class MvcApplication extends Application {

    @Override
    public Set<Class<?>> getClasses() {
        final Set<Class<?>> set = new HashSet<>();
        set.add(ProdutoController.class);
        return set;
    }

    @Override
    public Map<String, Object> getProperties() {
        final Map<String, Object> map = new HashMap<>();
        map.put(Csrf.ENABLE_CSRF, Boolean.TRUE);
        return map;
    }
}

Feito isso, todas as requisições de POST para o ProdutoController serão protegidas, com controle de um token que deve ser enviado pelo formulário da view:

<form action="/produtos/adiciona" method="post">
    <input type="submit" value="Click here"/>
    <input type="hidden" name="${csrf.name}" value="${csrf.token}"/>
</form>

A API de validação também tem sido o foco das mudanças mais recentes. Muito ainda está sendo discutido, mas por enquanto, você já pode imaginar o método adiciona sendo validado assim:

@Controller @Path("/produtos")
public class ProdutoController {

    @Inject private BindingResult result;

    @POST
    @ValidateOnExecution(type = ExecutableType.NONE)
    public Response adiciona(@Valid @BeanParam Produto produto) {
        if (result.isFailed()) {
                // mostra mensagens de validação, redireciona, etc
        }
        // adiciona produto no banco, etc etc
    }
}

E muito mais novidades!

Essas são apenas algumas das muitas novidades e atualizações que nos esperam. O Java EE está previsto só pro final do ano que vem, próximo ao JavaOne San Francisco 2016, mas desde já você pode e deve contribuir com testes, idéias, reports de bugs entre outros. O primeiro draft do CDI 2.0, assim como do MVC 1.0, e diversas outras especificações já estão disponíveis para download. E você, que outras novidades espera no Java EE 8? Já tem testado alguma delas?

Tags:

6 Comentários

  1. Rafael Ponte 23/07/2015 at 09:02 #

    Muito bacana as novidades, Turini.

    O que gostaria de saber é como eles pretendem fazer a integração entre JSF 2.3 e MVC 1.0, já que são 2 frameworks que trabalham com um modelo diferente de MVC. Espero que a integração seja simples e transparente onde ambos respeitariam os escopos de seus respectivos controllers.

    Um abraço e parabéns pelo post!

  2. Rodrigo Turini 23/07/2015 at 10:43 #

    Boa pergunta, Rafael! Isso ainda não está claro nem pra nós, do expert group. Assim que tivermos alguma discussão e decisão nesse sentido, vou compartilhar aqui no blog! Grande abraço

  3. Alberto 23/07/2015 at 11:26 #

    Meu chute, em relação a integração o JSF 2.3 e o MVC 1.0 é que não vai ter nenhuma :/. Parecido com o cenário atual, pensando no JAX-RS. Cada um vai ter seu servlet e salve-se quem puder… Uma coisa que ia gostar é que a implementação do MVC 1.0 entendesse um FacesRequest, nem que fosse apenas para extrair os valores dos parâmetros para montar o objeto. Se tivesse isso, acho que ajudaria bastante… Você usaria cada um no melhor cenário possível.

  4. João Cabral 31/08/2015 at 16:43 #

    O JSF é orientado a componentes e esse MVC parece ser orientado a rotas. Um não bate com o outro.

    Serão duas tecnologias diferentes a serem usadas em casos diferentes.

    Penso que seja para concorrer com o Spring MVC e outros. Desde que fique bom, será bem vindo!

  5. Rodrigo Turini 31/08/2015 at 17:19 #

    Isso João, são estilos de MVC diferentes (action vs component based).

    Tem um post bem legal do Adriano que explica a diferença entre eles:

    http://blog.caelum.com.br/entenda-os-mvcs-e-os-frameworks-action-e-component-based/

  6. Gilson Silva 21/03/2016 at 16:55 #

    Ficou show, parabém!!! 😉

Deixe uma resposta