Une comparaison entre Spring Boot et Spring Boot

1. Vue d'ensemble

Dans cet article, nous allons examiner les différences entre les frameworks Spring standard et Spring Boot.

Nous allons nous concentrer et discuter de la manière dont les modules de Spring, tels que MVC et Security, diffèrent lorsqu'ils sont utilisés dans le noyau Spring et lorsqu'ils sont utilisés avec Boot.

2. Qu'est-ce que le printemps?

En termes simples, le framework Spring fournit un support d'infrastructure complet pour le développement d'applications Java .

Il contient quelques fonctionnalités intéressantes telles que l'injection de dépendances et des modules prêts à l'emploi tels que:

  • Printemps JDBC
  • Printemps MVC
  • Sécurité du printemps
  • Printemps AOP
  • ORM de printemps
  • Test de ressort

Ces modules peuvent réduire considérablement le temps de développement d'une application.

Par exemple, au début du développement Web Java, nous devions écrire beaucoup de code standard pour insérer un enregistrement dans une source de données. Mais en utilisant le JDBCTemplate du module Spring JDBC, nous pouvons le réduire à quelques lignes de code avec seulement quelques configurations.

3. Qu'est-ce que Spring Boot?

Spring Boot est essentiellement une extension du framework Spring qui a éliminé les configurations standard requises pour la configuration d'une application Spring.

Il adopte une vision avisée de la plateforme Spring qui a ouvert la voie à un écosystème de développement plus rapide et plus efficace .

Voici quelques-unes des fonctionnalités de Spring Boot:

  • Dépendances `` de départ '' avisées pour simplifier la configuration de la construction et de l'application
  • Serveur intégré pour éviter la complexité du déploiement des applications
  • Mesures, vérification de l'état et configuration externalisée
  • Configuration automatique pour la fonctionnalité Spring - chaque fois que possible

Familiarisons-nous pas à pas avec ces deux cadres.

4. Dépendances de Maven

Tout d'abord, examinons les dépendances minimales requises pour créer une application Web à l'aide de Spring:

 org.springframework spring-web 5.2.9.RELEASE   org.springframework spring-webmvc 5.2.9.RELEASE 

Contrairement à Spring, Spring Boot ne nécessite qu'une seule dépendance pour qu'une application Web soit opérationnelle:

 org.springframework.boot spring-boot-starter-web 2.3.4.RELEASE 

Toutes les autres dépendances sont ajoutées automatiquement à l'archive finale pendant la construction.

Un autre bon exemple est le test de bibliothèques. Nous utilisons généralement l'ensemble des bibliothèques Spring Test, JUnit, Hamcrest et Mockito. Dans un projet Spring, nous devrions ajouter toutes ces bibliothèques en tant que dépendances.

Mais dans Spring Boot, nous n'avons besoin que de la dépendance de démarrage pour les tests afin d'inclure automatiquement ces bibliothèques.

Spring Boot fournit un certain nombre de dépendances de démarrage pour différents modules Spring. Certains des plus couramment utilisés sont:

  • spring-boot-starter-data-jpa
  • ressort-boot-starter-security
  • test de démarrage à ressort
  • ressort-boot-starter-web
  • ressort-démarrage-thymeleaf

Pour la liste complète des démarreurs, consultez également la documentation Spring.

5. Configuration MVC

Explorons la configuration requise pour créer une application Web JSP à l'aide de Spring et Spring Boot.

Spring nécessite la définition du servlet du répartiteur, des mappages et d'autres configurations de prise en charge. Nous pouvons le faire en utilisant le fichier web.xml ou une classe Initializer :

public class MyWebAppInitializer implements WebApplicationInitializer { @Override public void onStartup(ServletContext container) { AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext(); context.setConfigLocation("com.baeldung"); container.addListener(new ContextLoaderListener(context)); ServletRegistration.Dynamic dispatcher = container .addServlet("dispatcher", new DispatcherServlet(context)); dispatcher.setLoadOnStartup(1); dispatcher.addMapping("/"); } }

Nous devons également ajouter l' annotation @EnableWebMvc à une classe @Configuration et définir un résolveur de vue pour résoudre les vues renvoyées par les contrôleurs:

@EnableWebMvc @Configuration public class ClientWebConfig implements WebMvcConfigurer { @Bean public ViewResolver viewResolver() { InternalResourceViewResolver bean = new InternalResourceViewResolver(); bean.setViewClass(JstlView.class); bean.setPrefix("/WEB-INF/view/"); bean.setSuffix(".jsp"); return bean; } }

Par rapport à tout cela, Spring Boot n'a besoin que de quelques propriétés pour faire fonctionner les choses, une fois que nous avons ajouté le démarreur Web:

spring.mvc.view.prefix=/WEB-INF/jsp/ spring.mvc.view.suffix=.jsp

Toute la configuration Spring ci-dessus est automatiquement incluse en ajoutant le démarreur Web de démarrage, via un processus appelé configuration automatique.

Cela signifie que Spring Boot examinera les dépendances, propriétés et beans qui existent dans l'application et activera la configuration en fonction de ceux-ci.

Bien sûr, si nous voulons ajouter notre propre configuration personnalisée, la configuration automatique de Spring Boot disparaîtra.

5.1. Configuration du moteur de modèle

Apprenons maintenant à configurer un moteur de modèle Thymeleaf dans Spring et Spring Boot.

Au printemps, nous devons ajouter la dépendance thymeleaf-spring5 et certaines configurations pour le résolveur de vue:

