Ein Vergleich zwischen Spring und Spring Boot

1. Überblick

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.

Weitere Lektüre:

Konfigurieren Sie eine Spring Boot-Webanwendung

Einige der nützlicheren Konfigurationen für eine Spring Boot-Anwendung.

Migration von Spring zu Spring Boot

Hier erfahren Sie, wie Sie ordnungsgemäß von einem Spring zu einem Spring Boot migrieren.

2. Was ist Frühling?

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

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

Spring JDBC
Spring MVC
Frühling Sicherheit
Frühling AOP
Frühling ORM
Frühlingstest

Diese Module können die Entwicklungszeit einer Anwendung drastisch verkürzen.

In den Anfängen der Java-Webentwicklung mussten wir zum Beispiel viel Code für Boilerplates schreiben, um einen Datensatz in eine Datenquelle einzufügen. Durch die Verwendung vonJDBCTemplate des Spring JDBC-Moduls können wir es jedoch mit nur wenigen Konfigurationen auf wenige Codezeilen reduzieren.

3. Was ist Spring Boot?

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

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

Hier sind nur einige der Funktionen von Spring Boot:

Meinungen zu 'Starter'-Abhängigkeiten zur Vereinfachung der Build- und Anwendungskonfiguration
Eingebetteter Server, um Komplexität bei der Anwendungsbereitstellung zu vermeiden
Metriken, Integritätsprüfung und ausgelagerte Konfiguration
Automatische Konfiguration für 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.1.0.RELEASE


    org.springframework
    spring-webmvc
    5.1.0.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.0.5.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 Starter-Abhängigkeit zum Testen, um diese Bibliotheken automatisch einzuschließen.

Spring Boot provides a number of starter dependencies for different Spring modules. 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 inSpring documentation.

5. MVC-Konfiguration

Lassen Sie uns die Konfiguration erkunden, die erforderlich ist, um eine JSP-Webanwendung mit Spring und Spring Boot zu erstellen.

Spring requires defining the dispatcher servlet, mappings, and other supporting configurations. Wir können dies entweder mit der Dateiweb.xml oder einer KlasseInitializertun:

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

Wir müssen auch die Annotation@EnableWebMvczu einer Klasse@Configurationhinzufügen und einen Ansichtsauflöser 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 istSpring 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

Die gesamte oben genannte Spring-Konfiguration wird automatisch hinzugefügt, indem der Boot-Webstarter über einen Prozess namensauto-configuration 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 natürlich unsere eigene benutzerdefinierte Konfiguration hinzufügen möchten, wird die automatische Spring Boot-Konfiguration zurückgesetzt.

5.1. Template Engine konfigurieren

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

Im Frühjahr müssen wir die Abhängigkeit vonthymeleaf-spring5und 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 vonspring-boot-starter-thymeleaf , um die Unterstützung vonThymeleafin einer Webanwendung zu aktivieren. Aufgrund der neuen Funktionen inThymeleaf3.0, muss swethymeleaf-layout-dialect also als Abhängigkeit in einer Spring Boot 2-Webanwendung hinzufügen.

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

6. Spring-Sicherheitskonfiguration

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.

Spring requires both the standard the spring-security-web and spring-security-config dependencies, um die Sicherheit in einer Anwendung einzurichten.

Als nächstes die Anmerkung vonwe 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();
    }
}

Hier verwenden wirinMemoryAuthentication, 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 vonspring-boot-starter-security as this will automatically add all the relevant dependencies to the classpath. definieren

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 ArtikelA Guide to JPA with Spring.

7. Anwendungs-Bootstrap

Der grundlegende Unterschied beim Bootstrapping einer Anwendung in Spring und Spring Boot liegt beim Servlet. Spring verwendet entwederweb.xml oderSpringServletContainerInitializer as als Bootstrap-Einstiegspunkt.

Andererseits verwendet Spring Boot nur Servlet 3-Funktionen, um eine Anwendung zu booten. Lassen Sie uns ausführlich darüber sprechen.

7.1. Wie Spring Bootstraps?

Spring unterstützt sowohl die Bootstrapping-Methode von Legacyweb.xmlals auch die neueste Servlet 3+ -Methode.

Sehen wir uns den Ansatz vonweb.xmlin Schritten an:

Der Servlet-Container (der Server) liestweb.xml
Die inweb.xml definiertenDispatcherServlet werden vom Container instanziiert
DispatcherServlet erzeugtWebApplicationContext durch Lesen vonWEB-INF/{servletName}-servlet.xml
Schließlich registriertDispatcherServlet die im Anwendungskontext definierten Beans

So starten Spring-Bootstraps mit Servlet 3+:

Der Container sucht nach Klassen, dieServletContainerInitializer implementieren, und wird ausgeführt
SpringServletContainerInitializer findet alle Klassen, dieWebApplicationInitializer implementieren
DasWebApplicationInitializer erstellt den Kontext mit XML- oder@Configuration-Klassen
DasWebApplicationInitializer erstellt dasDispatcherServlet mit dem zuvor erstellten Kontext.

7.2. Wie Spring Boot Bootstraps?

Der Einstiegspunkt einer Spring Boot-Anwendung ist die Klasse, die mit@SpringBootApplication versehen ist:

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

Standardmäßig verwendet Spring Boot einen eingebetteten Container, um die Anwendung auszuführen. In diesem Fall verwendet Spring Boot den Einstiegspunkt vonpublic static void main, um einen eingebetteten Webserver zu starten.

Außerdem wird die Bindung der BeansServlet, Filter, undServletContextInitializer aus dem Anwendungskontext an den eingebetteten Servlet-Container sichergestellt.

Eine weitere Funktion von Spring Boot besteht darin, dass alle Klassen im selben Paket oder in denselben Unterpaketen der Hauptklasse automatisch nach Komponenten durchsucht werden.

Spring Boot bietet die Möglichkeit, es auch als Webarchiv in einem externen Container bereitzustellen. In diesem Fall müssen wir dieSpringBootServletInitializer verlängern:

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

Hier sucht der externe Servlet-Container nach der in der META-INF-Datei des Webarchivs definierten Hauptklasse, und dieSpringBootServletInitializer kümmern sich um die Bindung derServlet, Filter, undServletContextInitializer.

8. Verpackung und Bereitstellung

Lassen Sie uns abschließend sehen, wie eine Anwendung gepackt und bereitgestellt werden kann. Beide Frameworks unterstützen die gängigen Paketverwaltungstechnologien wie Maven und Gradle. Bei der Bereitstellung unterscheiden sich diese Frameworks jedoch erheblich.

Zum Beispiel bietetSpring Boot Maven Plugin Spring Boot-Unterstützung in Maven. Es ermöglicht auch das Packen von ausführbaren JAR- oder Kriegsarchiven und das Ausführen einer Anwendung "an Ort und Stelle".

Zu den Vorteilen von Spring Boot gegenüber Spring im Rahmen der Bereitstellung gehören:

Unterstützt eingebettete Container
Bereitstellung, um die Gläser unabhängig mit dem Befehljava -jar auszuführen
Option zum Ausschließen von Abhängigkeiten, um mögliche Jar-Konflikte bei der Bereitstellung in einem externen Container zu vermeiden
Option zum Angeben aktiver Profile bei der Bereitstellung
Zufällige Portgenerierung für Integrationstests

9. Fazit

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

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

TOC

Ein Vergleich zwischen Spring und Spring Boot