Spring Bewerbungsgespräch Fragen und Antworten

Dieser Beitrag wird Ihnen helfen, Spring Bewerbungsgespräch Fragen zu verstehen und erklärt die Kernkonzepte im Detail.

Das Spring Framework ist eines der beliebtesten Java EE Frameworks für Webanwendungen. Dependency Injection und Aspect-Oriented Programming stehen im Mittelpunkt des Spring Frameworks. Wenn Sie sich gut mit dem Spring Framework auskennen, sind die Chancen, in Java Bewerbungsgesprächen ausgewählt zu werden, sehr hoch.

Hier stelle ich fast 50 Spring Bewerbungsgespräch Fragen und ihre Antworten bereit.

Es ist auf dem neuesten Stand bis Spring 5, daher deckt es alle neuesten Funktionen ab, wie zum Beispiel Spring WebFlux für Reactive Programming.

Interviewfragen

1. Was ist das Spring Framework?

Spring ist eines der am weitesten verbreiteten Java EE Frameworks. Die Kernkonzepte des Spring Frameworks sind „Dependency Injection“ und „Aspect-Oriented Programming“.

Das Spring Framework kann auch in normalen Java-Anwendungen verwendet werden, um eine lose Kopplung zwischen verschiedenen Komponenten durch Implementierung von Dependency Injection zu erreichen. Wir können querschnittliche Aufgaben wie Logging und Authentifizierung mit Spring-Unterstützung für aspect-oriented programming durchführen.

Ich mag Spring, weil es viele Funktionen und verschiedene Module für spezifische Aufgaben bietet, wie zum Beispiel Spring MVC und Spring JDBC. Da es ein Open-Source-Framework mit vielen Online-Ressourcen und aktiven Community-Mitgliedern ist, ist die Arbeit mit dem Spring Framework gleichzeitig einfach und macht Spaß.

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

Das Spring Framework basiert auf zwei Designkonzepten – Dependency Injection und Aspect-Oriented Programming.

Einige der Funktionen des Spring Frameworks sind:

• Leichtgewichtig und sehr geringer Overhead bei der Verwendung eines Frameworks für unsere Entwicklung.
• Dependency Injection oder Inversion of Control, um Komponenten zu schreiben, die unabhängig voneinander sind, der Spring Container kümmert sich um das Verbinden dieser Komponenten, um unsere Arbeit zu erreichen.
• Der Spring IoC Container verwaltet den Lebenszyklus von Spring Beans und projektspezifische Konfigurationen wie JNDI-Lookup.
• Das Spring MVC Framework kann verwendet werden, um Webanwendungen sowie RESTful Web Services zu erstellen, die XML sowie JSON-Antworten zurückgeben können.
• Unterstützung für Transaktionsmanagement, JDBC-Operationen, Datei-Upload, Exception Handling usw. mit sehr wenigen Konfigurationen, entweder durch die Verwendung von Annotationen oder durch Spring Bean-Konfigurationsdatei.

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 verantwortlich für die Initialisierung von Ressourcen oder Beans und injiziert sie als Abhängigkeiten.
• Das Schreiben von Unit-Testfällen ist im Spring Framework einfach, weil unsere Geschäftslogik keine direkten Abhängigkeiten mit tatsächlichen Ressourcenimplementierungsklassen hat. Wir können leicht eine Testkonfiguration schreiben und unsere Mock-Beans zu Testzwecken injizieren.
• Reduziert die Menge an Boilerplate-Code, wie das Initialisieren von Objekten, Öffnen/Schließen von Ressourcen. Ich mag die JdbcTemplate-Klasse sehr, weil sie uns hilft, den gesamten Boilerplate-Code, der mit der JDBC-Programmierung einhergeht, zu entfernen.
• Das Spring Framework ist in mehrere Module unterteilt, es hilft uns, unsere Anwendung leichtgewichtig zu halten. Zum Beispiel, wenn wir die Funktionen für Spring Transaktionsmanagement nicht benötigen, müssen wir diese Abhängigkeit nicht in unser Projekt aufnehmen.
• Das Spring Framework unterstützt die meisten Java EE-Funktionen und noch viel mehr. Es ist immer auf dem neuesten Stand der Technik, zum Beispiel gibt es ein Spring Projekt für Android, um uns zu helfen, besseren Code für native Android-Anwendungen zu schreiben. Das macht das Spring Framework zu einem kompletten Paket und wir müssen uns nicht um verschiedene Frameworks für unterschiedliche Anforderungen kümmern.

