Porównanie butów wiosennych i wiosennych

1. Przegląd

W tym artykule przyjrzymy się różnicom między standardowymi frameworkami Spring i Spring Boot.

Skoncentrujemy się i omówimy, w jaki sposób moduły Spring, takie jak MVC i Security, różnią się, gdy są używane w rdzeniu Spring, a gdy są używane z Boot.

2. Co to jest wiosna?

Mówiąc najprościej, framework Spring zapewnia kompleksową obsługę infrastruktury do tworzenia aplikacji Java .

Jest wyposażony w kilka fajnych funkcji, takich jak Dependency Injection i moduły po wyjęciu z pudełka, takie jak:

  • Wiosna JDBC
  • Spring MVC
  • Wiosenne bezpieczeństwo
  • Spring AOP
  • Spring ORM
  • Test sprężynowy

Moduły te mogą drastycznie skrócić czas tworzenia aplikacji.

Na przykład na początku tworzenia stron internetowych w języku Java musieliśmy napisać dużo standardowego kodu, aby wstawić rekord do źródła danych. Ale używając JDBCTemplate modułu Spring JDBC możemy zredukować go do kilku wierszy kodu z tylko kilkoma konfiguracjami.

3. Co to jest Spring Boot?

Spring Boot jest w zasadzie rozszerzeniem struktury Spring, która wyeliminowała standardowe konfiguracje wymagane do skonfigurowania aplikacji Spring.

Ma uparty pogląd na platformę Spring, która utorowała drogę do szybszego i bardziej wydajnego ekosystemu rozwoju .

Oto tylko kilka funkcji Spring Boot:

  • Przemyślane zależności „startera” w celu uproszczenia kompilacji i konfiguracji aplikacji
  • Wbudowany serwer, aby uniknąć złożoności wdrażania aplikacji
  • Metryki, kontrola stanu i konfiguracja zewnętrzna
  • Automatyczna konfiguracja funkcjonalności Spring - kiedy tylko jest to możliwe

Zapoznajmy się krok po kroku z obydwoma tymi frameworkami.

4. Zależności Mavena

Przede wszystkim przyjrzyjmy się minimalnym zależnościom wymaganym do stworzenia aplikacji internetowej w Spring:

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

W przeciwieństwie do Springa, Spring Boot wymaga tylko jednej zależności, aby uruchomić i uruchomić aplikację internetową:

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

Wszystkie inne zależności są dodawane automatycznie do ostatecznego archiwum w czasie kompilacji.

Innym dobrym przykładem jest testowanie bibliotek. Zwykle korzystamy z zestawu bibliotek Spring Test, JUnit, Hamcrest i Mockito. W projekcie Spring powinniśmy dodać wszystkie te biblioteki jako zależności.

Ale w Spring Boot potrzebujemy tylko zależności startera do testowania, aby automatycznie uwzględnić te biblioteki.

Spring Boot zapewnia szereg zależności startowych dla różnych modułów Spring. Niektóre z najczęściej używanych to:

  • wiosna-boot-rozrusznik-data-jpa
  • zabezpieczenie rozruchu sprężynowego
  • test rozrusznika sprężynowego
  • wiosna-boot-starter-web
  • sprężynowy-rozrusznik-grasicy

Pełną listę starterów znajdziesz także w dokumentacji Spring.

5. Konfiguracja MVC

Przyjrzyjmy się konfiguracji wymaganej do utworzenia aplikacji internetowej JSP przy użyciu zarówno Spring, jak i Spring Boot.

Spring wymaga zdefiniowania serwletu dyspozytora, mapowań i innych konfiguracji pomocniczych. Możemy to zrobić za pomocą pliku web.xml lub klasy 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("/"); } }

Musimy również dodać adnotację @EnableWebMvc do klasy @Configuration i zdefiniować narzędzie do rozpoznawania widoków, aby rozwiązać widoki zwrócone przez kontrolery:

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

W porównaniu z tym wszystkim, Spring Boot potrzebuje tylko kilku właściwości, aby wszystko działało, po dodaniu startera internetowego:

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

Cała powyższa konfiguracja Spring jest automatycznie dołączana przez dodanie startowego startera internetowego w procesie zwanym automatyczną konfiguracją.

Oznacza to, że Spring Boot przyjrzy się zależnościom, właściwościom i komponentom bean, które istnieją w aplikacji i włączy na ich podstawie konfigurację.

Oczywiście, jeśli chcemy dodać własną konfigurację niestandardową, automatyczna konfiguracja Spring Boot wycofa się.

5.1. Konfigurowanie silnika szablonów

Nauczmy się teraz, jak skonfigurować silnik szablonów Thymeleaf zarówno w Spring, jak i Spring Boot.

Wiosną musimy dodać zależność thymeleaf-spring5 i kilka konfiguracji dla resolvera widoku:

@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 wymagał tylko zależności od spring-boot-starter-thymeleaf, aby włączyć obsługę Thymeleaf w aplikacji internetowej. Ale z powodu nowych funkcji w Thymeleaf 3.0, musimy dodać thymeleaf-layout-dialect również jako zależność w aplikacji internetowej Spring Boot 2. Alternatywnie możemy zdecydować się na dodanie zależności sprężyna-rozruch-rozrusznik-tymianek, która zajmie się tym wszystkim za nas.

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

W tym samouczku poznaliśmy różnice między Spring i Spring Boot.

W kilku słowach możemy powiedzieć, że Spring Boot jest po prostu rozszerzeniem samego Springa, dzięki czemu programowanie, testowanie i wdrażanie są wygodniejsze.