Voorjaarsinterviewvragen en antwoorden

Handleidingen
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.

Het Spring Framework is een van de meest populaire Java EE-frameworks voor webapplicaties. Dependency Injection en Aspect-Oriented Programming staan centraal in het Spring-framework. Als je goed bent in het Spring Framework, zijn de kansen om geselecteerd te worden echt hoog bij Java-interviews.

Pro Tip: Core Java is de basis van elk op Java gebaseerd framework, dus als je je voorbereidt op interviews, bekijk dan alsjeblieft de artikelen met Core Java Interviewvragen en Java Interviewvragen.

Spring Interviewvragen en Antwoorden

Hier bied ik bijna 50 lente-interviewvragen en hun antwoorden aan. Het is bijgewerkt tot Spring 5, dus het behandelt alle nieuwste functies zoals Spring WebFlux voor reactieve programmering.

1. Wat is het Spring Framework?

Spring is een van de meest gebruikte Java EE-frameworks. De kernconcepten van het Spring-framework zijn “Dependency Injection” en “Aspect-Oriented Programming”.

Het Spring-framework kan ook worden gebruikt in normale Java-toepassingen om een losse koppeling tussen verschillende componenten te bereiken door dependency injection te implementeren. We kunnen dwarsdoorsnijdende taken zoals logging en authenticatie uitvoeren met behulp van de ondersteuning van Spring voor aspect-oriented programming.

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.

Aanbevolen lectuur: Spring Framework

2. Wat zijn enkele belangrijke kenmerken van het Spring Framework?

Het Spring Framework is gebouwd op basis van twee ontwerpbegrippen – Dependency Injection en Aspect-Oriented Programming.

Enkele kenmerken van het Spring-framework zijn:

  • Lichtgewicht en zeer weinig overhead bij het gebruik van een framework voor onze ontwikkeling.
  • Dependency Injection of Inversion of Control om componenten te schrijven die onafhankelijk van elkaar zijn; de Spring-container zorgt voor de bedrading om ze samen te brengen om ons werk te realiseren.
  • De Spring IoC-container beheert de levenscyclus van Spring Bean en projectspecifieke configuraties zoals JNDI-lookup.
  • De Spring MVC-framework kan worden gebruikt om webapplicaties te maken, evenals restvolle webservices die in staat zijn XML en JSON als antwoord terug te geven.
  • Ondersteuning voor transactiebeheer, JDBC-operaties, bestandsuploaden, uitzonderingsafhandeling, enz., met zeer weinig configuraties, ofwel door annotaties te gebruiken of door middel van het Spring bean-configuratiebestand.

3. Wat is het voordeel van het gebruik van het Spring Framework?

Enkele voordelen van het gebruik van het Spring Framework zijn:

  • Het verminderen van directe afhankelijkheden tussen verschillende componenten van de applicatie. De Spring IoC-container is verantwoordelijk voor het initialiseren van resources of beans en het injecteren ervan als afhankelijkheden.
  • Het schrijven van unit testcases is eenvoudig in het Spring-framework omdat onze bedrijfslogica geen directe afhankelijkheden heeft met daadwerkelijke resource-implementatieklassen. We kunnen eenvoudig een testconfiguratie schrijven en onze mock beans injecteren voor testdoeleinden.
  • Het vermindert de hoeveelheid boilerplate-code, zoals het initialiseren van objecten, openen/sluiten van resources. Ik vind de JdbcTemplate-klasse erg fijn omdat het ons helpt bij het verwijderen van alle boilerplate-code die gepaard gaat met JDBC-programmering.
  • Het Spring-framework is verdeeld in verschillende modules, wat ons helpt om onze applicatie lichtgewicht te houden. Als we bijvoorbeeld de functies voor Spring-transactiebeheer niet nodig hebben, hoeven we die afhankelijkheid niet aan ons project toe te voegen.
  • Het Spring-framework ondersteunt de meeste Java EE-functies en zelfs nog veel meer. Het blijft altijd boven op de nieuwe technologieën; zo is er bijvoorbeeld een Spring-project voor Android om ons te helpen betere code te schrijven voor native Android-applicaties. Dit maakt het Spring-framework een compleet pakket, waardoor we niet hoeven te zoeken naar verschillende frameworks voor verschillende vereisten.

4. Wat zijn de belangrijke kenmerken van Spring 5?

Spring 5 is een grote revisie van Spring 4. Enkele belangrijke kenmerken zijn:

  • Ondersteuning voor Java 8 en nieuwere versies, zodat we lambda-uitdrukkingen kunnen gebruiken.
  • Ondersteuning voor Java EE7 en Servlet 4.0 specificaties.
  • Bestandsbewerkingen worden nu uitgevoerd via NIO 2-streams, een enorme verbetering als uw app veel bestandshandelingen uitvoert.
  • Introductie van spring-jcl om logging te stroomlijnen, voorheen was het een rommeltje vanwege het ontbreken van een enkel punt voor logging-doeleinden.
  • Ondersteuning voor Kotlin, Lombok, Reactor 3.1 Flux, en Mono evenals RxJava.
  • Spring WebFlux brengt reactief programmeren naar Spring.
  • Ondersteuning voor JUnit 5
  • Ondersteuning voor het verstrekken van informatie over Spring-componenten via het indexbestand “META-INF/spring.components” in plaats van het scannen van het classpath.

