当前位置:   article > 正文

Java检查日期字符串是否合法的方法总结(推荐方法3)_withresolverstyle(resolverstyle.strict)

withresolverstyle(resolverstyle.strict)

后端接口在接收数据的时候,都需要进行检查。检查全部通过后,才能够执行业务逻辑。本文总结了四个Java检查日期字符串是否合法的方法,感兴趣的可以了解一下


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

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

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

首先,定义时间校验器的接口:
 

  1. public interface DateValidator {
  2. boolean isValid(String dateStr);
  3. }

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

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

1.使用 DateFormat 检查

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

  1. public class DateValidatorUsingDateFormat implements DateValidator {
  2.     private final String dateFormat;
  3.     public DateValidatorUsingDateFormat(String dateFormat) {
  4.         this.dateFormat = dateFormat;
  5.     }
  6.     @Override
  7.     public boolean isValid(String dateStr) {
  8.         final DateFormat sdf = new SimpleDateFormat(this.dateFormat);
  9.         sdf.setLenient(false);
  10.         try {
  11.             sdf.parse(dateStr);
  12.         } catch (ParseException e) {
  13.             return false;
  14.         }
  15.         return true;
  16.     }
  17. }

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

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

  1. class DateValidatorUsingDateFormatTest {
  2.     @Test
  3.     void isValid() {
  4.         final DateValidator validator = new DateValidatorUsingDateFormat("yyyy-MM-dd");
  5.         Assertions.assertTrue(validator.isValid("2021-02-28"));
  6.         Assertions.assertFalse(validator.isValid("2021-02-30"));
  7.     }
  8. }

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

2.使用 LocalDate 检查

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

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

  1. // 使用 DateTimeFormatter.ISO_LOCAL_DATE 处理数据
  2. public static LocalDate parse(CharSequence text) {
  3.     return parse(text, DateTimeFormatter.ISO_LOCAL_DATE);
  4. }
  5. // 使用提供的 DateTimeFormatter 处理数据
  6. public static LocalDate parse(CharSequence text, DateTimeFormatter formatter) {
  7.         Objects.requireNonNull(formatter, "formatter");
  8.     return formatter.parse(text, LocalDate::from);
  9. }

通过LocalDateparse方法实现我们的校验器:

  1. public class DateValidatorUsingLocalDate implements DateValidator {
  2.     private final DateTimeFormatter dateFormatter;
  3.     public DateValidatorUsingLocalDate(DateTimeFormatter dateFormatter) {
  4.         this.dateFormatter = dateFormatter;
  5.     }
  6.     @Override
  7.     public boolean isValid(String dateStr) {
  8.         try {
  9.             LocalDate.parse(dateStr, this.dateFormatter);
  10.         } catch (DateTimeParseException e) {
  11.             return false;
  12.         }
  13.         return true;
  14.     }
  15. }

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

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

  1. class DateValidatorUsingLocalDateTest {
  2.     @Test
  3.     void isValid() {
  4.         final DateTimeFormatter dateFormatter = DateTimeFormatter.ISO_LOCAL_DATE;
  5.         final DateValidator validator = new DateValidatorUsingLocalDate(dateFormatter);
  6.         Assertions.assertTrue(validator.isValid("2021-02-28"));
  7.         Assertions.assertFalse(validator.isValid("2021-02-30"));
  8.     }
  9. }

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

3.使用 DateTimeFormatter 检查

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

实现验证器:

  1. public class DateValidatorUsingDateTimeFormatter implements DateValidator {
  2.     private final DateTimeFormatter dateFormatter;
  3.     public DateValidatorUsingDateTimeFormatter(DateTimeFormatter dateFormatter) {
  4.         this.dateFormatter = dateFormatter;
  5.     }
  6.     @Override
  7.     public boolean isValid(String dateStr) {
  8.         try {
  9.             this.dateFormatter.parse(dateStr);
  10.         } catch (DateTimeParseException e) {
  11.             return false;
  12.         }
  13.         return true;
  14.     }
  15. }

通过单元测试验证:

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

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

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

