create database test_date;

CREATE TABLE test_table (
  test_date date NULL,
  test_timestamp timestamp NULL,
  test_timestamptz timestamptz NULL,
  id serial2,
  CONSTRAINT test_table_pk PRIMARY KEY (id)
);

statement.setObject(1, entity.getTestDate(), Types.DATE)

insert into test_table (test_date) values ('2020-12-22 +03')

{ "testDate": "2020-12-22" }

new Date('2020-12-22')
new Date('2020-12-22T00:00:00.000+00:00')
Tue Dec 22 2020 03:00:00 GMT+0300 (Moscow Standard Time)

insert into test_table (test_date) values ('2020-12-21 +03')

statement.setDate(1, new java.sql.Date(entity.getTestDate().getTime()),
    Calendar.getInstance(TimeZone.getTimeZone(userZoneId)));

Intl.DateTimeFormat().resolvedOptions().timeZone;

{"testDate":"2020-12-21T20:00:00.000Z","zoneId":"Europe/Samara"}

insert into test_table (test_date) values ('2020-12-22 +04')

import java.text.SimpleDateFormat;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public class DateSerializer extends JsonSerializer<Date> {
  private final static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
  @Override
  public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
    gen.writeString(format.format(value));
  }
}

private static final String format = "yyyy-MM-dd'T'HH:mm:ss";
@Override
public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
  gen.writeString(new SimpleDateFormat(format).format(value));
}

{"testDate":"2020-12-21T21:00:00.000Z","zoneId":"Europe/Moscow"}

{"testDate":"2020-12-22T00:00:00.000+03:00","zoneId":"Europe/Moscow"}

const ymd: string[] = obj.testDate.split('-');
const date: Date = new Date(ymd);

const ymd: number[] = obj.testDate.split('-').map((s: string) => Number(s));
const date: Date = new Date(ymd[0], ymd[1] - 1, ymd[2])

public saveEntity(entity: TestEntity): Observable<number> {
  const date: Date = entity.testDate;
  const testDate: string = [date.getFullYear(), date.getMonth() + 1, date.getDate()]
    .map(n => String(n).padStart(2, '0')).join('-');
  const body: any = Object.assign({}, entity, {testDate});
  return this.http.post<number>(CONTROLLER, body);
}

insert into test_table (test_date) values ('2020-12-21 -06')

System.setProperty("user.timezone", "UTC")

public static final String APP_TIMEZONE = "America/Chicago";
public static void main(String[] args) {
    System.setProperty("user.timezone", APP_TIMEZONE);
    SpringApplication.run(TestDateApplication.class, args);
}