4. Welche sind die wichtigen Funktionen von Spring 5?

Spring 5 ist eine bedeutende Überarbeitung von Spring 4. Einige der wichtigen 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 jetzt über NIO 2-Streams durchgeführt, eine große Verbesserung, wenn Ihre App viele Dateioperationen durchführt.
• Einführung von spring-jcl zur Vereinfachung des Loggings, früher war es ein Durcheinander, da es keinen einzigen Punkt für Logging-Zwecke gab.
• Unterstützung für Kotlin, Lombok, Reactor 3.1 Flux und Mono sowie RxJava.
• Spring WebFlux, das Reactive Programming zu Spring bringt.
• Unterstützung für JUnit 5
• Unterstützung für die Bereitstellung von Informationen zu Spring-Komponenten durch die Indexdatei „META-INF/spring.components“ anstelle des Klassenpfad-Scannings.

5. Was ist Spring WebFlux?

Spring WebFlux ist das neue Modul, das in Spring 5 eingeführt wurde. Spring WebFlux ist der erste Schritt in Richtung des Reactive Programming-Modells 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 zu erstellen, die auf dem Event-Loop-Execution-Modell basiert.

6. Was verstehen Sie unter Dependency Injection?

Das Designmuster der Dependency Injection ermöglicht es uns, hartkodierte Abhängigkeiten zu entfernen und unsere Anwendung lose gekoppelt, erweiterbar und wartbar zu machen. Wir können das Dependency Injection-Muster implementieren, um die Abhängigkeitsauflösung von der Kompilierungszeit zur Laufzeit zu verlagern.

Einige der Vorteile der Verwendung von Dependency Injection sind Trennung von Belangen, Reduzierung von Boilerplate-Code, konfigurierbare Komponenten und einfache Unit-Tests.

7. Wie implementieren wir DI im Spring Framework?

Wir können sowohl Spring XML-basierte als auch auf Annotationen basierende Konfiguration verwenden, um DI in Spring-Anwendungen zu implementieren.

8. Welche Vorteile bietet die Verwendung des Spring Tool Suite?

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

Ich mag STS, weil es die Spring-Komponenten hervorhebt und wenn Sie AOP-Pointcuts und Ratschläge verwenden, zeigt es deutlich, welche Methoden unter den spezifischen Pointcut fallen. Daher bevorzuge ich die Verwendung von STS bei der Entwicklung von Spring-basierten Anwendungen, anstatt alles selbst zu installieren.

9. Nennen Sie einige der wichtigen Spring-Module?

Einige der wichtigen Module des Spring Frameworks sind:

• Spring Context – für Dependency Injection.
• Spring AOP – für aspect-oriented programming.
• Spring DAO – für Datenbankoperationen unter Verwendung des DAO-Musters.
• Spring JDBC – für JDBC und DataSource-Unterstützung.
• Spring ORM – für ORM-Tools-Unterstützung wie Hibernate.
• Spring Web Module – für die Erstellung von Webanwendungen.
• Spring MVC – Model-View-Controller-Implementierung für die Erstellung von Webanwendungen, Webdiensten usw.

10. Spring Bewerbungsgespräch Frage: Was verstehen Sie unter Aspect-Oriented Programming?

Unternehmensanwendungen haben einige gemeinsame querschnittliche Anliegen, die für verschiedene Arten von Objekten und Anwendungsmodulen gelten, wie Logging, Transaktionsmanagement, 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 überschneiden.

