Fragen zum Spring Boot-Interview

1. Einleitung

Seit seiner Einführung ist Spring Boot ein wichtiger Akteur im Spring-Ökosystem. Dieses Projekt erleichtert unser Leben durch seine Fähigkeit zur automatischen Konfiguration erheblich.

In diesem Tutorial werden einige der häufigsten Fragen im Zusammenhang mit Spring Boot behandelt, die während eines Vorstellungsgesprächs auftreten können.

2. Fragen

Q1. Was ist Spring Boot und was sind seine Hauptmerkmale?

Spring Boot ist im Wesentlichen ein Framework für die schnelle Anwendungsentwicklung, das auf dem Spring Framework aufbaut. Mit seiner Unterstützung für die automatische Konfiguration und den eingebetteten Anwendungsserver sowie der umfassenden Dokumentation und Community-Unterstützung ist Spring Boot derzeit eine der beliebtesten Technologien im Java-Ökosystem.

Hier sind einige herausragende Merkmale:

  • Starter - eine Reihe von Abhängigkeitsbeschreibungen, die relevante Abhängigkeiten auf einmal enthalten
  • Automatische Konfiguration - Eine Möglichkeit, eine Anwendung basierend auf den im Klassenpfad vorhandenen Abhängigkeiten automatisch zu konfigurieren
  • Aktuator - um produktionsbereite Funktionen wie Überwachung zu erhalten
  • Sicherheit
  • Protokollierung

Q2. Was sind die Unterschiede zwischen Spring und Spring Boot?

Das Spring Framework bietet mehrere Funktionen, die die Entwicklung von Webanwendungen erleichtern. Diese Funktionen umfassen Abhängigkeitsinjektion, Datenbindung, aspektorientierte Programmierung, Datenzugriff und vieles mehr.

Im Laufe der Jahre wurde Spring immer komplexer, und die Menge an Konfiguration, die eine solche Anwendung erfordert, kann einschüchternd sein. Hier bietet sich Spring Boot an - die Konfiguration einer Spring-Anwendung wird zum Kinderspiel.

Während Spring nicht der Meinung ist, nimmt Spring Boot im Wesentlichen eine Stellungnahme zur Plattform und zu den Bibliotheken ein, sodass wir schnell loslegen können .

Hier sind zwei der wichtigsten Vorteile, die Spring Boot bietet:

  • Konfigurieren Sie Anwendungen automatisch anhand der Artefakte, die im Klassenpfad gefunden werden
  • Stellen Sie nicht funktionierende Funktionen bereit, die für Anwendungen in der Produktion üblich sind, z. B. Sicherheits- oder Integritätsprüfungen

In einem unserer anderen Tutorials finden Sie einen detaillierten Vergleich zwischen Vanilla Spring und Spring Boot.

Q3. Wie können wir mit Maven eine Spring Boot-Anwendung einrichten?

Wir können Spring Boot wie jede andere Bibliothek in ein Maven-Projekt aufnehmen. Der beste Weg ist jedoch, vom übergeordneten Spring-Boot-Starter- Projekt zu erben und Abhängigkeiten zu Spring Boot-Startern zu deklarieren. Auf diese Weise kann unser Projekt die Standardeinstellungen von Spring Boot wiederverwenden.

Das Erben des übergeordneten Spring-Boot-Starter- Projekts ist unkompliziert - wir müssen nur ein übergeordnetes Element in pom.xml angeben :

 org.springframework.boot spring-boot-starter-parent 2.3.0.RELEASE 

Wir finden die neueste Version von Spring-Boot-Starter-Parent auf Maven Central.

Die Verwendung des übergeordneten Starterprojekts ist praktisch, aber nicht immer möglich. Wenn unser Unternehmen beispielsweise verlangt, dass alle Projekte von einem Standard-POM erben, können wir dennoch vom Abhängigkeitsmanagement von Spring Boot mithilfe eines benutzerdefinierten übergeordneten Elements profitieren.

Q4. Was ist Spring Initializr?

Spring Initializr ist eine bequeme Möglichkeit, ein Spring Boot-Projekt zu erstellen.

Wir können zur Spring Initializr-Site gehen, ein Abhängigkeitsmanagement-Tool (entweder Maven oder Gradle), eine Sprache (Java, Kotlin oder Groovy), ein Verpackungsschema (Jar oder War), eine Version und Abhängigkeiten auswählen und das Projekt herunterladen.

