Novidades do Spring Framework

Postado em Atualizado em

Segue abaixo um resumo das novidades do spring framework 5:

JDK 8+ and Java EE 7+ Baseline

  • Entire framework codebase based on Java 8 source code level now.
    • Improved readability through inferred generics, lambdas, etc.
    • Conditional support for Java 8 features now in straight code.
  • Full compatibility with JDK 9 for development and deployment.
    • On classpath as well as module path (with stable automatic module names).
    • Framework build and test suite passes on JDK 9 (runs on JDK 8 by default).
  • Java EE 7 API level required in Spring’s corresponding features now.
    • Servlet 3.1, Bean Validation 1.1, JPA 2.1, JMS 2.0
    • Recent servers: e.g. Tomcat 8.5+, Jetty 9.4+, WildFly 10+
  • Compatibility with Java EE 8 API level at runtime.
    • Servlet 4.0, Bean Validation 2.0, JPA 2.2, JSON Binding API 1.0
    • Tested against Tomcat 9.0, Hibernate Validator 6.0, Apache Johnzon 1.1

Removed Packages, Classes and Methods

  • Package beans.factory.access (BeanFactoryLocator mechanism).
  • Package jdbc.support.nativejdbc (NativeJdbcExtractor mechanism).
  • Package mock.staticmock removed from spring-aspects module.
    • No support for AnnotationDrivenStaticEntityMockingControl anymore.
  • Packages web.view.tiles2 and orm.hibernate3/hibernate4 dropped.
    • Minimum requirement: Tiles 3 and Hibernate 5 now.
  • Dropped support: Portlet, Velocity, JasperReports, XMLBeans, JDO, Guava.
    • Recommendation: Stay on Spring Framework 4.3.x for those if needed.
  • Many deprecated classes and methods removed across the codebase.
    • A few compromises made for commonly used methods in the ecosystem.

General Core Revision

  • JDK 8+ enhancements:
    • Efficient method parameter access based on Java 8 reflection enhancements.
    • Selective declarations of Java 8 default methods in core Spring interfaces.
    • Consistent use of JDK 7 Charset and StandardCharsets enhancements.
  • JDK 9 compatibility:
    • Avoiding JDK APIs which are deprecated in JDK 9 wherever possible.
    • Consistent instantiation via constructors (with revised exception handling).
    • Defensive use of reflection against core JDK classes.
  • Non-null API declaration at the package level:
    • Nullable arguments, fields and return values explicitly annotated with @Nullable.
    • Primarily for use with IntelliJ IDEA and Kotlin, but also Eclipse and FindBugs.
    • Some Spring APIs are not tolerating null values anymore (e.g. in StringUtils).
  • Resource abstraction provides isFile indicator for defensive getFile access.
    • Also features NIO-based readableChannel accessor in the Resource interface.
    • File system access via NIO.2 streams (no FileInput/OutputStream used anymore).
  • Spring Framework 5.0 comes with its own Commons Logging bridge out of the box:
    • spring-jcl instead of standard Commons Logging; still excludable/overridable.
    • Autodetecting Log4j 2.x, SLF4J, JUL (java.util.logging) without any extra bridges.
  • spring-core comes with ASM 6.0 (next to CGLIB 3.2.5 and Objenesis 2.6).

Core Container

  • Support for any @Nullable annotations as indicators for optional injection points.
  • Functional style on GenericApplicationContext/AnnotationConfigApplicationContext
    • Supplier-based bean registration API with bean definition customizer callbacks.
  • Consistent detection of transaction, caching, async annotations on interface methods.
    • In case of CGLIB proxies.
  • XML configuration namespaces streamlined towards unversioned schemas.
    • Always resolved against latest xsd files; no support for deprecated features.
    • Version-specific declarations still supported but validated against latest schema.
  • Support for candidate component index (as alternative to classpath scanning).

Spring Web MVC

  • Full Servlet 3.1 signature support in Spring-provided Filter implementations.
  • Support for Servlet 4.0 PushBuilder argument in Spring MVC controller methods.
  • MaxUploadSizeExceededException for Servlet 3.0 multipart parsing on common servers.
  • Unified support for common media types through MediaTypeFactory delegate.
    • Superseding use of the Java Activation Framework.
  • Data binding with immutable objects (Kotlin / Lombok / @ConstructorProperties)
  • Support for the JSON Binding API (as an alternative to Jackson and GSON).
  • Support for Jackson 2.9.
  • Support for Protobuf 3.
  • Support for Reactor 3.1 Flux and Mono as well as RxJava 1.3 and 2.1 as return values from Spring MVC controller methods targeting use of the new reactive WebClient (see below) or Spring Data Reactive repositories in Spring MVC controllers.
  • New ParsingPathMatcher alternative to AntPathMatcher with more efficient parsing and extended syntax.
  • @ExceptionHandler methods allow RedirectAttributes arguments (and therefore flash attributes).
  • Support for ResponseStatusException as a programmatic alternative to @ResponseStatus.
  • Support script engines that do not implement Invocable via direct rendering of the script provided using ScriptEngine#eval(String, Bindings), and also i18n and nested templates in ScriptTemplateView via the new RenderingContext parameter.
  • Spring’s FreeMarker macros (spring.ftl) use HTML output formatting now (requiring FreeMarker 2.3.24+).