AOP entfernt die direkte Abhängigkeit von querschnittlichen Aufgaben aus Klassen, die in der normalen objektorientierten Programmierung nicht möglich sind. Zum Beispiel können wir eine separate Klasse für das Logging haben, aber die anderen Klassen müssen diese Methoden aufrufen. Aber in AOP konfigurieren wir die Aspekte und die Methodenausführung erfolgt automatisch.

11. Was ist Aspect, Advice, Pointcut, JointPoint und Advice Arguments in AOP?

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

Advice: Advice ist die Aktion, die für einen bestimmten Join Point unternommen wird. Programmatisch gesehen sind es Methoden, die ausgeführt werden, wenn ein spezifischer Join Point mit einem passenden Pointcut in der Anwendung erreicht wird.

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

JoinPoint: Ein Join Point ist ein spezifischer Punkt in der Anwendung wie Methodenausführung, Exception Handling, Ändern von Objektvariablenwerten usw. In Spring AOP ist ein Join Point immer die Ausführung einer Methode.

Advice Arguments: Wir können Argumente in den Advice-Methoden übergeben. Wir können den Ausdruck args() im Pointcut verwenden, der auf jede Methode angewendet wird, die dem Argumentmuster entspricht. Wenn wir dies verwenden, müssen wir denselben Namen in der Advice-Methode verwenden, von wo aus der Argumenttyp bestimmt wird.

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

AspectJ ist die branchenübliche Implementierung für Aspect-Oriented Programming, während Spring AOP in einigen Fällen implementiert wird. Die Hauptunterschiede zwischen Spring AOP und AspectJ sind:

• Spring AOP ist einfacher zu verwenden als AspectJ, da wir uns keine Sorgen über den Webeprozess machen 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 proxy-basiertes AOP, daher kann es nur auf Methodenausführungs-Join Points angewendet werden. AspectJ unterstützt alle Arten von Pointcuts.
• Einer der Nachteile von Spring AOP ist, dass es nur auf die Beans angewendet werden kann, die durch den Spring Context erstellt wurden.

13. Was ist ein Spring IoC Container?

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

Die Klassen des Spring Framework 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, die auf Annotationen basierende Konfiguration verwenden.
• ClassPathXmlApplicationContext: Für eigenständige Java-Anwendungen, die XML-basierte Konfiguration verwenden.
• FileSystemXmlApplicationContext: Ähnlich wie ClassPathXmlApplicationContext, außer 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 Spring ApplicationContext, um die Spring Bean-Instanz zu erhalten.

Der Spring IoC Container verwaltet den Lebenszyklus von Spring Bean, Bean-Bereiche und injiziert alle erforderlichen Abhängigkeiten in das Bean.

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

Wir verwenden die Spring Bean-Konfigurationsdatei, um alle Beans zu definieren, die vom Spring Context initialisiert werden. Wenn wir die Instanz von Spring ApplicationContext erstellen, liest es die Spring Bean XML-Datei und initialisiert 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-Interceptor, View-Resolver und andere Elemente zur Unterstützung von auf Annotationen basierenden Konfigurationen.

16. Welche verschiedenen Möglichkeiten gibt es, eine Klasse als Spring Bean zu konfigurieren?

Es gibt drei verschiedene Wege, um eine Spring Bean zu konfigurieren.

• XML-Konfiguration: Dies ist die beliebteste Konfiguration und wir können das Bean-Element in der Kontextdatei verwenden, um eine 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 eine Spring Bean mit der Annotation @Bean konfigurieren. Diese Annotation wird zusammen mit @Configuration-Klassen verwendet, um eine Spring Bean zu konfigurieren. Ein Beispiel für die Konfiguration ist:

  @Configuration
  @ComponentScan(value="com.journaldev.spring.main")
  public class MyConfiguration {
  
      @Bean
      public MyService getService(){
          return new MyService();
      }
  }
  

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

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

17. Was sind die verschiedenen Scopes von Spring Beans?

Es gibt fünf definierte Scopes für Spring Beans.

