Frühlingsinterviewfragen und -antworten

Tutorials
Spring

I have posted a lot of Spring Tutorials recently. This post will help you get through Spring interview Questions explaining the core concepts in detail.

Spring Framework ist eines der beliebtesten Java-EE-Frameworks für Webanwendungen. Dependency Injection und Aspektorientierte Programmierung stehen im Mittelpunkt des Spring-Frameworks. Wenn Sie gut im Spring Framework sind, steigen die Chancen, in Java-Interviews ausgewählt zu werden, wirklich stark an.

Profi-Tipp: Core Java ist die Basis für jedes auf Java basierende Framework, also sollten Sie sich, wenn Sie sich auf Interviews vorbereiten, bitte die Artikel zu Core-Java-Interviewfragen und Java-Interviewfragen durchlesen.

Spring Interviewfragen und Antworten

Hier stelle ich fast 50 Frühlings-Interviewfragen und ihre Antworten zur Verfügung. Es ist auf dem neuesten Stand bis Spring 5, daher umfasst es alle neuesten Funktionen wie Spring WebFlux für reaktive Programmierung.

1. Was ist das Spring Framework?

Das Spring Framework ist eines der am weitesten verbreiteten Java EE-Frameworks. Die Kernkonzepte des Spring Frameworks sind „Dependency Injection“ und „Aspektorientierte Programmierung“.

Das Spring Framework kann auch in normalen Java-Anwendungen verwendet werden, um eine lose Kopplung zwischen verschiedenen Komponenten durch die Implementierung von Dependency Injection zu erreichen. Mit der Unterstützung von Spring für aspektorientierte Programmierung können wir Querschnittsaufgaben wie Logging und Authentifizierung durchführen.

I like spring because it provides a lot of features and different modules for specific tasks such as Spring MVC and Spring JDBC. Since it’s an open-source framework with a lot of online resources and active community members, working with the Spring framework is easy and fun at the same time.

Empfohlene Lektüre: Spring Framework

2. Welche sind einige der wichtigen Funktionen des Spring Frameworks?

Das Spring Framework basiert auf zwei Designkonzepten – Dependency Injection und Aspektorientierte Programmierung.

Einige der Funktionen des Spring Frameworks sind:

  • Leichtgewichtig und geringer Overhead bei der Verwendung eines Frameworks für unsere Entwicklung.
  • Dependency Injection oder Inversion of Control zum Schreiben von Komponenten, die unabhängig voneinander sind. Der Spring-Container kümmert sich darum, sie miteinander zu verbinden, um unsere Arbeit zu erreichen.
  • Der Spring IoC-Container verwaltet den Lebenszyklus von Spring Beans und projektbezogene Konfigurationen wie JNDI-Lookup.
  • Das Spring MVC-Framework kann verwendet werden, um Webanwendungen sowie RESTful-Webdienste zu erstellen, die XML sowie JSON-Antworten zurückgeben können.
  • Unterstützung für Transaktionsmanagement, JDBC-Operationen, Datei-Uploads, Ausnahmehandhabung usw. mit sehr wenigen Konfigurationen, entweder durch Verwendung von Annotationen oder durch Konfigurationsdateien für Spring Beans.

3. Was ist der Vorteil der Verwendung des Spring-Frameworks?

Einige der Vorteile der Verwendung des Spring-Frameworks sind:

  • Reduzierung direkter Abhängigkeiten zwischen verschiedenen Komponenten der Anwendung. Der Spring IoC-Container ist dafür verantwortlich, Ressourcen oder Beans zu initialisieren und sie als Abhängigkeiten einzufügen.
  • Das Schreiben von Unit-Testfällen ist im Spring-Framework einfach, da unsere Geschäftslogik keine direkten Abhängigkeiten von tatsächlichen Ressourcenimplementierungsklassen hat. Wir können leicht eine Testkonfiguration schreiben und unsere Mock-Beans für Testzwecke einfügen.
  • Reduziert die Menge an Boilerplate-Code, wie das Initialisieren von Objekten, Öffnen/Schließen von Ressourcen. Mir gefällt die JdbcTemplate-Klasse sehr, weil sie uns dabei hilft, den ganzen Boilerplate-Code zu entfernen, der mit der JDBC-Programmierung einhergeht.
  • Das Spring Framework ist in mehrere Module unterteilt und hilft uns dabei, unsere Anwendung schlank zu halten. Wenn wir zum Beispiel keine Spring-Transaktionsverwaltungsfunktionen benötigen, müssen wir diese Abhängigkeit nicht zu unserem Projekt hinzufügen.
  • Das Spring Framework unterstützt die meisten Java EE-Funktionen und noch viel mehr. Es ist immer auf dem neuesten Stand der neuen Technologien. Es gibt zum Beispiel ein Spring-Projekt für Android, das uns dabei hilft, besseren Code für native Android-Anwendungen zu schreiben. Dadurch wird das Spring Framework zu einem vollständigen Paket und wir müssen uns nicht um verschiedene Frameworks für unterschiedliche Anforderungen kümmern.

4. Welche wichtigen Funktionen hat Spring 5?

Spring 5 ist eine umfangreiche Überarbeitung von Spring 4. Einige wichtige Funktionen sind:

  • Unterstützung für Java 8 und höhere Versionen, sodass wir Lambda-Ausdrücke verwenden können.
  • Unterstützung für Java EE7 und Servlet 4.0-Spezifikationen.
  • Dateioperationen werden nun über NIO 2-Streams durchgeführt, was eine enorme Verbesserung darstellt, wenn Ihre App viele Dateioperationen durchführt.
  • Einführung von spring-jcl zur Optimierung des Loggings. Früher war es aufgrund fehlender zentraler Punkte für das Logging eine Unordnung.
  • Unterstützung für Kotlin, Lombok, Reactor 3.1 Flux und Mono sowie RxJava.
  • Spring WebFlux, das reaktive Programmierung in Spring bringt.
  • Unterstützung für JUnit 5
  • Unterstützung für die Bereitstellung von Informationen zu Spring-Komponenten über die Indexdatei „META-INF/spring.components“ anstelle von Klassenpfad-Scans.

