JAVA-LocalDateTime时间格式化，转换时间戳和源码分析（万字长文详解）

àì夳堔傛蜴生んèń 2024-03-31 14:04 18阅读 0赞

## JAVA-LocalDateTime时间格式化，转换时间戳和源码分析 ##

### LocalDateTime ###

`LocalDateTime`作为java8新加的时间类型，也是后面开发中常用的时间类型。

作为时间类型，最关注的点无非是这几个

*  获取当前时间
 *  获取指定时间
 *  时间格式化
 *  时间转时间戳
 *  时间戳转时间
 *  时间比较
 *  时间加减

这些点通过`LocalDateTime`来操作，都会比较简单

#### 获取当前时间 ####

只需要now一下就可以获取到当前的时间，还是很方便的。

LocalDateTime time = LocalDateTime.now();

再看一下之前的`Date`类

Date date = new Date();

#### 获取指定时间 ####

这个有比较多的方式

*  通过原来的`date`和`dateTime`类型来生成
 *  通过传年月日时分秒生成

LocalDateTime time = LocalDateTime.of(2022,11,30,6,6,6);

原来`Date`类的方式。比较奇怪，他的年份会+1900，所以2022年就得是122，月份也会+1,所以11月就是10.但是这个方法呢后面会被删除，已经被标记为弃用了，使用`Calendar`代替。

Date date = new Date(122,10,30,6,6,6);

看一下`Calendar`的使用。这个年份就正常了，是2022，但是月份还是会+1.

Calendar calendar = Calendar.getInstance();
    calendar.set(2022,10,30,6,6,6);

#### 时间格式化 ####

时间格式化都是通过`format`函数,需要传一个`DateTimeFormatter`对象进去，我们可以通过`DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")`来生成自己想要的格式。

DateTimeFormatter类里面也有一些定义好的格式可以直接用,除了下面列出的还有一些其他的，感兴趣可以看一下，不过我觉得都没啥用。

*  ISO\_DATE\_TIME 2011-12-03T10:15:30
 *  ISO\_OFFSET\_DATE\_TIME 2011-12-03T10:15:30+01:00
 *  ISO\_LOCAL\_DATE\_TIME 2011-12-03T10:15:30

time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

看一下`Date`的格式化。这个需要借用`SimpleDateFormat`类来完成格式化。

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    format.format(date);

#### 时间转时间戳 ####

时间转时间戳分为两种，一种是当你已经有一个`LocalDateTime`类型的时间了，需要转换成秒或者毫秒的时间戳。

##### 时间转换秒级时间戳 #####

只需要直接用`toEpochSecond`方法就可以了。

LocalDateTime time = LocalDateTime.now();
    time.toEpochSecond(ZoneOffset.ofHours(8));

`Date`类型没有办法直接获取秒级时间戳，只能获取毫秒级再转秒。

##### 时间转换毫秒级时间戳 #####

转换毫秒需要先转换成`instant`对象，然后才能转换成毫秒级时间戳。

LocalDateTime time = LocalDateTime.now();
    time.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();

`Date`获取毫秒就很简单了。

Date date = new Date();
    date.getTime();

#### 字符串转换成时间戳 ####

时间转时间戳分为两种，除了上面的，还有一种是有一个格式化好的字符串，比如`2022-12-18 10:00:00`这种，但是这个是字符串并不是时间类型。所以要先转换成`LocalDateTime`类型，然后就可以转换成时间戳了。

其实就是上面格式化的一种反向操作。使用`parse`方法就可以了。

LocalDateTime.parse("2022-12-18 10:00:00", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    LocalDateTime.parse("2022-12-18", DateTimeFormatter.ofPattern("yyyy-MM-dd"));

`Date`类型的字符串转时间戳也是通过`SimpleDateFormat`类来完成。

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = format.parse("2022-12-18 10:00:00")

#### 时间戳转时间 ####

那如果我们现在转换成时间戳以后又想转换成时间呢？也可以通过`instant`对象来做到。

##### 毫秒时间戳转时间 #####

`Instant.ofEpochSecond(1671365543834)`是将一个毫秒时间戳转换成一个instant对象。在通过`ofInstant`方法就可以将instant对象转换成LocalDateTime对象了。

LocalDateTime.ofInstant(Instant.ofEpochSecond(1671365543834), ZoneOffset.ofHours(8));

`Date`类

Date date = new Date(1669759566000L);

##### 秒时间戳转时间 #####

`Instant.ofEpochMilli(1671365543)`是将一个秒时间戳转换成`instant`对象。和上面的区别就是使用的是`ofEpochMilli`方法。

LocalDateTime.ofInstant(Instant.ofEpochMilli(1671365543), ZoneOffset.ofHours(8));

`Date`类不支持秒，只能把秒转成毫秒在转时间戳。

#### 时间比较 ####

通过`compareTo`方法可以进行时间的一个比较大小。如果大于会返回1，小于返回-1.

LocalDateTime time = LocalDateTime.now();
    time.compareTo(LocalDateTime.now());

`Date`也是通过`compareTo`方法进行比较

Date date = new Date(1669759566000L);
    date.compareTo(new Date());

#### 时间加减 ####

如果加上几天，就是`plusDays`。加几个小时就是`plusHours`。当然也可以使用`plus`。

LocalDateTime time = LocalDateTime.now();
    time.plusDays(1);
    time.plusHours(1);
    time.plus(Period.ofDays(1));

如果减去几天就是`minusDays`.减去几个小时就是`minusHours`。当然也可以使用`minus`。

LocalDateTime time = LocalDateTime.now();
    time.minusDays(1);
    time.minusHours(1);
    time.minus(Period.ofDays(1));

`Date`类不支持时间加减，只能通过`Calendar`类实现。

Date date = new Date();
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    calendar.add(Calendar.DAY_OF_MONTH, 1);
    //减去
    calendar.add(Calendar.DAY_OF_MONTH, -1);

#### 时间格式在入参出参中的使用 ####

入参的时候需要通过`JsonFormat`注解来指定需要的是字符串类型和对应的时间格式。

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern="yyyy-MM-dd")
    private LocalDate date;
    
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern="yyyy-MM-dd HH:mm:ss")
    private LocalDateTime time;

