{
  "isbn": "978-0000000001",
  "titol": "Java Eficac",
  "autor": "Joshua Bloch",
  "anyPublicacio": 2018,
  "disponible": true,
  "categories": ["Java", "Bones practiques"],
  "editorial": {
    "nom": "Addison-Wesley",
    "pais": "EUA"
  },
  "dataAlta": "2026-01-15",
  "valoracio": null
}

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <!-- sense version: la gestiona el BOM de Spring Boot (11-05) -->
</dependency>

<!-- Suport per a java.time (apartat 10) -->
<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>

// MALAMENT: crea un mapper a cada crida. Llenca la memoria cau cada vegada.
public String aJson(Material material) {
    return new ObjectMapper().writeValueAsString(material);   // lent i amb brossa
}

// BE: un de sol, compartit
private static final ObjectMapper MAPPER = new ObjectMapper();

public String aJson(Material material) {
    return MAPPER.writeValueAsString(material);
}

@Service
public class ExportadorCataleg {

    private final ObjectMapper mapper;   // Spring injecta el seu, ja configurat

    public ExportadorCataleg(ObjectMapper mapper) {
        this.mapper = mapper;
    }
}

package com.nexussoftware.bibliotech.persistencia;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.JsonProcessingException;

public class ExportadorJson {

    private final ObjectMapper mapper;

    public ExportadorJson(ObjectMapper mapper) { this.mapper = mapper; }

    public String exportar(Material material) {
        try {
            return mapper.writeValueAsString(material);
        } catch (JsonProcessingException e) {
            // Estrategia per capes del modul 6: embolcallar, conservar la causa
            throw new ExportacioException("No s'ha pogut serialitzar " + material.getIsbn(), e);
        }
    }

    public String exportarLlegible(Material material) {
        try {
            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(material);
        } catch (JsonProcessingException e) {
            throw new ExportacioException("No s'ha pogut serialitzar", e);
        }
    }

    public void exportarAFitxer(List<Material> cataleg, Path desti) throws IOException {
        mapper.writeValue(desti.toFile(), cataleg);         // sense carregar-ho tot en memoria
    }
}

{"isbn":"978-0000000001","titol":"Java Eficac","autor":"Joshua Bloch","exemplarsDisponibles":3}

{
  "isbn" : "978-0000000001",
  "titol" : "Java Eficac",
  "autor" : "Joshua Bloch",
  "exemplarsDisponibles" : 3
}

public Material importar(String json) {
    try {
        return mapper.readValue(json, Llibre.class);
    } catch (JsonProcessingException e) {
        throw new ImportacioException("JSON de material invalid", e);
    }
}

Llibre desDeCadena  = mapper.readValue(json, Llibre.class);
Llibre desDeFitxer  = mapper.readValue(Path.of("llibre.json").toFile(), Llibre.class);
Llibre desDeFlux    = mapper.readValue(entrada, Llibre.class);
Llibre desDUrl      = mapper.readValue(new URL("https://..."), Llibre.class);

com.fasterxml.jackson.databind.exc.InvalidDefinitionException:
Cannot construct instance of `com.nexussoftware.bibliotech.domini.Llibre`
(no Creators, like default constructor, exist)

public class MetadadesLlibre {

    private String isbn;
    private String titol;
    private String autor;
    private int anyPublicacio;

    public MetadadesLlibre() { }   // exigit per Jackson

    // getters i setters...
}

public record MetadadesLlibre(String isbn, String titol, String autor, int anyPublicacio) { }

public record MetadadesLlibre(
        String isbn,
        String titol,
        Autor autor,                    // objecte imbricat
        List<String> categories,        // array
        LocalDate dataPublicacio) {     // data ISO (apartat 10)

    public record Autor(String nom, String pais) { }
}

{
  "isbn": "978-0000000001",
  "titol": "Java Eficac",
  "autor": { "nom": "Joshua Bloch", "pais": "EUA" },
  "categories": ["Java", "Bones practiques"],
  "dataPublicacio": "2018-01-06"
}

package com.nexussoftware.bibliotech.xarxa;

import com.fasterxml.jackson.annotation.*;
import java.time.LocalDate;
import java.util.List;

@JsonIgnoreProperties(ignoreUnknown = true)      // imprescindible: apartat 8
@JsonInclude(JsonInclude.Include.NON_NULL)       // no serialitzar nuls
public record RespostaMetadades(

        @JsonProperty("isbn_13")                 // l'API fa servir snake_case
        String isbn,

        @JsonAlias({"title", "book_title"})      // l'API va canviar el nom a la v2
        String titol,

        @JsonProperty("authors")
        List<String> autors,

        @JsonProperty("publish_date")
        @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
        LocalDate dataPublicacio,

        @JsonProperty("number_of_pages")
        Integer pagines) {
}

public class UsuariDto {
    private String correu;

    @JsonIgnore
    private String hashContrasenya;   // MAI no ha de sortir en una resposta
}

public record MetadadesLlibre(String isbn, String titol) { }

{
  "isbn": "978-0000000001",
  "titol": "Java Eficac",
  "idioma": "ca"
}

com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException:
Unrecognized field "idioma" (class MetadadesLlibre), not marked as ignorable

@JsonIgnoreProperties(ignoreUnknown = true)
public record MetadadesLlibre(String isbn, String titol) { }

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

spring:
  jackson:
    deserialization:
      fail-on-unknown-properties: false   # valor per defecte a Spring Boot

// NO FUNCIONA com esperes
List<MetadadesLlibre> llista = mapper.readValue(json, List.class);
// -> retorna List<LinkedHashMap>, i esclata en fer-lo servir:
// ClassCastException: LinkedHashMap cannot be cast to MetadadesLlibre

List<MetadadesLlibre> llista = mapper.readValue(json,
        new TypeReference<List<MetadadesLlibre>>() { });

// Llista
List<Material> materials = mapper.readValue(json, new TypeReference<>() { });