Bitte lesen Sie Spring 5-Funktionen, um einen detaillierten Überblick über diese Version zu erhalten.

5. Was ist Spring WebFlux?

Spring WebFlux ist das neue Modul in Spring 5. Spring WebFlux ist der erste Schritt zum reaktiven Programmiermodell im Spring-Framework.

Spring WebFlux ist die Alternative zum Spring MVC-Modul. Spring WebFlux wird verwendet, um eine vollständig asynchrone und nicht blockierende Anwendung auf der Ereignisschleifen-Ausführungsplattform zu erstellen.

Weitere Informationen finden Sie unter Spring WebFlux Tutorial.

6. Was verstehen Sie unter Dependency Injection?

Das Entwurfsmuster für Dependency Injection ermöglicht es uns, die fest codierten Abhängigkeiten zu entfernen und unsere Anwendung locker gekoppelt, erweiterbar und wartbar zu machen. Wir können das Dependency Injection-Muster implementieren, um die Abhängigkeitsauflösung von der Kompilierungszeit auf die Laufzeit zu verschieben.

Einige Vorteile der Verwendung von Dependency Injection sind die Trennung der Anliegen, die Reduzierung von Boilerplate-Code, konfigurierbare Komponenten und einfaches Unit Testing.

Weitere Informationen finden Sie unter Dependency Injection Tutorial. Wir können auch Google Guice für Dependency Injection verwenden, um den Prozess der Dependency Injection zu automatisieren. Aber in den meisten Fällen suchen wir nach mehr als nur Dependency Injection, und das ist der Bereich, in dem Spring an erster Stelle steht.

7. Wie implementieren wir DI im Spring Framework?

Wir können sowohl die XML-basierte als auch die annotationsbasierte Konfiguration verwenden, um DI in Spring-Anwendungen zu implementieren. Für ein besseres Verständnis lesen Sie bitte das Beispiel für Spring Dependency Injection, in dem Sie beide Methoden mit JUnit-Testfall lernen können. Der Beitrag enthält auch eine Beispieldatei für ein Projekt, die Sie herunterladen und zum Lernen verwenden können.

8. Was sind die Vorteile der Verwendung von Spring Tool Suite?

Wir können Plugins in Eclipse installieren, um alle Funktionen von Spring Tool Suite zu erhalten. Allerdings wird STS mit Eclipse geliefert, mit einigen anderen wichtigen Dingen wie Maven-Unterstützung, Vorlagen zur Erstellung verschiedener Arten von Spring-Projekten und tc-Server für bessere Leistung mit Spring-Anwendungen.

I like STS because it highlights the Spring components and if you are using AOP pointcuts and advice, then it clearly shows which methods will come under the specific pointcut. So rather than installing everything on our own, I prefer using STS when developing Spring-based applications.

9. Nennen Sie einige wichtige Spring-Module?

Einige wichtige Spring-Framework-Module sind:

  • Spring Context – für die Dependency Injection.
  • Spring AOP – für die aspektorientierte Programmierung.
  • Spring DAO – für Datenbankoperationen mit dem DAO-Muster
  • Spring JDBC – für JDBC- und DataSource-Unterstützung.
  • Spring ORM – für die Unterstützung von ORM-Tools wie Hibernate
  • Spring Web Module – zur Erstellung von Webanwendungen.
  • Spring MVC – Implementierung des Model-View-Controller für die Erstellung von Webanwendungen, Webdiensten usw.

10. Was verstehen Sie unter Aspektorientierter Programmierung?

Unternehmensanwendungen haben einige gemeinsame übergreifende Anliegen, die auf verschiedene Arten von Objekten und Anwendungsmodulen anwendbar sind, wie z.B. Protokollierung, Transaktionsverwaltung, Datenvalidierung, Authentifizierung usw. Die Modularität der Anwendung wird durch Klassen in der objektorientierten Programmierung erreicht. In AOP wird die Anwendungsmodularität durch Aspekte erreicht, die so konfiguriert sind, dass sie verschiedene Klassenmethoden durchdringen.

AOP entfernt die direkte Abhängigkeit von übergreifenden Aufgaben von Klassen, was in der normalen objektorientierten Programmierung nicht möglich ist. Zum Beispiel können wir eine separate Klasse für die Protokollierung haben, aber die anderen Klassen müssten diese Methoden aufrufen. In AOP konfigurieren wir jedoch die Aspekte und die Methodenausführung erfolgt automatisch. Erfahren Sie mehr über die Unterstützung von Spring AOP unter Spring AOP Beispiel.

11. Was sind Aspekt, Rat, Schnittpunkt, JointPoint und Rat-Argumente in AOP?

Aspekt: Ein Aspekt ist eine Klasse, die Querschnittsbelange wie Transaktionsmanagement implementiert. Aspekte können eine normale Klasse sein, die in der Spring Bean-Konfigurationsdatei konfiguriert und dann konfiguriert werden kann, oder wir können die Spring AspectJ-Unterstützung verwenden, um eine Klasse mit der @Aspect-Annotation als Aspekt zu deklarieren.

Advice: Advice ist die Aktion, die für einen bestimmten Join Point ausgeführt wird. Im Hinblick auf die Programmierung handelt es sich dabei um Methoden, die ausgeführt werden, wenn ein bestimmter Join Point mit einem übereinstimmenden Pointcut in der Anwendung erreicht wird. Man kann sich Advice als Spring-Interceptors oder Servlet-Filter vorstellen.

Pointcut: Pointcuts sind reguläre Ausdrücke, die mit Join Points abgeglichen werden, um zu bestimmen, ob Advice ausgeführt werden muss oder nicht. Der Pointcut verwendet verschiedene Arten von Ausdrücken, die mit den Join Points abgeglichen werden. Das Spring-Framework verwendet die AspectJ-Punktdefinitionssprache, um die Join Points zu bestimmen, an denen Advice-Methoden angewendet werden sollen.

JoinPoint: Ein Join Point ist ein bestimmter Punkt in der Anwendung, wie z.B. die Ausführung einer Methode, die Behandlung einer Ausnahme, die Änderung von Objektvariablenwerten usw. In Spring AOP ist ein Join Point immer die Ausführung einer Methode.

