4hutool源码分析：DateUtil(时间工具类)-格式化时间(万字长文源码分析，学大佬如何写代码)

水深无声 2022-09-01 14:56 207阅读 0赞

技术活，该赏
    点赞再看，养成习惯

看本篇文章前，建议先对java源码的日期和时间有一定的了解，如果不了解的话，可以先看这篇文章：

[万字博文教你搞懂java源码的日期和时间相关用法][java]

关联文章：

[hutool实战（带你掌握里面的各种工具）目录][hutool]

[4hutool实战:DateUtil-格式化时间][4hutool_DateUtil-]

--------------------

# 源码分析目的 #

知其然，知其所以然

# 项目引用 #

此博文的依据：hutool-5.6.5版本源码

<dependency>
 			<groupId>cn.hutool</groupId>
 			<artifactId>hutool-core</artifactId>
 			<version>5.6.5</version>
 		</dependency>

# 方法名称:DateUtil.formatLocalDateTime(java.time.LocalDateTime) #

## 方法描述 ##

格式化日期时间 
格式 yyyy-MM-dd HH:mm:ss

## 源码分析一 ##

/** * 格式化日期时间 * 格式 yyyy-MM-dd HH:mm:ss * * @param localDateTime 被格式化的日期 * @return 格式化后的字符串 */
 	public static String formatLocalDateTime(LocalDateTime localDateTime) { 
 		return LocalDateTimeUtil.formatNormal(localDateTime);
 	}

首先**formatLocalDateTime方法**的入参是**LocalDateTime**（Java8支持的日期时间类，是线程安全的）

然后调用**LocalDateTimeUtil.formatNormal(localDateTime)**

//LocalDateTimeUtil
    	/** * 格式化日期时间为yyyy-MM-dd HH:mm:ss格式 * * @param time {@link LocalDateTime} * @return 格式化后的字符串 * @since 5.3.11 */
    	public static String formatNormal(LocalDateTime time) { 
    		return format(time, DatePattern.NORM_DATETIME_FORMATTER);
    	}
    	/** * 格式化日期时间为指定格式 * * @param time {@link LocalDateTime} * @param formatter 日期格式化器，预定义的格式见：{@link DateTimeFormatter} * @return 格式化后的字符串 */
    	public static String format(LocalDateTime time, DateTimeFormatter formatter) { 
    		return TemporalAccessorUtil.format(time, formatter);
    	}

跟代码，发现**DatePattern.NORM\_DATETIME\_FORMATTER**的日期时间格式为：

/** * 标准日期时间格式，精确到秒：yyyy-MM-dd HH:mm:ss */
    public static final String NORM_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

然后会调用**format(LocalDateTime time, DateTimeFormatter formatter)**，DateTimeFormatter 这个也是（Java8支持的日期格式化器类，是线程安全的）。

hutool这里做了很好的示范，使用DateTimeFormatter替换了SimpleDateFormat（线程不安全的）。

为什么SimpleDateFormat是线程不安全的，请看[万字博文教你搞懂java源码的日期和时间相关用法][java]

然后我们继续往下深挖**TemporalAccessorUtil.format(time, formatter)**

/** * 格式化日期时间为指定格式 * * @param time {@link TemporalAccessor} * @param formatter 日期格式化器，预定义的格式见：{@link DateTimeFormatter} * @return 格式化后的字符串 * @since 5.3.10 */
    public static String format(TemporalAccessor time, DateTimeFormatter formatter) { 
       if (null == time) { 
          return null;
       }
    
       if(null == formatter){ 
          formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
       }
    
    
       try { 
          return formatter.format(time);
       } catch (UnsupportedTemporalTypeException e){ 
          if(time instanceof LocalDate && e.getMessage().contains("HourOfDay")){ 
             // 用户传入LocalDate，但是要求格式化带有时间部分，转换为LocalDateTime重试
             return formatter.format(((LocalDate) time).atStartOfDay());
          }else if(time instanceof LocalTime && e.getMessage().contains("YearOfEra")){ 
             // 用户传入LocalTime，但是要求格式化带有日期部分，转换为LocalDateTime重试
             return formatter.format(((LocalTime) time).atDate(LocalDate.now()));
          }
          throw e;
       }
    }

最前面加了两个入参判空处理，**time**为null时，返回null；**formatter**为null时，给格式默认值，eg:2011-12-03T10:15:30

![image-20210725113946673][]