// Mapa
Map<String, List<Prestec>> perEmpleat = mapper.readValue(json, new TypeReference<>() { });

// Generic propi: el Resultat<T> de 10-01
Resultat<Material> resultat = mapper.readValue(json, new TypeReference<Resultat<Material>>() { });

JavaType tipus = mapper.getTypeFactory().constructCollectionType(List.class, Material.class);
List<Material> materials = mapper.readValue(json, tipus);

com.fasterxml.jackson.databind.exc.InvalidDefinitionException:
Java 8 date/time type `java.time.LocalDate` not supported by default:
add Module "com.fasterxml.jackson.datatype:jackson-datatype-jsr310"

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);   // important!

ObjectMapper mapper = JsonMapper.builder()
        .findAndAddModules()
        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
        .build();

// Activat (valor per defecte de Jackson): nombre de segons des de 1970
{"instantRegistre": 1774000800.000000000}

// Desactivat: ISO-8601, llegible i interoperable
{"instantRegistre": "2026-03-20T09:00:00Z"}

spring:
  jackson:
    serialization:
      write-dates-as-timestamps: false
    time-zone: Europe/Madrid
    default-property-inclusion: non_null

CsvMapper mapper = new CsvMapper();
CsvSchema esquema = mapper.schemaFor(MaterialCsv.class).withHeader().withColumnSeparator(';');

// Escriure
mapper.writer(esquema).writeValue(fitxer, materials);

// Llegir
List<MaterialCsv> materials = mapper.readerFor(MaterialCsv.class)
        .with(esquema).<MaterialCsv>readValues(fitxer).readAll();

JsonNode arrel = mapper.readTree(json);

String titol = arrel.path("titol").asText();
int any      = arrel.path("anyPublicacio").asInt(0);            // 0 si falta
String pais  = arrel.path("editorial").path("pais").asText("Desconegut");

// Recorrer un array
for (JsonNode categoria : arrel.path("categories")) {
    System.out.println(categoria.asText());
}

// Comprovar existencia
if (arrel.has("valoracio") && !arrel.get("valoracio").isNull()) {
    double valoracio = arrel.get("valoracio").asDouble();
}

// Construir JSON a ma
ObjectNode nou = mapper.createObjectNode();
nou.put("isbn", "978-0000000001");
nou.put("titol", "Java Eficac");
nou.putArray("categories").add("Java").add("Bones practiques");
String json = mapper.writeValueAsString(nou);

// Sense serialitzador propi: {"isbn": {"valor": "978-0000000001"}}
// Amb serialitzador propi: {"isbn": "978-0000000001"}

package com.nexussoftware.bibliotech.persistencia;

import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import java.io.IOException;

public class SerialitzadorIsbn extends JsonSerializer<Isbn> {
    @Override
    public void serialize(Isbn isbn, JsonGenerator gen, SerializerProvider sp)
            throws IOException {
        gen.writeString(isbn.valor());
    }
}

public class DeserialitzadorIsbn extends JsonDeserializer<Isbn> {
    @Override
    public Isbn deserialize(JsonParser p, DeserializationContext ctx) throws IOException {
        String text = p.getText();
        try {
            return new Isbn(text);           // la validacio del record actua aqui
        } catch (IsbnInvalidException e) {
            throw JsonMappingException.from(p, "ISBN invalid: " + text, e);
        }
    }
}

// Opcio 1: al camp
public record MaterialDto(
        @JsonSerialize(using = SerialitzadorIsbn.class)
        @JsonDeserialize(using = DeserialitzadorIsbn.class)
        Isbn isbn,
        String titol) { }

// Opcio 2: en un modul, aplicat a TOTS els Isbn
SimpleModule modul = new SimpleModule("BiblioTech");
modul.addSerializer(Isbn.class, new SerialitzadorIsbn());
modul.addDeserializer(Isbn.class, new DeserialitzadorIsbn());
mapper.registerModule(modul);

@Bean
public Module modulBiblioTech() {
    SimpleModule modul = new SimpleModule("BiblioTech");
    modul.addSerializer(Isbn.class, new SerialitzadorIsbn());
    modul.addDeserializer(Isbn.class, new DeserialitzadorIsbn());
    return modul;
}

// 09-06: l'"apedacament didactic" reconegut com a tal
public class ClientMetadades {

    public Optional<String> extreureTitol(String json) {
        int inici = json.indexOf("\"title\":\"");
        if (inici < 0) return Optional.empty();
        inici += 9;
        int fi = json.indexOf("\"", inici);
        if (fi < 0) return Optional.empty();
        return Optional.of(json.substring(inici, fi));
    }

    public Optional<String> extreureAutor(String json) {
        // ... el mateix, un altre cop
    }
}

package com.nexussoftware.bibliotech.xarxa;

import com.fasterxml.jackson.annotation.*;
import java.time.LocalDate;
import java.util.List;

/** Resposta de l'API externa de metadades. Es un DTO: reflecteix el JSON, no el domini. */
@JsonIgnoreProperties(ignoreUnknown = true)   // l'API pot afegir camps quan vulgui
public record RespostaMetadades(

        @JsonProperty("isbn_13")     String isbn,
        @JsonAlias({"title"})        String titol,
        @JsonProperty("authors")     List<Autor> autors,
        @JsonProperty("publish_date") LocalDate dataPublicacio,
        @JsonProperty("number_of_pages") Integer pagines,
        @JsonProperty("publishers")  List<String> editorials) {

    @JsonIgnoreProperties(ignoreUnknown = true)
    public record Autor(String name, String key) { }

    /** Tradueix el DTO extern al model de domini de BiblioTech. */
    public MetadadesLlibre aDomini() {
        String autorsUnits = autors == null ? null
                : autors.stream().map(Autor::name).collect(Collectors.joining(", "));
        String editorial = editorials == null || editorials.isEmpty()
                ? null : editorials.get(0);
        return new MetadadesLlibre(autorsUnits, dataPublicacio, editorial, pagines);
    }
}

package com.nexussoftware.bibliotech.xarxa;

