Tutoriel pour apprendre à développer les Microcservices REST avec Spring Boot et Spring RestTemplate

package com.bnguimgo.springbootrestclient.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class WelcomeController {

	private static Logger logger = LoggerFactory.getLogger(WelcomeController.class);

	@Autowired
	private RestTemplate restTemplate;

	@Autowired
	private PropertiesConfigurationService configurationService;

	@GetMapping(value = "/")
	ModelAndView ping(ModelAndView modelAndView) {
		// On vérifie directement la disponibilité du serveur au lancement de l'application
		ResponseEntity<String> reponseServeur = restTemplate.getForEntity(configurationService.getUrl(), String.class);
		int codeReponseServeur = reponseServeur.getStatusCodeValue();
		String reponsePing = "";
		if (codeReponseServeur != 200) {
			logger.error("Réponse du serveur: " + codeReponseServeur+ " ==> Serveur indisponible, votre application ne fonctionnera pas correctement");
			reponsePing = configurationService.getPingServeurKo();
		} else {
			reponsePing = configurationService.getPingServeurOk();
			logger.info(configurationService.getPingServeur(), reponsePing);
		}
		// construction de la vue
		modelAndView.setViewName("welcome");
		modelAndView.addObject("urlServeur", configurationService.getUrl());
		modelAndView.addObject("pingServeur", reponsePing);
		modelAndView.addObject("profileActif", configurationService.getProfileActif());
		return modelAndView;
	}

	@GetMapping(value = "/error")
	public String error() {
		return "error";
	}

	@GetMapping("/next")
	ModelAndView next(ModelAndView modelAndView) {
		modelAndView.setViewName("next");
		modelAndView.addObject("message", configurationService.getMessage());
		return modelAndView;
	}
}

@GetMapping(value = "/error")
    public String error() {
        return "error";
    }

package com.bnguimgo.springbootrestclient.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class PropertiesConfigurationService{
 
    @Value("${app.serveur.url}") // injection via application.properties
    private String url="";
    
    @Value("${app.serveur.pingServeur}")
    private String pingServeur;
    
    @Value("${app.serveur.ok}")
    private String pingServeurOk;
    
    @Value("${app.serveur.ko}")
    private String pingServeurKo;
    
    @Value("${nextpage.message}")
    private String message;
    
    @Value("${spring.profiles.active}")
    private String profileActif;
    // getters, setters
    
    public String getUrl() {
        return url;
    }

    public String getPingServeur() {
        return pingServeur;
    }
    
    public String getPingServeurOk() {
        return pingServeurOk;
    }
    
    public String getPingServeurKo() {
        return pingServeurKo;
    }

    public String getMessage() {
        return message;
    }

    public String getProfileActif() {
        return profileActif;
    }
}

#Au démarrage de l'application, en cas d'erreur
server.error.whitelabel.enabled = false
#Chargement du profil par defaut dev
spring.profiles.active=dev

#URL du serveur REST
app.serveur.url = http://localhost:8080/springboot-restserver/
nextpage.message = Salut vous êtes en profile dev
app.serveur.ok = disponible
app.serveur.ko = indisponible
app.serveur.pingServeur = Le serveur est {}
compte.user.exist = Un utilisateur est déjà enregistré avec ce compte

#GESTION DES LOGS
logging.level.org.springframework.web=DEBUG
logging.level.com.bnguimgo.restclient=DEBUG

# Pattern impression des logs consoles
logging.pattern.console= %d{yyyy-MM-dd HH:mm:ss} - %msg%n

# Pattern impression des logs dans un fichier
logging.pattern.file= %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
# Redirection des logs vers un fichier du repertoire Temp, exemple sur windows: C:\Users\UnserName\AppData\Local\Temp\
logging.file= ${java.io.tmpdir}\logs\\restClient\\applicationRestClient.log

logging.level.org.springframework.web=ERROR
logging.level.com.bnguimgo.restclient=ERROR
#
# Pattern impression des logs console
logging.pattern.console= %d{yyyy-MM-dd HH:mm:ss} - %msg%n

# Pattern impression des logs dans un fichier
logging.pattern.file= %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
# Redirection des logs vers un fichier du repertoire Temp, exemple sur windows: C:\Users\UnserName\AppData\Local\Temp\
logging.file=${java.io.tmpdir}/logs/rest/applicationRest.log

package com.bnguimgo.springbootrestclient.controller;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.validation.Valid;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpServerErrorException;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.ModelAndView;

import com.bnguimgo.springbootrestclient.dto.RestClientExceptionDTO;
import com.bnguimgo.springbootrestclient.dto.UserDto;
import com.bnguimgo.springbootrestclient.entities.User;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

@RestController
public class LoginController {

	private static Logger logger = LoggerFactory.getLogger(LoginController.class);