Neem alstublieft Spring 5 functies door om een gedetailleerd overzicht van deze release te krijgen.

5. Wat is Spring WebFlux?

Spring WebFlux is de nieuwe module die is geïntroduceerd in Spring 5. Spring WebFlux is de eerste stap naar het reactieve programmeermodel in het Spring-framework.

Spring WebFlux is het alternatief voor de Spring MVC-module. Spring WebFlux wordt gebruikt om een volledig asynchrone en niet-blokkerende toepassing te maken die is gebouwd op het event-loop uitvoeringsmodel.

Je kunt er meer over lezen op Spring WebFlux Tutorial.

6. Wat verstaat u onder Dependency Injection?

Het ontwerppatroon Dependency Injection stelt ons in staat om de hardcoded afhankelijkheden te verwijderen en onze toepassing losjes gekoppeld, uitbreidbaar en onderhoudbaar te maken. We kunnen het dependency injection-patroon implementeren om de afhankelijkheidsresolutie van compile-tijd naar runtime te verplaatsen.

Sommige voordelen van het gebruik van Dependency Injection zijn Scheiding van Zorgen, Vermindering van Overbodige Code, Configureerbare componenten en eenvoudige eenheidstests.

Lees meer op Dependency Injection Tutorial. We kunnen ook Google Guice voor Dependency Injection gebruiken om het proces van dependency injection te automatiseren. Maar in de meeste gevallen zijn we op zoek naar meer dan alleen dependency injection, en dat is waar Spring bovenaan staat.

7. Hoe implementeren we DI in het Spring Framework?

We kunnen zowel op Spring XML-gebaseerde als op Annotation-gebaseerde configuratie gebruiken om DI te implementeren in Spring-toepassingen. Voor een beter begrip, lees alstublieft het voorbeeld van Spring Dependency Injection waar je beide methoden kunt leren met JUnit-testcase. De post bevat ook een voorbeeldproject-zipbestand dat je kunt downloaden en gebruiken om meer te leren.

8. Wat zijn de voordelen van het gebruik van Spring Tool Suite?

We kunnen plugins installeren in Eclipse om alle functies van Spring Tool Suite te krijgen. Echter, STS wordt geleverd met Eclipse met enkele andere belangrijke zaken zoals Maven ondersteuning, Templates voor het maken van verschillende soorten Spring projecten, en tc server voor betere prestaties met Spring applicaties.

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. Noem enkele van de belangrijke Spring-modules?

Enkele van de belangrijke Spring Framework-modules zijn:

  • Spring Context – voor dependency injection.
  • Spring AOP – voor aspectgeoriënteerd programmeren.
  • Spring DAO – voor databasebewerkingen met behulp van het DAO-patroon
  • Spring JDBC – voor JDBC en DataSource-ondersteuning.
  • Spring ORM – voor ORM-tools zoals Hibernate
  • Spring Web Module – voor het maken van webapplicaties.
  • Spring MVC – Model-View-Controller implementatie voor het maken van webapplicaties, webservices, enz.

10. Wat verstaat u onder Aspect-Oriented Programming?

Enterprise-applicaties hebben enkele gemeenschappelijke concerns die van toepassing zijn op verschillende soorten objecten en applicatiemodules, zoals logging, transactiebeheer, gegevensvalidatie, authenticatie, enz. De modulariteit van de applicatie wordt bereikt door klassen in objectgeoriënteerd programmeren. In AOP wordt de modulariteit van de applicatie bereikt door Aspects en worden ze geconfigureerd om verschillende methoden van klassen te doorsnijden.

AOP haalt de directe afhankelijkheid van concerns die over klassen heen gaat weg, wat niet mogelijk is in normaal objectgeoriënteerd programmeren. Bijvoorbeeld, we kunnen een aparte klasse hebben voor logging, maar de andere klassen moeten deze methoden aanroepen. Maar in AOP configureren we de aspects en de methodenuitvoering gebeurt automatisch. Lees meer over Spring AOP-ondersteuning op Spring AOP-voorbeeld.

11. Wat is een Aspect, Advies, Pointcut, JointPoint en Adviesargumenten in AOP?

Aspect: Aspect is een klasse die dwarsdoorsnijdende zorgen implementeert, zoals transactiebeheer. Aspecten kunnen een normale klasse zijn die geconfigureerd wordt en vervolgens geconfigureerd wordt in het Spring Bean-configuratiebestand, of we kunnen Spring AspectJ-ondersteuning gebruiken om een klasse als een Aspect te verklaren met behulp van de @Aspect-annotatie.

Advies: Advies is de actie die wordt ondernomen voor een bepaald verbindingspunt. In termen van programmeren zijn het methoden die worden uitgevoerd wanneer een specifiek verbindingspunt met een overeenkomende pointcut wordt bereikt in de toepassing. U kunt Advies beschouwen als Spring-interceptors of Servlet-filters.

