[Spring Boot Basics] JSON với Jackson 3 và DTO trong Spring Boot: serialize, deserialize và MapStruct

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.time.Instant;
 
public class Product {
 
    private Long id;
    private String name;
    private BigDecimal price;
    private BigDecimal costPrice;
    private Instant createdAt;
    private String internalNotes;
 
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
 
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
 
    public BigDecimal getPrice() { return price; }
    public void setPrice(BigDecimal price) { this.price = price; }
 
    public BigDecimal getCostPrice() { return costPrice; }
    public void setCostPrice(BigDecimal costPrice) { this.costPrice = costPrice; }
 
    public Instant getCreatedAt() { return createdAt; }
    public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }
 
    public String getInternalNotes() { return internalNotes; }
    public void setInternalNotes(String internalNotes) { this.internalNotes = internalNotes; }
}

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
 
import org.springframework.stereotype.Component;
 
@Component
public class ProductStore {
 
    private final Map<Long, Product> products = new ConcurrentHashMap<>();
    private final AtomicLong sequence = new AtomicLong();
 
    public ProductStore() {
        save(seed("Mechanical keyboard", "1290000", "870000", "Supplier contract ends in December"));
        save(seed("Wireless mouse", "490000", "310000", "Return rate 4%, watch this one"));
    }
 
    public Product save(Product product) {
        if (product.getId() == null) {
            product.setId(sequence.incrementAndGet());
        }
        if (product.getCreatedAt() == null) {
            product.setCreatedAt(Instant.now().truncatedTo(ChronoUnit.SECONDS));
        }
        products.put(product.getId(), product);
        return product;
    }
 
    public Optional<Product> findById(Long id) {
        return Optional.ofNullable(products.get(id));
    }
 
    private static Product seed(String name, String price, String costPrice, String notes) {
        Product product = new Product();
        product.setName(name);
        product.setPrice(new BigDecimal(price));
        product.setCostPrice(new BigDecimal(costPrice));
        product.setInternalNotes(notes);
        return product;
    }
}

package com.example.demo.product;
 
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;
 
@RestController
@RequestMapping("/api/products")
public class ProductController {
 
    private final ProductStore store;
 
    public ProductController(ProductStore store) {
        this.store = store;
    }
 
    @GetMapping("/{id}")
    public Product findById(@PathVariable Long id) {
        return store.findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }
 
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Product create(@RequestBody Product product) {
        return store.save(product);
    }
}

curl -s http://localhost:8118/api/products/1

{"costPrice":870000,"createdAt":"2026-09-12T07:05:38Z","id":1,"internalNotes":"Supplier contract ends in December","name":"Mechanical keyboard","price":1290000}

package com.example.demo;
 
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.JacksonJsonHttpMessageConverter;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import tools.jackson.databind.ObjectMapper;
import tools.jackson.databind.json.JsonMapper;
 
@Component
class JacksonInspector implements ApplicationRunner {
 
    private final ApplicationContext context;
 
    JacksonInspector(ApplicationContext context) {
        this.context = context;
    }
 
    @Override
    public void run(ApplicationArguments args) {
        for (String name : context.getBeanNamesForType(ObjectMapper.class)) {
            System.out.println("mapper bean    : " + name + " -> " + context.getBean(name).getClass().getName());
        }
        for (String name : context.getBeanNamesForType(JsonMapper.Builder.class, true, false)) {
            System.out.println("builder bean   : " + name + " (prototype: " + context.isPrototype(name) + ")");
        }
        RequestMappingHandlerAdapter adapter = context.getBean(RequestMappingHandlerAdapter.class);
        for (HttpMessageConverter<?> converter : adapter.getMessageConverters()) {
            System.out.println("converter      : " + converter.getClass().getName());
            if (converter instanceof JacksonJsonHttpMessageConverter json) {
                System.out.println("  same mapper as the bean? " + (json.getMapper() == context.getBean(JsonMapper.class)));
            }
        }
    }
}

mapper bean    : jacksonJsonMapper -> tools.jackson.databind.json.JsonMapper
builder bean   : jsonMapperBuilder (prototype: true)
converter      : org.springframework.http.converter.ByteArrayHttpMessageConverter
converter      : org.springframework.http.converter.StringHttpMessageConverter
converter      : org.springframework.http.converter.ResourceHttpMessageConverter
converter      : org.springframework.http.converter.ResourceRegionHttpMessageConverter
converter      : org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter
converter      : org.springframework.http.converter.json.JacksonJsonHttpMessageConverter
  same mapper as the bean? true

curl -s -i -H 'Content-Type: application/json' -d '{"name":"USB-C hub","price":650000}' http://localhost:8118/api/products