出参的时候就很简单了，因为只是返回了一个字符串。

private String time;

#### 格式化时间源码分析 ####

格式化的时候这两个年是不一样的，具体的可以看一下源码。我们来找一下。

首先点进去是LocalDateTime这个类里面

@Override  // override for Javadoc and performance
    public String format(DateTimeFormatter formatter) {
        
        //判断参数是否空
        Objects.requireNonNull(formatter, "formatter");
        //真正的执行格式化
        return formatter.format(this);
    }

接下来点进去，看一下怎么执行的，可以看到又调用了`formatTo`这个函数，说明主要的格式化代码都在这里面。

public String format(TemporalAccessor temporal) {
        
           //创建了一个32长度的字符串构建器
            StringBuilder buf = new StringBuilder(32);
            //格式化主要代码
            formatTo(temporal, buf);
            //转成字符串
            return buf.toString();
        }

看一下`formatTo`函数，可以发现主要是调用`printerParser`这个对象的`format`方法，那我们这个对象是哪来的呢，是在一开始指定格式化类型的时候来的。不同的格式化类型对应不同的解析器，也就会执行不同的`format`方法。

public void formatTo(TemporalAccessor temporal, Appendable appendable) {
        
            //判断参数，这里不用管
            Objects.requireNonNull(temporal, "temporal");
            Objects.requireNonNull(appendable, "appendable");
            try {
        
                //创建一个DateTimePrintContext对象
                DateTimePrintContext context = new DateTimePrintContext(temporal, this);
                //判断，显然我们之前传过来的就是一个StringBuilder
                if (appendable instanceof StringBuilder) {
        
                    //主要看这个怎么处理  这里有个 printerParser 对象，这个对象是怎么来的呢，其实是上面DateTimeFormatter.ofPattern的时候给创建的。
                    printerParser.format(context, (StringBuilder) appendable);
                } else {
        
                    //这里其实就是如果传的不是个StringBuilder，就在创建一个然后执行
                    // buffer output to avoid writing to appendable in case of error
                    StringBuilder buf = new StringBuilder(32);
                    printerParser.format(context, buf);
                    appendable.append(buf);
                }
            } catch (IOException ex) {
        
                throw new DateTimeException(ex.getMessage(), ex);
            }
        }

接下来我们看一下`ofPattern`这个方法里面是怎样的吧。这里是创建了一个 时间格式化的建造者，然后把我们这个字符串添加进去了。

//这里的字符串就是我们传的 yyyy-MM-dd HH:mm:ss
    public static DateTimeFormatter ofPattern(String pattern) {
        
        return new DateTimeFormatterBuilder().appendPattern(pattern).toFormatter();
    }

看一下`appendPattern`里面是怎么把字符串加进去的。

public DateTimeFormatterBuilder appendPattern(String pattern) {
        
        //忽略
        Objects.requireNonNull(pattern, "pattern");
        //主要的解析逻辑
        parsePattern(pattern);
        return this;
    }

继续追踪到`parsePattern`方法里面。这个方法代码比较多，这里只关注我们想知道的。其余的有兴趣的可以看一下。