@Configuration @EnableWebMvc public class MvcWebConfig implements WebMvcConfigurer { @Autowired private ApplicationContext applicationContext; @Bean public SpringResourceTemplateResolver templateResolver() { SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver(); templateResolver.setApplicationContext(applicationContext); templateResolver.setPrefix("/WEB-INF/views/"); templateResolver.setSuffix(".html"); return templateResolver; } @Bean public SpringTemplateEngine templateEngine() { SpringTemplateEngine templateEngine = new SpringTemplateEngine(); templateEngine.setTemplateResolver(templateResolver()); templateEngine.setEnableSpringELCompiler(true); return templateEngine; } @Override public void configureViewResolvers(ViewResolverRegistry registry) { ThymeleafViewResolver resolver = new ThymeleafViewResolver(); resolver.setTemplateEngine(templateEngine()); registry.viewResolver(resolver); } }

Spring Boot 1 ne nécessitait que la dépendance de spring-boot-starter-thymeleaf pour activer la prise en charge de Thymeleaf dans une application Web. Mais en raison des nouvelles fonctionnalités de Thymeleaf3.0, nous devons également ajouter thymeleaf-layout-dialect en tant que dépendance dans une application Web Spring Boot 2. Alternativement, nous pouvons choisir d'ajouter une dépendance spring-boot-starter-thymeleaf qui s'occupera de tout cela pour nous.

Once the dependencies are in place, we can add the templates to the src/main/resources/templates folder and the Spring Boot will display them automatically.

6. Spring Security Configuration

For the sake of simplicity, we'll see how the default HTTP Basic authentication is enabled using these frameworks.

Let's start by looking at the dependencies and configuration we need to enable Security using Spring.

Spring requires both the standard spring-security-web and spring-security-config dependencies to set up Security in an application.

Next, we need to add a class that extends the WebSecurityConfigurerAdapter and makes use of the @EnableWebSecurity annotation:

@Configuration @EnableWebSecurity public class CustomWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter { @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication() .withUser("user1") .password(passwordEncoder() .encode("user1Pass")) .authorities("ROLE_USER"); } @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest().authenticated() .and() .httpBasic(); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } }

Here we're using inMemoryAuthentication to set up the authentication.

Similarly, Spring Boot also requires these dependencies to make it work. But we need to define only the dependency ofspring-boot-starter-security as this will automatically add all the relevant dependencies to the classpath.

The security configuration in Spring Boot is the same as the one above.

If you need to know how the JPA configuration can be achieved in both Spring and Spring Boot, then check out our article A Guide to JPA with Spring.

7. Application Bootstrap

The basic difference in bootstrapping of an application in Spring and Spring Boot lies with the servlet. Spring uses either the web.xml or SpringServletContainerInitializer as its bootstrap entry point.

On the other hand, Spring Boot uses only Servlet 3 features to bootstrap an application. Let's talk about this in detail.

7.1. How Spring Bootstraps?

Spring supports both the legacy web.xml way of bootstrapping as well as the latest Servlet 3+ method.

Let's see the web.xml approach in steps:

  1. Servlet container (the server) reads web.xml
  2. The DispatcherServlet defined in the web.xml is instantiated by the container
  3. DispatcherServlet creates WebApplicationContext by reading WEB-INF/{servletName}-servlet.xml
  4. Finally, the DispatcherServlet registers the beans defined in the application context

Here's how Spring bootstraps using Servlet 3+ approach:

  1. The container searches for classes implementing ServletContainerInitializer and executes
  2. The SpringServletContainerInitializer finds all classes implementing WebApplicationInitializer
  3. The WebApplicationInitializer creates the context with XML or @Configuration classes
  4. The WebApplicationInitializer creates the DispatcherServlet with the previously created context.

7.2. How Spring Boot Bootstraps?

The entry point of a Spring Boot application is the class which is annotated with @SpringBootApplication:

@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }

By default, Spring Boot uses an embedded container to run the application. In this case, Spring Boot uses the public static void main entry-point to launch an embedded web server.

Also, it takes care of the binding of the Servlet, Filter, and ServletContextInitializer beans from the application context to the embedded servlet container.

Another feature of Spring Boot is that it automatically scans all the classes in the same package or sub packages of the Main-class for components.

Spring Boot provides the option of deploying it as a web archive in an external container as well. In this case, we have to extend the SpringBootServletInitializer:

@SpringBootApplication public class Application extends SpringBootServletInitializer { // ... }

Here the external servlet container looks for the Main-class defined in the META-INF file of the web archive and the SpringBootServletInitializer will take care of binding the Servlet, Filter, and ServletContextInitializer.

8. Packaging and Deployment

Finally, let's see how an application can be packaged and deployed. Both of these frameworks support the common package managing technologies like Maven and Gradle. But when it comes to deployment, these frameworks differ a lot.

For instance, the Spring Boot Maven Plugin provides Spring Boot support in Maven. It also allows packaging executable jar or war archives and running an application “in-place”.

Some of the advantages of Spring Boot over Spring in the context of deployment include:

  • Provides embedded container support
  • Provision to run the jars independently using the command java -jar
  • Option to exclude dependencies to avoid potential jar conflicts when deploying in an external container
  • Option to specify active profiles when deploying
  • Random port generation for integration tests

9. Conclusion

Dans ce didacticiel, nous avons découvert les différences entre Spring et Spring Boot.

En quelques mots, nous pouvons dire que Spring Boot est simplement une extension de Spring lui-même pour rendre le développement, les tests et le déploiement plus pratiques.