看山聊 Java：检查日期字符串是否合法

迷南。 2021-09-25 13:02 400阅读 0赞

![看山聊 Java：检查日期字符串是否合法][Java]

> 该图片由[Анастасия Белоусова][Link 1]在[Pixabay][]上发布

你好，我是看山。

这次说一下，怎样检查给出的字符串，是否是合法日期字符串。本文将从 Java 原生和第三方组件两种方式来说明。

## WHY ##

后端接口在接收数据的时候，都需要进行检查。检查全部通过后，才能够执行业务逻辑。对于时间格式，我们一般需要检查这么几方面：

1.  字符串格式是否正确，比如格式是不是`yyyy-MM-dd`
2.  时间在合法范围内，比如我们需要限定在一个月内的时间
3.  字符串可以解析为正常的时间，比如 2 月 30 号就不是正常时间

对于时间格式的判断，我们可以通过正则表达式来检查。不过考虑到正则表达式的性能、输入数据的复杂性，一般能用别的方式，就不选正则表达式。我们还是选择一种更加通用、更加高效的检查方式。

首先，定义时间校验器的接口：

public interface DateValidator { 
        boolean isValid(String dateStr);
    }

接口方法接收一个字符串，返回布尔类型，表示字符串是否是合法的时间格式。

## HOW ##

接下来就是通过不同方式实现`DateValidator`。

### 使用 DateFormat 检查 ###

Java 提供了格式化和解析时间的工具：`DateFormat`抽象类和`SimpleDataFormat`实现类。我们借此实现时间校验器：

public class DateValidatorUsingDateFormat implements DateValidator { 
        private final String dateFormat;
    
        public DateValidatorUsingDateFormat(String dateFormat) { 
            this.dateFormat = dateFormat;
        }
    
        @Override
        public boolean isValid(String dateStr) { 
            final DateFormat sdf = new SimpleDateFormat(this.dateFormat);
            sdf.setLenient(false);
            try { 
                sdf.parse(dateStr);
            } catch (ParseException e) { 
                return false;
            }
            return true;
        }
    }

这里需要注意一下，`DateFormat`和`SimpleDataFormat`是非线程安全的，所以每次方法调用时，都需要新建实例。

我们通过单元测试验证下：

class DateValidatorUsingDateFormatTest { 
    
        @Test
        void isValid() { 
            final DateValidator validator = new DateValidatorUsingDateFormat("yyyy-MM-dd");
    
            Assertions.assertTrue(validator.isValid("2021-02-28"));
            Assertions.assertFalse(validator.isValid("2021-02-30"));
        }
    }

在 Java8 之前，一般都是用这种方式来验证。Java8 之后，我们有了更多的选择。

### 使用 LocalDate 检查 ###

Java8 引入了更加好用日期和时间 API（想要了解更多内容，请移步参看 [Java8 中的时间类及常用 API][Java8 _ API]）。其中包括`LocalDate`类，是一个不可变且线程安全的时间类。

`LocalDate`提供了两个静态方法，用来解析时间。这两个方法内部都是使用`java.time.format.DateTimeFormatter`来处理数据：

// 使用 DateTimeFormatter.ISO_LOCAL_DATE 处理数据
    public static LocalDate parse(CharSequence text) { 
        return parse(text, DateTimeFormatter.ISO_LOCAL_DATE);
    }
    
    // 使用提供的 DateTimeFormatter 处理数据
    public static LocalDate parse(CharSequence text, DateTimeFormatter formatter) { 
            Objects.requireNonNull(formatter, "formatter");
        return formatter.parse(text, LocalDate::from);
    }

通过`LocalDate`的`parse`方法实现我们的校验器：

public class DateValidatorUsingLocalDate implements DateValidator { 
        private final DateTimeFormatter dateFormatter;
    
        public DateValidatorUsingLocalDate(DateTimeFormatter dateFormatter) { 
            this.dateFormatter = dateFormatter;
        }
    
        @Override
        public boolean isValid(String dateStr) { 
            try { 
                LocalDate.parse(dateStr, this.dateFormatter);
            } catch (DateTimeParseException e) { 
                return false;
            }
            return true;
        }
    }

`java.time.format.DateTimeFormatter`类是不可变的，也就是天然的线程安全，我们可以在不同线程使用同一个校验器实例。

我们通过单元测试验证下：

class DateValidatorUsingLocalDateTest { 
    
