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.
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/120Tomcat 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ă
| Mediu | Exemplu de diferențe |
|---|---|
| laptopul tău | port 8080, bază de date locală, jurnale detaliate |
| serverul de test | altă bază de date, alt prag de reducere de probă |
| producție | port 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 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 ... */.
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.
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 + "%";
}
} 