Sto cercando di impostare una data / ora indipendente dal server nel mio database e credo che la migliore pratica per farlo sia impostare una data e ora UTC. Il mio server db è Cassandra e il driver db per Java comprende solo il tipo di data.

Quindi, supponendo che nel mio codice sto usando il nuovo Java 8 ZonedDateTime per ottenere l'UTC now ( ZonedDateTime.now(ZoneOffset.UTC)), come posso convertire questa istanza di ZonedDateTime nella classe Date "legacy"?

Puoi convertire ZonedDateTime in un istante, che puoi utilizzare direttamente con Date.

Date.from(java.time.ZonedDateTime.now().toInstant());

tl; dr

java.util.Date.from(  // Transfer the moment in UTC, truncating any microseconds or nanoseconds to milliseconds.
    Instant.now() ;   // Capture current moment in UTC, with resolution as fine as nanoseconds.
)

Sebbene non ci fosse alcun punto in quel codice sopra. Entrambi java.util.Datee Instantrappresentano un momento in UTC, sempre in UTC. Il codice sopra ha lo stesso effetto di:

new java.util.Date()  // Capture current moment in UTC.

Nessun vantaggio qui per l'utilizzo ZonedDateTime. Se hai già un ZonedDateTime, regola su UTC estraendo un file Instant.

java.util.Date.from(             // Truncates any micros/nanos.
    myZonedDateTime.toInstant()  // Adjust to UTC. Same moment, same point on the timeline, different wall-clock time.
)

Altra risposta corretta

La risposta di ssoltanid affronta correttamente la tua domanda specifica, come convertire un oggetto java.time di nuova scuola in un oggetto ZonedDateTimedi vecchia scuola java.util.Date. Estrarre il Instantda ZonedDateTime e passare a java.util.Date.from().

Perdita di dati

Si noti che si soffre di perdita di dati , come Instanttracce nanosecondi dal epoca , mentre java.util.Datele tracce millisecondi dal epoca.

La tua domanda e i tuoi commenti sollevano altri problemi.

Mantieni i server in UTC

I tuoi server dovrebbero avere il loro sistema operativo host impostato su UTC come best practice in generale. La JVM riprende questa impostazione del sistema operativo host come fuso orario predefinito, nelle implementazioni Java di cui sono a conoscenza.

Specificare il fuso orario

Ma non dovresti mai fare affidamento sul fuso orario predefinito corrente della JVM. Invece di prendere l'impostazione dell'host, un flag passato all'avvio di una JVM può impostare un altro fuso orario. Ancora peggio: qualsiasi codice in qualsiasi thread di qualsiasi app in qualsiasi momento può effettuare una chiamata a java.util.TimeZone::setDefaultper modificare l'impostazione predefinita in fase di esecuzione!

TimestampTipo Cassandra

Qualsiasi database e driver decente dovrebbe gestire automaticamente la regolazione di una data-ora passata su UTC per l'archiviazione. Non uso Cassandra, ma sembra avere un supporto rudimentale per la data e l'ora. La documentazione dice che il suo Timestamptipo è un conteggio di millisecondi della stessa epoca (primo momento del 1970 in UTC).

ISO 8601

Inoltre, Cassandra accetta input di stringhe nei formati standard ISO 8601 . Fortunatamente, java.time utilizza i formati ISO 8601 come impostazioni predefinite per l'analisi / la generazione di stringhe. L' implementazione della Instantclasse toStringandrà bene.

Precisione: millisecondi vs nanosecord

Ma prima dobbiamo ridurre la precisione in nanosecondi di ZonedDateTime a millisecondi. Un modo è creare un nuovo istantaneo usando i millisecondi. Fortunatamente, java.time ha alcuni metodi utili per la conversione in e da millisecondi.

Codice di esempio

Di seguito è riportato un codice di esempio in Java 8 Update 60.

ZonedDateTime zdt = ZonedDateTime.now( ZoneId.of( "America/Montreal" ) );
…
Instant instant = zdt.toInstant();
Instant instantTruncatedToMilliseconds = Instant.ofEpochMilli( instant.toEpochMilli() );
String fodderForCassandra = instantTruncatedToMilliseconds.toString();  // Example: 2015-08-18T06:36:40.321Z