import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.*;
import java.time.Duration;
import java.util.Optional;
import org.slf4j.*;
import org.springframework.stereotype.Component;

@Component
public class PassarelaMetadadesHttp implements PassarelaMetadades {

    private static final Logger log = LoggerFactory.getLogger(PassarelaMetadadesHttp.class);

    private final HttpClient http;          // un de sol, injectat (11-02)
    private final ObjectMapper mapper;      // un de sol, injectat
    private final String urlBase;

    public PassarelaMetadadesHttp(HttpClient http, ObjectMapper mapper,
                                  @Value("${bibliotech.metadades.url}") String urlBase) {
        this.http = http;
        this.mapper = mapper;
        this.urlBase = urlBase;
    }

    @Override
    public Optional<MetadadesLlibre> cercarPerIsbn(String isbn) {

        HttpRequest peticio = HttpRequest.newBuilder()
                .uri(URI.create(urlBase + "/isbn/" + isbn + ".json"))
                .header("Accept", "application/json")
                .timeout(Duration.ofSeconds(5))
                .GET()
                .build();

        try {
            HttpResponse<String> resposta =
                    http.send(peticio, HttpResponse.BodyHandlers.ofString());

            if (resposta.statusCode() == 404) {
                log.debug("L'API no coneix l'ISBN {}", isbn);
                return Optional.empty();
            }
            if (resposta.statusCode() >= 500) {
                throw new PassarelaNoDisponibleException(
                        "L'API ha retornat " + resposta.statusCode());
            }

            // UNA LINIA. Sense indexOf, sense substring, sense casos limit sense cobrir.
            RespostaMetadades dto = mapper.readValue(resposta.body(), RespostaMetadades.class);

            log.info("Metadades obtingudes per a {}: {}", isbn, dto.titol());
            return Optional.of(dto.aDomini());

        } catch (JsonProcessingException e) {
            log.warn("Resposta JSON invalida per a {}", isbn, e);
            throw new PassarelaNoDisponibleException("Resposta illegible de l'API", e);
        } catch (IOException | InterruptedException e) {
            if (e instanceof InterruptedException) Thread.currentThread().interrupt();
            throw new PassarelaNoDisponibleException("Error de xarxa en consultar " + isbn, e);
        }
    }
}

// PERILLOS amb dades externes
mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                             ObjectMapper.DefaultTyping.NON_FINAL);

{"@class": "com.exemple.ClassePerillosa", "propietat": "valor"}

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "tipus")
@JsonSubTypes({
    @JsonSubTypes.Type(value = LlibreDto.class,  name = "LLIBRE"),
    @JsonSubTypes.Type(value = RevistaDto.class, name = "REVISTA"),
    @JsonSubTypes.Type(value = DvdDto.class,     name = "DVD")
})
public sealed interface MaterialDto permits LlibreDto, RevistaDto, DvdDto { }

public class Empleat {

    private Long id;
    private String correu;
    private String nom;
    private String departament;

    public Empleat() { }

    public Empleat(String correu, String nom, String departament) {
        this.correu = correu;
        this.nom = nom;
        this.departament = departament;
    }

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getCorreu() { return correu; }
    public void setCorreu(String correu) { this.correu = correu; }
    public String getNom() { return nom; }
    public void setNom(String nom) { this.nom = nom; }
    public String getDepartament() { return departament; }
    public void setDepartament(String departament) { this.departament = departament; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Empleat)) return false;
        Empleat altre = (Empleat) o;
        return Objects.equals(correu, altre.correu);
    }

    @Override
    public int hashCode() { return Objects.hash(correu); }

    @Override
    public String toString() {
        return "Empleat{correu='" + correu + "', nom='" + nom + "'}";
    }
}

@Getter @Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(of = "correu")
@ToString(of = {"correu", "nom"})
public class Empleat {
    private Long id;
    private String correu;
    private String nom;
    private String departament;
}

javap -p target/classes/com/nexussoftware/bibliotech/domini/Empleat.class

public class com.nexussoftware.bibliotech.domini.Empleat {
  private java.lang.Long id;
  private java.lang.String correu;
  public java.lang.Long getId();
  public void setId(java.lang.Long);
  public java.lang.String getCorreu();
  ...
}

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>provided</scope>   <!-- nomes en compilacio (11-05) -->
    <optional>true</optional>
</dependency>

@Slf4j
@Service
public class GestorPrestecs {
    public void prestar(String isbn) {
        log.info("Prestant {}", isbn);       // 'log' existeix, generat per Lombok
    }
}

@SneakyThrows
public String llegir(Path fitxer) {
    return Files.readString(fitxer);    // IOException no declarada
}

@Builder
@Getter
public class Prestec {
    private final Material material;
    private final Empleat empleat;
    private final LocalDate dataPrestec;
    private final LocalDate dataVenciment;
    @Builder.Default
    private final EstatPrestec estat = EstatPrestec.ACTIU;
}

Prestec prestec = Prestec.builder()
        .material(llibre)
        .empleat(marta)
        .dataPrestec(LocalDate.now(rellotge))
        .dataVenciment(LocalDate.now(rellotge).plusDays(15))
        .build();

@Service
@RequiredArgsConstructor        // constructor amb TOTS els camps final
public class GestorPrestecs {

    private final MaterialRepository materials;
    private final EmpleatRepository empleats;
    private final PrestecRepository prestecs;
    private final CalculadoraMultes calculadora;
    private final ServeiAvisos avisos;
    private final Clock rellotge;

    // El constructor de 6 parametres el genera Lombok
}

# Atura la cerca de configuracio en directoris superiors
config.stopBubbling = true

# Afegeix @lombok.Generated al que es genera: JaCoCo ho EXCLOU de la cobertura (12-05)
lombok.addLombokGeneratedAnnotation = true

# Prohibeix @Data i @Value: obliguen a ser explicit (veure apartat 21)
lombok.data.flagUsage = error
lombok.value.flagUsage = warning