Ratschlag Argumente: Wir können Argumente in den Ratschlagsmethoden übergeben. Wir können den Ausdruck args() im Pointcut verwenden, um auf jede Methode angewendet zu werden, die zum Argumentmuster passt. Wenn wir dies verwenden, müssen wir denselben Namen in der Ratschlagsmethode verwenden, von der der Argumenttyp bestimmt wird.

Diese Konzepte scheinen zunächst verwirrend zu sein, aber wenn Sie Spring-Aspekt, Ratschlag Beispiel durchgehen, können Sie sie leicht nachvollziehen.

12. Was ist der Unterschied zwischen Spring AOP und AspectJ AOP?

AspectJ ist die branchenübliche Implementierung für Aspektorientierte Programmierung, während Spring AOP für einige Fälle AOP implementiert. Die Hauptunterschiede zwischen Spring AOP und AspectJ sind:

  • Spring AOP ist einfacher zu verwenden als AspectJ, weil wir uns nicht um den Webprozess kümmern müssen.
  • Spring AOP unterstützt AspectJ-Annotationen, daher ist die Arbeit mit Spring AOP einfacher, wenn Sie mit AspectJ vertraut sind.
  • Spring AOP unterstützt nur proxybasierte AOP, daher kann es nur auf Methodenausführungspunkte angewendet werden. AspectJ unterstützt alle Arten von Pointcuts.
  • Einer der Nachteile von Spring AOP ist, dass es nur auf die über Spring-Kontext erstellten Beans angewendet werden kann.

13. Was ist der Spring IoC Container?

Die Umkehrung der Steuerung (IoC) ist der Mechanismus, um lose Kopplung zwischen Objektabhängigkeiten zu erreichen. Um eine lose Kopplung und eine dynamische Bindung der Objekte zur Laufzeit zu erreichen, definieren die Objekte ihre Abhängigkeiten, die von anderen Zusammenbauerobjekten injiziert werden. Der Spring IoC-Container ist das Programm, das Abhängigkeiten in ein Objekt injiziert und es für unsere Verwendung bereit macht.

Die Klassen des Spring Frameworks IoC-Containers sind Teil der Pakete org.springframework.beans und org.springframework.context und bieten uns verschiedene Möglichkeiten, die Objektabhängigkeiten zu entkoppeln.

Einige der nützlichen ApplicationContext-Implementierungen, die wir verwenden, sind;

  • AnnotationConfigApplicationContext: Für eigenständige Java-Anwendungen mit annotationsbasierte Konfiguration.
  • ClassPathXmlApplicationContext: Für eigenständige Java-Anwendungen mit XML-basierter Konfiguration.
  • FileSystemXmlApplicationContext: Ähnlich wie ClassPathXmlApplicationContext, mit der Ausnahme, dass die XML-Konfigurationsdatei von überall im Dateisystem geladen werden kann.
  • AnnotationConfigWebApplicationContext und XmlWebApplicationContext für Webanwendungen.

14. Was ist ein Spring Bean?

Jede normale Java-Klasse, die vom Spring IoC-Container initialisiert wird, wird als Spring Bean bezeichnet. Wir verwenden den Spring ApplicationContext, um die Spring Bean-Instanz zu erhalten.

Der Spring IoC-Container verwaltet den Lebenszyklus des Spring Beans, die Bean-Scopes und das Injizieren aller erforderlichen Abhängigkeiten in die Bean.

15. Was ist die Bedeutung der Spring Bean-Konfigurationsdatei?

Wir verwenden die Spring Bean-Konfigurationsdatei, um alle Beans zu definieren, die vom Spring-Kontext initialisiert werden sollen. Wenn wir die Instanz des Spring ApplicationContext erstellen, liest sie die Spring Bean-XML-Datei und initialisiert sie alle. Sobald der Kontext initialisiert ist, können wir ihn verwenden, um verschiedene Bean-Instanzen zu erhalten.

Neben der Spring Bean-Konfiguration enthält diese Datei auch Spring MVC-Interceptoren, View-Resolver und andere Elemente zur Unterstützung von annotationsbasierten Konfigurationen.

16. Was sind verschiedene Möglichkeiten, eine Klasse als Spring Bean zu konfigurieren?

Es gibt drei verschiedene Möglichkeiten, ein Spring Bean zu konfigurieren.

XML-Konfiguration: Dies ist die beliebteste Konfiguration und wir können das bean-Element in der Kontextdatei verwenden, um ein Spring Bean zu konfigurieren. Zum Beispiel:

<bean name="myBean" class="com.journaldev.spring.beans.MyBean"></bean>

Java-basierte Konfiguration: Wenn Sie nur Annotationen verwenden, können Sie ein Spring Bean mit der @Bean-Annotation konfigurieren. Diese Annotation wird mit @Configuration-Klassen verwendet, um ein Spring Bean zu konfigurieren. Beispielkonfiguration:

@Configuration
@ComponentScan(value="com.journaldev.spring.main")
public class MyConfiguration {

	@Bean
	public MyService getService(){
		return new MyService();
	}
}

Um dieses Bean aus dem Spring-Kontext zu erhalten, müssen wir den folgenden Code-Schnipsel verwenden:

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
		MyConfiguration.class);
MyService service = ctx.getBean(MyService.class);

Annotation-basierte Konfiguration: Wir können auch die @Component, @Service, @Repository und @Controller Annotationen mit Klassen verwenden, um sie als Spring Bean zu konfigurieren. Dafür müssten wir den Basispaketspeicherort angeben, um diese Klassen zu durchsuchen. Zum Beispiel:

<context:component-scan base-package="com.journaldev.spring" />

17. Was sind die verschiedenen Scopes von Spring Bean?

