...
Pregătire interviuri

100 de întrebări de interviu Spring Boot, cu răspunsuri

Întrebările despre Spring Boot care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Spring Boot și REST API: primele 18 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 133 minde citit
Întrebări de interviu Spring Boot cu răspunsuri

La un interviu pentru un post de Java backend, Spring Boot este de obicei partea cea mai lungă a discuției tehnice. Întrebările vin în trei forme: teorie scurtă („ce face @SpringBootApplication”, „ce cod de status întorci la creare”), fragmente de cod pe care le citești și spui ce răspunde endpoint-ul sau de ce nu pornește aplicația, și exerciții practice: un controller CRUD scris live, o temă de casă cu un API mic, un bug de găsit într-un service. Subiectele recurente sunt pornirea și auto-configurarea, bean-urile și injectarea, controllerele REST, JSON-ul și DTO-urile, validarea și erorile, configurarea și profilurile, Spring Data JPA, securitatea, testele și, tot mai des, comunicarea între servicii.

La nivel de junior, intervievatorul vrea să vadă că știi să construiești corect un API: rutele, codurile de status, validarea, un repository, un test cu MockMvc, și că înțelegi mesajele de eroare de la pornire. La nivel de mid, întrebările merg spre „de ce” și „ce se întâmplă dedesubt”: proxy-uri, tranzacții, auto-configurare, formatul erorilor, strategia de testare, reziliența apelurilor între servicii. La senior apar deciziile de arhitectură, migrările de versiune și operarea în producție.

Fiecare întrebare are un răspuns scurt, bun de spus în primele secunde, și unul detaliat, cu explicația și codul pentru întrebările de continuare. Încearcă întâi să răspunzi singur, mai ales la întrebările cu cod, apoi compară. Pentru întrebările generale de Java, SQL, Git, Docker și pentru conceptele de bază Spring (injectare, tranzacții, N+1, Mockito), vezi și paginile pentru limbajul Java și pentru meseria de Java Developer.

Spring Boot: pornire, starter-e și auto-configurare

1 Junior

Ce face adnotarea @SpringBootApplication pusă pe clasa principală?

Răspuns scurt: Este o adnotare compusă din trei: @SpringBootConfiguration (clasa e o sursă de configurare), @EnableAutoConfiguration (pornește auto-configurarea) și @ComponentScan (caută bean-uri în pachetul clasei și în subpachete).

@SpringBootApplication este o scurtătură pentru trei adnotări pe care le-ai pune altfel separat:

  • @SpringBootConfiguration: o specializare a lui @Configuration; clasa poate defini metode @Bean, iar testele @SpringBootTest o găsesc automat ca punct de plecare;
  • @EnableAutoConfiguration: Spring Boot citește lista de auto-configurări din dependențele de pe classpath și le aplică pe cele ale căror condiții sunt îndeplinite (de exemplu, dacă există Tomcat și Spring MVC, pornește un server web);
  • @ComponentScan: scanează pachetul în care se află clasa și toate subpachetele după @Component, @Service, @Repository, @Controller, @Configuration.
JAVA
@SpringBootApplication
public class MagazinApplication {
    public static void main(String[] args) {
        SpringApplication.run(MagazinApplication.class, args);
    }
}

Poți personaliza fiecare parte prin atribute: @SpringBootApplication(exclude = DataSourceAutoConfiguration.class) dezactivează o auto-configurare, iar scanBasePackages schimbă pachetele scanate. În practică nu schimbi scanarea, ci pui clasa principală în pachetul rădăcină (ro.magazin), iar restul codului în subpachete (ro.magazin.produs, ro.magazin.comanda).

Consecința practică: o clasă pusă într-un pachet „frate” (ro.altceva) nu este găsită, iar aplicația pornește fără ea sau nu pornește deloc, cu mesajul că lipsește un bean.

Ce urmărește intervievatorul: Verifică dacă știi ce se întâmplă în spatele adnotării, nu doar că „trebuie pusă”. Greșeala tipică este să nu legi @ComponentScan de poziția clasei în pachete.

Eroarea, în practică:missing ServletWebServerFactory bean

2 Junior

Ce este un starter, de exemplu spring-boot-starter-web, și de ce în pom.xml nu scrii versiunile dependențelor Spring?

Răspuns scurt: Un starter este o dependență „pachet” care aduce tot ce trebuie pentru o funcționalitate (web: Spring MVC, Tomcat, Jackson, validare de bază). Versiunile vin din spring-boot-starter-parent sau din BOM-ul spring-boot-dependencies, care fixează versiuni compatibile între ele.

Înainte de Spring Boot, un proiect web cerea o listă lungă de dependențe (Spring MVC, un server, Jackson, logging), fiecare cu versiunea ei, iar combinațiile incompatibile dădeau erori greu de înțeles. Un starter rezolvă asta: e un artefact aproape gol, care doar declară dependențele potrivite.

Starter-e frecvente:

  • spring-boot-starter-web: Spring MVC, Tomcat încorporat, Jackson;
  • spring-boot-starter-validation: Hibernate Validator (Bean Validation);
  • spring-boot-starter-data-jpa: Spring Data JPA, Hibernate, pool-ul de conexiuni HikariCP;
  • spring-boot-starter-security, spring-boot-starter-actuator, spring-boot-starter-test.
XML
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.3.5</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Versiunea e scrisă o singură dată, la părinte. Acesta importă BOM-ul spring-boot-dependencies (o listă de versiuni testate împreună) și configurează plugin-urile Maven. Dacă proiectul are deja alt părinte, imporți BOM-ul în dependencyManagement cu scope import. Cu Gradle, același rol îl are plugin-ul org.springframework.boot împreună cu io.spring.dependency-management.

Poți suprascrie o versiune (de exemplu o proprietate <jackson-bom.version>), dar o faci doar cu motiv, de obicei pentru o corecție de securitate.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi gestionarea dependențelor, nu doar că ai copiat un pom.xml. Greșeala tipică este să scrii versiuni explicite pentru fiecare dependență Spring și să amesteci versiuni incompatibile.

Eroarea, în practică:Cannot resolve symbol 'SpringBootApplication'missing ServletWebServerFactory bean

3 Junior

Ce se întâmplă, pe scurt, când rulezi SpringApplication.run(MagazinApplication.class, args)?

Răspuns scurt: Spring Boot pregătește mediul (proprietăți, profiluri), creează ApplicationContext-ul, scanează și creează bean-urile, aplică auto-configurările, pornește serverul web încorporat și apoi rulează CommandLineRunner-ele. Dacă un pas eșuează, afișează APPLICATION FAILED TO START.

Pașii principali, în ordine:

  • se citește configurarea: application.properties sau .yml, variabilele de mediu, argumentele --cheie=valoare, profilul activ;
  • se creează ApplicationContext-ul potrivit (pentru o aplicație web, unul cu server servlet);
  • se încarcă definițiile de bean-uri: clasele găsite prin component scan, metodele @Bean, auto-configurările ale căror condiții sunt îndeplinite;
  • se creează bean-urile singleton în ordinea dependențelor, se injectează dependențele și se rulează metodele @PostConstruct;
  • se pornește serverul încorporat (Tomcat implicit, pe portul 8080) și se înregistrează rutele controllerelor;
  • se publică evenimentul ApplicationReadyEvent și rulează bean-urile CommandLineRunner și ApplicationRunner.
JAVA
@Bean
CommandLineRunner laPornire(ProdusRepository repo) {
    return args -> System.out.println("Produse în bază: " + repo.count());
}

În jurnal vezi liniile Tomcat started on port 8080 (http) și Started MagazinApplication in ... seconds. Dacă un bean nu poate fi creat (dependență lipsă, proprietate lipsă, port ocupat), contextul se oprește și Spring Boot afișează un raport cu secțiunile Description și Action, produs de un FailureAnalyzer.

Pentru a vedea ce auto-configurări s-au aplicat și de ce, pornești cu --debug: apare raportul de condiții (CONDITIONS EVALUATION REPORT).

Ce urmărește intervievatorul: Verifică dacă ai un model mental al pornirii, util când depanezi o aplicație care nu pornește. Greșeala tipică este să nu știi când rulează CommandLineRunner față de crearea bean-urilor.

4 Junior

Ai clasa principală în ro.magazin.app, iar controller-ul în ro.magazin.produs. Aplicația pornește, dar GET /produse dă 404. De ce?

Răspuns scurt: Component scan pornește din pachetul clasei @SpringBootApplication (ro.magazin.app) și coboară doar în subpachete. ro.magazin.produs este un pachet „frate”, deci controller-ul nu devine bean și ruta nu există. Muți clasa principală în ro.magazin.

Structura problemei:

ro.magazin.app.MagazinApplication      <- @SpringBootApplication
ro.magazin.produs.ProdusController     <- @RestController, nu e găsit

@ComponentScan fără argumente scanează pachetul clasei pe care stă și subpachetele lui: ro.magazin.app, ro.magazin.app.*. Pachetul ro.magazin.produs nu e sub ro.magazin.app, așa că ProdusController nu ajunge în context. Aplicația pornește normal, nu are nicio eroare, dar nu are nici ruta, deci orice cerere primește 404.

Reparația corectă este structura recomandată de Spring Boot: clasa principală în pachetul rădăcină, restul în subpachete.

ro.magazin.MagazinApplication
ro.magazin.produs.ProdusController
ro.magazin.produs.ProdusService
ro.magazin.comanda.ComandaController

Alternativ, @SpringBootApplication(scanBasePackages = "ro.magazin"), dar atunci trebuie să ai grijă și la @EnableJpaRepositories și @EntityScan, care pornesc tot de la pachetul clasei principale.

Dacă controller-ul ar fi avut o dependență injectată în alt bean, simptomul ar fi fost altul: aplicația nu pornește, cu mesajul required a bean of type ... that could not be found. Ambele au aceeași cauză: clasa nu a fost scanată.

Ce urmărește intervievatorul: Este un bug foarte frecvent la primele proiecte, iar intervievatorul verifică dacă legi simptomul (404 sau bean lipsă) de component scan. Greșeala tipică este să cauți problema în URL sau în adnotarea de pe metodă.

Eroarea, în practică:Field ... required a bean of type ... not foundNo static resource api/produse.

5 Junior

Cum rulezi o aplicație Spring Boot în timpul dezvoltării și cum o împachetezi pentru a o rula pe un server?

Răspuns scurt: În dezvoltare o rulezi din IDE (metoda main) sau cu ./mvnw spring-boot:run. Pentru server construiești un jar executabil cu ./mvnw clean package și îl pornești cu java -jar target/magazin-0.0.1-SNAPSHOT.jar, eventual cu profil și proprietăți din linia de comandă.

Spring Boot are un server încorporat (Tomcat implicit), deci aplicația este un program Java obișnuit, cu main. Nu mai copiezi un fișier .war într-un server instalat separat.

În dezvoltare:

BASH
./mvnw spring-boot:run
./mvnw spring-boot:run -Dspring-boot.run.profiles=dev

mvnw este Maven Wrapper: descarcă versiunea de Maven fixată în proiect, ca toată echipa să folosească aceeași. spring-boot-devtools adaugă repornire automată la modificarea claselor.

Pentru livrare:

BASH
./mvnw clean package
java -jar target/magazin-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod --server.port=9090

Plugin-ul spring-boot-maven-plugin creează un fat jar: jar-ul tău plus toate dependențele în BOOT-INF/lib și un lansator propriu. Configurarea de mediu nu stă în jar: o dai prin variabile de mediu (SPRING_DATASOURCE_URL), argumente sau fișiere externe.

Pentru containere ai două variante: un Dockerfile care copiază jar-ul într-o imagine cu JRE, sau ./mvnw spring-boot:build-image, care construiește imaginea cu Cloud Native Buildpacks, fără Dockerfile. Pentru imagini mai eficiente poți folosi straturile jar-ului (layertools), astfel încât dependențele, care se schimbă rar, să stea într-un strat separat de codul tău.

Ce urmărește intervievatorul: Verifică dacă ai dus vreodată o aplicație dincolo de IDE. Greșeala tipică este să pui parolele de producție în application.properties din jar în loc să le dai la rulare.

6 Mid

Cum funcționează auto-configurarea în Spring Boot 3? Cum afli de ce un bean a fost sau nu creat automat?

Răspuns scurt: Auto-configurările sunt clase @AutoConfiguration listate în META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports, cu condiții @ConditionalOnClass, @ConditionalOnMissingBean, @ConditionalOnProperty. Raportul de condiții, pornit cu --debug sau /actuator/conditions, arată ce s-a aplicat și de ce.

Fiecare modul Spring Boot vine cu clase de configurare obișnuite, marcate @AutoConfiguration, înregistrate într-un fișier din jar: META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports (în Boot 2 era spring.factories). @EnableAutoConfiguration le citește pe toate, dar aplică doar clasele ale căror condiții sunt adevărate:

  • @ConditionalOnClass(DataSource.class): clasa există pe classpath (ai adăugat dependența);
  • @ConditionalOnMissingBean: tu nu ai definit deja un bean de acel tip;
  • @ConditionalOnProperty("spring.jpa.open-in-view"): o proprietate are o anumită valoare;
  • @ConditionalOnWebApplication, @ConditionalOnBean, @ConditionalOnResource.

Schematic, auto-configurarea pentru ObjectMapper arată așa:

JAVA
@AutoConfiguration
@ConditionalOnClass(ObjectMapper.class)
class JacksonAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        return builder.build();
    }
}

Asta explică regula de aur: bean-ul tău câștigă. Dacă definești propriul ObjectMapper, condiția @ConditionalOnMissingBean pică și varianta automată nu se mai creează.

Când ceva nu se configurează cum te aștepți, pornești cu --debug (sau debug=true) și citești CONDITIONS EVALUATION REPORT: secțiunile Positive matches și Negative matches spun, pentru fiecare clasă, ce condiție a trecut sau a picat. În producție, același raport e disponibil la /actuator/conditions, dacă e expus.

Ce urmărește intervievatorul: Separă candidații care doar folosesc Boot de cei care îl înțeleg. Greșeala tipică este să descrii auto-configurarea ca „magie” fără să poți spune ce condiții o declanșează.

Eroarea, în practică:not loaded because @ConditionalOnProperty

7 Mid

Cum dezactivezi o auto-configurare și cum înlocuiești un bean creat automat, de exemplu ObjectMapper sau RestClient.Builder?

Răspuns scurt: Dezactivezi cu @SpringBootApplication(exclude = ...) sau proprietatea spring.autoconfigure.exclude. Înlocuiești definind propriul bean de același tip: auto-configurarea are @ConditionalOnMissingBean și se retrage. Pentru ajustări mici preferi proprietățile sau un customizer.

Ai trei niveluri de intervenție, de la cel mai fin la cel mai brutal.

Primul: proprietățile. Majoritatea auto-configurărilor citesc proprietăți (spring.jackson.default-property-inclusion=non_null, server.port, spring.datasource.url). Dacă ajunge o proprietate, nu scrii cod.

Al doilea: un customizer, care modifică bean-ul automat fără să-l înlocuiești:

JAVA
@Bean
Jackson2ObjectMapperBuilderCustomizer formatDate() {
    return b -> b.simpleDateFormat("yyyy-MM-dd");
}

@Bean
RestClientCustomizer antetComun() {
    return b -> b.defaultHeader("X-App", "magazin");
}

Avantajul: păstrezi tot ce face Boot (module Jackson, convertoare, metrici) și adaugi doar diferența.

Al treilea: propriul bean, care înlocuiește complet varianta automată, datorită lui @ConditionalOnMissingBean. E util când chiar vrei control total, dar pierzi setările implicite. Un ObjectMapper creat cu new ObjectMapper() nu mai are, de exemplu, modulul pentru java.time.

Dezactivarea completă:

JAVA
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)

sau spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration. Se folosește rar, de exemplu când ai driverul JPA pe classpath, dar un serviciu anume nu are bază de date.

Ce urmărește intervievatorul: Verifică dacă știi să lucrezi cu Boot, nu împotriva lui. Greșeala tipică este să înlocuiești ObjectMapper cu new ObjectMapper() și să strici serializarea datelor.

8 Senior

Echipa ta are o bibliotecă internă (de exemplu un client de audit) folosită în zece servicii. Cum ai transforma-o într-un starter Spring Boot?

Răspuns scurt: Creezi un modul de auto-configurare cu o clasă @AutoConfiguration, bean-uri marcate @ConditionalOnMissingBean, proprietăți @ConfigurationProperties cu prefix propriu, înregistrată în AutoConfiguration.imports, plus un modul starter care adună dependențele. Îl testezi cu ApplicationContextRunner.

Structura recomandată are două module:

  • audit-spring-boot-autoconfigure: codul de configurare;
  • audit-spring-boot-starter: un pom fără cod, care depinde de autoconfigure și de biblioteca propriu-zisă.

Auto-configurarea:

JAVA
@AutoConfiguration
@ConditionalOnClass(AuditClient.class)
@EnableConfigurationProperties(AuditProperties.class)
public class AuditAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnProperty(prefix = "audit", name = "enabled", matchIfMissing = true)
    AuditClient auditClient(AuditProperties p, RestClient.Builder builder) {
        return new AuditClient(builder.baseUrl(p.url()).build(), p.serviciu());
    }
}

@ConfigurationProperties("audit")
public record AuditProperties(String url, String serviciu, boolean enabled) { }

O înregistrezi în META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. Nu o pui într-un pachet scanat de aplicații: auto-configurarea trebuie încărcată doar prin mecanismul de auto-configurare, ca să i se aplice condițiile și ordinea (@AutoConfiguration(after = ...)).

Principii de design: totul se poate suprascrie (@ConditionalOnMissingBean), totul se poate opri dintr-o proprietate, valorile implicite sunt sigure, iar spring-boot-configuration-processor generează metadatele pentru autocompletare în IDE.

Testarea se face fără să pornești o aplicație întreagă:

JAVA
new ApplicationContextRunner()
    .withConfiguration(AutoConfigurations.of(AuditAutoConfiguration.class))
    .withPropertyValues("audit.enabled=false")
    .run(ctx -> assertThat(ctx).doesNotHaveBean(AuditClient.class));

Ce urmărește intervievatorul: La senior se verifică dacă poți construi infrastructură reutilizabilă pentru alte echipe. Greșeala tipică este să pui configurarea într-un @Configuration scanat, care nu poate fi dezactivat sau suprascris.

Bean-uri, IoC și ciclul de viață

9 Junior

Ce este ApplicationContext și ce înseamnă că un obiect este „bean”?

Răspuns scurt: ApplicationContext este containerul IoC al lui Spring: creează obiectele aplicației, le leagă între ele și le gestionează ciclul de viață. Un bean este un obiect creat și administrat de container, nu cu new de codul tău.

Inversion of Control înseamnă că nu mai creezi tu obiectele și legăturile dintre ele, ci descrii ce vrei, iar containerul le construiește. Descrierea vine din adnotări (@Component, @Service), din metode @Bean și din auto-configurări.

Pentru fiecare bean, containerul știe:

  • tipul și numele (implicit numele clasei cu prima literă mică: produsService);
  • scope-ul (implicit singleton: o singură instanță în tot contextul);
  • dependențele, pe care le injectează la creare.
JAVA
@Service
class ProdusService {
    private final ProdusRepository repo;
    ProdusService(ProdusRepository repo) { this.repo = repo; }
}

Containerul vede că ProdusService are nevoie de un ProdusRepository, îl creează întâi pe acesta și îl dă constructorului.

Consecințe practice: un obiect creat cu new ProdusService(...) în codul tău nu este bean; nu primește injectări, iar adnotările lui (@Transactional, @Cacheable, @Value) nu au efect. Un câmp @Autowired dintr-o astfel de clasă rămâne null, de unde un NullPointerException clasic.

Poți cere un bean direct cu context.getBean(ProdusService.class), dar în codul aplicației nu o faci: lași containerul să injecteze. ApplicationContext mai oferă evenimente, acces la proprietăți (Environment) și resurse.

Ce urmărește intervievatorul: Este întrebarea de bază despre Spring Core. Greșeala tipică este să crezi că orice obiect al unei clase adnotate devine bean, inclusiv cele create cu new.

Eroarea, în practică:No qualifying bean of type ... availableCannot invoke ... because "this.stoc" is null

10 Junior

Care este diferența dintre a pune @Component pe o clasă și a defini un bean cu o metodă @Bean într-o clasă @Configuration? Când alegi fiecare variantă?

Răspuns scurt: @Component (și @Service etc.) marchează propria ta clasă, găsită prin component scan. @Bean este o metodă care construiește obiectul explicit, util pentru clase pe care nu le poți adnota (din biblioteci) sau când crearea are logică ori parametri de configurare.

Cu @Component, Spring descoperă clasa singur și o construiește prin constructor:

JAVA
@Component
class CalculatorTva {
    BigDecimal aplica(BigDecimal pret) { return pret.multiply(new BigDecimal("1.19")); }
}

Cu @Bean, scrii tu codul de creare, într-o clasă de configurare:

JAVA
@Configuration
class ClientiConfig {
    @Bean
    RestClient catalogClient(RestClient.Builder builder, @Value("${catalog.url}") String url) {
        return builder.baseUrl(url).build();
    }

    @Bean
    Clock ceas() {
        return Clock.systemDefaultZone();
    }
}

Alegi @Bean când:

  • clasa vine dintr-o bibliotecă (RestClient, Clock, ObjectMapper) și nu poți pune adnotări pe ea;
  • vrei mai multe bean-uri de același tip cu configurări diferite (catalogClient, stocClient);
  • crearea depinde de proprietăți sau are pași de construcție.

Alegi @Component pentru propriile clase de aplicație: servicii, controllere, adaptoare.

Un detaliu de mid: într-o clasă @Configuration, metodele @Bean sunt interceptate printr-un proxy CGLIB, deci un apel ceas() din altă metodă @Bean întoarce același singleton, nu un obiect nou. În modul „lite” (@Configuration(proxyBeanMethods = false) sau metode @Bean într-un @Component), apelul direct creează un obiect nou, de aceea dependențele se cer ca parametri ai metodei.

Ce urmărește intervievatorul: Verifică dacă știi cum ajunge în context o clasă din altă bibliotecă. Greșeala tipică este să încerci să pui @Component pe o subclasă doar ca să faci bean un obiect din bibliotecă.

Eroarea, în practică:Factory method '...' threw exception

11 Junior

Ce se întâmplă la pornirea aplicației de mai jos și cum repari problema astfel încât comenzile să folosească implicit cardul, iar facturile transferul?

JAVA
interface Plata { String plateste(int suma); }

@Service class PlataCard implements Plata { public String plateste(int s) { return "card " + s; } }
@Service class PlataTransfer implements Plata { public String plateste(int s) { return "transfer " + s; } }

@RestController
class ComandaController {
    private final Plata plata;
    ComandaController(Plata plata) { this.plata = plata; }
}

Răspuns scurt: Aplicația nu pornește: Parameter 0 of constructor in ComandaController required a single bean, but 2 were found. Pui @Primary pe PlataCard, ca implementare implicită, iar unde ai nevoie de transfer ceri explicit @Qualifier("plataTransfer") Plata plata.

Injectarea se face după tip. Spring caută bean-uri de tip Plata și găsește două: plataCard și plataTransfer. Nu are cum să aleagă, așa că oprește pornirea și afișează:

Parameter 0 of constructor in ComandaController required a single bean, but 2 were found:
	- plataCard: defined in file [PlataCard.class]
	- plataTransfer: defined in file [PlataTransfer.class]

Secțiunea Action sugerează chiar soluțiile:

  • @Primary pe o implementare: devine alegerea implicită când există mai mulți candidați;
  • @Qualifier("nume") la punctul de injectare: ceri un bean anume după nume;
  • primești toate implementările: List<Plata> sau Map<String, Plata>.
JAVA
@Service @Primary
class PlataCard implements Plata { ... }

@RestController
class FacturaController {
    private final Plata plata;
    FacturaController(@Qualifier("plataTransfer") Plata plata) { this.plata = plata; }
}

ComandaController rămâne neschimbat și primește cardul. Numele implicit al bean-ului este numele clasei cu prima literă mică; dacă te temi de redenumiri, pui un nume explicit (@Service("transfer")) sau creezi o adnotare proprie marcată cu @Qualifier.

Mai există o regulă de rezervă: dacă numele parametrului coincide cu numele unui bean (Plata plataTransfer), Spring îl alege pe acela. Funcționează, dar e fragil, pentru că depinde de numele variabilei.

Ce urmărește intervievatorul: Este o situație reală, cu mesajul exact pe care îl vezi în consolă. Intervievatorul verifică dacă știi diferența dintre alegerea implicită (@Primary) și cea explicită (@Qualifier).

Eroarea, în practică:required a single bean, but 2 were foundexpected single matching bean but found 2

12 Junior

Ai trei implementări ale interfeței CalculReducere. Cum le injectezi pe toate într-un service și cum alegi una după un cod primit în cerere?

Răspuns scurt: Ceri List<CalculReducere> (toate, în ordinea @Order) sau Map<String, CalculReducere> (cheia este numele bean-ului). Pentru alegere după cod, construiești în constructor o hartă din codul declarat de fiecare implementare. Este pattern-ul Strategy, cu Spring ca registru.

Spring poate injecta toate bean-urile de un tip, nu doar unul:

JAVA
interface CalculReducere {
    String cod();
    BigDecimal aplica(BigDecimal total);
}

@Component class ReducereStudent implements CalculReducere {
    public String cod() { return "STUDENT"; }
    public BigDecimal aplica(BigDecimal t) { return t.multiply(new BigDecimal("0.90")); }
}
// ReducerePensionar, FaraReducere la fel

@Service
class ReducereService {
    private final Map<String, CalculReducere> dupaCod;

    ReducereService(List<CalculReducere> toate) {
        this.dupaCod = toate.stream()
                .collect(Collectors.toMap(CalculReducere::cod, c -> c));
    }

    BigDecimal aplica(String cod, BigDecimal total) {
        CalculReducere c = dupaCod.get(cod);
        if (c == null) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Reducere necunoscută: " + cod);
        }
        return c.aplica(total);
    }
}

Variante:

  • List<T>: ordinea se controlează cu @Order sau interfața Ordered; util pentru lanțuri de reguli aplicate pe rând;
  • Map<String, T>: cheile sunt numele bean-urilor (reducereStudent), comod, dar leagă logica de numele claselor;
  • ObjectProvider<T>: acces leneș sau opțional, cu getIfAvailable().

Avantajul este principiul open/closed: o reducere nouă înseamnă o clasă nouă cu @Component, fără să modifici service-ul. Collectors.toMap aruncă IllegalStateException la coduri duplicate, deci afli la pornire dacă două implementări declară același cod.

Ce urmărește intervievatorul: Verifică dacă știi să folosești containerul pentru design, nu doar pentru un bean pe interfață. Greșeala tipică este un switch mare care trebuie modificat la fiecare regulă nouă.

Eroarea, în practică:expected single matching bean but found 2

13 Junior

Ce sunt @PostConstruct și @PreDestroy? Când rulează @PostConstruct față de constructor și de injectarea câmpurilor?

Răspuns scurt: @PostConstruct rulează o singură dată, după ce bean-ul a fost construit și toate dependențele i-au fost injectate; e locul pentru inițializări care au nevoie de ele. @PreDestroy rulează la oprirea contextului, pentru eliberarea resurselor. Ambele vin din jakarta.annotation.

Ciclul de viață al unui bean singleton, simplificat:

  • se apelează constructorul (cu dependențele din constructor);
  • se injectează câmpurile și setter-ele @Autowired, apoi valorile @Value;
  • rulează metodele Aware și BeanPostProcessor-ele „înainte”;
  • rulează @PostConstruct (apoi InitializingBean.afterPropertiesSet și initMethod);
  • se aplică post-procesoarele „după”: aici se creează proxy-urile pentru @Transactional, @Async, @Cacheable;
  • bean-ul e gata de folosit; la închiderea contextului rulează @PreDestroy.
JAVA
@Service
class CursValutarService {
    @Autowired
    private CursRepository repo;
    private Map<String, BigDecimal> cache;

    CursValutarService() {
        // aici repo este încă null
    }

    @PostConstruct
    void incarca() {
        cache = repo.cursuriCurente();
    }

    @PreDestroy
    void opreste() {
        System.out.println("Închid conexiunile");
    }
}

Cu injectarea prin constructor, nevoia de @PostConstruct scade, pentru că dependențele există deja în constructor. Rămâne util pentru validări sau încărcări care nu ar trebui să stea în constructor.