• singleton: Für jeden Container wird nur eine Instanz des Beans erstellt. Dies ist der Standard-Scope für Spring Beans. Achten Sie bei der Verwendung dieses Scopes darauf, dass Spring Bean keine gemeinsam genutzten Instanzvariablen hat, da dies zu Dateninkonsistenzen führen kann, weil es nicht threadsicher ist.
• prototype: Bei jeder Anforderung des Beans wird eine neue Instanz erstellt.
• request: Dies ist derselbe wie der prototype Scope, jedoch ist er für Webanwendungen gedacht. Für jede HTTP-Anfrage wird eine neue Instanz des Beans erstellt.
• session: Für jede HTTP-Sitzung wird vom Container ein neues Bean erstellt.
• global-session: Dies wird verwendet, um globale Session-Beans für Portlet-Anwendungen zu erstellen.

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

18. Was ist der Lebenszyklus eines Spring Beans?

Spring Beans werden vom Spring Container initialisiert und alle Abhängigkeiten werden ebenfalls injiziert. 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 Validierungen durchführen, bevor unsere Beans einsatzbereit sind. Das Spring Framework bietet Unterstützung für Methoden nach der Initialisierung und vor dem Zerstören in Spring Beans.

Wir können dies auf zwei Arten tun – indem wir die Interfaces InitializingBean und DisposableBean implementieren oder die Attribute init-method und destroy-method in den Spring Bean-Konfigurationen verwenden.

19. Wie erhält man ServletContext und ServletConfig-Objekt in einem Spring Bean?

Es gibt zwei Wege, um Container-spezifische Objekte im Spring Bean zu erhalten.

• Implementierung der Spring *Aware-Interfaces, für diese ServletContextAware und ServletConfigAware Interfaces
• Verwendung der Annotation @Autowired mit Bean-Variablen vom Typ ServletContext und ServletConfig. Diese funktionieren nur in servlet container-spezifischen Umgebungen.

@Autowired
ServletContext servletContext;

20. Spring Bewerbungsgespräch Frage: Was ist Bean Wiring und die @Autowired Annotation?

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

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

21. Welche verschiedenen Arten von Spring Bean-Autowiring gibt es?

Es gibt vier Arten von Autowiring im Spring Framework.

• autowire byName
• autowire byType
• autowire by constructor
• autowiring durch @Autowired und @Qualifier Annotationen

Vor Spring 3.1 wurde auch autowire by autodetect unterstützt, das ähnlich wie autowire by constructor oder byType war.

22. Bietet Spring Bean Thread-Sicherheit?

Der Standard-Scope eines Spring Beans ist singleton, daher wird es pro Kontext nur eine Instanz geben. Das bedeutet, dass alle eine Klassenlevel-Variable haben, die von jedem Thread aktualisiert werden kann, was zu inkonsistenten Daten führen kann. Daher sind Spring Beans im Standardmodus nicht thread-sicher.

Wir können jedoch den Spring Bean-Scope auf request, prototype oder session ändern, um Thread-Sicherheit auf Kosten der Leistung zu erreichen. Es ist eine Designentscheidung und basiert auf den Projektanforderungen.

23. Was ist ein Controller in Spring MVC?

Genau wie das MVC-Designmuster ist der Controller die Klasse, die sich um alle Kundenanfragen kümmert und diese an die konfigurierten Ressourcen zur Bearbeitung weiterleitet. In Spring MVC ist der DispatcherServlet der Frontcontroller, der den Kontext basierend auf den Spring Bean-Konfigurationen initialisiert.

Ein Controller ist verantwortlich für die Bearbeitung verschiedener Arten von Kundenanfragen basierend auf den Request-Mappings. Wir können eine Controller-Klasse erstellen, indem wir die Annotation @Controller verwenden. Üblicherweise wird sie mit der Annotation @RequestMapping verwendet, um Handlermethoden für spezifische URI-Mappings zu definieren.

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

