Articles : java

Testing Java Spring Boot Microservices

Tests are an essential part of our codebase. At the very least, they minimize the risk of regression when we modify our code. There are several types of tests and each has a specific role: unit tests, integration tests, component tests, contract tests and end-to-end tests. It is crucial to understand the role of each type of test in order to leverage their potential.

The goal of this article is to describe a strategy to use them in order to test Java Spring Boot microservices. For every type of test, we will try to explain its role, its scope as well as tooling we like to use.

java, microservices, spring, tests

How to Write Robust Component Tests

Component tests allow to test complete use cases from end to end. They are often expensive especially in terms of setup and execution time. Thus, thought needs to be given to define their scope. Nevertheless, they are required in order to check and document the overall behaviour of the application or the microservice.

I have noticed that, in the context of microservices, these tests are very cost-effective. Indeed, they can be quite easy to set up because the already existing external API of the microservice can often be used directly without needing additional elements (like a fake server for instance). Moreover, the scope of a microservice is generally limited and can be tested exhaustively in isolation.

The goal of this article is to show how to make these tests robust. The main idea is to make them independent of the implementation.

java, microservices, tests

Setup a Circuit Breaker with Hystrix, Feign Client and Spring Boot

In a microservices architecture, several things can go wrong. A middleware, the network or the service you want to contact can be down. In this world of uncertainty, you have to anticipate problems in order not to break the entire chain and throw an error to the end user when you could offer a partially degraded service instead.

The goal of this article is to show how to implement the circuit breaker pattern using Hystrix, Feign Client and Spring Boot.

java, microservices, spring

Refactoring Conditional Structures with Map

When working on already existing codebases, I often encounter pieces of code that look like this:

public class Day {
  public void start(Weather weather) {
    switch(weather) {
      case RAINY:
          takeAnUmbrella();
          break;
      case SUNNY:
          takeAHat();
          break;
      case STORMY:
          stayHome();
          break;
      default:
          doNothing();
          break;
    }
  }
}

Basically, depending on the weather, an action has to be taken. This kind of code is pretty hard to test and to maintain. The goal of this article is to refactor it using a Map.

clean code, java, refactoring

Controlling the Time in Java

Time is a tricky thing, it’s always changing. Having such moving parts into the codebase can be very annoying when testing, for instance. In this article, we will see how to control the time in Java.

java, tests

Trivia Kata: A Refactoring Story

Refactoring a legacy code can be a tricky business. More often than not, the code is not tested, unclear and contains some bugs. If not planned, the time required to refactor will eat all the time allocated to the feature. The feature will then be implemented very quickly and it will result in more buggy unmaintainable code.

In this blog post, I will try to show some tools and methods to refactor safely a piece of code. I will use the trivia kata as a support for this. The resulting code can be found on GitHub.

java, refactoring

Gérer les dépendances circulaires

Durant mon travail, j'ai rencontré des dépendances circulaires dans une application sur laquelle je suis intervenue. Dans sa plus simple forme, il s'agit de deux classes qui dépendent l'une de l'autre. Ceci est, selon moi, un problème pour plusieurs raisons. L'objectif de cet article est de montrer ce qu'est une dépendance circulaire, en quoi cela peut poser problème, et comment les éliminer.

java, oop

Implémenter un mécanisme d’AOP, sans framework !

L'Aspect Oriented Programming est un paradigme de programmation qui permet de traiter les préoccupations transverses (ou cross cutting concerns en anglais) telles que le logging, le cache ou les transactions séparément du code métier.

L'AOP repose la plupart du temps sur l'utilisation de librairies ou de frameworks qui rendent ce type de programmation assez obscur et parfois difficile à comprendre. L'objectif de cet article est d'expliquer comment cela fonctionne afin de le démystifier.

aop, java, oop

Quoi de neuf dans Spring 5

Juergen Hoeller a annoncé hier la sortie de Spring 5.0 M1. Cette nouvelle version majeure de Spring arrive avec son lot de nouveautés. L'objectif de cet article est de découvrir ces nouveautés et ce qu'elles peuvent apporter aux développeurs Spring. Les nouveautés décrites dans cet article sont déjà disponibles dans la version 5.0.M1.

java, reactive, spring

Pourquoi ne pas utiliser l'héritage pour éviter la duplication de code ?

L'héritage est une composante très importante des langages orientés objet tels que Java. Cependant, il doit être utilisé à bon escient afin de respecter les bonnes pratiques de programmation.