# Prohibeix @SneakyThrows: trenca el contracte d'excepcions del modul 6
lombok.sneakyThrows.flagUsage = error

# Copia aquestes anotacions al constructor generat (util amb Spring i Jackson)
lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Qualifier

// EL QUE NO CAL FER
@Entity
@Data                       // <- inclou @EqualsAndHashCode amb TOTS els camps
public class Material {

    @Id @GeneratedValue
    private Long id;

    private String isbn;
    private String titol;

    @OneToMany(mappedBy = "material", fetch = FetchType.LAZY)
    private List<Prestec> prestecs;
}

Material llibre = new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch");
Set<Material> conjunt = new HashSet<>();
conjunt.add(llibre);                        // id = null -> hashCode X

repositori.save(llibre);                    // JPA assigna id = 42 -> hashCode Y

assertThat(conjunt.contains(llibre));       // FALSE! Es al cubell equivocat

log.debug("Material: {}", material);
// -> toString() crida getPrestecs()
// -> s'inicialitza la col.leccio mandrosa
// -> SELECT * FROM prestecs WHERE material_id = 42

@Entity
@Getter                                       // nomes getters
@Setter(AccessLevel.PROTECTED)                // setters restringits
@NoArgsConstructor(access = AccessLevel.PROTECTED)   // el que exigeix JPA
@ToString(of = { "id", "isbn", "titol" })     // NOMES camps escalars
@EqualsAndHashCode(of = "isbn")               // NOMES la clau de negoci, immutable
public class Material {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String isbn;                      // clau de negoci: mai no canvia

    private String titol;

    @OneToMany(mappedBy = "material", fetch = FetchType.LAZY)
    private List<Prestec> prestecs = new ArrayList<>();
}

// Lombok
@Value
public class MetadadesLlibre {
    String autor;
    LocalDate dataPublicacio;
    String editorial;
}

// Java 16+, sense dependencies
public record MetadadesLlibre(String autor, LocalDate dataPublicacio, String editorial) { }

package com.nexussoftware.bibliotech.servei;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class GestorPrestecs {

    private static final Logger log = LoggerFactory.getLogger(GestorPrestecs.class);

    public Prestec prestar(String isbn, String correu) {
        log.debug("Solicitud de prestec: isbn={}, empleat={}", isbn, correu);
        // ...
        log.info("Prestec creat: id={}, venc={}", prestec.getId(), prestec.getDataVenciment());
        return prestec;
    }
}

logging.level.com.nexussoftware.bibliotech=DEBUG
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.springframework=INFO

@Slf4j
public class GestorPrestecs { ... }

// MALAMENT: concatenacio
log.debug("Prestec " + prestec.getId() + " del material " + material.getTitol()
          + " per a " + empleat.getNom());

// BE: parametritzat
log.debug("Prestec {} del material {} per a {}",
          prestec.getId(), material.getTitol(), empleat.getNom());

// Excepcions: SEMPRE com a ULTIM argument, SENSE {}
log.error("No s'ha pogut prestar {}", isbn, excepcio);   // registra la traca completa

// MALAMENT: perd la traca de pila, que es l'unic util
log.error("No s'ha pogut prestar " + isbn + ": " + excepcio.getMessage());

// Si l'argument es CAR de calcular, comprova el nivell
if (log.isDebugEnabled()) {
    log.debug("Estat complet del cataleg: {}", cataleg.bolcatComplet());
}

log.atDebug().setMessage("Cataleg: {}")
   .addArgument(() -> cataleg.bolcatComplet())   // lambda: nomes s'avalua si cal
   .log();

// ERROR: cal actuar. Algu hauria de rebre una alerta.
log.error("No s'ha pogut connectar amb la base de dades despres de 3 intents", excepcio);

// WARN: anomal pero recuperat.
log.warn("L'API de metadades no ha respost per a {}; es continua sense enriquir", isbn);

// INFO: esdeveniments de negoci. Ha de poder llegir-se en produccio sense soroll.
log.info("Prestec {} creat per a {} amb venciment {}", id, correu, venciment);

// DEBUG: per diagnosticar. Desactivat en produccio.
log.debug("Avaluant {} reserves pendents amb antelacio de {} dies", total, dies);

// TRACE: molt fi. Gairebe mai activat.
log.trace("Reserva {} : dataSolicitud={}, caduca={}", id, solicitud, caducitat);

// MALAMENT: la mateixa excepcio apareixera tres vegades al log
catch (IOException e) {
    log.error("Error en llegir", e);
    throw new PersistenciaException("Error en llegir", e);
}

// BE: o registres (perque aqui es gestiona) o rellances (i registra qui gestioni)
catch (IOException e) {
    throw new PersistenciaException("Error en llegir " + fitxer, e);
}

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <property name="PATRO_CONSOLA"
              value="%d{HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{36}) - %msg%n"/>
    <property name="PATRO_FITXER"
              value="%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{40} [%X{idPeticio}] - %msg%n"/>

    <!-- APPENDER 1: consola -->
    <appender name="CONSOLA" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${PATRO_CONSOLA}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- APPENDER 2: fitxer amb rotacio per data I mida -->
    <appender name="FITXER" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/bibliotech.log</file>
        <encoder>
            <pattern>${PATRO_FITXER}</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>logs/bibliotech-%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>50MB</maxFileSize>      <!-- rota en superar 50 MB -->
            <maxHistory>30</maxHistory>          <!-- conserva 30 dies -->
            <totalSizeCap>2GB</totalSizeCap>     <!-- mai mes de 2 GB en total -->
        </rollingPolicy>
    </appender>

    <!-- APPENDER 3: asincron. No bloqueja el fil de negoci en escriure -->
    <appender name="FITXER_ASINCRON" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="FITXER"/>
        <queueSize>512</queueSize>
        <discardingThreshold>0</discardingThreshold>   <!-- no descartar missatges -->
    </appender>

    <!-- NIVELLS PER PAQUET -->
    <logger name="com.nexussoftware.bibliotech" level="DEBUG"/>
    <logger name="org.hibernate.SQL" level="DEBUG"/>
    <logger name="org.hibernate.orm.jdbc.bind" level="TRACE"/>
    <logger name="org.springframework" level="INFO"/>

    <!-- PERFILS DE SPRING (11-02) -->
    <springProfile name="dev">
        <root level="DEBUG">
            <appender-ref ref="CONSOLA"/>
        </root>
    </springProfile>

    <springProfile name="prod">
        <root level="INFO">
            <appender-ref ref="FITXER_ASINCRON"/>
        </root>
        <logger name="com.nexussoftware.bibliotech" level="INFO"/>
        <logger name="org.hibernate.SQL" level="OFF"/>
    </springProfile>