Spring WebFlux

  • New spring-webflux module, an alternative to spring-webmvc built on a reactive foundation — fully asynchronous and non-blocking, intended for use in an event-loop execution model vs traditional large thread pool with thread-per-request execution model.
  • Reactive infrastructure in spring-core such as Encoder and Decoder for encoding and decoding streams of Objects; DataBuffer abstraction, e.g. for using Java ByteBuffer or Netty ByteBufReactiveAdapterRegistry for transparent support of reactive libraries in controller method signatures.
  • Reactive infrastructure in spring-web including HttpMessageReader and HttpMessageWriterthat build on and delegate to Encoder and Decoder; server HttpHandler with adapters to (non-blocking) runtimes such as Servlet 3.1+ containers, Netty, and Undertow; WebFilterWebHandler and other non-blocking contract alternatives to Servlet API equivalents.
  • @Controller style, annotation-based, programming model, similar to Spring MVC, but supported in WebFlux, running on a reactive stack, e.g. capable of supporting reactive types as controller method arguments, never blocking on I/O, respecting backpressure all the way to the HTTP socket, and running on extra, non-Servlet containers such as Netty and Undertow.
  • New functional programming model (“WebFlux.fn”) as an alternative to the @Controller, annotation-based, programming model — minimal and transparent with an endpoint routing API, running on the same reactive stack and WebFlux infrastructure.
  • New WebClient with a functional and reactive API for HTTP calls, comparable to the RestTemplate but through a fluent API and also excelling in non-blocking and streaming scenarios based on WebFlux infrastructure; in 5.0 the AsyncRestTemplate is deprecated in favor of the WebClient.

Kotlin support

  • Null-safe API when using Kotlin 1.1.50+
  • Support for Kotlin immutable classes with optional parameters and default values
  • Functional bean definition Kotlin DSL.
  • Functional routing Kotlin DSL for WebFlux.
  • Leveraging Kotlin reified type parameters to avoid specifying explicitly the Class to use for serialization/deserialization in various APIs like RestTemplate or WebFlux APIs.
  • Kotlin null-safety support for @Autowired/@Inject and @RequestParam/@RequestHeader/etc annotations in order to determine if a parameter/bean is required or not.
  • Kotlin script support in ScriptTemplateView for both Spring MVC and Spring WebFlux.
  • Array-like setters added to ModelModelMap and Environement.
  • Support for Kotlin autowired constructor with optional parameters
  • Kotlin reflection is used to determine interface method parameters

Testing Improvements

  • Complete support for JUnit 5‘s Jupiter programming and extension models in the Spring TestContext Framework.
    • SpringExtension: an implementation of multiple extension APIs from JUnit Jupiter that provides full support for the existing feature set of the Spring TestContext Framework. This support is enabled via @ExtendWith(SpringExtension.class).
    • @SpringJUnitConfig: a composed annotation that combines@ExtendWith(SpringExtension.class) from JUnit Jupiter with @ContextConfigurationfrom the Spring TestContext Framework.
    • @SpringJUnitWebConfig: a composed annotation that combines@ExtendWith(SpringExtension.class) from JUnit Jupiter with @ContextConfiguration and @WebAppConfiguration from the Spring TestContext Framework.
    • @EnabledIf: signals that the annotated test class or test method is enabled if the supplied SpEL expression or property placeholder evaluates to true.
    • @DisabledIf: signals that the annotated test class or test method is disabled if the supplied SpEL expression or property placeholder evaluates to true.
  • Support for parallel test execution in the Spring TestContext Framework.
  • New before and after test execution callbacks in the Spring TestContext Framework with support for TestNG, JUnit 5, and JUnit 4 via the SpringRunner (but not via JUnit 4 rules).
    • New beforeTestExecution() and afterTestExecution() callbacks in theTestExecutionListener API and TestContextManager.
  • MockHttpServletRequest now has getContentAsByteArray() and getContentAsString()methods for accessing the content (i.e., request body).
  • The print() and log() methods in Spring MVC Test now print the request body if the character encoding has been set in the mock request.
  • The redirectedUrl() and forwardedUrl() methods in Spring MVC Test now support URI templates with variable expansion.
  • XMLUnit support upgraded to 2.3.