Atenție: @PostConstruct rulează înaintea proxy-ului, deci un apel la o metodă @Transactional a aceluiași bean nu e tranzacțional. Pentru lucru „după pornire”, cu tot contextul gata, folosești ApplicationRunner sau @EventListener(ApplicationReadyEvent.class). Dacă @PostConstruct aruncă o excepție, aplicația nu pornește (BeanCreationException).

Ce urmărește intervievatorul: Verifică dacă știi ordinea din ciclul de viață. Greșeala tipică este să folosești un câmp @Autowired direct în constructor și să primești NullPointerException.

Eroarea, în practică:Invocation of init method failed

14 Junior

Aplicația nu pornește cu mesajul Field produsService in ProdusController required a bean of type 'ProdusService' that could not be found. Care sunt cauzele posibile și cum le verifici?

Răspuns scurt: Spring nu are niciun bean de tipul cerut. Cauze frecvente: clasa nu are @Service/@Component, e într-un pachet pe care component scan nu îl vede, e exclusă de o condiție (@Profile, @ConditionalOnProperty) sau este o interfață fără nicio implementare-bean.

Mesajul are trei părți utile: cine cere (Field produsService in ProdusController), ce tip lipsește (ProdusService) și secțiunea Action, cu sugestia Consider defining a bean of type 'ProdusService' in your configuration.

Lista de verificare, în ordinea probabilității:

  • clasa are o adnotare de stereotip? Un ProdusService fără @Service e o clasă obișnuită;
  • pachetul: clasa e în pachetul clasei @SpringBootApplication sau într-un subpachet?
  • condiții: @Profile("prod") pe o clasă, când rulezi cu profilul dev, sau @ConditionalOnProperty cu proprietatea lipsă, scot bean-ul din context;
  • tipul cerut e o interfață, iar implementarea nu e bean; la un repository, interfața nu extinde JpaRepository sau lipsește dependența spring-boot-starter-data-jpa;
  • clasa e internă și nu e static, sau ai importat alt ProdusService dintr-o bibliotecă.
JAVA
// lipsește @Service: clasa nu ajunge în context
class ProdusService { }

@Service
class ProdusService { }   // reparat

Cu --debug, raportul de condiții arată bean-urile excluse de condiții. În IntelliJ, iconița de lângă câmp arată dacă există un candidat.

Mesajul are și forma Parameter 0 of constructor in ProdusController required a bean... când injectarea e prin constructor; cauzele sunt aceleași.

Ce urmărește intervievatorul: Este cea mai frecventă eroare de pornire la juniori, iar intervievatorul vrea o metodă de depanare, nu o ghicire. Greșeala tipică este să adaugi @Autowired în plus, care nu schimbă nimic.

Eroarea, în practică:Field ... required a bean of type ... not foundParameter 0 of constructor ... required a bean

15 Mid

Ce este o dependență circulară între bean-uri, de ce Spring Boot o refuză implicit începând cu versiunea 2.6 și cum o elimini corect?

Răspuns scurt: Două bean-uri depind unul de altul (A cere B, B cere A). Cu injectare prin constructor nu pot fi create, iar Boot 2.6+ refuză ciclurile implicit, pentru că indică un design greșit. Soluția: o a treia clasă cu logica comună sau evenimente.

Exemplu:

JAVA
@Service class ComandaService {
    ComandaService(ClientService clienti) { ... }
}
@Service class ClientService {
    ClientService(ComandaService comenzi) { ... }
}

Pentru a crea ComandaService e nevoie de ClientService, care are nevoie de ComandaService, încă necreat. Spring afișează desenul ciclului:

The dependencies of some of the beans in the application context form a cycle:
┌─────┐
|  comandaService
↑     ↓
|  clientService
└─────┘

Cu injectare pe câmp sau setter, Spring putea rezolva ciclul dând o referință spre un obiect încă neinițializat complet. Din Boot 2.6, spring.main.allow-circular-references este implicit false, pentru că ciclul e aproape mereu un semn de responsabilități amestecate și poate produce bug-uri subtile (un proxy tranzacțional lipsă, un câmp folosit prea devreme).

Soluții, de la cea mai bună:

  • extragi partea de care au nevoie amândouă într-o a treia clasă (de exemplu IstoricClientService), iar ambele depind de ea;
  • inversezi o direcție cu evenimente: ComandaService publică ComandaPlasata, iar ClientService o ascultă cu @EventListener;
  • dacă nu poți refactoriza acum, @Lazy pe un parametru: Spring injectează un proxy care creează bean-ul real la primul apel.

Reactivarea proprietății allow-circular-references=true doar ascunde problema și e o soluție de ultim moment, nu de design.

Ce urmărește intervievatorul: Verifică dacă tratezi ciclul ca problemă de design, nu de configurare. Greșeala tipică este să treci pe injectare pe câmp sau să activezi proprietatea doar ca să pornească aplicația.

Eroarea, în practică:dependencies ... form a cycleRequested bean is currently in creation

16 Mid

Ce face @Lazy pe un bean sau pe un punct de injectare și ce efect are spring.main.lazy-initialization=true asupra aplicației?

Răspuns scurt: @Lazy amână crearea bean-ului până la prima folosire; pe un parametru, injectează un proxy care creează bean-ul real la primul apel. Inițializarea leneșă globală pornește aplicația mai repede, dar mută erorile de configurare de la pornire la prima cerere.

Implicit, toate bean-urile singleton se creează la pornire (eager). Avantajul principal: o greșeală de configurare oprește aplicația imediat, nu după o oră în producție.

@Lazy pe clasă sau pe metoda @Bean schimbă asta pentru un bean anume:

JAVA
@Service
@Lazy
class RaportGreuService {
    RaportGreuService() {
        System.out.println("Încarc șabloanele de rapoarte");
    }
}

Bean-ul se creează doar când îl cere cineva. Dacă un bean eager îl injectează direct, se creează tot la pornire, de aceea @Lazy se pune adesea și la punctul de injectare:

JAVA
RaportController(@Lazy RaportGreuService rapoarte) { ... }

Aici Spring injectează un proxy, iar bean-ul real se creează la primul apel de metodă. Același mecanism rupe, ca soluție de compromis, o dependență circulară.

spring.main.lazy-initialization=true face toate bean-urile leneșe:

  • pornire mai rapidă, utilă în dezvoltare sau la funcții serverless;
  • prima cerere spre fiecare endpoint e mai lentă;
  • erorile (bean lipsă, proprietate greșită) apar abia la folosire, iar health check-ul poate raporta UP pentru o aplicație stricată.

Pentru servere obișnuite, varianta eager rămâne alegerea sigură. Poți exclude bean-uri anume cu @Lazy(false).

Ce urmărește intervievatorul: Verifică dacă înțelegi compromisul dintre timpul de pornire și detectarea timpurie a erorilor. Greșeala tipică este să activezi inițializarea leneșă global ca optimizare fără să-i știi efectele.

17 Mid

Cum publici și asculți evenimente în Spring? Care e diferența dintre @EventListener și @TransactionalEventListener?

Răspuns scurt: Publici cu ApplicationEventPublisher.publishEvent(obiect), iar orice bean cu o metodă @EventListener care primește acel tip îl primește, sincron, în același fir. @TransactionalEventListener amână livrarea până după commit (implicit AFTER_COMMIT), ca să nu reacționezi la date care pot fi anulate.

Evenimentele decuplează părțile aplicației: cine produce un fapt nu știe cine reacționează la el.

JAVA
record ComandaPlasata(long id, String email) { }

@Service
class ComandaService {
    private final ApplicationEventPublisher evenimente;
    ComandaService(ApplicationEventPublisher evenimente) { this.evenimente = evenimente; }

    @Transactional
    public void plaseaza(Comanda c) {
        // salvează comanda...
        evenimente.publishEvent(new ComandaPlasata(c.getId(), c.getEmail()));
    }
}

@Component
class NotificareListener {
    @TransactionalEventListener
    void trimiteEmail(ComandaPlasata e) {
        System.out.println("Email pentru comanda " + e.id());
    }
}

Diferențe importante:

  • @EventListener rulează imediat, sincron, în firul și în tranzacția celui care publică; o excepție în listener ajunge la publicator și poate anula tranzacția;
  • @TransactionalEventListener rulează doar dacă tranzacția se termină cu commit (sau în altă fază: BEFORE_COMMIT, AFTER_ROLLBACK, AFTER_COMPLETION); dacă nu există tranzacție, evenimentul e ignorat, cu excepția cazului fallbackExecution = true;
  • cu @Async pe listener, procesarea trece în alt fir și nu mai blochează cererea.

Evenimentele Spring rămân în același proces și se pierd dacă aplicația cade. Pentru comunicare între servicii sau livrare garantată folosești un broker (Kafka, RabbitMQ), eventual cu pattern-ul outbox.

Ce urmărește intervievatorul: Verifică dacă știi problema clasică: email trimis pentru o comandă care a făcut apoi rollback. Greșeala tipică este să crezi că evenimentele Spring sunt asincrone implicit.

18 Senior

Ce afișează codul de mai jos la două apeluri pret(1) venite din controller și de ce? Cum îl repari?

JAVA
@Service
class ProdusService {
    public BigDecimal pret(long id) {
        return pretCalculat(id);
    }

    @Cacheable("preturi")
    public BigDecimal pretCalculat(long id) {
        System.out.println("calculez " + id);
        return new BigDecimal("99.90");
    }
}

Răspuns scurt: Afișează calculez 1 de două ori: cache-ul nu funcționează. @Cacheable este aplicat de un proxy din jurul bean-ului, iar apelul pretCalculat din interiorul aceleiași clase merge direct pe this, ocolind proxy-ul. Muți metoda cache-uită în alt bean sau pui adnotarea pe metoda apelată din exterior.

Adnotările de infrastructură (@Cacheable, @Async, @Transactional, @Retryable, @PreAuthorize) sunt implementate prin proxy-uri AOP. Controller-ul nu primește obiectul ProdusService real, ci un proxy (subclasă CGLIB sau, pentru interfețe, un proxy JDK dinamic) care interceptează apelurile publice, verifică cache-ul și abia apoi apelează obiectul țintă.

Fluxul aici:

  • controller-ul apelează proxy.pret(1); pret nu are adnotare, deci proxy-ul trece direct la obiectul real;
  • în obiectul real, pretCalculat(id) înseamnă this.pretCalculat(id); this este obiectul țintă, nu proxy-ul, deci nu se verifică niciun cache.

Reparații:

JAVA
@Service
class PretService {
    @Cacheable("preturi")
    public BigDecimal pretCalculat(long id) { ... }
}

@Service
class ProdusService {
    private final PretService preturi;
    ProdusService(PretService preturi) { this.preturi = preturi; }
    public BigDecimal pret(long id) { return preturi.pretCalculat(id); }
}

Alternative mai puțin curate: auto-injectarea propriului proxy (@Lazy ProdusService self), AopContext.currentProxy() cu exposeProxy, sau weaving AspectJ la compilare.

Alte limite ale proxy-urilor CGLIB: metodele private, final sau static nu pot fi interceptate, iar clasa nu trebuie să fie final. Și @EnableCaching trebuie să fie activ, altfel adnotarea e ignorată fără nicio eroare.

Ce urmărește intervievatorul: Este o capcană clasică, iar intervievatorul verifică dacă înțelegi mecanismul de proxy, nu doar regula. Greșeala tipică este să crezi că problema e configurarea cache-ului.

19 Senior

Ce sunt BeanPostProcessor și BeanFactoryPostProcessor? Dă exemple de locuri în care Spring însuși le folosește.

Răspuns scurt: BeanFactoryPostProcessor modifică definițiile bean-urilor înainte de crearea lor (de exemplu, rezolvarea ${...}). BeanPostProcessor lucrează pe instanțe, înainte și după inițializare, și poate întoarce alt obiect, de obicei un proxy. Pe ele se bazează @Autowired, @Value, @Transactional, @Async.

Containerul lucrează în două faze, iar fiecare are un punct de extensie.

Faza definițiilor: Spring a citit configurarea și are „rețetele” bean-urilor (BeanDefinition), dar nu a creat încă niciun obiect. Un BeanFactoryPostProcessor poate modifica aceste rețete. Exemple din Spring:

  • PropertySourcesPlaceholderConfigurer înlocuiește ${app.nume} cu valori;
  • ConfigurationClassPostProcessor procesează clasele @Configuration, @ComponentScan, @Import și înregistrează bean-urile găsite.

Faza instanțelor: un BeanPostProcessor primește fiecare bean creat:

JAVA
@Component
class TimpPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String name) {
        if (bean.getClass().isAnnotationPresent(Masoara.class)) {
            return Proxy.newProxyInstance(bean.getClass().getClassLoader(),
                    bean.getClass().getInterfaces(), new MasoaraHandler(bean));
        }
        return bean;
    }
}

Exemple din Spring: AutowiredAnnotationBeanPostProcessor (injectează @Autowired și @Value), CommonAnnotationBeanPostProcessor (@PostConstruct, @PreDestroy), AnnotationAwareAspectJAutoProxyCreator (creează proxy-urile pentru @Transactional, @Cacheable, aspecte), AsyncAnnotationBeanPostProcessor.

Detalii de senior: post-procesoarele sunt create foarte devreme, de aceea bean-urile de care depind nu mai primesc ele însele toate procesările (mesajul is not eligible for getting processed by all BeanPostProcessors); metodele @Bean care întorc un BeanFactoryPostProcessor trebuie declarate static. În aplicațiile obișnuite le scrii rar; le întâlnești în biblioteci și starter-e interne.

Ce urmărește intervievatorul: Verifică dacă știi cum e construit Spring în interior. Greșeala tipică este să confunzi faza definițiilor cu faza instanțelor sau să nu știi de unde apar proxy-urile.

API-uri REST cu Spring MVC

Exersează capitolul cu exerciții reale: Curs Spring Boot →
20 Junior

Ce face DispatcherServlet și ce drum parcurge o cerere GET /api/produse/7 până la metoda din controller?

Răspuns scurt: DispatcherServlet este punctul unic de intrare al Spring MVC (front controller). Primește cererea de la Tomcat după filtre, găsește metoda potrivită prin HandlerMapping, convertește parametrii, apelează metoda, apoi transformă rezultatul în răspuns (JSON prin Jackson) cu un HttpMessageConverter.

Drumul unei cereri într-o aplicație Spring Boot:

  • Tomcat primește conexiunea și creează obiectele HttpServletRequest și HttpServletResponse;
  • cererea trece prin lanțul de filtre servlet (encoding, securitate, filtrele tale OncePerRequestFilter);
  • ajunge la DispatcherServlet, înregistrat automat pe /;
  • RequestMappingHandlerMapping caută metoda după URL, metoda HTTP și eventual antete (consumes, produces); nu găsește nimic: 404, găsește calea dar nu metoda: 405;
  • rulează HandlerInterceptor.preHandle;
  • HandlerAdapter rezolvă argumentele: @PathVariable long id din 7, @RequestBody prin Jackson, @Valid declanșează validarea;
  • se apelează metoda controller-ului;
  • valoarea întoarsă trece printr-un HttpMessageConverter (MappingJackson2HttpMessageConverter pentru obiecte, conversie text pentru String) ales după antetul Accept;
  • o excepție aruncată pe drum ajunge la HandlerExceptionResolver-e: @ExceptionHandler, @ResponseStatus, apoi tratarea implicită (/error).
JAVA
@RestController
@RequestMapping("/api/produse")
class ProdusController {
    @GetMapping("/{id}")
    ProdusDto unul(@PathVariable long id) { ... }
}

Înțelegerea fluxului ajută la depanare: un 400 fără să intre în metodă înseamnă conversie sau validare eșuată; un 401 înainte de controller vine din filtre; un 404 cu mesajul No static resource înseamnă că nicio rută nu se potrivește.

Ce urmărește intervievatorul: Verifică dacă ai un model al stivei web, nu doar adnotări învățate. Greșeala tipică este să nu știi unde se termină filtrele și unde începe Spring MVC.

Eroarea, în practică:Request method 'POST' is not supportedAmbiguous mapping. Cannot map ... method

21 Junior

Ce răspunde aplicația la cererile GET /api/produse/7, GET /api/produse/abc, POST /api/produse/7 și GET /api/produs/7?

JAVA
@RestController
@RequestMapping("/api/produse")
class ProdusController {
    @GetMapping("/{id}")
    String unul(@PathVariable long id) {
        return "Produsul " + id;
    }
}

Răspuns scurt: /api/produse/7 dă 200 cu Produsul 7; /api/produse/abc dă 400, pentru că abc nu se poate converti în long; POST pe aceeași cale dă 405 Method Not Allowed; /api/produs/7 dă 404, pentru că nicio rută nu se potrivește.

Ruta completă este prefixul clasei plus calea metodei: GET /api/produse/{id}.

  • GET /api/produse/7: se potrivește, 7 se convertește în long, metoda întoarce un String, iar Spring îl trimite ca text cu statusul 200.
  • GET /api/produse/abc: calea se potrivește, dar conversia eșuează cu MethodArgumentTypeMismatchException; Spring răspunde 400 Bad Request fără să intre în metodă.
  • POST /api/produse/7: există o rută pentru cale, dar nu și pentru metoda POST; răspunsul este 405 Method Not Allowed, cu antetul Allow: GET (și jurnalul Request method 'POST' is not supported).
  • GET /api/produs/7: nicio rută; în Spring Boot 3.2+ apare NoResourceFoundException (No static resource api/produs/7.), iar clientul primește 404.

Corpul erorilor implicite este JSON-ul standard Spring Boot:

JSON
{"timestamp":"2026-03-01T10:00:00.000+00:00","status":404,"error":"Not Found","path":"/api/produs/7"}

Câmpul message apare doar cu server.error.include-message=always.

Dacă vrei ca abc să primească alt răspuns, poți restrânge ruta cu o expresie regulată (@GetMapping("/{id:\\d+}"), caz în care abc dă 404) sau tratezi MethodArgumentTypeMismatchException într-un @ExceptionHandler.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce face framework-ul înainte de codul tău. Greșeala tipică este să crezi că abc produce o excepție 500 sau că metoda greșită dă 404.

Eroarea, în practică:No static resource api/produse.Request method 'POST' is not supported

22 Junior

Ce coduri de status HTTP întorci, într-un API REST, pentru creare, citire, actualizare, ștergere și pentru resursă inexistentă? Cum le setezi în Spring?

Răspuns scurt: Creare: 201 Created cu antetul Location; citire: 200; actualizare: 200 cu corp sau 204 fără corp; ștergere: 204; resursă inexistentă: 404; date invalide: 400; conflict (duplicat): 409. În Spring le setezi cu ResponseEntity, @ResponseStatus sau excepții cu status.

Codurile comunică rezultatul fără ca clientul să citească textul. Cele uzuale într-un API CRUD:

  • 200 OK: citire reușită sau actualizare cu corp;
  • 201 Created: resursă nouă, cu Location: /api/produse/12;
  • 204 No Content: succes fără corp (ștergere, actualizare fără răspuns);
  • 400 Bad Request: JSON invalid, validare eșuată, parametri greșiți;
  • 401 Unauthorized (lipsește autentificarea), 403 Forbidden (autentificat, fără drept);
  • 404 Not Found: resursa nu există;
  • 409 Conflict: email deja folosit, versiune depășită;
  • 422 Unprocessable Entity: unele API-uri o folosesc pentru reguli de business încălcate;
  • 500: eroare neprevăzută pe server, niciodată pentru greșelile clientului.

În Spring:

JAVA
@PostMapping
ResponseEntity<ProdusDto> creeaza(@Valid @RequestBody ProdusNou p) {
    ProdusDto creat = service.creeaza(p);
    return ResponseEntity.created(URI.create("/api/produse/" + creat.id())).body(creat);
}

@DeleteMapping("/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
void sterge(@PathVariable long id) { service.sterge(id); }

@GetMapping("/{id}")
ProdusDto unul(@PathVariable long id) {
    return service.gaseste(id)
        .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Produsul " + id + " nu există"));
}

Regula practică: statusul se decide în controller sau în tratarea centralizată a excepțiilor, nu în service. Service-ul aruncă excepții de domeniu (ProdusNegasitException), iar un @RestControllerAdvice le traduce în coduri.

Ce urmărește intervievatorul: Este o întrebare de bază de design REST. Greșeala tipică este să întorci 200 cu {"error": ...} în corp sau 500 pentru date invalide trimise de client.

23 Junior

Scrie un endpoint POST /api/clienti care salvează un client și întoarce 201, antetul Location cu adresa noului client și clientul creat în corp.

Răspuns scurt: Metoda primește un DTO cu @Valid @RequestBody, salvează prin service, construiește URI-ul cu ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}") și întoarce ResponseEntity.created(uri).body(client).

O implementare completă:

JAVA
record ClientNou(@NotBlank String nume, @Email @NotBlank String email) { }
record ClientDto(long id, String nume, String email) { }

@RestController
@RequestMapping("/api/clienti")
class ClientController {
    private final ClientService service;
    ClientController(ClientService service) { this.service = service; }

    @PostMapping
    ResponseEntity<ClientDto> creeaza(@Valid @RequestBody ClientNou cerere) {
        ClientDto creat = service.creeaza(cerere);
        URI locatie = ServletUriComponentsBuilder.fromCurrentRequest()
                .path("/{id}")
                .buildAndExpand(creat.id())
                .toUri();
        return ResponseEntity.created(locatie).body(creat);
    }
}

Pentru POST http://localhost:8080/api/clienti cu {"nume": "Ana", "email": "ana@exemplu.ro"}, răspunsul este:

HTTP/1.1 201
Location: http://localhost:8080/api/clienti/1
Content-Type: application/json

{"id":1,"nume":"Ana","email":"ana@exemplu.ro"}

Ce urmărește intervievatorul:

  • DTO separat pentru intrare: clientul nu trimite id, iar entitatea nu e expusă;
  • validarea cu @Valid: fără ea, adnotările din record nu au efect;
  • fromCurrentRequest() construiește adresa pornind de la cererea curentă, deci funcționează și în spatele unui proxy (cu server.forward-headers-strategy configurat);
  • statusul 201, nu 200;
  • tratarea duplicatului (email existent) cu 409, printr-o excepție proprie și un handler.

Un URI relativ (URI.create("/api/clienti/" + id)) este și el acceptat de specificația HTTP actuală și apare des în cod.

Ce urmărește intervievatorul: Este o sarcină tipică de live coding. Greșeala tipică este să întorci entitatea JPA direct și statusul 200 fără antetul Location.

24 Junior

Care este diferența dintre POST, PUT și PATCH? Ce înseamnă că o metodă HTTP este idempotentă?

Răspuns scurt: POST creează o resursă nouă (sau declanșează o acțiune); PUT înlocuiește complet resursa de la o adresă cunoscută; PATCH modifică doar câmpurile trimise. O metodă idempotentă are același efect dacă o repeți: GET, PUT, DELETE sunt idempotente, POST nu.

Pe o resursă /api/produse/{id}:

  • POST /api/produse: serverul alege id-ul și creează; două cereri identice creează două produse;
  • PUT /api/produse/7: corpul este reprezentarea completă a produsului; câmpurile lipsă devin goale sau null; repetarea dă aceeași stare;
  • PATCH /api/produse/7: corp parțial, de exemplu {"pret": 89}; doar prețul se schimbă.

Idempotența contează pentru reîncercări: dacă o cerere PUT a expirat fără răspuns, clientul o poate retrimite în siguranță. Cu POST, o retrimitere poate crea o comandă dublă, de aceea API-urile de plăți folosesc un antet Idempotency-Key, salvat pe server, ca a doua cerere cu aceeași cheie să întoarcă rezultatul primei.

Metodele „sigure” (GET, HEAD, OPTIONS) nu modifică nimic; orice metodă sigură este și idempotentă.

În Spring:

JAVA
@PutMapping("/{id}")
ProdusDto inlocuieste(@PathVariable long id, @Valid @RequestBody ProdusDate date) { ... }

@PatchMapping("/{id}")
ProdusDto modifica(@PathVariable long id, @RequestBody Map<String, Object> campuri) { ... }

La PATCH trebuie să distingi „câmp lipsă” de „câmp trimis cu null”. Un record obișnuit nu poate face diferența; variante: Map, JsonNode, Optional în DTO sau formatul JSON Merge Patch (application/merge-patch+json).

Ce urmărește intervievatorul: Verifică înțelegerea semanticii HTTP, care contează la reîncercări și la clienți mobili. Greșeala tipică este să folosești PUT pentru modificări parțiale și să ștergi câmpuri fără să vrei.

25 Junior

Cum citești un antet al cererii într-un controller și cum adaugi un antet propriu în răspuns?

Răspuns scurt: Citești cu @RequestHeader("X-Client-Id") String clientId (cu required = false sau defaultValue dacă e opțional). Adaugi în răspuns prin ResponseEntity.ok().header("X-Total", "42").body(...) sau prin HttpServletResponse.setHeader.

Exemplu cu ambele direcții:

JAVA
@GetMapping("/api/produse")
ResponseEntity<List<ProdusDto>> lista(
        @RequestHeader(value = "Accept-Language", defaultValue = "ro") String limba,
        @RequestHeader("X-Client-Id") String clientId) {
    List<ProdusDto> produse = service.toate(limba);
    return ResponseEntity.ok()
            .header("X-Total", String.valueOf(produse.size()))
            .cacheControl(CacheControl.maxAge(Duration.ofMinutes(5)))
            .body(produse);
}

Detalii:

  • numele antetelor nu țin cont de litere mari (x-client-id merge la fel);
  • un antet obligatoriu lipsă dă 400, cu mesajul Required request header 'X-Client-Id' for method parameter type String is not present;
  • poți primi toate antetele: @RequestHeader HttpHeaders antete sau Map<String, String>;
  • ResponseEntity are metode dedicate pentru antetele standard: location, eTag, lastModified, contentType, cacheControl.

Pentru antete puse pe toate răspunsurile (de exemplu un X-Request-Id pentru corelarea jurnalelor) folosești un filtru, nu fiecare controller.

Atenție la CORS: un client JavaScript din alt domeniu nu poate citi antetele proprii din răspuns decât dacă serverul le declară în Access-Control-Expose-Headers (exposedHeaders("X-Total") în configurarea CORS). Aplicația funcționează în Postman, dar în browser antetul pare să lipsească.

Ce urmărește intervievatorul: Verifică lucrul cu HTTP dincolo de corpul JSON. Greșeala tipică este să uiți Access-Control-Expose-Headers și să crezi că serverul nu trimite antetul.

Eroarea, în practică:Required request header ... is not present

26 Junior

Ce răspunde endpoint-ul de mai jos la GET /cauta, GET /cauta?q=mouse și GET /cauta?q=mouse&pagina=abc?

JAVA
@GetMapping("/cauta")
String cauta(@RequestParam(required = false) String q,
             @RequestParam(defaultValue = "1") int pagina) {
    return "q=" + q + ", pagina=" + pagina;
}

Răspuns scurt: /cauta răspunde q=null, pagina=1; /cauta?q=mouse răspunde q=mouse, pagina=1; /cauta?q=mouse&pagina=abc dă 400 Bad Request, pentru că abc nu se poate converti în int. defaultValue face parametrul opțional automat.

Regulile pentru @RequestParam:

  • implicit parametrul este obligatoriu; lipsa lui dă 400 cu Required request parameter 'q' for method parameter type String is not present;
  • required = false îl face opțional, iar valoarea lipsă devine null; pentru un tip primitiv (int) asta ar da eroare, pentru că null nu încape într-un int, deci folosești Integer, Optional<Integer> sau defaultValue;
  • defaultValue = "1" implică required = false și se aplică și când parametrul e trimis gol (?pagina=);
  • conversia se face înainte de apel; un text care nu e număr dă MethodArgumentTypeMismatchException, deci 400.

Așadar:

GET /cauta                      -> 200  q=null, pagina=1
GET /cauta?q=mouse              -> 200  q=mouse, pagina=1
GET /cauta?q=mouse&pagina=abc   -> 400

Variante utile: Optional<String> q (mai expresiv decât null), @RequestParam List<Long> id pentru ?id=1&id=2 sau ?id=1,2, @RequestParam Map<String, String> toti pentru filtre dinamice, sau un record de parametri (CautareParams params, fără adnotare), legat automat după numele câmpurilor.

Numele parametrului se ia din numele variabilei doar dacă proiectul e compilat cu -parameters, ceea ce face implicit spring-boot-starter-parent. Fără el, în Spring 6.1+ apare eroarea despre lipsa informațiilor despre numele parametrilor, iar soluția este @RequestParam("q") sau flag-ul de compilare.

Ce urmărește intervievatorul: Verifică detaliile care produc bug-uri în producție: null în loc de valoare, 400 neașteptat. Greșeala tipică este required = false pe un int.