@Component wird verwendet, um anzugeben, dass eine Klasse ein Bestandteil ist. Diese Klassen werden zur automatischen Erkennung verwendet und als Bean konfiguriert, wenn auf Annotationen basierende Konfigurationen verwendet werden.

@Controller ist eine spezifische Art von Komponente, die in MVC-Anwendungen verwendet wird und meistens mit der Annotation RequestMapping verwendet wird.

Die Annotation @Repository wird verwendet, um anzugeben, dass eine Komponente als Repository und als Mechanismus zum Speichern/Abfragen/Suchen von Daten dient. Wir können diese Annotation mit Klassen implementieren, die das DAO-Muster verwenden.

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

Wir können jede 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 sind DispatcherServlet und ContextLoaderListener?

DispatcherServlet ist der Frontcontroller in der Spring MVC-Anwendung und lädt die Spring Bean-Konfigurationsdatei und initialisiert alle konfigurierten Beans. Wenn Annotationen aktiviert sind, scannt es auch die Pakete und konfiguriert alle Beans, die mit @Component, @Controller, @Repository oder @Service Annotationen versehen sind.

ContextLoaderListener ist der Listener, um das Spring-Root-WebApplicationContext zu starten und herunterzufahren. Seine wichtigen Funktionen sind, den Lebenszyklus des ApplicationContext an den Lebenszyklus des ServletContext zu binden und die Erstellung des ApplicationContext zu automatisieren. Wir können es verwenden, um gemeinsame Beans zu definieren, die in verschiedenen Spring-Kontexten verwendet werden können.

26. Was ist ViewResolver in Spring?

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

<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 der Implementierungen des ViewResolver-Interfaces und wir geben das Verzeichnis der Ansichtsseiten und den Suffix-Standort durch die Bean-Eigenschaften an. Wenn also eine Controller-Handler-Methode „home“ zurückgibt, verwendet der ViewResolver die Ansichtsseite, die sich unter /WEB-INF/views/home.jsp befindet.

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

Das Interface MultipartResolver wird zum Hochladen von Dateien verwendet – CommonsMultipartResolver und StandardServletMultipartResolver sind zwei Implementierungen, die das Spring Framework für das Hochladen von Dateien bereitstellt. Standardmäßig sind keine MultipartResolver konfiguriert, aber um sie zum Hochladen von Dateien zu verwenden, müssen wir einen Bean namens „multipartResolver“ mit dem Typ MultipartResolver in den Spring Bean-Konfigurationen definieren.

Einmal konfiguriert, wird jede Multipart-Anfrage vom konfigurierten MultipartResolver aufgelöst und an eine eingehüllte HttpServletRequest weitergegeben. Dann wird es in der Controller-Klasse verwendet, um die Datei zu erhalten und zu verarbeiten.

28. Wie behandelt man Ausnahmen im Spring MVC Framework?

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

• Controller-basiert – Wir können Ausnahmebehandlermethoden in unseren Controller-Klassen definieren. Alles, was wir tun müssen, ist, diese Methoden mit der Annotation @ExceptionHandler zu annotieren.
• Globaler Ausnahmebehandler – Die Ausnahmebehandlung ist ein querschnittliches Anliegen und Spring bietet die Annotation @ControllerAdvice, die wir mit jeder Klasse verwenden können, um unseren globalen Ausnahmebehandler zu definieren.
• Implementierung von HandlerExceptionResolver – Für generische Ausnahmen bedienen wir meist statische Seiten. Das Spring Framework bietet das Interface HandlerExceptionResolver, das wir implementieren können, um einen globalen Ausnahmebehandler zu erstellen. Der Grund für diese zusätzliche Möglichkeit, den globalen Ausnahmebehandler zu definieren, ist, dass das Spring Framework auch Standardimplementierungsklassen bereitstellt, die wir in unserer Spring Bean-Konfigurationsdatei definieren können, um die Vorteile der Spring Framework-Ausnahmebehandlung zu nutzen.

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

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