Pointcut: Pointcuts zijn reguliere expressies die overeenkomen met verbindingspunten om te bepalen of advies al dan niet moet worden uitgevoerd. Pointcut gebruikt verschillende soorten expressies die overeenkomen met de verbindingspunten. Het Spring-framework gebruikt de AspectJ pointcut-uitdrukkingstaal om de verbindingspunten te bepalen waar adviesmethoden zullen worden toegepast.

JoinPoint: Een verbindingspunt is een specifiek punt in de toepassing, zoals methoduitvoering, uitzonderingsafhandeling, wijzigen van objectvariabele waarden, enz. In Spring AOP is een verbindingspunt altijd de uitvoering van een methode.

Adviesargumenten: We kunnen argumenten doorgeven in de adviesmethoden. We kunnen de args() expressie gebruiken in het pointcut om toe te passen op elke methode die overeenkomt met het argumentpatroon. Als we dit gebruiken, moeten we dezelfde naam gebruiken in de adviesmethode van waaruit het argumenttype wordt bepaald.

Deze concepten lijken in eerste instantie verwarrend, maar als je door Spring Aspect, Adviesvoorbeeld gaat, kun je er gemakkelijk een relatie mee leggen.

12. Wat is het verschil tussen Spring AOP en AspectJ AOP?

AspectJ is de industriestandaard implementatie voor Aspect-Oriented Programming, terwijl Spring AOP AOP implementeert voor sommige gevallen. De belangrijkste verschillen tussen Spring AOP en AspectJ zijn:

  • Spring AOP is eenvoudiger te gebruiken dan AspectJ omdat we ons geen zorgen hoeven te maken over het weefproces.
  • Spring AOP ondersteunt AspectJ-annotaties, dus als je bekend bent met AspectJ, is werken met Spring AOP eenvoudiger.
  • Spring AOP ondersteunt alleen op proxy gebaseerde AOP, dus het kan alleen worden toegepast op method uitvoeringsaansluitingen. AspectJ ondersteunt alle soorten pointcuts.
  • Een van de tekortkomingen van Spring AOP is dat het alleen kan worden toegepast op de beans die zijn gemaakt via de Spring Context.

13. Wat is de Spring IoC-container?

Inversion of Control (IoC) is het mechanisme om losse koppeling tussen objectafhankelijkheden te bereiken. Om losse koppeling en dynamische binding van objecten op runtime te bereiken, definiëren de objecten hun afhankelijkheden die worden geïnjecteerd door andere assemblerende objecten. De Spring IoC-container is het programma dat afhankelijkheden injecteert in een object en het gereed maakt voor ons gebruik.

De klassen van de Spring Framework IoC-container maken deel uit van de pakketten org.springframework.beans en org.springframework.context en bieden ons verschillende manieren om de afhankelijkheden van objecten te ontkoppelen.

Enkele nuttige implementaties van ApplicationContext die we gebruiken zijn;

  • AnnotationConfigApplicationContext: Voor op zichzelf staande Java-toepassingen met op annotaties gebaseerde configuratie.
  • ClassPathXmlApplicationContext: Voor op zichzelf staande Java-toepassingen met op XML gebaseerde configuratie.
  • FileSystemXmlApplicationContext: Vergelijkbaar met ClassPathXmlApplicationContext, behalve dat het XML-configuratiebestand vanaf elke locatie in het bestandssysteem kan worden geladen.
  • AnnotationConfigWebApplicationContext en XmlWebApplicationContext voor webtoepassingen.

14. Wat is een Spring Bean?

Elke normale Java-klasse die geïnitialiseerd wordt door de Spring IoC-container wordt een Spring Bean genoemd. We gebruiken de Spring ApplicationContext om de instantie van de Spring Bean te verkrijgen.

De Spring IoC-container beheert de levenscyclus van Spring Bean, de bean-scopes en injecteert eventuele benodigde afhankelijkheden in de bean.

15. Wat is het belang van het Spring bean-configuratiebestand?

We gebruiken het Spring Bean-configuratiebestand om alle beans te definiëren die door de Spring-context worden geïnitialiseerd. Wanneer we de instantie van de Spring ApplicationContext maken, leest deze het Spring bean XML-bestand en initialiseert alle beans. Zodra de context is geïnitialiseerd, kunnen we deze gebruiken om verschillende bean-instanties te verkrijgen.

Naast de Spring Bean-configuratie bevat dit bestand ook Spring MVC-interceptors, view resolvers en andere elementen om annotatiegebaseerde configuraties te ondersteunen.

16. Wat zijn de verschillende manieren om een klasse te configureren als Spring Bean?

Er zijn drie verschillende manieren om een Spring Bean te configureren.

XML-configuratie: Dit is de meest gebruikte configuratiemethode en we kunnen het bean-element in het contextbestand gebruiken om een Spring Bean te configureren. Bijvoorbeeld:

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

Java-gebaseerde configuratie: Als je alleen annotaties gebruikt, kun je een Spring Bean configureren met de @Bean-annotatie. Deze annotatie wordt gebruikt met klassen gemarkeerd met @Configuration om een Spring Bean te configureren. Een voorbeeldconfiguratie is:

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

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

Om deze bean uit de Spring-context te halen, moeten we de volgende code gebruiken:

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

Configuratie op basis van annotaties: We kunnen ook @Component, @Service, @Repository en @Controller annotaties gebruiken met klassen om ze te configureren als Spring Bean. Hiervoor moeten we de basispakketlocatie opgeven om deze klassen te scannen. Bijvoorbeeld:

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