        @Test
        void isValid() { 
            final DateTimeFormatter dateFormatter = DateTimeFormatter.ISO_LOCAL_DATE;
            final DateValidator validator = new DateValidatorUsingLocalDate(dateFormatter);
    
            Assertions.assertTrue(validator.isValid("2021-02-28"));
            Assertions.assertFalse(validator.isValid("2021-02-30"));
        }
    }

既然`LocalDate#parse`是通过`DateTimeFormatter`实现的，那我们也可以直接使用`DateTimeFormatter`。

### 使用 DateTimeFormatter 检查 ###

`DateTimeFormatter`解析文本总共分两步。第一步，根据配置将文本解析为日期和时间字段；第二步，用解析后的字段创建日期和时间对象。

实现验证器：

public class DateValidatorUsingDateTimeFormatter implements DateValidator { 
        private final DateTimeFormatter dateFormatter;
    
        public DateValidatorUsingDateTimeFormatter(DateTimeFormatter dateFormatter) { 
            this.dateFormatter = dateFormatter;
        }
    
        @Override
        public boolean isValid(String dateStr) { 
            try { 
                this.dateFormatter.parse(dateStr);
            } catch (DateTimeParseException e) { 
                return false;
            }
            return true;
        }
    }

通过单元测试验证：

class DateValidatorUsingDateTimeFormatterTest { 
        private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("uuuu-MM-dd", Locale.CHINA);
    
        @Test
        void isValid() { 
            final DateTimeFormatter dateFormatter = DATE_FORMATTER.withResolverStyle(ResolverStyle.STRICT);
            final DateValidator validator = new DateValidatorUsingDateTimeFormatter(dateFormatter);
    
            Assertions.assertTrue(validator.isValid("2021-02-28"));
            Assertions.assertFalse(validator.isValid("2021-02-30"));
        }
    }

可以看到，我们指定了转换模式是`ResolverStyle.STRICT`，这个类型是说明解析模式。共有三种：

*  STRICT：严格模式，日期、时间必须完全正确。
 *  SMART：智能模式，针对日可以自动调整。月的范围在 1 到 12，日的范围在 1 到 31。比如输入是 2 月 30 号，当年 2 月只有 28 天，返回的日期就是 2 月 28 日。
 *  LENIENT：宽松模式，主要针对月和日，会自动后延。结果类似于`LocalData#plusDays`或者`LocalDate#plusMonths`。

我们通过例子看下区别：

class DateValidatorUsingDateTimeFormatterTest { 
        private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("uuuu-MM-dd", Locale.CHINA);
    
        @Test
        void testResolverStyle() { 
            Assertions.assertEquals(LocalDate.of(2021, 2,28), parseDate("2021-02-28", ResolverStyle.STRICT));
            Assertions.assertNull(parseDate("2021-02-29", ResolverStyle.STRICT));
    
            Assertions.assertEquals(LocalDate.of(2021, 2,28), parseDate("2021-02-28", ResolverStyle.STRICT));
            Assertions.assertNull(parseDate("2021-13-28", ResolverStyle.STRICT));
    
            Assertions.assertEquals(LocalDate.of(2021, 2,28), parseDate("2021-02-28", ResolverStyle.SMART));
            Assertions.assertEquals(LocalDate.of(2021, 2,28), parseDate("2021-02-29", ResolverStyle.SMART));
    
            Assertions.assertNull(parseDate("2021-13-28", ResolverStyle.SMART));
            Assertions.assertNull(parseDate("2021-13-29", ResolverStyle.SMART));
    
            Assertions.assertEquals(LocalDate.of(2021, 2,28), parseDate("2021-02-28", ResolverStyle.LENIENT));
            Assertions.assertEquals(LocalDate.of(2021, 3,1), parseDate("2021-02-29", ResolverStyle.LENIENT));
    
            Assertions.assertEquals(LocalDate.of(2022, 1,28), parseDate("2021-13-28", ResolverStyle.LENIENT));
            Assertions.assertEquals(LocalDate.of(2022, 2,2), parseDate("2021-13-33", ResolverStyle.LENIENT));
        }
    
        private static LocalDate parseDate(String dateString, ResolverStyle resolverStyle) { 
            try { 
                return LocalDate.parse(dateString, DATE_FORMATTER.withResolverStyle(resolverStyle));
            } catch (DateTimeParseException e) { 
                return null;
            }
        }
    }