然后执行**formatter.format(time)相当于是DateTimeFormatter.format(LocalDateTime)**。这样就格式化成功了。

值得一说的是\*\*TemporalAccessorUtil.format(TemporalAccessor time, DateTimeFormatter formatter)\*\*里面有加异常处理机制

try { 
          return formatter.format(time);
       } catch (UnsupportedTemporalTypeException e){ 
          if(time instanceof LocalDate && e.getMessage().contains("HourOfDay")){ 
             // 用户传入LocalDate，但是要求格式化带有时间部分，转换为LocalDateTime重试
             return formatter.format(((LocalDate) time).atStartOfDay());
          }else if(time instanceof LocalTime && e.getMessage().contains("YearOfEra")){ 
             // 用户传入LocalTime，但是要求格式化带有日期部分，转换为LocalDateTime重试
             return formatter.format(((LocalTime) time).atDate(LocalDate.now()));
          }
          throw e;
       }

因为入参**TemporalAccessor time**的实现类常用的有如下几个（java8提供的）：

*  LocalDateTime
 *  LocalDate
 *  LocalTime

在进行日期时间转化时，日期时间和要转化的格式化字符串要对应上，不然会抛出异常，所以做了如上的补救措施。

# 方法名称:DateUtil.format(java.time.LocalDateTime, java.lang.String) #

## 方法描述 ##

根据特定格式格式化日期

## 源码分析一 ##

/** * 根据特定格式格式化日期 * * @param localDateTime 被格式化的日期 * @param format 日期格式，常用格式见： {@link DatePattern} * @return 格式化后的字符串 */
    public static String format(LocalDateTime localDateTime, String format) { 
       return LocalDateTimeUtil.format(localDateTime, format);
    }

首先：hutool提供了常用的日期时间格式

/** * 日期格式化类，提供常用的日期格式化对象 * */
    public class DatePattern { 
    ...
    }

![image-20210725115905355][]

然后：调用**LocalDateTimeUtil.format(localDateTime, format)**

/** * 格式化日期时间为指定格式 * * @param time {@link LocalDateTime} * @param format 日期格式，类似于yyyy-MM-dd HH:mm:ss,SSS * @return 格式化后的字符串 */
    public static String format(LocalDateTime time, String format) { 
       if (null == time) { 
          return null;
       }
       return format(time, DateTimeFormatter.ofPattern(format));
    }

源码\*\*format(time, DateTimeFormatter.ofPattern(format))\*\*可以拆解成两部分：

*  DateTimeFormatter.ofPattern(format)
 *  format(LocalDateTime time, DateTimeFormatter formatter)

第一部分：\*\*DateTimeFormatter.ofPattern(format)\*\*是把字符串日期时间格式转化为日期时间格式化对象DateTimeFormatter ；

注意DateTimeFormatter.ofPattern(format)的用法是有**坑**的(代码详解–>[万字博文教你搞懂java源码的日期和时间相关用法][java]):

1.  在正常配置按照标准格式的字符串日期，是能够正常转换的。如果月，日，时，分，秒在不足两位的情况需要补0，否则的话会转换失败，抛出异常。
2.  YYYY和DD谨慎使用

第二部分，format(LocalDateTime time, DateTimeFormatter formatter)上面有介绍了，这里就不水字了。

# 方法名称:DateUtil.format(java.util.Date, java.text.DateFormat) #

## 方法描述 ##

根据特定格式格式化日期

## 源码分析一 ##

/** * 根据特定格式格式化日期 * * @param date 被格式化的日期 * @param format 日期格式，常用格式见： {@link DatePattern} * @return 格式化后的字符串 */
    public static String format(Date date, String format) { 
       if (null == date || StrUtil.isBlank(format)) { 
          return null;
       }
    
       TimeZone timeZone = null;
       if (date instanceof DateTime) { 
          timeZone = ((DateTime) date).getTimeZone();
       }
       return format(date, newSimpleFormat(format, null, timeZone));
    }

从代码中\*\*format(Date date, String format)\*\*方法提供了两个入参，一个是Date 类型的 被格式化的日期和要日期格式的字符串。**这是为了兼容java8之前的旧日期时间API提供的方法**。

方法内首先对两个参数加了判空处理。

然后判断时间是否是hutool的DateTime对象，如果是，则获取时区TimeZone

接着调用**format(date, newSimpleFormat(format, null, timeZone))**,可拆解成两部分：