Dies erstellt ein Skelettprojekt für uns und spart Einrichtungszeit, sodass wir uns auf das Hinzufügen von Geschäftslogik konzentrieren können.

Selbst wenn wir den neuen Projektassistenten unserer IDEs (wie STS oder Eclipse mit STS-Plugin) verwenden, um ein Spring Boot-Projekt zu erstellen, wird Spring Initializr unter der Haube verwendet.

Q5. Welche Spring Boot Starter gibt es da draußen?

Jeder Starter spielt eine Rolle als One-Stop-Shop für alle von uns benötigten Spring-Technologien. Andere erforderliche Abhängigkeiten werden dann transitiv abgerufen und auf konsistente Weise verwaltet.

Alle Starter befinden sich in der Gruppe org.springframework.boot und ihre Namen beginnen mit spring-boot-Starter- . Dieses Namensmuster erleichtert das Auffinden von Startern, insbesondere bei der Arbeit mit IDEs, die das Suchen von Abhängigkeiten nach Namen unterstützen.

Zum Zeitpunkt dieses Schreibens stehen uns mehr als 50 Vorspeisen zur Verfügung. Die am häufigsten verwendeten sind:

  • Spring-Boot-Starter: Core-Starter, einschließlich Unterstützung für automatische Konfiguration, Protokollierung und YAML
  • Spring-Boot-Starter-Aop: Starter für die aspektorientierte Programmierung mit Spring AOP und AspectJ
  • Spring-Boot-Starter-Data-JPA: Starter für die Verwendung von Spring Data JPA mit Hibernate
  • Spring-Boot-Starter-Sicherheit: Starter für die Verwendung von Spring Security
  • Spring-Boot-Starter-Test: Starter zum Testen von Spring Boot-Anwendungen
  • Spring-Boot-Starter-Web: Starter zum Erstellen von Web-, einschließlich RESTful-Anwendungen mit Spring MVC

Eine vollständige Liste der Starter finden Sie in diesem Repository.

Weitere Informationen zu Spring Boot-Startern finden Sie unter Einführung in Spring Boot-Starter.

Q6. Wie deaktiviere ich eine bestimmte automatische Konfiguration?

Wenn Sie eine bestimmte automatische Konfiguration deaktivieren möchten, können Sie dies mithilfe des exclude- Attributs der Annotation @EnableAutoConfiguration angeben . Dieses Code-Snippet neutralisiert beispielsweise DataSourceAutoConfiguration :

// other annotations @EnableAutoConfiguration(exclude = DataSourceAutoConfiguration.class) public class MyConfiguration { }

Wenn wir die automatische Konfiguration mit der Annotation @SpringBootApplication aktivieren, die @EnableAutoConfiguration als Meta-Annotation enthält, können wir die automatische Konfiguration mit einem gleichnamigen Attribut deaktivieren:

// other annotations @SpringBootApplication(exclude = DataSourceAutoConfiguration.class) public class MyConfiguration { }

Wir können eine automatische Konfiguration auch mit der Umgebungseigenschaft spring.autoconfigure.exclude deaktivieren . Diese Einstellung in der Datei application.properties bewirkt dasselbe wie zuvor:

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

Q7. Wie registriere ich eine benutzerdefinierte automatische Konfiguration?

To register an auto-configuration class, we must have its fully-qualified name listed under the EnableAutoConfiguration key in the META-INF/spring.factories file:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.baeldung.autoconfigure.CustomAutoConfiguration

If we build a project with Maven, that file should be placed in the resources/META-INF directory, which will end up in the mentioned location during the package phase.

Q8. How to Tell an Auto-Configuration to Back Away When a Bean Exists?

To instruct an auto-configuration class to back off when a bean is already existent, we can use the @ConditionalOnMissingBean annotation. The most noticeable attributes of this annotation are:

  • value: The types of beans to be checked
  • name: The names of beans to be checked

When placed on a method adorned with @Bean, the target type defaults to the method's return type:

@Configuration public class CustomConfiguration { @Bean @ConditionalOnMissingBean public CustomService service() { ... } }

Q9. How to Deploy Spring Boot Web Applications as Jar and War Files?

