Geekly articles weekly

Spring Boot vs Spring MVC vs Spring - Comment se comparent-ils?

Spring Boot vs Spring MVC vs Spring - Comment se comparent-ils?


image

Spring, Spring Boot, Spring MVC, partout il y a le mot «printemps»! Voyons où et quand vous pouvez utiliser chacun de ces outils.


Dans cet article, vous verrez des critiques: Spring, Spring MVC et Spring Boot, découvrez quels problèmes ils résolvent et où ils sont les mieux appliqués. Le fait le plus important que vous apprenez est que Spring, Spring MVC et Spring Boot ne rivalisent pas pour le même endroit. Ils résolvent différents problèmes, et ils les résolvent très bien.

Quel est le principal problème résolu par ce framework Spring?


Réfléchissez bien et longtemps. Quel est le problème résolu par Spring Framework?

Pourquoi est-ce important? Parce que lorsque DI ou IOC sont utilisés correctement, nous pouvons développer des applications à couplage lâche. Et les applications faiblement couplées peuvent être facilement testées avec des tests unitaires.

Regardons un exemple simple.

Un exemple sans injection de dépendance


Prenons l'exemple ci-dessous: WelcomeController dépend du WelcomeService pour recevoir un message de bienvenue. Que fait-il pour obtenir une instance de WelcomeService?

WelcomeService service = new WelcomeService();

Cette ligne crée une instance de ce service. Et cela signifie qu'ils sont fortement connectés. Par exemple, si je crée une maquette pour WelcomeService dans le test unitaire du WelcomeController, comment puis-je faire en sorte que le WelcomeController utilise la maquette? Pas facile!

 @RestController public class WelcomeController { private WelcomeService service = new WelcomeService(); @RequestMapping("/welcome") public String welcome() { return service.retrieveWelcomeMessage(); } }

Exemple d'injection de dépendance simple


Le monde semble beaucoup plus facile avec l'injection de dépendances. Vous laissez le Spring Framework faire le gros du travail. Nous utilisons simplement deux annotations simples: Component et Autowired .

  • En utilisant Component , nous disons Spring Framework: Hé là, c'est le bac que vous devez gérer.
  • En utilisant Autowired , nous disons Spring Framework: Hé, trouvez la bonne correspondance pour ce type particulier et branchez-le.

Dans l'exemple ci-dessous, le framework Spring créera un bean pour le WelcomeService et le connectera au WelcomeController.