*  newSimpleFormat(format, null, timeZone)，获取SimpleDateFormat对象（注：此方法是非线程安全的）
 *  format(Date date, DateFormat format) 根据特定格式格式化日期

首先：\*\*newSimpleFormat(format, null, timeZone)\*\*代码详解：

/** * 创建{@link SimpleDateFormat}，注意此对象非线程安全！ * 此对象默认为严格格式模式，即parse时如果格式不正确会报错。 * * @param pattern 表达式 * @param locale {@link Locale}，{@code null}表示默认 * @param timeZone {@link TimeZone}，{@code null}表示默认 * @return {@link SimpleDateFormat} * @since 5.5.5 */
 public static SimpleDateFormat newSimpleFormat(String pattern, Locale locale, TimeZone timeZone) { 
 if (null == locale) { 
 locale = Locale.getDefault(Locale.Category.FORMAT);
 }
 final SimpleDateFormat format = new SimpleDateFormat(pattern, locale);
 if (null != timeZone) { 
 format.setTimeZone(timeZone);
 }
 format.setLenient(false);
 return format;
 }

如果\*\*format(Date date, String format)**输入的是Date对象的时间，那**format(date, newSimpleFormat(format, null, timeZone))\*\*具象化后，是这样的：**format(date, newSimpleFormat(format, null, null))**。

//获取当前的语言环境 
    locale = Locale.getDefault(Locale.Category.FORMAT);

然后new了一个**SimpleDateFormat对象**。并设置了时区和设置了setLenient，这个方法的含义是是否严格解析日期。setLenient设置为false时，就是严格解析日期：会严格按照日期时间格式，java不会帮忙计算，直接抛出异常。

![image-20210725122714337][]

然后\*\*format(Date date, DateFormat format) \*\*代码分析：

/** * 根据特定格式格式化日期 * * @param date 被格式化的日期 * @param format {@link SimpleDateFormat} * @return 格式化后的字符串 */
    public static String format(Date date, DateFormat format) { 
       if (null == format || null == date) { 
          return null;
       }
       return format.format(date);
    }

对两个入参进行了判空处理。然后调用**SimpleDateFormat.format(date)**，这是java8之前就有提供的方法。

# 方法名称:DateUtil.format(java.util.Date, java.time.format.DateTimeFormatter)（方法有问题，已反馈,官方已修正） #

## 方法描述 ##

根据特定格式格式化日期

## 源码分析一 ##

/** * 根据特定格式格式化日期 * * @param date 被格式化的日期 * @param format {@link DateTimeFormatter} * @return 格式化后的字符串 * @since 5.0.0 */
    public static String format(Date date, DateTimeFormatter format) { 
       if (null == format || null == date) { 
          return null;
       }
       return format.format(date.toInstant());
    }

首先对两个入参做了判空处理。

然后，执行了**format.format(date.toInstant())**,代码可拆解成两部分：

*  date.toInstant():返回Instant对象
 *  DateTimeFormatter.format(Instant)：java8提供的格式化日期时间的方法

代码\*\*DateTimeFormatter.format(Instant)\*\*是怎么处理的呢？

public String format(TemporalAccessor temporal) { 
            StringBuilder buf = new StringBuilder(32);
            formatTo(temporal, buf);
            return buf.toString();
        }

首先new了个StringBuilder对象，用来拼接字符串；

然后调用\*\*formatTo(temporal, buf)\*\*方法