Eroarea, în practică:Required request parameter ... is not presentMethod parameter 'id': Failed to convert value

27 Junior

Ce primești în browser când accesezi o adresă inexistentă a aplicației, și în Postman pentru aceeași cerere? De unde vine acest răspuns și cum îl personalizezi?

Răspuns scurt: În browser vezi Whitelabel Error Page, în Postman un JSON cu timestamp, status, error, path. Ambele vin de la BasicErrorController, mapat pe /error, care alege HTML sau JSON după antetul Accept. Îl personalizezi cu @RestControllerAdvice, ProblemDetail sau proprietățile server.error.*.

Când o cerere se termină cu eroare (rută inexistentă, excepție netratată, sendError), containerul servlet redirecționează intern spre /error. Spring Boot înregistrează acolo BasicErrorController:

  • pentru Accept: text/html (browserul) generează pagina „Whitelabel Error Page”: This application has no explicit mapping for /error, so you are seeing this as a fallback.;
  • pentru alte cereri întoarce JSON:
JSON
{"timestamp":"2026-03-01T10:00:00.000+00:00","status":404,"error":"Not Found","path":"/api/produs"}

Personalizare, de la simplu la complet:

  • proprietăți: server.error.include-message=always, include-binding-errors, include-stacktrace=never (lasă never în producție), server.error.whitelabel.enabled=false;
  • pagini statice pentru browser: src/main/resources/templates/error/404.html sau static/error/404.html;
  • un bean ErrorAttributes propriu, pentru alte câmpuri în JSON;
  • @RestControllerAdvice cu @ExceptionHandler: tratezi excepțiile înainte să ajungă la /error;
  • spring.mvc.problemdetails.enabled=true: erorile Spring MVC devin application/problem+json (RFC 9457).

Atenție la securitate: cu Spring Security, /error trebuie permis (permitAll), altfel o eroare 400 se poate transforma într-un 401 sau 403 confuz, pentru că redirecționarea spre /error este și ea filtrată.

Ce urmărește intervievatorul: Verifică dacă știi de unde vin erorile implicite și cum le controlezi. Greșeala tipică este să crezi că „Whitelabel” e o eroare în sine, nu doar pagina de rezervă pentru orice eroare.

Eroarea, în practică:Whitelabel Error PageThere was an unexpected error, status=500

28 Junior

Ce se întâmplă dacă un @Controller (nu @RestController) are o metodă @GetMapping("/salut") care întoarce "salut"?

Răspuns scurt: Spring tratează "salut" ca numele unei vederi (șablon Thymeleaf, JSP), nu ca text de trimis. Fără șablon apare o eroare (de exemplu 500 sau Circular view path [salut]). Pentru un API adaugi @ResponseBody pe metodă sau folosești @RestController.

@RestController este @Controller plus @ResponseBody pe toate metodele. Diferența contează la ce face Spring cu valoarea întoarsă:

  • cu @ResponseBody, valoarea se scrie direct în corpul răspunsului printr-un HttpMessageConverter: String ca text, obiectele ca JSON;
  • fără @ResponseBody, un String întors este numele unei vederi; un ViewResolver caută șablonul (de exemplu templates/salut.html cu Thymeleaf) și îl randează.
JAVA
@Controller
class PaginaController {
    @GetMapping("/salut")
    String salut(Model model) {
        model.addAttribute("nume", "Ana");
        return "salut";             // templates/salut.html
    }

    @GetMapping("/api/salut")
    @ResponseBody
    String salutText() {
        return "salut";             // textul „salut”
    }
}

Fără motor de șabloane, Spring încearcă să găsească o resursă cu numele vederii; dacă numele coincide cu ruta curentă, apare Circular view path [salut]: would dispatch back to the current handler URL [/salut] again. Cu Thymeleaf instalat, dar fără fișier, vezi Error resolving template [salut].

Pentru un API REST pui @RestController pe clasă. @Controller rămâne pentru aplicații cu pagini randate pe server, unde poți amesteca metode care întorc vederi cu metode @ResponseBody pentru apeluri AJAX.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce există două adnotări, dintr-un unghi practic. Greșeala tipică este eroarea „Circular view path” la primul API scris cu @Controller.

29 Mid

Cum proiectezi URL-urile unui API REST pentru un magazin cu produse, categorii, comenzi și liniile comenzilor? Ce reguli urmezi?

Răspuns scurt: Resurse ca substantive la plural (/produse, /comenzi/{id}), ierarhie doar pentru relații de compoziție (/comenzi/{id}/linii), filtrare, sortare și paginare prin query (?categorie=3&sort=pret,desc&page=0), metodele HTTP pentru acțiuni și coduri de status corecte. Acțiunile care nu sunt CRUD devin sub-resurse sau verbe explicite.

Reguli folosite în practică:

  • resurse, nu acțiuni: GET /produse, nu GET /getProduse; metoda HTTP spune acțiunea;
  • plural și id în cale: /produse/{id};
  • ierarhie pentru apartenență: /comenzi/{id}/linii, /comenzi/{id}/linii/{nr}; nu adânci peste două niveluri;
  • filtrare și căutare prin query: /produse?categorie=3&pretMax=200&q=mouse;
  • paginare și sortare standard: ?page=0&size=20&sort=pret,desc, cu metadate în răspuns (totalElements, totalPages);
  • litere mici, cuvinte separate prin -: /metode-plata;
  • prefix de versiune sau de API: /api/v1/....
GET    /api/v1/produse?categorie=3&page=0&size=20
GET    /api/v1/produse/12
POST   /api/v1/comenzi                     -> 201, Location
GET    /api/v1/comenzi/45/linii
POST   /api/v1/comenzi/45/anulare          -> acțiune care nu e CRUD
GET    /api/v1/clienti/7/comenzi           -> comenzile unui client

Acțiunile de business (anulare, plată, aprobare) se modelează fie ca sub-resursă cu POST (/comenzi/45/anulare), fie ca schimbare de stare cu PATCH {"stare": "ANULATA"}. Prima variantă e mai explicită și permite reguli și jurnale separate.

Contează și consecvența: același format de eroare peste tot, aceleași nume de parametri, date în ISO-8601, sume ca text sau număr zecimal exact, nu ca double aproximativ. Contractul se documentează cu OpenAPI (springdoc).

Ce urmărește intervievatorul: Verifică gândirea de design, nu doar adnotările. Greșeala tipică este un amestec de verbe în URL, GET cu efecte și coduri de status alese la întâmplare.

30 Mid

Cum versionezi un API REST în Spring Boot și cum îl documentezi pentru alte echipe?

Răspuns scurt: Variante de versionare: în cale (/api/v1), cea mai simplă și mai vizibilă; în antet (X-API-Version) sau în media type (application/vnd.magazin.v2+json). Documentezi cu OpenAPI prin springdoc-openapi, care generează /v3/api-docs și Swagger UI din controllere și adnotări.

Versionezi doar la schimbări incompatibile: un câmp eliminat sau redenumit, un tip schimbat, o regulă nouă de validare. Adăugarea unui câmp opțional nu cere versiune nouă, dacă clienții ignoră câmpurile necunoscute.

Versionare în cale:

JAVA
@RestController
@RequestMapping("/api/v1/produse")
class ProdusControllerV1 { ... }

@RestController
@RequestMapping("/api/v2/produse")
class ProdusControllerV2 { ... }

Avantaje: vizibilă în jurnale, ușor de rutat în gateway, ușor de testat cu curl. În antet sau media type, URL-ul rămâne stabil, dar cererile sunt mai greu de testat și de pus în cache.

Practici bune: v1 și v2 folosesc același service, cu DTO-uri și mapări diferite; anunți o dată de retragere și adaugi antete precum Deprecation și Sunset la versiunea veche; măsori cine mai folosește v1 înainte să o oprești. Spring Framework 7 adaugă suport nativ pentru versionare (@GetMapping(version = "1.1")), dar majoritatea proiectelor Boot 3 folosesc calea.

Documentare cu springdoc:

XML
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
</dependency>

Fără alt cod, primești specificația la /v3/api-docs și interfața la /swagger-ui.html. Completezi cu @Operation(summary = ...), @ApiResponse, @Schema pe DTO-uri. Specificația poate genera clienți pentru alte echipe și poate fi verificată în CI, ca o schimbare incompatibilă să nu treacă neobservată.

Ce urmărește intervievatorul: Verifică experiența cu API-uri folosite de alții. Greșeala tipică este o versiune nouă la orice modificare sau, invers, schimbări incompatibile fără versiune.

31 Mid

Care este diferența dintre un filtru servlet (OncePerRequestFilter) și un HandlerInterceptor? Ce ai alege pentru un X-Request-Id în jurnale și ce pentru verificarea unei permisiuni pe controller?

Răspuns scurt: Filtrul rulează în containerul servlet, înaintea lui DispatcherServlet, pentru orice cerere, inclusiv cele fără controller. Interceptorul rulează în Spring MVC, după alegerea metodei, și știe ce handler se apelează. X-Request-Id: filtru. Logica legată de controller: interceptor, sau mai bine securitate la nivel de metodă.

Ordinea pe drumul unei cereri: filtre, DispatcherServlet, interceptori (preHandle), controller, interceptori (postHandle, afterCompletion), filtre la întoarcere.

Filtru:

JAVA
@Component
class RequestIdFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
            throws ServletException, IOException {
        String id = Optional.ofNullable(req.getHeader("X-Request-Id")).orElse(UUID.randomUUID().toString());
        MDC.put("requestId", id);
        res.setHeader("X-Request-Id", id);
        try {
            chain.doFilter(req, res);
        } finally {
            MDC.remove("requestId");
        }
    }
}

Poate modifica sau înlocui cererea și răspunsul, poate opri lanțul (de exemplu cu 401) și vede și resursele statice și 404-urile. Spring Security este un lanț de filtre.

Interceptor:

JAVA
class AuditInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) {
        if (handler instanceof HandlerMethod m && m.hasMethodAnnotation(Audit.class)) {
            System.out.println("Audit: " + m.getMethod().getName());
        }
        return true;
    }
}

Se înregistrează prin WebMvcConfigurer.addInterceptors(...).addPathPatterns("/api/**") și are acces la metoda aleasă și la adnotările ei.

OncePerRequestFilter garantează o singură rulare pe cerere, chiar dacă cererea e redirecționată intern (de exemplu spre /error). Pentru permisiuni pe metode, în aplicații reale folosești @PreAuthorize din Spring Security, nu interceptori scriși de mână.

Ce urmărește intervievatorul: Verifică dacă știi straturile web și alegi locul potrivit pentru o preocupare transversală. Greșeala tipică este să pui logica de corelare a jurnalelor în fiecare controller.

32 Mid

Frontend-ul de pe http://localhost:3000 primește în browser eroarea „blocked by CORS policy”, deși cererea din Postman merge. Ce se întâmplă și cum configurezi corect CORS în Spring Boot?

Răspuns scurt: Browserul blochează răspunsurile de la altă origine dacă serverul nu le permite explicit prin antetele Access-Control-Allow-*; Postman nu aplică regula. Configurezi originile permise global cu WebMvcConfigurer.addCorsMappings (sau @CrossOrigin), iar cu Spring Security activezi și http.cors().

CORS (Cross-Origin Resource Sharing) este o regulă a browserului, nu a serverului. O origine este schema, gazda și portul: http://localhost:3000 și http://localhost:8080 sunt origini diferite. Pentru cereri „ne-simple” (de exemplu POST cu Content-Type: application/json sau cu antetul Authorization), browserul trimite întâi o cerere preflight OPTIONS și continuă doar dacă răspunsul conține antetele potrivite.

Configurare globală:

JAVA
@Configuration
class WebConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
                .allowedOrigins("http://localhost:3000", "https://magazin.ro")
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("*")
                .exposedHeaders("Location", "X-Total")
                .allowCredentials(true)
                .maxAge(3600);
    }
}

Capcane frecvente:

  • allowedOrigins("*") împreună cu allowCredentials(true) este interzis și oprește aplicația; folosești origini explicite sau allowedOriginPatterns;
  • cu Spring Security, filtrele de securitate rulează înainte de MVC și pot respinge preflight-ul cu 401; adaugi http.cors(Customizer.withDefaults()), care folosește configurarea CORS;
  • antetele proprii din răspuns nu sunt vizibile în JavaScript fără exposedHeaders;
  • CORS nu protejează serverul: un client care nu e browser trimite orice cerere. Este o protecție pentru utilizatorii browserului, nu autentificare.

În dezvoltare, o alternativă este un proxy al serverului de frontend (Vite, Angular CLI), astfel încât browserul vede o singură origine.

Ce urmărește intervievatorul: Este o problemă pe care o are aproape orice echipă full-stack. Greșeala tipică este allowedOrigins("*") peste tot sau ideea că CORS este o măsură de securitate a API-ului.

Eroarea, în practică:blocked by CORS policy: no Allow-Origin headerallowCredentials true with allowedOrigins "*"

33 Senior

Un API Spring MVC face multe apeluri lente spre alte servicii și rămâne fără fire de execuție sub încărcare. Ce opțiuni ai: virtual threads, apeluri asincrone sau WebFlux?

Răspuns scurt: Firele Tomcat blocate în I/O epuizează pool-ul. Întâi timeout-uri și circuit breaker; apoi, cu Java 21 și Boot 3.2+, spring.threads.virtual.enabled=true, fără rescrierea codului. WebFlux merită doar pentru o stivă complet reactivă sau streaming.

Tomcat are implicit un pool de 200 de fire (server.tomcat.threads.max). Dacă fiecare cerere așteaptă două secunde un serviciu extern, capacitatea se termină repede, iar cererile noi stau la coadă, deși CPU-ul e liber.

Opțiunile, în ordinea costului:

  • timeout-uri și limitare: înainte de orice, fiecare apel extern are timeout de conectare și de citire, plus circuit breaker; altfel orice soluție doar amână blocarea;
  • virtual threads (Java 21, Boot 3.2+): spring.threads.virtual.enabled=true. Tomcat, @Async și alte executoare folosesc fire virtuale. Un fir virtual blocat în I/O eliberează firul de platformă, deci poți avea zeci de mii de cereri în așteptare. Codul rămâne imperativ și ușor de citit. Atenție la limitările reale: pool-ul de conexiuni la bază rămâne mic, iar blocurile synchronized lungi pot fixa firul (pinning) în versiunile Java dinaintea lui 24;
  • apeluri paralele: dacă o cerere face trei apeluri independente, le pornești în paralel (CompletableFuture cu un executor, sau StructuredTaskScope când e stabil), reducând latența, nu doar consumul de fire;
  • WebFlux: model reactiv, puține fire, backpressure, streaming (SSE, WebSocket). Cere ca toată stiva să fie neblocantă (R2DBC în loc de JPA, WebClient), iar codul și depanarea sunt mai grele.

Decizia trebuie făcută pe măsurători: profil de încărcare, durata apelurilor, pool-uri saturate (metricile tomcat.threads.busy, hikaricp.connections.pending). Adesea gâtul de sticlă real este baza de date, pe care nici virtual threads, nici WebFlux nu o fac mai rapidă.

Ce urmărește intervievatorul: La senior se verifică dacă alegi soluția după măsurători și cost, nu după modă. Greșeala tipică este migrarea la WebFlux păstrând JPA blocant în interior.

JSON, Jackson și DTO-uri

34 Junior

Cum transformă Spring Boot un obiect Java întors din controller în JSON? Ce reguli folosește Jackson pentru numele și ordinea câmpurilor?

Răspuns scurt: Spring MVC folosește MappingJackson2HttpMessageConverter, care apelează ObjectMapper-ul configurat de Boot. Jackson ia proprietățile din getter-e publice, câmpuri publice sau componentele unui record; numele JSON vine din numele proprietății (getPretUnitar dă pretUnitar), iar ordinea urmează declararea.

Pentru o metodă @RestController care întoarce un obiect, Spring alege un HttpMessageConverter după tipul obiectului și antetul Accept. Pentru JSON, convertorul folosește ObjectMapper, bean creat de auto-configurarea Jackson.

Cum găsește Jackson proprietățile:

  • la un record: componentele (record ProdusDto(long id, String nume) dă {"id":1,"nume":"Mouse"});
  • la o clasă: getter-ele publice (getNume() dă nume, isActiv() pentru boolean dă activ) și câmpurile publice; câmpurile private fără getter sunt ignorate;
  • numele vine din getter, nu din câmp: getPretFinal() apare ca pretFinal, chiar dacă nu există un câmp cu acel nume.
JAVA
class Produs {
    private String nume = "Mouse";
    private double pret = 89;
    public String getNume() { return nume; }
    public double getPret() { return pret; }
    public boolean isInStoc() { return true; }
}
// {"nume":"Mouse","pret":89.0,"inStoc":true}

Ce iese din Boot în mod implicit: null este inclus, datele LocalDate sunt text ISO ("2026-03-01", nu un tablou de numere, pentru că Boot dezactivează WRITE_DATES_AS_TIMESTAMPS), enum-urile apar cu numele constantei, BigDecimal cu scala lui.

O clasă fără nicio proprietate vizibilă dă eroarea No serializer found for class ... and no properties discovered to create BeanSerializer. La primire, câmpurile JSON necunoscute sunt ignorate, pentru că Boot dezactivează FAIL_ON_UNKNOWN_PROPERTIES.

Ce urmărește intervievatorul: Verifică dacă știi de unde vine forma JSON-ului. Greșeala tipică este să crezi că Jackson citește câmpurile private direct și să nu înțelegi de ce un câmp lipsește din răspuns.

Eroarea, în practică:No serializer found for class ...

35 Junior

Ce JSON întoarce endpoint-ul de mai jos?

JAVA
enum Stare { NOUA, PLATITA }
record ComandaDto(long id, BigDecimal total, double reducere, LocalDate data, Stare stare, String observatii) { }

@GetMapping("/comenzi/1")
ComandaDto comanda() {
    return new ComandaDto(1, new BigDecimal("149.50"), 10, LocalDate.of(2026, 3, 1), Stare.PLATITA, null);
}

Răspuns scurt: Întoarce {"id":1,"total":149.50,"reducere":10.0,"data":"2026-03-01","stare":"PLATITA","observatii":null}. BigDecimal își păstrează scala, double apare cu .0, data e text ISO, enum-ul e numele constantei, iar null este inclus implicit.

Pe rând:

  • id: long devine număr întreg, 1;
  • total: BigDecimal se scrie ca număr cu scala creată (149.50, nu 149.5), deci păstrează zecimalele exacte;
  • reducere: un double 10 se scrie 10.0;
  • data: Spring Boot înregistrează modulul JavaTimeModule și dezactivează scrierea datelor ca timestamp, deci rezultatul este "2026-03-01";
  • stare: enum-ul apare ca numele constantei, "PLATITA"; @JsonValue pe o metodă a enum-ului ar schimba asta;
  • observatii: valoarea null este inclusă.
JSON
{"id":1,"total":149.50,"reducere":10.0,"data":"2026-03-01","stare":"PLATITA","observatii":null}

Ce poți controla:

JAVA
@JsonInclude(JsonInclude.Include.NON_NULL)
record ComandaDto(long id,
                  BigDecimal total,
                  double reducere,
                  @JsonFormat(pattern = "dd.MM.yyyy") LocalDate data,
                  Stare stare,
                  String observatii) { }

Acum observatii lipsește când e null, iar data apare "01.03.2026". Global: spring.jackson.default-property-inclusion=non_null.

Pentru sume de bani, BigDecimal este alegerea corectă; un double poate produce valori ca 0.30000000000000004. Unii clienți JavaScript pierd precizia la numere mari, de aceea unele API-uri trimit sumele ca text (@JsonFormat(shape = JsonFormat.Shape.STRING)).

Ce urmărește intervievatorul: Verifică dacă știi exact ce primește clientul, cu tot cu tipuri. Greșeala tipică este să te aștepți la 149.5 sau la data ca tablou [2026,3,1].

36 Junior

De ce nu este bine să întorci entitățile JPA direct din controller? Ce rezolvă DTO-urile?

Răspuns scurt: Entitatea expune structura bazei de date, poate scurge câmpuri sensibile (parola, note interne), poate da recursivitate infinită la relații bidirecționale și declanșează încărcări leneșe neașteptate. DTO-ul este contractul API-ului: doar câmpurile dorite, separat pentru intrare și ieșire, stabil la schimbări de schemă.

Problemele concrete ale entității expuse:

  • date sensibile: Utilizator are parolaHash, rol, dataStergerii; orice câmp nou adăugat în entitate apare automat în API;
  • mass assignment la intrare: dacă primești entitatea cu @RequestBody, clientul poate trimite "rol": "ADMIN" sau "id": 5 și suprascrie date;
  • relații: Comanda are client, iar Client are List<Comanda>; Jackson merge în cerc până la StackOverflowError (Infinite recursion);
  • lazy loading: serializarea atinge colecții leneșe, care fie declanșează interogări în plus, fie aruncă LazyInitializationException;
  • cuplare: redenumirea unei coloane schimbă contractul API-ului și strică clienții.

Cu DTO-uri:

JAVA
record ProdusNou(@NotBlank String nume, @Positive BigDecimal pret, long categorieId) { }
record ProdusDto(long id, String nume, BigDecimal pret, String categorie) { }

ProdusDto laDto(Produs p) {
    return new ProdusDto(p.getId(), p.getNume(), p.getPret(), p.getCategorie().getNume());
}

Ai DTO-uri separate pentru creare, actualizare și răspuns, fiecare cu validarea lui. Răspunsul poate aplatiza relații (categorie ca nume) și poate adăuga câmpuri calculate.

Costul este codul de mapare. Pentru proiecte mari folosești MapStruct, care generează maparea la compilare. Pentru citiri, poți încărca direct DTO-ul din bază (proiecții, SELECT new ...), fără entitate.

Ce urmărește intervievatorul: Este o întrebare de design întâlnită aproape la orice interviu Spring. Greșeala tipică este să răspunzi doar „pentru că așa e bine”, fără problemele concrete.

Eroarea, în practică:Could not write JSON: Infinite recursion

37 Junior

Ce fac adnotările @JsonProperty, @JsonIgnore și @JsonInclude? Dă câte un exemplu de folosire reală.

Răspuns scurt: @JsonProperty("nume_json") schimbă numele câmpului în JSON (sau îl face doar de citire ori scriere). @JsonIgnore scoate o proprietate din serializare și deserializare. @JsonInclude(NON_NULL) omite câmpurile null (sau goale, cu NON_EMPTY).

Toate trei controlează cum se potrivesc obiectele Java cu JSON-ul, fără să schimbi numele din cod.

@JsonProperty pentru un contract cu alte convenții de nume, de exemplu un API extern în snake_case:

JAVA
record PlataRaspuns(
        @JsonProperty("transaction_id") String idTranzactie,
        @JsonProperty("amount_cents") long sumaBani) { }

Global, în loc de adnotări pe fiecare câmp: spring.jackson.property-naming-strategy=SNAKE_CASE.

Cu access, o proprietate poate fi doar primită, nu și trimisă:

JAVA
class UtilizatorNou {
    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    private String parola;
}

@JsonIgnore scoate complet o proprietate:

JAVA
@Entity
class Client {
    @OneToMany(mappedBy = "client")
    @JsonIgnore
    private List<Comanda> comenzi;
}

Rupe recursivitatea, dar e o soluție de avarie; cu DTO-uri nu mai ai nevoie de ea.

@JsonInclude pentru răspunsuri mai curate:

JAVA
@JsonInclude(JsonInclude.Include.NON_NULL)
record EroareDto(String cod, String mesaj, List<String> campuri) { }

NON_EMPTY omite și listele sau textele goale. Atenție: pentru unii clienți, „câmp lipsă” și „câmp null” înseamnă lucruri diferite, deci alegerea face parte din contractul API-ului.

Alte adnotări utile: @JsonFormat pentru date, @JsonAlias pentru nume alternative la citire, @JsonCreator pentru constructori speciali, @JsonIgnoreProperties(ignoreUnknown = true) pentru clienți externi, unde ai propriul ObjectMapper.

Ce urmărește intervievatorul: Verifică dacă știi să controlezi contractul JSON. Greșeala tipică este @JsonIgnore pe parolă, care împiedică și primirea ei la înregistrare.

38 Mid

Clientul trimite {"nume": "Mouse", "pret": 89, "culoare": "negru"}, iar DTO-ul tău nu are câmpul culoare. Ce se întâmplă? Cum deserializează Jackson un record fără constructor implicit?

Răspuns scurt: În Spring Boot cererea trece: Boot dezactivează FAIL_ON_UNKNOWN_PROPERTIES, deci culoare e ignorat. Un ObjectMapper creat cu new ar arunca UnrecognizedPropertyException. Record-urile se deserializează prin constructorul canonic, potrivind numele componentelor cu cheile JSON; câmpurile lipsă primesc null, 0 sau false.

Comportamentul diferă între Spring Boot și Jackson „simplu”:

  • ObjectMapper-ul din Boot are DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES = false; câmpurile necunoscute sunt ignorate în tăcere. Avantaj: clienții vechi și noi coexistă. Dezavantaj: o greșeală de scriere ("pretul" în loc de "pret") nu dă eroare, iar câmpul primește valoarea implicită;
  • un new ObjectMapper() scris de tine are funcția activă și aruncă Unrecognized field "culoare" (class ProdusNou), not marked as ignorable.

Pentru un API strict poți reactiva verificarea: spring.jackson.deserialization.fail-on-unknown-properties=true.

La record-uri, Jackson (2.12+) folosește constructorul canonic:

JAVA
record ProdusNou(String nume, int pret, boolean promo) { }

Pentru {"nume": "Mouse"} obții ProdusNou[nume=Mouse, pret=0, promo=false]. Componentele primitive lipsă devin 0 și false, fără eroare; de aceea, pentru câmpuri obligatorii, folosești tipuri wrapper (Integer) și @NotNull, ca lipsa să fie detectată de validare.

La clase obișnuite, Jackson are nevoie de un constructor fără argumente și de setter-e, sau de un constructor marcat @JsonCreator cu parametri @JsonProperty. Fără ele apare Cannot construct instance of 'ProdusNou' (no Creators, like default constructor, exist). Numele parametrilor se citesc din bytecode doar cu -parameters (activ în spring-boot-starter-parent).

Ce urmărește intervievatorul: Verifică dacă știi diferențele dintre setările Boot și cele implicite ale bibliotecii. Greșeala tipică este un int pentru un câmp obligatoriu, unde lipsa lui devine 0 fără nicio eroare.

39 Mid

Unde e problema în codul de mai jos și ce primește clientul la GET /categorii/1?

JAVA
@Entity
class Categorie {
    @Id @GeneratedValue Long id;
    String nume;
    @OneToMany(mappedBy = "categorie") List<Produs> produse = new ArrayList<>();
    // getteri
}

@Entity
class Produs {
    @Id @GeneratedValue Long id;
    String nume;
    @ManyToOne Categorie categorie;
    // getteri
}

@GetMapping("/categorii/{id}")
Categorie una(@PathVariable long id) { return repo.findById(id).orElseThrow(); }

Răspuns scurt: Relația bidirecțională face serializarea circulară: categoria are produse, fiecare produs are categoria, care are iar produsele. Jackson intră în recursivitate infinită și răspunsul e 500 cu Could not write JSON: Infinite recursion (StackOverflowError). Soluția: un DTO cu doar datele necesare.

Jackson serializează Categorie: scrie id, nume, apoi produse. Pentru fiecare Produs scrie id, nume, categorie, adică iar obiectul Categorie, cu lista lui de produse, și tot așa. Stiva se termină, iar Jackson aruncă JsonMappingException: Infinite recursion (StackOverflowError). Spring o transformă în HttpMessageNotWritableException și răspunde 500. Uneori clientul primește chiar un început de JSON, trunchiat, pentru că răspunsul începuse să fie scris.

Pe lângă recursivitate, în aplicația reală apar și alte probleme: produse este o colecție leneșă; dacă sesiunea Hibernate e închisă, serializarea aruncă LazyInitializationException, iar dacă e deschisă (open-in-view), declanșează interogări din stratul web.

Soluția recomandată, DTO-uri:

JAVA
record ProdusScurt(long id, String nume) { }
record CategorieDto(long id, String nume, List<ProdusScurt> produse) { }

@Transactional(readOnly = true)
public CategorieDto una(long id) {
    Categorie c = repo.findById(id).orElseThrow(() -> new CategorieNegasitaException(id));
    return new CategorieDto(c.getId(), c.getNume(),
            c.getProduse().stream().map(p -> new ProdusScurt(p.getId(), p.getNume())).toList());
}