private void parsePattern(String pattern) {
        
        //这里给字符串做循环，注意 pattern = yyyy-MM-dd HH:mm:ss 这个字符串。
        for (int pos = 0; pos < pattern.length(); pos++) {
        
            //取出字符 比如第一个就是 y 对应的ASCII码就是121
            char cur = pattern.charAt(pos);
            //这里就是判断是否是大小写字母了，也就是A-Z或者a-z
            if ((cur >= 'A' && cur <= 'Z') || (cur >= 'a' && cur <= 'z')) {
        
                //初始化变量 start = 0 pos = 1
                int start = pos++;
                //这里做一个循环，目的其实就是找出相同的字符有几个，比如y有4个，pos就会变成4
                for ( ; pos < pattern.length() && pattern.charAt(pos) == cur; pos++);  // short loop
                //这里就是算出具体的数量 4 - 0 = 4
                int count = pos - start;
                // padding  这里忽略 我们这里面没有这个字符
                if (cur == 'p') {
        
                    int pad = 0;
                    if (pos < pattern.length()) {
        
                        cur = pattern.charAt(pos);
                        if ((cur >= 'A' && cur <= 'Z') || (cur >= 'a' && cur <= 'z')) {
        
                            pad = count;
                            start = pos++;
                            for ( ; pos < pattern.length() && pattern.charAt(pos) == cur; pos++);  // short loop
                            count = pos - start;
                        }
                    }
                    if (pad == 0) {
        
                        throw new IllegalArgumentException(
                                "Pad letter 'p' must be followed by valid pad pattern: " + pattern);
                    }
                    padNext(pad); // pad and continue parsing
                }
                //接下来是主要逻辑。
                // main rules
                //从hashMap里面取出对应的值，这个map放在下面了。y取出来就是 YEAR_OF_ERA
                TemporalField field = FIELD_MAP.get(cur);
                //判断map里面取出来的是否为空，如果不为空就直接解析，如果为空就接着往下走，看是不是 zvZOXxWwY 这几个，如果都不是就会报错了
                if (field != null) {
        
                    //我们y是能取出来的，直接解析这里 cur = y, count = 4, field = YEAR_OF_ERA
                    parseField(cur, count, field);
                } else if (cur == 'z') {
        
                    if (count > 4) {
        
                        throw new IllegalArgumentException("Too many pattern letters: " + cur);
                    } else if (count == 4) {
        
                        appendZoneText(TextStyle.FULL);
                    } else {
        
                        appendZoneText(TextStyle.SHORT);
                    }
                } else if (cur == 'V') {
        
                    if (count != 2) {
        
                        throw new IllegalArgumentException("Pattern letter count must be 2: " + cur);
                    }
                    appendZoneId();
                } else if (cur == 'Z') {
        
                    if (count < 4) {
        
                        appendOffset("+HHMM", "+0000");
                    } else if (count == 4) {
        
                        appendLocalizedOffset(TextStyle.FULL);
                    } else if (count == 5) {
        
                        appendOffset("+HH:MM:ss","Z");
                    } else {
        
                        throw new IllegalArgumentException("Too many pattern letters: " + cur);
                    }
                } else if (cur == 'O') {
        
                    if (count == 1) {
        
                        appendLocalizedOffset(TextStyle.SHORT);
                    } else if (count == 4) {
        
                        appendLocalizedOffset(TextStyle.FULL);
                    } else {
        
                        throw new IllegalArgumentException("Pattern letter count must be 1 or 4: " + cur);
                    }
                } else if (cur == 'X') {
        
                    if (count > 5) {
        
                        throw new IllegalArgumentException("Too many pattern letters: " + cur);
                    }
                    appendOffset(OffsetIdPrinterParser.PATTERNS[count + (count == 1 ? 0 : 1)], "Z");
                } else if (cur == 'x') {
        
                    if (count > 5) {
        
                        throw new IllegalArgumentException("Too many pattern letters: " + cur);
                    }
                    String zero = (count == 1 ? "+00" : (count % 2 == 0 ? "+0000" : "+00:00"));
                    appendOffset(OffsetIdPrinterParser.PATTERNS[count + (count == 1 ? 0 : 1)], zero);
                } else if (cur == 'W') {
        
                    // Fields defined by Locale
                    if (count > 1) {
        
                        throw new IllegalArgumentException("Too many pattern letters: " + cur);
                    }
                    appendInternal(new WeekBasedFieldPrinterParser(cur, count));
                } else if (cur == 'w') {
        
                    // Fields defined by Locale
                    if (count > 2) {
        
                        throw new IllegalArgumentException("Too many pattern letters: " + cur);
                    }
                    appendInternal(new WeekBasedFieldPrinterParser(cur, count));
                } else if (cur == 'Y') {
        
                    // Fields defined by Locale
                    appendInternal(new WeekBasedFieldPrinterParser(cur, count));
                } else {
        
                    throw new IllegalArgumentException("Unknown pattern letter: " + cur);
                }
                pos--;
    
            } else if (cur == '\'') {
        
                // parse literals
                int start = pos++;
                for ( ; pos < pattern.length(); pos++) {
        
                    if (pattern.charAt(pos) == '\'') {
        
                        if (pos + 1 < pattern.length() && pattern.charAt(pos + 1) == '\'') {
        
                            pos++;
                        } else {
        
                            break;  // end of literal
                        }
                    }
                }
                if (pos >= pattern.length()) {
        
                    throw new IllegalArgumentException("Pattern ends with an incomplete string literal: " + pattern);
                }
                String str = pattern.substring(start + 1, pos);
                if (str.length() == 0) {
        
                    appendLiteral('\'');
                } else {
        
                    appendLiteral(str.replace("''", "'"));
                }
    
            } else if (cur == '[') {
        
                optionalStart();
    
            } else if (cur == ']') {
        
                if (active.parent == null) {
        
                    throw new IllegalArgumentException("Pattern invalid as it contains ] without previous [");
                }
                optionalEnd();
    
            } else if (cur == '{' || cur == '}' || cur == '#') {
        
                throw new IllegalArgumentException("Pattern includes reserved character: '" + cur + "'");
            } else {
        
                // - : 这两个符号就会走到这里了
                appendLiteral(cur);
            }
        }
    }

