22 Frequently Asked Spring Boot Intervjufrågor och svar

Innehållsförteckning

Förbered dig för din Java Spring Boot-intervju

Är du en Java Spring Boot-utvecklare som snart ska på intervju och känner dig osäker på vilka frågor som kan dyka upp? Oroa dig inte, vi är här för att hjälpa dig! Denna artikel ger dig en gedigen förberedelse genom att gå igenom vanliga frågor och svar som ofta används under Spring Boot-intervjuer.

Intervjuare använder specifika Spring Boot-frågor för att bedöma kandidaternas kunskapsnivå, vilken är avgörande för den aktuella rollen. Därför är det viktigt att du är väl förberedd med relevanta frågor och vet hur du ska svara på dem.

Innan vi dyker in i intervjufrågorna, låt oss kortfattat definiera vad Spring Boot är och hur det underlättar arbetet för Java-utvecklare.

Vad är Java Spring Boot?

Detta Java-ramverk lanserades 2014 av Spring-teamet. Spring Boot är ett ramverk med öppen källkod som underlättar utvecklingen av fristående, produktionsklara applikationer som kan köras på en Java Virtual Machine (JVM).

Java-utvecklare föredrar detta ramverk för att utveckla webbapplikationer och mikrotjänster på grund av den snabba installationen, enkla konfigurationen och inbyggda säkerhetsfunktioner.

Spring Boots enkla installations- och konfigurationsprocess bygger på tre kärnfunktioner:

Autokonfiguration – Automatisk konfiguration av Spring-applikationen.
Egenmäktig inställning av konfigurationsstandarder och paket för nödvändiga beroenden, vilket snabbar upp projektstarten.
Möjligheten att köra applikationer fristående utan behov av en separat webbserver.

Hur hjälper Spring Boot Java-utvecklare?

Spring Boot förenklar utvecklingen av produktionsklara Spring-applikationer genom automatisk konfiguration av nödvändiga komponenter. Detta leder till kortare utvecklingstid och ökad effektivitet.

Spring Boot integreras sömlöst med Spring-ekosystemet, inklusive Spring JDBC, Spring Data, Spring Security och Spring ORM.

Java-utvecklare kan även ansluta Spring Boot till olika databaser som Oracle, MySQL, PostgreSQL och MongoDB.

Flexibla konfigurationer med XML, Java Beans och databastransaktioner är andra värdefulla funktioner.

Nu när du har en grundläggande förståelse för Spring Boot, låt oss gå igenom några vanliga intervjufrågor och svar för att hjälpa dig förbereda dig inför din intervju.

Spring Boot Intervjufrågor och Svar

Vilka är några funktioner i Spring Boot?

Här är några populära funktioner:

Spring Boot CLI ger dig möjligheten att använda Groovy för att skriva applikationer och därmed undvika onödig kod.
Loggnings- och säkerhetsfunktioner skyddar applikationen mot potentiella hot.
Automatisk konfiguration av projektets komponenter eliminerar behovet av onödiga WAR-filer.
Startinitialiseraren definierar en standardprojektstruktur, vilket minskar behovet av manuell konfigurering.
Ställdonsfunktionen ger insikter och mätvärden i realtid när applikationen körs.
Starter Dependency-funktionen förenklar beroendehantering genom att samla ihop ofta använda beroenden för en given funktion.

Vad är Spring Boot Starters?

Spring Boot Starters är beroendebeskrivningar som samlar en uppsättning beroenden som underlättar auto-beroendehantering. De förenklar och snabbar upp utvecklingsprocessen.

Vad är ett ställdon i Spring Boot, och vad är dess fördelar?

Ställdonet är en funktion i Spring Boot som möjliggör övervakning av applikationen under körning.

Under felsökning kan du använda ställdonet för att analysera loggar, CPU-användning och identifikation av bönor.

Ställdonet ger enkel tillgång till produktionsklara REST-slutpunkter för övervakning och hantering av information samt hämtning av data via webben.

Vad är Thymeleaf och hur används det?

Thymeleaf är en Java-baserad server-side mallmotor som skapar en naturlig layout för Spring- och HTML5 Java-webbapplikationer.

