TOC

Une comparaison entre Spring et Spring Boot

Une comparaison entre Spring 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.

Lectures complémentaires:

Configurer une application Web Spring Boot

Certaines des configurations les plus utiles pour une application Spring Boot.

Read more →

Migration de Spring à Spring Boot

Découvrez comment migrer correctement d'une initialisation à une autre.

Read more →

2. Qu'est-ce que le printemps?

Simply put, the Spring framework provides comprehensive infrastructure support for developing Java applications.

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

  • Spring JDBC

  • Spring MVC

  • Sécurité de printemps

  • Printemps AOP

  • ORM de printemps

  • Test de printemps

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 lesJDBCTemplate 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 fondamentalement une extension du cadre Spring, qui élimine les configurations standard requises pour la configuration d’une application Spring.

It takes an opinionated view of the Spring platform which paved the way for a faster and more efficient development eco-system.

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

  • Dépendances de type "starter" pour simplifier la construction et la configuration de l'application

  • Serveur intégré pour éviter la complexité lors du déploiement d'applications

  • Métriques, bilan de santé et configuration externalisée

  • Configuration automatique pour la fonctionnalité Spring - autant que possible

Familiarisons-nous pas à pas avec ces deux cadres.

4. Dépendances 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.1.0.RELEASE


    org.springframework
    spring-webmvc
    5.1.0.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.0.5.RELEASE

Toutes les autres dépendances sont automatiquement ajoutées à l’archive finale lors de la construction.

Un autre bon exemple est le test des 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 pour inclure automatiquement ces bibliothèques.

Spring Boot provides a number of starter dependencies for different Spring modules. Certains des plus couramment utilisés sont:

  • spring-boot-starter-data-jpa

  • ressort-boot-starter-security

  • test de démarrage à ressort

  • web-démarrage-à-ressort

  • Spring-boot-starter-thymeleaf

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

5. Configuration MVC

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

Spring requires defining the dispatcher servlet, mappings, and other supporting configurations. Nous pouvons le faire en utilisant soit le fichierweb.xml, soit une classeInitializer: 

public class MyWebAppInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext container) {
        AnnotationConfigWebApplicationContext context
          = new AnnotationConfigWebApplicationContext();
        context.setConfigLocation("com.example");

        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 only needs a couple of properties to make things work, once we’ve added the web starter: 

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éauto-configuration.

Cela signifie que Spring Boot examinera les dépendances, les propriétés et les beans existant 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 s'éloigne.

5.1. Configuration du moteur de modèle

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

Au printemps, nous devons ajouter la dépendancethymeleaf-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 despring-boot-starter-thymeleaf pour activer la prise en charge deThymeleaf dans une application Web. Mais en raison des nouvelles fonctionnalités deThymeleaf3.0, , swe doit également ajouterthymeleaf-layout-dialect en tant que dépendance dans une application Web Spring Boot 2.

Une fois les dépendances en place, nous pouvons ajouter les modèles au dossiersrc/main/resources/templates et Spring Boot les affichera automatiquement.

6. Configuration de sécurité de printemps

Dans un souci de simplicité, nous allons voir comment l'authentification HTTP Basic par défaut est activée à l'aide de ces frameworks.

Commençons par examiner les dépendances et la configuration dont nous avons besoin pour activer la sécurité à l'aide de Spring.

Spring requires both the standard the spring-security-web and spring-security-config dependencies pour configurer la sécurité dans une application.

Ensuite, l'annotationwe need to add a class that extends the WebSecurityConfigurerAdapter and makes use of the @EnableWebSecurity: 

@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();
    }
}

Ici, nous utilisons lesinMemoryAuthentication pour configurer l'authentification.

De même, Spring Boot requiert également ces dépendances pour le faire fonctionner. Mais nous devons définir uniquement la dépendance despring-boot-starter-security as this will automatically add all the relevant dependencies to the classpath.

La configuration de sécurité dans Spring Boot est la même que celle ci-dessus.

Si vous avez besoin de savoir comment la configuration JPA peut être réalisée à la fois dans Spring et Spring Boot, consultez notre articleA Guide to JPA with Spring.

7. Bootstrap de l'application

La différence fondamentale dans l'amorçage d'une application dans Spring et Spring Boot réside dans le servlet. Spring utilise soitweb.xml soitSpringServletContainerInitializer  comme point d'entrée de bootstrap.

En revanche, Spring Boot utilise uniquement les fonctionnalités de Servlet 3 pour amorcer une application. Parlons de cela en détail.

7.1. Comment Spring Bootstraps?

Spring prend en charge à la fois la méthode de démarrage héritée deweb.xmlainsi que la dernière méthode Servlet 3+.

Voyons l’approcheweb.xml par étapes:

  1. Le conteneur de servlet (le serveur) litweb.xml

  2. LeDispatcherServlet défini dans leweb.xml est instancié par le conteneur

  3. DispatcherServlet créeWebApplicationContext en lisantWEB-INF/{servletName}-servlet.xml

  4. Enfin, leDispatcherServlet enregistre les beans définis dans le contexte de l'application

Voici comment Spring démarre à l'aide de l'approche Servlet 3+:

  1. Le conteneur recherche les classes implémentantServletContainerInitializer  et s'exécute

  2. LeSpringServletContainerInitializer trouve toutes les classes implémentantWebApplicationInitializer

  3. LeWebApplicationInitializer crée le contexte avec les classes XML ou@Configuration

  4. LeWebApplicationInitializer crée le commutateurDispatcherServlet avec le contexte précédemment créé.

7.2. Comment Spring Boot Bootstraps?

Le point d'entrée d'une application Spring Boot est la classe qui est annotée avec@SpringBootApplication: 

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

Spring Boot utilise par défaut un conteneur incorporé pour exécuter l'application. Dans ce cas, Spring Boot utilise le point d'entréepublic static void main pour lancer un serveur Web intégré.

En outre, il prend en charge la liaison des beansServlet, Filter, etServletContextInitializer du contexte d'application au conteneur de servlet intégré.

Une autre caractéristique de Spring Boot est qu'il analyse automatiquement toutes les classes du même package ou des mêmes sous-packages de Main-class à la recherche de composants.

Spring Boot offre également la possibilité de le déployer en tant qu’archive Web dans un conteneur externe. Dans ce cas, nous devons étendre lesSpringBootServletInitializer: 

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

Ici, le conteneur de servlet externe recherche la classe Main définie dans le fichier META-INF de l'archive Web et lesSpringBootServletInitializer se chargeront de lier lesServlet, Filter, etServletContextInitializer.

8. Emballage et déploiement

Enfin, voyons comment une application peut être empaquetée et déployée. Ces deux cadres prennent en charge les technologies de gestion de paquet communes telles que Maven et Gradle. Mais lorsqu'il s'agit de déploiement, ces frameworks diffèrent beaucoup.

Par exemple, leSpring Boot Maven Plugin fournit la prise en charge de Spring Boot dans Maven. Il permet également de conditionner des archives de fichiers jar ou de guerre exécutables et d’exécuter une application «en place».

Certains des avantages de Spring Boot sur Spring dans le contexte du déploiement sont les suivants:

  • Fournit un support de conteneur intégré

  • Possibilité d'exécuter les jars indépendamment à l'aide de la commandejava -jar

  • Option permettant d'exclure les dépendances pour éviter les conflits de jar potentiels lors du déploiement dans un conteneur externe

  • Option pour spécifier les profils actifs lors du déploiement

  • Génération de ports aléatoires pour les tests d'intégration

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 pour rendre le développement, les tests et le déploiement plus pratiques.

Related