Il m'est arrivé de rencontrer des cas où l'héritage était utilisé afin de ne pas dupliquer du code. Le but de cet article est d'illustrer une telle utilisation, d'analyser ses inconvénients et de montrer une manière possible de la corriger.

java, oop

Testing Spring MVC Controllers

Since Spring 3.2 (January, 2013), it is possible to test Spring MVC controllers without an external framework. The goal of this article is to show how to test Spring MVC controllers using only Spring testing capabilities.

java, spring, spring mvc, tests

Exposer des ressources statiques avec Spring MVC

Il est souvent nécessaire d'exposer des ressources statiques telles que des images, des fichiers pdf, des vidéos, etc. dans une application web. Ces fichiers sont stockés sur le serveur et ne sont donc pas accessibles à l'utilisateur via une URL.

L'objectif de cet article est d'exposer des fichiers stockés sur le serveur via une URL dans une application Spring MVC.

java, spring, spring mvc

Transférer des paramètres à travers un redirect avec Spring MVC

Dans une application web, il est courant d'effectuer une redirection après la soumission d'un formulaire. Cette redirection permet notamment de rendre l'url bookmarkable et d'empêcher l'utilisateur de resoumettre le formulaire par erreur (suite à un refresh, par exemple).

Il peut être intéressant de passer des paramètres à travers ce redirect. Par exemple, pour indiquer à l'utilisateur que son formulaire a bien été soumis. Pour ce faire, il est possible d'ajouter des paramètres directement dans l'url : redirect:/path/to/endpoint?formSubmitted=true. Cette solution n'est pas toujours adpatée pour des raisons de confidentialité, de taille d'url ou simplement d'esthétique.

L'objectif de cet article est de démontrer comment transférer des paramètres à travers une redirection avec Spring MVC en utilisant des flash attributes. L'exemple utilisé consistera en un formulaire qui permet d'envoyer un nom. Ce nom s'affichera ensuite une fois le formulaire soumis.

java, spring, spring mvc

Spring Security et Spring Boot

Depuis Spring 3.1, il est possible de configurer Spring en Java. La configuration Java de Spring Security est supportée depuis sa version 3.2 (source).

L'objectif de cet article est de montrer comment configurer Spring Security en Java config, dans une application Spring Boot, avec une base de données qui contient les utilisateurs et leur mot de passe hashé. De plus, une authentification HTTP basic sera mise en place.

java, spring, spring boot, spring security

Injections de dépendances avec Spring

Il existe plusieurs méthodes pour injecter une dépendance dans un objet Java :

Cet article a pour objectif de définir ces différentes méthodes, de décrire leurs avantages et inconvénients et indiquer leurs cas d'utilisation.

java, spring

Multiples vues JSON avec @JsonView

Le format Json est de plus en plus utilisé aujourd'hui notamment dans les API de type REST qui offrent des services et retournent leurs résultats sous ce format. Afin d'éviter d'avoir à écrire la transformation en Json manuellement, il existe de nombreuses librairies permettant de faire cette transformation de manière automatique.

Dans cet article, nous allons voir comment utiliser la librairie Jackson et notamment l'annotation @JsonView pour configurer plusieurs transformations pour un même objet. Nous allons également voir succintement comment intégrer cette annotation avec le framework Spring MVC.

java, json, spring

Eviter les classes utilitaires et les appels statiques

De manière générale, les appels statiques sont des mauvaises pratiques car ils induisent notamment un fort couplage entre les classes et rendent les méthodes appelantes difficiles à tester. Cependant, il existe un cas d'utilisation qui utilise abondamment des appels statiques : il s'agit des classes utilitaires.

Cet article a pour objectif de voir comment et quand se passer des appels statiques aux classes utilitaires.

java, oop

Distribuer son application java sur Mac OSX grâce à Maven

Dans un article précédent, nous avons vu comment distribuer son application Java sur Windows grâce à Maven. Cet article vise à faire la même chose sur MacOSX. Nous n'allons donc pas revenir sur l'alternative qui vise à distribuer directement le jar et passer directement à la partie qui nous intéresse, à savoir distribuer un exécutable Mac OSX.

java, maven

Distribuer son application java sur Windows grâce à Maven

Vous avez développé une application java qui va révolutionner le monde. Bravo ! Maintenant, il vous faut la distribuer au monde entier afin que chacun puisse en profiter. Cet article a pour but de montrer comment le faire grâce à l'outil Maven. Il ne s'agit pas d'un article sur Maven en lui-même ni sur la mise en place d'un projet avec Maven.

java, maven