• AnnotationConfigApplicationContext: Wenn wir Spring in eigenständigen Java-Anwendungen verwenden und Annotationen für die Konfiguration verwenden, dann können wir dies nutzen, um den Container zu initialisieren und die Bean-Objekte zu erhalten.
• ClassPathXmlApplicationContext: Wenn wir eine Spring Bean-Konfigurations-XML-Datei in einer eigenständigen Anwendung haben, dann können wir diese Klasse verwenden, um die Datei zu laden und das Container-Objekt zu erhalten.
• FileSystemXmlApplicationContext: Ähnlich wie ClassPathXmlApplicationContext, außer dass die XML-Konfigurationsdatei von überall im Dateisystem geladen werden kann.

30. Spring Bewerbungsgespräch Frage: Können wir mehrere Spring-Konfigurationsdateien haben?

Für Spring MVC-Anwendungen können wir mehrere Spring-Kontext-Konfigurationsdateien über contextConfigLocation definieren. Diese Standortzeichenfolge kann aus mehreren Standorten bestehen, die durch beliebig viele 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 Root-Level-Spring-Konfigurationen definieren und durch 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 Möglichkeit 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 Root-Kontext zu laden und Spring Bean-Konfigurationen zu definieren, die für alle anderen Kontexte sichtbar sein werden. Es ist in der web.xml-Datei 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üssen wir folgende Aufgaben durchführen:

• Die Abhängigkeiten spring-context und spring-webmvc im Projekt hinzufügen.
• DispatcherServlet in der Datei web.xml konfigurieren, um Anfragen über den Spring Container zu verarbeiten.
• Spring Bean-Konfigurationsdatei, um Beans zu definieren. Wenn Annotationen verwendet werden, muss dies hier konfiguriert werden. Außerdem müssen wir den View-Resolver für die Ansichtsseiten konfigurieren.
• Controller-Klasse mit definierten Request-Mappings, um die Kundenanfragen 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 Model-View-Controller-Architektur. DispatcherServlet ist der Front-Controller 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 in jedem anderen MVC-Framework, bietet Spring die 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 Kontrolle wieder an den DispatcherServlet Controller übergeben. DispatcherServlet ist verantwortlich für das Rendern der Ansicht und das Zurücksenden der endgültigen Antwort an den Kunden.

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

Spring bietet hervorragende 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 Gebietsschemata, 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 des Gebietsschemawechsels, ein 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 Element spring:message in den Ansichtsseiten mit Schlüsselnamen, DispatcherServlet wählt den entsprechenden Wert aus und rendert die Seite im entsprechenden Gebietsschema und gibt sie als Antwort zurück.

35. Wie können wir Spring verwenden, um einen RESTful Webdienst zu erstellen, der JSON-Antworten zurückgibt?

Wir können das Spring Framework verwenden, um RESTful Webdienste zu erstellen, die JSON-Daten zurückgeben. Spring bietet Integration mit der Jackson JSON API, die wir verwenden können, um JSON-Antworten in einem RESTful Webdienst zu senden.

Wir müssen folgende Schritte durchführen, um unsere Spring MVC-Anwendung so zu konfigurieren, dass sie JSON-Antworten sendet:

1. Hinzufügen von Jackson JSON-Abhängigkeiten, wenn Sie Maven verwenden, kann dies mit folgendem Code erfolgen:

<!-- 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 messageConverters auf das MappingJackson2HttpMessageConverter-Bean. Eine Beispielkonfiguration wäre:

<!-- Konfigurieren, um JSON als Anfrage und Antwort im Methodenhandler zu verwenden -->
<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>
     
<!-- Konfigurieren des Beans, um JSON in POJO zu konvertieren und umgekehrt -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>

3. In den Controller-Handlermethoden geben Sie das Objekt als Antwort mit der Annotation @ResponseBody 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-Dienst über jede API aufrufen, aber wenn Sie Spring verwenden möchten, können Sie dies einfach mit der RestTemplate-Klasse tun.

36. Welche sind einige der wichtigen Spring-Annotationen, die Sie verwendet haben?