Alternativele cu adnotări: @JsonManagedReference pe produse și @JsonBackReference pe categorie (partea „înapoi” nu se serializează), @JsonIgnore pe una din laturi sau @JsonIdentityInfo. Funcționează, dar leagă forma API-ului de modelul de date și sunt ușor de stricat la următoarea relație adăugată.

Ce urmărește intervievatorul: Este un bug foarte frecvent, iar intervievatorul vrea să vadă că recunoști cauza din descriere. Greșeala tipică este să repari cu @JsonIgnore peste tot, fără să separi API-ul de entități.

Eroarea, în practică:Could not write JSON: Infinite recursion

40 Mid

Cum configurezi global serializarea JSON într-o aplicație Spring Boot (format de date, câmpuri null, nume în snake_case) fără să pierzi setările implicite?

Răspuns scurt: Prin proprietăți spring.jackson.* (default-property-inclusion, property-naming-strategy, serialization.*, deserialization.*) sau printr-un bean Jackson2ObjectMapperBuilderCustomizer. Ambele modifică ObjectMapper-ul creat de Boot. Un ObjectMapper propriu, construit cu new, înlocuiește tot și pierde modulele înregistrate.

Boot creează ObjectMapper printr-un Jackson2ObjectMapperBuilder, care înregistrează automat modulele găsite pe classpath (JavaTimeModule, Jdk8Module, ParameterNamesModule) și aplică proprietățile.

Cu proprietăți:

YAML
spring:
  jackson:
    default-property-inclusion: non_null
    property-naming-strategy: SNAKE_CASE
    serialization:
      write-dates-as-timestamps: false
      indent-output: false
    deserialization:
      fail-on-unknown-properties: false
    time-zone: Europe/Bucharest

Cu cod, pentru ce nu se poate exprima prin proprietăți:

JAVA
@Bean
Jackson2ObjectMapperBuilderCustomizer jsonConfig() {
    return b -> b
            .serializerByType(BigDecimal.class, new ToStringSerializer())
            .featuresToEnable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES);
}

Un Module declarat ca bean este și el înregistrat automat (de exemplu un SimpleModule cu serializatori proprii).

Ce să eviți:

  • @Bean ObjectMapper mapper() { return new ObjectMapper(); }: auto-configurarea se retrage, datele LocalDate nu se mai serializează (Java 8 date/time type not supported by default), proprietățile spring.jackson.* nu se mai aplică;
  • @EnableWebMvc într-o aplicație Boot: oprește auto-configurarea MVC, inclusiv convertoarele configurate, iar JSON-ul se schimbă neașteptat;
  • new ObjectMapper() în service-uri: injectezi bean-ul, ca să folosești aceleași reguli peste tot.

Pentru excepții locale, adnotările pe DTO (@JsonFormat, @JsonInclude) au prioritate față de setările globale.

Ce urmărește intervievatorul: Verifică dacă știi să configurezi fără să strici auto-configurarea. Greșeala tipică este un ObjectMapper creat de mână, după care datele încep să apară greșit.

41 Senior

Cum organizezi maparea între entități, modelul de domeniu și DTO-uri într-un proiect mare? Mapare manuală, MapStruct sau altceva?

Răspuns scurt: Maparea stă la granița stratului web, într-un mapper dedicat. Pentru puține DTO-uri, maparea manuală e clară; pentru multe, MapStruct generează cod verificat la compilare. Mapperele bazate pe reflecție ascund greșelile până la rulare.

Întrebarea de fond este unde stă granița dintre straturi.

  • Controller-ul primește un DTO de intrare și întoarce un DTO de ieșire.
  • Service-ul lucrează cu entități sau cu un model de domeniu și primește comenzi clare (CreeazaProdus), nu obiecte HTTP.
  • Maparea DTO-entitate stă într-un mapper dedicat sau în service, la intrare și la ieșire.

Mapare manuală:

JAVA
static ProdusDto laDto(Produs p) {
    return new ProdusDto(p.getId(), p.getNume(), p.getPret(), p.getCategorie().getNume());
}

Avantaje: explicită, ușor de depanat, fără dependențe. Dezavantaj: cod repetitiv și riscul de a uita un câmp nou.

MapStruct:

JAVA
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.ERROR)
interface ProdusMapper {
    @Mapping(target = "categorie", source = "categorie.nume")
    ProdusDto laDto(Produs p);

    @Mapping(target = "id", ignore = true)
    Produs dinCerere(ProdusNou cerere);
}

Generează la compilare o clasă Java obișnuită, rapidă, iar unmappedTargetPolicy = ERROR transformă câmpurile uitate în erori de compilare. E bean Spring, deci se injectează.

Pentru citiri complexe, cea mai eficientă mapare este să nu încarci entitatea deloc: proiecții JPA (SELECT new ProdusDto(...)), care citesc doar coloanele necesare.

Decizia ține de mărimea proiectului și de convențiile echipei. Contează consecvența: același tip de mapare peste tot și teste care verifică JSON-ul public, pentru că maparea este contractul cu clienții.

Ce urmărește intervievatorul: La senior contează argumentele pentru structura proiectului. Greșeala tipică este maparea prin reflecție, care face ca un câmp redenumit să dispară din API fără nicio eroare.

Validare și tratarea erorilor

42 Junior

Cum validezi corpul unei cereri POST în Spring Boot și ce primește clientul dacă datele sunt invalide?

Răspuns scurt: Pui adnotări Bean Validation (@NotBlank, @Size, @Positive) pe câmpurile DTO-ului și @Valid înaintea parametrului @RequestBody. Ai nevoie de spring-boot-starter-validation. La date invalide, Spring aruncă MethodArgumentNotValidException, iar clientul primește 400, fără ca metoda să ruleze.

Validarea se face înainte de apelul metodei, în etapa de rezolvare a argumentelor:

JAVA
record ProdusNou(
        @NotBlank String nume,
        @Size(max = 200) String descriere,
        @NotNull @Positive BigDecimal pret,
        @Min(0) int stoc) { }

@PostMapping("/api/produse")
ResponseEntity<ProdusDto> creeaza(@Valid @RequestBody ProdusNou cerere) {
    ...
}

Condiții ca validarea să funcționeze:

  • dependența spring-boot-starter-validation (din Boot 2.3 nu mai vine cu starter-ul web); fără ea, adnotările se compilează, dar nu sunt verificate;
  • @Valid (sau @Validated) pe parametru; fără el, adnotările din DTO sunt ignorate;
  • importurile din jakarta.validation.constraints (în Boot 3; javax.validation era în Boot 2).

Pentru {"nume": "", "pret": -5} Spring aruncă MethodArgumentNotValidException. Răspunsul implicit este 400 cu JSON-ul standard de eroare, fără detalii despre câmpuri (sau cu errors, dacă activezi server.error.include-binding-errors=always). În practică îl tratezi într-un @RestControllerAdvice și întorci lista de câmpuri:

JSON
{"status":400,"erori":{"nume":"must not be blank","pret":"must be greater than 0"}}

Mesajele implicite vin de la Hibernate Validator, în limba din Locale; le schimbi cu atributul message. Validarea DTO-ului verifică forma datelor; regulile care cer acces la bază (email unic, stoc suficient) stau în service.

Ce urmărește intervievatorul: Este baza oricărui API. Greșeala tipică este să uiți @Valid sau dependența de validare și să crezi că adnotările funcționează singure.

Eroarea, în practică:MethodArgumentNotValidException: Validation failedpackage javax.validation.constraints does not exist

43 Junior

Care dintre valorile null, "", " " și "Ana" trec validarea pentru fiecare dintre @NotNull, @NotEmpty și @NotBlank pe un câmp String nume?

Răspuns scurt: @NotNull respinge doar null. @NotEmpty respinge null și "", dar acceptă " ". @NotBlank respinge null, "" și " ", acceptând doar texte cu cel puțin un caracter care nu e spațiu. Toate acceptă "Ana". Pentru texte obligatorii folosești @NotBlank.

Tabelul complet:

valoare     @NotNull   @NotEmpty   @NotBlank
null        respinge   respinge    respinge
""          acceptă    respinge    respinge
"   "       acceptă    acceptă     respinge
"Ana"       acceptă    acceptă     acceptă

Pe tipuri:

  • @NotNull merge pe orice tip (numere, date, obiecte imbricate, liste);
  • @NotEmpty merge pe String, colecții, Map-uri și tablouri: o listă goală e respinsă;
  • @NotBlank merge doar pe CharSequence. Pus pe un Integer, dă la rulare eroarea HV000030: No validator could be found for constraint 'jakarta.validation.constraints.NotBlank' validating type 'java.lang.Integer'.

Capcane:

  • celelalte constrângeri trec pentru null: @Size(min = 3) și @Email acceptă null, de aceea le combini cu @NotNull sau @NotBlank când câmpul e obligatoriu;
  • pentru numere, un int primitiv nu poate fi null, deci un câmp lipsă din JSON devine 0 și nu e detectat; folosești Integer cu @NotNull;
  • @NotBlank nu elimină spațiile: " Ana " trece și ajunge așa în bază. Normalizarea (trim) o faci explicit, în DTO sau în service.
JAVA
record ClientNou(@NotBlank @Size(max = 60) String nume,
                 @NotBlank @Email String email,
                 @NotNull @Min(18) Integer varsta,
                 @NotEmpty List<@NotBlank String> telefoane) { }

Ce urmărește intervievatorul: Este o întrebare clasică de tip „capcană”. Greșeala tipică este @NotNull pe un text obligatoriu, care lasă să treacă textul gol.

Eroarea, în practică:must not be blankHV000030: No validator could be found

44 Junior

Cum schimbi mesajele de validare implicite (de exemplu „must not be blank”) cu mesaje proprii în română?

Răspuns scurt: Cel mai simplu, cu atributul message: @NotBlank(message = "Numele este obligatoriu"). Pentru mesaje centralizate folosești chei (message = "{produs.nume.obligatoriu}") într-un fișier ValidationMessages.properties, care poate avea și variante pe limbi și parametri ca {min}, {max}.

Mesajele implicite vin de la Hibernate Validator și depind de Locale-ul serverului: „must not be blank”, „size must be between 3 and 20”. Pentru un API cu clienți români, le personalizezi.

Direct în adnotare:

JAVA
record ProdusNou(
        @NotBlank(message = "Numele este obligatoriu") String nume,
        @Size(min = 3, max = 60, message = "Numele are între {min} și {max} caractere") String cod,
        @Positive(message = "Prețul trebuie să fie pozitiv") BigDecimal pret) { }

{min} și {max} sunt înlocuite cu valorile atributelor. Poți folosi și ${validatedValue}, valoarea respinsă (cu grijă la datele sensibile).

Centralizat, în src/main/resources/ValidationMessages.properties:

produs.nume.obligatoriu=Numele produsului este obligatoriu
produs.pret.pozitiv=Prețul trebuie să fie mai mare decât 0
JAVA
@NotBlank(message = "{produs.nume.obligatoriu}") String nume

Variante pe limbi: ValidationMessages_en.properties. Cu configurare suplimentară, validatorul poate folosi MessageSource-ul Spring (messages.properties) și limba din antetul Accept-Language.

Pentru clienți care programează pe baza erorilor (aplicații mobile, frontend), mesajul text nu ajunge: întorci și codul constrângerii (NotBlank, din FieldError.getCode()) sau un cod propriu stabil, iar textul afișat rămâne la latitudinea clientului.

Ce urmărește intervievatorul: Verifică dacă ai construit un API folosit de oameni reali. Greșeala tipică este să scrii același mesaj în zece locuri în loc să folosești chei.

Eroarea, în practică:must not be blankmust be a well-formed email address

45 Junior

Ai o excepție ProdusNegasitException. Ce face @ResponseStatus(HttpStatus.NOT_FOUND) pus pe ea și cum se compară cu ResponseStatusException?

Răspuns scurt: @ResponseStatus(HttpStatus.NOT_FOUND) pe clasa excepției transformă orice aruncare netratată a ei în 404. ResponseStatusException primește statusul și mesajul la aruncare, fără clasă proprie. Pentru erori de domeniu refolosite, clasa proprie e mai clară.

Varianta cu clasă proprie:

JAVA
@ResponseStatus(HttpStatus.NOT_FOUND)
class ProdusNegasitException extends RuntimeException {
    ProdusNegasitException(long id) {
        super("Produsul " + id + " nu există");
    }
}

@GetMapping("/produse/{id}")
ProdusDto unul(@PathVariable long id) {
    return service.gaseste(id).orElseThrow(() -> new ProdusNegasitException(id));
}

ResponseStatusExceptionResolver vede adnotarea și răspunde cu 404. Mesajul apare în corp doar cu server.error.include-message=always; atributul reason al adnotării ar fixa un text, dar ar ignora mesajul excepției.

Varianta fără clasă:

JAVA
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Produsul " + id + " nu există");

Comparație:

  • ResponseStatusException e rapidă pentru cazuri punctuale, dar leagă codul de HTTP; un service care aruncă ResponseStatusException nu mai e independent de stratul web;
  • o excepție de domeniu (ProdusNegasitException, StocInsuficientException) se poate arunca din service, se poate testa și se poate trata unitar într-un @RestControllerAdvice, unde decizi statusul și formatul;
  • @ResponseStatus pe excepție este o variantă intermediară, dar formatul răspunsului rămâne cel implicit.

În Spring 6, ResponseStatusException extinde ErrorResponseException, deci produce ProblemDetail când activezi spring.mvc.problemdetails.enabled.

Ce urmărește intervievatorul: Verifică dacă știi mai multe moduri de a produce un status și consecințele lor asupra straturilor. Greșeala tipică este un service plin de ResponseStatusException.

Eroarea, în practică:ResponseStatusException: 404 NOT_FOUND

46 Junior

Care este diferența dintre un @ExceptionHandler scris în controller și unul scris într-o clasă @RestControllerAdvice?

Răspuns scurt: Un @ExceptionHandler din controller tratează doar excepțiile aruncate de metodele acelui controller. Într-un @RestControllerAdvice se aplică tuturor controllerelor (sau celor filtrate prin basePackages, assignableTypes), deci centralizezi formatul erorilor. Handler-ele locale au prioritate față de cele globale.

@RestControllerAdvice este @ControllerAdvice plus @ResponseBody: valorile întoarse de handler-e devin JSON.

JAVA
record EroareDto(String cod, String mesaj) { }

@RestControllerAdvice
class EroriGlobale {
    @ExceptionHandler(ProdusNegasitException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    EroareDto negasit(ProdusNegasitException e) {
        return new EroareDto("PRODUS_NEGASIT", e.getMessage());
    }

    @ExceptionHandler(StocInsuficientException.class)
    ResponseEntity<EroareDto> stoc(StocInsuficientException e) {
        return ResponseEntity.status(HttpStatus.CONFLICT).body(new EroareDto("STOC_INSUFICIENT", e.getMessage()));
    }
}

Reguli de alegere:

  • un handler din controller câștigă în fața celor din advice, pentru excepțiile acelui controller;
  • între handler-e, Spring alege tipul de excepție cel mai apropiat în ierarhie: pentru ProdusNegasitException câștigă handler-ul ei, nu cel pentru RuntimeException;
  • între mai multe clase advice, ordinea se dă cu @Order;
  • metoda handler poate primi excepția, HttpServletRequest, WebRequest, Locale și poate întoarce obiect, ResponseEntity sau ProblemDetail.

Limite: advice-urile tratează doar excepțiile apărute în Spring MVC (controller, conversie, validare). O excepție dintr-un filtru servlet, inclusiv din Spring Security, nu ajunge la ele; acolo folosești AuthenticationEntryPoint, AccessDeniedHandler sau tratare în filtru.

Pentru o bază comună poți extinde ResponseEntityExceptionHandler, care tratează deja excepțiile standard Spring MVC.

Ce urmărește intervievatorul: Verifică dacă știi să centralizezi tratarea erorilor. Greșeala tipică este să crezi că advice-ul prinde și excepțiile din filtre.

47 Mid

Scrie un handler care, pentru o validare eșuată, întoarce 400 cu lista câmpurilor și a mesajelor, de forma {"erori": {"nume": "...", "pret": "..."}}.

Răspuns scurt: Tratezi MethodArgumentNotValidException într-un @RestControllerAdvice, iei getBindingResult().getFieldErrors() și construiești un Map din getField() și getDefaultMessage(), păstrând primul mesaj pentru fiecare câmp. Folosești LinkedHashMap pentru o ordine stabilă.

Implementarea:

JAVA
record EroriValidare(int status, Map<String, String> erori) { }

@RestControllerAdvice
class ValidareHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    ResponseEntity<EroriValidare> invalid(MethodArgumentNotValidException e) {
        Map<String, String> erori = new LinkedHashMap<>();
        for (FieldError fe : e.getBindingResult().getFieldErrors()) {
            erori.putIfAbsent(fe.getField(), fe.getDefaultMessage());
        }
        e.getBindingResult().getGlobalErrors()
                .forEach(ge -> erori.putIfAbsent(ge.getObjectName(), ge.getDefaultMessage()));
        return ResponseEntity.badRequest().body(new EroriValidare(400, erori));
    }
}

Pentru {"nume": "", "pret": -5}:

JSON
{"status":400,"erori":{"nume":"Numele este obligatoriu","pret":"Prețul trebuie să fie pozitiv"}}

Detalii:

  • un câmp poate avea mai multe erori (@NotBlank și @Size); putIfAbsent păstrează una; dacă vrei toate, folosești Map<String, List<String>>;
  • ordinea erorilor nu e garantată, deci un LinkedHashMap nu sortează după declarare; pentru teste stabile poți sorta cheile;
  • câmpurile imbricate apar cu cale: adresa.oras, linii[0].cantitate;
  • getGlobalErrors() conține erorile la nivel de obiect, de exemplu de la o metodă @AssertTrue.

Alternativ, extinzi ResponseEntityExceptionHandler și suprascrii handleMethodArgumentNotValid; nu poți avea în același timp și propriul @ExceptionHandler pentru aceeași excepție, pentru că Spring oprește pornirea cu Ambiguous @ExceptionHandler method mapped. În Spring 6.1, validarea parametrilor simpli produce altă excepție, HandlerMethodValidationException, pe care o tratezi separat.

Ce urmărește intervievatorul: Este o sarcină tipică de live coding. Greșeala tipică este să întorci e.getMessage(), un text lung și tehnic, în loc de o structură pe câmpuri.

Eroarea, în practică:MethodArgumentNotValidException: Validation failedAmbiguous @ExceptionHandler method mapped for ...

48 Mid

Ce este ProblemDetail și cum îl folosești în Spring Boot 3 pentru erorile unui API?

Răspuns scurt: ProblemDetail este implementarea Spring a formatului standard RFC 9457 (fostul RFC 7807), application/problem+json, cu câmpurile type, title, status, detail, instance și proprietăți proprii. spring.mvc.problemdetails.enabled=true îl activează pentru erorile Spring MVC, iar handler-ele tale îl pot întoarce direct.

Formatul standard evită ca fiecare API să-și inventeze structura de eroare:

JSON
{
  "type": "https://magazin.ro/erori/stoc-insuficient",
  "title": "Stoc insuficient",
  "status": 409,
  "detail": "Produsul 7 mai are 2 bucăți, ai cerut 5",
  "instance": "/api/comenzi",
  "produsId": 7
}

În Spring 6 / Boot 3:

JAVA
@RestControllerAdvice
class Erori {
    @ExceptionHandler(StocInsuficientException.class)
    ProblemDetail stoc(StocInsuficientException e) {
        ProblemDetail pd = ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, e.getMessage());
        pd.setTitle("Stoc insuficient");
        pd.setType(URI.create("https://magazin.ro/erori/stoc-insuficient"));
        pd.setProperty("produsId", e.getProdusId());
        return pd;
    }
}

Spring setează automat Content-Type: application/problem+json și statusul răspunsului din status, iar instance din calea cererii, dacă nu îl setezi tu.

Cu spring.mvc.problemdetails.enabled=true, excepțiile standard (404 pe rută, 405, 400 la validare, 415) produc și ele ProblemDetail, prin ProblemDetailsExceptionHandler. Excepțiile proprii pot extinde ErrorResponseException și vin direct cu ProblemDetail-ul lor.

type ar trebui să fie un URI stabil care identifică tipul erorii (poate duce la documentație); implicit este about:blank. Clienții se bazează pe type și pe proprietățile proprii, nu pe textul din detail.

Ce urmărește intervievatorul: Verifică dacă știi standardul și suportul nativ din Spring 6. Greșeala tipică este să-l confunzi cu formatul vechi {"timestamp","status","error","path"} al lui Boot.

49 Mid

Cum validezi parametrii simpli, de exemplu @RequestParam @Min(1) int pagina sau @PathVariable @Positive long id? Care e diferența dintre @Valid și @Validated?

Răspuns scurt: În Spring 6.1+ constrângerile pe parametri simpli sunt verificate automat și dau HandlerMethodValidationException (400). Înainte trebuia @Validated pe clasă, iar eroarea era ConstraintViolationException, adesea 500. @Valid validează în cascadă; @Validated acceptă grupuri.

Exemplu:

JAVA
@RestController
@Validated          // necesar înainte de Spring 6.1; inofensiv după
class ProdusController {
    @GetMapping("/produse")
    List<ProdusDto> pagina(@RequestParam @Min(1) int pagina,
                           @RequestParam @Max(100) int marime) { ... }
}

Comportament după versiune:

  • Spring 6.0 și Boot 2: cu @Validated pe clasă, un proxy AOP verifică parametrii și aruncă jakarta.validation.ConstraintViolationException; fără handler, clientul primește 500, deci trebuia tratată explicit;
  • Spring 6.1+: validarea e integrată în MVC; pentru ?pagina=0 se aruncă HandlerMethodValidationException cu statusul 400, tratat implicit. Dacă clasa păstrează @Validated, poți ajunge la ambele mecanisme, de aceea se recomandă să alegi unul.

Diferența dintre adnotări:

  • @Valid (Jakarta) marchează un obiect pentru validare, inclusiv în cascadă: @Valid Adresa adresa validează câmpurile adresei, List<@Valid Linie> fiecare element;
  • @Validated (Spring) activează validarea pe metodele unui bean și acceptă grupuri: @Validated(LaCreare.class), ca același DTO să aibă reguli diferite la creare și la actualizare.

Același mecanism de validare a metodelor funcționează și în service-uri: @Validated pe clasă, constrângeri pe parametri. Erorile acolo sunt ConstraintViolationException, pe care le traduci tu în 400.

Ce urmărește intervievatorul: Verifică dacă știi diferențele de versiune, care schimbă statusul primit de client. Greșeala tipică este un 500 în producție la un parametru invalid, pentru că lipsea handler-ul.

50 Mid

Cum validezi un obiect imbricat (adresa unui client), o listă de linii de comandă și o regulă care leagă două câmpuri (data de sfârșit după data de început)?

Răspuns scurt: Pui @Valid pe câmpul imbricat și pe elementele listei (List<@Valid Linie>), altfel constrângerile lor sunt ignorate. Pentru reguli între câmpuri folosești o metodă @AssertTrue în DTO sau o constrângere proprie pe clasă, implementată cu ConstraintValidator.

Validarea nu coboară singură în obiectele imbricate:

JAVA
record Adresa(@NotBlank String oras, @Pattern(regexp = "\\d{6}") String codPostal) { }
record Linie(@Positive long produsId, @Min(1) @Max(50) int cantitate) { }

record ComandaNoua(
        @NotNull @Valid Adresa adresa,
        @NotEmpty List<@Valid Linie> linii,
        @NotNull LocalDate livrareDe,
        @NotNull LocalDate livrarePana) {

    @AssertTrue(message = "Intervalul de livrare este invalid")
    boolean isIntervalValid() {
        return livrareDe == null || livrarePana == null || !livrarePana.isBefore(livrareDe);
    }
}

Observații:

  • fără @Valid pe adresa, un oraș gol trece; @NotNull verifică doar că obiectul există;
  • List<@Valid Linie> (sau @Valid List<Linie>) validează fiecare element; erorile apar cu cale: linii[1].cantitate;
  • metoda @AssertTrue trebuie să fie un getter (is... sau get...) și să tolereze null, pentru că rulează și când celelalte câmpuri sunt invalide; eroarea apare pe proprietatea intervalValid.

Pentru reguli refolosite, o constrângere pe clasă:

JAVA
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = IntervalValidator.class)
@interface IntervalCorect {
    String message() default "Data de sfârșit trebuie să fie după data de început";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

Validatorul implementează ConstraintValidator<IntervalCorect, ComandaNoua> și poate fi bean Spring cu dependențe injectate. Regulile care depind de starea bazei (stoc, unicitate) rămân în service, pentru că pot deveni false între validare și salvare.

Ce urmărește intervievatorul: Verifică dacă știi limitele validării declarative. Greșeala tipică este lipsa lui @Valid pe obiectul imbricat, care lasă date invalide să treacă.

51 Senior

Cum ai proiecta formatul și politica de erori pentru un API folosit de o aplicație web, o aplicație mobilă și parteneri externi?

Răspuns scurt: Un singur format (ideal ProblemDetail), cu cod stabil de eroare, mesaj pentru oameni, detalii pe câmpuri și traceId. Statusuri HTTP corecte, fără stack trace-uri către client, tratare centrală și documentare în OpenAPI.

Principiile, cu argumentul pentru fiecare:

  • un format unic: clienții scriu o singură funcție de tratare a erorilor; ProblemDetail (RFC 9457) e standard și suportat nativ în Spring 6;
  • coduri stabile: type sau o proprietate cod (STOC_INSUFICIENT, EMAIL_FOLOSIT), care nu se schimbă când reformulezi textul; aplicația mobilă afișează mesajele din traducerile ei;
  • status HTTP corect: 4xx pentru greșelile clientului, 5xx doar pentru defecte ale serverului; contează pentru reîncercări automate, alerte și cache;
  • detalii pe câmpuri la validare, cu calea câmpului (linii[1].cantitate);
  • corelare: un traceId în răspuns, același ca în jurnale, ca suportul să găsească problema;
  • fără scurgeri: niciun stack trace, nume de tabele, SQL sau mesaje de excepții interne (include-stacktrace=never, un handler pentru Exception care întoarce un mesaj generic și loghează detaliile);
  • documentare: erorile posibile pentru fiecare endpoint apar în OpenAPI.

Implementare:

JAVA
@RestControllerAdvice
class EroriApi extends ResponseEntityExceptionHandler {
    @ExceptionHandler(EroareDomeniu.class)
    ProblemDetail domeniu(EroareDomeniu e) {
        ProblemDetail pd = ProblemDetail.forStatusAndDetail(e.status(), e.getMessage());
        pd.setType(URI.create("https://api.magazin.ro/erori/" + e.cod()));
        pd.setProperty("cod", e.cod());
        pd.setProperty("traceId", MDC.get("traceId"));
        return pd;
    }