2026-09-12T14:05:46.917+07:00 DEBUG 37638 --- [demo] [nio-8118-exec-4] o.s.web.servlet.DispatcherServlet        : POST "/api/products", parameters={}
2026-09-12T14:05:46.917+07:00 DEBUG 37638 --- [demo] [nio-8118-exec-4] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped to com.example.demo.product.ProductController#create(Product)
2026-09-12T14:05:46.938+07:00 DEBUG 37638 --- [demo] [nio-8118-exec-4] m.m.a.RequestResponseBodyMethodProcessor : Read "application/json;charset=UTF-8" to [com.example.demo.product.Product@69867be0]
2026-09-12T14:05:46.942+07:00 DEBUG 37638 --- [demo] [nio-8118-exec-4] m.m.a.RequestResponseBodyMethodProcessor : Using 'application/json', given [*/*] and supported [application/json, application/*+json]
2026-09-12T14:05:46.942+07:00 DEBUG 37638 --- [demo] [nio-8118-exec-4] m.m.a.RequestResponseBodyMethodProcessor : Writing [com.example.demo.product.Product@69867be0]
2026-09-12T14:05:46.944+07:00 DEBUG 37638 --- [demo] [nio-8118-exec-4] o.s.web.servlet.DispatcherServlet        : Completed 201 CREATED

\--- org.springframework.boot:spring-boot-starter-webmvc -> 4.1.1
     +--- org.springframework.boot:spring-boot-starter-jackson:4.1.1
     |    \--- org.springframework.boot:spring-boot-jackson:4.1.1
     |         \--- tools.jackson.core:jackson-databind:3.1.5
     |              +--- com.fasterxml.jackson.core:jackson-annotations:2.21
     |              +--- tools.jackson.core:jackson-core:3.1.5
     |              |    \--- tools.jackson:jackson-bom:3.1.5
     |              |         +--- com.fasterxml.jackson.core:jackson-annotations:2.21 (c)
     |              |         +--- tools.jackson.core:jackson-core:3.1.5 (c)
     |              |         \--- tools.jackson.core:jackson-databind:3.1.5 (c)
     |              \--- tools.jackson:jackson-bom:3.1.5 (*)

import com.fasterxml.jackson.annotation.JsonFormat;   // annotations: same package as Jackson 2
import tools.jackson.core.JacksonException;            // everything else: tools.jackson
import tools.jackson.databind.SerializationFeature;
import tools.jackson.databind.json.JsonMapper;

package com.example.demo;
 
import com.fasterxml.jackson.databind.ObjectMapper;
 
class LegacyImport {
    ObjectMapper mapper;
}

package com.example.demo;
 
import tools.jackson.databind.SerializationFeature;
import tools.jackson.databind.json.JsonMapper;
 
class MutateMapper {
    void configure(JsonMapper mapper) {
        mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
    }
}

./gradlew -q compileJava

src/main/java/com/example/demo/LegacyImport.java:3: error: package com.fasterxml.jackson.databind does not exist
import com.fasterxml.jackson.databind.ObjectMapper;
                                     ^
src/main/java/com/example/demo/LegacyImport.java:6: error: cannot find symbol
    ObjectMapper mapper;
    ^
  symbol:   class ObjectMapper
  location: class LegacyImport
src/main/java/com/example/demo/MutateMapper.java:8: error: cannot find symbol
        mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
              ^
  symbol:   method configure(SerializationFeature,boolean)
  location: variable mapper of type JsonMapper
3 errors

import java.time.Instant;
import java.time.LocalDate;
 
import tools.jackson.core.JacksonException;
import tools.jackson.databind.SerializationFeature;
import tools.jackson.databind.json.JsonMapper;
 
public class JacksonApiDemo {
 
    record Launch(String product, Instant at, LocalDate day) {}
 
    public static void main(String[] args) {
        JsonMapper mapper = JsonMapper.builder().build();
        Launch launch = new Launch("Mechanical keyboard", Instant.parse("2026-10-17T02:30:00Z"), LocalDate.of(2026, 10, 17));
 
        System.out.println(mapper.writeValueAsString(launch));
 
        JsonMapper pretty = mapper.rebuild()
                .enable(SerializationFeature.INDENT_OUTPUT)
                .build();
        System.out.println(pretty.writeValueAsString(launch));
        System.out.println("original still compact: " + !mapper.isEnabled(SerializationFeature.INDENT_OUTPUT));
 
        Launch back = mapper.readValue("{\"product\":\"Mechanical keyboard\",\"at\":\"2026-10-17T02:30:00Z\",\"day\":\"2026-10-17\"}", Launch.class);
        System.out.println(back);
 
        try {
            mapper.readValue("{\"product\": \"Mechanical keyboard\", \"day\": \"17/10/2026\"}", Launch.class);
        } catch (JacksonException e) {
            System.out.println(e.getClass().getName());
            System.out.println("RuntimeException? " + (e instanceof RuntimeException));
            System.out.println(e.getOriginalMessage());
        }
    }
}

{"product":"Mechanical keyboard","at":"2026-10-17T02:30:00Z","day":"2026-10-17"}
{
  "product" : "Mechanical keyboard",
  "at" : "2026-10-17T02:30:00Z",
  "day" : "2026-10-17"
}
original still compact: true
Launch[product=Mechanical keyboard, at=2026-10-17T02:30:00Z, day=2026-10-17]
tools.jackson.databind.exc.InvalidFormatException
RuntimeException? true
Cannot deserialize value of type `java.time.LocalDate` from String "17/10/2026": Failed to deserialize `java.time.LocalDate` (with format 'Value(Year,4,10,EXCEEDS_PAD)'-'Value(MonthOfYear,2)'-'Value(DayOfMonth,2)'): (java.time.format.DateTimeParseException) Text '17/10/2026' could not be parsed at index 0

public class com.fasterxml.jackson.core.JsonProcessingException extends com.fasterxml.jackson.core.JacksonException {
public abstract class com.fasterxml.jackson.core.JacksonException extends java.io.IOException {

public class tools.jackson.core.JacksonException extends java.lang.RuntimeException {
public class tools.jackson.databind.DatabindException extends tools.jackson.core.JacksonException {
public class tools.jackson.databind.exc.MismatchedInputException extends tools.jackson.databind.DatabindException {
public class tools.jackson.databind.exc.InvalidFormatException extends tools.jackson.databind.exc.MismatchedInputException {

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Java 8 date/time type `java.time.Instant` not supported by default: add Module "com.fasterxml.jackson.datatype:jackson-datatype-jsr310" to enable handling (or disable `MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_TIMES`)

@RestController
@RequestMapping("/lab")
public class JsonLabController {
 
    private static final Logger log = LoggerFactory.getLogger(JsonLabController.class);
 
    private static final Instant LISTED = Instant.parse("2026-10-17T02:30:00Z");
 
    public record NewProduct(String name, BigDecimal price, int stockQuantity) {}
 
    @PostMapping("/products")
    public NewProduct create(@RequestBody NewProduct product) {
        log.info("Deserialized {}", product);
        return product;
    }
 
    public record Timestamps(Instant instant, LocalDate localDate, LocalDateTime localDateTime,
            OffsetDateTime offsetDateTime, ZonedDateTime zonedDateTime, Duration duration, Date legacyDate) {}
 
    @GetMapping("/times")
    public Timestamps times() {
        return new Timestamps(LISTED, LocalDate.of(2026, 10, 17), LocalDateTime.of(2026, 10, 17, 9, 30),
                LISTED.atOffset(ZoneOffset.UTC), LISTED.atZone(ZoneId.of("Asia/Ho_Chi_Minh")),
                Duration.ofMinutes(90), Date.from(LISTED));
    }
 
    public static class Supplier {
 
        private final String name;
        private final String country;
 
        public Supplier(String name, String country) {
            this.name = name;
            this.country = country;
        }
 
        public String getName() { return name; }
        public String getCountry() { return country; }
 
        @Override
        public String toString() {
            return "Supplier[name=" + name + ", country=" + country + "]";
        }
    }
 
    @PostMapping("/suppliers")
    public Supplier supplier(@RequestBody Supplier supplier) {
        log.info("Deserialized {}", supplier);
        return supplier;
    }
 
    // the sections below add more endpoints here
}

curl -s http://localhost:8118/lab/times

{"instant":"2026-10-17T02:30:00Z","localDate":"2026-10-17","localDateTime":"2026-10-17T09:30:00","offsetDateTime":"2026-10-17T02:30:00Z","zonedDateTime":"2026-10-17T09:30:00+07:00","duration":"PT1H30M","legacyDate":"2026-10-17T02:30:00.000Z"}

curl -s -i -H 'Content-Type: application/json' -d '{"name":"USB-C hub","price":650000,"stockQuantity":null}' http://localhost:8118/lab/products

HTTP/1.1 400
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:03:51 GMT
Connection: close
 
{"timestamp":"2026-09-12T07:03:51.034Z","status":400,"error":"Bad Request","path":"/lab/products"}

2026-09-12T14:03:51.034+07:00  WARN 36561 --- [demo] [nio-8118-exec-4] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Cannot map `null` into type `int` (set `DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES` to 'false' to allow)]

2026-09-12T14:03:51.055+07:00  WARN 36561 --- [demo] [nio-8118-exec-8] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Trailing token (`JsonToken.START_OBJECT`) found after value (bound as `com.example.demo.lab.JsonLabController$NewProduct`): not allowed as per `DeserializationFeature.FAIL_ON_TRAILING_TOKENS`]

{"id":1,"name":"Mechanical keyboard","price":1290000,"costPrice":870000,"createdAt":"2026-09-12T07:05:39Z","internalNotes":"Supplier contract ends in December"}

tools.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `com.example.demo.lab.JsonLabController$Supplier` (no Creators, like default constructor, exist): cannot deserialize from Object value (no delegate- or property-based Creator)

public record ProductSummary(Long id, String name, BigDecimal price, Instant listedAt) {}
 
@GetMapping("/summary")
public ProductSummary summary() {
    return new ProductSummary(1L, "Mechanical keyboard", new BigDecimal("1290000"), LISTED);
}

curl -s http://localhost:8118/lab/summary

{"id":1,"name":"Mechanical keyboard","price":1290000,"listedAt":"2026-10-17T02:30:00Z"}

public record MobileProduct(Long id, @JsonProperty("product_name") String name, BigDecimal price) {}
 
@GetMapping("/mobile")
public MobileProduct mobile() {
    return new MobileProduct(1L, "Mechanical keyboard", new BigDecimal("1290000"));
}
 
@PostMapping("/mobile")
public MobileProduct mobileIn(@RequestBody MobileProduct product) {
    log.info("Deserialized {}", product);
    return product;
}

curl -s http://localhost:8118/lab/mobile

{"id":1,"product_name":"Mechanical keyboard","price":1290000}

2026-09-12T14:03:51.110+07:00  INFO 36561 --- [demo] [nio-8118-exec-1] com.example.demo.lab.JsonLabController   : Deserialized MobileProduct[id=1, name=null, price=1290000]

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.time.Instant;
 
import com.fasterxml.jackson.annotation.JsonIgnore; 
 
public class Product {
 
    private Long id;
    private String name;
    private BigDecimal price;
    @JsonIgnore
    private BigDecimal costPrice;
    private Instant createdAt;
    @JsonIgnore
    private String internalNotes;
 
    // getters and setters unchanged
}

curl -s http://localhost:8118/api/products/1

{"createdAt":"2026-09-12T07:07:46Z","id":1,"name":"Mechanical keyboard","price":1290000}

@GetMapping("/summary/draft")
public ProductSummary draft() {
    return new ProductSummary(3L, "USB-C hub", new BigDecimal("650000"), null);
}

{"id":3,"name":"USB-C hub","price":650000,"listedAt":null}

@JsonInclude(JsonInclude.Include.NON_NULL)
public record DraftProduct(Long id, String name, BigDecimal price, Instant listedAt) {}
 
@GetMapping("/draft")
public DraftProduct draftProduct() {
    return new DraftProduct(3L, "USB-C hub", new BigDecimal("650000"), null);
}

{"id":3,"name":"USB-C hub","price":650000}

spring.jackson.default-property-inclusion=non_null

public record PriceChange(BigDecimal price,
        @JsonFormat(pattern = "dd/MM/yyyy HH:mm", timezone = "Asia/Ho_Chi_Minh") Instant changedAt,
        @JsonFormat(pattern = "dd/MM/yyyy") LocalDate validUntil) {}
 
@GetMapping("/price-change")
public PriceChange priceChange() {
    return new PriceChange(new BigDecimal("1190000"), LISTED, LocalDate.of(2026, 10, 31));
}
 
@PostMapping("/price-change")
public PriceChange priceChangeIn(@RequestBody PriceChange change) {
    log.info("Deserialized {}", change);
    return change;
}

curl -s http://localhost:8118/lab/price-change

{"price":1190000,"changedAt":"17/10/2026 09:30","validUntil":"31/10/2026"}

2026-09-12T14:03:51.131+07:00  INFO 36561 --- [demo] [nio-8118-exec-7] com.example.demo.lab.JsonLabController   : Deserialized PriceChange[price=1190000, changedAt=2026-10-17T02:30:00Z, validUntil=2026-10-31]

public record UnzonedPriceChange(BigDecimal price, @JsonFormat(pattern = "dd/MM/yyyy HH:mm") Instant changedAt) {}
 
@GetMapping("/price-change/unzoned")
public UnzonedPriceChange unzoned() {
    return new UnzonedPriceChange(new BigDecimal("1190000"), LISTED);
}

curl -s -i http://localhost:8118/lab/price-change/unzoned

HTTP/1.1 500
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:03:51 GMT
Connection: close
 
{"timestamp":"2026-09-12T07:03:51.139Z","status":500,"error":"Internal Server Error","path":"/lab/price-change/unzoned"}

2026-09-12T14:03:51.139+07:00  WARN 36561 --- [demo] [nio-8118-exec-9] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.http.converter.HttpMessageNotWritableException: Could not write JSON: Unsupported field: DayOfMonth]

public record Prices(BigDecimal listed, BigDecimal stripped, BigDecimal withCents) {}
 
@GetMapping("/prices")
public Prices prices() {
    BigDecimal listed = new BigDecimal("1000");
    return new Prices(listed, listed.stripTrailingZeros(), new BigDecimal("19.90"));
}

curl -s http://localhost:8118/lab/prices

{"listed":1000,"stripped":1E+3,"withCents":19.90}

spring.jackson.write.write-bigdecimal-as-plain=true

{"listed":1000,"stripped":1000,"withCents":19.90}

public enum ProductStatus { ACTIVE, OUT_OF_STOCK, DISCONTINUED }
 
public record StatusView(Long id, ProductStatus status) {}
 
@GetMapping("/status")
public StatusView status() {
    return new StatusView(2L, ProductStatus.OUT_OF_STOCK);
}
 
@PostMapping("/status")
public StatusView statusIn(@RequestBody StatusView view) {
    log.info("Deserialized {}", view);
    return view;
}

2026-09-12T14:03:51.159+07:00  WARN 36561 --- [demo] [nio-8118-exec-4] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Cannot deserialize value of type `com.example.demo.lab.JsonLabController$ProductStatus` from String "out_of_stock": not one of the values accepted for Enum class: [ACTIVE, OUT_OF_STOCK, DISCONTINUED]]

public enum Availability {
    @JsonProperty("in_stock") IN_STOCK,
    @JsonProperty("out_of_stock") OUT_OF_STOCK
}
 
public record AvailabilityView(Long id, Availability availability) {}

public record ProductDetails(String name, Optional<String> description) {}
 
@GetMapping("/details")
public List<ProductDetails> details() {
    return List.of(new ProductDetails("Mechanical keyboard", Optional.of("Hot-swappable switches")),
            new ProductDetails("USB-C hub", Optional.empty()));
}

[{"name":"Mechanical keyboard","description":"Hot-swappable switches"},{"name":"USB-C hub","description":null}]

curl -s -i -H 'Content-Type: application/json' -d '{"name":"USB-C hub","price":650000,"stockQuantity":25}' http://localhost:8118/lab/products

2026-09-12T14:03:51.015+07:00  INFO 36561 --- [demo] [io-8118-exec-10] com.example.demo.lab.JsonLabController   : Deserialized NewProduct[name=USB-C hub, price=650000, stockQuantity=25]

2026-09-12T14:03:51.048+07:00  INFO 36561 --- [demo] [nio-8118-exec-6] com.example.demo.lab.JsonLabController   : Deserialized NewProduct[name=USB-C hub, price=null, stockQuantity=25]

curl -s -i -H 'Content-Type: application/json' -d '{"name":"USB-C hub","price":"abc","stockQuantity":25}' http://localhost:8118/lab/products

HTTP/1.1 400
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:03:51 GMT
Connection: close
 
{"timestamp":"2026-09-12T07:03:51.070Z","status":400,"error":"Bad Request","path":"/lab/products"}

2026-09-12T14:03:51.070+07:00  WARN 36561 --- [demo] [io-8118-exec-10] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Cannot deserialize value of type `java.math.BigDecimal` from String "abc": not a valid representation]

2026-09-12T14:03:51.089+07:00  INFO 36561 --- [demo] [nio-8118-exec-5] com.example.demo.lab.JsonLabController   : Deserialized NewProduct[name=USB-C hub, price=650000, stockQuantity=2]

public record ImportedProduct(@JsonAlias({"title", "product_name"}) String name, BigDecimal price) {}
 
@PostMapping("/imports")
public ImportedProduct importProduct(@RequestBody ImportedProduct product) {
    log.info("Deserialized {}", product);
    return product;
}

2026-09-12T14:03:51.179+07:00  INFO 36561 --- [demo] [nio-8118-exec-8] com.example.demo.lab.JsonLabController   : Deserialized ImportedProduct[name=Webcam 1080p, price=790000]
2026-09-12T14:03:51.186+07:00  INFO 36561 --- [demo] [io-8118-exec-10] com.example.demo.lab.JsonLabController   : Deserialized ImportedProduct[name=Webcam 1080p, price=790000]
2026-09-12T14:03:51.192+07:00  INFO 36561 --- [demo] [nio-8118-exec-2] com.example.demo.lab.JsonLabController   : Deserialized ImportedProduct[name=Webcam 1080p, price=790000]

public static final class Sku {
 
    private final String value;
 
    @JsonCreator
    public Sku(String value) {
        this.value = value.trim().toUpperCase();
    }
 
    @JsonValue
    public String value() {
        return value;
    }
 
    @Override
    public String toString() {
        return "Sku[" + value + "]";
    }
}
 
public record StockLine(Sku sku, int quantity) {}
 
@PostMapping("/stock")
public StockLine stock(@RequestBody StockLine line) {
    log.info("Deserialized {}", line);
    return line;
}

curl -s -i -H 'Content-Type: application/json' -d '{"sku":" kb-001 ","quantity":5}' http://localhost:8118/lab/stock

2026-09-12T14:03:51.199+07:00  INFO 36561 --- [demo] [nio-8118-exec-4] com.example.demo.lab.JsonLabController   : Deserialized StockLine[sku=Sku[KB-001], quantity=5]

spring.jackson.property-naming-strategy=SNAKE_CASE

spring.jackson.deserialization.fail-on-unknown-properties=true

curl -s -i -H 'Content-Type: application/json' -d '{"name":"USB-C hub","price":650000,"stockQuantity":25,"warehouse":"HN-02"}' http://localhost:8118/lab/products

HTTP/1.1 400
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 12 Sep 2026 07:05:45 GMT
Connection: close
 
{"timestamp":"2026-09-12T07:05:45.648Z","status":400,"error":"Bad Request","path":"/lab/products"}

2026-09-12T14:05:45.648+07:00  WARN 37405 --- [demo] [io-8118-exec-10] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Unrecognized property "warehouse" (class com.example.demo.lab.JsonLabController$NewProduct), not marked as ignorable]

package com.example.demo;
 
import java.math.BigDecimal;
 
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.boot.jackson.autoconfigure.JsonMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class JacksonConfig {
 
    @Bean
    JsonMapperBuilderCustomizer bigDecimalAsString() {
        return builder -> builder.withConfigOverride(BigDecimal.class,
                override -> override.setFormat(JsonFormat.Value.forShape(JsonFormat.Shape.STRING)));
    }
}

curl -s http://localhost:8118/lab/prices

{"listed":"1000","stripped":"1E+3","withCents":"19.90"}

package com.example.demo;
 
import java.math.BigDecimal;
 
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.boot.jackson.autoconfigure.JsonMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import tools.jackson.databind.SerializationFeature; 
import tools.jackson.databind.json.JsonMapper; 
 
@Configuration
public class JacksonConfig {
 
    @Bean
    JsonMapperBuilderCustomizer bigDecimalAsString() {
        return builder -> builder.withConfigOverride(BigDecimal.class,
                override -> override.setFormat(JsonFormat.Value.forShape(JsonFormat.Shape.STRING)));
    }
 
    @Bean
    JsonMapper jsonMapper() { 
        return JsonMapper.builder() 
                .enable(SerializationFeature.INDENT_OUTPUT) 
                .build(); 
    } 
}

mapper bean    : jsonMapper -> tools.jackson.databind.json.JsonMapper
builder bean   : jsonMapperBuilder (prototype: true)
  same mapper as the bean? true

curl -s http://localhost:8118/lab/summary

{
  "id" : 1,
  "name" : "Mechanical keyboard",
  "price" : 1290000,
  "listedAt" : "2026-10-17T02:30:00Z"
}

    @Bean
    JsonMapper jsonMapper() { 
        return JsonMapper.builder() 
    JsonMapper jsonMapper(JsonMapper.Builder builder) { 
        return builder 
                .enable(SerializationFeature.INDENT_OUTPUT)
                .build();
    }

{
  "id" : 1,
  "name" : "Mechanical keyboard",
  "price" : "1290000",
  "listed_at" : "2026-10-17T02:30:00Z"
}

curl -s -i -H 'Content-Type: application/json' -d '{"id":1,"name":"Mechanical keyboard","price":1,"costPrice":0,"createdAt":"2020-01-01T00:00:00Z","internalNotes":"hacked"}' http://localhost:8118/api/products

HTTP/1.1 201
Content-Type: application/json
Content-Length: 82
Date: Sat, 12 Sep 2026 07:07:46 GMT
 
{"createdAt":"2020-01-01T00:00:00Z","id":1,"name":"Mechanical keyboard","price":1}

curl -s http://localhost:8118/api/products/1

{"createdAt":"2020-01-01T00:00:00Z","id":1,"name":"Mechanical keyboard","price":1}

package com.example.demo.product;
 
import java.math.BigDecimal;
 
public record CreateProductRequest(String name, BigDecimal price) {}

package com.example.demo.product;
 
import java.math.BigDecimal;
 
public record UpdateProductRequest(String name, BigDecimal price) {}

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.time.Instant;
 
public record ProductResponse(Long id, String name, BigDecimal price, Instant listedAt) {}

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.time.Instant;
 
public record ProductResponse(Long id, String name, BigDecimal price, Instant listedAt) {} 
public record ProductResponse(Long id, String name, BigDecimal price, Instant listedAt) { 
 
    public static ProductResponse from(Product product) { 
        return new ProductResponse(product.getId(), product.getName(), product.getPrice(), 
                product.getCreatedAt()); 
    } 
} 

package com.example.demo.product;
 
import java.math.BigDecimal;
 
public record CreateProductRequest(String name, BigDecimal price) {} 
public record CreateProductRequest(String name, BigDecimal price) { 
 
    public Product toProduct() { 
        Product product = new Product(); 
        product.setName(name); 
        product.setPrice(price); 
        return product; 
    } 
} 

package com.example.demo.product;
 
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;
 
@RestController
@RequestMapping("/api/products")
public class ProductController {
 
    private final ProductStore store;
 
    public ProductController(ProductStore store) {
        this.store = store;
    }
 
    @GetMapping("/{id}")
    public ProductResponse findById(@PathVariable Long id) {
        Product product = store.findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
        return ProductResponse.from(product);
    }
 
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public ProductResponse create(@RequestBody CreateProductRequest request) {
        return ProductResponse.from(store.save(request.toProduct()));
    }
}

curl -s http://localhost:8118/api/products/1

{"id":1,"name":"Mechanical keyboard","price":1290000,"listedAt":"2026-09-12T07:23:42Z"}

curl -s -i -H 'Content-Type: application/json' -d '{"id":1,"name":"USB-C hub","price":1,"costPrice":0,"createdAt":"2020-01-01T00:00:00Z","internalNotes":"hacked"}' http://localhost:8118/api/products

HTTP/1.1 201
Content-Type: application/json
Content-Length: 71
Date: Sat, 12 Sep 2026 07:23:42 GMT
 
{"id":4,"name":"USB-C hub","price":1,"listedAt":"2026-09-12T07:23:42Z"}

2026-09-12T14:29:27.417+07:00  WARN 49448 --- [demo] [nio-8118-exec-1] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Unrecognized property "id" (class com.example.demo.product.CreateProductRequest), not marked as ignorable]

package com.example.demo.product;
 
import org.springframework.stereotype.Component;
 
@Component
public class ProductMapper {
 
    public Product toEntity(CreateProductRequest request) {
        Product product = new Product();
        product.setName(request.name());
        product.setPrice(request.price());
        return product;
    }
 
    public ProductResponse toResponse(Product product) {
        return new ProductResponse(product.getId(), product.getName(), product.getPrice(),
                product.getCreatedAt());
    }
 
    public void update(UpdateProductRequest request, Product product) {
        product.setName(request.name());
        product.setPrice(request.price());
    }
}

package com.example.demo.product;
 
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;
 
@RestController
@RequestMapping("/api/products")
public class ProductController {
 
    private final ProductStore store;
    private final ProductMapper mapper;
 
    public ProductController(ProductStore store, ProductMapper mapper) {
        this.store = store;
        this.mapper = mapper;
    }
 
    @GetMapping("/{id}")
    public ProductResponse findById(@PathVariable Long id) {
        return mapper.toResponse(find(id));
    }
 
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public ProductResponse create(@RequestBody CreateProductRequest request) {
        Product product = mapper.toEntity(request);
        return mapper.toResponse(store.save(product));
    }
 
    @PutMapping("/{id}")
    public ProductResponse update(@PathVariable Long id, @RequestBody UpdateProductRequest request) {
        Product product = find(id);
        mapper.update(request, product);
        return mapper.toResponse(store.save(product));
    }
 
    private Product find(Long id) {
        return store.findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }
}

curl -s -i -X PUT -H 'Content-Type: application/json' -d '{"name":"Mechanical keyboard (TKL)","price":1190000,"costPrice":0}' http://localhost:8118/api/products/1

HTTP/1.1 200
Content-Type: application/json
Content-Length: 93
Date: Sat, 12 Sep 2026 07:23:44 GMT
 
{"id":1,"name":"Mechanical keyboard (TKL)","price":1190000,"listedAt":"2026-09-12T07:23:43Z"}

2026-09-12T14:23:45.413+07:00 DEBUG 42958 --- [demo] [nio-8118-exec-2] o.s.web.servlet.DispatcherServlet        : POST "/api/products", parameters={}
2026-09-12T14:23:45.414+07:00 DEBUG 42958 --- [demo] [nio-8118-exec-2] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped to com.example.demo.product.ProductController#create(CreateProductRequest)
2026-09-12T14:23:45.439+07:00 DEBUG 42958 --- [demo] [nio-8118-exec-2] m.m.a.RequestResponseBodyMethodProcessor : Read "application/json;charset=UTF-8" to [CreateProductRequest[name=USB-C hub, price=650000]]
2026-09-12T14:23:45.442+07:00 DEBUG 42958 --- [demo] [nio-8118-exec-2] m.m.a.RequestResponseBodyMethodProcessor : Using 'application/json', given [*/*] and supported [application/json, application/*+json]
2026-09-12T14:23:45.444+07:00 DEBUG 42958 --- [demo] [nio-8118-exec-2] m.m.a.RequestResponseBodyMethodProcessor : Writing [ProductResponse[id=3, name=USB-C hub, price=650000, listedAt=2026-09-12T07:23:45Z]]
2026-09-12T14:23:45.446+07:00 DEBUG 42958 --- [demo] [nio-8118-exec-2] o.s.web.servlet.DispatcherServlet        : Completed 201 CREATED

unzip -l build/libs/demo-0.0.1-SNAPSHOT.jar | grep -i mapstruct

    34069  02-01-1980 00:00   BOOT-INF/lib/mapstruct-1.6.3.jar

./mvnw clean compile

[INFO] --- compiler:3.15.0:compile (default-compile) @ demo ---
[INFO] Recompiling the module because of changed source code.
[INFO] Compiling 10 source files with javac [debug parameters release 21] to target/classes
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS

package com.example.demo.product;
 
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;
 
@Mapper(componentModel = "spring")
public interface ProductMapper {
 
    Product toEntity(CreateProductRequest request);
 
    ProductResponse toResponse(Product product);
 
    void update(UpdateProductRequest request, @MappingTarget Product product);
}

./gradlew compileJava --console=plain

> Task :compileJava
src/main/java/com/example/demo/product/ProductMapper.java:9: warning: Unmapped target properties: "id, costPrice, createdAt, internalNotes".
    Product toEntity(CreateProductRequest request);
            ^
src/main/java/com/example/demo/product/ProductMapper.java:11: warning: Unmapped target property: "listedAt".
    ProductResponse toResponse(Product product);
                    ^
src/main/java/com/example/demo/product/ProductMapper.java:13: warning: Unmapped target properties: "id, costPrice, createdAt, internalNotes".
    void update(UpdateProductRequest request, @MappingTarget Product product);
         ^
3 warnings
 
BUILD SUCCESSFUL in 1s

[WARNING] src/main/java/com/example/demo/product/ProductMapper.java:[9,13] Unmapped target properties: "id, costPrice, createdAt, internalNotes".
[WARNING] src/main/java/com/example/demo/product/ProductMapper.java:[11,21] Unmapped target property: "listedAt".
[WARNING] src/main/java/com/example/demo/product/ProductMapper.java:[13,10] Unmapped target properties: "id, costPrice, createdAt, internalNotes".

    @Override
    public ProductResponse toResponse(Product product) {
        if ( product == null ) {
            return null;
        }
 
        Long id = null;
        String name = null;
        BigDecimal price = null;
 
        id = product.getId();
        name = product.getName();
        price = product.getPrice();
 
        Instant listedAt = null;
 
        ProductResponse productResponse = new ProductResponse( id, name, price, listedAt );
 
        return productResponse;
    }

package com.example.demo.product;
 
import org.mapstruct.Mapper;
import org.mapstruct.Mapping; 
import org.mapstruct.MappingTarget;
 
@Mapper(componentModel = "spring")
public interface ProductMapper {
 
    @Mapping(target = "id", ignore = true) 
    @Mapping(target = "costPrice", ignore = true) 
    @Mapping(target = "createdAt", ignore = true) 
    @Mapping(target = "internalNotes", ignore = true) 
    Product toEntity(CreateProductRequest request);
 
    @Mapping(target = "listedAt", source = "createdAt") 
    ProductResponse toResponse(Product product);
 
    @Mapping(target = "id", ignore = true) 
    @Mapping(target = "costPrice", ignore = true) 
    @Mapping(target = "createdAt", ignore = true) 
    @Mapping(target = "internalNotes", ignore = true) 
    void update(UpdateProductRequest request, @MappingTarget Product product);
}

package com.example.demo.product;
 
import java.math.BigDecimal;
import java.time.Instant;
import javax.annotation.processing.Generated;
import org.springframework.stereotype.Component;
 
@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2026-09-12T14:26:31+0700",
    comments = "version: 1.6.3, compiler: IncrementalProcessingEnvironment from gradle-java-compiler-worker-9.7.1.jar, environment: Java 21.0.6 (Homebrew)"
)
@Component
public class ProductMapperImpl implements ProductMapper {
 
    @Override
    public Product toEntity(CreateProductRequest request) {
        if ( request == null ) {
            return null;
        }
 
        Product product = new Product();
 
        product.setName( request.name() );
        product.setPrice( request.price() );
 
        return product;
    }
 
    @Override
    public ProductResponse toResponse(Product product) {
        if ( product == null ) {
            return null;
        }
 
        Instant listedAt = null;
        Long id = null;
        String name = null;
        BigDecimal price = null;
 
        listedAt = product.getCreatedAt();
        id = product.getId();
        name = product.getName();
        price = product.getPrice();
 
        ProductResponse productResponse = new ProductResponse( id, name, price, listedAt );
 
        return productResponse;
    }
 
    // update(...) follows, see the last subsection
}

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.MappingTarget;
import org.mapstruct.ReportingPolicy; 
 
@Mapper(componentModel = "spring") 
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.ERROR) 
public interface ProductMapper {
 
    @Mapping(target = "id", ignore = true)
    @Mapping(target = "costPrice", ignore = true)
    @Mapping(target = "createdAt", ignore = true)
    @Mapping(target = "internalNotes", ignore = true) 
    Product toEntity(CreateProductRequest request);
 
    // toResponse and update unchanged
}

./gradlew compileJava --console=plain

> Task :compileJava FAILED
src/main/java/com/example/demo/product/ProductMapper.java:14: error: Unmapped target property: "internalNotes".
    Product toEntity(CreateProductRequest request);
            ^
1 error

    @Override
    public void update(UpdateProductRequest request, Product product) {
        if ( request == null ) {
            return;
        }
 
        product.setName( request.name() );
        product.setPrice( request.price() );
    }