Einige der Spring-Annotationen, die ich in meinem Projekt verwendet habe, sind:

• @Controller – für Controller-Klassen im Spring MVC-Projekt.
• @RequestMapping – zur Konfiguration der URI-Zuordnung in Controller-Handlermethoden.
• @ResponseBody – um ein Objekt als Antwort zu senden, normalerweise zum Senden von XML- oder JSON-Daten als Antwort.
• @PathVariable – zur Zuordnung dynamischer Werte aus der URI zu Handlermethodenargumenten.
• @Autowired – zur automatischen Verdrahtung von Abhängigkeiten in Spring Beans.
• @Qualifier – zusammen mit der Annotation @Autowired, um Verwirrung zu vermeiden, wenn mehrere Instanzen des Bean-Typs vorhanden sind.
• @Service – für Dienstklassen.
• @Scope – zur Konfiguration des Bereichs des Spring Beans.
• @Configuration, @ComponentScan und @Bean – für Java-basierte Konfigurationen.
• AspectJ-Annotationen zur Konfiguration von Aspekten und Ratschlägen, @Aspect, @Before, @After, @Around, @Pointcut usw.

37. Können wir ein Objekt als Antwort der Controller-Handlermethode senden?

Ja, das können wir, mit der Annotation @ResponseBody. So senden wir JSON- oder XML-basierte Antworten in RESTful Webdiensten.

38. Wie lädt man Dateien in der Spring MVC-Anwendung hoch?

Spring bietet integrierte Unterstützung für das Hochladen von Dateien durch Implementierungen des MultipartResolver-Interfaces. Es ist sehr einfach zu verwenden und erfordert nur Konfigurationsänderungen, um es in Betrieb zu nehmen. Wir müssen eine Controller-Handlermethode schreiben, um die eingehende Datei zu verarbeiten. Für ein vollständiges Beispiel siehe Spring File Upload Beispiel.

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

Spring unterstützt JSR-303-Annotation-basierte Validierungen sowie ein Validator-Interface, das wir implementieren können, um unseren eigenen benutzerdefinierten Validator zu erstellen. Um 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 ihn in der Controller-Klasse konfigurieren.

40. Spring Bewerbungsgespräch Frage: Was ist ein Spring MVC Interceptor und wie wird er verwendet?

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

Wir können einen Spring Interceptor erstellen, indem wir das HandlerInterceptor-Interface 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 Kundenanfragen zu unterbrechen, oder ihn auch für bestimmte URI-Zuordnungen konfigurieren.

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

Das Spring Framework bietet eine hervorragende Integration mit der JDBC API und bietet die JdbcTemplate-Hilfsklasse, die wir verwenden können, um Boilerplate-Code aus unserer Datenbankoperationslogik wie Öffnen/Schließen der Verbindung, ResultSet, PreparedStatement usw. zu vermeiden.

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

Um eine im Servlet-Container konfigurierte JNDI DataSource zu verwenden, müssen wir sie in der Spring Bean-Konfigurationsdatei konfigurieren und dann als Abhängigkeiten in Spring Beans injizieren. Dann können wir sie 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>

43. Wie erreicht man Transaktionsmanagement in Spring?

Das Spring Framework bietet Unterstützung für das Transaktionsmanagement durch deklaratives Transaktionsmanagement sowie programmgesteuertes Transaktionsmanagement. Deklaratives Transaktionsmanagement wird am häufigsten verwendet, da es einfach zu verwenden ist und in den meisten Fällen funktioniert.

Wir verwenden die Annotation @Transactional, um eine Methode für deklaratives Transaktionsmanagement zu annotieren. Wir müssen den Transaktionsmanager für die 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 Ausnahme-Hierarchie und wir müssen keine spezifischen Ausnahmen abfangen.

45. Wie integriert man Spring und Hibernate Frameworks?

