O comparație între primăvară și primăvară

1. Prezentare generală

În acest articol, vom analiza diferențele dintre cadrele standard Spring și Spring Boot.

Ne vom concentra asupra și vom discuta despre modul în care modulele Spring, precum MVC și Security, diferă atunci când sunt utilizate în Core Spring față de atunci când sunt utilizate cu Boot.

2. Ce este primăvara?

Pur și simplu, cadrul de primăvară oferă suport de infrastructură complet pentru dezvoltarea aplicațiilor Java .

Este plin de câteva caracteristici frumoase, cum ar fi injecția de dependență și module scoase din cutie, cum ar fi:

  • JDBC de primăvară
  • MVC de primăvară
  • Securitate de primăvară
  • Primăvara AOP
  • ORM de primăvară
  • Test de primăvară

Aceste module pot reduce drastic timpul de dezvoltare al unei aplicații.

De exemplu, în primele zile ale dezvoltării web Java, trebuia să scriem o mulțime de coduri pentru a insera o înregistrare într-o sursă de date. Dar folosind modelul JDBCT al modulului Spring JDBC îl putem reduce la câteva linii de cod cu doar câteva configurații.

3. Ce este Spring Boot?

Spring Boot este în esență o extensie a cadrului Spring, care a eliminat configurațiile cazanului necesare pentru configurarea unei aplicații Spring.

Este nevoie de o viziune opinionată asupra platformei de primăvară, care a deschis calea către un ecosistem de dezvoltare mai rapid și mai eficient .

Iată doar câteva dintre caracteristicile din Spring Boot:

  • Dependențe „starter” opinionate pentru a simplifica construirea și configurația aplicației
  • Server încorporat pentru a evita complexitatea în implementarea aplicației
  • Valori, verificare de sănătate și configurație externalizată
  • Configurare automată pentru funcționalitatea Spring - ori de câte ori este posibil

Să ne familiarizăm cu aceste două cadre pas cu pas.

4. Dependențele Maven

În primul rând, să ne uităm la dependențele minime necesare pentru a crea o aplicație web folosind Spring:

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

Spre deosebire de Spring, Spring Boot necesită o singură dependență pentru a pune în funcțiune o aplicație web:

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

Toate celelalte dependențe sunt adăugate automat la arhiva finală în timpul construirii.

Un alt exemplu bun este testarea bibliotecilor. De obicei folosim setul de biblioteci Spring Test, JUnit, Hamcrest și Mockito. Într-un proiect de primăvară, ar trebui să adăugăm toate aceste biblioteci ca dependențe.

Dar în Spring Boot, avem nevoie doar de dependența de pornire pentru testare pentru a include automat aceste biblioteci.

Spring Boot oferă o serie de dependențe de pornire pentru diferite module Spring. Unele dintre cele mai frecvent utilizate sunt:

  • spring-boot-starter-data-jpa
  • spring-boot-starter-security
  • spring-boot-starter-test
  • spring-boot-starter-web
  • spring-boot-starter-thymeleaf

Pentru lista completă a starterelor, consultați și documentația de primăvară.

5. Configurare MVC

Să explorăm configurația necesară pentru a crea o aplicație web JSP utilizând atât Spring cât și Spring Boot.

Primăvara necesită definirea servletului dispecer, mapări și alte configurații suport. Putem face acest lucru folosind fie fișierul web.xml, fie o clasă 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("/"); } }

De asemenea, trebuie să adăugăm adnotarea @EnableWebMvc la o clasă @Configuration și să definim un view-resolver pentru a rezolva vizualizările returnate de la controlere:

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

În comparație cu toate acestea, Spring Boot are nevoie doar de câteva proprietăți pentru a face lucrurile să funcționeze, după ce am adăugat starterul web:

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

Toată configurația de primăvară de mai sus este inclusă automat prin adăugarea starterului web Boot, printr-un proces numit auto-configurare.

Ceea ce înseamnă acest lucru este că Spring Boot va analiza dependențele, proprietățile și fasolea care există în aplicație și va permite configurarea pe baza acestora.

Desigur, dacă dorim să adăugăm propria noastră configurație personalizată, atunci configurarea automată Spring Boot va reveni.

5.1. Configurarea motorului de șabloane

Să învățăm acum cum să configurăm un motor de șabloane Thymeleaf atât în ​​Spring cât și în Spring Boot.

În primăvară trebuie să adăugăm dependența thymeleaf-spring5 și câteva configurații pentru rezolvatorul de vizualizare:

@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 a necesitat doar dependența spring-boot-starter-thymeleaf pentru a permite suportul Thymeleaf într-o aplicație web. Dar, datorită noilor caracteristici din Thymeleaf3.0, trebuie să adăugăm thymeleaf-layout-dialect și ca dependență într-o aplicație web Spring Boot 2. Alternativ, putem alege să adăugăm o dependență spring-boot-starter-thymeleaf care să se ocupe de toate acestea pentru noi.

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

În acest tutorial, am aflat despre diferențele dintre Spring Boot și Spring Boot.

În câteva cuvinte, putem spune că Spring Boot este pur și simplu o extensie a Spring în sine pentru a face dezvoltarea, testarea și implementarea mai convenabile.