我们通过例子看下区别:

  1. class DateValidatorUsingDateTimeFormatterTest {
  2.     private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("uuuu-MM-dd", Locale.CHINA);
  3.     @Test
  4.     void testResolverStyle() {
  5.         Assertions.assertEquals(LocalDate.of(20212,28), parseDate("2021-02-28", ResolverStyle.STRICT));
  6.         Assertions.assertNull(parseDate("2021-02-29", ResolverStyle.STRICT));
  7.         Assertions.assertEquals(LocalDate.of(20212,28), parseDate("2021-02-28", ResolverStyle.STRICT));
  8.         Assertions.assertNull(parseDate("2021-13-28", ResolverStyle.STRICT));
  9.         Assertions.assertEquals(LocalDate.of(20212,28), parseDate("2021-02-28", ResolverStyle.SMART));
  10.         Assertions.assertEquals(LocalDate.of(20212,28), parseDate("2021-02-29", ResolverStyle.SMART));
  11.         Assertions.assertNull(parseDate("2021-13-28", ResolverStyle.SMART));
  12.         Assertions.assertNull(parseDate("2021-13-29", ResolverStyle.SMART));
  13.         Assertions.assertEquals(LocalDate.of(20212,28), parseDate("2021-02-28", ResolverStyle.LENIENT));
  14.         Assertions.assertEquals(LocalDate.of(20213,1), parseDate("2021-02-29", ResolverStyle.LENIENT));
  15.         Assertions.assertEquals(LocalDate.of(20221,28), parseDate("2021-13-28", ResolverStyle.LENIENT));
  16.         Assertions.assertEquals(LocalDate.of(20222,2), parseDate("2021-13-33", ResolverStyle.LENIENT));
  17.     }
  18.     private static LocalDate parseDate(String dateString, ResolverStyle resolverStyle) {
  19.         try {
  20.             return LocalDate.parse(dateString, DATE_FORMATTER.withResolverStyle(resolverStyle));
  21.         } catch (DateTimeParseException e) {
  22.             return null;
  23.         }
  24.     }
  25. }

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

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

4.使用 Apache 出品的 commons-validator 检查

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

  1. public class GenericValidator implements Serializable {
  2.     // 其他方法
  3.     public static boolean isDate(String value, Locale locale) {
  4.         return DateValidator.getInstance().isValid(value, locale);
  5.     }
  6.     public static boolean isDate(String value, String datePattern, boolean strict) {
  7.         return org.apache.commons.validator.DateValidator.getInstance().isValid(value, datePattern, strict);
  8.     }
  9. }

先引入依赖:

  1. <dependency>
  2.     <groupId>commons-validator</groupId>
  3.     <artifactId>commons-validator</artifactId>
  4.     <version>1.7</version>
  5. </dependency>

实现验证器:

  1. public class DateValidatorUsingCommonsValidator implements DateValidator {
  2.     private final String dateFormat;
  3.     public DateValidatorUsingCommonsValidator(String dateFormat) {
  4.         this.dateFormat = dateFormat;
  5.     }
  6.     @Override
  7.     public boolean isValid(String dateStr) {
  8.         return GenericValidator.isDate(dateStr, dateFormat, true);
  9.     }
  10. }

通过单元测试验证:

  1. class DateValidatorUsingCommonsValidatorTest {
  2.     @Test
  3.     void isValid() {
  4.         final DateValidator dateValidator = new DateValidatorUsingCommonsValidator("yyyy-MM-dd");
  5.         Assertions.assertTrue(dateValidator.isValid("2021-02-28"));
  6.         Assertions.assertFalse(dateValidator.isValid("2021-02-30"));
  7.     }
  8. }

org.apache.commons.validator.DateValidator#isValid源码可以发现,内部是通过DateFormatSimpleDateFormat实现的。

总结

在本文中,我们通过四种方式实现了时间字符串校验逻辑。其中DateFormatSimpleDataFormat是非线程安全的,所以每次方法调用时,都需要新建实例;通过观察apache.commons.validator.DateValidator#isValid的源码发现,它的内部也是通过DateFormatSimpleDateFormat实现的;而LocalDate和DateTimeFormatter则为JDK8中提供的实现方法。


原文:

Java检查日期字符串是否合法的方法总结_java_脚本之家

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/不正经/article/detail/119324?site
推荐阅读
相关标签
  

闽ICP备14008679号