“Portanto, já que vocês aceitaram Cristo Jesus como Senhor, vivam unidos com ele. Estejam enraizados nele, construam a sua vida sobre ele e se tornem mais fortes na fé, como foi ensinado a vocês. E deem sempre graças a Deus.” Colossenses 2:6-7


Spring Framework 4.3.11 disponível

Postado em Atualizado em

Liberada uma a versão 4.3.11 do spring framework. Atualizem seus pom!

“Eu aguardo ansioso a ajuda de Deus, o SENHOR, e confio na sua palavra.” Salmos 130:5

Spring Framework Reference Documentation

Postado em Atualizado em

Falta poucas semanas para o lançamento da versão do spring framework 5, mas já foi liberado o acesso a nova documentação de referencia totalmente refatorado e reorganizada. Ficou fantástico! Vejam  https://docs.spring.io/spring-framework/docs/5.0.0.BUILD-SNAPSHOT/spring-framework-reference/

“O Senhor não demora a fazer o que prometeu, como alguns pensam. Pelo contrário, ele tem paciência com vocês porque não quer que ninguém seja destruído, mas deseja que todos se arrependam dos seus pecados.”2 Pedro 3:9

Poster Spring Framework

Postado em Atualizado em

A Spring é um dos frameworks mais populares para simplificar o desenvolvimento de soluções Java. Ele ajuda os desenvolvedores a criar aplicativos confiáveis e fáceis de manter, reduzindo significativamente o tempo de mercado para projetos complexos. Seus módulos escondem a complexidade de várias tecnologias enterprise, especificações e produtos proprietários, fornecendo uma interface unificada baseada em modelo. O poster abaixo mostra os principais componentes da estrutura e ilustra visualmente como usá-los com amostras de código e diagramas UML simples.

O poster aborda a estrutura geral da estrutura e os módulos amplamente utilizados. Baixe, imprima 24 x 36 e coloca ai na sua parede! Bom final de semana a todos!

“O ladrão só vem para roubar, matar e destruir; mas eu vim para que as ovelhas tenham vida, a vida completa.” João 10:10

Métodos Privados Transacionais com Spring

Postado em

Como a maioria de vocês provavelmente já sabe, devido à própria natureza da solução, a anotação @Transactional do Spring não funciona em métodos privados, devido ao fato que, o controle transacional é gerado via proxy dinâmico que decora a chamada publica da interface. Mas muitas das vezes, eu já precisei fatorar um método privado transacional para reuso de código. E ai vem a pergunta: É possível fazer? Com Java 8 na sua caixa de ferramenta sim, no qual você pode criar um método funcional recebendo um Supplier que faz uma operação publica, totalmente dinâmica que faça o encapsulamento do controle transacional. veja um exemplo:

Como pode ser observado, a versão do Java 8 e suas features funcionais são base da nova revolução que esta acontecendo dentro da linguagem Java. E você, já sabe programar funcional no Java 8? Veja nosso curso de Java SE F5 – Desenvolvedor Funcional Java 8 e entre nessa nova onda!

“As pessoas que pertencem a Cristo Jesus crucificaram a natureza humana delas, junto com todas as paixões e desejos dessa natureza.” Gálatas 5:24

Certificações Spring Framework

Postado em

Recebi hoje uma ótima notícia: a certificação spring framework professional da pivotal não precisa mais de curso obrigatório e você ainda pode fazer em casa:

“We recently announced this exciting change to our Spring Certification Program. Spring Certification Exams are now available for individual purchase, without the enrolling in the course. Yes, you read that right!. Experienced Java developers – with extensive Spring knowledge already – can purchase a Spring Certification Exam directly from Pivotal. That said, the best way to prepare for a Spring Certification Exam is to attend the corresponding Spring course. However, this change to our Certification Program makes proving your Spring expertise even more accessible.”

A partir da versão 4.3, os exames já podem ser feitos no modelo novo:

“With Innovative Exams the certification may be taken in your office or in your own home provided you can demonstrate an open, working area with no books, pencils, paper, mobile phone or any other electronic devices, other than your computer. You must have a webcam with a sufficiently wide field-of-view because you will be monitored throughout the exam.”

Se o valor absurdo em dólar e a burocracia de adquirir o curso obrigatório te impedia de fazer essa prova, assim como aconteceu comigo, agora é hora de tocar o barco e se tornar um profissional oficialmente credenciado e certificado Spring Professional! Quem vem comigo? Um ótimo final de semana 🙂 .

“Faça o que é direito e justo, pois isso agrada mais a Deus do que lhe oferecer sacrifícios.” Provérbios 21:3

Solução de mensageira não é um bicho de 7 cabeças # 1

Postado em Atualizado em

activemq-5-x-box-reflectionVocê já ouviu falar de MOM?