Wir können das Spring ORM-Modul verwenden, um Spring und Hibernate Frameworks zu integrieren, wenn Sie Hibernate 3+ verwenden, wo SessionFactory die aktuelle Sitzung bereitstellt, dann sollten Sie HibernateTemplate oder HibernateDaoSupport-Klassen vermeiden und besser das DAO-Muster mit Dependency Injection für die Integration verwenden.

Spring ORM bietet Unterstützung für die Verwendung von Spring deklarativem Transaktionsmanagement, daher sollten Sie dies nutzen, anstatt auf Hibernate Boilerplate-Code für das Transaktionsmanagement zurückzugreifen.

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.

47. Wie injiziert man ein java.util.Properties in ein Spring Bean?

Wir müssen das propertyConfigurer-Bean definieren, das die Eigenschaften aus der angegebenen Eigenschaftsdatei lädt. Dann können wir Spring EL-Unterstützung verwenden, um Eigenschaften in andere Bean-Abhängigkeiten zu injizieren. 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, dann können Sie Eigenschaften wie folgt injizieren.

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

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

Das Spring Framework verwendet viele Designmuster, einige der gängigen sind:

• Singleton-Muster: Erstellen von Beans mit Standard-Scope.
• Factory-Muster: Bean Factory-Klassen
• Prototype-Muster: Bean-Scopes
• Adapter-Muster: Spring Web und Spring MVC
• Proxy-Muster: Unterstützung für Spring Aspect Oriented Programming
• Template Method-Muster: JdbcTemplate, HibernateTemplate usw.
• Front Controller: Spring MVC DispatcherServlet
• Data Access Object: Unterstützung für Spring DAO
• Dependency Injection und Aspect-Oriented Programming

49. Was sind einige der besten Praktiken für das Spring Framework?

Einige der besten Praktiken für das Spring Framework sind:

• Vermeiden Sie Versionsnummern in der Schema-Referenz, um sicherzustellen, dass wir die neuesten Konfigurationen haben.
• Teilen Sie Spring Bean-Konfigurationen basierend auf ihren Anliegen auf, wie 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, versuchen Sie, Autowiring so weit wie möglich zu vermeiden.
• Für anwendungsspezifische Eigenschaften ist der beste Ansatz, eine Eigenschaftsdatei zu erstellen und sie in der Spring Bean-Konfigurationsdatei zu lesen.
• Für kleinere Anwendungen sind Annotationen nützlich, aber für größere Anwendungen können Annotationen zu einem Problem werden. Wenn wir alle Konfigurationen in XML-Dateien haben, wird die Wartung einfacher sein.
• Verwenden Sie korrekte Annotationen für Komponenten, um den Zweck leicht zu verstehen. Für Dienste verwenden Sie @Service und für DAO-Beans verwenden Sie @Repository.
• Das Spring Framework hat viele Module, verwenden Sie, 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, achten Sie darauf, den Verbindungspunkt so eng wie möglich zu halten, um unerwünschte Methoden zu vermeiden. Betrachten Sie benutzerdefinierte Annotationen, die einfacher zu verwenden sind und Probleme vermeiden.
• Verwenden Sie Dependency Injection, wenn es einen tatsächlichen Vorteil gibt, verwenden Sie es nicht nur um der losen Kopplung willen, da es schwerer zu warten ist.

50. Spring Bewerbungsgespräch Frage: 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 Servlet Container-Laufzeitumgebung zu verbinden. So erhalten wir eine einzelne JAR-Datei, die wir ausführen können, um das Projekt auszuführen. Das spart uns viel Zeit bei der Erstellung des Grundgerüsts des Projekts, das sehr schnell einsatzbereit ist. So können wir uns mehr auf die Geschäftslogik konzentrieren, anstatt den üblichen Prozess des Code-Buildings und dann des Deployments auf einem Servlet-Container zu durchlaufen.

Fazit

Das war’s für Spring Framework Bewerbungsgespräch Fragen. Ich hoffe, diese Fragen werden Ihnen im kommenden Java EE-Interview helfen. Ich werde weiterhin mehr Fragen zur Liste hinzufügen, sobald ich sie finde.