看一下通过不同的key取值的map

//时代
    FIELD_MAP.put('G', ChronoField.ERA);                       // SDF, LDML (different to both for 1/2 chars)
    //这个时代的年份，也就是我们常用的年份yyyy
    FIELD_MAP.put('y', ChronoField.YEAR_OF_ERA);               // SDF, LDML
    //单纯的年份
    FIELD_MAP.put('u', ChronoField.YEAR);                      // LDML (different in SDF)
    FIELD_MAP.put('Q', IsoFields.QUARTER_OF_YEAR);             // LDML (removed quarter from 310)
    FIELD_MAP.put('q', IsoFields.QUARTER_OF_YEAR);             // LDML (stand-alone)
    //一年里面的月份，也是我们常用的月份 MM
    FIELD_MAP.put('M', ChronoField.MONTH_OF_YEAR);             // SDF, LDML
    FIELD_MAP.put('L', ChronoField.MONTH_OF_YEAR);             // SDF, LDML (stand-alone)
    //一年里面的天，我们基本不用这个作为日子
    FIELD_MAP.put('D', ChronoField.DAY_OF_YEAR);               // SDF, LDML
    //一个月里面的天，我们常用这个获取多少号
    FIELD_MAP.put('d', ChronoField.DAY_OF_MONTH);              // SDF, LDML
    FIELD_MAP.put('F', ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH);  // SDF, LDML
    FIELD_MAP.put('E', ChronoField.DAY_OF_WEEK);               // SDF, LDML (different to both for 1/2 chars)
    FIELD_MAP.put('c', ChronoField.DAY_OF_WEEK);               // LDML (stand-alone)
    FIELD_MAP.put('e', ChronoField.DAY_OF_WEEK);               // LDML (needs localized week number)
    FIELD_MAP.put('a', ChronoField.AMPM_OF_DAY);               // SDF, LDML
    //一天里面的小时，常用的小时 HH
    FIELD_MAP.put('H', ChronoField.HOUR_OF_DAY);               // SDF, LDML
    FIELD_MAP.put('k', ChronoField.CLOCK_HOUR_OF_DAY);         // SDF, LDML
    FIELD_MAP.put('K', ChronoField.HOUR_OF_AMPM);              // SDF, LDML
    FIELD_MAP.put('h', ChronoField.CLOCK_HOUR_OF_AMPM);        // SDF, LDML
    //一个小时里面的分钟，常用的分钟 mm
    FIELD_MAP.put('m', ChronoField.MINUTE_OF_HOUR);            // SDF, LDML
    //一分钟里面的秒数，常用的秒数 ss
    FIELD_MAP.put('s', ChronoField.SECOND_OF_MINUTE);          // SDF, LDML
    //这个大S基本不用，这是秒里面的纳秒
    FIELD_MAP.put('S', ChronoField.NANO_OF_SECOND);            // LDML (SDF uses milli-of-second number)
    FIELD_MAP.put('A', ChronoField.MILLI_OF_DAY);              // LDML
    FIELD_MAP.put('n', ChronoField.NANO_OF_SECOND);            // 310 (proposed for LDML)
    FIELD_MAP.put('N', ChronoField.NANO_OF_DAY);               // 310 (proposed for LDML)

继续深入，直接解析y的方法`parseField`。可以看到这个是根据我们格式化的字母执行不同的代码，比如u,y都执行到一个代码块。4个y走到了`appendValue`方法里面。

