Ein Vergleich zwischen Spring und Spring Boot

1. Übersicht

In diesem Artikel werden wir uns die Unterschiede zwischen den Standard-Spring-Frameworks und Spring Boot ansehen.

Wir werden uns darauf konzentrieren und diskutieren, wie sich die Module von Spring, wie MVC und Security, bei Verwendung in Core Spring von denen bei Boot unterscheiden.

2. Was ist Frühling?

Einfach ausgedrückt bietet das Spring-Framework umfassende Infrastrukturunterstützung für die Entwicklung von Java-Anwendungen .

Es enthält einige nette Funktionen wie Dependency Injection und sofort einsatzbereite Module wie:

  • Frühling JDBC
  • Feder MVC
  • Frühlingssicherheit
  • Frühling AOP
  • Frühling ORM
  • Frühlingstest

Diese Module können die Entwicklungszeit einer Anwendung drastisch reduzieren.

In den frühen Tagen der Java-Webentwicklung mussten wir beispielsweise viel Boilerplate-Code schreiben, um einen Datensatz in eine Datenquelle einzufügen. Mit der JDBCTemplate des Spring JDBC-Moduls können wir sie jedoch mit nur wenigen Konfigurationen auf wenige Codezeilen reduzieren.

3. Was ist Spring Boot?

Spring Boot ist im Grunde eine Erweiterung des Spring-Frameworks, bei der die für die Einrichtung einer Spring-Anwendung erforderlichen Boilerplate-Konfigurationen entfallen.

Sie nimmt eine Stellungnahme zur Spring-Plattform ein, die den Weg für ein schnelleres und effizienteres Entwicklungsökosystem ebnete .

Hier sind nur einige der Funktionen von Spring Boot:

  • Meinungen zu Starter-Abhängigkeiten zur Vereinfachung der Build- und Anwendungskonfiguration
  • Eingebetteter Server zur Vermeidung von Komplexität bei der Anwendungsbereitstellung
  • Metriken, Integritätsprüfung und externe Konfiguration
  • Automatische Konfiguration für die Spring-Funktionalität - wann immer möglich

Machen wir uns Schritt für Schritt mit diesen beiden Frameworks vertraut.

4. Maven-Abhängigkeiten

Schauen wir uns zunächst die Mindestabhängigkeiten an, die zum Erstellen einer Webanwendung mit Spring erforderlich sind:

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

Im Gegensatz zu Spring benötigt Spring Boot nur eine Abhängigkeit, um eine Webanwendung zum Laufen zu bringen:

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

Alle anderen Abhängigkeiten werden während der Erstellungszeit automatisch zum endgültigen Archiv hinzugefügt.

Ein weiteres gutes Beispiel ist das Testen von Bibliotheken. Normalerweise verwenden wir die Bibliotheken Spring Test, JUnit, Hamcrest und Mockito. In einem Spring-Projekt sollten wir alle diese Bibliotheken als Abhängigkeiten hinzufügen.

In Spring Boot benötigen wir jedoch nur die Starterabhängigkeit zum Testen, um diese Bibliotheken automatisch einzuschließen.

Spring Boot bietet eine Reihe von Starterabhängigkeiten für verschiedene Spring-Module. Einige der am häufigsten verwendeten sind:

  • Spring-Boot-Starter-Daten-jpa
  • Spring-Boot-Starter-Sicherheit
  • Spring-Boot-Starter-Test
  • Spring-Boot-Starter-Web
  • Spring-Boot-Starter-Thymeleaf

Die vollständige Liste der Starter finden Sie auch in der Spring-Dokumentation.

5. MVC-Konfiguration

Lassen Sie uns die Konfiguration untersuchen, die zum Erstellen einer JSP-Webanwendung mit Spring und Spring Boot erforderlich ist.

Für Spring müssen das Dispatcher-Servlet, die Zuordnungen und andere unterstützende Konfigurationen definiert werden. Wir können dies entweder mit der Datei web.xml oder einer Initializer- Klasse tun :

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

Wir müssen auch die Annotation @EnableWebMvc zu einer @ Configuration- Klasse hinzufügen und einen View-Resolver definieren, um die von den Controllern zurückgegebenen Ansichten aufzulösen:

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

Im Vergleich dazu benötigt Spring Boot nur einige Eigenschaften, damit die Dinge funktionieren, sobald wir den Webstarter hinzugefügt haben:

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