Message oriented middleware (MOM) é servidor de aplicação (infra-estrutura de software + hardware) idealizado exclusivamente para suportar o envio e recebimento de mensagens entre sistemas distribuídos. É um serviço utilizado para intermediar a troca de mensagens entre sistemas, com o objetivo de fazer integração de serviços.

Para que serve um MOM?

Serve para dar solução robusta e confiável na integração entre duas ou mais diferentes soluções. Integrar sistemas hoje é um desafio imenso, diferentes plataformas, diferentes tecnologias, diferentes protocolos, diferentes mecanismos de persistências, assim, se faz necessario garantir serviços dentro da solução de integração como por exemplo: desacoplamento, entrega de mensagem, persistência de mensagem, politicas de retry, processamento assíncrono, escalabilidade, confiabilidade, transação, interrupções, segurança, clusterização e muito etc. Um MOM já faz tudo isso e muito mais.

MOM é para ser utilizado em soluções de grande porte?

Essa é justamente meu ponto: você lendo tal definição, tem a falsa impressão que só usaria um MOM para fazer coisas gigantescas e exorbitantes!!! Mas depois de conhecer Apache ActiveMQ e Spring JMS, você vera que é muito fácil e pode usar para fazer coisas pequenas também. Como diria um amigo meu, “só na manteguinha….. 🙂 “.

Você já ouviu falar de ActiveMQ?

ActiveMQ é uma implementação de um middleware completo (MOM), open source e grátis. Ele possui todas as grandes features necessários para dar solução em coisas de “grande porte”, mas o que o pessoal desconhece é que ele tem um arquitetura tão flexível e é tão bem feito que oferece diversas opções de uso e configurações flexíveis. Umas delas é usar o serviço de MOM de forma “embarcada”, dentro da sua própria instancia da JVM e da solução, não precisando criar um servidor remoto exclusivo para isso. Juntamente com isso, você desabilita as chamadas remotas e questões de persistência, e assim, acaba ficando com um mini-serviço de MOM simples, local com suporte a filas(Queue) e tópicos (Topics) que é justamente a “cereja de bolo” desse tipo de serviço.

Você já ouviu falar de Spring JMS?

Spring JMS é kit de desenvolvimento arquitetural que faz parte do framework spring criado exclusivamente para se trabalhar com integração de sistemas usando MOM. Esse produto abstrai toda a infra-estrutura de código utilizada para programar esse tipo de solução, criando uma facade de serviços rápida, produtiva e fácil de usar, retirando a necessidade de fazer código sujo e infraestrutural (boilepart) necessário para se configurar, enviar e consumir mensagens de um MOM.

Vamos fazer um exemplo prático?

Segue abaixo um exemplo real dessa simples e robusta solução:


  • Maven
  • Eclipse Java EE IDE for Web Developers – Versão Neon.1
  • Groovy-Eclipse plugin


Segue os passos resumido do projeto:

Crie um projeto java maven: New project -> Maven Project. Adicione groovy no projeto: botão direto no projeto -> configure -> Convert to groovy project. Configure o pom para baixar as dependências básicas: groovy, spring, cdi e activemq:


Configurar o spring.xml, subindo o activemq local, sem persistência, sem jmx, sem chamada remota. Configurar uma fila simples e um listener de fila. Configuramos também um jmsTemplate que é a facade de serviços spring que esconde a código sujo de MOM e JMS.


Criar um bean que envia a mensagem da fila:


Criar um bean que consome as mensagens da fila:


Fazer uma classe simples com main para testar o envio e o consumo da mensagem:


Execute a solução e teremos a saída:


E assim, com  menos de 5 minutos, e poucas linhas de código você consegue embarcar e reusar um MOM completo fazendo filas, tópicos, sem persistência, sem chamada remota, sem gastar muita memoria, rápido, fácil e sem perder tempo fazendo na unha qualquer coisa do tipo. Sem contar que você pode evoluir mais esse produto, habilitando serviço por serviço, tudo de acordo com sua necessidade.

Aonde eu uso isso?

Precisou integrar sua solução java com e-mail?, web services soap? web services rest?, banco de dados legados? ou quer gerar um relatório pesado assíncrono? Esta ai seu ponto de partido. ActiveMQ + Spring JMS = Solução simples e rápida com todos os sabores de processamento assíncrono usando filas e tópicos 100% MOM.

Como eu aprendo mais sobre esse assunto?

Tudo isso e muito mais pode ser encontrado no livro ActiveMQ in Action. Excelente livro sobre conceitos de mensageria, JMS e integrações em geral.


Se te interessar, baixe esse projeto no meu git. Até a próxima 😉 !

“Mas tu, ó SENHOR, me proteges como um escudo. Tu me dás a vitória e renovas a minha coragem.” Salmos 3:3