从例子可以看出，`ResolverStyle.STRICT`是严格控制，用来做时间校验比较合适；`ResolverStyle.LENIENT`可以最大程度将字符串转化为时间对象，在合理范围内可以随便玩；`ResolverStyle.SMART`名为智能，但智力有限，两不沾边，优势不够明显。JDK 提供的`DateTimeFormatter`实现，都是`ResolverStyle.STRICT`模式。

说了 JDK 自带的实现，接下来说说第三方组件的实现方式。

### 使用 Apache 出品的 commons-validator 检查 ###

Apache Commons 项目提供了一个校验器框架，包含多种校验规则，包括日期、时间、数字、货币、IP 地址、邮箱、URL 地址等。本文主要说检查时间，所以重点看看`GenericValidator`类提供的`isDate`方法：

public class GenericValidator implements Serializable { 
        // 其他方法
    
        public static boolean isDate(String value, Locale locale) { 
            return DateValidator.getInstance().isValid(value, locale);
        }
    
        public static boolean isDate(String value, String datePattern, boolean strict) { 
            return org.apache.commons.validator.DateValidator.getInstance().isValid(value, datePattern, strict);
        }
    }

先引入依赖：

<dependency>
        <groupId>commons-validator</groupId>
        <artifactId>commons-validator</artifactId>
        <version>1.7</version>
    </dependency>

实现验证器：

public class DateValidatorUsingCommonsValidator implements DateValidator { 
        private final String dateFormat;
    
        public DateValidatorUsingCommonsValidator(String dateFormat) { 
            this.dateFormat = dateFormat;
        }
    
        @Override
        public boolean isValid(String dateStr) { 
            return GenericValidator.isDate(dateStr, dateFormat, true);
        }
    }

通过单元测试验证：

class DateValidatorUsingCommonsValidatorTest { 
        @Test
        void isValid() { 
            final DateValidator dateValidator = new DateValidatorUsingCommonsValidator("yyyy-MM-dd");
    
            Assertions.assertTrue(dateValidator.isValid("2021-02-28"));
            Assertions.assertFalse(dateValidator.isValid("2021-02-30"));
        }
    }

看`org.apache.commons.validator.DateValidator#isValid`源码可以发现，内部是通过`DateFormat`和`SimpleDateFormat`实现的。

## 文末总结 ##

在本文中，我们通过四种方式实现了时间字符串校验逻辑。为了节省篇幅，文中代码只提供了核心内容。想要了解具体实现，可以关注公号「看山的小屋」，回复“date”获取源码。

## 推荐阅读 ##

1.  [Java8 中的时间类及常用 API][Java8 _ API]
2.  [Date 与 LocalDate 或 LocalDateTime 互相转换][Date _ LocalDate _ LocalDateTime]
3.  [使用 Java8 中的时间类][Java8]
4.  [检查日期字符串是否合法][Link 2]

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

你好，我是看山，公众号：看山的小屋，10 年老猿，开源贡献者。游于码界，戏享人生。

个人主页：[https://www.howardliu.cn][https_www.howardliu.cn]  
个人博文：[看山聊 Java：检查日期字符串是否合法][Link 2]  
CSDN 主页：[https://kanshan.blog.csdn.net/][https_kanshan.blog.csdn.net]  
CSDN 博文：[看山聊 Java：检查日期字符串是否合法][Java 1]

![公众号：看山的小屋][21785bb43b333b0ff8efda479e715378.png]

[Java]: /images/20210923/01c8106a5ab249d0a00e98d2de68086b.png
[Link 1]: https://pixabay.com/zh/users/nastasyaday-11197808/?utm_source=link-attribution&utm_medium=referral&utm_campaign=image&utm_content=6514669
[Pixabay]: https://pixabay.com/zh/?utm_source=link-attribution&utm_medium=referral&utm_campaign=image&utm_content=6514669
[Java8 _ API]: https://www.howardliu.cn/java-date-and-time-intro/
[Date _ LocalDate _ LocalDateTime]: https://www.howardliu.cn/java-date-to-localdate-and-localdatetime/
[Java8]: https://www.howardliu.cn/java-date-time-migrating-to-jsr310/
[Link 2]: https://www.howardliu.cn/java-date-string-valid-date/
[https_www.howardliu.cn]: https://www.howardliu.cn
[https_kanshan.blog.csdn.net]: https://kanshan.blog.csdn.net/
[Java 1]: https://kanshan.blog.csdn.net/article/details/119464230
[21785bb43b333b0ff8efda479e715378.png]: /images/20210923/9a47d0d5e9e24a15b5ed2a899d03d4c3.png