Dans le test unitaire, je peux demander au framework Spring de connecter la maquette WelcomeService au WelcomeController. (Spring Boot facilite les choses en faisant cela avec l'annotation @MockBean. Mais c'est une autre histoire!)

 @Component public class WelcomeService { //Bla Bla Bla }@RestController public class WelcomeController { @Autowired private WelcomeService service; @RequestMapping("/welcome") public String welcome() { return service.retrieveWelcomeMessage(); } }

Qu'est-ce que le Spring Framework résout d'autre?


Problème 1: Duplication de code / pollution


Spring Framework s'arrête-t-il avec l'injection de dépendances? Non. Il s'appuie sur le concept de base de l'injection de dépendances avec plusieurs modules Spring.

  • Spring jdbc
  • Spring mvc
  • Spring aop
  • Orme de printemps
  • Spring jms
  • Test de printemps

Arrêtons-nous un instant sur Spring JMS et Spring JDBC.

Ces modules apportent-ils de nouvelles fonctionnalités? Non. Nous pouvons faire tout cela sur J2EE ou Java EE. Alors qu'apportent-ils? Ils apportent des abstractions simples. Le but de ces abstractions est:

  • Réduire le code de la chaudière / réduire la duplication
  • Promouvoir la déconnexion / étendre la testabilité

Par exemple, vous avez besoin de beaucoup moins de code pour utiliser JDBCTemplate ou JMSTemplate que JDBC ou JMS traditionnel.

Problème 2: bonne intégration avec d'autres cadres


Ce qu'il y a de bien avec le cadre Spring, c'est qu'il n'essaie pas de résoudre des problèmes qui ont déjà été résolus. Il ne fait que fournir une excellente intégration avec d'autres frameworks, qui à leur tour fournissent d'excellentes solutions.

  • Mise en veille prolongée pour ORM
  • iBatis pour la cartographie d'objets
  • JUnit et Mockito pour les tests unitaires

Pourquoi avons-nous besoin d'une botte à ressort?


Les applications basées sur Spring ont de nombreuses configurations.

Lorsque nous utilisons Spring MVC, nous devons configurer: l'analyse des composants, le servlet du répartiteur, le résolveur de vue, les pots Web (pour fournir du contenu statique), entre autres.

 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix"> <value>/WEB-INF/views/</value> </property> <property name="suffix"> <value>.jsp</value> </property> </bean><mvc:resources mapping="/webjars/**" location="/webjars/"/>

Le code ci-dessous montre une configuration de servlet de répartiteur typique dans une application Web.

 <servlet> <servlet-name>dispatcher</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/todo-servlet.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet><servlet-mapping> <servlet-name>dispatcher</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>

Lorsque nous utilisons Hibernate / JPA, nous devons configurer la source de données, la fabrique de gestionnaire d'entités, le gestionnaire de transactions et d'autres choses.

 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> <property name="driverClass" value="${db.driver}" /> <property name="jdbcUrl" value="${db.url}" /> <property name="user" value="${db.username}" /> <property name="password" value="${db.password}" /> </bean><jdbc:initialize-database data-source="dataSource"> <jdbc:script location="classpath:config/schema.sql" /> <jdbc:script location="classpath:config/data.sql" /> </jdbc:initialize-database><bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory"> <property name="persistenceUnitName" value="hsql_pu" /> <property name="dataSource" ref="dataSource" /> </bean><bean id="transactionManager"class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory" /> <property name="dataSource" ref="dataSource" /> </bean><tx:annotation-driven transaction-manager="transactionManager"/>

Problème 1: Configuration automatique de Spring Boot: pouvons-nous penser différemment?


Spring Boot apporte un nouveau processus de réflexion autour de tout cela.

  • Qu'en est-il de la configuration automatique de la source de données si le pot Hibernate se trouve dans le chemin de classe?
  • Qu'en est-il de la configuration automatique d'un servlet Dispatcher si le pot Spring MVC est dans le chemin de classe?

Ensuite, il y aura des dispositions pour remplacer la configuration automatique par défaut.

Problème 2: Projets de démarrage de démarrage de printemps: construits autour de modèles bien connus


Disons que nous voulons développer une application web.

Tout d'abord, nous devons déterminer les cadres que nous voulons utiliser, les versions à utiliser et comment les connecter ensemble.

Toutes les applications Web ont des besoins similaires. Les dépendances suivantes sont utilisées dans Spring MVC. Il s'agit notamment de Spring MVC, Jackson Databind, Hibernate-Validator et Log4j.

 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>4.2.2.RELEASE</version> </dependency><dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.5.3</version> </dependency><dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-validator</artifactId> <version>5.0.2.Final</version> </dependency><dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>

Si vous souhaitez développer une application Web ou une application pour les services RESTful, votre choix est Spring Boot Start Web. Créons rapidement un projet avec Spring Boot Starter Web en utilisant Spring Initializr.

Dépendances pour Spring Boot Starter Web


 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>

La capture d'écran suivante montre les différentes dépendances qui ont été ajoutées à notre application.

image

Les dépendances peuvent être classées en:

  • Spring: core, beans, context, aop
  • Web MVC: (Spring MVC)
  • Jackson: pour la communication JSON
  • Validation: Hibernate Validator, API de validation
  • Conteneur de servlet intégré: Tomcat
  • Journalisation: logback, slf4j

Toute application Web typique utilisera toutes ces dépendances. Spring Boot Starter Web les accompagne. En tant que développeur, je n'ai pas à me soucier de ces dépendances ou versions compatibles.

Options du projet Spring Boot Starter


Comme nous pouvons le voir sur le Spring Boot Starter Web, les projets de démarrage nous aident à démarrer rapidement le développement de certains types d'applications.

  • services-web-spring-boot-starter: SOAP Web Services
  • spring-boot-starter-web: applications Web et RESTful
  • Spring-boot-starter-test: tests unitaires et tests d'intégration
  • spring-boot-starter-jdbc: JDBC traditionnel
  • spring-boot-starter-hateoas: Ajoutez des fonctionnalités HATEOAS à vos services
  • spring-boot-starter-security: authentification et autorisation à l'aide de Spring Security
  • spring-boot-starter-data-jpa: Spring Data JPA avec Hibernate
  • spring-boot-starter-cache: activation de la prise en charge de la mise en cache de Spring Framework
  • spring-boot-starter-data-rest: Fourniture de services REST simples à l'aide de Spring Data REST

Autres objectifs de Spring Boot


Il y a aussi plusieurs entrées pour les choses techniques:

  • Spring-boot-starter-actuator: Pour utiliser des fonctionnalités avancées telles que la surveillance et le suivi de votre application hors de la boîte
  • Spring-Boot-Starter-Undowow, Spring-Boot-Starter-Jetty, Spring-Boot-Starter-Tomcat: pour sélectionner un conteneur de servlet intégré spécifique
  • Spring-boot-starter-logging: pour la journalisation à l'aide de logback
  • spring-boot-starter-log4j2: journalisation à l'aide de Log4j2

Spring Boot vise à créer des applications pour des périodes plus courtes.

  • Actionneur: permet une surveillance et un suivi avancés des applications.
  • Intégrations de serveur intégré: Étant donné que le serveur est intégré à l'application, je dois avoir un serveur d'applications distinct installé sur le serveur
  • Gestion des erreurs par défaut

Source: https://habr.com/ru/post/fr481914/

More articles:


All Articles