private void parseField(char cur, int count, TemporalField field) {
        
        boolean standalone = false;
        switch (cur) {
        
            case 'u':
            case 'y':
                //判断数量
                if (count == 2) {
        
                    //yy走这里
                    appendValueReduced(field, 2, 2, ReducedPrinterParser.BASE_DATE);
                } else if (count < 4) {
        
                    //y or yyy走这里
                    appendValue(field, count, 19, SignStyle.NORMAL);
                } else {
        
                    // yyyy走这里 field = YEAR_OF_ERA count = 4
                    appendValue(field, count, 19, SignStyle.EXCEEDS_PAD);
                }
                break;
            case 'c':
                if (count == 2) {
        
                    throw new IllegalArgumentException("Invalid pattern \"cc\"");
                }
                /*fallthrough*/
            case 'L':
            case 'q':
                standalone = true;
                /*fallthrough*/
            case 'M':
            case 'Q':
            case 'E':
            case 'e':
                switch (count) {
        
                    case 1:
                    case 2:
                        //两个MM输出月份走到这里
                        if (cur == 'c' || cur == 'e') {
        
                            appendInternal(new WeekBasedFieldPrinterParser(cur, count));
                        } else if (cur == 'E') {
        
                            appendText(field, TextStyle.SHORT);
                        } else {
        
                            if (count == 1) {
        
                                appendValue(field);
                            } else {
        
                                //经过判断走到这里
                                appendValue(field, 2);
                            }
                        }
                        break;
                    case 3:
                        appendText(field, standalone ? TextStyle.SHORT_STANDALONE : TextStyle.SHORT);
                        break;
                    case 4:
                        appendText(field, standalone ? TextStyle.FULL_STANDALONE : TextStyle.FULL);
                        break;
                    case 5:
                        appendText(field, standalone ? TextStyle.NARROW_STANDALONE : TextStyle.NARROW);
                        break;
                    default:
                        throw new IllegalArgumentException("Too many pattern letters: " + cur);
                }
                break;
            case 'a':
                if (count == 1) {
        
                    appendText(field, TextStyle.SHORT);
                } else {
        
                    throw new IllegalArgumentException("Too many pattern letters: " + cur);
                }
                break;
            case 'G':
                switch (count) {
        
                    case 1:
                    case 2:
                    case 3:
                        appendText(field, TextStyle.SHORT);
                        break;
                    case 4:
                        appendText(field, TextStyle.FULL);
                        break;
                    case 5:
                        appendText(field, TextStyle.NARROW);
                        break;
                    default:
                        throw new IllegalArgumentException("Too many pattern letters: " + cur);
                }
                break;
            case 'S':
                appendFraction(NANO_OF_SECOND, count, count, false);
                break;
            case 'F':
                if (count == 1) {
        
                    appendValue(field);
                } else {
        
                    throw new IllegalArgumentException("Too many pattern letters: " + cur);
                }
                break;
            case 'd':
            case 'h':
            case 'H':
            case 'k':
            case 'K':
            case 'm':
            case 's':
                if (count == 1) {
        
                    appendValue(field);
                } else if (count == 2) {
        
                    //可以看到dd HH mm ss也是走到这里，最终也是通过NumberPrinterParser这个对象来格式化
                    appendValue(field, count);
                } else {
        
                    throw new IllegalArgumentException("Too many pattern letters: " + cur);
                }
                break;
            case 'D':
                if (count == 1) {
        
                    appendValue(field);
                } else if (count <= 3) {
        
                    appendValue(field, count);
                } else {
        
                    throw new IllegalArgumentException("Too many pattern letters: " + cur);
                }
                break;
            default:
                if (count == 1) {
        
                    appendValue(field);
                } else {
        
                    appendValue(field, count);
                }
                break;
        }
    }

看一下`appendValue`方法。field = YEAR\_OF\_ERA,minWidth = 4, maxWidth = 19, signStyle = SignStyle.EXCEEDS\_PAD。前面是一些判断，重点是创建了一个`NumberPrinterParser`的对象。最后转换的时候其实就是通过这个对象来转换的。

public DateTimeFormatterBuilder appendValue(
        TemporalField field, int minWidth, int maxWidth, SignStyle signStyle) {
        
        //这里不执行 忽略
        if (minWidth == maxWidth && signStyle == SignStyle.NOT_NEGATIVE) {
        
            return appendValue(field, maxWidth);
        }
        //参数校验
        Objects.requireNonNull(field, "field");
        Objects.requireNonNull(signStyle, "signStyle");
        //一些校验规则
        if (minWidth < 1 || minWidth > 19) {
        
            throw new IllegalArgumentException("The minimum width must be from 1 to 19 inclusive but was " + minWidth);
        }
        if (maxWidth < 1 || maxWidth > 19) {
        
            throw new IllegalArgumentException("The maximum width must be from 1 to 19 inclusive but was " + maxWidth);
        }
        if (maxWidth < minWidth) {
        
            throw new IllegalArgumentException("The maximum width must exceed or equal the minimum width but " +
                    maxWidth + " < " + minWidth);
        }
        //重点是这里，创建了一个 NumberPrinterParser的对象，把参数传进去了。
        NumberPrinterParser pp = new NumberPrinterParser(field, minWidth, maxWidth, signStyle);
        appendValue(pp);
        return this;
    }

看一下`NumberPrinterParser`类。还记得最开始格式化的时候那一段代码`printerParser.format(context, (StringBuilder) appendable);`吗，实际调用的就是这里。？

//构造方法赋值
    NumberPrinterParser(TemporalField field, int minWidth, int maxWidth, SignStyle signStyle) {
        
        // validated by caller
        this.field = field;
        this.minWidth = minWidth;
        this.maxWidth = maxWidth;
        this.signStyle = signStyle;
        this.subsequentWidth = 0;
    }
    
    //格式化方法
    @Override
    public boolean format(DateTimePrintContext context, StringBuilder buf) {
        
        //从context上下文中获取字段 field = YEAR_OF_ERA  context实际包含了真正的时间 2022-12-01T00:00:00
        Long valueLong = context.getValue(field);
        if (valueLong == null) {
        
            return false;
        }
        //获取到以后 value = 2022
        long value = getValue(context, valueLong);
        DecimalStyle decimalStyle = context.getDecimalStyle();
        String str = (value == Long.MIN_VALUE ? "9223372036854775808" : Long.toString(Math.abs(value)));
        if (str.length() > maxWidth) {
        
            throw new DateTimeException("Field " + field +
                " cannot be printed as the value " + value +
                " exceeds the maximum print width of " + maxWidth);
        }
        //转换一个格式类型
        str = decimalStyle.convertNumberToI18N(str);
    
        //这些条件都不满足，忽略
        if (value >= 0) {
        
            switch (signStyle) {
        
                case EXCEEDS_PAD:
                    if (minWidth < 19 && value >= EXCEED_POINTS[minWidth]) {
        
                        buf.append(decimalStyle.getPositiveSign());
                    }
                    break;
                case ALWAYS:
                    buf.append(decimalStyle.getPositiveSign());
                    break;
            }
        } else {
        
            switch (signStyle) {
        
                case NORMAL:
                case EXCEEDS_PAD:
                case ALWAYS:
                    buf.append(decimalStyle.getNegativeSign());
                    break;
                case NOT_NEGATIVE:
                    throw new DateTimeException("Field " + field +
                        " cannot be printed as the value " + value +
                        " cannot be negative according to the SignStyle");
            }
        }
        //填充0 也就是yyyy minWidth = 4就会填充0 MM minWidth = 2如果 1月就会填充01，一个M就不会走到循环填充0
        for (int i = 0; i < minWidth - str.length(); i++) {
        
            buf.append(decimalStyle.getZeroDigit());
        }
        //输出到buf中
        buf.append(str);
        return true;
    }