Es gibt fünf Scopes, die für Spring Beans definiert sind.

  1. singleton: Es wird nur eine Instanz der Bean für jeden Container erstellt. Dies ist der Standard-Scope für Spring Beans. Bei der Verwendung dieses Scopes stellen Sie sicher, dass die Spring Bean keine gemeinsam genutzten Instanzvariablen hat, da dies zu Dateninkonsistenzproblemen führen kann, da es nicht threadsicher ist.
  2. prototype: Eine neue Instanz wird jedes Mal erstellt, wenn die Bean angefordert wird.
  3. request: Dies entspricht dem Prototype-Scope, ist jedoch für Webanwendungen vorgesehen. Es wird für jede HTTP-Anfrage eine neue Instanz der Bean erstellt.
  4. session: Für jede HTTP-Session wird eine neue Bean vom Container erstellt.
  5. global-session: Dies wird verwendet, um globale Session-Beans für Portlet-Anwendungen zu erstellen.

Der Spring Framework ist erweiterbar, und wir können auch unsere eigenen Scopes erstellen. Aber meistens sind die vom Framework bereitgestellten Scopes ausreichend. Um Spring Bean-Scopes festzulegen, können wir das „scope“-Attribut im Bean-Element oder die @Scope-Annotation für annotationsbasierte Konfigurationen verwenden.

18. Was ist der Lebenszyklus einer Spring Bean?

Spring Beans werden vom Spring Container initialisiert, und alle Abhängigkeiten werden ebenfalls eingefügt. Wenn der Kontext zerstört wird, werden auch alle initialisierten Beans zerstört. Dies funktioniert in den meisten Fällen gut, aber manchmal möchten wir andere Ressourcen initialisieren oder einige Überprüfungen durchführen, bevor unsere Beans einsatzbereit sind. Das Spring Framework bietet Unterstützung für Post-Initialisierung und Pre-Destroy-Methoden in Spring Beans.

Dies kann auf zwei Arten erfolgen – durch Implementierung der Schnittstellen InitializingBean und DisposableBean oder durch Verwendung der Attribute init-method und destroy-method in der Konfiguration der Spring Beans. Weitere Details finden Sie unter Spring Bean Life Cycle Methods.

19. Wie bekomme ich das ServletContext- und ServletConfig-Objekt in einer Spring Bean?

Es gibt zwei Möglichkeiten, containerabhängige Objekte im Spring Bean zu erhalten.

  • Implementieren von Spring *Aware-Schnittstellen, für diese ServletContextAware- und ServletConfigAware-Schnittstellen, für ein vollständiges Beispiel dieser Aware-Schnittstellen, bitte lesen Sie Spring Aware-Schnittstellen.
  • Verwendung der @Autowired-Annotation mit der Bean-Variablen vom Typ ServletContext und ServletConfig. Sie funktionieren nur in Container-spezifischen Umgebungen.
@Autowired
ServletContext servletContext;

Was ist Bean-Verkabelung und @Autowired-Annotation?

Der Prozess der Injektion von Spring-Bean-Abhängigkeiten beim Initialisieren wird als Spring Bean-Verkabelung bezeichnet.

Normalerweise ist es bewährte Praxis, die explizite Verkabelung aller Bean-Abhängigkeiten durchzuführen, aber das Spring-Framework unterstützt auch die automatische Verkabelung. Wir können die @Autowired-Annotation mit Feldern oder Methoden für das Autowiring byType verwenden. Damit diese Annotation funktioniert, müssen wir auch die annotative Konfiguration in der Spring-Bean-Konfigurationsdatei aktivieren. Dies kann durch das context:annotation-config-Element erfolgen.

Weitere Details zur @Autowired-Annotation finden Sie unter Spring Autowire Beispiel.

21. Was sind die verschiedenen Arten von Spring Bean Autowiring?

Es gibt vier Arten von Autowiring im Spring-Framework.

  1. Autowiring nach Name
  2. Autowiring nach Typ
  3. Autowiring durch Konstruktor
  4. Autowiring mittels @Autowired und @Qualifier Annotationen

Vor Spring 3.1 wurde auch Autowiring durch Autodetect unterstützt, das ähnlich wie Autowiring durch Konstruktor oder nach Typ war. Für weitere Details zu diesen Optionen lesen Sie bitte Spring Bean Autowiring.

22. Bietet Spring Bean Thread-Sicherheit?

Der Standardumfang des Spring-Beans ist Singleton, sodass es nur eine Instanz pro Kontext geben wird. Das bedeutet, dass alle Klassenvariablen, die von einem Thread aktualisiert werden können, zu inkonsistenten Daten führen. Daher sind Spring-Beans im Standardmodus nicht thread-sicher.

Jedoch können wir den Spring Bean Scope auf „request“, „prototype“ oder „session“ ändern, um Thread-Sicherheit auf Kosten der Leistung zu erreichen. Es ist eine Designentscheidung, die auf den Projektanforderungen basiert.

23. Was ist ein Controller in Spring MVC?

Genau wie das MVC-Designmuster ist der Controller die Klasse, die sich um alle Client-Anfragen kümmert und sie an die konfigurierten Ressourcen sendet, um sie zu verarbeiten. In Spring MVC ist DispatcherServlet die Front-Controller-Klasse, die den Kontext basierend auf den Spring Bean-Konfigurationen initialisiert.

A Controller class is responsible to handle a different kind of client requests based on the request mappings. We can create a controller class by using @Controller annotation. Usually, it’s used with @RequestMapping annotation to define handler methods for specific URI mapping.

24. Was ist der Unterschied zwischen @Component, @Controller, @Repository & @Service Annotationen in Spring?

@Component wird verwendet, um anzuzeigen, dass eine Klasse ein Komponente ist. Diese Klassen werden für die automatische Erkennung verwendet und als Bean konfiguriert, wenn annotationsbasierte Konfigurationen verwendet werden.

@Controller ist ein spezifischer Typ von Komponente, der in MVC-Anwendungen verwendet wird und hauptsächlich mit der RequestMapping-Annotation verwendet wird.

@Repository-Annotation wird verwendet, um anzuzeigen, dass eine Komponente als Repository verwendet wird und ein Mechanismus zum Speichern/Abrufen/Suchen von Daten ist. Diese Annotation kann mit DAO-Musterimplementierungsklassen verwendet werden.