Die gesamte oben genannte Spring-Konfiguration wird automatisch hinzugefügt, indem der Boot-Webstarter über einen Prozess namens Autokonfiguration hinzugefügt wird.

Dies bedeutet, dass Spring Boot die in der Anwendung vorhandenen Abhängigkeiten, Eigenschaften und Beans überprüft und die darauf basierende Konfiguration aktiviert.

Wenn wir unsere eigene benutzerdefinierte Konfiguration hinzufügen möchten, wird die automatische Spring Boot-Konfiguration natürlich zurückgesetzt.

5.1. Template Engine konfigurieren

Lassen Sie uns nun lernen, wie Sie eine Thymeleaf- Vorlagen-Engine sowohl in Spring als auch in Spring Boot konfigurieren .

Im Frühjahr müssen wir die Abhängigkeit von Thymeleaf-Spring5 und einige Konfigurationen für den Ansichtsauflöser hinzufügen :

@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 erforderte nur die Abhängigkeit von Spring-Boot-Starter-Thymeleaf , um die Thymeleaf- Unterstützung in einer Webanwendung zu aktivieren . Aufgrund der neuen Funktionen in Thymeleaf3.0 müssen wir den Thymeleaf-Layout-Dialekt auch als Abhängigkeit in einer Spring Boot 2-Webanwendung hinzufügen . Alternativ können wir eine Spring-Boot-Starter-Thymeleaf- Abhängigkeit hinzufügen , die all dies für uns erledigt .

Sobald die Abhängigkeiten vorhanden sind, können wir die Vorlagen zum Ordner src / main / resources / templates hinzufügen, und der Spring Boot zeigt sie automatisch an.

6. Spring Security-Konfiguration

Der Einfachheit halber werden wir sehen, wie die Standard-HTTP-Basisauthentifizierung mithilfe dieser Frameworks aktiviert wird.

Schauen wir uns zunächst die Abhängigkeiten und Konfigurationen an, die wir benötigen, um die Sicherheit mit Spring zu aktivieren.

Frühling erfordert sowohl die Standard - Feder-security-Bahn und Feder-security-config - Abhängigkeiten Sicherheit einzurichten in einer Anwendung.

Als Nächstes müssen wir eine Klasse hinzufügen, die den WebSecurityConfigurerAdapter erweitert und die Annotation @EnableWebSecurity verwendet :

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

Hier verwenden wir inMemoryAuthentication , um die Authentifizierung einzurichten.

In ähnlicher Weise benötigt Spring Boot auch diese Abhängigkeiten, damit es funktioniert. Wir müssen jedoch nur die Abhängigkeit der Spring-Boot-Starter-Sicherheit definieren, da dadurch automatisch alle relevanten Abhängigkeiten zum Klassenpfad hinzugefügt werden.

Die Sicherheitskonfiguration in Spring Boot ist dieselbe wie oben.

Wenn Sie wissen möchten, wie die JPA-Konfiguration sowohl in Spring als auch in Spring Boot erreicht werden kann, lesen Sie unseren Artikel Ein Handbuch zu JPA mit Spring.

7. Anwendungs-Bootstrap

Der grundlegende Unterschied beim Bootstrapping einer Anwendung in Spring und Spring Boot liegt im Servlet. Spring verwendet entweder die Datei web.xml oder SpringServletContainerInitializer als Bootstrap-Einstiegspunkt.

Auf der anderen Seite verwendet Spring Boot nur Servlet 3-Funktionen, um eine Anwendung zu booten. Lassen Sie uns darüber im Detail sprechen.

7.1. Wie Spring Bootstraps?

Spring unterstützt sowohl die ältere web.xml- Methode zum Bootstrapping als auch die neueste Servlet 3+ -Methode.

Sehen wir uns den web.xml- Ansatz in Schritten an:

  1. Der Servlet-Container (der Server) liest web.xml
  2. Das in der Datei web.xml definierte DispatcherServlet wird vom Container instanziiert
  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

In diesem Tutorial haben wir die Unterschiede zwischen Spring und Spring Boot kennengelernt.

Mit wenigen Worten können wir sagen, dass Spring Boot einfach eine Erweiterung von Spring selbst ist, um die Entwicklung, das Testen und die Bereitstellung komfortabler zu gestalten.