17. Wat zijn de verschillende scopes van Spring Bean?

Er zijn vijf scopes gedefinieerd voor Spring Beans.

  1. singleton: Er wordt slechts één exemplaar van de bean aangemaakt voor elke container. Dit is de standaardscope voor de Spring Beans. Bij het gebruik van deze scope, zorg ervoor dat de Spring Bean geen gedeelde instantievariabelen heeft, anders kan dit leiden tot inconsistentieproblemen omdat het niet thread-safe is.
  2. prototype: Telkens wanneer de bean wordt aangevraagd, wordt een nieuwe instantie aangemaakt.
  3. request: Dit is hetzelfde als de prototype-scope, maar het is bedoeld voor gebruik in webapplicaties. Er wordt een nieuwe instantie van de bean aangemaakt voor elke HTTP-aanvraag.
  4. session: Voor elke HTTP-sessie wordt een nieuwe bean aangemaakt door de container.
  5. global-session: Dit wordt gebruikt om wereldwijde sessiebeans te creëren voor Portlet-toepassingen.

Het Spring Framework is uitbreidbaar, en we kunnen ook onze eigen scopes maken. Maar meestal voldoen de standaardscopes van het framework. Om Spring Bean-scopes in te stellen, kunnen we het “scope”-attribuut in het bean-element gebruiken of de @Scope-annotatie voor op annotaties gebaseerde configuraties.

18. Wat is de levenscyclus van de Spring Bean?

Spring Beans worden geïnitialiseerd door de Spring Container en alle afhankelijkheden worden ook geïnjecteerd. Wanneer de context wordt vernietigd, worden ook alle geïnitialiseerde beans vernietigd. Dit werkt goed in de meeste gevallen, maar soms willen we andere resources initialiseren of enkele validaties uitvoeren voordat onze beans klaar zijn voor gebruik. Het Spring-framework biedt ondersteuning voor post-initialisatie- en pre-vernietigingsmethoden in Spring Beans.

We kunnen dit op twee manieren doen: door de interfaces InitializingBean en DisposableBean te implementeren, of door gebruik te maken van de attributen init-method en destroy-method in de configuratie van Spring Beans. Voor meer details, lees Methoden voor de levenscyclus van Spring Bean.

19. Hoe verkrijg je het ServletContext- en ServletConfig-object in een Spring Bean?

Er zijn twee manieren om container-specifieke objecten te verkrijgen in de Spring Bean.

  • Implementeren van Spring *Aware-interfaces, zoals de ServletContextAware- en ServletConfigAware-interfaces. Voor een volledig voorbeeld van deze aware-interfaces, lees alstublieft Spring Aware Interfaces.
  • Gebruik @Autowired-annotatie met een bean-variabele van het type ServletContext en ServletConfig. Ze werken alleen in omgevingen die specifiek zijn voor een servletcontainer.
@Autowired
ServletContext servletContext;

20. Wat is Bean-wiring en @Autowired-annotatie?

Het proces van het injecteren van Spring bean-afhankelijkheden tijdens de initialisatie wordt Spring Bean Wiring genoemd.

Meestal is het een goede praktijk om expliciete bedrading van alle bean-afhankelijkheden te doen, maar het Spring-framework ondersteunt ook automatische bedrading. We kunnen de @Autowired-annotatie gebruiken met velden of methoden voor autowiring byType. Voor deze annotatie om te werken, moeten we ook annotatiegebaseerde configuratie inschakelen in het Spring bean-configuratiebestand. Dit kan worden gedaan met het context:annotation-config-element.

Voor meer details over de @Autowired-annotatie, lees alstublieft Spring Autowire Example.

21. Wat zijn de verschillende soorten Spring Bean autowiring?

Er zijn vier soorten autowiring in het Spring-framework.

  1. autowire op naam
  2. autowire op type
  3. autowire via constructor
  4. Autowiring met behulp van @Autowired en @Qualifier annotaties

Vóór Spring 3.1 werd ook autowire door autodetecteren ondersteund, wat vergelijkbaar was met autowire via constructor of via type. Voor meer informatie over deze opties, lees alstublieft Spring Bean Autowiring.

22. Biedt Spring Bean threadveiligheid?

De standaardscope van een Spring-bean is singleton, dus er zal slechts één instantie per context zijn. Dat betekent dat alle klassenvariabelen die door een willekeurige thread kunnen worden bijgewerkt, leiden tot inconsistente gegevens. Daarom zijn spring beans in de standaardmodus niet thread-safe.

Echter kunnen we de reikwijdte van de spring bean wijzigen naar request, prototype of session om thread-veiligheid te bereiken ten koste van prestaties. Het is een ontwerpbeslissing gebaseerd op de projectvereisten.

23. Wat is een Controller in Spring MVC?

Net als het MVC-ontwerppatroon is de Controller de klasse die verantwoordelijk is voor alle clientverzoeken en stuurt ze door naar de geconfigureerde resources om ze te verwerken. In Spring MVC is DispatcherServlet de front-controllerklasse die de context initialiseert op basis van de configuraties van de spring beans.

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. Wat is het verschil tussen @Component, @Controller, @Repository & @Service annotaties in Spring?