@Service wird verwendet, um anzuzeigen, dass eine Klasse ein Dienst ist. Normalerweise sind die Geschäftsfassadenklassen, die einige Dienste bereitstellen, mit dieser Annotation versehen.

Wir können eine beliebige der oben genannten Annotationen für eine Klasse zur automatischen Erkennung verwenden, aber verschiedene Typen werden bereitgestellt, damit Sie den Zweck der annotierten Klassen leicht unterscheiden können.

25. Was ist DispatcherServlet und ContextLoaderListener?

Der DispatcherServlet ist der Front-Controller in einer Spring MVC-Anwendung. Er lädt die Spring Bean-Konfigurationsdatei und initialisiert alle konfigurierten Beans. Wenn Annotationen aktiviert sind, durchsucht es auch die Pakete und konfiguriert alle mit den Annotationen @Component, @Controller, @Repository oder @Service versehenen Beans.

Der ContextLoaderListener ist ein Listener, der den Start und das Herunterfahren des Wurzel-WebApplicationContexts von Spring ermöglicht. Seine wichtigsten Funktionen sind die Verknüpfung des ApplicationContext-Lebenszyklus mit dem ServletContext-Lebenszyklus und die automatische Erstellung des ApplicationContexts. Wir können ihn verwenden, um gemeinsam genutzte Beans zu definieren, die in verschiedenen Spring-Kontexten verwendet werden können.

26. Was ist ein ViewResolver in Spring?

ViewResolver-Implementierungen werden verwendet, um die Ansichtsseiten anhand ihres Namens aufzulösen. Wir konfigurieren dies in der Spring Bean-Konfigurationsdatei. Zum Beispiel:

<!-- Löst Ansichten, die von @Controllern zur Darstellung ausgewählt wurden, zu .jsp-Ressourcen im Verzeichnis /WEB-INF/views auf -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<beans:property name="prefix" value="/WEB-INF/views/" />
	<beans:property name="suffix" value=".jsp" />
</beans:bean>

InternalResourceViewResolver ist eine Implementierung des ViewResolver-Interfaces, und wir geben das Verzeichnis für die Ansichtsseiten und den Suffix-Speicherort über die Bean-Eigenschaften an. Wenn eine Controller-Handler-Methode „home“ zurückgibt, verwendet der Ansichtsresolver die Ansichtsseite, die sich unter /WEB-INF/views/home.jsp befindet.

27. Was ist ein MultipartResolver und wann wird es verwendet?

Das MultipartResolver-Interface wird zum Hochladen von Dateien verwendet – CommonsMultipartResolver und StandardServletMultipartResolver sind zwei Implementierungen, die vom Spring-Framework für das Datei-Upload bereitgestellt werden. Standardmäßig sind keine Multipart-Resolver konfiguriert, aber um sie für das Hochladen von Dateien zu verwenden, müssen wir lediglich eine Bean mit dem Namen „multipartResolver“ und dem Typ MultipartResolver in den Spring-Bean-Konfigurationen definieren.

Nach der Konfiguration wird jede Multipart-Anforderung vom konfigurierten MultipartResolver aufgelöst und an eine verpackte HttpServletRequest weitergeleitet. Anschließend wird es in der Controller-Klasse verwendet, um die Datei zu erhalten und zu verarbeiten. Für ein vollständiges Beispiel lesen Sie bitte Spring MVC-Datei-Upload-Beispiel.

28. Wie behandelt man Ausnahmen im Spring MVC Framework?

Das Spring MVC Framework bietet verschiedene Möglichkeiten, um eine robuste Ausnahmebehandlung zu erreichen.

Controller-basiert – Wir können Ausnahmebehandlungsmethoden in unseren Controller-Klassen definieren. Alles, was wir tun müssen, ist, diese Methoden mit der @ExceptionHandler-Annotation zu kennzeichnen.

Globaler Ausnahmebehandler – Die Ausnahmebehandlung ist ein übergreifendes Anliegen und Spring bietet die @ControllerAdvice-Annotation, die wir mit jeder Klasse verwenden können, um unseren globalen Ausnahmebehandler zu definieren.

Implementierung des HandlerExceptionResolver – Für generische Ausnahmen verwenden wir oft statische Seiten. Das Spring Framework stellt eine HandlerExceptionResolver-Schnittstelle zur Verfügung, die wir implementieren können, um einen globalen Ausnahmebehandler zu erstellen. Der Grund für diese zusätzliche Möglichkeit, den globalen Ausnahmebehandler zu definieren, besteht darin, dass das Spring Framework auch standardmäßige Implementierungsklassen bereitstellt, die wir in unserer Spring Bean-Konfigurationsdatei definieren können, um die Vorteile der Ausnahmebehandlung des Spring Frameworks zu nutzen.

Für ein vollständiges Beispiel lesen Sie bitte Spring Exception Handling Example.

29. Wie erstellt man einen ApplicationContext in einem Java-Programm?

Es gibt verschiedene Möglichkeiten, einen Spring-Kontext in einem eigenständigen Java-Programm zu erstellen.

  1. AnnotationConfigApplicationContext: Wenn wir Spring in eigenständigen Java-Anwendungen verwenden und Annotationen für die Konfiguration verwenden, können wir dies verwenden, um den Container zu initialisieren und die Bean-Objekte abzurufen.
  2. ClassPathXmlApplicationContext: Wenn wir eine Spring Bean-Konfigurationsdatei in einer eigenständigen Anwendung haben, können wir diese Klasse verwenden, um die Datei zu laden und das Container-Objekt abzurufen.
  3. FileSystemXmlApplicationContext: Dies ist ähnlich wie ClassPathXmlApplicationContext, mit dem Unterschied, dass die XML-Konfigurationsdatei aus jedem beliebigen Verzeichnis im Dateisystem geladen werden kann.

30. Können wir mehrere Spring-Konfigurationsdateien haben?

Für Spring MVC-Anwendungen können wir mehrere Spring-Kontextkonfigurationsdateien über contextConfigLocation definieren. Diese Positionszeichenfolge kann aus mehreren Positionen bestehen, die durch beliebige Anzahl von Kommas und Leerzeichen getrennt sind. Zum Beispiel;