O secondo questo documento del driver Java Cassandra , puoi passare java.util.Dateun'istanza (da non confondere con java.sqlDate). Quindi potresti creare un juDate da quello instantTruncatedToMillisecondsnel codice sopra.

java.util.Date dateForCassandra = java.util.Date.from( instantTruncatedToMilliseconds );

Se lo fai spesso, potresti creare una battuta.

java.util.Date dateForCassandra = java.util.Date.from( zdt.toInstant() );

Ma sarebbe più ordinato creare un piccolo metodo di utilità.

static public java.util.Date toJavaUtilDateFromZonedDateTime ( ZonedDateTime zdt ) {
    Instant instant = zdt.toInstant();
    // Data-loss, going from nanosecond resolution to milliseconds.
    java.util.Date utilDate = java.util.Date.from( instant ) ;
    return utilDate;
}

Notare la differenza in tutto questo codice rispetto alla domanda. Il codice della domanda stava tentando di regolare il fuso orario dell'istanza di ZonedDateTime su UTC. Ma non è necessario. Concettualmente:

ZonedDateTime = Istantaneo + ZoneId

Estraiamo solo la parte Instant, che è già in UTC (fondamentalmente in UTC, leggi il documento di classe per dettagli precisi).

Informazioni su java.time

Il framework java.time è integrato in Java 8 e versioni successive. Queste classi soppiantare la vecchia fastidiosi legacy classi data-time come java.util.Date, Calendar, e SimpleDateFormat.

Il progetto Joda-Time , ora in modalità di manutenzione , consiglia la migrazione alle classi java.time .

Per saperne di più, vedere il tutorial Oracle . E cerca Stack Overflow per molti esempi e spiegazioni. La specifica è JSR 310 .

Puoi scambiare oggetti java.time direttamente con il tuo database. Utilizza un driver JDBC conforme a JDBC 4.2 o successivo. Non c'è bisogno di stringhe, non c'è bisogno di java.sql.*classi.

Dove ottenere le classi java.time?

• Java SE 8 , Java SE 9 , Java SE 10 e versioni successive
  • Incorporato.
  • Parte dell'API Java standard con un'implementazione in bundle.
  • Java 9 aggiunge alcune funzionalità e correzioni minori.
• Java SE 6 e Java SE 7
  • Gran parte delle funzionalità java.time sono portate indietro a Java 6 e 7 in ThreeTen-Backport .
• Android
  • Versioni successive delle implementazioni di bundle Android delle classi java.time .
  • Per precedenza Android (<26), il ThreeTenABP progetto si adatta ThreeTen-Backport (di cui sopra). Vedi Come usare ThreeTenABP… .

Il progetto ThreeTen-Extra estende java.time con classi aggiuntive. Questo progetto è un banco di prova per possibili future aggiunte a java.time. Si possono trovare alcune classi utili, come per esempio Interval, YearWeek, YearQuartere altro .

Ecco un esempio di conversione dell'ora di sistema corrente in UTC. Implica la formattazione di ZonedDateTime come String e quindi l'oggetto String verrà analizzato in un oggetto data utilizzando java.text DateFormat.

    ZonedDateTime zdt = ZonedDateTime.now(ZoneOffset.UTC);
    final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd HH:mm:ss");
    final DateFormat FORMATTER_YYYYMMDD_HH_MM_SS = new SimpleDateFormat("yyyyMMdd HH:mm:ss");
    String dateStr = zdt.format(DATETIME_FORMATTER);

    Date utcDate = null;
    try {
        utcDate = FORMATTER_YYYYMMDD_HH_MM_SS.parse(dateStr);
    }catch (ParseException ex){
        ex.printStackTrace();
    }