</configuration>

logging:
  level:
    root: INFO
    com.nexussoftware.bibliotech: DEBUG
    org.hibernate.SQL: DEBUG
  file:
    name: logs/bibliotech.log
  logback:
    rollingpolicy:
      max-file-size: 50MB
      max-history: 30
  pattern:
    console: "%d{HH:mm:ss.SSS} %-5level %logger{36} - %msg%n"

import org.slf4j.MDC;

public class FiltreCorrelacio implements Filter {

    @Override
    public void doFilter(ServletRequest peticio, ServletResponse resposta, FilterChain cadena)
            throws IOException, ServletException {

        String idPeticio = Optional
                .ofNullable(((HttpServletRequest) peticio).getHeader("X-Request-Id"))
                .orElse(UUID.randomUUID().toString());

        MDC.put("idPeticio", idPeticio);
        MDC.put("usuari", usuariActual());

        try {
            cadena.doFilter(peticio, resposta);
        } finally {
            MDC.clear();   // IMPRESCINDIBLE: el fil torna al pool (modul 8)
        }
    }
}

2026-03-20 10:15:23.451 INFO  [http-nio-8080-exec-3] c.n.b.s.GestorPrestecs [a3f2-9b21] - Prestec 4218 creat
2026-03-20 10:15:23.502 DEBUG [http-nio-8080-exec-3] c.n.b.p.PrestecRepository [a3f2-9b21] - Desant prestec
2026-03-20 10:15:23.510 INFO  [http-nio-8080-exec-7] c.n.b.s.GestorPrestecs [7c81-4e55] - Prestec 4219 creat

{"@timestamp":"2026-03-20T10:15:23.451+01:00","level":"INFO","logger":"com.nexussoftware.bibliotech.servei.GestorPrestecs","thread":"http-nio-8080-exec-3","message":"Prestec 4218 creat","idPeticio":"a3f2-9b21","usuari":"[email protected]"}

<appender name="JSON" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
        <includeMdcKeyName>idPeticio</includeMdcKeyName>
        <includeMdcKeyName>usuari</includeMdcKeyName>
    </encoder>
</appender>

logging:
  structured:
    format:
      console: ecs      # Elastic Common Schema

import java.util.logging.Level;
import java.util.logging.Logger;

public class GestorPrestecs {

    private static final Logger LOG = Logger.getLogger(GestorPrestecs.class.getName());