    @ExceptionHandler(Exception.class)
    ProblemDetail neprevazut(Exception e) {
        log.error("Eroare neprevăzută", e);
        return ProblemDetail.forStatusAndDetail(HttpStatus.INTERNAL_SERVER_ERROR, "A apărut o eroare internă");
    }
}

Pentru partenerii externi, schimbările de format sunt schimbări incompatibile și se versionează. Erorile din filtrele de securitate (401, 403) trebuie aduse la același format, prin AuthenticationEntryPoint și AccessDeniedHandler.

Ce urmărește intervievatorul: La senior se verifică gândirea de contract și operare. Greșeala tipică este un format diferit în fiecare controller și mesaje de excepții interne ajunse la client.

52 Senior

Unde validezi regula „emailul clientului trebuie să fie unic”: în DTO, în service sau în baza de date? Ce se întâmplă când două cereri cu același email vin în același timp?

Răspuns scurt: Pe toate trei niveluri, cu roluri diferite: DTO-ul verifică forma (@Email), service-ul verifică existența (existsByEmail) pentru un mesaj prietenos, iar constrângerea UNIQUE din bază este singura garanție reală. Între verificare și salvare poate intra altă cerere, deci tratezi și DataIntegrityViolationException și o traduci în 409.

O verificare în aplicație de tipul „citește, apoi scrie” are o fereastră de concurență:

cererea A: existsByEmail("ana@x.ro") -> false
cererea B: existsByEmail("ana@x.ro") -> false
cererea A: save(...)  -> reușește
cererea B: save(...)  -> al doilea client cu același email

Niciun @Transactional obișnuit nu previne asta: la nivelul de izolare implicit (READ COMMITTED), ambele tranzacții văd că emailul nu există. Doar baza de date poate garanta unicitatea:

JAVA
@Entity
@Table(name = "client", uniqueConstraints = @UniqueConstraint(name = "uk_client_email", columnNames = "email"))
class Client { ... }

Cu migrări (Flyway), constrângerea se scrie în SQL: ALTER TABLE client ADD CONSTRAINT uk_client_email UNIQUE (email); atenție la normalizare: emailurile se salvează cu litere mici, altfel Ana@x.ro și ana@x.ro trec ca diferite.

Service-ul păstrează verificarea, pentru cazul frecvent, cu mesaj clar, și tratează cazul rar de concurență:

JAVA
@Transactional
public ClientDto inregistreaza(ClientNou c) {
    String email = c.email().trim().toLowerCase();
    if (repo.existsByEmail(email)) {
        throw new EmailFolositException(email);
    }
    try {
        return laDto(repo.saveAndFlush(new Client(c.nume(), email)));
    } catch (DataIntegrityViolationException e) {
        throw new EmailFolositException(email);
    }
}

saveAndFlush forțează inserarea în metodă, ca excepția să apară aici și nu la commit, în afara blocului try. EmailFolositException devine 409 într-un handler. O validare „unică” scrisă ca ConstraintValidator cu acces la repository are aceeași fereastră de concurență și nu înlocuiește constrângerea din bază.

Ce urmărește intervievatorul: La senior se verifică înțelegerea concurenței și a garanțiilor reale. Greșeala tipică este să consideri suficient un if (existsByEmail).

Eroarea, în practică:Unique index or primary key violationNULL not allowed for column "NUME"

Configurare, profiluri și logging

Exersează capitolul cu exerciții reale: Curs Spring Boot →
53 Junior

Care e diferența dintre application.properties și application.yml? Ce proprietăți setezi aproape în orice proiect?

Răspuns scurt: Ambele sunt fișiere de configurare citite automat din src/main/resources; diferă doar formatul: perechi cheie=valoare sau YAML ierarhic, cu indentare. Proprietăți uzuale: spring.application.name, server.port, spring.datasource.*, spring.jpa.*, logging.level.*, spring.profiles.active.

Aceeași configurare în ambele formate:

spring.application.name=magazin
server.port=8081
spring.datasource.url=jdbc:postgresql://localhost:5432/magazin
spring.jpa.open-in-view=false
logging.level.ro.magazin=DEBUG
app.produse.pe-pagina=20
YAML
spring:
  application:
    name: magazin
  datasource:
    url: jdbc:postgresql://localhost:5432/magazin
  jpa:
    open-in-view: false
server:
  port: 8081
logging:
  level:
    ro.magazin: DEBUG
app:
  produse:
    pe-pagina: 20

Diferențe practice:

  • YAML evită repetarea prefixelor și e mai lizibil pentru structuri adânci sau liste (- valoare); un singur fișier poate conține mai multe documente separate prin ---, cu spring.config.activate.on-profile;
  • YAML e sensibil la indentare: tab-urile sunt interzise, iar un spațiu greșit mută o proprietate sub alt părinte, fără eroare; valori ca on, no sau 08 pot fi interpretate altfel decât te aștepți, deci pui ghilimele;
  • .properties e mai greu de greșit și se încarcă cu @PropertySource (YAML nu).

Dacă ambele fișiere există, se încarcă ambele, iar pentru aceeași cheie .properties are prioritate. Proprietățile proprii ale aplicației se grupează sub un prefix (app.) și se citesc cu @ConfigurationProperties. IntelliJ și VS Code oferă autocompletare pentru cheile Spring.

Ce urmărește intervievatorul: Verifică familiaritatea cu configurarea de zi cu zi. Greșeala tipică este o indentare greșită în YAML, care face ca o proprietate să fie ignorată fără nicio eroare.

Eroarea, în practică:mapping values are not allowed herefound character '\t' that cannot start any token

54 Junior

Cum citești o proprietate cu @Value, cum îi dai o valoare implicită și ce se întâmplă dacă proprietatea lipsește?

Răspuns scurt: Scrii @Value("${app.reducere}") pe un câmp sau parametru de constructor. Valoarea implicită se dă după două puncte: ${app.reducere:0}. Dacă proprietatea lipsește și nu are valoare implicită, aplicația nu pornește: Could not resolve placeholder 'app.reducere' in value "${app.reducere}".

Exemplu cu injectare prin constructor:

JAVA
@Service
class PretService {
    private final int reducere;
    private final List<String> tari;

    PretService(@Value("${app.reducere:0}") int reducere,
                @Value("${app.livrare.tari:RO,MD}") List<String> tari) {
        this.reducere = reducere;
        this.tari = tari;
    }
}

Detalii:

  • conversia la tip se face automat: int, boolean, Duration (30s), List<String> din text separat prin virgule;
  • o valoare care nu se poate converti (app.reducere=zece) oprește pornirea cu o eroare de conversie (Failed to convert value of type 'java.lang.String' to required type 'int');
  • ${...} caută în toate sursele: fișiere, variabile de mediu, argumente; #{...} este SpEL, altceva;
  • @Value pe un câmp static nu funcționează: Spring injectează doar în instanțe, iar câmpul rămâne null;
  • @Value funcționează doar în bean-uri; într-un obiect creat cu new, câmpul rămâne gol.

Valoarea implicită goală se scrie ${app.titlu:}. Pentru proprietăți obligatorii e de preferat să nu pui valoare implicită: e mai bine ca aplicația să nu pornească decât să ruleze în producție cu o valoare greșită.

Pentru mai mult de două-trei proprietăți înrudite folosești @ConfigurationProperties, care grupează valorile într-un obiect tipizat, validat, cu autocompletare în IDE.

Ce urmărește intervievatorul: Verifică lucrul de bază cu configurarea și mesajul de eroare asociat. Greșeala tipică este @Value pe un câmp static sau într-o clasă creată cu new.

Eroarea, în practică:Could not resolve placeholderFailed to convert value ... to required type 'int'

55 Junior

Ce sunt profilurile Spring, cum activezi profilul dev și cum faci ca un bean să existe doar în producție?

Răspuns scurt: Un profil este un nume de mediu (dev, test, prod) care activează fișiere application-<profil>.properties și bean-uri marcate @Profile. Îl activezi cu spring.profiles.active=dev, cu variabila SPRING_PROFILES_ACTIVE sau cu --spring.profiles.active=dev. Un bean doar pentru producție primește @Profile("prod").

Fișierele se suprapun: application.properties se încarcă mereu, iar application-dev.properties se încarcă peste el doar cu profilul dev; valorile din fișierul profilului câștigă.

# application.properties
app.email.expeditor=noreply@magazin.ro
spring.jpa.show-sql=false

# application-dev.properties
spring.datasource.url=jdbc:h2:mem:magazin
spring.jpa.show-sql=true

Bean-uri pe profil:

JAVA
interface EmailSender { void trimite(String catre, String text); }

@Service
@Profile("prod")
class SmtpEmailSender implements EmailSender { ... }

@Service
@Profile("!prod")
class ConsolaEmailSender implements EmailSender {
    public void trimite(String catre, String text) {
        System.out.println("Email către " + catre + ": " + text);
    }
}

Activare:

BASH
java -jar magazin.jar --spring.profiles.active=prod
SPRING_PROFILES_ACTIVE=prod java -jar magazin.jar

Fără profil activ, Spring folosește profilul default și scrie în jurnal No active profile set, falling back to 1 default profile: "default".

Bune practici:

  • profilurile descriu medii, nu funcționalități; pentru a porni sau opri o funcție folosești proprietăți și @ConditionalOnProperty;
  • în testele de integrare, @ActiveProfiles("test");
  • secretele de producție nu stau în application-prod.properties din repository, ci vin din variabile de mediu sau dintr-un seif;
  • grupuri de profiluri: spring.profiles.group.prod=prod-db,prod-email.

Ce urmărește intervievatorul: Verifică dacă știi să rulezi aceeași aplicație în medii diferite. Greșeala tipică este să pui parolele de producție în fișierul profilului din git.

Eroarea, în practică:No active profile set, falling back to default

56 Junior

Aceeași proprietate server.port este setată în application.properties, ca variabilă de mediu SERVER_PORT și ca argument --server.port=9090. Pe ce port pornește aplicația și de ce?

Răspuns scurt: Pe 9090. Spring Boot are o ordine de prioritate a surselor: argumentele din linia de comandă bat proprietățile de sistem Java, care bat variabilele de mediu, care bat fișierele de configurare (cele din afara jar-ului înaintea celor din jar, cele de profil înaintea celor generale).

Ordinea simplificată, de la prioritate mare la mică:

  • proprietăți din teste (@SpringBootTest(properties = ...), @DynamicPropertySource);
  • argumente din linia de comandă: --server.port=9090;
  • SPRING_APPLICATION_JSON;
  • proprietăți de sistem Java: -Dserver.port=9091;
  • variabile de mediu: SERVER_PORT=9092;
  • fișiere de profil din afara jar-ului, apoi din jar (application-prod.properties);
  • fișiere generale din afara jar-ului (./config/application.properties, ./application.properties), apoi din jar;
  • valori implicite (@Value("${x:implicit}"), valorile din cod).

Ideea: fișierul din jar conține valorile implicite, iar mediul de rulare le suprascrie fără să reconstruiești aplicația.

Relaxed binding permite ca variabila de mediu să aibă alt format decât cheia: SERVER_PORT se potrivește cu server.port, SPRING_DATASOURCE_URL cu spring.datasource.url, APP_PRODUSE_PEPAGINA cu app.produse.pe-pagina. Regula pentru variabile de mediu: litere mari, punctele devin _, liniuțele se elimină, iar indicii de listă se scriu APP_TARI_0_.

BASH
SERVER_PORT=9092 java -jar magazin.jar --server.port=9090
# Tomcat started on port 9090 (http)

Când nu știi de unde vine o valoare, endpoint-ul /actuator/env (protejat, nu public) arată fiecare proprietate și sursa ei.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum se configurează aceeași aplicație în medii diferite. Greșeala tipică este să crezi că fișierul din jar câștigă și să reconstruiești aplicația pentru fiecare mediu.

Eroarea, în practică:Port 8080 was already in use

57 Junior

Cum scrii jurnale într-o aplicație Spring Boot și cum schimbi nivelul de logging doar pentru pachetul tău sau pentru SQL-ul generat de Hibernate?

Răspuns scurt: Folosești SLF4J (LoggerFactory.getLogger(X.class)), cu Logback în spate, configurat de Boot. Nivelurile se setează prin proprietăți: logging.level.ro.magazin=DEBUG, logging.level.org.hibernate.SQL=DEBUG. Mesajele folosesc {} în loc de concatenare, iar excepția se dă ca ultim argument.

Boot configurează implicit Logback, cu ieșire în consolă și nivelul INFO pentru tot.

JAVA
@Service
class ComandaService {
    private static final Logger log = LoggerFactory.getLogger(ComandaService.class);

    public void plaseaza(Comanda c) {
        log.info("Plasez comanda {} pentru clientul {}", c.getId(), c.getClientId());
        try {
            plati.incaseaza(c);
        } catch (PlataRespinsaException e) {
            log.warn("Plata respinsă pentru comanda {}", c.getId(), e);
            throw e;
        }
        log.debug("Detalii comandă: {}", c);
    }
}

De ce {}: mesajul se construiește doar dacă nivelul este activ; log.debug("..." + c) ar apela toString() mereu. Excepția ca ultim argument (fără {} pentru ea) produce stack trace-ul complet în jurnal.

Configurare:

logging.level.root=INFO
logging.level.ro.magazin=DEBUG
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.orm.jdbc.bind=TRACE
logging.file.name=logs/magazin.log

org.hibernate.SQL afișează interogările, iar org.hibernate.orm.jdbc.bind (Hibernate 6) valorile parametrilor. Le preferi lui spring.jpa.show-sql=true, care scrie direct în consolă, ocolind sistemul de logging.

Niveluri: TRACE, DEBUG, INFO, WARN, ERROR. În producție lași INFO, iar cu Actuator poți schimba nivelul la rulare (POST /actuator/loggers/ro.magazin) pentru depanare. Pentru agregare (ELK, Loki), Boot 3.4+ are jurnale structurate în JSON (logging.structured.format.console=ecs). Nu scrie niciodată parole, token-uri sau date personale complete în jurnale.

Ce urmărește intervievatorul: Verifică obiceiuri care contează în producție. Greșeala tipică este System.out.println sau concatenarea în mesajele de debug.

58 Mid

Când folosești @ConfigurationProperties în loc de @Value? Scrie o clasă de proprietăți pentru app.plati.*, cu validare.

Răspuns scurt: @ConfigurationProperties leagă un grup de proprietăți cu un prefix comun de un obiect tipizat (record sau clasă), cu relaxed binding, liste, map-uri, obiecte imbricate, validare la pornire și metadate pentru IDE. @Value rămâne pentru valori izolate. Activezi clasa cu @EnableConfigurationProperties sau @ConfigurationPropertiesScan.

Configurarea:

YAML
app:
  plati:
    url: https://plati.exemplu.ro
    timeout: 5s
    max-reincercari: 3
    monede: [RON, EUR]
    comision:
      procent: 1.5
      minim: 2.00

Clasa de proprietăți, ca record imuabil:

JAVA
@Validated
@ConfigurationProperties(prefix = "app.plati")
record PlatiProperties(
        @NotNull URI url,
        @NotNull Duration timeout,
        @Min(0) @Max(10) int maxReincercari,
        @NotEmpty List<String> monede,
        @Valid Comision comision) {

    record Comision(@DecimalMin("0") BigDecimal procent, BigDecimal minim) { }
}

@SpringBootApplication
@ConfigurationPropertiesScan
class MagazinApplication { ... }

Folosire: o injectezi ca pe orice bean, PlataClient(PlatiProperties props).

Avantaje față de @Value:

  • un singur loc pentru toate setările unei funcționalități, cu tipuri (Duration, URI, BigDecimal, enum-uri);
  • max-reincercari se leagă de maxReincercari (kebab-case recomandat în fișiere);
  • validare la pornire: app.plati.max-reincercari=20 oprește aplicația cu Binding to target ... failed și secțiunile Property, Value, Origin, Reason, nu o eroare în timpul unei plăți;
  • cu spring-boot-configuration-processor, IDE-ul oferă autocompletare și documentare.

@Value rămâne potrivit pentru o valoare izolată sau pentru expresii SpEL, pe care @ConfigurationProperties nu le suportă. Prefixul trebuie scris în forma canonică (litere mici, cu -), altfel pornirea eșuează cu Configuration property name 'appPlati' is not valid.

Ce urmărește intervievatorul: Verifică dacă știi să organizezi configurarea unei aplicații reale. Greșeala tipică este douăzeci de @Value împrăștiate prin cod, fără validare.

Eroarea, în practică:Binding to target ... failedFailed to bind properties ... to Duration

59 Mid

Vrei să poți porni și opri o funcționalitate (de exemplu un nou calcul de transport) din configurare, fără profiluri noi. Cum folosești @ConditionalOnProperty și @ConditionalOnMissingBean?

Răspuns scurt: Pui @ConditionalOnProperty(name = "app.transport.nou", havingValue = "true") pe bean-ul nou și o variantă implicită marcată matchIfMissing = true sau @ConditionalOnMissingBean. Decizia se ia la pornire: ca să schimbi comportamentul trebuie repornire; pentru schimbări la rulare folosești un serviciu de feature flags.

Exemplu cu două implementări:

JAVA
interface CalculTransport { BigDecimal cost(Comanda c); }

@Configuration
class TransportConfig {
    @Bean
    @ConditionalOnProperty(name = "app.transport.nou", havingValue = "true")
    CalculTransport transportNou() {
        return c -> c.getTotal().compareTo(new BigDecimal("200")) >= 0 ? BigDecimal.ZERO : new BigDecimal("15");
    }

    @Bean
    @ConditionalOnMissingBean
    CalculTransport transportClasic() {
        return c -> new BigDecimal("20");
    }
}

Cu app.transport.nou=true se creează transportNou, iar transportClasic se retrage pentru că există deja un bean de tipul CalculTransport. Fără proprietate, condiția primului pică și rămâne varianta clasică.

Detalii:

  • havingValue compară textul; fără el, condiția trece pentru orice valoare în afară de false;
  • matchIfMissing = true face ca bean-ul să existe și când proprietatea lipsește;
  • @ConditionalOnMissingBean e evaluat în ordinea înregistrării bean-urilor; e sigur în auto-configurări și în aceeași clasă @Configuration, dar fragil între clase scanate diferit, unde ordinea nu e garantată;
  • raportul --debug arată de ce o condiție a trecut sau nu.

Aceasta este o comutare la pornire. Pentru lansări treptate (10% din utilizatori), oprire de urgență fără repornire sau decizii per utilizator, folosești un sistem de feature flags (Unleash, LaunchDarkly, OpenFeature) sau proprietăți reîncărcabile, cu codul care verifică flag-ul la fiecare cerere.

Ce urmărește intervievatorul: Verifică dacă știi mecanismul condițiilor dincolo de profiluri. Greșeala tipică este un profil nou pentru fiecare funcționalitate, care duce la combinații greu de urmărit.

Eroarea, în practică:not loaded because @ConditionalOnProperty

60 Mid

Unde ții parolele bazei de date, cheile API și secretul JWT ale unei aplicații Spring Boot? Ce nu faci niciodată?

Răspuns scurt: Nu le pui în application.properties din repository. Le dai din mediu: variabile de mediu (SPRING_DATASOURCE_PASSWORD), secrete Kubernetes montate ca fișiere sau variabile, un seif (HashiCorp Vault, AWS Secrets Manager) prin spring.config.import. În fișier rămâne doar referința, de exemplu ${DB_PASSWORD}.

Configurarea din repository descrie forma, mediul dă valorile:

spring.datasource.url=${DB_URL:jdbc:postgresql://localhost:5432/magazin}
spring.datasource.username=${DB_USER:magazin}
spring.datasource.password=${DB_PASSWORD}
app.jwt.secret=${JWT_SECRET}

Fără variabila DB_PASSWORD, aplicația nu pornește, ceea ce e preferabil unei parole implicite.

Surse uzuale:

  • variabile de mediu, setate de platformă (Docker Compose, Kubernetes, CI);
  • Kubernetes Secrets montate ca fișiere și citite cu spring.config.import=optional:configtree:/etc/secrete/; fiecare fișier devine o proprietate;
  • un seif: spring.config.import=vault:// cu Spring Cloud Vault, sau AWS Secrets Manager, Azure Key Vault; oferă rotire, audit și acces controlat;
  • pentru dezvoltare locală, un fișier ignorat de git (application-local.properties în .gitignore) sau un .env.

Ce nu faci:

  • secrete în git, nici în profilul prod; istoricul păstrează parola chiar după ștergere, iar o scurgere înseamnă rotirea tuturor cheilor;
  • secrete în jurnale: endpoint-urile Actuator /env și /configprops maschează valorile cheilor care conțin password, secret, key, token, dar nu le expui public oricum;
  • același secret în toate mediile.

Bonus: în CI, un scanner de secrete (gitleaks) blochează commit-urile care conțin chei.

Ce urmărește intervievatorul: Verifică maturitatea în operare și securitate. Greșeala tipică este parola de producție scrisă în fișierul de profil din repository.

61 Senior

Ai douăzeci de microservicii care împart o parte din configurare. Ce variante ai pentru configurare centralizată și cum schimbi o valoare fără să redeployezi toate serviciile?

Răspuns scurt: Variante: Spring Cloud Config Server (configurare în git, citită de servicii cu spring.config.import=configserver:), ConfigMap-uri și Secret-e Kubernetes, sau servicii ca Consul. Schimbarea la rulare se face cu @RefreshScope sau reîncărcarea @ConfigurationProperties prin /actuator/refresh sau Spring Cloud Bus, dar multe echipe preferă repornirea controlată.

Opțiunile principale:

  • Spring Cloud Config Server: un serviciu care servește configurarea dintr-un repository git (application.yml comun, comenzi.yml, comenzi-prod.yml). Clienții o citesc la pornire:
spring.application.name=comenzi
spring.config.import=optional:configserver:http://config:8888

Avantaje: istoric și review prin git, ierarhie comun, serviciu, profil. Dezavantaje: încă un serviciu critic (dacă nu răspunde la pornire, serviciile nu pornesc fără optional:), iar secretele cer criptare sau un seif;

  • Kubernetes ConfigMap și Secret: configurarea stă lângă deployment, versionată cu manifestele (GitOps); serviciile o citesc ca variabile de mediu sau fișiere; nu e nevoie de server suplimentar;
  • Consul / etcd / AWS AppConfig: stocuri cheie-valoare cu notificări la schimbare.

Schimbarea la rulare:

JAVA
@RefreshScope
@RestController
class PromoController {
    @Value("${app.promo.text}") String text;
}

POST /actuator/refresh recitește sursele; bean-urile @RefreshScope sunt recreate, iar @ConfigurationProperties sunt relegate. Spring Cloud Bus propagă evenimentul la toate instanțele printr-un broker.

Riscuri: instanțe cu configurări diferite pentru o perioadă, bean-uri recreate în mijlocul unei cereri, schimbări netestate aplicate direct în producție. De aceea multe echipe tratează configurarea ca pe cod: o schimbare trece prin review și pipeline, iar serviciile sunt repornite treptat (rolling restart), cu verificări de sănătate. Pentru valori care chiar trebuie schimbate des (limite, flag-uri), un serviciu dedicat de feature flags e mai potrivit.

Ce urmărește intervievatorul: La senior se verifică echilibrul dintre flexibilitate și siguranța operării. Greșeala tipică este reîncărcarea la cald peste tot, fără să te gândești la consistența dintre instanțe.

Spring Data JPA și tranzacții

62 Junior

Ce primești când scrii interface ProdusRepository extends JpaRepository<Produs, Long> {}? Cine implementează interfața?

Răspuns scurt: Primești operațiile CRUD gata făcute: save, saveAll, findById, findAll (cu Sort și Pageable), existsById, count, deleteById, delete, flush, saveAndFlush. Spring Data creează la pornire o implementare (un proxy bazat pe SimpleJpaRepository), pe care o injectezi ca bean.

Nu scrii nicio clasă: Spring Data JPA detectează interfețele care extind Repository și generează la pornire câte un bean care le implementează.

JAVA
@Entity
class Produs {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nume;
    private BigDecimal pret;
    protected Produs() { }
    // constructori, getteri
}

interface ProdusRepository extends JpaRepository<Produs, Long> {
    List<Produs> findByPretLessThan(BigDecimal max);
}

Ierarhia: Repository (marcaj) → CrudRepository (CRUD de bază) → PagingAndSortingRepository → ListCrudRepository / ListPagingAndSortingRepository (întorc List în loc de Iterable, din Spring Data 3) → JpaRepository (plus flush, saveAndFlush, deleteAllInBatch, getReferenceById).

Detalii utile:

  • findById întoarce Optional<Produs>; nu folosi .get() fără verificare, ci orElseThrow(() -> new ProdusNegasitException(id));
  • save întoarce entitatea salvată (cu id-ul generat); folosește valoarea întoarsă, nu obiectul trimis, pentru că la entități existente se face merge și se întoarce altă instanță;
  • metodele implementării implicite sunt deja tranzacționale (readOnly pentru citiri);
  • getReferenceById nu citește din bază, ci întoarce un proxy; util când ai nevoie doar de o referință pentru o relație.

Pentru a limita ce expui, poți extinde direct Repository<Produs, Long> și declara doar metodele de care ai nevoie, de exemplu fără deleteAll.

Ce urmărește intervievatorul: Verifică dacă știi ce oferă abstracția și unde se termină. Greșeala tipică este findById(id).get(), care aruncă NoSuchElementException și dă 500.

Eroarea, în practică:NoSuchElementException: No value presentThe given id must not be null

63 Junior

Ce condiții trebuie să îndeplinească o clasă @Entity? Care e diferența dintre GenerationType.IDENTITY și GenerationType.SEQUENCE?

Răspuns scurt: O entitate are @Entity, un câmp @Id, un constructor fără argumente (cel puțin protected) și nu este final. IDENTITY lasă baza să genereze id-ul la inserare (coloană auto-increment), deci Hibernate trebuie să insereze imediat; SEQUENCE ia id-urile dintr-o secvență, permite pre-alocare și inserări în lot.

Cerințele JPA pentru o entitate:

  • adnotarea @Entity (din jakarta.persistence în Boot 3);
  • un identificator @Id; fără el pornirea eșuează cu No identifier specified for entity;
  • un constructor fără argumente, public sau protected, pentru că Hibernate creează obiectele prin reflecție înainte să completeze câmpurile;
  • clasa și metodele nu sunt final, ca Hibernate să poată crea proxy-uri pentru încărcarea leneșă;
  • un record nu poate fi entitate (e final și imuabil), dar este foarte bun pentru DTO-uri și proiecții.
JAVA
@Entity
@Table(name = "produs")
public class Produs {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "produs_seq")
    @SequenceGenerator(name = "produs_seq", sequenceName = "produs_seq", allocationSize = 50)
    private Long id;

    @Column(nullable = false, length = 120)
    private String nume;

    protected Produs() { }
    public Produs(String nume) { this.nume = nume; }
}

Strategiile:

  • IDENTITY: coloană GENERATED AS IDENTITY sau AUTO_INCREMENT; id-ul se află doar după INSERT, deci Hibernate execută inserarea imediat la persist și nu poate grupa inserările în loturi JDBC;
  • SEQUENCE: Hibernate cere valori din secvență, cu allocationSize le rezervă în avans (o interogare la 50 de id-uri) și poate amâna inserările până la flush, cu batching. E preferată în PostgreSQL și Oracle;
  • AUTO: lasă alegerea furnizorului, care în Hibernate 6 alege de obicei secvența;
  • UUID: id-uri generate în aplicație, utile în sisteme distribuite, cu dezavantaje la indexare.

Folosește tipuri wrapper (Long) pentru id: null înseamnă „entitate nouă” pentru Spring Data.

Ce urmărește intervievatorul: Verifică dacă știi regulile pe care Hibernate le impune modelului. Greșeala tipică este o entitate fără constructor implicit sau final, care pică la pornire sau la încărcarea leneșă.

Eroarea, în practică:Not a managed type: class ProdusNo identifier specified for entity

64 Junior

Ce interogare execută metoda de mai jos și ce întoarce pentru o categorie fără produse?

JAVA
List<Produs> findByCategorieNumeAndPretLessThanEqualOrderByPretDesc(String categorie, BigDecimal pretMaxim);

Răspuns scurt: Spring Data generează JPQL din numele metodei: produsele a căror categorie are numele dat și prețul cel mult pretMaxim, ordonate descrescător după preț, cu un JOIN spre categorie. Pentru o categorie fără produse întoarce o listă goală, nu null.

Numele se citește pe bucăți:

  • findBy: interogare de citire;
  • CategorieNume: proprietatea categorie (o relație @ManyToOne), apoi câmpul ei nume; Spring Data traversează relația;
  • And: a doua condiție;
  • PretLessThanEqual: pret <= ?;
  • OrderByPretDesc: sortare.

JPQL-ul echivalent:

SQL
SELECT p FROM Produs p JOIN p.categorie c
WHERE c.nume = ?1 AND p.pret <= ?2
ORDER BY p.pret DESC

Rezultatul pentru zero rânduri este o listă goală; un tip de retur Optional<Produs> ar întoarce Optional.empty(), iar unul Produs ar întoarce null. Dacă metoda întoarce o singură entitate și găsește două, apare IncorrectResultSizeDataAccessException: Query did not return a unique result.

Alte cuvinte-cheie utile: Containing, StartingWith, IgnoreCase, Between, In, IsNull, True, Before/After, Top3/First, countBy, existsBy, deleteBy.

Numele metodei este validat la pornire: o greșeală de scriere (findByNumme) oprește aplicația cu No property 'numme' found for type 'Produs'. Asta e un avantaj, eroarea apare devreme.

Limita practică este lizibilitatea. Dincolo de două-trei condiții, numele devine greu de citit; atunci treci la @Query cu JPQL, care poate avea și un nume scurt de metodă (produseIeftineDinCategorie).

Ce urmărește intervievatorul: Verifică dacă știi să citești convențiile Spring Data. Greșeala tipică este să crezi că o listă fără rezultate este null.

Eroarea, în practică:No property 'x' found for type 'Produs'No property 'contain' found for type 'String'

65 Junior

Când folosești @Query și care e diferența dintre JPQL și o interogare nativă SQL? Cum dai parametrii?

Răspuns scurt: Când metoda derivată ar avea un nume prea lung sau ai nevoie de JOIN-uri, agregări, proiecții. JPQL lucrează cu entități și câmpuri Java; SQL-ul nativ (nativeQuery = true) cu tabele și coloane. Parametrii se dau cu :nume și @Param.

JPQL, pe modelul de obiecte:

JAVA
interface ComandaRepository extends JpaRepository<Comanda, Long> {
    @Query("""
           SELECT c FROM Comanda c
           WHERE c.client.email = :email AND c.total >= :minim
           ORDER BY c.data DESC
           """)
    List<Comanda> comenziMari(@Param("email") String email, @Param("minim") BigDecimal minim);

