How to parse properly Date string to java.util.Date when deserializing JSON to Java POJO with Jackson ObjectMapper

It looks like there is a problem generating the JSON. I really don't think you want to have the dates formatted like that. Right now, you have some odd text surrounding a unix timestamp in milliseconds followed by a zone offset. You are also using the old and rather frowned-upon Date and SimpleDateFormat classes rather than the newer java.time API. However, it is possible to deserialize your date format. Here is one way:

public class DateDeserializer extends JsonDeserializer<Date> {
    @Override
    public Date deserialize(JsonParser jsonParser, DeserializationContext context) 
            throws IOException, JsonProcessingException {
        Pattern pattern = Pattern.compile("/Date\\((\\d+)([+-]\\d+)\\)/");
        Matcher matcher = pattern.matcher(jsonParser.getText());
        if (matcher.find()) {
            String timestamp = matcher.group(1);
            String offset = matcher.group(2);
            Instant instant = Instant.ofEpochMilli(Long.parseLong(timestamp));
            ZonedDateTime zdt = instant.atZone(ZoneId.of(offset));
            instant = zdt.toInstant();
            return Date.from(instant);
        } else {
          throw new RuntimeException("Invalid format: " + jsonParser.getText());
        }
    }
}

java.time

For this answer I am assuming:

1. The time in your JSON may come with or without the UTC offset.
2. You can go all-in on java.time, the modern Java date and time API, and declare your variable to be of type Instant or OffsetDateTime, for example (not Date).

For JSON that comes with an offset such as +0300 declare your variable an OffsetDateTime. Then use the following deserializer.

public class OdtDeserializer extends JsonDeserializer<OffsetDateTime> {

    private static final DateTimeFormatter JSON_DATE_FORMATTER = new DateTimeFormatterBuilder()
            .appendLiteral("/Date(")
            .appendValue(ChronoField.INSTANT_SECONDS)
            .appendValue(ChronoField.MILLI_OF_SECOND, 3)
            .appendOffset("+HHMM", "Z")
            .appendLiteral(")/")
            .toFormatter();

    @Override
    public OffsetDateTime deserialize(JsonParser jsonParser, DeserializationContext context)
            throws IOException {
        String dateStr = jsonParser.getText();
        return OffsetDateTime.parse(dateStr, JSON_DATE_FORMATTER);
    }

}

For JSON that comes without offset like /Date(1636510000000)/ declare your variable Instant. Use a similar deserializer. Leave out the offset from the formatter. Parse into an Instant — the syntax is a bit different.

public class InstantDeserializerWIthoutOffset extends JsonDeserializer<Instant> {

    private static final DateTimeFormatter JSON_DATE_FORMATTER = new DateTimeFormatterBuilder()
            .appendLiteral("/Date(")
            .appendValue(ChronoField.INSTANT_SECONDS)
            .appendValue(ChronoField.MILLI_OF_SECOND, 3)
            .appendLiteral(")/")
            .toFormatter();

    @Override
    public Instant deserialize(JsonParser jsonParser, DeserializationContext context)
            throws IOException {
        String dateStr = jsonParser.getText();
        return JSON_DATE_FORMATTER.parse(dateStr, Instant::from);
    }

}

For JSON that may come with or without the offset still use Instant and just modify the formatter of the latter deserializer to include an optional offset:

    private static final DateTimeFormatter JSON_DATE_FORMATTER = new DateTimeFormatterBuilder()
            .appendLiteral("/Date(")
            .appendValue(ChronoField.INSTANT_SECONDS)
            .appendValue(ChronoField.MILLI_OF_SECOND, 3)
            .optionalStart()
            .appendOffset("+HHMM", "Z")
            .optionalEnd()
            .appendLiteral(")/")
            .toFormatter();

If you cannot modify your POJO class and need to stay with Date, modify my Instant deserializer into a Date deserializer by changing the declaration and returning a Date like this:

        String dateStr = jsonParser.getText();
        Instant inst = JSON_DATE_FORMATTER.parse(dateStr, Instant::from);
        return Date.from(inst);

Final solution catching both: /Date(1633035600000+0300)/ and /Date(-62135596800000)/ (the latter was also present at one place in oneof the JSONs). Thank you @DavidConrad

@Override
    public Date deserialize(JsonParser jsonParser, DeserializationContext context) throws IOException, JsonProcessingException {
        String dateString = jsonParser.getText();
        Pattern pattern = Pattern.compile("/Date\\((-)?(\\d+)([+-]\\d+)?\\)/");
        Matcher matcher = pattern.matcher(dateString);
        if (!matcher.find()) {
            throw new RuntimeException("Invalid format: " + dateString);
        }
        String timestamp = matcher.group(2);
        String offset = matcher.group(3);
        Instant instant = Instant.ofEpochMilli(Long.parseLong(timestamp));
        if (nonNull(offset)) {
            ZonedDateTime zdt = instant.atZone(ZoneId.of(offset));
            instant = zdt.toInstant();
        }
        return Date.from(instant);
    }

@DavidConrad Thank you, I will try your solution. By the way, for now I made a workaround that works for me for now:

@Override
    public Date deserialize(JsonParser jsonParser, DeserializationContext context) throws IOException, JsonProcessingException {
        SimpleDateFormat dateFormattter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = jsonParser.getText();
        String timeZone = dateStr.substring(dateStr.indexOf("+") + 1, dateStr.indexOf(")"));
        String timeZoneShift = String.format("%s:%s",
                timeZone.substring(0, timeZone.length()/2),
                timeZone.substring(timeZone.length()/2));
        dateFormattter.setTimeZone(TimeZone.getTimeZone(String.format("GMT+%s", timeZoneShift)));
        Long millis = 0L;
        if (dateStr.contains("+") && !dateStr.contains("-")) {
            millis = Long.parseLong(dateStr.substring(dateStr.indexOf("(") + 1, dateStr.indexOf("+")));
        } else if (dateStr.contains("+") && !dateStr.contains("-")) {
            millis = Long.parseLong(dateStr.substring(dateStr.indexOf("(") + 1, dateStr.indexOf(")")));
        }
        Date date = new Date(millis);
        String stringDate= dateFormattter.format(date);
        try {
            date = dateFormattter.parse(stringDate);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
        return date;
    }