    public Prestec prestar(String isbn, String correu) {
        if (LOG.isLoggable(Level.FINE)) {                     // comprovacio manual
            LOG.fine("Prestant " + isbn + " a " + correu);    // concatenacio
        }
        try {
            // ...
            LOG.info("Prestec creat: " + prestec.getId());
            return prestec;
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Error en prestar " + isbn, e);   // API incomoda
            throw e;
        }
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class GestorPrestecs {

    private static final Logger log = LoggerFactory.getLogger(GestorPrestecs.class);

    public Prestec prestar(String isbn, String correu) {
        log.debug("Prestant {} a {}", isbn, correu);           // parametritzat, diferit

        Prestec prestec = /* ... */;
        log.info("Prestec creat: id={}, venc={}",
                 prestec.getId(), prestec.getDataVenciment());
        return prestec;
    }
}

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jul-to-slf4j</artifactId>
</dependency>

./mvnw dependency:tree | grep -E "slf4j|logback|log4j"

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [.../logback-classic-1.5.6.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [.../slf4j-simple-2.0.13.jar!/org/slf4j/impl/StaticLoggerBinder.class]

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

// El teu LectorCsv de 07-07: 70 linies, sense cobrir cometes ni salts incrustats
// Amb OpenCSV:
try (var lector = new CsvToBeanBuilder<MaterialCsv>(new FileReader(fitxer, UTF_8))
        .withType(MaterialCsv.class)
        .withSeparator(';')
        .build()) {
    List<MaterialCsv> materials = lector.parse();
}

@Mapper(componentModel = "spring")
public interface MaterialMapper {
    MaterialDto aDto(Material material);
    List<MaterialDto> aDtos(List<Material> materials);
}

@Test
void elDominiNoDepenDeSpringNiDeJpa() {
    JavaClasses classes = new ClassFileImporter()
            .importPackages("com.nexussoftware.bibliotech");

    noClasses().that().resideInAPackage("..domini..")
            .should().dependOnClassesThat()
            .resideInAnyPackage("org.springframework..", "jakarta.persistence..")
            .check(classes);
}

{
  "request_id": "req-8821",
  "generated_at": "2026-03-20T10:15:23Z",
  "items": [
    {
      "isbn_13": "978-0000000001",
      "book_title": "Java Eficac",
      "stock": { "available": 3, "reserved": 1, "warehouse": "MAD-01" },
      "unit_price": 54.95,
      "currency": "EUR",
      "last_updated": "2026-03-19",
      "tags": ["java", "best-practices"],
      "discontinued": false
    }
  ],
  "warnings": []
}

@Entity
@Table(name = "materials")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Material {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String isbn;

    private String titol;

    private int exemplarsDisponibles = 1;

    @OneToMany(mappedBy = "material", fetch = FetchType.LAZY)
    private List<Prestec> prestecs = new ArrayList<>();

    @ManyToMany(fetch = FetchType.LAZY)
    private Set<Categoria> categories = new HashSet<>();

    @Version
    private Long version;
}

public class GestorDevolucions {

    private static final Logger LOG = Logger.getLogger(GestorDevolucions.class.getName());

    public ResultatDevolucio retornar(Long prestecId) {

        LOG.info("Iniciant devolucio del prestec " + prestecId);

        Prestec prestec = prestecs.findById(prestecId).orElse(null);
        if (prestec == null) {
            LOG.severe("Prestec no trobat: " + prestecId);
            throw new PrestecNoTrobatException(prestecId);
        }

        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Estat del prestec: " + prestec.toString()
                     + " amb material " + prestec.getMaterial().toString());
        }

        BigDecimal multa = calculadora.calcular(prestec);
        LOG.info("Multa calculada: " + multa);

        try {
            prestec.retornar(LocalDate.now(rellotge));
            prestecs.save(prestec);
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Error en desar la devolucio de " + prestecId, e);
            throw new PersistenciaException("Error en retornar " + prestecId, e);
        }

        LOG.info("Devolucio completada");
        return new ResultatDevolucio(prestec, multa, false);
    }
}

package com.nexussoftware.bibliotech.xarxa;

import com.fasterxml.jackson.annotation.*;
import java.math.BigDecimal;
import java.time.*;
import java.util.List;

/** (1) DTO de l'API externa de disponibilitat. Reflecteix el JSON, no el domini. */
@JsonIgnoreProperties(ignoreUnknown = true)          // (1) sobreviu a camps nous
public record RespostaDisponibilitat(

        @JsonProperty("request_id")   String idPeticio,
        @JsonProperty("generated_at") Instant generatEl,      // (4) instant absolut
        @JsonProperty("items")        List<Item> items,
        @JsonProperty("warnings")     List<String> avisos) {

    @JsonIgnoreProperties(ignoreUnknown = true)
    public record Item(

            @JsonProperty("isbn_13") String isbn,

            // (2) l'API v1 fa servir "book_title", la v2 fa servir "title"
            @JsonProperty("book_title")
            @JsonAlias({"title"})
            String titol,

            @JsonProperty("stock") Stock stock,

            // (3) BigDecimal, MAI double per a diners (01-04, 11-03)
            @JsonProperty("unit_price") BigDecimal preuUnitari,

            @JsonProperty("currency") String moneda,

            // (4) data de negoci sense hora: LocalDate (10-05)
            @JsonProperty("last_updated") LocalDate ultimaActualitzacio,

            @JsonProperty("tags") List<String> etiquetes,

            @JsonProperty("discontinued") boolean descatalogat) {

        @JsonIgnoreProperties(ignoreUnknown = true)
        public record Stock(
                @JsonProperty("available") int disponibles,
                @JsonProperty("reserved")  int reservats,
                @JsonProperty("warehouse") String magatzem) { }

        // (5) traduccio al domini
        public DisponibilitatMaterial aDomini() {
            return new DisponibilitatMaterial(
                    isbn,
                    titol,
                    stock == null ? 0 : stock.disponibles(),   // defensiu: el JSON pot ometre'l
                    preuUnitari,
                    ultimaActualitzacio);
        }
    }

    /** (5) Tots els items, ja traduits al domini. */
    public List<DisponibilitatMaterial> aDomini() {
        return items == null ? List.of() : items.stream().map(Item::aDomini).toList();
    }
}

// (5) El record de DOMINI: noms en catala, sense rastre de l'API externa
public record DisponibilitatMaterial(
        String isbn,
        String titol,
        int disponibles,
        BigDecimal preu,
        LocalDate actualitzat) {

    public boolean hiHaExistencies() { return disponibles > 0; }
}

@Configuration
public class ConfiguracioJackson {

    @Bean
    public ObjectMapper objectMapper() {
        return JsonMapper.builder()

                // Suport de java.time: sense aixo, LocalDate i Instant fallen
                .addModule(new JavaTimeModule())

                // Dates en ISO-8601, no com a nombre de segons.
                // Llegible, interoperable i coherent amb el decidit a 10-05.
                .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)

                // Redundant amb @JsonIgnoreProperties, pero protegeix
                // qualsevol DTO on algu oblidi l'anotacio.
                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)

                // Els decimals del JSON es llegeixen com a BigDecimal, no com a double.
                // Imprescindible per a imports: evita 54.949999999999996.
                .enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)

                // No serialitzar camps null: respostes mes petites.
                .serializationInclusion(JsonInclude.Include.NON_NULL)

                .build();
    }
}

class RespostaDisponibilitatTest {

    private final ObjectMapper mapper = new ConfiguracioJackson().objectMapper();

    @Test
    @DisplayName("deserialitza la resposta i la tradueix al domini, ignorant camps desconeguts")
    void deserialitzaITradueix() throws Exception {
        String json = """
                {
                  "request_id": "req-8821",
                  "generated_at": "2026-03-20T10:15:23Z",
                  "server_region": "eu-west-1",
                  "items": [
                    {
                      "isbn_13": "978-0000000001",
                      "book_title": "Java Eficac",
                      "stock": { "available": 3, "reserved": 1, "warehouse": "MAD-01" },
                      "unit_price": 54.95,
                      "currency": "EUR",
                      "last_updated": "2026-03-19",
                      "tags": ["java", "best-practices"],
                      "discontinued": false,
                      "promo_code": "SPRING26"
                    }
                  ],
                  "warnings": []
                }
                """;   // bloc de text de 10-06

        RespostaDisponibilitat resposta =
                mapper.readValue(json, RespostaDisponibilitat.class);

        // Els camps desconeguts (server_region, promo_code) no trenquen res
        assertThat(resposta.idPeticio()).isEqualTo("req-8821");
        assertThat(resposta.generatEl()).isEqualTo(Instant.parse("2026-03-20T10:15:23Z"));
        assertThat(resposta.avisos()).isEmpty();

        assertThat(resposta.aDomini()).singleElement().satisfies(d -> {
            assertThat(d.isbn()).isEqualTo("978-0000000001");
            assertThat(d.titol()).isEqualTo("Java Eficac");
            assertThat(d.disponibles()).isEqualTo(3);
            assertThat(d.preu()).isEqualByComparingTo("54.95");   // exacte, sense error
            assertThat(d.actualitzat()).isEqualTo(LocalDate.of(2026, 3, 19));
            assertThat(d.hiHaExistencies()).isTrue();
        });
    }