@Component wordt gebruikt om aan te geven dat een klasse een component is. Deze klassen worden gebruikt voor automatische detectie en geconfigureerd als een bean wanneer op annotaties gebaseerde configuraties worden gebruikt.

@Controller is een specifiek type component dat wordt gebruikt in MVC-toepassingen en meestal wordt gebruikt met de RequestMapping-annotatie.

@Repository annotatie wordt gebruikt om aan te geven dat een component wordt gebruikt als een repository en een mechanisme om gegevens op te slaan/op te halen/te doorzoeken. We kunnen deze annotatie toepassen op implementatieklassen van het DAO-patroon.

@Service wordt gebruikt om aan te geven dat een klasse een Service is. Gewoonlijk worden de bedrijfsfacadeklassen die bepaalde services bieden, met deze annotatie gemarkeerd.

We kunnen een van de bovenstaande annotaties gebruiken voor een klasse voor automatische detectie, maar verschillende typen worden geleverd zodat u gemakkelijk het doel van de geannoteerde klassen kunt onderscheiden.

25. Wat is DispatcherServlet en ContextLoaderListener?

DispatcherServlet is de frontcontroller in de Spring MVC-toepassing en het laadt het voorjaarsbonenconfiguratiebestand en initialiseert alle geconfigureerde bonen. Als annotaties zijn ingeschakeld, scant het ook de pakketten en configureert het elke bean die is geannoteerd met `@Component`, `@Controller`, `@Repository` of `@Service` annotaties.

ContextLoaderListener is de luisteraar om de root WebApplicationContext van Spring op te starten en af te sluiten. Zijn belangrijke functies zijn om de levenscyclus van ApplicationContext te koppelen aan de levenscyclus van de ServletContext en om de creatie van ApplicationContext te automatiseren. We kunnen het gebruiken om gedeelde bonen te definiëren die kunnen worden gebruikt in verschillende spring-contexten.

26. Wat is ViewResolver in Spring?

ViewResolver-implementaties worden gebruikt om de weergavepagina’s op naam op te lossen. We configureren het in het voorjaarsbonenconfiguratiebestand. Bijvoorbeeld:

<!-- Lost views op die zijn geselecteerd voor weergave door @Controllers naar .jsp-resources in de /WEB-INF/views-directory -->
<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 is een van de implementaties van het ViewResolver-interface en we geven de map met view-pagina’s en de suffix-locatie op via de bean-eigenschappen. Dus als een controller-handlermethode “home” retourneert, zal de viewresolver de viewpagina gebruiken die zich bevindt op /WEB-INF/views/home.jsp.

27. Wat is een MultipartResolver en wanneer wordt het gebruikt?

MultipartResolver-interface wordt gebruikt voor het uploaden van bestanden – CommonsMultipartResolver en StandardServletMultipartResolver zijn twee implementaties die door het Spring-framework worden geleverd voor het uploaden van bestanden. Standaard zijn er geen multipart resolvers geconfigureerd, maar om ze te gebruiken voor het uploaden van bestanden, hoeven we alleen maar een bean met de naam “multipartResolver” te definiëren met het type MultipartResolver in de Spring-beanconfiguraties.

Eenmaal geconfigureerd, zal elke multipart-request worden opgelost door de geconfigureerde MultipartResolver en doorgegeven aan een ingepakte HttpServletRequest. Vervolgens wordt het gebruikt in de controllerklasse om het bestand te krijgen en te verwerken. Voor een volledig voorbeeld, lees alstublieft Voorbeeld van bestandsupload in Spring MVC.

28. Hoe om te gaan met uitzonderingen in het Spring MVC Framework?

Het Spring MVC Framework biedt de volgende manieren om robuuste uitzonderingsafhandeling te realiseren.

Controller-Based – We kunnen uitzonderingsafhandelingsmethoden definiëren in onze controllerklassen. Het enige wat we hoeven te doen, is deze methoden annoteren met @ExceptionHandler-annotatie.

Global Exception Handler – Uitzonderingsafhandeling is een cross-cutting concern en Spring biedt de @ControllerAdvice-annotatie die we kunnen gebruiken met elke klasse om onze wereldwijde uitzonderingsafhandelaar te definiëren.

HandlerExceptionResolver-implementatie – Voor generieke uitzonderingen serveren we meestal statische pagina’s. Het Spring Framework biedt een HandlerExceptionResolver-interface die we kunnen implementeren om een wereldwijde uitzonderingsafhandelaar te maken. De reden achter deze aanvullende manier om de wereldwijde uitzonderingsafhandelaar te definiëren, is dat het Spring-framework ook standaard implementatieklassen biedt die we kunnen definiëren in ons Spring bean-configuratiebestand om de voordelen van uitzonderingsafhandeling in het Spring-framework te verkrijgen.

Voor een volledig voorbeeld, lees alstublieft Spring Exception Handling Example.

29. Hoe maak je ApplicationContext aan in een Java-programma?