    @Query("SELECT COUNT(c) FROM Comanda c WHERE c.stare = :stare")
    long numara(@Param("stare") StareComanda stare);
}

Observă: Comanda este numele entității, client.email navighează o relație, stare este un enum Java. Interogarea e validată la pornire; un câmp greșit oprește aplicația (Could not resolve attribute), iar un nume de tabel în loc de entitate dă eroarea că entitatea nu e cunoscută.

SQL nativ:

JAVA
@Query(value = "SELECT * FROM comanda WHERE total > :minim LIMIT 10", nativeQuery = true)
List<Comanda> topComenzi(@Param("minim") BigDecimal minim);

Îl folosești pentru funcții specifice (JSONB în PostgreSQL, ferestre analitice, WITH RECURSIVE), cu prețul portabilității și al lipsei validării la pornire.

Parametri:

  • numiți: :email cu @Param("email") (sau fără @Param, dacă compilezi cu -parameters);
  • poziționali: ?1, ?2;
  • niciodată prin concatenare de text: parametrii previn SQL injection.

Pentru modificări în masă (UPDATE, DELETE) ai nevoie de @Modifying și de o tranzacție.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre modelul de obiecte și schema bazei. Greșeala tipică este să scrii numele tabelului într-o interogare JPQL.

Eroarea, în practică:Could not resolve attribute 'x' of 'Produs'Could not resolve root entity 'produse'

66 Junior

Ce face proprietatea spring.jpa.hibernate.ddl-auto și ce valoare folosești în producție?

Răspuns scurt: Controlează ce face Hibernate cu schema la pornire: none, validate, update, create, create-drop. În producție folosești validate sau none, iar schema o gestionezi cu migrări versionate (Flyway sau Liquibase). update nu șterge coloane, nu migrează date și poate produce scheme imprevizibile.

Valorile:

  • create-drop: creează schema la pornire și o șterge la oprire; implicit pentru baze în memorie (H2) fără migrări; util în teste;
  • create: șterge și recreează schema la fiecare pornire, cu pierderea datelor;
  • update: adaugă tabelele și coloanele lipsă; nu șterge, nu redenumește, nu schimbă tipuri și nu mută date;
  • validate: verifică dacă schema existentă se potrivește cu entitățile și oprește pornirea dacă nu;
  • none: nu face nimic (implicit pentru baze reale).

De ce nu update în producție:

  • redenumirea unui câmp creează o coloană nouă, goală, iar cea veche rămâne cu datele;
  • nu ai istoric al schimbărilor și nu le poți revizui la code review;
  • medii diferite ajung la scheme diferite, în funcție de ordinea versiunilor rulate.

Cu Flyway:

src/main/resources/db/migration/V1__creare_produs.sql
src/main/resources/db/migration/V2__adauga_stoc.sql
SQL
-- V2__adauga_stoc.sql
ALTER TABLE produs ADD COLUMN stoc INT NOT NULL DEFAULT 0;

Boot rulează migrările la pornire, înainte de JPA, și le înregistrează în tabela flyway_schema_history; o migrare deja rulată nu se mai modifică, ci se adaugă una nouă. Combinat cu ddl-auto=validate, ai și siguranța că entitățile corespund schemei.

Pentru generarea primei migrări poți folosi DDL-ul produs de Hibernate ca punct de plecare, dar îl revizuiești manual (indexuri, constrângeri cu nume).

Ce urmărește intervievatorul: Verifică dacă ai lucrat cu o bază reală, nu doar cu H2 în memorie. Greșeala tipică este ddl-auto=update în producție.

Eroarea, în practică:Error executing DDL "create table order"

67 Junior

Pui un fișier data.sql cu INSERT-uri în src/main/resources, dar la pornire primești eroarea că tabela produs nu există. De ce și cum repari?

Răspuns scurt: Implicit, Spring Boot rulează schema.sql și data.sql înainte ca Hibernate să creeze tabelele din entități, deci INSERT-ul nu găsește tabela. Repari cu spring.jpa.defer-datasource-initialization=true (scripturile rulează după Hibernate) sau creezi schema chiar tu, cu schema.sql ori cu migrări Flyway.

Ordinea implicită, din Boot 2.5 încoace: inițializarea bazei prin scripturi rulează înaintea EntityManagerFactory, adică înaintea lui ddl-auto. Cu o bază H2 goală, data.sql încearcă să insereze într-o tabelă care încă nu există, iar pornirea eșuează cu o eroare de tipul Table "PRODUS" not found.

Soluții:

spring.jpa.defer-datasource-initialization=true

Acum Hibernate creează schema, apoi rulează data.sql. E potrivit pentru demo-uri și teste.

Alternativ, scrii schema singur în schema.sql și oprești generarea Hibernate (ddl-auto=none), sau, varianta pentru proiecte reale, folosești Flyway, cu datele inițiale într-o migrare.

Alte capcane frecvente:

  • scripturile rulează automat doar pentru baze încorporate (H2, HSQLDB); pentru PostgreSQL ai nevoie de spring.sql.init.mode=always;
  • numele tabelelor și coloanelor sunt cele generate de Hibernate, în snake_case: câmpul pretUnitar devine coloana pret_unitar, relația categorie devine categorie_id;
  • dacă inserezi id-uri explicite și folosești IDENTITY sau secvențe, contorul nu știe de ele, iar următorul save poate încerca un id deja folosit (eroare de cheie primară duplicată); fie nu dai id-uri, fie resetezi secvența;
  • data.sql rulează la fiecare pornire, deci cu o bază persistentă dublează datele.
SQL
INSERT INTO produs (nume, pret, categorie_id) VALUES ('Mouse', 89.00, 1), ('Tastatură', 199.00, 1);

Ce urmărește intervievatorul: Este o eroare clasică la primul proiect cu JPA. Greșeala tipică este să crezi că problema e numele tabelului, nu ordinea inițializării.

Eroarea, în practică:Table "PRODUSE" not foundColumn "X" not found

68 Junior

Ce întoarce endpoint-ul de mai jos pentru GET /produse?page=1&size=2&sort=pret,desc dacă în bază sunt cinci produse? Ce conține obiectul Page?

JAVA
@GetMapping("/produse")
Page<Produs> pagina(Pageable pageable) {
    return repo.findAll(pageable);
}

Răspuns scurt: Spring construiește Pageable din parametri: pagina a doua (numerotarea începe de la 0), câte două elemente, sortat descrescător după preț. Întoarce produsele 3 și 4 în ordinea prețului, plus metadate: totalElements 5, totalPages 3, number 1, size 2. Repository-ul execută două interogări: datele și COUNT.

Parametrii standard sunt page (de la 0), size și sort (camp,asc|desc, se poate repeta). Spring Data execută:

SQL
SELECT ... FROM produs ORDER BY pret DESC LIMIT 2 OFFSET 2;
SELECT COUNT(*) FROM produs;

Page<T> conține getContent() (elementele paginii), getTotalElements(), getTotalPages(), getNumber(), getSize(), isFirst(), isLast(), hasNext().

Ce să îmbunătățești în codul din întrebare:

  • nu întorci Page<Produs> direct: serializarea unei implementări PageImpl dă un JSON cu multe câmpuri interne, iar Spring Data 3.3 afișează chiar un avertisment că structura nu e garantată stabilă; folosești un DTO propriu sau @EnableSpringDataWebSupport(pageSerializationMode = VIA_DTO);
  • nu expui entitatea, ci un DTO: repo.findAll(pageable).map(this::laDto);
  • limitezi dimensiunea (spring.data.web.pageable.max-page-size=100) și câmpurile de sortare permise, altfel un client cere size=100000 sau sortează după o coloană fără index;
  • sort=pretul (câmp inexistent) aruncă PropertyReferenceException, adică 500 fără tratare, deci validezi sau tratezi excepția.
JAVA
record PaginaDto<T>(List<T> elemente, int pagina, long total, int totalPagini) { }

Pentru tabele foarte mari, OFFSET devine lent la pagini îndepărtate și COUNT costă; atunci folosești Slice (fără numărare) sau paginare după cheie (WHERE id > :ultimId).

Ce urmărește intervievatorul: Verifică dacă știi să implementezi corect paginarea și ce costă ea. Greșeala tipică este să crezi că paginile încep de la 1 și să expui Page<Entitate> direct.

Eroarea, în practică:Invalid value 'x' for orders givenPage size must not be less than one

69 Mid

De ce, în codul de mai jos, produsul este salvat, dar coloana categorie_id rămâne NULL?

JAVA
@Entity class Categorie {
    @Id @GeneratedValue Long id;
    @OneToMany(mappedBy = "categorie", cascade = CascadeType.ALL)
    List<Produs> produse = new ArrayList<>();
}
@Entity class Produs {
    @Id @GeneratedValue Long id;
    @ManyToOne Categorie categorie;
}

Categorie c = new Categorie();
c.produse.add(new Produs());
categorieRepo.save(c);

Răspuns scurt: Partea care deține relația (owner) este Produs.categorie, cea cu cheia străină; mappedBy marchează Categorie.produse ca latură inversă, pe care Hibernate o ignoră la scrierea cheii. Produsul e salvat prin cascadă, dar produs.categorie e null. Trebuie setate ambele laturi, ideal printr-o metodă adaugaProdus.

Într-o relație bidirecțională, o singură latură controlează coloana din bază:

  • @ManyToOne Categorie categorie din Produs este owner-ul: corespunde coloanei categorie_id;
  • @OneToMany(mappedBy = "categorie") spune: „relația aceasta este descrisă de câmpul categorie din Produs”; lista e doar o oglindă în memorie.

În cod, lista categoriei conține produsul, deci cascade = ALL îl salvează. Dar Hibernate scrie categorie_id din produs.categorie, care e null. Rezultatul: un produs orfan.

Reparația, cu o metodă care ține ambele laturi sincronizate:

JAVA
@Entity
class Categorie {
    @OneToMany(mappedBy = "categorie", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Produs> produse = new ArrayList<>();

    public void adaugaProdus(Produs p) {
        produse.add(p);
        p.setCategorie(this);
    }

    public void scoateProdus(Produs p) {
        produse.remove(p);
        p.setCategorie(null);
    }
}

Reguli practice:

  • la @OneToMany + @ManyToOne, owner-ul este întotdeauna latura @ManyToOne;
  • la @ManyToMany, alegi tu owner-ul; cealaltă latură primește mappedBy;
  • un @OneToMany fără mappedBy (unidirecțional) creează implicit o tabelă de legătură, rar ce îți dorești; folosește @JoinColumn.

De multe ori relația bidirecțională nici nu e necesară: un @ManyToOne simplu, plus o interogare findByCategorieId când ai nevoie de listă, e mai ușor de întreținut.

Ce urmărește intervievatorul: Verifică înțelegerea reală a mapărilor JPA, cu un bug pe care îl fac mulți. Greșeala tipică este să adaugi doar în listă și să crezi că cascade rezolvă și cheia străină.

Eroarea, în practică:mappedBy reference an unknown target entity property

70 Mid

Ce fac cascade = CascadeType.ALL și orphanRemoval = true pe o relație @OneToMany? Când nu ar trebui să folosești cascada?

Răspuns scurt: Cascada propagă operațiile (persist, merge, remove) de la părinte la copii: salvezi comanda, se salvează și liniile. orphanRemoval șterge din bază un copil scos din colecția părintelui. Le folosești pentru compoziție (comandă și linii), nu pentru entități independente (produs și categorie, client și comenzi).

Tipurile de cascadă: PERSIST, MERGE, REMOVE, REFRESH, DETACH și ALL, care le include pe toate.

Un caz potrivit este compoziția, unde copilul nu are sens fără părinte:

JAVA
@Entity
class Comanda {
    @OneToMany(mappedBy = "comanda", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<LinieComanda> linii = new ArrayList<>();

    public void adaugaLinie(Produs p, int cantitate) {
        linii.add(new LinieComanda(this, p, cantitate));
    }

    public void stergeLinie(LinieComanda l) {
        linii.remove(l);            // orphanRemoval: DELETE la flush
    }
}

comandaRepo.save(comanda) salvează și liniile, iar delete(comanda) le șterge.

Diferența dintre REMOVE și orphanRemoval: REMOVE șterge copiii când ștergi părintele; orphanRemoval șterge și copilul scos din colecție, chiar dacă părintele rămâne.

Când cascada e o greșeală:

  • @ManyToOne(cascade = CascadeType.ALL) Categorie categorie pe Produs: ștergerea unui produs încearcă să șteargă categoria, folosită de alte produse;
  • Client cu cascade = REMOVE pe comenzi: ștergerea unui client șterge istoricul financiar; de obicei vrei interdicție sau ștergere logică;
  • relații @ManyToMany cu REMOVE: șterge entitățile de la celălalt capăt, nu doar legătura.

Capcană cu orphanRemoval: dacă înlocuiești colecția (comanda.setLinii(listaNoua)), Hibernate aruncă A collection with cascade="all-delete-orphan" was no longer referenced by the owning entity instance; modifici lista existentă (clear() și addAll), nu o înlocuiești.

Ce urmărește intervievatorul: Verifică dacă înțelegi efectele cascadei asupra datelor. Greșeala tipică este CascadeType.ALL pus din reflex pe orice relație, inclusiv pe @ManyToOne.

Eroarea, în practică:object references an unsaved transient instancecollection with cascade all-delete-orphan

71 Mid

Ce afișează codul de mai jos, presupunând că produsul 1 are prețul 100? Explică rezultatul.

JAVA
@Service
class PretService {
    @Transactional
    public void scumpeste(long id) {
        Produs p = repo.findById(id).orElseThrow();
        p.setPret(p.getPret().add(new BigDecimal("10")));
    }

    public void ieftineste(long id) {
        Produs p = repo.findById(id).orElseThrow();
        p.setPret(p.getPret().subtract(new BigDecimal("50")));
    }
}

service.scumpeste(1);
service.ieftineste(1);
System.out.println(repo.findById(1L).orElseThrow().getPret());

Răspuns scurt: Afișează 110. În scumpeste, produsul este o entitate gestionată în tranzacție: Hibernate detectează modificarea (dirty checking) și face UPDATE la commit, fără save. În ieftineste nu există tranzacție a metodei, entitatea întoarsă e detașată după findById, iar modificarea fără save se pierde.

În scumpeste, @Transactional deschide o tranzacție și un context de persistență pentru toată metoda. findById întoarce o entitate gestionată: Hibernate îi păstrează o copie a stării inițiale. La commit face flush, compară starea curentă cu copia, vede prețul schimbat și execută:

SQL
UPDATE produs SET pret = 110 WHERE id = 1

Fără niciun save. Mecanismul se numește dirty checking.

În ieftineste nu e nicio tranzacție deschisă de metodă. findById are propria tranzacție scurtă (metodele SimpleJpaRepository sunt tranzacționale), care se închide la ieșirea din apel; entitatea întoarsă devine detașată. setPret modifică doar obiectul Java, nimic nu ajunge în bază. Rezultatul final rămâne 110.

Excepție importantă: cu spring.jpa.open-in-view=true (implicit în Boot, cu un avertisment în jurnal), dacă ieftineste e apelată dintr-o cerere HTTP, contextul de persistență rămâne deschis pe toată cererea. Entitatea e tot gestionată, dar, fără tranzacție, flush-ul nu se face, deci modificarea tot nu se salvează.

Reparații pentru ieftineste: @Transactional pe metodă sau repo.save(p) explicit.

Lecția practică: dirty checking este util, dar poate surprinde și invers, adică salvând modificări pe care nu voiai să le salvezi. Orice entitate modificată într-o metodă tranzacțională, chiar și doar pentru un calcul temporar, ajunge în bază. De aceea calculele se fac pe DTO-uri sau copii, iar metodele de citire au @Transactional(readOnly = true).

Ce urmărește intervievatorul: Verifică stările entităților printr-un exercițiu de citire a codului, nu prin definiții. Greșeala tipică este să crezi că fără save nu se salvează nimic sau, invers, că orice modificare se salvează.

Eroarea, în practică:LazyInitializationException: no Sessiondetached entity passed to persist

72 Mid

Metoda de mai jos aruncă PlataRespinsaException, o excepție verificată (extends Exception). Se anulează scăderea stocului? Cum repari?

JAVA
@Transactional
public void plaseaza(Comanda c) throws PlataRespinsaException {
    stocService.scade(c);
    comandaRepo.save(c);
    plataClient.incaseaza(c);   // aruncă PlataRespinsaException
}

Răspuns scurt: Nu. Implicit, @Transactional face rollback doar la RuntimeException și Error; la o excepție verificată face commit, deci stocul scăzut și comanda rămân în bază. Repari cu @Transactional(rollbackFor = PlataRespinsaException.class) sau transformi excepția într-una neverificată.

Regula implicită de rollback, moștenită din EJB: excepțiile neverificate sunt considerate defecte neprevăzute (rollback), iar cele verificate rezultate de business așteptate (commit). Mulți se așteaptă la rollback la orice excepție, de unde bug-uri cu date pe jumătate salvate.

Fluxul aici: stocul se scade, comanda se salvează, plata aruncă PlataRespinsaException. Proxy-ul tranzacțional vede o excepție verificată, face commit și abia apoi o aruncă mai departe. Clientul primește o eroare, dar stocul e scăzut pentru o comandă neplătită.

Reparații:

JAVA
@Transactional(rollbackFor = PlataRespinsaException.class)
public void plaseaza(Comanda c) throws PlataRespinsaException { ... }

sau o excepție neverificată:

JAVA
class PlataRespinsaException extends RuntimeException { ... }

Multe proiecte Spring folosesc doar excepții neverificate în service-uri și evită complet problema.

Probleme de design la fel de importante:

  • apelul HTTP spre plăți în interiorul tranzacției ține conexiunea la bază deschisă cât așteaptă rețeaua; sub încărcare, pool-ul de conexiuni se epuizează;
  • rollback-ul bazei nu anulează plata externă: dacă plata reușește și commit-ul pică, banii sunt încasați pentru o comandă inexistentă.

Varianta robustă: salvezi comanda în starea IN_ASTEPTARE_PLATA și rezervi stocul într-o tranzacție scurtă, faci plata în afara tranzacției, apoi o a doua tranzacție confirmă sau anulează (cu eliberarea stocului). La scară mare, acesta e pattern-ul saga.

Ce urmărește intervievatorul: Verifică o regulă care produce bug-uri de date reale, prin citirea codului. Greșeala tipică este să crezi că orice excepție anulează tranzacția.

Eroarea, în practică:Transaction silently rolled back (rollback-only)

73 Mid

Ai nevoie doar de id-ul, numele și prețul produselor pentru o listă cu mii de rânduri. Cum le încarci fără entități complete? Ce sunt proiecțiile în Spring Data?

Răspuns scurt: Folosești o proiecție: o interfață sau un record cu doar câmpurile necesare ca tip de retur, sau SELECT new ...ProdusRand(p.id, p.nume, p.pret) în JPQL. Hibernate citește doar coloanele cerute și nu gestionează entități.

Încărcarea entităților complete pentru o listă de citire costă: toate coloanele, inclusiv texte mari, obiecte gestionate de Hibernate (copii pentru dirty checking) și riscul de interogări în plus pe relații.

Proiecție cu record și JPQL:

JAVA
record ProdusRand(Long id, String nume, BigDecimal pret) { }

interface ProdusRepository extends JpaRepository<Produs, Long> {
    @Query("SELECT new ro.magazin.produs.ProdusRand(p.id, p.nume, p.pret) FROM Produs p WHERE p.activ = true")
    List<ProdusRand> randuriActive();
}

Numele complet al clasei este obligatoriu în SELECT new.

Proiecție derivată cu interfață:

JAVA
interface ProdusSumar {
    String getNume();
    BigDecimal getPret();
    @Value("#{target.nume + ' (' + target.pret + ' lei)'}")
    String getEticheta();    // proiecție „deschisă”: încarcă tot, evit-o
}

List<ProdusSumar> findByCategorieId(long categorieId);

Spring Data observă tipul de retur și selectează doar nume și pret. Proiecțiile „deschise” (cu SpEL) încarcă entitatea completă și pierd avantajul.

Proiecțiile dinamice permit alegerea la apel: <T> List<T> findByActiv(boolean activ, Class<T> tip).

Proiecțiile pot conține și câmpuri din relații (SELECT new ...(p.id, c.nume) FROM Produs p JOIN p.categorie c), ceea ce rezolvă din start și o parte din problemele de încărcare leneșă la listări. Pentru scrieri folosești în continuare entitățile: proiecțiile sunt doar pentru citire și nu sunt gestionate.

Ce urmărește intervievatorul: Verifică dacă știi să optimizezi citirile fără SQL nativ. Greșeala tipică este o proiecție cu @Value și SpEL, care încarcă oricum toată entitatea.

74 Mid

Cum ștergi sau actualizezi multe rânduri dintr-o dată cu Spring Data? De ce o metodă deleteByStare aruncă eroarea No EntityManager with actual transaction available când e apelată din controller?

Răspuns scurt: Metodele deleteBy... încarcă entitățile și le șterg pe rând, deci cer o tranzacție; fără @Transactional apare acea eroare. Pentru volume mari scrii @Modifying @Query cu DELETE sau UPDATE, apelat dintr-o metodă tranzacțională.

Metodele pe care le declari tu în repository nu sunt tranzacționale implicit pentru scriere. O metodă derivată deleteByStare face, de fapt, SELECT pe entități, apoi remove pe fiecare; remove cere un context de persistență legat de o tranzacție. Fără ea apare:

No EntityManager with actual transaction available for current thread - cannot reliably process 'remove' call

Reparația minimă: @Transactional pe metoda din service care o apelează (sau pe metoda din repository).

Pentru volume mari, ștergerea una câte una e lentă (o interogare pe rând și evenimentele JPA pentru fiecare). Varianta în masă:

JAVA
interface ComandaRepository extends JpaRepository<Comanda, Long> {
    @Modifying(clearAutomatically = true, flushAutomatically = true)
    @Query("DELETE FROM Comanda c WHERE c.stare = :stare AND c.data < :inainte")
    int stergeVechi(@Param("stare") StareComanda stare, @Param("inainte") LocalDate inainte);

    @Modifying
    @Query("UPDATE Produs p SET p.pret = p.pret * :factor WHERE p.categorie.id = :cat")
    int ajusteazaPreturi(@Param("factor") BigDecimal factor, @Param("cat") long cat);
}

Detalii:

  • fără @Modifying, Spring Data tratează interogarea ca citire și aruncă o excepție;
  • interogările în masă ocolesc contextul de persistență: entitățile deja încărcate în aceeași tranzacție rămân cu valorile vechi; clearAutomatically golește contextul după execuție, iar flushAutomatically scrie modificările în așteptare înainte;
  • nu se aplică cascada, orphanRemoval, @PreRemove sau @Version; dacă ai copii cu cheie străină, îi ștergi întâi tu;
  • valoarea întoarsă int este numărul de rânduri afectate.

Ce urmărește intervievatorul: Verifică diferența dintre operațiile pe entități și cele în masă. Greșeala tipică este un deleteBy fără tranzacție sau un UPDATE în masă urmat de citirea unei entități cu date vechi din context.

Eroarea, în practică:No EntityManager with actual transaction available

75 Senior

Doi operatori editează același produs în același timp, iar modificările unuia se pierd. Cum previi asta cu JPA și ce răspuns HTTP întorci?

Răspuns scurt: Cu blocare optimistă: un câmp @Version. Hibernate adaugă WHERE version = ? la UPDATE; dacă altcineva a salvat între timp, apare ObjectOptimisticLockingFailureException. Clientul trimite versiunea citită, iar conflictul devine 409 sau 412.

Problema se numește lost update: A citește produsul (preț 100), B îl citește, A salvează prețul 90, B salvează descrierea cu prețul vechi 100, iar modificarea lui A dispare.

Blocarea optimistă:

JAVA
@Entity
class Produs {
    @Id @GeneratedValue Long id;
    String nume;
    BigDecimal pret;
    @Version
    long versiune;
}

La fiecare actualizare, Hibernate execută:

SQL
UPDATE produs SET pret = ?, versiune = 8 WHERE id = ? AND versiune = 7

Dacă rândul are deja versiunea 8, nu se modifică nimic, iar Spring aruncă ObjectOptimisticLockingFailureException.

Ca să funcționeze într-un API, versiunea trebuie să circule prin client: GET întoarce versiune (sau antetul ETag: "7"), iar PUT o trimite înapoi (în corp sau If-Match: "7"). Service-ul compară versiunea primită cu cea curentă, pentru că o entitate proaspăt încărcată are mereu versiunea curentă și conflictul nu ar fi detectat.

JAVA
@ExceptionHandler(ObjectOptimisticLockingFailureException.class)
ProblemDetail conflict() {
    return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, "Produsul a fost modificat între timp. Reîncarcă datele.");
}

Cu If-Match, statusul corect este 412 Precondition Failed; altfel 409 Conflict.

Alternativa este blocarea pesimistă (@Lock(PESSIMISTIC_WRITE), adică SELECT ... FOR UPDATE): previne conflictul, dar ține rândul blocat și reduce concurența. O folosești pentru operații scurte cu conflicte frecvente (scăderea stocului la vânzări intense) sau o înlocuiești cu un UPDATE atomic (SET stoc = stoc - 1 WHERE stoc > 0).

Ce urmărește intervievatorul: La senior se verifică înțelegerea concurenței cap-coadă, de la bază până la contractul HTTP. Greșeala tipică este @Version adăugat fără ca versiunea să circule prin client.

76 Senior

Trebuie să redenumești coloana nume în denumire într-un tabel mare, fără oprirea aplicației, care rulează pe mai multe instanțe. Cum planifici migrarea cu Flyway?

Răspuns scurt: Cu expand and contract, în mai multe versiuni: adaugi coloana nouă, aplicația scrie în ambele, copiezi datele în loturi, apoi ștergi coloana veche când nicio instanță nu o mai folosește. Fiecare pas e compatibil cu versiunea anterioară.

Un ALTER TABLE produs RENAME COLUMN nume TO denumire direct strică instanțele care rulează încă versiunea veche în timpul unui rolling deploy: ele caută coloana nume și pică.

Pașii, fiecare livrat separat:

SQL
-- V12__adauga_denumire.sql (expand)
ALTER TABLE produs ADD COLUMN denumire VARCHAR(120);

Versiunea N+1 a aplicației scrie în ambele coloane și citește din denumire, cu revenire la nume dacă e goală:

JAVA
@Column(name = "nume") private String numeVechi;
@Column(name = "denumire") private String denumire;

public void setDenumire(String d) { this.denumire = d; this.numeVechi = d; }
public String getDenumire() { return denumire != null ? denumire : numeVechi; }

Copierea datelor, în loturi, ca să nu blochezi tabelul și să nu ții o tranzacție uriașă:

SQL
UPDATE produs SET denumire = nume WHERE denumire IS NULL AND id BETWEEN 1 AND 10000;

O faci dintr-un job sau dintr-o migrare Java Flyway care iterează pe intervale. Apoi adaugi constrângerea NOT NULL, după ce toate rândurile sunt completate.

Versiunea N+2 nu mai folosește coloana veche, iar ulterior:

SQL
-- V14__sterge_nume.sql (contract)
ALTER TABLE produs DROP COLUMN nume;

Alte reguli: migrările nu se modifică după ce au rulat; operațiile care blochează mult (indexuri pe tabele mari) se fac cu opțiuni non-blocante (CREATE INDEX CONCURRENTLY în PostgreSQL, care nu rulează într-o tranzacție); orice migrare se testează pe o copie realistă a datelor; ai un plan de revenire, de obicei o migrare înainte, nu un rollback.

Ce urmărește intervievatorul: La senior se verifică experiența cu sisteme care nu se pot opri. Greșeala tipică este o migrare care strică versiunea veche a aplicației în timpul deploy-ului.

Securitate

77 Junior

Care e diferența dintre autentificare și autorizare? Când răspunde un API cu 401 și când cu 403?

Răspuns scurt: Autentificarea stabilește cine ești (parolă, token, certificat); autorizarea stabilește ce ai voie să faci (roluri, permisiuni). 401 Unauthorized înseamnă că lipsește sau e invalidă autentificarea; 403 Forbidden înseamnă că ești autentificat, dar nu ai dreptul la resursă.

Exemplu pe un API de magazin:

  • GET /api/comenzi fără antetul Authorization: 401; serverul nu știe cine ești și, conform HTTP, trimite antetul WWW-Authenticate (de exemplu Bearer);
  • același apel cu un token expirat sau falsificat: 401;
  • DELETE /api/produse/7 cu un token valid al unui client obișnuit, când doar administratorii pot șterge: 403;
  • GET /api/comenzi/45, comanda altui client: 403, sau 404 dacă nu vrei să confirmi existența resursei.

Numele de status sunt istorice și înșelătoare: „Unauthorized” înseamnă de fapt „neautentificat”.

În Spring Security, filtrul de autentificare stabilește Authentication în SecurityContext, iar regulile de autorizare verifică rolurile:

JAVA
http.authorizeHttpRequests(auth -> auth
        .requestMatchers(HttpMethod.GET, "/api/produse/**").permitAll()
        .requestMatchers(HttpMethod.DELETE, "/api/produse/**").hasRole("ADMIN")
        .anyRequest().authenticated());

Lipsa autentificării ajunge la AuthenticationEntryPoint (401), iar lipsa dreptului la AccessDeniedHandler (403).

Autorizarea trebuie să verifice și datele, nu doar rolul: un client autentificat nu trebuie să poată citi comanda altui client doar schimbând id-ul din URL (IDOR, Insecure Direct Object Reference). Verificarea se face în service, comparând proprietarul resursei cu utilizatorul curent.

Ce urmărește intervievatorul: Este baza securității web. Greșeala tipică este 403 pentru un token lipsă sau lipsa verificării de proprietar pe resurse.

Eroarea, în practică:Full authentication is required (401)Access Denied (403 Forbidden)

78 Junior

Ce se schimbă imediat după ce adaugi spring-boot-starter-security într-o aplicație care avea endpoint-uri publice?

Răspuns scurt: Toate endpoint-urile devin protejate: orice cerere fără autentificare primește 401 (sau, din browser, un formular de login). Boot creează un utilizator user cu o parolă generată afișată în jurnal (Using generated security password), activează CSRF pentru cererile care modifică date și adaugă antete de securitate.

Auto-configurarea Spring Security, fără niciun cod scris de tine:

  • un SecurityFilterChain implicit: orice cerere cere autentificare, cu formular de login (/login) pentru browser și HTTP Basic pentru clienți API;
  • un UserDetailsService în memorie cu utilizatorul user și o parolă aleatoare, scrisă la pornire: Using generated security password: ... și avertismentul că e doar pentru dezvoltare;
  • protecție CSRF activă: cererile POST, PUT, DELETE fără token CSRF primesc 403, chiar cu utilizator și parolă corecte; e prima surpriză pentru cine testează un API din Postman;
  • antete de securitate în răspuns: X-Content-Type-Options, X-Frame-Options: DENY, Cache-Control: no-cache, HSTS pe HTTPS;
  • endpoint-urile Actuator, cu excepția health, cer autentificare.

Pasul următor este propria configurare:

JAVA
@Configuration
class SecurityConfig {
    @Bean
    SecurityFilterChain api(HttpSecurity http) throws Exception {
        return http
                .csrf(csrf -> csrf.disable())
                .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                .authorizeHttpRequests(a -> a
                        .requestMatchers("/api/public/**", "/actuator/health").permitAll()
                        .anyRequest().authenticated())
                .httpBasic(Customizer.withDefaults())
                .build();
    }
}

Dezactivarea CSRF este corectă pentru un API stateless cu token-uri în antet, nu pentru o aplicație cu sesiune în cookie. Testele existente trebuie actualizate: cu spring-security-test, @WithMockUser simulează un utilizator autentificat în testele MockMvc.

Ce urmărește intervievatorul: Verifică dacă ai integrat securitatea într-o aplicație existentă. Greșeala tipică este confuzia 403 la POST din cauza CSRF, depanată ca problemă de roluri.

Eroarea, în practică:Full authentication is required (401)Using generated security password

79 Junior

Cum salvezi parolele utilizatorilor într-o aplicație Spring? De ce nu SHA-256 și ce înseamnă {bcrypt} la începutul unui hash?

Răspuns scurt: Salvezi doar un hash lent, cu sare, generat de un PasswordEncoder (BCrypt, Argon2, PBKDF2), și verifici cu encoder.matches(parola, hash). SHA-256 e prea rapid, deci ușor de spart prin forță brută. {bcrypt} este prefixul lui DelegatingPasswordEncoder, care arată algoritmul folosit pentru acel hash.

Reguli de bază: parola nu se salvează niciodată în clar și nici criptată reversibil; se salvează un hash dintr-o funcție gândită pentru parole:

  • lentă și configurabilă (factorul de cost la BCrypt), ca un atacator cu baza de date furată să încerce puține parole pe secundă;
  • cu sare unică per parolă, ca două parole identice să aibă hash-uri diferite și tabelele precalculate să nu funcționeze.

SHA-256 e proiectat să fie rapid; plăcile video calculează miliarde de hash-uri pe secundă, deci parolele slabe cad repede.

JAVA
@Bean
PasswordEncoder passwordEncoder() {
    return PasswordEncoderFactories.createDelegatingPasswordEncoder();
}

@Service
class InregistrareService {
    private final PasswordEncoder encoder;
    private final UtilizatorRepository repo;

    void inregistreaza(String email, String parola) {
        repo.save(new Utilizator(email, encoder.encode(parola)));
    }

    boolean verifica(Utilizator u, String parola) {
        return encoder.matches(parola, u.getParolaHash());
    }
}

encode produce, de exemplu, {bcrypt}$2a$10$.... Prefixul permite migrarea: utilizatorii vechi au hash-uri {sha256} sau {noop}, cei noi {bcrypt}, iar DelegatingPasswordEncoder le verifică pe toate și poate actualiza hash-ul la următoarea autentificare. Un hash fără prefix dă eroarea There is no PasswordEncoder mapped for the id "null".

Nu compari hash-uri cu equals și nu cripta parola în client ca înlocuitor pentru HTTPS. Limitează încercările de autentificare și nu jurnaliza parolele.

Ce urmărește intervievatorul: Verifică cunoștințe minime de securitate, obligatorii pentru orice backend. Greșeala tipică este un hash rapid (MD5, SHA) sau {noop} lăsat în producție.

Eroarea, în practică:No PasswordEncoder mapped for the id "null"

80 Mid

Cum funcționează lanțul de filtre din Spring Security? Scrie un SecurityFilterChain pentru un API în care produsele se citesc public, comenzile cer autentificare, iar administrarea cere rolul ADMIN.

Răspuns scurt: Spring Security se înregistrează ca un singur filtru servlet (DelegatingFilterProxy către FilterChainProxy), care alege un SecurityFilterChain după URL și rulează filtrele lui: CORS, CSRF, autentificare, apoi AuthorizationFilter. Regulile requestMatchers se evaluează în ordine, primul care se potrivește câștigă.

Configurarea pentru cerința dată:

JAVA
@Configuration
@EnableMethodSecurity
class SecurityConfig {
    @Bean
    SecurityFilterChain api(HttpSecurity http) throws Exception {
        return http
                .csrf(c -> c.disable())
                .cors(Customizer.withDefaults())
                .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                .authorizeHttpRequests(a -> a
                        .requestMatchers(HttpMethod.GET, "/api/produse/**").permitAll()
                        .requestMatchers("/api/admin/**").hasRole("ADMIN")
                        .requestMatchers("/api/comenzi/**").authenticated()
                        .requestMatchers("/actuator/health", "/error").permitAll()
                        .anyRequest().denyAll())
                .oauth2ResourceServer(o -> o.jwt(Customizer.withDefaults()))
                .build();
    }
}

Cum ajunge o cerere aici: Tomcat rulează filtrele servlet; unul dintre ele este DelegatingFilterProxy (springSecurityFilterChain), care delegă la FilterChainProxy. Acesta alege primul SecurityFilterChain al cărui securityMatcher se potrivește (poți avea un lanț pentru /api/** și altul pentru paginile web) și rulează filtrele lui în ordine fixă: CorsFilter, CsrfFilter, filtrele de autentificare (Basic, Bearer, formular), ExceptionTranslationFilter, apoi AuthorizationFilter.

Detalii importante:

  • ordinea regulilor contează: o regulă generală pusă înaintea uneia specifice o acoperă;
  • anyRequest().denyAll() la final e mai sigur decât permitAll(): o rută nouă uitată este închisă, nu deschisă;
  • /error trebuie permis, altfel erorile se transformă în 401;
  • hasRole("ADMIN") caută autoritatea ROLE_ADMIN;
  • regulile pe URL se completează cu reguli pe metode (@PreAuthorize), mai aproape de logică.

Ce urmărește intervievatorul: Verifică dacă înțelegi arhitectura, nu doar configurația copiată. Greșeala tipică este o ordine greșită a regulilor sau permitAll() pentru tot ce nu e listat.

81 Mid

Ce este un atac CSRF? De ce dezactivezi protecția CSRF la un API stateless cu token JWT în antet, dar nu la o aplicație cu sesiune în cookie?

Răspuns scurt: CSRF păcălește browserul victimei să trimită o cerere spre site-ul tău, iar browserul atașează automat cookie-ul de sesiune. Un token în antetul Authorization nu e trimis automat, deci atacul nu are ce folosi. Cu sesiune în cookie, protecția rămâne obligatorie.

Scenariul atacului: utilizatorul e autentificat pe magazin.ro, cu sesiunea într-un cookie. Vizitează o pagină rău intenționată care conține un formular ascuns:

HTML
<form action="https://magazin.ro/cont/email" method="POST">
  <input type="hidden" name="email" value="atacator@exemplu.com">
</form>
<script>document.forms[0].submit()</script>

Browserul trimite cererea spre magazin.ro cu cookie-ul de sesiune, iar serverul o vede ca legitimă. Atacatorul nu poate citi răspunsul, dar efectul (schimbarea emailului) se produce.

Protecția Spring Security: un token CSRF secret, legat de sesiune, pe care serverul îl cere la orice cerere care modifică date (POST, PUT, DELETE). Pagina malițioasă nu îl cunoaște. În aplicațiile cu JavaScript, Spring îl poate pune într-un cookie citibil (CookieCsrfTokenRepository.withHttpOnlyFalse()), iar clientul îl retrimite în antetul X-XSRF-TOKEN.

La un API stateless:

  • clientul trimite Authorization: Bearer <token> explicit, din cod;
  • browserul nu adaugă niciodată acest antet singur pentru o cerere cross-site;
  • deci falsificarea nu are credențiale de folosit, iar protecția CSRF nu adaugă nimic.

Atenție: dacă pui JWT-ul într-un cookie (de exemplu HttpOnly, ca să-l ferești de XSS), revii la autentificare automată prin cookie și ai din nou nevoie de CSRF sau de SameSite=Strict/Lax. Atributul SameSite al cookie-urilor (implicit Lax în browserele moderne) reduce mult riscul, dar nu înlocuiește complet tokenul pentru toate cazurile.

Ce urmărește intervievatorul: Verifică dacă dezactivezi CSRF înțelegând de ce, nu din reflex. Greșeala tipică este dezactivarea CSRF într-o aplicație cu sesiune în cookie.

Eroarea, în practică:Invalid CSRF token found (403 la POST)

82 Mid

Ce fac @EnableMethodSecurity și @PreAuthorize? Care e diferența dintre hasRole('ADMIN') și hasAuthority('ADMIN')?

Răspuns scurt: @EnableMethodSecurity activează verificări de securitate pe metode, prin proxy-uri. @PreAuthorize("expresie") verifică expresia înainte de apel și aruncă AccessDeniedException (403) dacă e falsă. hasRole('ADMIN') caută autoritatea ROLE_ADMIN (adaugă prefixul), iar hasAuthority('ADMIN') caută exact ADMIN.

Regulile pe URL sunt grosiere; pe metode poți exprima reguli legate de date:

JAVA
@Configuration
@EnableMethodSecurity
class MetodeConfig { }

@Service
class ComandaService {
    @PreAuthorize("hasRole('ADMIN')")
    public void anuleazaOrice(long id) { ... }

    @PreAuthorize("hasAuthority('SCOPE_comenzi:citire') and #email == authentication.name")
    public List<ComandaDto> aleClientului(String email) { ... }

    @PostAuthorize("returnObject.email() == authentication.name or hasRole('ADMIN')")
    public ComandaDto una(long id) { ... }
}

Diferența de prefix vine din convenția Spring: rolurile sunt autorități cu prefixul ROLE_. Dacă utilizatorul are autoritatea ROLE_ADMIN, atunci hasRole('ADMIN') și hasAuthority('ROLE_ADMIN') trec, iar hasAuthority('ADMIN') nu. Cu JWT, JwtAuthenticationConverter transformă implicit claim-ul scope în autorități SCOPE_...; dacă rolurile vin în alt claim (roles), configurezi convertorul să le mapeze la ROLE_..., altfel hasRole pică mereu cu 403.

Fiind bazată pe proxy-uri, securitatea pe metode are aceleași limite ca @Transactional: apelurile din interiorul aceleiași clase o ocolesc, iar metodele private nu sunt verificate.

@Secured("ROLE_ADMIN") și @RolesAllowed sunt alternative mai simple, fără expresii. Pentru reguli complexe (proprietar, echipă), o metodă dintr-un bean (@PreAuthorize("@acces.poateEdita(#id)")) ține logica testabilă. În teste, @WithMockUser(roles = "ADMIN") simulează utilizatorul.

Ce urmărește intervievatorul: Verifică autorizarea fină și o capcană de configurare care produce 403 inexplicabile. Greșeala tipică este amestecul hasRole cu autorități fără prefix.

Eroarea, în practică:Access Denied (403 Forbidden)

83 Senior

Serviciul tău primește token-uri JWT emise de un server de autorizare (Keycloak, Auth0). Cum configurezi validarea în Spring Boot și ce verifici, în afară de semnătură?

Răspuns scurt: Îl configurezi ca resource server: spring-boot-starter-oauth2-resource-server și spring.security.oauth2.resourceserver.jwt.issuer-uri. Spring descarcă cheile publice (JWKS), verifică semnătura, exp, nbf și emitentul. Adaugi verificarea audienței (aud), maparea rolurilor din claim-uri și eventual o limită pentru durata de viață.

Configurarea minimă:

YAML
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: https://auth.magazin.ro/realms/magazin
          audiences: comenzi-api
JAVA
http.oauth2ResourceServer(o -> o.jwt(j -> j.jwtAuthenticationConverter(convertor())));

La pornire (sau la prima cerere), Spring citește documentul de descoperire al emitentului și adresa JWKS, cu cheile publice. Pentru fiecare cerere Authorization: Bearer ..., BearerTokenAuthenticationFilter decodează token-ul și verifică:

  • semnătura cu cheia publică indicată de kid; cheile sunt păstrate în cache și reîmprospătate la rotire;
  • algoritmul (nu acceptă alg: none și nici o cheie simetrică în locul celei publice);
  • exp și nbf, cu o mică toleranță la diferențele de ceas;
  • iss egal cu emitentul configurat;
  • aud: un token emis pentru alt serviciu nu trebuie acceptat aici (proprietatea audiences din Boot 3.2+ sau un validator propriu).

Maparea rolurilor:

JAVA
JwtAuthenticationConverter convertor() {
    JwtGrantedAuthoritiesConverter g = new JwtGrantedAuthoritiesConverter();
    g.setAuthoritiesClaimName("roles");
    g.setAuthorityPrefix("ROLE_");
    JwtAuthenticationConverter c = new JwtAuthenticationConverter();
    c.setJwtGrantedAuthoritiesConverter(g);
    return c;
}

Aspecte de design: token-urile de acces au viață scurtă (minute), pentru că un JWT nu poate fi revocat ușor; revocarea imediată cere introspecție sau o listă de token-uri blocate. Serviciul nu emite token-uri, doar le validează. Nu pui date sensibile în claim-uri: conținutul unui JWT e doar codificat Base64, nu criptat.

Ce urmărește intervievatorul: La senior se verifică integrarea cu un sistem real de identitate și cunoașterea atacurilor clasice pe JWT. Greșeala tipică este lipsa verificării audienței.

84 Senior

Serviciul comenzi apelează serviciul stoc. Cum autentifici apelurile dintre microservicii? Transmiți token-ul utilizatorului sau folosești altceva?

Răspuns scurt: Dacă stoc trebuie să știe utilizatorul, propagi token-ul lui sau faci token exchange; pentru operații de sistem, comenzi obține propriul token prin client credentials. Adaugi mTLS sau service mesh; rețeaua internă nu e o dovadă de identitate.

Opțiunile, cu compromisurile lor:

Propagarea token-ului utilizatorului. comenzi trimite mai departe antetul Authorization primit:

JAVA
RestClient stoc = builder.baseUrl("http://stoc")
        .requestInterceptor((req, body, exec) -> {
            var auth = (JwtAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();
            req.getHeaders().setBearerAuth(auth.getToken().getTokenValue());
            return exec.execute(req, body);
        })
        .build();

Avantaj: stoc aplică regulile pe utilizatorul real și ai audit cap-coadă. Dezavantaje: token-ul trebuie să aibă audiența potrivită pentru stoc, poate expira în mijlocul unui flux lung și nu există pentru procesele fără utilizator (job-uri, mesaje Kafka). Token exchange (RFC 8693) rezolvă audiența: comenzi schimbă token-ul primit pe unul emis pentru stoc.

Client credentials. comenzi are propriul client OAuth2 și obține un token cu scope-uri de serviciu (stoc:rezervare). Spring Security îl gestionează automat (OAuth2AuthorizedClientManager, configurare spring.security.oauth2.client.registration.*), cu reîmprospătare la expirare. Potrivit pentru job-uri și consumatori de mesaje.

Nivelul de rețea. mTLS: fiecare serviciu are un certificat, iar conexiunile sunt autentificate reciproc; un service mesh (Istio, Linkerd) automatizează certificatele și politicile. E un strat în plus, nu un înlocuitor pentru autorizarea în aplicație.

Principiul de fond este zero trust: „cererea vine din rețeaua internă” nu este o dovadă de identitate. Un serviciu compromis nu trebuie să poată apela orice alt serviciu cu orice drepturi. Fiecare serviciu validează token-ul și scope-urile, iar comunicarea e criptată.

Ce urmărește intervievatorul: La senior se verifică proiectarea securității într-un sistem distribuit. Greșeala tipică este o rețea internă considerată de încredere, fără autentificare între servicii.

Eroarea, în practică:HttpClientErrorException$Unauthorized: 401

Teste

Exersează capitolul cu exerciții reale: Curs Spring Boot →
85 Junior

Cum scrii un test unitar pentru ComandaService, care depinde de interfața StocRepository, fără să pornești Spring și fără bibliotecă de mock-uri?

Răspuns scurt: Datorită injectării prin constructor, creezi service-ul cu new și îi dai o implementare de test a interfeței (un fake în memorie, de exemplu peste un HashMap). Testul JUnit 5 pregătește datele în fake, apelează metoda și verifică rezultatul și starea fake-ului. Rulează în milisecunde.

Codul de producție:

JAVA
interface StocRepository {
    int stoc(long produsId);
    void scade(long produsId, int cantitate);
}

@Service
class ComandaService {
    private final StocRepository stoc;
    ComandaService(StocRepository stoc) { this.stoc = stoc; }

    public void plaseaza(long produsId, int cantitate) {
        if (stoc.stoc(produsId) < cantitate) {
            throw new StocInsuficientException(produsId);
        }
        stoc.scade(produsId, cantitate);
    }
}

Fake-ul și testele:

JAVA
class StocInMemorie implements StocRepository {
    final Map<Long, Integer> date = new HashMap<>();
    public int stoc(long id) { return date.getOrDefault(id, 0); }
    public void scade(long id, int c) { date.merge(id, -c, Integer::sum); }
}

class ComandaServiceTest {
    StocInMemorie stoc = new StocInMemorie();
    ComandaService service = new ComandaService(stoc);

    @Test
    void scadeStoculLaComandaValida() {
        stoc.date.put(1L, 10);
        service.plaseaza(1L, 3);
        assertEquals(7, stoc.stoc(1L));
    }

    @Test
    void refuzaComandaPesteStoc() {
        stoc.date.put(1L, 2);
        assertThrows(StocInsuficientException.class, () -> service.plaseaza(1L, 5));
        assertEquals(2, stoc.stoc(1L));
    }
}

JUnit creează o instanță nouă a clasei de test pentru fiecare metodă, deci câmpurile sunt proaspete la fiecare test.

Fake-ul verifică starea finală, nu ordinea apelurilor, deci testul nu se strică dacă refactorizezi implementarea. Mock-urile (Mockito) sunt utile când interfața e mare sau vrei să verifici că un apel a avut loc (un email trimis). Ambele variante cer același lucru de la design: dependențe prin interfețe, primite în constructor.

Ce urmărește intervievatorul: Verifică dacă scrii cod testabil și înțelegi că testul unitar nu are nevoie de Spring. Greșeala tipică este un @SpringBootTest pentru orice test de logică.

Eroarea, în practică:AssertionFailedError: expected: <x> but was: <y>Expected X to be thrown, but nothing was thrown.

86 Junior

Scrie un test MockMvc care verifică faptul că GET /api/produse/1 întoarce 200 și un JSON cu numele Mouse, iar GET /api/produse/99 întoarce 404.

Răspuns scurt: Clasa de test are @SpringBootTest și @AutoConfigureMockMvc (sau @WebMvcTest), primește MockMvc injectat, apoi mvc.perform(get("/api/produse/1")).andExpect(status().isOk()).andExpect(jsonPath("$.nume").value("Mouse")), iar pentru 99 status().isNotFound().

Un test complet:

JAVA
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@SpringBootTest
@AutoConfigureMockMvc
class ProdusControllerTest {
    @Autowired
    MockMvc mvc;

    @Test
    void produsExistent() throws Exception {
        mvc.perform(get("/api/produse/{id}", 1))
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(jsonPath("$.id").value(1))
                .andExpect(jsonPath("$.nume").value("Mouse"));
    }

    @Test
    void produsInexistent() throws Exception {
        mvc.perform(get("/api/produse/99"))
                .andExpect(status().isNotFound());
    }
}

Ce face MockMvc: trimite cererea prin DispatcherServlet, cu filtre, conversii, validare și tratarea excepțiilor, dar fără server HTTP real și fără rețea. E mult mai rapid decât un client HTTP, dar testează aproape tot stratul web.

Detalii utile:

  • jsonPath folosește sintaxa JsonPath: $.nume, $[0].pret, $.length(), jsonPath("$", hasSize(3)) cu Hamcrest;
  • andDo(print()) afișează cererea și răspunsul când un test pică;
  • datele de test vin din data.sql, dintr-un @BeforeEach care salvează prin repository sau dintr-un fake pus în context;
  • dacă testele modifică date, @Transactional pe clasă le anulează după fiecare test.

Din Spring 6.2 există și MockMvcTester, cu aserțiuni AssertJ (assertThat(mvc.get().uri("/api/produse/1")).hasStatusOk()), dar perform și andExpect rămân forma pe care o întâlnești în cele mai multe proiecte.

Ce urmărește intervievatorul: Este o sarcină tipică la interviu sau la tema de casă. Greșeala tipică este un import static lipsă sau confuzia dintre jsonPath și compararea întregului text.

Eroarea, în practică:Status expected:<200> but was:<404>No value at JSON path "$.x"

87 Junior

Toate testele @SpringBootTest pică cu Failed to load ApplicationContext, deși aplicația pornește normal din IDE. Cum găsești cauza?

Răspuns scurt: Mesajul spune doar că contextul de test nu s-a creat; cauza e la ultimul Caused by din stack trace. Frecvent: o proprietate lipsă în configurarea de test, o bază indisponibilă sau un bean exclus în profilul de test.

Failed to load ApplicationContext este un mesaj „ambalaj”: Spring a încercat să pornească contextul pentru clasa de test și a eșuat. Informația utilă e în lanțul de cauze:

java.lang.IllegalStateException: Failed to load ApplicationContext for [WebMergedContextConfiguration ...]
Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'plataClient' ...
Caused by: java.lang.IllegalArgumentException: Could not resolve placeholder 'plati.url' in value "${plati.url}"

Citești de jos în sus: ultimul Caused by este cauza primară. Aici, proprietatea plati.url lipsește.

De ce pornește aplicația din IDE, dar nu în test:

  • proprietățile vin din alt loc: variabile de mediu setate în configurarea de rulare din IDE, dar nu și în teste, sau un src/test/resources/application.properties care înlocuiește complet fișierul din main, în loc să-l completeze;
  • profilul de test (@ActiveProfiles("test")) activează sau dezactivează bean-uri diferit;
  • testul are nevoie de o bază de date care nu rulează (soluție: H2 pentru teste sau Testcontainers);
  • clasa de test e într-un pachet din care nu se găsește clasa @SpringBootApplication: Unable to find a @SpringBootConfiguration;
  • un test-slice (@WebMvcTest) nu încarcă service-urile, iar controller-ul are nevoie de ele.

Spring păstrează contextele în cache și, după un eșec, poate raporta pentru testele următoare doar că pragul de eșecuri a fost depășit (ApplicationContext failure threshold exceeded); cauza reală e la primul test care a picat.

Ce urmărește intervievatorul: Verifică dacă știi să citești un stack trace lung și să ajungi la cauză. Greșeala tipică este să citești doar prima linie și să cauți problema în test.

Eroarea, în practică:Found multiple @SpringBootConfiguration classesFailed to load ApplicationContext

88 Junior

Cum testezi aceeași regulă de business pe mai multe seturi de date fără să scrii zece metode de test aproape identice?

Răspuns scurt: Cu teste parametrizate JUnit 5: @ParameterizedTest în loc de @Test, plus o sursă de date: @ValueSource pentru o singură valoare, @CsvSource pentru mai multe coloane, @MethodSource pentru obiecte. Fiecare rând devine un test separat în raport, cu un nume configurabil.

Regula: transport gratuit de la 200 de lei, altfel 15 lei, iar pentru clienții premium mereu gratuit.

JAVA
class TransportTest {
    CalculTransport calcul = new CalculTransport();

    @ParameterizedTest(name = "total {0}, premium {1} -> transport {2}")
    @CsvSource({
            "50.00,  false, 15",
            "199.99, false, 15",
            "200.00, false, 0",
            "350.00, false, 0",
            "50.00,  true,  0"
    })
    void costTransport(BigDecimal total, boolean premium, BigDecimal asteptat) {
        assertEquals(0, asteptat.compareTo(calcul.cost(total, premium)));
    }

    @ParameterizedTest
    @ValueSource(strings = {"", " ", "abc", "12-34"})
    void codPostalInvalid(String cod) {
        assertFalse(Validari.codPostalValid(cod));
    }
}

Observații:

  • JUnit convertește automat textul din CSV în tipurile parametrilor (BigDecimal, boolean, LocalDate, enum-uri);
  • o valoare goală fără ghilimele este null, iar '' este textul gol; pentru null și gol explicit există @NullAndEmptySource;
  • valorile de la granițe (199.99 și 200.00) sunt exact cazurile care prind erorile de tip > în loc de >=;
  • BigDecimal se compară cu compareTo: new BigDecimal("0") și new BigDecimal("0.00") nu sunt egale cu equals, pentru că au scale diferite.

Pentru date complexe (obiecte construite, liste), @MethodSource("cazuri") primește un Stream<Arguments> dintr-o metodă statică. Pentru tabele mari de cazuri, @CsvFileSource citește un fișier din resursele de test.

Ce urmărește intervievatorul: Verifică stilul de testare și atenția la cazurile limită. Greșeala tipică este compararea BigDecimal cu assertEquals, care pică din cauza scalei diferite.

Eroarea, în practică:No ParameterResolver registered for parameter

89 Mid

Cum testezi cu MockMvc că un POST /api/produse cu date invalide întoarce 400 cu erorile pe câmpuri, iar unul valid întoarce 201 cu antetul Location?

Răspuns scurt: Trimiți cererea cu post(...).contentType(MediaType.APPLICATION_JSON).content(json), apoi verifici status().isBadRequest() și jsonPath("$.erori.nume").exists() pentru cazul invalid, respectiv status().isCreated(), header().string("Location", ...) și jsonPath("$.id") pentru cel valid. Corpul JSON îl scrii ca text block sau cu ObjectMapper.

Testele:

JAVA
@SpringBootTest
@AutoConfigureMockMvc
@Transactional
class ProdusCreareTest {
    @Autowired MockMvc mvc;
    @Autowired ObjectMapper json;

    @Test
    void dateInvalide() throws Exception {
        mvc.perform(post("/api/produse")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("""
                                {"nume": "", "pret": -5}
                                """))
                .andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.erori.nume").value("Numele este obligatoriu"))
                .andExpect(jsonPath("$.erori.pret").exists());
    }

    @Test
    void dateValide() throws Exception {
        String corp = json.writeValueAsString(new ProdusNou("Mouse", new BigDecimal("89.90"), 10));
        mvc.perform(post("/api/produse").contentType(MediaType.APPLICATION_JSON).content(corp))
                .andExpect(status().isCreated())
                .andExpect(header().string("Location", matchesPattern(".*/api/produse/\\d+")))
                .andExpect(jsonPath("$.nume").value("Mouse"));
    }