Traditionally, we package a web application as a WAR file, then deploy it into an external server. Doing this allows us to arrange multiple applications on the same server. During the time that CPU and memory were scarce, this was a great way to save resources.

However, things have changed. Computer hardware is fairly cheap now, and the attention has turned to server configuration. A small mistake in configuring the server during deployment may lead to catastrophic consequences.

Spring tackles this problem by providing a plugin, namely spring-boot-maven-plugin, to package a web application as an executable JAR. To include this plugin, just add a plugin element to pom.xml:

 org.springframework.boot spring-boot-maven-plugin 

With this plugin in place, we'll get a fat JAR after executing the package phase. This JAR contains all the necessary dependencies, including an embedded server. Thus, we no longer need to worry about configuring an external server.

We can then run the application just like we would an ordinary executable JAR.

Notice that the packaging element in the pom.xml file must be set to jar to build a JAR file:

jar

If we don't include this element, it also defaults to jar.

In case we want to build a WAR file, change the packaging element to war:

war

And leave the container dependency off the packaged file:

 org.springframework.boot spring-boot-starter-tomcat provided 

After executing the Maven package phase, we'll have a deployable WAR file.

Q10. How to Use Spring Boot for Command Line Applications?

Just like any other Java program, a Spring Boot command line application must have a main method. This method serves as an entry point, which invokes the SpringApplication#run method to bootstrap the application:

@SpringBootApplication public class MyApplication { public static void main(String[] args) { SpringApplication.run(MyApplication.class); // other statements } }

The SpringApplication class then fires up a Spring container and auto-configures beans.

Notice we must pass a configuration class to the run method to work as the primary configuration source. By convention, this argument is the entry class itself.

After calling the run method, we can execute other statements as in a regular program.

Q11. What Are Possible Sources of External Configuration?

Spring Boot provides support for external configuration, allowing us to run the same application in various environments. We can use properties files, YAML files, environment variables, system properties, and command-line option arguments to specify configuration properties.

We can then gain access to those properties using the @Value annotation, a bound object via the @ConfigurationProperties annotation, or the Environment abstraction.

Q12. What Does it Mean that Spring Boot Supports Relaxed Binding?

Relaxed binding in Spring Boot is applicable to the type-safe binding of configuration properties.

With relaxed binding, the key of a property doesn't need to be an exact match of a property name. Such an environment property can be written in camelCase, kebab-case, snake_case, or in uppercase with words separated by underscores.

For example, if a property in a bean class with the @ConfigurationProperties annotation is named myProp, it can be bound to any of these environment properties: myProp, my-prop, my_prop, or MY_PROP.

Q13. What is Spring Boot Devtools Used For?

Spring Boot Developer Tools, or DevTools, is a set of tools making the development process easier. To include these development-time features, we just need to add a dependency to the pom.xml file:

 org.springframework.boot spring-boot-devtools 

The spring-boot-devtools module is automatically disabled if the application runs in production. The repackaging of archives also excludes this module by default. Hence, it won't bring any overhead to our final product.

By default, DevTools applies properties suitable to a development environment. These properties disable template caching, enable debug logging for the web group, and so on. As a result, we have this sensible development-time configuration without setting any properties.

Applications using DevTools restart whenever a file on the classpath changes. This is a very helpful feature in development, as it gives quick feedback for modifications.

By default, static resources, including view templates, don't set off a restart. Instead, a resource change triggers a browser refresh. Notice this can only happen if the LiveReload extension is installed in the browser to interact with the embedded LiveReload server that DevTools contains.

For further information on this topic, please see Overview of Spring Boot DevTools.

Q14. How to Write Integration Tests?

When running integration tests for a Spring application, we must have an ApplicationContext.

To make our life easier, Spring Boot provides a special annotation for testing – @SpringBootTest. This annotation creates an ApplicationContext from configuration classes indicated by its classes attribute.

In case the classes attribute isn't set, Spring Boot searches for the primary configuration class. The search starts from the package containing the test up until it finds a class annotated with @SpringBootApplication or @SpringBootConfiguration.

For detailed instructions, check out our tutorial on testing in Spring Boot.

Q15. What Is Spring Boot Actuator Used For?

Essentially, Actuator brings Spring Boot applications to life by enabling production-ready features. These features allow us to monitor and manage applications when they're running in production.

Integrating Spring Boot Actuator into a project is very simple. All we need to do is to include the spring-boot-starter-actuator starter in the pom.xml file:

 org.springframework.boot spring-boot-starter-actuator 

Spring Boot Actuator can expose operational information using either HTTP or JMX endpoints. Most applications go for HTTP, though, where the identity of an endpoint and the /actuator prefix form a URL path.

Here are some of the most common built-in endpoints Actuator provides:

  • env: Exposes environment properties
  • health: Shows application health information
  • httptrace: Displays HTTP trace information
  • info: Displays arbitrary application information
  • metrics: Shows metrics information
  • loggers: Shows and modifies the configuration of loggers in the application
  • mappings: Displays a list of all @RequestMapping paths

Please refer to our Spring Boot Actuator tutorial for a detailed rundown.

Q16. Which Is a Better Way to Configure a Spring Boot Project – Using Properties or YAML?

YAML offers many advantages over properties files, such as:

  • More clarity and better readability
  • Perfect for hierarchical configuration data, which is also represented in a better, more readable format
  • Support for maps, lists, and scalar types
  • Can include several profiles in the same file

However, writing it can be a little difficult and error-prone due to its indentation rules.

For details and working samples, please refer to our Spring YAML vs Properties tutorial.

Q17. What Are the Basic Annotations that Spring Boot Offers?

The primary annotations that Spring Boot offers reside in its org.springframework.boot.autoconfigure and its sub-packages. Here are a couple of basic ones:

  • @EnableAutoConfiguration – to make Spring Boot look for auto-configuration beans on its classpath and automatically apply them.
  • @SpringBootApplication – used to denote the main class of a Boot Application. This annotation combines @Configuration, @EnableAutoConfiguration, and @ComponentScan annotations with their default attributes.

Spring Boot Annotations offers more insight into the subject.

Q18. How Can You Change the Default Port in Spring Boot?

We can change the default port of a server embedded in Spring Boot using one of these ways:

  • using a properties file – we can define this in an application.properties (or application.yml) file using the property server.port
  • programmatically – in our main @SpringBootApplication class, we can set the server.port on the SpringApplication instance
  • using the command line – when running the application as a jar file, we can set the server.port as a java command argument:
    java -jar -Dserver.port=8081 myspringproject.jar 

Q19. Which Embedded Servers does Spring Boot Support, and How to Change the Default?

As of date, Spring MVC supports Tomcat, Jetty, and Undertow. Tomcat is the default application server supported by Spring Boot's web starter.

Spring WebFlux supports Reactor Netty, Tomcat, Jetty, and Undertow with Reactor Netty as default.

In Spring MVC, to change the default, let's say to Jetty, we need to exclude Tomcat and include Jetty in the dependencies:

 org.springframework.boot spring-boot-starter-web   org.springframework.boot spring-boot-starter-tomcat     org.springframework.boot spring-boot-starter-jetty 

Similarly, to change the default in WebFlux to UnderTow, we need to exclude Reactor Netty and include UnderTow in the dependencies.

“Comparing embedded servlet contains in Spring Boot” contains more details on the different embedded servers we can use with Spring MVC.

Q20. Why Do We Need Spring Profiles?

When developing applications for the enterprise, we typically deal with multiple environments such as Dev, QA, and Prod. The configuration properties for these environments are different.

For example, we might be using an embedded H2 database for Dev, but Prod could have the proprietary Oracle or DB2. Even if the DBMS is the same across environments, the URLs would definitely be different.

Um dies einfach und sauber zu machen, bietet Spring Profile an, mit denen die Konfiguration für jede Umgebung getrennt werden kann . Anstatt dies programmgesteuert zu verwalten, können die Eigenschaften in separaten Dateien wie application-dev gespeichert werden . Eigenschaften und Anwendungsprodukt Eigenschaften . Der Standard application.propertie Punkte s auf die derzeit aktive Profil mit Feder. Profile. aktiv, damit die richtige Konfiguration übernommen wird.

Spring Profiles bietet einen umfassenden Überblick über dieses Thema.

3. Fazit

In diesem Tutorial wurden einige der wichtigsten Fragen zu Spring Boot behandelt, denen Sie möglicherweise während eines technischen Interviews gegenüberstehen. Wir hoffen, dass sie Ihnen helfen, Ihren Traumjob zu finden.