Er zijn verschillende manieren om een Spring-context aan te maken in een op zichzelf staand Java-programma.

  1. AnnotationConfigApplicationContext: Als we Spring gebruiken in op zichzelf staande Java-toepassingen en annotaties gebruiken voor configuratie, kunnen we dit gebruiken om de container te initialiseren en de bean-objecten te verkrijgen.
  2. ClassPathXmlApplicationContext: Als we een Spring bean-configuratie XML-bestand hebben in een op zichzelf staande toepassing, kunnen we deze klasse gebruiken om het bestand te laden en het containerobject te verkrijgen.
  3. FileSystemXmlApplicationContext: Dit is vergelijkbaar met ClassPathXmlApplicationContext, behalve dat het XML-configuratiebestand vanaf elke locatie in het bestandssysteem kan worden geladen.

30. Kunnen we meerdere Spring-configuratiebestanden hebben?

Voor Spring MVC-toepassingen kunnen we meerdere spring context configuratiebestanden definiëren via contextConfigLocation. Deze locatiestring kan bestaan uit meerdere locaties gescheiden door een willekeurig aantal komma’s en spaties. Bijvoorbeeld;

<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>

We kunnen ook meerdere root-level spring-configuraties definiëren en deze laden via context-param. Bijvoorbeeld;

<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>

Een andere optie is om het importelement te gebruiken in het contextconfiguratiebestand om andere configuraties te importeren, bijvoorbeeld:

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

31. Wat is ContextLoaderListener?

ContextLoaderListener is de luisterklasse die wordt gebruikt om de rootcontext te laden en spring bean-configuraties te definiëren die zichtbaar zullen zijn voor alle andere contexten. Het wordt geconfigureerd in het web.xml-bestand als:

<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. Wat zijn de minimale configuraties die nodig zijn om een Spring MVC-toepassing te maken?

Om een eenvoudige Spring MVC-toepassing te maken, zouden we de volgende taken moeten uitvoeren.

  • Voeg de afhankelijkheden spring-context en spring-webmvc toe aan het project.
  • Configureer DispatcherServlet in het web.xml-bestand om verzoeken via de spring-container te verwerken.
  • Spring bean-configuratiebestand om beans te definiëren, als je annotaties gebruikt, moeten ze hier geconfigureerd worden. Ook moeten we de viewresolver configureren voor viewpagina’s.
  • Controllerklasse met request mappings gedefinieerd om de clientverzoeken te behandelen.

Bovenstaande stappen zouden voldoende moeten zijn om een eenvoudige Spring MVC Hello World-toepassing te maken.

33. Hoe zou je Spring MVC Framework relateren aan MVC-architectuur?

Zoals de naam al aangeeft, is Spring MVC gebouwd op basis van de Model-View-Controller-architectuur. DispatcherServlet is de Front Controller in de Spring MVC-toepassing die zorgt voor alle inkomende verzoeken en ze doorstuurt naar verschillende controller-handelingsmethoden.

Het model kan elk Java Bean zijn in het Spring Framework, net als elk ander MVC-framework biedt Spring automatische binding van formuliergegevens aan Java Beans. We kunnen model beans instellen als attributen die worden gebruikt in de viewpagina’s.

Viewpagina’s kunnen JSP, statisch HTML, enz. zijn en viewresolvers zijn verantwoordelijk voor het vinden van de juiste viewpagina. Zodra de viewpagina is geïdentificeerd, wordt de controle teruggegeven aan de DispatcherServlet-controller. DispatcherServlet is verantwoordelijk voor het renderen van de view en het teruggeven van de uiteindelijke respons aan de client.

34. Hoe lokale vertaling te bereiken in Spring MVC-toepassingen?

Spring biedt uitstekende ondersteuning voor lokalisatie of i18n via resource-bundels. Basisstappen die nodig zijn om onze toepassing te lokaliseren zijn:

  • Het maken van berichtresource-bundels voor verschillende talen, zoals messages_en.properties, messages_fr.properties, enz.
  • Het definiëren van het messageSource-bean in het voorjaarsbean-configuratiebestand van het type ResourceBundleMessageSource of ReloadableResourceBundleMessageSource.
  • Voor ondersteuning van wijziging van taal, definieer het localeResolver-bean van het type CookieLocaleResolver en configureer de LocaleChangeInterceptor-interceptor. Een voorbeeldconfiguratie wordt hieronder getoond:
<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>
  • Gebruik het spring:message-element in de weergavepagina’s met sleutelnamen. DispatcherServlet haalt de overeenkomstige waarde op en rendert de pagina in de overeenkomstige taal en geeft deze terug als respons.

Voor een volledig voorbeeld, lees Voorbeeld van Spring Lokalisatie.

35. Hoe kunnen we Spring gebruiken om een Restful Web Service te maken die een JSON-response retourneert?

We kunnen Spring Framework gebruiken om Restful webservices te maken die JSON-gegevens retourneren. Spring biedt integratie met de Jackson JSON API die we kunnen gebruiken om JSON-responses te verzenden in een restful webservice.

We moeten de volgende stappen uitvoeren om onze Spring MVC-toepassing te configureren voor het verzenden van JSON-response.

1. Voeg Jackson JSON-afhankelijkheden toe. Als je Maven gebruikt, kan dit worden gedaan met de volgende code:

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

