背景
最近刚做了一个用户签到获取奖励的需求，因为是Trip端即海外端，所以会需要考虑到时区的问题，又用到了平时配置中会经常使用到的关于生效时间问题的LocalDate和LocalDateTime类，刚好最近就好好整理一下。按照惯例，我们还是从学源码开始，然后写写例子实践一下，最后总结。
LocalDate
public final class LocalDate
implements Temporal, TemporalAdjuster, ChronoLocalDate, Serializable {
//年月日
private final int year;
private final short month;
private final short day;
//常用的一个方法，获取当前默认时区当前时间的LocalDate对象，有兴趣的同学可以走进去看看Clock代码
public static LocalDate now() {
return now(Clock.systemDefaultZone());
}
//获取指定时区当前时间的LocalDate对象
public static LocalDate now(ZoneId zone) {
return now(Clock.system(zone));
}
//从这里可以看出根据时区获取就是先获取当前格林威治时间now，然后加上时区的偏移量
public static LocalDate now(Clock clock) {
Objects.requireNonNull(clock, "clock");
final Instant now = clock.instant();
ZoneOffset offset = clock.getZone().getRules().getOffset(now);
long epochSec = now.getEpochSecond() + offset.getTotalSeconds();
long epochDay = Math.floorDiv(epochSec, SECONDS_PER_DAY);
return LocalDate.ofEpochDay(epochDay);
}
//根据年月日构造LocalDate对象，不常用，此类中还有一些类似于此类的不常用构造函数暂不列出
private LocalDate(int year, int month, int dayOfMonth) {
this.year = year;
this.month = (short) month;
this.day = (short) dayOfMonth;
}
//根据字符串转换
public static LocalDate parse(CharSequence text) {
return parse(text, DateTimeFormatter.ISO_LOCAL_DATE);
}
public static LocalDate parse(CharSequence text, DateTimeFormatter formatter) {
Objects.requireNonNull(formatter, "formatter");
return formatter.parse(text, LocalDate::from);
}
//从纪元时期开始计数
public static LocalDate ofEpochDay(long epochDay) {
long zeroDay = epochDay + DAYS_0000_TO_1970;
// find the march-based year
zeroDay -= 60; // adjust to 0000-03-01 so leap day is at end of four year cycle
long adjust = 0;
if (zeroDay < 0) {
// adjust negative years to positive for calculation
long adjustCycles = (zeroDay + 1) / DAYS_PER_CYCLE - 1;
adjust = adjustCycles * 400;
zeroDay += -adjustCycles * DAYS_PER_CYCLE;
}
long yearEst = (400 * zeroDay + 591) / DAYS_PER_CYCLE;
long doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
if (doyEst < 0) {
// fix estimate
yearEst--;
doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
}
yearEst += adjust; // reset any negative year
int marchDoy0 = (int) doyEst;
// convert march-based values back to january-based
int marchMonth0 = (marchDoy0 * 5 + 2) / 153;
int month = (marchMonth0 + 2) % 12 + 1;
int dom = marchDoy0 - (marchMonth0 * 306 + 5) / 10 + 1;
yearEst += marchMonth0 / 10;
// check year now we are certain it is correct
int year = YEAR.checkValidIntValue(yearEst);
return new LocalDate(year, month, dom);
}
//当前年份顺延多少年
public static LocalDate ofYearDay(int year, int dayOfYear) {
YEAR.checkValidValue(year);
DAY_OF_YEAR.checkValidValue(dayOfYear);
boolean leap = IsoChronology.INSTANCE.isLeapYear(year);
if (dayOfYear == 366 && leap == false) {
throw new DateTimeException("Invalid date 'DayOfYear 366' as '" + year + "' is not a leap year");
}
Month moy = Month.of((dayOfYear - 1) / 31 + 1);
int monthEnd = moy.firstDayOfYear(leap) + moy.length(leap) - 1;
if (dayOfYear > monthEnd) {
moy = moy.plus(1);
}
int dom = dayOfYear - moy.firstDayOfYear(leap) + 1;
return new LocalDate(year, moy.getValue(), dom);
}
//增加或减少年数
public LocalDate minusYears(long yearsToSubtract) {
return (yearsToSubtract == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1) : plusYears(-yearsToSubtract));
}
//增加或者减少月份
public LocalDate minusMonths(long monthsToSubtract) {
return (monthsToSubtract == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1) : plusMonths(-monthsToSubtract));
}
//增加或者减少周数
public LocalDate minusWeeks(long weeksToSubtract) {
return (weeksToSubtract == Long.MIN_VALUE ? plusWeeks(Long.MAX_VALUE).plusWeeks(1) : plusWeeks(-weeksToSubtract));
}
//增加或减少天数
public LocalDate minusDays(long daysToSubtract) {
return (daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-daysToSubtract));
}
//当前时间是否是传参时间之后或之前，因为LocalDate实现了ChronoLocalDate接口，而ChronoLocalDate继承了Comparable接口
@Override
public boolean isAfter(ChronoLocalDate other) {
if (other instanceof LocalDate) {
return compareTo0((LocalDate) other) > 0;
}
return ChronoLocalDate.super.isAfter(other);
}
@Override
public boolean isBefore(ChronoLocalDate other) {
if (other instanceof LocalDate) {
return compareTo0((LocalDate) other) < 0;
}
return ChronoLocalDate.super.isBefore(other);
}
@Override
public int compareTo(ChronoLocalDate other) {
if (other instanceof LocalDate) {
return compareTo0((LocalDate) other);
}
return ChronoLocalDate.super.compareTo(other);
}
int compareTo0(LocalDate otherDate) {
int cmp = (year - otherDate.year);
if (cmp == 0) {
cmp = (month - otherDate.month);
if (cmp == 0) {
cmp = (day - otherDate.day);
}
}
return cmp;
}
}
上面通过源码的方式列举出了我们常用的一些方法并加上了注释，最常用的方法是now，parse，isAfter，isBefore等方法，因为项目中配置生效时间和截止时间一般是字符串，可以通过parse方法获取LocalDate对象，然后now方法获取当前时间，最后通过isAfter，isBefore进行判断是否在生效时间内。当然LocalDate是精确到天数的，而我们实际使用一般是精确到时分秒，所以使用的是LocalDateTime，但是其实这两个内容很相似，所以就只介绍这一个了，下面写了一些使用案例帮助大家理解。
测试
public class LocalDateExample {
public static void main(String[] args) {
//当前时间
LocalDate today = LocalDate.now();
System.out.println("Current date = " +today);
//自定义日期
LocalDate firstDay_2014 = LocalDate.of(2014, Month.JANUARY, 1);
System.out.println("Specific date = " + firstDay_2014);
//根据时间字符串
LocalDate todayStr = LocalDate.parse("2020-10-01");
System.out.println("TodayStr = " + todayStr);
//更换时区
LocalDate todayKolkata = LocalDate.now(ZoneId.of("Asia/Kolkata"));
System.out.println("Current date in ist="+todayKolkata);
//从起始天之后顺延365天之后
LocalDate dateFromBase = LocalDate.ofEpochDay(365);
System.out.println("365th day form base date="+dateFromBase);
//2014年之后100的日期
LocalDate hundredDay2014 = LocalDate.ofYearDay(2014, 100);
System.out.println("100th day of 2014="+hundredDay2014);
//日期大小比较
System.out.println(dateFromBase.isBefore(hundredDay2014));
//日期格式化
System.out.println(LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
System.out.println(LocalDate.now().minusDays(7).format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
System.out.println(LocalDate.now().minusMonths(6).format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
System.out.println(LocalDate.now().toEpochDay() - LocalDate.now().minusMonths(1).toEpochDay());
System.out.println(LocalDateTime.now().minusDays(7).toEpochSecond(ZoneOffset.of("+8")));
}
}
运行结果如下
总结
之前JDK已经有了Date，SimpleDateFormat，Calendar等用于时间操作的类了，为啥还会新开发呢，其实就是Calendar，SimpleDateFormat是会有并发风险的，但是LocalDate，LocalDateTime都是并发安全的类，实际当中使用起来也更加的方便快捷。
思考
上面所说的SimpleDateFormat线程不安全的原因是什么，为啥DateTimeFormatter又是线程安全的？因为SimpleDateFormat有个继承自父类的全局变量calendar但是DateTimeFormatter只有final类型的全局变量，这个可以大家自己去学习一下。