可以看到上面的代码，但是`NumberPrinterParser`其实只是解析了`yMdHms`这些格式的。也可以再看一下`M`的确认一下。

首先是`appendValue`这个方法。大差不差，除了传到解析器的参数不一样，没啥区别，其实dd这些也都一样。

public DateTimeFormatterBuilder appendValue(TemporalField field, int width) {
        
        //参数校验
        Objects.requireNonNull(field, "field");
        if (width < 1 || width > 19) {
        
            throw new IllegalArgumentException("The width must be from 1 to 19 inclusive but was " + width);
        }
        //可以发现MM也是用的yyyy这个解析器格式化的，但是后面三个参数不一样
        NumberPrinterParser pp = new NumberPrinterParser(field, width, width, SignStyle.NOT_NEGATIVE);
        appendValue(pp);
        return this;
    }

那我们`-`,`:`这些格式化符号的输出呢？是通过另外一个解析器，它先是取到`char`类型的一个字符来判断的时候会走到else里面然后走`appendLiteral(cur);`这个方法。看一下这个方法里面。这里可以看到主要使用的是 CharLiteralPrinterParser 这个解析器。

public DateTimeFormatterBuilder appendLiteral(char literal) {
        
        //这里可以看到主要使用的是 CharLiteralPrinterParser 这个解析器
        appendInternal(new CharLiteralPrinterParser(literal));
        return this;
    }

看一下 CharLiteralPrinterParser 这个解析器

//构造方法
    CharLiteralPrinterParser(char literal) {
        
        this.literal = literal;
    }
    
    @Override
    public boolean format(DateTimePrintContext context, StringBuilder buf) {
        
        //简单粗暴 直接把 - : 这种符号添加到字符串里面
        buf.append(literal);
        return true;
    }

接下来看一下为啥我们刚才上面说的，y代表 YEAR\_OF\_ERA，为啥就能从`2022-12-01`里面取到`2022`呢？这个可以看到我们`NumberPrinterParser`这个解析器里面主要调用了一个`context.getValue(field)`方法。

主要是`temporal.getLong(field)`方法，其实temporal就是我们的日期时间，在我们一开始创建上下文的时候过来的。回忆一下上面的创建。这里的temporal可以再往上一层传过来的，传的其实就是`LocalDateTime的对象`。

> new DateTimePrintContext(temporal, this)

Long getValue(TemporalField field) {
        
        try {
        
            //主要是这里，其实temporal就是我们的日期时间，在我们一开始创建上下文的时候过来的。
            return temporal.getLong(field);
        } catch (DateTimeException ex) {
        
            if (optional > 0) {
        
                return null;
            }
            throw ex;
        }
    }

所以我们再看一下`getLong`方法。可以看到有一个类型判断，`yMdHms`这几个类型就会走到if里面，如果是时间的 Hms这几个调用time.getLong方法，yMd日期的调用日期的getLong方法。Y的话就会走到 `getFrom` 这个方法。而且是通过`field`调用。

@Override
    public long getLong(TemporalField field) {
        
        //类型判断 yMdHms这几个走的这里面
        if (field instanceof ChronoField) {
        
            ChronoField f = (ChronoField) field;
            //如果是时间的 Hms这几个调用time.getLong方法，yMd日期的调用日期的getLong方法
            return (f.isTimeBased() ? time.getLong(field) : date.getLong(field));
        }
        //Y走这个方法
        return field.getFrom(this);
    }

看一下`getFrom`方法。

@Override
    public long getFrom(TemporalAccessor temporal) {
        
        if (rangeUnit == WEEKS) {
          // day-of-week
            return localizedDayOfWeek(temporal);
        } else if (rangeUnit == MONTHS) {
          // week-of-month
            return localizedWeekOfMonth(temporal);
        } else if (rangeUnit == YEARS) {
          // week-of-year
            return localizedWeekOfYear(temporal);
        } else if (rangeUnit == WEEK_BASED_YEARS) {
        
            return localizedWeekOfWeekBasedYear(temporal);
        } else if (rangeUnit == FOREVER) {
        
            // YYYY 大写的Y走的是这里
            return localizedWeekBasedYear(temporal);
        } else {
        
            throw new IllegalStateException("unreachable, rangeUnit: " + rangeUnit + ", this: " + this);
        }
    }