<servlet>
	<servlet-name>appServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
            <param-name>contextConfigLocation</param-name>
	    <param-value>/WEB-INF/spring/appServlet/servlet-context.xml,/WEB-INF/spring/appServlet/servlet-jdbc.xml</param-value>
	</init-param>
	<load-on-startup>1</load-on-startup>
</servlet>

Wir können auch mehrere Wurzelebene-Spring-Konfigurationen definieren und sie über context-param laden. Zum Beispiel;

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml /WEB-INF/spring/root-security.xml</param-value>
</context-param>

Eine weitere Option besteht darin, das import-Element in der Kontextkonfigurationsdatei zu verwenden, um andere Konfigurationen zu importieren, zum Beispiel:

<beans:import resource="spring-jdbc.xml"/>

31. Was ist ContextLoaderListener?

ContextLoaderListener ist die Listener-Klasse, die verwendet wird, um den Wurzelkontext zu laden und Spring-Bean-Konfigurationen zu definieren, die für alle anderen Kontexte sichtbar sind. Es wird in der Datei web.xml wie folgt konfiguriert:

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
	
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

32. Welche Mindestkonfigurationen sind erforderlich, um eine Spring MVC-Anwendung zu erstellen?

Um eine einfache Spring MVC-Anwendung zu erstellen, müssten wir die folgenden Aufgaben erledigen.

  • Fügen Sie die Abhängigkeiten „spring-context“ und „spring-webmvc“ dem Projekt hinzu.
  • Konfigurieren Sie DispatcherServlet in der web.xml-Datei, um Anfragen über den Spring-Container zu verarbeiten.
  • Spring-Bean-Konfigurationsdatei zum Definieren von Beans, wenn Annotationen verwendet werden, dann muss dies hier konfiguriert werden. Außerdem müssen wir den View-Resolver für Ansichtsseiten konfigurieren.
  • Controller-Klasse mit definierten Anforderungszuordnungen, um die Client-Anfragen zu bearbeiten.

Die oben genannten Schritte sollten ausreichen, um eine einfache Spring MVC Hello World-Anwendung zu erstellen.

33. Wie würden Sie das Spring MVC Framework mit der MVC-Architektur in Beziehung setzen?

Wie der Name schon sagt, basiert Spring MVC auf der Architektur des Model-View-Controller. DispatcherServlet ist der Frontcontroller in der Spring MVC-Anwendung, der sich um alle eingehenden Anfragen kümmert und sie an verschiedene Controller-Handlermethoden delegiert.

Das Modell kann jede Java-Bean im Spring-Framework sein, genau wie bei jedem anderen MVC-Framework bietet Spring automatische Bindung von Formulardaten an Java-Beans. Wir können Modell-Beans als Attribute festlegen, die in den Ansichtsseiten verwendet werden sollen.

Ansichtsseiten können JSP, statisches HTML usw. sein, und View-Resolver sind dafür verantwortlich, die richtige Ansichtsseite zu finden. Sobald die Ansichtsseite identifiziert ist, wird die Steuerung an den DispatcherServlet-Controller zurückgegeben. DispatcherServlet ist dafür verantwortlich, die Ansicht zu rendern und die endgültige Antwort an den Client zurückzugeben.

34. Wie erreicht man Lokalisierung in Spring MVC-Anwendungen?

Spring bietet eine ausgezeichnete Unterstützung für Lokalisierung oder i18n durch Ressourcenbündel. Die grundlegenden Schritte, um unsere Anwendung zu lokalisieren, sind:

  • Erstellen von Nachrichten-Ressourcenbündeln für verschiedene Sprachversionen, wie messages_en.properties, messages_fr.properties, usw.
  • Definieren des messageSource-Beans in der Spring Bean-Konfigurationsdatei vom Typ ResourceBundleMessageSource oder ReloadableResourceBundleMessageSource.
  • Für die Unterstützung von Sprachänderungen das localeResolver-Bean vom Typ CookieLocaleResolver definieren und den LocaleChangeInterceptor-Interceptor konfigurieren. Eine Beispielkonfiguration wird wie folgt gezeigt:
<beans:bean id="messageSource"
class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
<beans:property name="basename" value="classpath:messages" />
<beans:property name="defaultEncoding" value="UTF-8" />
</beans:bean>
 
<beans:bean id="localeResolver"
    class="org.springframework.web.servlet.i18n.CookieLocaleResolver">
    <beans:property name="defaultLocale" value="en" />
    <beans:property name="cookieName" value="myAppLocaleCookie"></beans:property>
    <beans:property name="cookieMaxAge" value="3600"></beans:property>
</beans:bean>
 
<interceptors>
    <beans:bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
        <beans:property name="paramName" value="locale" />
    </beans:bean>
</interceptors>
  • Verwenden Sie das spring:message-Element in den Ansichtsseiten mit Schlüsselnamen. Der DispatcherServlet wählt den entsprechenden Wert aus und rendert die Seite in der entsprechenden Sprachversion und gibt sie als Antwort zurück.

Für ein vollständiges Beispiel lesen Sie bitte Spring-Beispiel zur Lokalisierung.

35. Wie können wir Spring verwenden, um einen Restful Web Service zu erstellen, der eine JSON-Antwort zurückgibt?

Wir können das Spring Framework verwenden, um Restful Web Services zu erstellen, die JSON-Daten zurückgeben. Spring bietet eine Integration mit der Jackson JSON API, die wir verwenden können, um JSON-Antworten in einem Restful Web Service zu senden.

Um unsere Spring MVC-Anwendung zu konfigurieren, um eine JSON-Antwort zu senden, müssen wir die folgenden Schritte durchführen.

1. Fügen Sie die Jackson JSON-Abhängigkeiten hinzu. Wenn Sie Maven verwenden, können Sie dies mit folgendem Code tun:

<!-- Jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson.databind-version}</version>
</dependency>

2. Konfigurieren Sie das RequestMappingHandlerAdapter-Bean in der Spring-Bean-Konfigurationsdatei und setzen Sie die Eigenschaft message converters auf das MappingJackson2HttpMessageConverter-Bean. Eine Beispielkonfiguration wäre:

<!-- Konfiguriere JSON als Anfrage und Antwort im Methodenhandler -->
<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <beans:property name="messageConverters">
        <beans:list>
            <beans:ref bean="jsonMessageConverter"/>
        </beans:list>
    </beans:property>
</beans:bean>
     
<!-- Konfiguriere das Bean, um JSON in POJO und umgekehrt zu konvertieren -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>

3. In den Methoden des Controller-Handlers geben Sie das Objekt als Antwort mit der @ResponseBody-Annotation zurück. Beispielcode:

@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {
    logger.info("Start getEmployee. ID="+empId);
     
    return empData.get(empId);
}

4. Sie können den Rest-Service über eine beliebige API aufrufen, aber wenn Sie Spring verwenden möchten, können Sie dies einfach mit der Klasse RestTemplate tun.

Für ein vollständiges Beispiel lesen Sie bitte Spring Restful Webservice Example.

36. Welche wichtigen Spring-Annotationen haben Sie verwendet?

Einige der von mir in meinem Projekt verwendeten Spring-Annotationen sind:

37. Können wir ein Objekt als Antwort auf eine Controller-Handler-Methode senden?

Ja, das können wir tun, indem wir die @ResponseBody-Annotation verwenden. Auf diese Weise senden wir JSON- oder XML-basierte Antworten in RESTful-Webdiensten.

38. Wie können Dateien in einer Spring MVC-Anwendung hochgeladen werden?

Spring bietet eine integrierte Unterstützung zum Hochladen von Dateien über Implementierungen des MultipartResolver-Interfaces. Es ist sehr einfach zu verwenden und erfordert nur Konfigurationsänderungen, um es zum Laufen zu bringen. Wir müssten eine Controller-Handler-Methode schreiben, um die eingehende Datei zu verarbeiten. Für ein vollständiges Beispiel siehe Spring File Upload Example.

39. Wie validiert man Formulardaten im Spring Web MVC Framework?

Spring unterstützt JSR-303-annotationsbasierte Validierungen und bietet eine Validator-Schnittstelle, die wir implementieren können, um unseren eigenen benutzerdefinierten Validator zu erstellen. Um die JSR-303-basierte Validierung zu verwenden, müssen wir Bean-Variablen mit den erforderlichen Validierungen annotieren.

Für die Implementierung eines benutzerdefinierten Validators müssen wir diesen in der Controller-Klasse konfigurieren. Für ein vollständiges Beispiel lesen Sie bitte Spring MVC Form Validation Example.

40. Was ist ein Spring MVC Interceptor und wie wird er verwendet?

Spring MVC Interceptors sind wie Servlet-Filter und ermöglichen es uns, Client-Anfragen abzufangen und zu verarbeiten. Wir können Client-Anfragen an drei Stellen abfangen – preHandle, postHandle und afterCompletion.

Einen Spring-Interceptor können wir erstellen, indem wir die Schnittstelle HandlerInterceptor implementieren oder die abstrakte Klasse HandlerInterceptorAdapter erweitern.

Wir müssen Interceptors in der Spring Bean-Konfigurationsdatei konfigurieren. Wir können einen Interceptor definieren, um alle Client-Anfragen abzufangen, oder ihn auch für bestimmte URI-Zuordnungen konfigurieren. Für ein detailliertes Beispiel siehe Spring MVC Interceptor Beispiel.

41. Was ist die Spring JdbcTemplate-Klasse und wie wird sie verwendet?

Das Spring Framework bietet eine ausgezeichnete Integration mit der JDBC-API und stellt die JdbcTemplate-Hilfsklasse bereit, die wir verwenden können, um boilerplate-Code aus unserer Datenbankbetriebslogik wie das Öffnen/Schließen von Verbindungen, ResultSet, PreparedStatement usw. zu vermeiden.

Für ein Beispiel zur Verwendung von JdbcTemplate siehe Spring JDBC Beispiel.

42. Wie verwendet man Tomcat JNDI DataSource in einer Spring Webanwendung?

Um den Servlet-Container konfigurierten JNDI DataSource zu verwenden, müssen wir ihn in der Spring-Bean-Konfigurationsdatei konfigurieren und dann als Abhängigkeiten in Spring-Beans einfügen. Anschließend können wir es mit JdbcTemplate verwenden, um Datenbankoperationen durchzuführen.

<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>
</beans:bean>

Für ein vollständiges Beispiel siehe Spring Tomcat JNDI Beispiel.

43. Wie erreichen Sie die Transaktionsverwaltung in Spring?

Das Spring-Framework bietet Unterstützung für die Transaktionsverwaltung durch deklarative Transaktionsverwaltung sowie programmatische Transaktionsverwaltung. Die deklarative Transaktionsverwaltung wird am häufigsten verwendet, da sie einfach zu verwenden ist und in den meisten Fällen funktioniert.

Wir annotieren eine Methode mit der Annotation @Transactional für die deklarative Transaktionsverwaltung. Wir müssen den Transaktionsmanager für den DataSource in der Spring-Bean-Konfigurationsdatei konfigurieren.

<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

44. Was ist Spring DAO?

Spring DAO-Unterstützung wird bereitgestellt, um mit Datenzugriffstechnologien wie JDBC, Hibernate auf konsistente und einfache Weise zu arbeiten. Zum Beispiel haben wir JdbcDaoSupport, HibernateDaoSupport, JdoDaoSupport und JpaDaoSupport für die jeweiligen Technologien.

Spring DAO bietet auch Konsistenz in der Ausnahmehierarchie und wir müssen keine spezifischen Ausnahmen abfangen.

45. Wie integriert man Spring- und Hibernate-Frameworks?

Wenn Sie Hibernate 3+ verwenden, wo SessionFactory die aktuelle Sitzung bereitstellt, sollten Sie HibernateTemplate oder HibernateDaoSupport-Klassen vermeiden und das DAO-Muster mit Dependency Injection für die Integration verwenden.