Spring Boot kan automatiskt konfigurera Thymeleaf med hjälp av spring-boot-starter-thymeleaf-beroendet i pom.xml-filen för att hantera dynamiskt webbinnehåll.

För att Spring Boot ska kunna läsa och rendera Thymeleaf-mallar, placeras mallarna i katalogen src/main/resources/templates.

Thymeleaf analyserar sedan index.html-filen och ersätter dynamiska värden med de faktiska värden som skickas från controller-klassen.

När Spring Boot-applikationen körs visas det renderade meddelandet i webbläsaren.

    org.springframework.boot spring-boot-starter-thymeleaf

Beskriv processen för att skapa ett Spring Boot-projekt med Spring Initializr.

Spring Initializr är ett webbaserat verktyg från Spring som låter dig skapa Spring Boot-projekt i några få steg genom att ange projektinformationen.

Besök Spring Initializr och fyll i nödvändiga fält.
Klicka på knappen ”Generera” för att starta nedladdningen av projektet.
Extrahera den nedladdade projektfilen och öppna den i din IDE. I IDE:n går du till Arkiv -> Nytt -> Projekt från befintliga källor -> Spring-boot-app, och väljer pom.xml-filen. Klicka på ”importera ändringar” för att synkronisera projektet. Redigera sedan server.port-numret i application.properties-filen till exempelvis server.port=7000.
Kör applikationen från src->main->java->com.gfg.Spring.boot.app

Vad är JPA i Spring Boot?

JPA (Java Persistence API) är en specifikation i Java som använder Object-Relational Mapping (ORM) för att hantera relationsdata och ge tillgång till data mellan Java-objekt och applikationens relationsdatabas.

JPA använder Java Persistent Query Language (JPQL), ett objektorienterat frågespråk som är plattformsoberoende.

JPA möjliggör frågehantering och objekttransaktioner mot databasen med hjälp av Entity Manager API.

Vad är automatisk konfiguration i Spring Boot?

Automatisk konfiguration syftar till att automatisera konfigurationen av Spring Boot-applikationer med hjälp av JAR-beroenden som läggs till i applikationerna.

Beroende på tillgängliga beroenden deklarerar automatisk konfiguration modulinbyggda objekt, inklusive JPA och Spring Security.

Vad är Spring-annotationer?

Spring-annotationer ger metadata om ett program och kompletterar programmets data. Kodkomponenter, inklusive klasser och metoder, associeras med annotationer.

Annotationer påverkar inte programmets funktion eller den kompilerade koden. Deras syntax börjar med symbolen ”@”.

Spring Boot har sex huvudsakliga typer av annotationer:

Spring Core Annotations
Spring Data Annotations
Spring Beans Annotations
Spring Web Annotations
Spring Scheduling Annotations
Spring Boot Annotations

Vad betyder Spring Data REST?

Spring Data REST exponerar RESTful-resurser som finns i Spring Data Resources med minimal kod.

Följande exempel visar hur POST-metoden används för att begära innehåll med URL:en http://localhost/example och Content-Type: application/json i headern.

Begär innehåll:

{
    "name": "Jimmy",
    "Gender": "Male",
    "Age": 23
}

Svarsinnehåll:

{
    "name": "Jimmy",
    "Gender": "Male",
    "Age": 23
    "_links": {
        "self": {
            "href": "http://localhost:8080/example/1"
        },
        "person": {
            "href": "http://localhost:8080/example/1"
         }
    }
}

Dessa är fördefinierade verktyg som tillämpas i utvecklingsmiljön för att förenkla utvecklingen och spara tid.

Spring Boot DevTools startar om applikationen automatiskt vid kodändringar. Detta eliminerar behovet av manuell omstart.

Vad är Spring Data?

Spring Data underlättar åtkomsten till olika datalager som relationsdatabaser, icke-relationella databaser och molnbaserade datatjänster, med bibehållen respekt för datalagrets unika egenskaper.

Hur instruerar man automatisk konfiguration att backa om en böna redan finns?

Använd annoteringen `@ConditionalOnMissingBean`, som inkluderar attributen `name` och `value`:

`value`-attributet lagrar den böntyp som ska kontrolleras.
`name`-attributet namnger den böna som ska kontrolleras.

Hur hämtar man data från databasen i Spring Boot?

Här är stegen för att komma åt data från en MySQL-databas med Spring Boot:

Steg 1: Skapa databasen i MySQL med kommandot `create DATABASE person`.

Steg 2: Skapa en tabell i databasen:

    CREATE TABLE person(id INT PRIMARY KEY NOT NULL AUTO_INCREMENT, name VARCHAR(255));

Steg 3: Skapa en Spring Boot-applikation och lägg till JDBC, MySQL och webberoenden.

Steg 4: Konfigurera databasen i application.properties-filen:

spring.datasource.url=jdbc:mysql://localhost:3306/personDetails
spring.datasource.username=example123
spring.datasource.password=example123
spring.jpa.hibernate.ddl-auto=create-drop

Steg 5: Hantera förfrågningar i controller-klassen:

package com.person;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class JdbcController {
   @Autowired
   JdbcTemplate jdbc;
   @RequestMapping("/save")
   public String index(){
      jdbc.execute("insert into person (name)values(Trial)");
      return "Name entered Successfully";
   }
}

Kör applikationen och kontrollera databasen för att se vilken data som hämtats.

Varför behövs Spring Profiles?

Spring Profiles tillåter att applikationskonfigurationer delas upp i olika delar som används i specifika utvecklingsmiljöer.

Spring Profiles besparar utvecklaren besväret med att hantera miljöspecifika externa konfigurationer. Det underlättar även synkronisering och eliminerar behovet av att skriva komplexa fabriksliknande komponenter som beror på specifika miljöparametrar.

Kan man ändra porten för den inbäddade Tomcat-servern i Spring Boot?

Ja, det går att ändra porten för den inbäddade Tomcat-servern genom att lägga till server.port-egenskapen i application.properties-filen. Spring Boot läser in filen automatiskt och tillämpar de nödvändiga konfigurationerna. Till exempel, kan server.port-numret ändras från standard 8080 till server.port = 8081.

Hur konfigurerar man Log4j för loggning?

Konfigurera Log4j med dessa steg:

Skapa ett Java-projekt och navigera till MyEclipse -> Arkiv -> Nytt -> Java-projekt. Ge projektet ett namn och klicka på ”Slutför”.
Högerklicka på projektets namn och välj ”Bygg sökväg” -> ”Konfigurera byggväg”. Lägg till log4j-filen.
Klicka på ”Lägg till externa JARs” och välj log4j-filen. Klicka på OK.
Skapa en ny java-fil, döp den till log4j.properties och lägg till filen i Classpath.
Klicka på ”Avancerat” från klasssökvägen, välj ”Lägg till mappar” och klicka på OK.
Sök efter filen log4j.properties, klicka på OK och kör projektet.
Kontrollera utskriften i konsolen.

[main] DEBUG Example – Hello this is a debug message
[main] INFO Example – Hello this is an info message

Vad är en IoC-behållare?

En IoC (Inversion of Control)-behållare är en central Spring-behållare som automatiskt hanterar beroendeinjektion. Den instansierar applikationsklasser, konfigurerar objekten och sammansätter nödvändiga beroenden.

Den hanterar även objektets livscykel, från instansiering till förstörelse. IoC använder metadatakonfiguration i form av Java-kod, XML och Java-annotationer för att utföra dessa uppgifter.

Behållaren benämns ”Inversion of Control” eftersom den styr Java-objekt och deras livscykler, en uppgift som annars ligger hos utvecklaren.

Hur skapar man en Spring Boot-applikation med Maven?

Följ dessa steg:

Steg 1: Välj projekttyp.

Steg 2: Ge projektet ett namn och konfigurera det. Klicka sedan på ”Slutför” för att skapa projektet.

Steg 3: Konfigurera pom.xml-filen för att skapa ett Spring Boot-projekt:

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>com.javatpoint</groupId>  
  <artifactId>spring-boot-example</artifactId>  
  <version>0.0.1-SNAPS</version><name>JavaTpoint Spring Boot Example</name>  
</project>