2. Configureer de RequestMappingHandlerAdapter bean in het voorjaarsbestand voor configuratie van bonen en stel de message converters eigenschap in op MappingJackson2HttpMessageConverter bean. Een voorbeeldconfiguratie zou zijn:

<!-- Configureer om JSON in te schakelen als verzoek en respons in methodehandler -->
<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>
     
<!-- Configureer bean om JSON naar POJO en vice versa te converteren -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>

3. In de controller-handlermethoden retourneer het Object als respons met de annotatie @ResponseBody. Voorbeeldcode:

@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. Je kunt de REST-service aanroepen via elke API, maar als je Spring wilt gebruiken, kun je dit eenvoudig doen met de klasse RestTemplate.

Voor een volledig voorbeeld, lees alstublieft Spring Restful Webservice Example.

36. Welke van de belangrijke Spring-annotaties heb je gebruikt?

Sommige van de Spring-annotaties die ik in mijn project heb gebruikt, zijn:

37. Kan een Object als het antwoord van de Controller-handlermethode worden verzonden?

Ja, dat kunnen we doen met de @ResponseBody-annotatie. Zo sturen we JSON- of XML-gebaseerde antwoorden in RESTful webdiensten.

38. Hoe bestanden uploaden in de Spring MVC-toepassing?

Spring biedt ingebouwde ondersteuning voor het uploaden van bestanden via de MultipartResolver-interface-implementaties. Het is zeer eenvoudig te gebruiken en vereist alleen configuratiewijzigingen om het te laten werken. We moeten een controller-handlermethode schrijven om het inkomende bestand te verwerken. Voor een volledig voorbeeld, zie Spring File Upload Example.

39. Hoe valideer je formuliergegevens in het Spring Web MVC-framework?

Spring ondersteunt door JSR-303 op annotaties gebaseerde validaties en biedt ook een Validator-interface die we kunnen implementeren om onze eigen aangepaste validator te maken. Voor het gebruik van op JSR-303 gebaseerde validatie moeten we bean-variabelen annoteren met de vereiste validaties.

Voor de implementatie van aangepaste validatoren moeten we deze configureren in de controllerklasse. Voor een volledig voorbeeld, lees Spring MVC Form Validation Example.

40. Wat is een Spring MVC Interceptor en hoe gebruik je het?

Spring MVC Interceptors zijn vergelijkbaar met Servlet Filters en stellen ons in staat om clientverzoeken te onderscheppen en te verwerken. We kunnen clientverzoeken onderscheppen op drie plaatsen – preHandle, postHandle en afterCompletion.

We kunnen een Spring-interceptor maken door de interface HandlerInterceptor te implementeren of door de abstracte klasse HandlerInterceptorAdapter uit te breiden.

We moeten interceptors configureren in het configuratiebestand van de spring bean. We kunnen een interceptor definiëren om alle clientverzoeken te onderscheppen, of we kunnen het configureren voor specifieke URI-mapping ook. Voor een gedetailleerd voorbeeld, zie Spring MVC Interceptor Example.

41. Wat is de Spring JdbcTemplate-klasse en hoe gebruik je die?

Het Spring Framework biedt uitstekende integratie met de JDBC API en biedt de JdbcTemplate-hulpprogrammaklasse die we kunnen gebruiken om boilerplate-code te vermijden bij onze databasebewerkingen, zoals het openen/sluiten van de verbinding, ResultSet, PreparedStatement, enz.

Voor een voorbeeld van JdbcTemplate, zie Spring JDBC Example.

42. Hoe gebruik je Tomcat JNDI DataSource in een Spring-webtoepassing?

Voor het gebruik van een servletcontainer geconfigureerde JNDI DataSource moeten we deze configureren in het Spring bean-configuratiebestand en deze vervolgens injecteren in Spring beans als afhankelijkheden. Vervolgens kunnen we het gebruiken met \code{JdbcTemplate} om databasebewerkingen uit te voeren.

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

Voor een volledig voorbeeld, zie Voorbeeld van Spring Tomcat JNDI.

43. Hoe bereik je Transactiebeheer in Spring?

Het Spring-framework biedt ondersteuning voor transactiebeheer via declaratief transactiebeheer en programmatisch transactiebeheer. Declaratief transactiebeheer wordt het meest gebruikt omdat het eenvoudig is en in de meeste gevallen werkt.

We gebruiken een methode annoteren met \code{@Transactional} annotatie voor declaratief transactiebeheer. We moeten de transactiemanager configureren voor de DataSource in het Spring bean-configuratiebestand.

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

44. Wat is Spring DAO?

Spring DAO-ondersteuning wordt geleverd om te werken met gegevenstoegangstechnologieën zoals JDBC, Hibernate op een consistente en eenvoudige manier. Bijvoorbeeld, we hebben JdbcDaoSupport, HibernateDaoSupport, JdoDaoSupport en JpaDaoSupport voor respectievelijke technologieën.

Spring DAO biedt ook consistentie in de hiërarchie van uitzonderingen en we hoeven geen specifieke uitzonderingen op te vangen.

45. Hoe Spring en Hibernate Frameworks integreren?

We kunnen de Spring ORM-module gebruiken om Spring en Hibernate frameworks te integreren als je Hibernate 3+ gebruikt waar SessionFactory de huidige sessie biedt, dan moet je vermijden om HibernateTemplate of HibernateDaoSupport-klassen te gebruiken en beter DAO-patroon met dependency injection te gebruiken voor de integratie.