    @Test
    @DisplayName("accepta també el nom antic del camp títol")
    void acceptaLAliasDeVersioAntiga() throws Exception {
        String jsonV2 = """
                {"items":[{"isbn_13":"978-0000000002","title":"Patrons de Disseny",
                           "stock":{"available":2},"unit_price":49.00,
                           "last_updated":"2026-03-18"}]}
                """;

        var resposta = mapper.readValue(jsonV2, RespostaDisponibilitat.class);

        assertThat(resposta.aDomini()).singleElement()
                .extracting(DisponibilitatMaterial::titol)
                .isEqualTo("Patrons de Disseny");
    }

    @Test
    @DisplayName("el preu es llegeix com a BigDecimal exacte, no com a double")
    void preuExacte() throws Exception {
        String json = """
                {"items":[{"isbn_13":"978-0000000003","book_title":"Refactoritzacio",
                           "stock":{"available":1},"unit_price":0.1,
                           "last_updated":"2026-03-20"}]}
                """;

        var d = mapper.readValue(json, RespostaDisponibilitat.class).aDomini().get(0);

        // Amb double seria 0.1000000000000000055511151231257827
        assertThat(d.preu()).isEqualByComparingTo(new BigDecimal("0.1"));
        assertThat(d.preu().toPlainString()).isEqualTo("0.1");
    }
}

Material llibre = Material.builder().isbn("978-0000000001").titol("Java Eficac").build();
Set<Material> seleccio = new HashSet<>();
seleccio.add(llibre);                    // id = null -> hashCode H1 -> cubell A

repositori.save(llibre);                 // JPA assigna id = 42 -> hashCode H2

seleccio.contains(llibre);               // busca al cubell B -> FALSE

log.debug("Material: {}", material);

material.setId(99L);        // corromp la identitat de l'entitat
material.setVersion(0L);    // trenca el bloqueig optimista d'11-03

private int exemplarsDisponibles = 1;
private List<Prestec> prestecs = new ArrayList<>();
private Set<Categoria> categories = new HashSet<>();

Material m = Material.builder().isbn("978-0000000001").build();
m.getExemplarsDisponibles();    // 0, no 1
m.getPrestecs();                // null, no llista buida -> NullPointerException

package com.nexussoftware.bibliotech.domini;

import jakarta.persistence.*;
import java.util.*;
import lombok.*;

@Entity
@Table(name = "materials")
@Getter                                                   // nomes lectura publica
@Setter(AccessLevel.PROTECTED)                            // setters restringits a JPA/subclasses
@NoArgsConstructor(access = AccessLevel.PROTECTED)        // el que exigeix JPA (11-03)
@ToString(of = { "id", "isbn", "titol", "exemplarsDisponibles" })   // NOMES escalars
@EqualsAndHashCode(of = "isbn")                           // clau de negoci IMMUTABLE
public class Material {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true, length = 20, updatable = false)
    private String isbn;                                  // updatable=false: mai no canvia

    @Column(nullable = false, length = 200)
    private String titol;

    @Column(name = "exemplars_disponibles", nullable = false)
    private int exemplarsDisponibles;

    @OneToMany(mappedBy = "material", fetch = FetchType.LAZY)
    private List<Prestec> prestecs = new ArrayList<>();

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(name = "materials_categories",
               joinColumns = @JoinColumn(name = "material_id"),
               inverseJoinColumns = @JoinColumn(name = "categoria_id"))
    private Set<Categoria> categories = new HashSet<>();

    @Version
    private Long version;

    /** Constructor public amb validacio: substitueix @Builder i @AllArgsConstructor. */
    public Material(String isbn, String titol, int exemplarsDisponibles) {
        this.isbn = Objects.requireNonNull(isbn, "L'ISBN es obligatori");
        this.titol = Objects.requireNonNull(titol, "El titol es obligatori");
        if (exemplarsDisponibles < 0) {
            throw new IllegalArgumentException("Els exemplars no poden ser negatius");
        }
        this.exemplarsDisponibles = exemplarsDisponibles;
    }

    // Metodes de DOMINI amb validacio, en lloc de setters oberts
    public void prestarUnExemplar() {
        if (exemplarsDisponibles <= 0) throw new SenseExemplarsException(isbn);
        exemplarsDisponibles--;
    }

    public void retornarUnExemplar() { exemplarsDisponibles++; }

    /** Copia defensiva: ningu modifica la col.leccio des de fora (11-03 §13). */
    public List<Prestec> getPrestecs() { return List.copyOf(prestecs); }
}

@Test
@DisplayName("un Material continua sent localitzable en un HashSet després de rebre el seu id")
void identitatEstableDespresDePersistir() {

    Material llibre = new Material("978-0000000001", "Java Eficac", 3);
    Set<Material> seleccio = new HashSet<>();
    seleccio.add(llibre);

    // Simula el que fa JPA en persistir: assignar l'id generat
    ReflectionTestUtils.setField(llibre, "id", 42L);

    // Amb @Data aixo FALLA: el hashCode va canviar i l'objecte es en un altre cubell
    assertThat(seleccio).contains(llibre);
    assertThat(seleccio.contains(llibre)).isTrue();
}

@Test
@DisplayName("toString no accedeix a les relacions mandroses")
void toStringSenseRelacions() {
    Material llibre = new Material("978-0000000001", "Java Eficac", 3);

    assertThat(llibre.toString())
            .contains("978-0000000001")
            .contains("Java Eficac")
            .doesNotContain("prestecs")       // hauria disparat la consulta
            .doesNotContain("categories");
}