import com.fasterxml.jackson.annotation.JsonFormat;
public class TestEntity {
    @JsonFormat(timezone = TestDateApplication.APP_TIMEZONE,
                pattern = "yyyy-MM-dd")
    private Date testDate;

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.exc.InvalidFormatException;
public class DateDeserializer extends JsonDeserializer<Date> {
    private static final String format = "yyyy-MM-dd";
    @Override
    public Date deserialize(JsonParser p, DeserializationContext ctxt)
            throws IOException, JsonProcessingException {
        if (p.hasToken(JsonToken.VALUE_STRING)) {
            String text = p.getText().trim();
            if (text.length() != format.length()) {
                throw new InvalidFormatException(p, "Wrong date", text, Date.class);
            }
            try {
                Date result = new SimpleDateFormat(format).parse(text);
                return result;
            } catch (ParseException e) {
                throw new InvalidFormatException(p, "Wrong date", text, Date.class);
            }
        }
        return (Date) ctxt.handleUnexpectedToken(Date.class, p);
    }
}

private static final String COLUMN_LABEL = "test_timestamp";
entity.setTestDate(rs.getTimestamp(COLUMN_LABEL));
statement.setTimestamp(1, new Timestamp(entity.getTestDate().getTime()));

insert into test_table (test_timestamptz) values ('2020-12-21 14:00:00-06')

private static final String COLUMN_TIMEZONE = "America/Chicago";
entity.setTestDate(rs.getTimestamp(COLUMN_LABEL,
    Calendar.getInstance(TimeZone.getTimeZone(COLUMN_TIMEZONE))));
statement.setTimestamp(1, new Timestamp(entity.getTestDate().getTime()),
    Calendar.getInstance(TimeZone.getTimeZone(COLUMN_TIMEZONE)));

update test_table
set test_timestamp =
    (test_timestamp at time zone 'America/Chicago') at time zone 'UTC';

private static final String COLUMN_TIMEZONE = "UTC";

insert into test_table (test_timestamp) values ('2020-12-21 20:00:00+00')

private static final String COLUMN_LABEL = "test_timestamptz";
entity.setTestDate(rs.getTimestamp(COLUMN_LABEL));
statement.setTimestamp(1, new Timestamp(entity.getTestDate().getTime()));

insert into test_table (test_timestamptz) values ('2020-12-21 14:00:00-06')

public saveEntity(entity: TestEntity): Observable<number> {
  const date: Date = entity.testDate;
  const testDate: string = [date.getFullYear(), date.getMonth() + 1, date.getDate()]
    .map(n => String(n).padStart(2, '0')).join('-')
    + 'T' + [date.getHours(), date.getMinutes(), date.getSeconds()]
    .map(n => String(n).padStart(2, '0')).join(':');
  const body: any = Object.assign({}, entity, {testDate});
  return this.http.post<number>(CONTROLLER, body);
}

@JsonDeserialize(using = DateDeserializer.class)
@JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss", timezone = TestDateApplication.APP_TIMEZONE)
private Date testDate;

Date result = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss").parse(text);

insert into test_table (test_timestamp) values ('2020-12-22 14:14:00+04')

new Date('2020-12-22T14:14:00')
Tue Dec 22 2020 14:14:00 GMT-0600 (Central Standard Time)

private LocalDate testDate;
statement.setObject(1, entity.getTestDate(), Types.DATE);
entity.setTestDate(rs.getObject("test_date", LocalDate.class));

insert into test_table (test_date) values ('2020-12-21'::date)

new Date('2020-12-21')
Mon Dec 21 2020 03:00:00 GMT+0300 (Moscow Standard Time)

public LocalDate deserialize(JsonParser p, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    if (p.hasToken(JsonToken.VALUE_STRING)) {
        String text = p.getText().trim();
        try {
            DateTimeFormatter formatter = new DateTimeFormatterBuilder()
                    .append(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
                    .appendZoneId()
                    .toFormatter();
            LocalDate result = ZonedDateTime.parse(text, formatter)
                    .withZoneSameInstant(ZoneId.systemDefault())
                    .toLocalDate();
            return result;
        } catch (Exception e) {
            throw new InvalidFormatException(p, "Wrong date", text, Date.class);
        }
    }
    return (LocalDate) ctxt.handleUnexpectedToken(LocalDate.class, p);
}

insert into test_table (test_date) values ('2020-12-22'::date)

String zoneId = entity.getZoneId();
statement.setObject(1,
    ZonedDateTime.of(entity.getTestDate(), ZoneId.systemDefault())
    .withZoneSameInstant(ZoneId.of(zoneId))
    .toLocalDate(),
    Types.DATE);
entity.setTestDate(
    LocalDateTime.of(rs.getObject(COLUMN_LABEL, LocalDate.class), LocalTime.MIN));

statement.setObject(1, entity.getTestDate(), Types.DATE);
entity.setTestDate(rs.getObject(COLUMN_LABEL, LocalDate.class));

@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate testDate;

statement.setObject(1,
    entity.getTestDate()
        .withZoneSameInstant(ZoneId.systemDefault())
        .toLocalDateTime(),
    Types.TIMESTAMP);
entity.setTestDate(
    ZonedDateTime.of(
        rs.getObject(COLUMN_LABEL, LocalDateTime.class),
        ZoneId.systemDefault()
        )
    );

private static final String COLUMN_TIMEZONE = "UTC";
statement.setObject(1,
    entity.getTestDate()
      .withZoneSameInstant(ZoneId.of(COLUMN_TIMEZONE))
      .toLocalDateTime(),
    Types.TIMESTAMP);
entity.setTestDate(
    ZonedDateTime.of(
        rs.getObject(COLUMN_LABEL, LocalDateTime.class),
        ZoneId.of(COLUMN_TIMEZONE)
        )
    );

statement.setObject(1,
    entity.getTestDate()
      .withZoneSameInstant(ZoneId.systemDefault())
      .toLocalDateTime());

insert into test_table (test_timestamptz) values ('2020-12-21 23:30:00+03'::timestamp)

statement.setObject(1, entity.getTestDate().toOffsetDateTime());

insert into test_table (test_timestamptz)
values ('2020-12-21 20:30:00+00'::timestamp with time zone)

entity.setTestDate(
    rs.getObject(COLUMN_LABEL, OffsetDateTime.class).toZonedDateTime()
    );

public saveEntity(entity: TestEntity): Observable<number> {
  const date: Date = entity.testDate;
  const testDate: string =
    [date.getFullYear(), date.getMonth() + 1, date.getDate()]
      .map(n => String(n).padStart(2, '0')).join('-')
    + 'T'
    + [date.getHours(), date.getMinutes(), date.getSeconds()]
      .map(n => String(n).padStart(2, '0')).join(':');
  const body: any = Object.assign({}, entity, {testDate});
  return this.http.post<number>(CONTROLLER, body);
}

statement.setObject(1, entity.getTestDate());
entity.setTestDate(rs.getObject(COLUMN_LABEL, LocalDateTime.class));