Spring ORM bietet Unterstützung für die Verwendung der deklarativen Transaktionsverwaltung von Spring. Daher sollten Sie das nutzen, anstatt den Hibernate-Boilerplate-Code für die Transaktionsverwaltung zu verwenden.

Zur besseren Verständnis sollten Sie die folgenden Tutorials durchgehen:

46. Was ist Spring Security?

Das Spring Security Framework konzentriert sich darauf, sowohl Authentifizierung als auch Autorisierung in Java-Anwendungen bereitzustellen. Es kümmert sich auch um die meisten gängigen Sicherheitslücken wie CSRF-Angriffe.

Es ist sehr vorteilhaft und einfach, Spring Security in Webanwendungen zu verwenden, durch die Verwendung von Annotationen wie @EnableWebSecurity. Sie sollten die folgenden Beiträge durchgehen, um zu lernen, wie man das Spring Security Framework verwendet.

47. Wie kann man eine java.util.Properties in ein Spring Bean einfügen?

Wir müssen den propertyConfigurer-Bean definieren, der die Eigenschaften aus der angegebenen Property-Datei lädt. Dann können wir die Unterstützung von Spring EL verwenden, um Eigenschaften in andere Bean-Abhängigkeiten einzufügen. Zum Beispiel:

<bean id="propertyConfigurer" 
  class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
    <property name="location" value="/WEB-INF/application.properties" />
</bean> 

<bean class="com.journaldev.spring.EmployeeDaoImpl">
    <property name="maxReadResults" value="${results.read.max}"/>
</bean>

Wenn Sie Annotationen verwenden, um das Spring Bean zu konfigurieren, können Sie Eigenschaften wie folgt injizieren.

@Value("${maxReadResults}") 
private int maxReadResults;

48. Nennen Sie einige der Entwurfsmuster, die im Spring Framework verwendet werden?

Das Spring Framework verwendet viele Entwurfsmuster. Einige der gängigen sind:

  1. Singleton-Muster: Erstellen von Beans mit Standardscope.
  2. Factory-Muster: Bean Factory-Klassen
  3. Prototyp-Muster: Bean-Bereiche
  4. Adapter-Muster: Spring Web und Spring MVC
  5. Proxy-Muster: Unterstützung für Spring Aspektorientierte Programmierung
  6. Vorlagenmethode-Muster: JdbcTemplate, HibernateTemplate, etc
  7. Front-Controller: Spring MVC DispatcherServlet
  8. Datenzugriffsobjekt: Unterstützung für Spring DAO
  9. Dependency Injection und Aspektorientierte Programmierung

49. Was sind einige bewährte Methoden für das Spring Framework?

Einige bewährte Methoden für das Spring Framework sind:

  • Vermeiden Sie Versionsnummern in Schema-Referenzen, um sicherzustellen, dass wir die neuesten Konfigurationen haben.
  • Teilen Sie Spring Bean-Konfigurationen nach ihren Anliegen auf, z.B. spring-jdbc.xml, spring-security.xml.
  • Für Spring Beans, die in mehreren Kontexten in Spring MVC verwendet werden, erstellen Sie sie im Root-Kontext und initialisieren Sie sie mit dem Listener.
  • Konfigurieren Sie Bean-Abhängigkeiten so weit wie möglich und vermeiden Sie so weit wie möglich die Automatisierungsverdrahtung.
  • Für anwendungsweite Eigenschaften ist der beste Ansatz das Erstellen einer Eigenschaftsdatei und das Lesen in der Spring Bean-Konfigurationsdatei.
  • Für kleinere Anwendungen sind Annotationen nützlich, aber für größere Anwendungen können Annotationen problematisch werden. Wenn wir alle Konfigurationen in XML-Dateien haben, wird die Wartung erleichtert.
  • Verwenden Sie korrekte Annotationen für Komponenten, um den Zweck leicht zu verstehen. Verwenden Sie für Services @Service und für DAO-Beans @Repository.
  • Der Spring-Framework verfügt über viele Module, verwenden Sie nur das, was Sie benötigen. Entfernen Sie alle zusätzlichen Abhängigkeiten, die normalerweise hinzugefügt werden, wenn Sie Projekte über Spring Tool Suite-Vorlagen erstellen.
  • Wenn Sie Aspekte verwenden, stellen Sie sicher, dass der Join Point so eng wie möglich ist, um Ratschläge für unerwünschte Methoden zu vermeiden. Verwenden Sie benutzerdefinierte Annotationen, die einfacher zu verwenden sind und keine Probleme verursachen.
  • Verwenden Sie Dependency Injection nur dann, wenn es tatsächlich von Vorteil ist. Verwenden Sie es nicht nur wegen der lose gekoppelten Struktur, da es schwieriger zu warten ist.

50. Was ist Spring Boot?

Spring Boot macht das Spring Framework einzigartig. Es bietet uns eine einfache Möglichkeit, verschiedene Arten von Java-Anwendungen zu erstellen und sie mit der Laufzeitumgebung des Servlet-Containers zu verbinden. Dadurch erhalten wir eine einzelne JAR-Datei, die wir ausführen können, um das Projekt zu starten. Dies spart uns viel Zeit, um schnell ein skelettiertes Projekt bereitzustellen, das für die Produktbereitstellung geeignet ist. Auf diese Weise können wir uns mehr auf die Geschäftslogik konzentrieren, anstatt den üblichen Prozess des Code-Buildens und anschließenden Bereitstellens auf einem Servlet-Container durchzugehen. Da es ein sehr umfangreiches Thema ist, würde ich vorschlagen, dass Sie sich Fragen zum Spring Boot Interview durchlesen.

Das ist alles für die Fragen zum Spring Framework Interview. Ich hoffe, diese Fragen werden Ihnen bei Ihrem kommenden Java EE Interview helfen. Ich werde laufend weitere Fragen zur Liste hinzufügen, sobald ich sie finde. Wenn Sie weitere Fragen kennen, die Teil der Liste sein sollten, fügen Sie bitte einen Kommentar hinzu, und ich werde sie aufnehmen.

Source:
https://www.digitalocean.com/community/tutorials/spring-interview-questions-and-answers