背景

  在線上執行的一個數據庫同步系統，突然在某一天發現了一條奇怪的資料。 出現瞭如下異常：

Java程式碼 

1. SQL state [99999]; error code [17361]; Year out of range.; nested exception is java.sql.SQLException: Year out of range.:  

 分析其對應的資料內容，就發現了有一個Oracle的Date型別的資料欄位，返回了-235316004988000L. 

Java程式碼 

1. EventColumn[index=0,columnType=93,columnName=RESERVED_TIME,columnValue=-235347540988000,oldColumnValue=<null>,isNull=false,isKey=false]，  

過程

1. 查詢了下資料庫源庫中的資料記錄(oracle 11g)

Java程式碼 

1. RESERVED_TIME           TO_CHAR(RESERVED_TIME,'YYYY-MM-DDHH24:   
2. -------------------             --------------------------------------  
3. 5488-04-02 11:03:32   0000-00-00 00:00:00     

注意: oracle to_char函數出現失敗. 

2. 接著dump了下"5488-04-02 11:03:32"的記錄和對應該異常資料的記錄，發現16進位制下資料有點不同

Java程式碼 

1. dump(RESERVED_TIME,16):   
2. 5488-04-02 11:03:32  
3. Typ=12 Len=7: 2d,70,4,2,c,4,21  
4. 5488-04-02 11:03:32  
5. Typ=12 Len=7: 9a,bc,4,2,c,4,21  

3. 通過jdbc獲取資料庫返回結果資料

    出現了本文的重點: Timestamp.getTime() =  -253402271999000

原因

做java的人，基本都知道Date.getTime()返回的時間是相對於"1970-01-01 00:00:00"的毫秒數差值。

對應的javadoc說明：

思考： 那1969年的Date物件，獲取到的getTime會是一個什麼結果？ 

測試1： (1970年邊界值測試)

Java程式碼 

1. public static void test_1970() throws Exception {  
2.         TimeZone.setDefault(TimeZone.getTimeZone("GMT+0"));  
3.         Date date1 = parse("1970-01-01 00:00:00"); // 0值  
4.         Date date2 = parse("1969-12-31 00:00:00"); // -86400000值  
5.         System.out.printf("1970 date:%s ,1969 date: %s \n", date1.getTime(), date2.getTime());  
6.     }  

結果很明顯，返回的是負數

測試2：(0000年邊界值測試)

Java程式碼 

1. public static void test_zero() throws Exception {  
2.         TimeZone.setDefault(TimeZone.getTimeZone("GMT+0"));  
3.         Date date1 = parse("0001-01-01 00:00:00");  
4.         long time = date1.getTime();  
5.         Date date2 = new Date(time - ONE_DAY); // 獲取公元1年的下一天  
6.         System.out.printf("date:%s \n", format(date2)); // 0001-12-31 00:00:00, 做了一個輪迴  
7.         Date date3 = new Date(time - ONE_DAY * (365 + 1)); // 獲取公元1年的下一年  
8.         System.out.printf("date:%s \n", format(date3)); // 0001-01-01 00:00:00 , 做了一個輪迴，公元前1年  
9.     }  

結果：

• 0001-01-01的下一天是，0001-12-31 (一個輪迴)
• 0001-01-01的下一年是, 0001-01-01 (一個年的輪迴)

測試3：(本文的異常資料)

獲取正常的5488年的time資料

Java程式碼 

1. Date test = parse("5488-04-02 11:03:32");  
2. System.out.printf("time:%s \n", test.getTime()); // 輸出111025307012000   

計算一下:

Java程式碼 

1. public static void test_answer() throws Exception {  
2.         Date test = parse("5488-04-02 11:03:32");  
3.         Date zero = parse("0001-01-01 00:00:00");  
4.         long days = (test.getTime() - zero.getTime()) / ONE_DAY;  
5.         long ans = (111025307012000L - (-235316004988000L)) / ONE_DAY - days;  
6.         Date now = new Date(zero.getTime() - ONE_DAY * (ans + 1)); // 獲取公元1年的下一年  
7.         System.out.printf("date:%s \n", format(now)); // 5488-04-01 00:00:00 , 做了一個輪迴  
8.     }  

結果： 

• 111025307012000代表的是正確的5488年的time型別
• -253402271999000代表的是從0001再往前倒數5000多年的資料，也就是說是公元前5488年的意思。

結論

1. 1970年的前一天的getTime返回的是-1 * 24 * 3600 * 1000 = -86400000
2. 0001年的前一年(公元前1年)，java裡表示還是0001年

所以本文裡的兩個time時間：111025307012000 , -253402271999000都是代表著"5488-04-02 11:03:32"，只不過前者是公元，後者是公元前的區別，問題就已經很明確了。