如果大写的`Y`格式化就会走下面的函数，主要就是取出年份以后计算周数，如果周数=0就认为是上一年的，年份-1，如果周数大于等于下一年的周数就年份+1

private int localizedWeekBasedYear(TemporalAccessor temporal) {
        
        //获取到这周的第几天 第5天
        int dow = localizedDayOfWeek(temporal);
        //获取日期中的年份 2021
        int year = temporal.get(YEAR);
        //获取今年的第几天 2021-12-30 是 364天
        int doy = temporal.get(DAY_OF_YEAR);
        //这周开始的偏移量 5
        int offset = startOfWeekOffset(doy, dow);
        //今年的第几周 53周
        int week = computeWeek(offset, doy);
        //如果这周是0周，就是上一年的，年份就-1
        if (week == 0) {
        
            // Day is in end of week of previous year; return the previous year
            return year - 1;
        } else {
        
            //如果接近年底，使用更高精度的逻辑
            //检查 如果年份的日期包含在下一年的部分的星期里面了
            // If getting close to end of year, use higher precision logic
            // Check if date of year is in partial week associated with next year
            //获取一年里面的天数 对象里面包含 最小1天 - 最大365天
            ValueRange dayRange = temporal.range(DAY_OF_YEAR);
            //获取到年份的长度，也就是365
            int yearLen = (int)dayRange.getMaximum();
            //下一年的周数 根据下面的计算公式得出 (7 + 5 + 366 - 1) / 7 = 53
            //这里为啥是366呢，因为yearLen是今年的天数也就是365 + 1，其实也就是到下一年去了。为的是计算下一年的第一周
            int newYearWeek = computeWeek(offset, yearLen + weekDef.getMinimalDaysInFirstWeek());
            //比较如果今年的这周大于等于下一年的周 就年份 +1 所以这里格式化就会出错了。
            if (week >= newYearWeek) {
        
                return year + 1;
            }
        }
        return year;
    }

那么是怎么计算今年的第几周的呢，看一下`computeWeek`方法。其实就是一个计算公式。

//offset = 5 , day = 今年的第几天 364 天
    private int computeWeek(int offset, int day) {
        
        //计算公式 ( 7 + 5 + （364 - 1）) / 7
        return ((7 + offset + (day - 1)) / 7);
    }

还有一个问题，就是我们用到了一个周的偏移量，这个偏移量怎么计算的呢，看一下这个方法`startOfWeekOffset`。以`2021-12-30`为例，day = 364,dow = 5

private int startOfWeekOffset(int day, int dow) {
        
        // offset of first day corresponding to the day of week in first 7 days (zero origin)
        //算出上一周 (364 - 5) % 7 = 2
        int weekStart = Math.floorMod(day - dow, 7);
        // offset = -2
        int offset = -weekStart;
        //这里 2 + 1  > 1会走进去
        if (weekStart + 1 > weekDef.getMinimalDaysInFirstWeek()) {
        
            // The previous week has the minimum days in the current month to be a 'week'
            //这里 7 - 2 = 5 返回的就是5
            offset = 7 - weekStart;
        }
        return offset;
    }

上面看完了大写的`Y`，再来看一下小写的`y`。走的`getLong`方法。

日期的`getLong`方法。经过判断后主要看`get0`这个方法。可以看到这个命名就很随意了。。

@Override
    public long getLong(TemporalField field) {
        
        //这个判断也会走进来
        if (field instanceof ChronoField) {
        
            //这两个判断忽略
            if (field == EPOCH_DAY) {
        
                return toEpochDay();
            }
            if (field == PROLEPTIC_MONTH) {
        
                return getProlepticMonth();
            }
            //走到这里
            return get0(field);
        }
        return field.getFrom(this);
    }

看一下日期的`get0`方法。可以发现了，这里主要处理了这几种类型。我们常用的

*  y也就是YEAR\_OF\_ERA 处理很简单，判断了一下year >= 1就返回 year。
 *  M也就是MONTH\_OF\_YEAR 处理很简单，返回日期的month.
 *  d也就是DAY\_OF\_MONTH 返回日期的day.

从这里也可以看出我们格式化成`YEAR`和`ERA`作为年其实也是可以的。

private int get0(TemporalField field) {
        
        switch ((ChronoField) field) {
        
            case DAY_OF_WEEK: return getDayOfWeek().getValue();
            case ALIGNED_DAY_OF_WEEK_IN_MONTH: return ((day - 1) % 7) + 1;
            case ALIGNED_DAY_OF_WEEK_IN_YEAR: return ((getDayOfYear() - 1) % 7) + 1;
            case DAY_OF_MONTH: return day;
            case DAY_OF_YEAR: return getDayOfYear();
            case EPOCH_DAY: throw new UnsupportedTemporalTypeException("Invalid field 'EpochDay' for get() method, use getLong() instead");
            case ALIGNED_WEEK_OF_MONTH: return ((day - 1) / 7) + 1;
            case ALIGNED_WEEK_OF_YEAR: return ((getDayOfYear() - 1) / 7) + 1;
            case MONTH_OF_YEAR: return month;
            case PROLEPTIC_MONTH: throw new UnsupportedTemporalTypeException("Invalid field 'ProlepticMonth' for get() method, use getLong() instead");
            case YEAR_OF_ERA: return (year >= 1 ? year : 1 - year);
            case YEAR: return year;
            case ERA: return (year >= 1 ? 1 : 0);
        }
        throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
    }