	@Autowired
	private RestTemplate restTemplate;

	@Autowired
	private PropertiesConfigurationService configurationService;

	@GetMapping(value = "/login") // initialisation du login
	public ModelAndView loginView(ModelAndView modelAndView) {
		modelAndView.setViewName("loginForm");
		UserDto userDto = new UserDto();
		modelAndView.addObject("userForm", userDto);
		return modelAndView;
	}

	@PostMapping(value = "/login")
	public ModelAndView login(@Valid @ModelAttribute("userForm") UserDto userForm, BindingResult bindingResult,
			ModelAndView modelAndView) throws JsonMappingException, JsonProcessingException {

		modelAndView.setViewName("loginForm");
		if (bindingResult.hasErrors()) {
			modelAndView.addObject("saveError", "Erreur de saisie");
			return modelAndView;
		}
		try {
			ResponseEntity<User> userExists = restTemplate
					.postForEntity(configurationService.getUrl() + "user/users/login", new User(userForm), User.class);

			modelAndView.addObject("currentUser", new UserDto(userExists.getBody()));
			modelAndView.setViewName("loginSuccess");
			return modelAndView;

		} catch (HttpClientErrorException | HttpServerErrorException ex) {
			ObjectMapper objectMapper = new ObjectMapper();
			RestClientExceptionDTO restClientExceptionDTO = objectMapper.readValue(ex.getResponseBodyAsString(),
					new TypeReference<RestClientExceptionDTO>() {
					});
			modelAndView.setViewName("loginForm");
			modelAndView.addObject("saveError", restClientExceptionDTO.getErrorMessage());
			modelAndView.addObject("createAccount", " Créez votre compte !");
			return modelAndView;
		} catch (Exception ex) {
			modelAndView.setViewName("loginForm");
			modelAndView.addObject("saveError", ex.getMessage());
			modelAndView.addObject("createAccount", " Créez votre compte !");
			return modelAndView;
		}

	}

	@GetMapping(value = "/registration") // initialisation du formulaire de création du compte
	public ModelAndView registrationView(ModelAndView modelAndView) {
		modelAndView.setViewName("registrationForm");
		UserDto userRegistrationForm = new UserDto();
		modelAndView.addObject("registrationForm", userRegistrationForm);
		return modelAndView;
	}

	@PostMapping(value = "/registration")
	public ModelAndView saveUser(@Valid @ModelAttribute("registrationForm") UserDto userDtoForm,
			BindingResult bindingResult, ModelAndView modelAndView)
			throws JsonMappingException, JsonProcessingException {
		modelAndView.setViewName("registrationForm");
		if (bindingResult.hasErrors()) {
			return modelAndView;
		}
		try {
			ResponseEntity<User> userEntitySaved = restTemplate.postForEntity(configurationService.getUrl() + "user/users", new User(userDtoForm), User.class);
			User user = userEntitySaved.getBody();
			modelAndView.addObject("currentUser", new UserDto(user));
			modelAndView.setViewName("loginSuccess");
			return modelAndView;

		} catch (HttpClientErrorException | HttpServerErrorException ex) {
			ObjectMapper objectMapper = new ObjectMapper();
			RestClientExceptionDTO restClientExceptionDTO = objectMapper.readValue(ex.getResponseBodyAsString(),
					new TypeReference<RestClientExceptionDTO>() {
					});
			modelAndView.addObject("saveError", restClientExceptionDTO.getErrorMessage());
			bindingResult.rejectValue("login", "error.user", restClientExceptionDTO.getErrorMessage());
			// login doit être un attribut réel du formulaire UserDto
			return modelAndView;

		} catch (Exception ex) {
			logger.info("Erreur technique de création du compte", ex);
			modelAndView.addObject("saveError", "erreur technique de création du compte");
			return modelAndView;

		}
	}
	
	@GetMapping(value = "/{id}")
	public ModelAndView findUserById(@PathVariable(value = "id") Long id, ModelAndView modelAndView) throws JsonMappingException, JsonProcessingException {
		modelAndView.setViewName("updateUserForm");
		Map<String, Long> variables = new HashMap<>(1);
        variables.put("id", new Long(id));
		try {
			ResponseEntity<User> userEntityFound = restTemplate.getForEntity(configurationService.getUrl() + "user/users/"+String.valueOf(id), User.class);
			UserDto userDto = new UserDto(userEntityFound.getBody());
		modelAndView.addObject("currentUserForm", userDto);
		return modelAndView;
		} catch (HttpClientErrorException | HttpServerErrorException ex) {
			ObjectMapper objectMapper = new ObjectMapper();
			RestClientExceptionDTO restClientExceptionDTO = objectMapper.readValue(ex.getResponseBodyAsString(),
					new TypeReference<RestClientExceptionDTO>() {
					});
			modelAndView.addObject("userNotFoundError", restClientExceptionDTO.getErrorMessage());
			return modelAndView;
		} catch (Exception ex) {
			logger.info("Erreur technique de recherche utilisateur", ex);
			modelAndView.addObject("saveError", "Erreur technique de recherche utilisateur");
			return modelAndView;

		}
	}
	