public void formatTo(TemporalAccessor temporal, Appendable appendable) { 
        Objects.requireNonNull(temporal, "temporal");
        Objects.requireNonNull(appendable, "appendable");
        try { 
            DateTimePrintContext context = new DateTimePrintContext(temporal, this);
            if (appendable instanceof StringBuilder) { 
                printerParser.format(context, (StringBuilder) appendable);
            } else { 
                // 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);
        }
    }

\*\*formatTo(temporal, buf)\*\*方法也是先判断两个入参空处理。

然后，Instant对象被封装在一个新new的DateTimePrintContext对象

运行demo有问题，进行排查

//根据特定格式格式化日期
    		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    		String dateStr = DateUtil.format(new Date(),dtf);
    		System.out.println(dateStr);

![image-20210725195348793][]

到这里已经是jdk的源码了DateTimeFormatter.format

![image-20210725195424950][]

![image-20210725195522610][]

![image-20210725195636339][]

从上面可知，会调用 **NumberPrinterParser.format()** NumberPrinterParser是在DateTimeFormatterBuilder类中的。

![image-20210725195947802][]

到这一步会报错

![image-20210725200153850][]

为什么会报错呢，我们来看下context.getValue(field)发生了什么：

![image-20210725200349650][]

从上面代码可行，temporal实际上是Instant对象，Instant.getLong只支持四种字段类型。。

NANO_OF_SECOND
    MICRO_OF_SECOND
    MILLI_OF_SECOND
    INSTANT_SECONDS

![image-20210725200551164][]

如果不是上面这几种字段类型，则抛出异常

DateUtil.format当遇到DateTimeFormatter会将Date对象首先转换为Instant，因为缺少时区，导致报错。

## 建议改法 ##

/** * 根据特定格式格式化日期 * * @param date 被格式化的日期 * @param format {@link SimpleDateFormat} todo-zhw DateTimeFormatter * @return 格式化后的字符串 * @since 5.0.0 */
    public static String format(Date date, DateTimeFormatter format) { 
       if (null == format || null == date) { 
          return null;
       }
       Instant instant = date.toInstant();
       ZoneId zoneId = ZoneId.systemDefault();
       ZonedDateTime zonedDateTime = instant.atZone(zoneId);
       LocalDateTime localDateTime = zonedDateTime.toLocalDateTime();
       return format.format(localDateTime);
    }

先把date类型转化为LocalDateTime类型，然后再进行DateTimeFormatter.format(LocalDateTime)的格式化

测试demo

//根据特定格式格式化日期
    String str = "2021-07-25 20:11:25";
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:dd");
    Date date = DateUtil.parse(str);
    String dateStr = DateUtil.format(date,dtf);
    System.out.println(dateStr);
    Assert.assertEquals(str, dateStr);

![image-20210725201444728][]

## 官方改法 ##

修订版本 \#5.7.5

/** * 根据特定格式格式化日期 * * @param date 被格式化的日期 * @param format {@link SimpleDateFormat} {@link DatePattern#NORM_DATETIME_FORMATTER} * @return 格式化后的字符串 * @since 5.0.0 */
    public static String format(Date date, DateTimeFormatter format) { 
       if (null == format || null == date) { 
          return null;
       }
       // java.time.temporal.UnsupportedTemporalTypeException: Unsupported field: YearOfEra
       // 出现以上报错时，表示Instant时间戳没有时区信息，赋予默认时区
       return TemporalAccessorUtil.format(date.toInstant(), format);
    }

更换了新的调用方法**TemporalAccessorUtil.format(date.toInstant(), format)**,date.toInstant()返回Instant对象，则变成了**TemporalAccessorUtil.format(Instant, format)**

//TemporalAccessorUtil
    	/** * 格式化日期时间为指定格式 * * @param time {@link TemporalAccessor} * @param formatter 日期格式化器，预定义的格式见：{@link DateTimeFormatter} * @return 格式化后的字符串 * @since 5.3.10 */
    	public static String format(TemporalAccessor time, DateTimeFormatter formatter) { 
    		if (null == time) { 
    			return null;
    		}
    
    		if(null == formatter){ 
    			formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    		}
    
    		try { 
    			return formatter.format(time);
    		} catch (UnsupportedTemporalTypeException e){ 
    			if(time instanceof LocalDate && e.getMessage().contains("HourOfDay")){ 
    				// 用户传入LocalDate，但是要求格式化带有时间部分，转换为LocalDateTime重试
    				return formatter.format(((LocalDate) time).atStartOfDay());
    			}else if(time instanceof LocalTime && e.getMessage().contains("YearOfEra")){ 
    				// 用户传入LocalTime，但是要求格式化带有日期部分，转换为LocalDateTime重试
    				return formatter.format(((LocalTime) time).atDate(LocalDate.now()));
    			} else if(time instanceof Instant){ 
    				// 时间戳没有时区信息，赋予默认时区
    				return formatter.format(((Instant) time).atZone(ZoneId.systemDefault()));
    			}
    			throw e;
    		}
    	}

对比了下跟5.6.5版本的差异，新增了当time是Instant时，给一个默认的时区

else if(time instanceof Instant){ 
       // 时间戳没有时区信息，赋予默认时区
       return formatter.format(((Instant) time).atZone(ZoneId.systemDefault()));
    }

![image-2021072651290][]

# 方法名称:DateUtil.formatDateTime(java.util.Date) #

## 方法描述 ##

格式化日期时间 
格式 yyyy-MM-dd HH:mm:ss

## 源码分析一 ##

/** * 格式化日期时间 * 格式 yyyy-MM-dd HH:mm:ss * * @param date 被格式化的日期 * @return 格式化后的日期 */
 public static String formatDateTime(Date date) { 
 if (null == date) { 
 return null;
 }
 return DatePattern.NORM_DATETIME_FORMAT.format(date);
 }

首先好习惯，先对入参进行判空处理

然后调用**DatePattern.NORM\_DATETIME\_FORMAT.format(date)返回FastDateFormat**对象

针对只支持java8之前的程序，可以使用FastDateFormat线程安全替换SimpleDateFormat线程不安全–》[源码分析][Link 1]

FastDateFormat 是一个线程安全的实现
    来源 Apache Commons Lang 3.5

DatePattern.NORM_DATETIME_FORMAT-->	
    /** * 标准日期时间格式，精确到秒 {@link FastDateFormat}：yyyy-MM-dd HH:mm:ss */
    	public static final FastDateFormat NORM_DATETIME_FORMAT = FastDateFormat.getInstance(NORM_DATETIME_PATTERN);

则转化为了**FastDateFormat.format(date)**

//FastDateFormat
    @Override
    public String format(final Date date) { 
       return printer.format(date);
    }
    
    //FastDatePrinter 
    @Override
    public String format(final Date date) { 
        final Calendar c = Calendar.getInstance(timeZone, locale);
        c.setTime(date);
        return applyRulesToString(c);
    }

先把date转化为Calendar，方便获取日期和时间

private String applyRulesToString(final Calendar c) { 
 return applyRules(c, new StringBuilder(mMaxLengthEstimate)).toString();
 }
 
 	private B applyRules(final Calendar calendar, final B buf) { 
 		try { 
 			for (final Rule rule : this.rules) { 
 				rule.appendTo(buf, calendar);
 			}
 		} catch (final IOException e) { 
 			throw new DateException(e);
 		}
 		return buf;
 	}

核心的代码是这块

for (final Rule rule : this.rules) { 
    				rule.appendTo(buf, calendar);
    			}

测试demo

String dateStr = "2017-03-01";
    Date date = DateUtil.parse(dateStr);
    String formatDateTime = DateUtil.formatDateTime(date);
    Assert.assertEquals("2017-03-01 00:00:00", formatDateTime);

断点跟进代码：

![image-20210725211322291][]

往下跟代码

![image-20210725203801875][]

//FastDatePrinter
    private static class PaddedNumberField implements NumberRule { 
        ...
           @Override
    		public void appendTo(final Appendable buffer, final Calendar calendar) throws IOException { 
    			appendTo(buffer, calendar.get(mField));
    		}
    
    		/** * {@inheritDoc} */
    		@Override
    		public final void appendTo(final Appendable buffer, final int value) throws IOException { 
    			appendFullDigits(buffer, value, mSize);
    		} 
            
        ...}

已经取到年份了：2017

![image-20210725204215108][]

往下跟代码：

![image-20210725211459199][]

//FastDatePrinter
    	private static class CharacterLiteral implements Rule { 
    	...
    	@Override
    		public void appendTo(final Appendable buffer, final Calendar calendar) throws IOException { 
    			buffer.append(mValue);
    		}
    	...
    	}

就是把’-'字符串直接拼接上去。

下一个获取月份：

![image-20210725211534912][]

//FastDatePrinter
    private static class TwoDigitMonthField implements NumberRule { 
        ...
            /** * {@inheritDoc} */
    		@Override
    		public void appendTo(final Appendable buffer, final Calendar calendar) throws IOException { 
    			appendTo(buffer, calendar.get(Calendar.MONTH) + 1);
    		}
    
    		/** * {@inheritDoc} */
    		@Override
    		public final void appendTo(final Appendable buffer, final int value) throws IOException { 
    			appendDigits(buffer, value);
    		}
        ...
    }

获取了月份：3

![image-20210725205900990][]

然后下一个：把’-'字符串直接拼接上去。

![image-20210725211609400][]

继续往下跟

![image-20210725211704501][]

//FastDatePrinter
 private static class TwoDigitNumberField implements NumberRule { 
 ...
 	@Override
 		public void appendTo(final Appendable buffer, final Calendar calendar) throws IOException { 
 			appendTo(buffer, calendar.get(mField));
 		}
 
 		/** * {@inheritDoc} */
 		@Override
 		public final void appendTo(final Appendable buffer, final int value) throws IOException { 
 			if (value < 100) { 
 				appendDigits(buffer, value);
 			} else { 
 				appendFullDigits(buffer, value, 2);
 			}
 		}
 ...
 }

![image-20210725210353207][]

这样获取到的日期：2017-03-01

然后加了一个空格字符串

![image-20210725211811625][]

时分秒的调用，都是调用一样的FastDatePrinter\#TwoDigitNumberField。

![image-20210725212005035][]

这样就得到了"2017-03-01 00:00:00"

# 方法名称:DateUtil.formatDate(java.util.Date) #

## 方法描述 ##

格式化日期部分（不包括时间） 
格式 yyyy-MM-dd

## 源码分析一 ##

/** * 格式化日期部分（不包括时间） * 格式 yyyy-MM-dd * * @param date 被格式化的日期 * @return 格式化后的字符串 */
 public static String formatDate(Date date) { 
 if (null == date) { 
 return null;
 }
 return DatePattern.NORM_DATE_FORMAT.format(date);
 }

首先好习惯，先对入参进行判空处理

然后调用**DatePattern.NORM\_DATE\_FORMAT.format(date)返回FastDateFormat**对象

针对只支持java8之前的程序，可以使用FastDateFormat线程安全替换SimpleDateFormat线程不安全–》[源码分析][Link 1]

FastDateFormat 是一个线程安全的实现
    来源 Apache Commons Lang 3.5

/** * 标准日期格式 {@link FastDateFormat}：yyyy-MM-dd */
    	public static final FastDateFormat NORM_DATE_FORMAT = FastDateFormat.getInstance(NORM_DATE_PATTERN);

则转化为了**FastDateFormat.format(date)**,源码分析看上面

# 方法名称:DateUtil.formatTime(java.util.Date) #

## 方法描述 ##

格式化时间 
格式 HH:mm:ss

## 源码分析一 ##

/** * 格式化时间 * 格式 HH:mm:ss * * @param date 被格式化的日期 * @return 格式化后的字符串 * @since 3.0.1 */
 public static String formatTime(Date date) { 
 if (null == date) { 
 return null;
 }
 return DatePattern.NORM_TIME_FORMAT.format(date);
 }

首先好习惯，先对入参进行判空处理

然后调用**DatePattern.NORM\_TIME\_FORMAT.format(date)返回FastDateFormat**对象

针对只支持java8之前的程序，可以使用FastDateFormat线程安全替换SimpleDateFormat线程不安全–》[源码分析][Link 1]

FastDateFormat 是一个线程安全的实现
    来源 Apache Commons Lang 3.5

/** * 标准时间格式 {@link FastDateFormat}：HH:mm:ss */
    	public static final FastDateFormat NORM_TIME_FORMAT = FastDateFormat.getInstance(NORM_TIME_PATTERN);

则转化为了**FastDateFormat.format(date)**,源码分析看上面

# 方法名称:DateUtil.formatHttpDate(java.util.Date) #

## 方法描述 ##

格式化为Http的标准日期格式 
标准日期格式遵循RFC 1123规范，格式类似于：Fri, 31 Dec 1999 23:59:59 GMT

## 源码分析一 ##

/** * 格式化为Http的标准日期格式 * 标准日期格式遵循RFC 1123规范，格式类似于：Fri, 31 Dec 1999 23:59:59 GMT * * @param date 被格式化的日期 * @return HTTP标准形式日期字符串 */
 public static String formatHttpDate(Date date) { 
 if (null == date) { 
 return null;
 }
 return DatePattern.HTTP_DATETIME_FORMAT.format(date);
 }

首先好习惯，先对入参进行判空处理

然后调用**DatePattern.HTTP\_DATETIME\_FORMAT.format(date)返回FastDateFormat**对象

针对只支持java8之前的程序，可以使用FastDateFormat线程安全替换SimpleDateFormat线程不安全–》[源码分析][Link 1]

FastDateFormat 是一个线程安全的实现
    来源 Apache Commons Lang 3.5

/** * HTTP头中日期时间格式 {@link FastDateFormat}：EEE, dd MMM yyyy HH:mm:ss z */
    	public static final FastDateFormat HTTP_DATETIME_FORMAT = FastDateFormat.getInstance(HTTP_DATETIME_PATTERN, TimeZone.getTimeZone("GMT"), Locale.US);

则转化为了**FastDateFormat.format(date)**,源码分析看上面

# 方法名称:DateUtil.formatChineseDate(java.util.Date, boolean, boolean) #

## 方法描述 ##

格式化为中文日期格式，如果isUppercase为false，则返回类似：2018年10月24日，否则返回二〇一八年十月二十四日

## 源码分析一 ##

/** * 格式化为中文日期格式，如果isUppercase为false，则返回类似：2018年10月24日，否则返回二〇一八年十月二十四日 * * @param date 被格式化的日期 * @param isUppercase 是否采用大写形式 * @param withTime 是否包含时间部分 * @return 中文日期字符串 * @since 5.3.9 */
    public static String formatChineseDate(Date date, boolean isUppercase, boolean withTime) { 
       if (null == date) { 
          return null;
       }
    
       if (false == isUppercase) { 
          return (withTime ? DatePattern.CHINESE_DATE_TIME_FORMAT : DatePattern.CHINESE_DATE_FORMAT).format(date);
       }
    
       return CalendarUtil.formatChineseDate(CalendarUtil.calendar(date), withTime);
    }

首先好习惯，先对入参进行判空处理

### 当不采用大写形式时 ###

执行\*\*(withTime ? DatePattern.CHINESE\_DATE\_TIME\_FORMAT : DatePattern.CHINESE\_DATE\_FORMAT).format(date)\*\*

这里用了一个多目运算，包含时间部分时，调用**DatePattern.CHINESE\_DATE\_TIME\_FORMAT .format(date)**, 不包含时间部分时，调用**DatePattern.CHINESE\_DATE\_FORMAT.format(date)**

/** * 标准日期格式 {@link FastDateFormat}：yyyy年MM月dd日HH时mm分ss秒 */
    public static final FastDateFormat CHINESE_DATE_TIME_FORMAT = FastDateFormat.getInstance(CHINESE_DATE_TIME_PATTERN);
    
    	/** * 标准日期格式 {@link FastDateFormat}：yyyy年MM月dd日 */
    	public static final FastDateFormat CHINESE_DATE_FORMAT = FastDateFormat.getInstance(CHINESE_DATE_PATTERN);

由上面源码可知，两个都是返回**FastDateFormat**对象。

针对只支持java8之前的程序，可以使用FastDateFormat线程安全替换SimpleDateFormat线程不安全–》[源码分析][Link 1]

FastDateFormat 是一个线程安全的实现
    来源 Apache Commons Lang 3.5

则转化为了**FastDateFormat.format(date)**,源码分析看上面

### 当采用大写形式时 ###

执行**CalendarUtil.formatChineseDate(CalendarUtil.calendar(date), withTime);**

可以拆解成两部分：

*  CalendarUtil.calendar(date):把date对象转换为Calendar对象
 *  CalendarUtil.formatChineseDate(Calendar calendar, boolean withTime)：将指定Calendar时间格式化为纯中文形式，例如
    
        2018-02-24 12:13:14转换为 二〇一八年二月二十四日（withTime为false）
        2018-02-24 12:13:14 转换为 二〇一八年二月二十四日一十二时一十三分一十四秒（withTime为true）

#### CalendarUtil.calendar(date)源码分析： ####

/** * 转换为Calendar对象 * * @param date 日期对象 * @return Calendar对象 */
    public static Calendar calendar(Date date) { 
       if (date instanceof DateTime) { 
          return ((DateTime) date).toCalendar();
       } else { 
          return calendar(date.getTime());
       }
    }

如果是hutool提供的DateTime类型，可以直接转化获取。

如果是date类型，则通过\***cal.setTimeInMillis**转化为Calendar对象。

/** * 转换为Calendar对象 * * @param millis 时间戳 * @return Calendar对象 */
    public static Calendar calendar(long millis) { 
       final Calendar cal = Calendar.getInstance();
       cal.setTimeInMillis(millis);
       return cal;
    }

有同学会发现，这个跟我们常用的**Calendar.setTime(Date date)**，不一样，看了下源码

//Calendar
    public final void setTime(Date date) { 
        setTimeInMillis(date.getTime());
    }

本质上是一样的。。**setTime方法**里也是会调用setTimeInMillis方法。

#### CalendarUtil.formatChineseDate(Calendar calendar, boolean withTime)源码分析： ####

/** * 将指定Calendar时间格式化为纯中文形式，比如： * * <pre> * 2018-02-24 12:13:14转换为 二〇一八年二月二十四日（withTime为false） * 2018-02-24 12:13:14 转换为 二〇一八年二月二十四日一十二时一十三分一十四秒（withTime为true） * </pre> * * @param calendar {@link Calendar} * @param withTime 是否包含时间部分 * @return 格式化后的字符串 * @since 5.3.9 */
 public static String formatChineseDate(Calendar calendar, boolean withTime) { 
 final StringBuilder result = StrUtil.builder();
 
 // 年
 String year = String.valueOf(calendar.get(Calendar.YEAR));
 final int length = year.length();
 for (int i = 0; i < length; i++) { 
 result.append(NumberChineseFormatter.numberCharToChinese(year.charAt(i), false));
 }
 result.append('年');
 
 // 月
 int month = calendar.get(Calendar.MONTH) + 1;
 result.append(NumberChineseFormatter.format(month, false));
 result.append('月');
 
 // 日
 int day = calendar.get(Calendar.DAY_OF_MONTH);
 result.append(NumberChineseFormatter.format(day, false));
 result.append('日');
 
 if (withTime) { 
 // 时
 int hour = calendar.get(Calendar.HOUR_OF_DAY);
 result.append(NumberChineseFormatter.format(hour, false));
 result.append('时');
 // 分
 int minute = calendar.get(Calendar.MINUTE);
 result.append(NumberChineseFormatter.format(minute, false));
 result.append('分');
 // 秒
 int second = calendar.get(Calendar.SECOND);
 result.append(NumberChineseFormatter.format(second, false));
 result.append('秒');
 }
 
 return result.toString().replace('零', '〇');
 }

由源码可知，是按年月日时分秒，每个字段进行转化。

[java]: https://xiaoxuzhu.blog.csdn.net/article/details/118947669
[hutool]: https://blog.csdn.net/shi_hong_fei_hei/article/details/117253917
[4hutool_DateUtil-]: https://blog.csdn.net/shi_hong_fei_hei/article/details/117305616
[image-20210725113946673]: /images/20220829/7b62cc7b50d34030a0f9949378fa18f6.png
[image-20210725115905355]: /images/20220829/88607173c6f445bda72949801144a5fc.png
[image-20210725122714337]: /images/20220829/bec98cc0f20f49c8a7b8bff28ad2c309.png
[image-20210725195348793]: /images/20220829/ee02a44e919c4eb98ee4cdde17cbf51e.png
[image-20210725195424950]: /images/20220829/732dec22b36341b49feec8aee3dc2cdc.png
[image-20210725195522610]: /images/20220829/7cb777b6ba2e41b384137b575e01c434.png
[image-20210725195636339]: /images/20220829/3fdfb9148ebe46c0aa3d18e0cb3c4eaf.png
[image-20210725195947802]: /images/20220829/775d2165f9924e62bf200fcf1e9268af.png
[image-20210725200153850]: /images/20220829/335b1eeff96e483eb4277f3cf3161df7.png
[image-20210725200349650]: /images/20220829/c84ab62cbb854ba181167465277907c0.png
[image-20210725200551164]: /images/20220829/e3da7a11c5fd426a85ec4a431f63b824.png
[image-20210725201444728]: /images/20220829/9f9b2c18fba8491f96184b667d97a88d.png
[image-2021072651290]: /images/20220829/f625f03f68e8424196c381a673e08ef2.png
[Link 1]: https://xiaoxuzhu.blog.csdn.net/article/details/119189969
[image-20210725211322291]: /images/20220829/79c9abdd28a4484294c521cf4e90fc9f.png
[image-20210725203801875]: /images/20220829/9b6a8a0e40e84cefa45380d23b6c587c.png
[image-20210725204215108]: /images/20220829/c3f935dace6c4961bcaea442f60314d3.png
[image-20210725211459199]: /images/20220829/571b7f73592043d89a2c2cf86a2c5e3f.png
[image-20210725211534912]: /images/20220829/294ec13a1ca748cb8230503b4f825d27.png
[image-20210725205900990]: /images/20220829/342af062db03454595aaee22944c206c.png
[image-20210725211609400]: /images/20220829/979a2c092f28484aa90cd3dc9285bbd7.png
[image-20210725211704501]: /images/20220829/34692d36b7464a4db59258ef7c1e2e32.png
[image-20210725210353207]: /images/20220829/31a39dc23e154f01a538003dd6b416d1.png
[image-20210725211811625]: /images/20220829/e5fdbb77243941788b0a0eab6b28915b.png
[image-20210725212005035]: /images/20220829/a1f9418f799b4cc3be8cda2fb37f2c23.png