Konfigureringen innebär att lägga till en förälder till Maven-projektet. Detta deklarerar Maven-projektet som ett underprojekt:

<parent>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-parent</artifactId>  
    <version>1.4.2.RELEASE</version>  
</parent>

Steg 4: Lägg till webberoendet `spring-boot-starter-web` till pom.xml:

<dependencies>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
    </dependency>  
</dependencies>

Steg 5: Lägg till projektets Java-version:

<properties>  
    <java.version>1.8</java.version>  
</properties>

Steg 6: Kom ihåg att uppdatera Maven-projektet efter att ha lagt till nya beroenden.

Steg 7: Gör Maven-projektet körbart genom att skapa en Java-klass i `src/main/java`-mappen.

Steg 8: Anropa Spring Applications klassens statiska körningsmetod.

Steg 9: Kör sedan klassen som en Java-applikation.

Vilka är fördelarna med Spring Boot jämfört med Spring?

Spring Boots bootstrapping-funktion, som använder Boot Initializer för att kompilera källkoden, sparar diskutrymme och minskar applikationens laddningstid.
Spring Boot tillåter beroendehantering efter att spring-boot-beroenden har lagts till utan behov av en förälder POM eller XML-fil.
Spring Boot stöder användning av annotationer eller XML-konfigurationer.
Spring Boot kräver mindre standardkod för applikationskonfigurationer eftersom den har en inbyggd databas i minnet och en inbäddad Tomcat-server. Spring, å andra sidan, har mer boilerplate-kod.
Spring Boot kräver inte WAR-filer och kan enbart använda JAR-filer, som är mindre, enklare och mer praktiska för både användare och utvecklare.
Spring Boot bäddar in servrar som Tomcat och Jetty automatiskt, vilket eliminerar behovet av manuell serverkonfiguration.

Paginering delar in data i sektioner för att spara resurser. Det innefattar två fält: sidstorleken och sidnumret.

Processen innefattar följande steg:

Steg 1: Första installation.
Entiteten namnges till Person som domänklass.

@Entity 
public class Person {
    @Id
    private long id;
    private String name; 
}

Steg 2: Skapande av arkiv.
Använd ett `PersonRepository` som utökar `PagingAndSortingRepository` för att få tillgång till metoderna `findAll(Pageable pageable)` och `findAll(Sort sort)` för sökning och sortering.

public interface PersonRepository extends PagingAndSortingRepository<Person, Integer> {
    List<Product> findAllByPrice(double price, Pageable pageable);
}

Steg 3: Paginering.
Börja med att skapa ett `PageRequest`-objekt genom att skicka det efterfrågade sidnumret och sidstorleken som implementerar `Pageable`-gränssnittet.

Pageable firstPageWithTwoElements = PageRequest.of(0,2);
Pageable secondPageWithThreeElements = PageRequest.of(1,3);

Skicka `PageRequest`-objektet till repository-metoden som en parameter:

Page<Person> allProducts = personRepository.findAllByPrice(findPageWithTwoElements);
List<Items> allTwoDollarItems = itemsRepository.findAllByPrice(2, secondPageThreeElements)

Som standard returnerar metoden `findAll(Pageable pageable)` ett `Page<T>`-objekt.

Hur registrerar man en anpassad automatisk konfiguration?

Under `@EnableAutoConfiguration`-nyckeln i filen `META-INF/spring.factories`, anger du det fullständiga namnet. Detta steg registrerar automatisk konfigurationsklassen:

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

När du bygger projektet med Maven, måste du placera filen i resurskatalogen `resources/META-INF`.

Vad är bootstrapping i Spring Boot?

Bootstrapping är processen att exekvera logik i en Spring Boot-applikation vid uppstart. Boot Initializer kompilerar källspråket i Spring Boot, vilket sparar diskutrymme och minskar applikationens laddningstid.

Slutord 👨‍💻

Den här artikeln har gått igenom ett antal Spring Boot-frågor som intervjuare sannolikt kommer ställa, samt förslag på svar för att hjälpa dig känna dig säker inför intervjun. Vi hoppas att du lyckas få ditt drömjobb!

Du kan även kolla in tips från frågor som ställs under en Java-intervju.

Lycka till! 🙂