@DataJpaTest
class MaterialToStringIT {

    @Autowired private TestEntityManager em;

    @Test
    @DisplayName("toString no provoca LazyInitializationException fora de la sessió")
    void toStringSegurForaDeSessio() {
        Material llibre = em.persistAndFlush(new Material("978-0000000001", "Java Eficac", 3));
        em.clear();                                   // simula el tancament del context

        Material separat = em.getEntityManager()
                .getReference(Material.class, llibre.getId());

        assertThatCode(separat::toString).doesNotThrowAnyException();
    }
}

config.stopBubbling = true

# @Data es l'arrel dels dos incidents: prohibit a tot el projecte
lombok.data.flagUsage = error

# @Value es immutable pero incompatible amb JPA: avis
lombok.value.flagUsage = warning

# @AllArgsConstructor permet construir entitats sense validacio
lombok.allArgsConstructor.flagUsage = warning

# @SneakyThrows trenca el contracte d'excepcions del modul 6
lombok.sneakyThrows.flagUsage = error

# Els metodes generats no compten per a la cobertura (12-05)
lombok.addLombokGeneratedAnnotation = true

package com.nexussoftware.bibliotech.servei;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.UUID;
import org.slf4j.*;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@RequiredArgsConstructor          // Lombok: injeccio per constructor (11-02)
public class GestorDevolucions {

    private static final Logger log = LoggerFactory.getLogger(GestorDevolucions.class);
    // (o simplement @Slf4j sobre la classe)

    private final PrestecRepository prestecs;
    private final CalculadoraMultes calculadora;
    private final Clock rellotge;

    @Transactional
    public ResultatDevolucio retornar(Long prestecId) {

        // (3) MDC: correlacio de totes les linies d'aquesta devolucio
        MDC.put("operacio", "devolucio");
        MDC.put("prestecId", String.valueOf(prestecId));
        MDC.put("idOperacio", UUID.randomUUID().toString());

        try {
            // (5) DEBUG, no INFO: l'inici d'una operacio no interessa en produccio
            log.debug("Iniciant devolucio");

            Prestec prestec = prestecs.findById(prestecId)
                    .orElseThrow(() -> {
                        // (4) DEBUG, no ERROR: es un cas de negoci, no una fallada del sistema
                        log.debug("Prestec no trobat");
                        return new PrestecNoTrobatException(prestecId);
                    });

            // (1)(2)(7) parametritzat, sense toString() d'entitats, sense isLoggable
            log.debug("Prestec localitzat: isbn={}, venciment={}, estat={}",
                    prestec.getMaterial().getIsbn(),      // nomes camps ESCALARS
                    prestec.getDataVenciment(),
                    prestec.getEstat());

            BigDecimal multa = calculadora.calcular(prestec);

            prestec.retornar(LocalDate.now(rellotge));
            prestecs.save(prestec);
            // (3) sense catch: l'excepcio de persistencia puja i la registra qui la gestioni

            // (5)(6) UNA linia INFO per operacio, amb TOT el context rellevant
            log.info("Devolucio completada: isbn={}, empleat={}, multa={} EUR, diesRetard={}",
                    prestec.getMaterial().getIsbn(),
                    prestec.getEmpleat().getCorreu(),
                    multa,
                    prestec.diesDeRetard(LocalDate.now(rellotge)));

            if (multa.compareTo(BigDecimal.ZERO) > 0) {
                log.warn("Devolucio amb multa: isbn={}, quantitat={} EUR",
                        prestec.getMaterial().getIsbn(), multa);
            }

            return new ResultatDevolucio(prestec, multa, false);

        } finally {
            MDC.clear();   // (3) IMPRESCINDIBLE: el fil torna al pool (10-07)
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <!-- ============ DESENVOLUPAMENT: consola llegible ============ -->
    <springProfile name="dev">

        <appender name="CONSOLA" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>%d{HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{30}) [%X{idOperacio:-sense-id}] - %msg%n</pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>

        <logger name="com.nexussoftware.bibliotech" level="DEBUG"/>
        <logger name="org.hibernate.SQL" level="DEBUG"/>            <!-- SQL nomes a dev -->
        <logger name="org.hibernate.orm.jdbc.bind" level="TRACE"/>  <!-- parametres -->
        <logger name="org.springframework" level="INFO"/>

        <root level="INFO">
            <appender-ref ref="CONSOLA"/>
        </root>
    </springProfile>

    <!-- ============ PRODUCCIO: fitxer rotat en JSON ============ -->
    <springProfile name="prod">

        <appender name="FITXER_JSON" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>logs/bibliotech.json</file>

            <encoder class="net.logstash.logback.encoder.LogstashEncoder">
                <includeMdcKeyName>idOperacio</includeMdcKeyName>
                <includeMdcKeyName>prestecId</includeMdcKeyName>
                <includeMdcKeyName>operacio</includeMdcKeyName>
                <customFields>{"aplicacio":"bibliotech","entorn":"prod"}</customFields>
            </encoder>

            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <fileNamePattern>logs/bibliotech-%d{yyyy-MM-dd}.%i.json.gz</fileNamePattern>
                <maxFileSize>100MB</maxFileSize>
                <maxHistory>30</maxHistory>
                <totalSizeCap>5GB</totalSizeCap>
            </rollingPolicy>
        </appender>

        <!-- Asincron: escriure en disc no bloqueja el fil de negoci -->
        <appender name="ASINCRON" class="ch.qos.logback.classic.AsyncAppender">
            <appender-ref ref="FITXER_JSON"/>
            <queueSize>1024</queueSize>
            <discardingThreshold>0</discardingThreshold>
        </appender>

        <logger name="com.nexussoftware.bibliotech" level="INFO"/>
        <logger name="org.hibernate.SQL" level="OFF"/>      <!-- MAI SQL en produccio -->
        <logger name="org.springframework" level="WARN"/>

        <root level="INFO">
            <appender-ref ref="ASINCRON"/>
        </root>
    </springProfile>

</configuration>