	@PostMapping(value = "/updateuser")
	public ModelAndView updateUser(@Valid @ModelAttribute("currentUserForm") UserDto userDtoForm, @RequestParam(value ="roles", required=false) Set<String>roles,
			BindingResult bindingResult, ModelAndView modelAndView)
			throws JsonMappingException, JsonProcessingException {
		modelAndView.setViewName("updateUserForm");
		if (bindingResult.hasErrors()) {
			return modelAndView;
		}
		try {
			HttpEntity<User> requestEntity = new HttpEntity<User>(new User(userDtoForm));
			ResponseEntity<User> userEntityUpdated = restTemplate
					.exchange(configurationService.getUrl() + "user/users", HttpMethod.PUT, requestEntity, User.class);
			UserDto userDto = new UserDto(userEntityUpdated.getBody());
			modelAndView.addObject("currentUserForm", userDto);
			modelAndView.addObject("updateSucess", "Mise à jour Ok !");
			modelAndView.setViewName("updateUserForm");
			return modelAndView;

		} catch (HttpClientErrorException | HttpServerErrorException ex) {
			ObjectMapper objectMapper = new ObjectMapper();
			RestClientExceptionDTO restClientExceptionDTO = objectMapper.readValue(ex.getResponseBodyAsString(),
					new TypeReference<RestClientExceptionDTO>() {
					});
			modelAndView.addObject("saveError", restClientExceptionDTO.getErrorMessage());
			bindingResult.rejectValue("login", "error.user", restClientExceptionDTO.getErrorMessage());// login doit être un attribut réel du formulaire UserDto
			return modelAndView;

		} catch (Exception ex) {
			logger.info("Erreur technique de mise à jour", ex);
			modelAndView.addObject("saveError", "erreur technique de mise à jour.");
			return modelAndView;

		}

	}
}

	@GetMapping(value = "/login")
	public ModelAndView loginView(ModelAndView modelAndView) {
		modelAndView.setViewName("loginForm");
		UserDto userDto = new UserDto();
		modelAndView.addObject("userForm", userDto);
		return modelAndView;
	}

@PostMapping(value = "/login")
public ModelAndView login(@Valid @ModelAttribute("userForm") UserDto userForm, BindingResult bindingResult,
		ModelAndView modelAndView) throws JsonMappingException, JsonProcessingException {

	modelAndView.setViewName("loginForm");
	if (bindingResult.hasErrors()) {
		modelAndView.addObject("saveError", "Erreur de saisie");
		return modelAndView;
	}
	try {
		ResponseEntity<User> userExists = restTemplate
				.postForEntity(configurationService.getUrl() + "user/users/login", new User(userForm), User.class);

		modelAndView.addObject("currentUser", new UserDto(userExists.getBody()));
		modelAndView.setViewName("loginSuccess");
		return modelAndView;

	} catch (HttpClientErrorException | HttpServerErrorException ex) {
		ObjectMapper objectMapper = new ObjectMapper();
		RestClientExceptionDTO restClientExceptionDTO = objectMapper.readValue(ex.getResponseBodyAsString(),
				new TypeReference<RestClientExceptionDTO>() {
				});
		modelAndView.setViewName("loginForm");
		modelAndView.addObject("saveError", restClientExceptionDTO.getErrorMessage());
		modelAndView.addObject("createAccount", " Créez votre compte !");
		return modelAndView;
	} catch (Exception ex) {
		modelAndView.setViewName("loginForm");
		modelAndView.addObject("saveError", ex.getMessage());
		modelAndView.addObject("createAccount", " Créez votre compte !");
		return modelAndView;
	}

}

package com.bnguimgo.springbootrestclient.config;

import java.time.Duration;

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;

@Configuration
@EnableWebMvc
@ComponentScan
public class MvcConfiguration implements WebMvcConfigurer {
	
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        resolver.setOrder(1);
        resolver.setViewClass(JstlView.class);
        registry.viewResolver(resolver);
    }
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
    
	@Bean
	public RestTemplate restTemplate(RestTemplateBuilder builder) {
		builder.setConnectTimeout(Duration.ofSeconds(10));//set timeout connection
		return builder.build();
	}
	//Permet de spécifier le chemin d'accès aux fichiers de resources statiques comme le CSS, les images etc.
	@Override
	public void addResourceHandlers(final ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
    }
}