Se stai usando il backport ThreeTen per Android e non puoi usare il più recente Date.from(Instant instant)(che richiede almeno l'API 26) puoi usare:

ZonedDateTime zdt = ZonedDateTime.now();
Date date = new Date(zdt.toInstant().toEpochMilli());

o:

Date date = DateTimeUtils.toDate(zdt.toInstant());

Si prega di leggere anche il consiglio nella risposta di Basil Bourque

Puoi farlo utilizzando le classi java.time integrate in Java 8 e versioni successive.

ZonedDateTime temporal = ...
long epochSecond = temporal.getLong(INSTANT_SECONDS);
int nanoOfSecond = temporal.get(NANO_OF_SECOND);
Date date = new Date(epochSecond * 1000 + nanoOfSecond / 1000000);

Io uso questo.

public class TimeTools {

    public static Date getTaipeiNowDate() {
        Instant now = Instant.now();
        ZoneId zoneId = ZoneId.of("Asia/Taipei");
        ZonedDateTime dateAndTimeInTai = ZonedDateTime.ofInstant(now, zoneId);
        try {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateAndTimeInTai.toString().substring(0, 19).replace("T", " "));
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
}

Perché Date.from(java.time.ZonedDateTime.ofInstant(now, zoneId).toInstant()); non funziona !!! Se esegui la tua applicazione sul tuo computer, non è un problema. Ma se esegui in qualsiasi regione di AWS, Docker o GCP, genererà problemi. Perché il computer non è il tuo fuso orario su Cloud. È necessario impostare correttamente il fuso orario in Code. Ad esempio, Asia / Taipei. Quindi verrà corretto in AWS o Docker o GCP.

public class App {
    public static void main(String[] args) {
        Instant now = Instant.now();
        ZoneId zoneId = ZoneId.of("Australia/Sydney");
        ZonedDateTime dateAndTimeInLA = ZonedDateTime.ofInstant(now, zoneId);
        try {
            Date ans = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateAndTimeInLA.toString().substring(0, 19).replace("T", " "));
            System.out.println("ans="+ans);
        } catch (ParseException e) {
        }
        Date wrongAns = Date.from(java.time.ZonedDateTime.ofInstant(now, zoneId).toInstant());
        System.out.println("wrongAns="+wrongAns);
    }
}

La risposta accettata non ha funzionato per me. La data restituita è sempre la data locale e non la data del fuso orario originale. Vivo in UTC + 2.

//This did not work for me
Date.from(java.time.ZonedDateTime.now().toInstant()); 

Ho escogitato due modi alternativi per ottenere la data corretta da ZonedDateTime.

Supponiamo di avere questo ZonedDateTime per le Hawaii

LocalDateTime ldt = LocalDateTime.now();
ZonedDateTime zdt = ldt.atZone(ZoneId.of("US/Hawaii"); // UTC-10

o per UTC come richiesto originariamente

Instant zulu = Instant.now(); // GMT, UTC+0
ZonedDateTime zdt = zulu.atZone(ZoneId.of("UTC"));

Alternativa 1

Possiamo usare java.sql.Timestamp. È semplice ma probabilmente intaccerà anche la tua integrità di programmazione

Date date1 = Timestamp.valueOf(zdt.toLocalDateTime());

Alternativa 2

Creiamo la data da millisecondi (risposta qui prima). Nota che ZoneOffset locale è un must.

ZoneOffset localOffset = ZoneOffset.systemDefault().getRules().getOffset(LocalDateTime.now());
long zonedMillis = 1000L * zdt.toLocalDateTime().toEpochSecond(localOffset) + zdt.toLocalDateTime().getNano() / 1000000L;
Date date2 = new Date(zonedMillis);

Per un'applicazione docker come ha commentato Beehuang, è necessario impostare il fuso orario.

In alternativa puoi usare con ZoneSameLocal . Per esempio:

01-07-2014T00: 00 + 02: 00 [GMT + 02: 00] viene convertito da

Date.from(zonedDateTime.withZoneSameLocal(ZoneId.systemDefault()).toInstant())

a Tue Jul 01 00:00:00 CEST 2014 e da

Date.from(zonedDateTime.toInstant())

a lunedì 30 giugno 22:00:00 UTC 2014

Se sei interessato solo ora, usa semplicemente:

Date d = new Date();