Spring ORM biedt ondersteuning voor het gebruik van Spring declaratief transactiebeheer, dus je moet dat gebruiken in plaats van te gaan voor Hibernate boilerplate-code voor transactiebeheer.

Voor een beter begrip moet je de volgende tutorials doornemen:

46. Wat is Spring Security?

Het Spring Security-framework richt zich op het bieden van zowel authenticatie als autorisatie in Java-toepassingen. Het behandelt ook de meeste veelvoorkomende beveiligingsproblemen, zoals CSRF-aanvallen.

Het is zeer nuttig en eenvoudig om Spring Security te gebruiken in webtoepassingen, door middel van het gebruik van annotaties zoals @EnableWebSecurity. U zou de volgende berichten moeten doornemen om te leren hoe u het Spring Security-framework moet gebruiken.

47. Hoe injecteer je een java.util.Properties in een Spring Bean?

We moeten de propertyConfigurer-bean definiëren die de eigenschappen uit het opgegeven eigenschappenbestand zal laden. Vervolgens kunnen we Spring EL-ondersteuning gebruiken om eigenschappen in andere bean-afhankelijkheden te injecteren. Bijvoorbeeld:

<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>

Als u annotaties gebruikt om de Spring bean te configureren, kunt u eigenschappen injecteren zoals hieronder.

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

48. Noem enkele van de ontwerppatronen die worden gebruikt in het Spring Framework?

Het Spring Framework maakt gebruik van veel ontwerppatronen, enkele van de gebruikelijke zijn:

  1. Singleton-patroon: Beans maken met standaardscope.
  2. Factory-patroon: Bean Factory-klassen
  3. Prototype-patroon: Bean-scopes
  4. Adapter-patroon: Spring Web en Spring MVC
  5. Proxy-patroon: Ondersteuning voor Spring Aspect Oriented Programming
  6. Template Method-patroon: JdbcTemplate, HibernateTemplate, enz.
  7. Front Controller: Spring MVC DispatcherServlet
  8. – Gegevenstoegangsobject: Spring DAO-ondersteuning
  9. Dependency Injection en Aspect-Oriented Programming

49. Wat zijn enkele van de beste praktijken voor het Spring Framework?

Enkele van de beste praktijken voor het Spring Framework zijn:

  • Vermijd versienummers in schemareferenties, zodat we altijd de nieuwste configuraties hebben.
  • Verdeel Spring-beanconfiguraties op basis van hun functies, zoals spring-jdbc.xml, spring-security.xml.
  • Voor Spring-beans die in meerdere contexten in Spring MVC worden gebruikt, maak ze in de rootcontext en initialiseer ze met de luisteraar.
  • Configureer bean-afhankelijkheden zoveel mogelijk, probeer bedraden zoveel mogelijk te vermijden.
  • Voor toepassingsniveau-eigenschappen is de beste aanpak het maken van een eigenschappenbestand en het lezen ervan in het Spring-beanconfiguratiebestand.
  • Voor kleinere toepassingen zijn annotaties handig, maar voor grotere toepassingen kunnen annotaties een last worden. Als we alle configuratie in XML-bestanden hebben, zal het onderhouden ervan gemakkelijker zijn.
  • @Service en voor DAO-beans gebruik @Repository.
  • Het Spring-framework heeft veel modules, gebruik wat je nodig hebt. Verwijder alle extra afhankelijkheden die meestal worden toegevoegd wanneer je projecten maakt via Spring Tool Suite-templates.
  • Als je Aspecten gebruikt, zorg er dan voor dat het join point zo nauw mogelijk is om advies over ongewenste methoden te vermijden. Overweeg aangepaste annotaties die eenvoudiger te gebruiken zijn en eventuele problemen vermijden.
  • Gebruik dependency injection alleen als er daadwerkelijk voordeel is, gebruik het niet alleen vanwege losse koppeling, maar omdat het moeilijker te onderhouden is.

50. Wat is Spring Boot?

Spring Boot maakt het spring-framework uniek. Het biedt ons een eenvoudige manier om verschillende soorten Java-toepassingen te maken en deze te koppelen aan de runtime-omgeving van de servletcontainer. Op deze manier krijgen we een enkel JAR-bestand dat we kunnen uitvoeren om het project te starten. Dit bespaart ons veel tijd bij het verkrijgen van het skeletproject dat snel gereed is voor implementatie. Op deze manier kunnen we ons meer richten op de bedrijfslogica in plaats van het doorlopen van het gebruikelijke proces van het bouwen van de code en het implementeren ervan op een servletcontainer. Aangezien het een zeer uitgebreid onderwerp is, zou ik aanraden om door Spring Boot Interviewvragen te gaan.

Dat is alles voor de vragen over het Spring Framework. Ik hoop dat deze vragen je zullen helpen bij je Java EE-interview. Ik zal blijven doorgaan met het toevoegen van meer vragen aan de lijst zodra ik ze vind. Als je meer vragen weet die deel moeten uitmaken van de lijst, voeg dan een opmerking toe en ik zal ze opnemen.

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