    @Test
    void jsonStricat() throws Exception {
        mvc.perform(post("/api/produse").contentType(MediaType.APPLICATION_JSON).content("{\"nume\":"))
                .andExpect(status().isBadRequest());
    }
}

Ce acoperă aceste teste, dincolo de controller: deserializarea Jackson, validarea Bean Validation, handler-ul @RestControllerAdvice și formatul erorilor. Sunt testele care prind regresiile cele mai vizibile pentru clienți, de exemplu un handler șters sau o adnotare @Valid lipsă.

Detalii:

  • fără contentType(APPLICATION_JSON) cererea primește 415, nu ajunge la validare;
  • @Transactional pe clasă face rollback după fiecare test, deci produsele create nu afectează alte teste (atenție: doar pentru codul care rulează în același fir, ceea ce e adevărat la MockMvc, dar nu și la un server real pornit cu RANDOM_PORT);
  • un ObjectMapper injectat folosește aceleași setări ca aplicația; un new ObjectMapper() poate serializa diferit.

Ce urmărește intervievatorul: Verifică dacă testezi contractul API-ului, nu doar cazul fericit. Greșeala tipică este lipsa testelor pentru 400, singurele care verifică validarea.

Eroarea, în practică:Content-Type 'text/plain' is not supported (415)JSON parse error: Unexpected character

90 Mid

Ce efect are @Transactional pe o clasă de test Spring și când nu te protejează? Ce face @DirtiesContext și de ce trebuie folosit cu grijă?

Răspuns scurt: Fiecare test rulează într-o tranzacție anulată la final, deci datele dispar. Nu ajută când codul rulează în alt fir sau altă tranzacție (@Async, REQUIRES_NEW, server real). @DirtiesContext recreează contextul și încetinește mult suita.

Cu @Transactional pe clasa de test, Spring TestContext pornește o tranzacție înainte de fiecare test și face rollback după, chiar dacă testul trece. Avantaj: testele nu se influențează între ele.

Capcane:

  • fals pozitive: flush-ul nu are loc niciodată dacă nimic nu îl declanșează, deci o constrângere de bază (NOT NULL, UNIQUE) poate să nu fie verificată; în testele de repository apelezi flush() (sau saveAndFlush) ca SQL-ul să ruleze;
  • comportament diferit de producție: codul din test vede entități gestionate și încărcarea leneșă funcționează, deși în producție, în afara tranzacției, ar arunca LazyInitializationException;
  • alt fir: cu @SpringBootTest(webEnvironment = RANDOM_PORT) și un client HTTP real, cererea rulează în firul serverului, în altă tranzacție, deci rollback-ul testului nu o anulează; la fel pentru @Async și consumatori de mesaje;
  • REQUIRES_NEW în codul testat face commit independent.

Alternative: curățarea explicită în @AfterEach (repo.deleteAll()), scripturi @Sql înainte și după, sau o bază nouă per suită (Testcontainers).

@DirtiesContext: Spring păstrează contextul în cache între clasele de test cu aceeași configurare, ceea ce face suitele rapide. @DirtiesContext marchează contextul ca stricat (singleton-uri cu stare modificată, cache-uri) și forțează recrearea. Folosit des, transformă câteva secunde într-o suită de minute. Fiecare combinație diferită de @MockitoBean, @ActiveProfiles sau properties creează de asemenea un context nou; o configurare comună pentru teste reduce numărul lor.

Ce urmărește intervievatorul: Verifică experiența cu suite de teste reale, care trebuie să fie și corecte, și rapide. Greșeala tipică este un test verde care ar pica în producție din cauza tranzacției de test.

91 Mid

Service-ul tău apelează un API extern de curs valutar prin RestClient. Cum testezi acest cod fără să apelezi API-ul real?

Răspuns scurt: Simulezi serverul HTTP: MockRestServiceServer (legat de RestClient.Builder) sau WireMock (server local real), cu răspunsuri, erori și întârzieri definite în test. Logica de business o testezi separat, cu un fake în spatele unei interfețe.

Separarea în două niveluri:

  • logica de business (conversii, rotunjiri) depinde de o interfață CursValutar; o testezi cu un fake, fără HTTP;
  • adaptorul HTTP (CursValutarClient implements CursValutar) îl testezi cu un server simulat, pentru că acolo pot apărea erorile reale: URL greșit, JSON mapat greșit, tratarea lui 404 și 500, timeout-uri.

Cu MockRestServiceServer și @RestClientTest:

JAVA
@RestClientTest(CursValutarClient.class)
class CursValutarClientTest {
    @Autowired CursValutarClient client;
    @Autowired MockRestServiceServer server;

    @Test
    void citesteCursul() {
        server.expect(requestTo("https://curs.exemplu.ro/api/curs/EUR"))
              .andExpect(method(HttpMethod.GET))
              .andRespond(withSuccess("{\"moneda\":\"EUR\",\"valoare\":4.97}", MediaType.APPLICATION_JSON));

        assertEquals(new BigDecimal("4.97"), client.curs("EUR"));
    }

    @Test
    void monedaNecunoscuta() {
        server.expect(requestTo("https://curs.exemplu.ro/api/curs/XYZ")).andRespond(withResourceNotFound());
        assertThrows(MonedaNecunoscutaException.class, () -> client.curs("XYZ"));
    }
}

Clientul trebuie să-și construiască RestClient-ul din RestClient.Builder-ul injectat, ca serverul simulat să se poată lega de el.

WireMock rulează un server HTTP real, deci testează și configurarea de rețea (timeout-uri reale, antete, retry), funcționează cu orice client și poate simula întârzieri (withFixedDelay). Pentru contractul dintre echipe există și testele de contract (Spring Cloud Contract, Pact), care verifică automat că furnizorul respectă ce așteaptă consumatorul.

Ce urmărește intervievatorul: Verifică dacă știi să testezi integrările fără dependențe externe instabile. Greșeala tipică este testul care apelează API-ul real și pică atunci când acesta nu răspunde.

92 Senior

Cum ai organiza strategia de testare pentru un serviciu Spring Boot cu API REST, bază PostgreSQL și mesaje Kafka? Ce testezi la fiecare nivel?

Răspuns scurt: Pe niveluri: multe teste unitare pentru domeniu, teste de slice pentru web și persistență (cu Testcontainers), câteva teste de integrare cu tot contextul, teste de contract pentru API și mesaje și foarte puține teste end-to-end.

Structura și argumentul pentru fiecare nivel:

  • Domeniu, teste unitare (cele mai multe): reguli de business, calcule, tranziții de stare. Fără Spring, cu fake-uri. Rapide, deci acoperă toate cazurile limită.
  • Web, slice MVC: rute, statusuri, validare, formatul erorilor, securitatea pe URL. Service-urile sunt înlocuite, deci testezi doar contractul HTTP.
  • Persistență: interogările proprii, mapările, constrângerile, migrările Flyway, pe aceeași bază ca în producție, prin Testcontainers. H2 ascunde diferențele de dialect (tipuri, funcții, comportamentul LIKE).
JAVA
@Testcontainers
@DataJpaTest
@AutoConfigureTestDatabase(replace = Replace.NONE)
class ComandaRepositoryTest {
    @Container @ServiceConnection
    static PostgreSQLContainer<?> pg = new PostgreSQLContainer<>("postgres:16");
}

@ServiceConnection (Boot 3.1+) configurează automat conexiunea, fără proprietăți.

  • Integrare: câteva fluxuri complete (plasarea unei comenzi, de la HTTP la bază și la mesajul Kafka), cu @SpringBootTest și containere pentru PostgreSQL și Kafka. Sunt lente, deci acoperă legăturile, nu toate cazurile.
  • Contract: OpenAPI verificat în CI și teste de contract pentru mesaje (schema evenimentelor), ca un consumator să nu fie stricat de o schimbare a producătorului.
  • End-to-end: puține, pe un mediu de test, pentru fluxurile critice.

Principii: teste deterministe (ceas injectat cu Clock, fără sleep, cu Awaitility pentru asincron), date construite în test, nu dependente de ordine, și un număr mic de configurații de context distincte, ca suita să rămână rapidă. Acoperirea de cod e un indicator, nu un scop: un test fără aserțiuni relevante crește procentul fără să protejeze nimic.

Ce urmărește intervievatorul: La senior se verifică echilibrul dintre încredere, viteză și cost de întreținere. Greșeala tipică este o suită formată aproape numai din @SpringBootTest lente și fragile.

Actuator, microservicii și situații reale

93 Junior

Ce oferă Spring Boot Actuator? Ce endpoint-uri expui într-o aplicație de producție și ce trebuie protejat?

Răspuns scurt: Actuator adaugă endpoint-uri de operare: /actuator/health (starea aplicației și a dependențelor), /actuator/info, /actuator/metrics, /actuator/prometheus, /actuator/loggers, /actuator/env. Implicit, prin HTTP este expus doar health. Public lași health (fără detalii); restul se expun pe un port de management intern sau cu autentificare.

După adăugarea spring-boot-starter-actuator:

GET /actuator/health -> {"status":"UP"}

Configurare tipică:

management.endpoints.web.exposure.include=health,info,prometheus
management.endpoint.health.show-details=when-authorized
management.endpoint.health.probes.enabled=true
management.server.port=8081
info.app.versiune=1.4.2
management.info.env.enabled=true

Endpoint-uri utile:

  • health: agregă indicatori (baza de date, spațiul pe disc, broker-ul de mesaje); poți adăuga un HealthIndicator propriu pentru o dependență critică; pentru Kubernetes, /actuator/health/liveness și /actuator/health/readiness;
  • info: versiunea, commit-ul git, date despre build;
  • metrics și prometheus: metrici Micrometer (cereri HTTP pe rută și status, JVM, pool-ul de conexiuni), colectate de Prometheus și afișate în Grafana;
  • loggers: citirea și schimbarea nivelului de logging la rulare;
  • env, configprops, beans, mappings, conditions: diagnostic; heapdump și threaddump: analiză de memorie și fire.

Ce protejezi: env și configprops pot dezvălui configurații (valorile sensibile sunt mascate, dar nu te bazezi doar pe asta), heapdump conține tot conținutul memoriei, inclusiv parole și token-uri, loggers permite modificări. Variante: un port separat accesibil doar din rețeaua internă, autentificare cu un rol de operare, sau neexpunerea lor deloc.

Atenție la health check-uri: un readiness care pică pentru o dependență externă scoate instanța din load balancer, ceea ce e corect; un liveness care pică din același motiv repornește toate instanțele în buclă, ceea ce nu ajută.

Ce urmărește intervievatorul: Verifică dacă te gândești la aplicație și după ce ajunge în producție. Greșeala tipică este exposure.include=* pe portul public.

Eroarea, în practică:Actuator: 404 pe /actuator/infoActuator health: status DOWN (503)

94 Junior

Scrie un client RestClient care cere un produs de la serviciul catalog (GET /produse/{id}) și tratează separat cazul în care produsul nu există și cazul în care serviciul e indisponibil.

Răspuns scurt: Construiești clientul din RestClient.Builder cu baseUrl, apoi get().uri("/produse/{id}", id).retrieve().body(ProdusDto.class). Un 404 aruncă HttpClientErrorException.NotFound (sau îl tratezi cu onStatus), un serviciu oprit sau un timeout aruncă ResourceAccessException, iar un 5xx HttpServerErrorException.

Implementare:

JAVA
record ProdusDto(long id, String nume, BigDecimal pret) { }

@Component
class CatalogClient {
    private final RestClient http;

    CatalogClient(RestClient.Builder builder, @Value("${catalog.url}") String url) {
        this.http = builder.baseUrl(url).build();
    }

    Optional<ProdusDto> produs(long id) {
        try {
            ProdusDto p = http.get()
                    .uri("/produse/{id}", id)
                    .retrieve()
                    .onStatus(s -> s.value() == 404, (req, res) -> { throw new ProdusNegasitException(id); })
                    .body(ProdusDto.class);
            return Optional.ofNullable(p);
        } catch (ProdusNegasitException e) {
            return Optional.empty();
        } catch (ResourceAccessException e) {
            throw new CatalogIndisponibilException("Catalogul nu răspunde", e);
        }
    }
}

Ce se întâmplă în fiecare caz:

  • 200: Jackson citește corpul în ProdusDto;
  • 404: handler-ul din onStatus aruncă excepția de domeniu; fără el, retrieve() ar arunca HttpClientErrorException.NotFound;
  • 5xx: HttpServerErrorException; o lași să ajungă la un handler care întoarce 502 sau 503 clientului tău, nu 500;
  • serviciu oprit, DNS greșit sau timeout: ResourceAccessException (I/O error on GET request for ...: Connection refused).

Lucruri pe care nu le uiți: timeout-uri (implicit, unele implementări așteaptă foarte mult; în Boot 3.4+ spring.http.client.connect-timeout și read-timeout), parametrii prin template {id}, nu prin concatenare, și folosirea builder-ului injectat, care aduce configurarea Boot, metrici și tracing. RestClient (Spring 6.1) înlocuiește RestTemplate în codul nou, cu un API fluent și sincron; pentru clienți declarativi există interfețele @HttpExchange sau OpenFeign.

Ce urmărește intervievatorul: Verifică dacă știi că apelurile între servicii pot eșua în moduri diferite. Greșeala tipică este un singur catch (Exception e) și lipsa timeout-urilor.

Eroarea, în practică:I/O error on GET request: Connection refusedHttpClientErrorException$NotFound: 404 Not Found

95 Mid

Cum consumi mesaje Kafka într-o aplicație Spring Boot? Ce înseamnă grupul de consumatori și livrarea at-least-once pentru codul tău?

Răspuns scurt: Cu spring-kafka: trimiți cu KafkaTemplate.send(topic, cheie, mesaj) și consumi cu @KafkaListener(topics = "comenzi", groupId = "facturare"). Fiecare grup primește toate mesajele, iar în grup partițiile sunt împărțite între instanțe. At-least-once înseamnă că un mesaj poate veni de două ori, deci consumatorul trebuie să fie idempotent.

Producător și consumator:

JAVA
record ComandaPlasata(long comandaId, String email, BigDecimal total) { }

@Service
class ComandaService {
    private final KafkaTemplate<String, ComandaPlasata> kafka;

    void plaseaza(Comanda c) {
        kafka.send("comenzi", String.valueOf(c.getId()), new ComandaPlasata(c.getId(), c.getEmail(), c.getTotal()));
    }
}

@Component
class FacturaListener {
    @KafkaListener(topics = "comenzi", groupId = "facturare")
    void laComanda(ComandaPlasata e) {
        if (facturi.existaPentruComanda(e.comandaId())) {
            return;                       // mesaj repetat: deja procesat
        }
        facturi.emite(e);
    }
}

Concepte:

  • un topic are partiții; mesajele cu aceeași cheie ajung în aceeași partiție, deci își păstrează ordinea (toate evenimentele unei comenzi, în ordine);
  • grupul de consumatori: serviciile facturare și notificari, cu grupuri diferite, primesc fiecare toate mesajele; trei instanțe ale facturare își împart partițiile, deci fiecare mesaj e procesat o singură dată în grup;
  • Spring confirmă offset-ul după ce metoda se termină fără excepție; dacă instanța cade înainte de confirmare, mesajul e livrat din nou: at-least-once;
  • o excepție duce la reîncercări (DefaultErrorHandler, cu backoff) și apoi, opțional, la un topic de mesaje moarte (DeadLetterPublishingRecoverer), ca un mesaj stricat să nu blocheze partiția.

De aici, regula: consumatorul idempotent, cu verificare după un id de eveniment sau o constrângere unică în bază. Pentru a nu pierde evenimente când trimiți după salvarea în bază, folosești pattern-ul outbox: evenimentul se scrie în aceeași tranzacție cu datele, iar un proces separat îl publică.

Ce urmărește intervievatorul: Verifică dacă înțelegi garanțiile unui broker de mesaje, nu doar API-ul. Greșeala tipică este un consumator care emite două facturi pentru același mesaj livrat de două ori.

96 Mid

Echipa ta trebuie să migreze o aplicație de la Spring Boot 2.7 la Spring Boot 3. Cum procedezi și la ce probleme te aștepți?

Răspuns scurt: Pregătești terenul pe 2.7 (Java 17, eliminarea API-urilor depreciate), apoi treci la Boot 3: pachetele javax.* devin jakarta.*, Spring Security 6 (fără WebSecurityConfigurerAdapter), Hibernate 6, schimbări de proprietăți. Folosești OpenRewrite pentru modificările mecanice, spring-boot-properties-migrator pentru proprietăți, și te bazezi pe teste.

Un plan structurat, ca la orice migrare mare:

Pregătire, încă pe 2.7:

  • treci pe Java 17 (minimul pentru Boot 3) și pe ultima versiune 2.7.x;
  • elimini avertismentele de depreciere: în Boot 3 dispar API-urile depreciate;
  • verifici bibliotecile terțe: fiecare trebuie să aibă o versiune compatibilă cu Jakarta EE 9+;
  • te asiguri că ai teste de integrare pe fluxurile principale; ele sunt plasa de siguranță.

Migrarea propriu-zisă, pe o ramură separată:

  • javax.persistence, javax.validation, javax.servlet devin jakarta.*; rețeta OpenRewrite UpgradeSpringBoot_3_0 face automat importurile, dependențele și multe alte schimbări;
  • Spring Security 6: configurarea prin bean SecurityFilterChain, authorizeHttpRequests și requestMatchers în loc de antMatchers;
  • Hibernate 6: interogări JPQL validate mai strict, alte tipuri implicite, generatoare de id-uri schimbate;
  • spring-boot-properties-migrator, adăugat temporar, raportează la pornire proprietățile redenumite;
  • potrivirea URL-urilor: în Spring 6, /produse/ nu mai e același lucru cu /produse (trailing slash), ceea ce poate strica clienți;
  • jurnalele, metricile (Micrometer Observation) și tracing-ul (Sleuth înlocuit de Micrometer Tracing).

Livrare: pe un mediu de test cu date realiste, apoi treptat (canary), urmărind erorile și performanța.

Ca răspuns la interviu, structura contează: pregătire, unelte, riscuri cunoscute, verificare, livrare treptată și cum comunici echipei progresul, nu doar lista de schimbări.

Ce urmărește intervievatorul: Este o întrebare de situație despre experiență practică. Intervievatorul urmărește dacă ai un plan și unelte, nu doar „schimbi importurile”.

Eroarea, în practică:package javax.validation.constraints does not existpackage javax.persistence does not exist

97 Mid

Un endpoint de plasare a comenzilor dă din când în când 500 în producție, iar local nu poți reproduce problema. Cum procedezi?

Răspuns scurt: Pornești de la date: metricile arată când și unde apare, jurnalele după traceId dau stack trace-ul complet. Formulezi ipoteze (date neașteptate, concurență, timeout), le verifici, repari cu un test care reproduce cazul și monitorizezi după livrare.

Un răspuns structurat:

1. Delimitezi problema. Metricile HTTP (http.server.requests cu status=500, pe rută) arată frecvența și momentul: constant, la orele de vârf, după un deploy anume, pe o singură instanță? Fiecare variantă indică altă cauză.

2. Găsești cererile concrete. Cu un traceId în jurnale (Micrometer Tracing pune traceId în MDC), vezi tot drumul unei cereri eșuate, inclusiv apelurile spre alte servicii. Citești stack trace-ul complet, până la Caused by.

3. Ipoteze tipice pentru „din când în când”:

  • date neașteptate: un câmp null pentru clienții vechi, un caracter special, o comandă cu zero linii;
  • concurență: două cereri simultane pentru același stoc (DataIntegrityViolationException, ObjectOptimisticLockingFailureException);
  • dependențe: timeout la serviciul de plăți, pool de conexiuni epuizat (HikariPool... Connection is not available, request timed out);
  • resurse: memorie, fire blocate, o instanță cu configurare diferită.

4. Reproduci. Cu datele reale ale cererii (anonimizate), un test care o trimite; pentru concurență, un test cu cereri paralele.

5. Repari și previi. Corecția vine cu testul care reproducea problema; adaugi tratarea explicită a erorii (de exemplu 409 în loc de 500 la conflict), jurnale mai bune unde lipseau informații și o alertă dacă rata erorilor crește.

6. Comunici. Dacă au fost afectați clienți (comenzi pierdute), informezi echipa de suport și verifici datele.

Ce nu faci: modificări „la ghici” direct în producție sau catch (Exception e) care ascunde eroarea.

Ce urmărește intervievatorul: Este o întrebare de situație care verifică metoda de depanare. Răspunsul bun e o succesiune de pași bazați pe date, nu o listă de tehnologii.

Eroarea, în practică:Servlet.service() for servlet [dispatcherServlet]There was an unexpected error, status=500

98 Mid

Un coleg nou pune toată logica (validări, calcule, apeluri la repository, construirea răspunsului) direct în controller. Cum îi explici de ce e mai bine să separe straturile, fără să sune ca o regulă impusă?

Răspuns scurt: Pornești de la probleme concrete din codul lui: logica din controller nu se poate refolosi dintr-un job sau consumator și se testează doar prin HTTP. Îi arăți, în pereche, o refactorizare mică: controller subțire, service cu logica, repository pentru date.

O structură pentru conversație:

1. Începi cu ce face bine. Codul funcționează și e ușor de urmărit acum; asta contează.

2. Arăți o problemă reală, nu o regulă. De exemplu: „Mâine trebuie să plasăm aceeași comandă și dintr-un mesaj Kafka. Unde ar sta logica?” Dacă e în controller, fie o copiezi, fie apelezi controller-ul din consumator, cu obiecte HTTP false.

3. Explici rolurile cu codul lui:

JAVA
@PostMapping("/comenzi")
ResponseEntity<ComandaDto> plaseaza(@Valid @RequestBody ComandaNoua cerere) {
    ComandaDto c = comenzi.plaseaza(cerere);   // logica în service
    return ResponseEntity.created(URI.create("/comenzi/" + c.id())).body(c);
}
  • controller-ul traduce HTTP: citește cererea, validează forma, alege statusul;
  • service-ul aplică regulile (stoc, reduceri, tranzacția) și nu știe de HTTP;
  • repository-ul vorbește cu baza.

4. Arăți câștigul la teste. Logica din service se testează în milisecunde, fără server, cu un fake; testul controller-ului verifică doar statusuri și JSON.

5. Faci schimbarea împreună, în pair programming, pe o singură funcționalitate, nu ceri rescrierea a tot. Lași o notă în ghidul echipei.

6. Accepți nuanțele. Pentru un endpoint care doar citește o listă, un service „pass-through” poate părea birocrație; regula e un instrument, nu un scop.

Intervievatorul urmărește empatia, argumentele concrete și dacă transformi corectura într-o ocazie de învățare.

Ce urmărește intervievatorul: Este o întrebare comportamentală despre comunicare și mentorat. Greșeala tipică este un răspuns de tipul „îi spun că așa e best practice”.

99 Senior

Serviciul de comenzi apelează serviciul de stoc, care uneori devine foarte lent. Cum folosești timeout-uri, retry și circuit breaker ca să nu cadă tot sistemul?

Răspuns scurt: Întâi timeout-uri scurte, ca firele să nu aștepte la nesfârșit. Retry cu backoff doar pentru erori tranzitorii și operații idempotente. Un circuit breaker oprește apelurile peste un prag de eșecuri, răspunde cu o variantă de rezervă și testează periodic revenirea.

Fără protecții, un serviciu lent se propagă în lanț: cererile spre stoc țin firele ocupate, pool-ul serviciului comenzi se epuizează, iar acum și comenzi pare căzut pentru toate rutele (cascading failure).

Mecanismele, în ordinea în care le aplici:

  • timeout: conectare și citire limitate (de exemplu sute de milisecunde pentru un apel intern); cu Boot 3.4+: spring.http.client.read-timeout=500ms;
  • retry: doar pentru erori tranzitorii (conexiune refuzată, 503) și operații idempotente; cu backoff exponențial și jitter, ca reîncercările să nu lovească simultan; fără retry la 4xx;
  • circuit breaker: numără eșecurile într-o fereastră; peste prag trece în starea OPEN și refuză imediat apelurile (CallNotPermittedException); după o pauză trece în HALF_OPEN, lasă câteva apeluri de probă și se închide dacă reușesc;
  • bulkhead: limitează apelurile concurente spre o dependență, ca ea să nu consume toate firele.
JAVA
@CircuitBreaker(name = "stoc", fallbackMethod = "stocNecunoscut")
@Retry(name = "stoc")
public StocDto stoc(long produsId) {
    return stocClient.get().uri("/stoc/{id}", produsId).retrieve().body(StocDto.class);
}

StocDto stocNecunoscut(long produsId, Throwable t) {
    return new StocDto(produsId, null, "INDISPONIBIL");
}
YAML
resilience4j:
  circuitbreaker.instances.stoc:
    sliding-window-size: 20
    failure-rate-threshold: 50
    wait-duration-in-open-state: 10s
  retry.instances.stoc:
    max-attempts: 3
    wait-duration: 200ms

Ordinea aspectelor contează: retry în interiorul circuit breaker-ului, ca reîncercările să fie numărate corect. Fallback-ul trebuie să fie o decizie de business (comanda se acceptă cu „stoc de confirmat”), nu o ascundere a erorii. Toate stările se monitorizează (metricile Resilience4j în Actuator), iar valorile pragurilor se aleg din măsurători, nu din exemple.

Ce urmărește intervievatorul: La senior se verifică înțelegerea defectelor în sisteme distribuite. Greșeala tipică este retry agresiv fără timeout, care amplifică exact problema pe care trebuia s-o rezolve.

Eroarea, în practică:I/O error on GET request: Read timed outCircuitBreaker 'x' is OPEN and does not permit calls

100 Senior

Pentru un produs nou, o echipă de cinci programatori trebuie să aleagă între un monolit modular Spring Boot și microservicii. Cum argumentezi decizia?

Răspuns scurt: Pornești de la constrângeri: mărimea echipei, maturitatea operațională, nevoile de scalare și claritatea domeniului. Pentru cinci oameni și un domeniu în schimbare, un monolit modular cu granițe clare e de obicei mai sigur; extragi servicii când ai un motiv măsurabil.

Un răspuns structurat, ca o decizie de arhitectură (ADR):

Context. Cinci programatori, produs nou, cerințe care se vor schimba, infrastructură încă de construit.

Ce aduc microserviciile: livrare independentă pe echipe, scalare separată, izolarea defectelor, tehnologii diferite. Ce costă: rețea între componente (latență, eșecuri parțiale, timeout-uri, retry), consistență eventuală în loc de tranzacții, observabilitate distribuită (tracing), pipeline-uri și deploy pentru fiecare serviciu, contracte versionate. O echipă de cinci oameni ar petrece mult timp pe infrastructură în loc de produs.

Monolitul modular: o singură aplicație Spring Boot, împărțită pe module de domeniu (comenzi, catalog, plati), fiecare cu API public și date proprii; modulele comunică prin interfețe sau evenimente interne, nu accesând direct tabelele celorlalte. Spring Modulith poate verifica automat aceste reguli în teste.

ro.magazin.comenzi   (api, intern)
ro.magazin.catalog   (api, intern)
ro.magazin.plati     (api, intern)

Decizia propusă: monolit modular acum, cu criterii explicite pentru extragerea unui serviciu: o parte care trebuie scalată separat, o echipă nouă care are nevoie de ritm propriu de livrare, cerințe de izolare (plăți, conformitate). Granițele clare fac extragerea ulterioară mult mai ieftină.

Riscuri și cum le urmărești: modulele se pot cupla în timp; testele de arhitectură și review-ul le păstrează separate.

Intervievatorul urmărește compromisurile, nu răspunsul „corect”. Un argument bun recunoaște când microserviciile sunt totuși potrivite: mai multe echipe, domenii stabile, cerințe diferite de scalare sau disponibilitate.

Ce urmărește intervievatorul: Este o întrebare de judecată arhitecturală. Greșeala tipică este alegerea microserviciilor „pentru că așa se face”, fără costurile operaționale.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Spring Boot, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Spring Boot scriind cod, nu doar citind

Curs Spring Boot și REST API: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 18 lecții sunt gratuite.