看完了日期的处理再看一下时间的吧，其实大同小异了。

时间的`getLong`方法。同样的经过判断走到`get0`里面，注意这是时间的`getLong`和`get0`。

@Override
    public long getLong(TemporalField field) {
        
        if (field instanceof ChronoField) {
        
            if (field == NANO_OF_DAY) {
        
                return toNanoOfDay();
            }
            if (field == MICRO_OF_DAY) {
        
                return toNanoOfDay() / 1000;
            }
            return get0(field);
        }
        return field.getFrom(this);
    }

时间的`get0`方法。处理的就是这些类型了。主要看我们关注的几个

*  H 也就是 HOUR\_OF\_DAY, 直接返回时间的 hour
 *  m 也就是MINUTE\_OF\_HOUR，直接返回时间的 minute
 *  s 也就是 SECOND\_OF\_MINUTE, 直接返回时间的 second

private int get0(TemporalField field) {
        
        switch ((ChronoField) field) {
        
            case NANO_OF_SECOND: return nano;
            case NANO_OF_DAY: throw new UnsupportedTemporalTypeException("Invalid field 'NanoOfDay' for get() method, use getLong() instead");
            case MICRO_OF_SECOND: return nano / 1000;
            case MICRO_OF_DAY: throw new UnsupportedTemporalTypeException("Invalid field 'MicroOfDay' for get() method, use getLong() instead");
            case MILLI_OF_SECOND: return nano / 1000_000;
            case MILLI_OF_DAY: return (int) (toNanoOfDay() / 1000_000);
            case SECOND_OF_MINUTE: return second;
            case SECOND_OF_DAY: return toSecondOfDay();
            case MINUTE_OF_HOUR: return minute;
            case MINUTE_OF_DAY: return hour * 60 + minute;
            case HOUR_OF_AMPM: return hour % 12;
            case CLOCK_HOUR_OF_AMPM: int ham = hour % 12; return (ham % 12 == 0 ? 12 : ham);
            case HOUR_OF_DAY: return hour;
            case CLOCK_HOUR_OF_DAY: return (hour == 0 ? 24 : hour);
            case AMPM_OF_DAY: return hour / 12;
        }
        throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
    }

### 总结 ###

好了，到这里我们知道了时间格式的各种使用方法和格式化的源码。

对于不同格式化的区别。总结一下。

*  `y` 处理简单，只是判断了year > 1 就返回了year。
 *  `Y` 处理较复杂，还判断了周，根据情况对年份+1和-1。某些年份的某些日期会有坑。**一定要注意！！！**
 *  `Md Hms`处理非常简单，直接返回了日期时间上面对应的数。
 *  `-:`一些特殊字符，格式化的时候是直接增加到字符串里面的。

下面总结一下源码对应文件和方法的追踪链。感兴趣的可以自己在多翻翻源码。

ofPattern指定格式的调用链

*  DateTimeFormatter.java -> public static DateTimeFormatter ofPattern(String pattern)
    
     *  DateTimeFormatterBuilder.java -> public DateTimeFormatterBuilder appendPattern(String pattern)
     *  DateTimeFormatterBuilder.java -> private void parsePattern(String pattern)
     *  DateTimeFormatterBuilder.java -> private void parseField(char cur, int count, TemporalField field)
     *  DateTimeFormatterBuilder.java -> public DateTimeFormatterBuilder appendValue(TemporalField field, int width)
     *  在这里创建的解析器
     *  DateTimeFormatterBuilder.java -> `static class NumberPrinterParser implements DateTimePrinterParser`
     *  DateTimeFormatterBuilder.java -> `static final class CharLiteralPrinterParser implements DateTimePrinterParser`

format方法调用链

*  LocalDateTime.java -> public String format(DateTimeFormatter formatter)
    
     *  DateTimeFormatter.java -> public String format(TemporalAccessor temporal)
     *  DateTimeFormatter.java -> public void formatTo(TemporalAccessor temporal, Appendable appendable)
        
         *  接下来根据不同的处理解析器进行处理，主要有两个解析器
         *  DateTimeFormatterBuilder.java -> `static class NumberPrinterParser implements DateTimePrinterParser`
         *  DateTimeFormatterBuilder.java -> `static final class CharLiteralPrinterParser implements DateTimePrinterParser`
            
             *  DateTimePrintContext.java -> Long getValue(TemporalField field)
                
                 *  LocalDateTime.java -> public long getLong(TemporalField field)
                    
                     *  这里日期调日期的 LocalDate.java -> public long getLong(TemporalField field)
                     *  LocalDate.java -> private int get0(TemporalField field)
                     *  时间调时间的 LocalTime.java -> public long getLong(TemporalField field)
                     *  LocalTime.java -> private int get0(TemporalField field)