...
← Curs Spring Boot și REST API: toate lecțiile
Lecția 15 · Configurare

Configurare cu application.properties și @Value

Portul serverului, numele magazinului, pragul pentru livrarea gratuită: valori care se schimbă fără să schimbi codul. Locul lor este fișierul application.properties, iar în cod le citești cu @Value. Afli și cum dai o valoare implicită și ce se întâmplă când o proprietate lipsește.

Fișierul application.properties

Într-un proiect real, fișierul stă în src/main/resources/application.properties. Fiecare rând este o pereche cheie=valoare; cheile sunt grupate cu puncte, ca niște directoare:

# setări Spring Boot
server.port=8081
spring.application.name=catalog

# setările tale
app.magazin.nume=Librăria Ana
app.livrare.prag=200
  • server.port: portul pe care pornește Tomcat (implicit 8080);
  • spring.application.name: numele aplicației (apare în jurnale și, mai târziu, la microservicii);
  • app.*: proprietăți proprii; prefixul app. nu e obligatoriu, dar e o convenție bună ca să nu se amestece cu cele ale lui Spring.
  • rândurile care încep cu # sunt comentarii.
În laborator

Laboratorul nu are directoare: fișierul vine fie din exercițiu (setarea files), fie îl scrii chiar în Application.java, ca un comentariu bloc al cărui prim rând este numele fișierului: /* application.properties ... */. L-ai văzut deja în lecțiile 6 și 7, pentru server.error.include-message. Într-un proiect real, fiecare fișier stă separat, în src/main/resources.

@Value: o proprietate într-un câmp

@Value("${cheie}") pe un câmp îi spune lui Spring: „pune aici valoarea proprietății cheie”. Spring o completează la pornire, înainte de prima cerere. Merge și pentru proprietățile Spring, ca spring.application.name:

/* application.properties
server.port=8081
spring.application.name=catalog
app.mesaj=Bine ai venit în catalog
*/

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Value;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RestController
class CatalogController {
    @Value("${app.mesaj}")
    private String mesaj;

    @Value("${spring.application.name}")
    private String numeAplicatie;

    @GetMapping("/")
    String acasa() {
        return mesaj + " (aplicația " + numeAplicatie + ")";
    }
}

// > GET /
Tomcat started on port 8081 (http)
Started Application
GET / → 200
Bine ai venit în catalog (aplicația catalog)

Observă prima linie: serverul a pornit pe portul 8081, citit din server.port. Sintaxa ${...} din @Value înseamnă „valoarea proprietății”; fără ea, @Value("app.mesaj") ar pune chiar textul app.mesaj.

Tipuri și valori implicite

Valoarea din fișier este text, dar Spring o convertește la tipul câmpului: int, double, boolean. După două puncte poți da o valoare implicită, folosită când proprietatea lipsește: ${app.livrare.cost:15}.

/* application.properties
app.livrare.prag=200
app.livrare.activa=true
*/

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Value;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RestController
class LivrareController {
    @Value("${app.livrare.prag}")
    private int prag;

    @Value("${app.livrare.activa}")
    private boolean activa;

    @Value("${app.livrare.cost:15}")
    private double cost;

    @Value("${app.livrare.firma:FanCurier}")
    private String firma;

    @GetMapping("/livrare/{valoare}")
    String livrare(@PathVariable int valoare) {
        if (!activa) {
            return "Livrarea este oprită";
        }
        if (valoare >= prag) {
            return "Livrare gratuită cu " + firma;
        }
        return "Livrare " + cost + " lei cu " + firma + " (gratuită de la " + prag + " lei)";
    }
}

// > GET /livrare/250
// > GET /livrare/120
Tomcat started on port 8080 (http)
Started Application
GET /livrare/250 → 200
Livrare gratuită cu FanCurier
GET /livrare/120 → 200
Livrare 15.0 lei cu FanCurier (gratuită de la 200 lei)

cost și firma nu sunt în fișier, deci primesc valorile implicite (15, convertit la 15.0, și FanCurier). Ca să schimbi pragul de livrare gratuită, modifici doar fișierul: codul rămâne neatins.

Proprietate lipsă, fără valoare implicită

Dacă @Value("${app.magazin.nume}") nu găsește proprietatea și nu are valoare implicită, aplicația nu pornește. În jurnal apare motivul:

Could not resolve placeholder 'app.magazin.nume' in value "${app.magazin.nume}"

Se citește: „nu pot înlocui ${app.magazin.nume}, pentru că proprietatea nu există”. Cauze obișnuite: o greșeală de scriere în cheie (app.magazn.nume), fișierul pus în alt director sau proprietatea uitată pe un server nou. E un comportament bun: mai bine nu pornește decât să pornească cu o valoare greșită.

De ce configurare separată

MediuExemplu de diferențe
laptopul tăuport 8080, bază de date locală, jurnale detaliate
serverul de testaltă bază de date, alt prag de reducere de probă
producțieport 80/443, baza reală, jurnale doar pentru erori

Același cod rulează în toate mediile; se schimbă doar configurarea. Mai târziu în curs înveți profilurile (application-dev.properties, application-prod.properties) și cum grupezi proprietățile într-un record cu @ConfigurationProperties.

Parolele nu stau în cod

Parolele bazelor de date și cheile API nu se scriu în cod și nici în fișierul din Git. În producție vin din variabile de mediu sau dintr-un serviciu de secrete, iar Spring le citește la fel, ca proprietăți.

Pe scurt

  • application.properties (în src/main/resources) conține perechi cheie=valoare.
  • server.port schimbă portul; spring.application.name dă numele aplicației.
  • @Value("${cheie}") pune valoarea într-un câmp, convertită la tipul lui.
  • ${cheie:implicit} dă o valoare implicită; o proprietate lipsă fără implicit oprește pornirea.
  • În laborator, fișierul vine din exercițiu sau dintr-un comentariu /* application.properties ... */.
Exercițiul tău

Fișierul application.properties al exercițiului conține deja server.port=9090, app.magazin.nume=Librăria Ana și app.magazin.reducere=15 (laboratorul îl încarcă singur, nu trebuie să-l scrii). Citește numele și reducerea cu @Value și fă ca GET /info să întoarcă Magazin: Librăria Ana, reducere: 15%. Valorile se citesc din proprietăți, nu se scriu în cod.

  • Adaugă un câmp String nume cu @Value("${app.magazin.nume}").
  • Adaugă un câmp int reducere cu @Value("${app.magazin.reducere}").
  • În info(), întoarce "Magazin: " + nume + ", reducere: " + reducere + "%".
  • Observă că serverul pornește pe portul 9090.
Importul org.springframework.beans.factory.annotation.Value există deja. Nu uita ${ și } în jurul cheii.

Soluția exercițiului

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Value;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RestController
class InfoController {
    @Value("${app.magazin.nume}")
    private String nume;

    @Value("${app.magazin.reducere}")
    private int reducere;

    @GetMapping("/info")
    String info() {
        return "Magazin: " + nume + ", reducere: " + reducere + "%";
    }
}
Excelent! Continuă cu lecția următoare →
Application.javaSpring Boot
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Primul tău API cu Spring Boot Lecția 15 · Configurare cu application.properties și @Value
Progres 0% 0 din 20
Lecția curentă 15 / 18 Configurare