覆盖 Java System.currentTimeMillis 以测试时间敏感代码

Question

除了手动更改主机上的系统时钟之外，是否有一种方法（通过代码或使用 JVM 参数）来覆盖当前时间（如 System.currentTimeMillis 所示）？

一点背景知识：

我们有一个运行许多会计作业的系统，这些作业的大部分逻辑围绕当前日期（即每月的第一天、每年的第一天等），

不幸的是，许多遗留代码调用诸如此类的函数如 new Date() 或 Calendar.getInstance()，两者最终都会调用 System.currentTimeMillis。

出于测试目的，现在我们只能手动更新系统时钟来操纵代码认为测试正在运行的时间和日期。

所以我的问题是：

有没有办法覆盖 System.currentTimeMillis 返回的内容？例如，告诉 JVM 在从该方法返回之前自动添加或减去一些偏移量？

Answer 1

我强烈建议您不要弄乱系统时钟，而是硬着头皮重构遗留代码以使用可替换的时钟。 理想这应该通过依赖注入来完成，但即使您使用可替换的单例，您也将获得可测试性。

这几乎可以通过搜索和替换单例版本来实现自动化：

• 将 Calendar.getInstance() 替换为 Clock.getInstance().getCalendarInstance()。
• 将 new Date() 替换为 Clock.getInstance().newDate()
• 将 System.currentTimeMillis() 替换为 Clock.getInstance( ).currentTimeMillis()

（根据需要等）

一旦迈出了第一步，您就可以用 DI 一次一点地替换单例。

Answer 2

太长了；博士

除了手动更改主机上的系统时钟之外，是否有一种方法（通过代码或使用 JVM 参数）来覆盖当前时间（通过 System.currentTimeMillis 提供）？

是的。

Instant.now( 
    Clock.fixed( 
        Instant.parse( "2016-01-23T12:34:56Z"), ZoneOffset.UTC
    )
)

java.time 中的Clock

我们针对可插拔时钟替换问题提供了一个新的解决方案，以方便使用假日期时间值进行测试。 java.time 包 Java 8 包含一个抽象类 java.time.Clock，其中明确的目的：

允许在需要时插入备用时钟

您可以插入您自己的 Clock 实现，尽管您可能会找到一个已经实现的时钟来满足您的需求。为了您的方便，java.time 包含静态方法来产生特殊的实现。这些替代实现在测试期间可能很有价值。

改变节奏

各种 tick... 方法产生以不同节奏增加当前时刻的时钟。

默认时钟报告时间更新频率为毫秒在 Java 8 和 Java 9 中与 纳秒 一样精细（取决于您的硬件）。您可以要求以不同的粒度报告当前的真实时刻。

• tickSeconds - 以整秒为单位递增
• tickMinutes - 整分钟增量
• tick - 按传递的 Duration 参数。

虚假时钟

有些时钟可能会撒谎，产生与主机操作系统硬件时钟不同的结果。

• fixed - 将单个不变（非增量）时刻报告为当前时刻。
• offset - 报告当前时刻，但按传递的 持续时间 参数。

比如锁定今年最早圣诞节的第一时刻。换句话说，当圣诞老人和他的驯鹿到达第一站时。现在最早的时区似乎是 Pacific/Kiritimati +14:00。

LocalDate ld = LocalDate.now( ZoneId.of( "America/Montreal" ) );
LocalDate xmasThisYear = MonthDay.of( Month.DECEMBER , 25 ).atYear( ld.getYear() );
ZoneId earliestXmasZone = ZoneId.of( "Pacific/Kiritimati" ) ;
ZonedDateTime zdtEarliestXmasThisYear = xmasThisYear.atStartOfDay( earliestXmasZone );
Instant instantEarliestXmasThisYear = zdtEarliestXmasThisYear.toInstant();
Clock clockEarliestXmasThisYear = Clock.fixed( instantEarliestXmasThisYear , earliestXmasZone );

使用那个特殊的固定时钟总是返回同一时刻。我们在 Kiritimati 迎来了圣诞节的第一个时刻，UTC 显示挂钟时间 提前 14 个小时，即 12 月 24 日前一天上午 10 点。

Instant instant = Instant.now( clockEarliestXmasThisYear );
ZonedDateTime zdt = ZonedDateTime.now( clockEarliestXmasThisYear );

instant.toString(): 2016-12-24T10:00:00Z

zdt.toString(): 2016-12-25T00:00+14:00[太平洋/基里蒂马蒂]

请参阅 IdeOne 中的实时代码。 com。

真实时间，不同时区

您可以通过Clock实现来控制分配哪个时区。这在某些测试中可能有用。但我不建议在生产代码中这样做，您应该始终显式指定可选的 ZoneId 或 ZoneOffset 参数。

您可以指定 UTC 作为默认区域。

ZonedDateTime zdtClockSystemUTC = ZonedDateTime.now ( Clock.systemUTC () );

您可以指定任何特定时区。以大陆/地区格式指定正确的时区名称 ，例如 America/Montreal、非洲/卡萨布兰卡，或太平洋/奥克兰 。切勿使用 3-4 个字母的缩写，例如 EST 或 IST，因为它们不是真正的时区，不是标准化的，甚至不是唯一的（ ！）。

ZonedDateTime zdtClockSystem = ZonedDateTime.now ( Clock.system ( ZoneId.of ( "America/Montreal" ) ) );

您可以指定 JVM 当前的默认时区应该是特定 Clock 对象的默认时区。

ZonedDateTime zdtClockSystemDefaultZone = ZonedDateTime.now ( Clock.systemDefaultZone () );

运行此代码进行比较。请注意，它们都报告同一时刻、时间线上的同一点。它们仅在挂钟时间方面有所不同；换句话说，用三种方式表达同一件事，用三种方式展示同一时刻。

System.out.println ( "zdtClockSystemUTC.toString(): " + zdtClockSystemUTC );
System.out.println ( "zdtClockSystem.toString(): " + zdtClockSystem );
System.out.println ( "zdtClockSystemDefaultZone.toString(): " + zdtClockSystemDefaultZone );

America/Los_Angeles 是运行此代码的计算机上的 JVM 当前默认区域。

zdtClockSystemUTC.toString(): 2016-12-31T20:52:39.688Z

zdtClockSystem.toString(): 2016-12-31T15:52:39.750-05:00[美国/蒙特利尔]

zdtClockSystemDefaultZone.toString(): 2016-12-31T12:52:39.762-08:00[美国/洛杉矶]

Instant 类根据定义始终采用 UTC。因此，这三个与区域相关的Clock 用法具有完全相同的效果。

Instant instantClockSystemUTC = Instant.now ( Clock.systemUTC () );
Instant instantClockSystem = Instant.now ( Clock.system ( ZoneId.of ( "America/Montreal" ) ) );
Instant instantClockSystemDefaultZone = Instant.now ( Clock.systemDefaultZone () );

instantClockSystemUTC.toString(): 2016-12-31T20:52:39.763Z

instantClockSystem.toString(): 2016-12-31T20:52:39.763Z

instantClockSystemDefaultZone.toString(): 2016-12-31T20:52:39.763Z

默认时钟

Instant.now 默认使用的实现是 Clock.systemUTC()。这是当您不指定时钟时使用的实现。亲自查看 Instant.now 的预发布 Java 9 源代码。

public static Instant now() {
    return Clock.systemUTC().instant();
}

OffsetDateTime.now 和 ZonedDateTime.now 的默认Clock 是 Clock.systemDefaultZone()。请参阅 源代码。

public static ZonedDateTime now() {
    return now(Clock.systemDefaultZone());
}

默认实现的行为在 Java 8 和 Java 9 之间发生了变化。在 Java 8 中，当前时刻仅通过 毫秒，尽管类能够存储纳秒的分辨率。 Java 9 带来了一种新的实现，能够以纳秒的分辨率捕获当前时刻——当然，这取决于计算机硬件时钟的功能。

---

关于 java.time

java.time 框架内置于 Java 8 及更高版本中。这些类取代了麻烦的旧遗留日期时间类，例如java.util.Date，日历, & SimpleDateFormat 。

要了解更多信息，请参阅 Oracle 教程。并在 Stack Overflow 上搜索许多示例和解释。规范为 JSR 310。

Joda-Time 项目，现已在 维护模式，建议迁移到 java.time 类。

您可以直接与数据库交换java.time对象。使用符合 JDBC 驱动程序 /jeps/170" rel="nofollow noreferrer">JDBC 4.2 或更高版本。不需要字符串，不需要 java.sql.* 类。 Hibernate 5 和 Hibernate 5 JPA 2.2 支持 java.time。

从哪里获取 java.time 类？

• Java SE 8，Java SE 9, Java SE 10, Java SE 11 及更高版本 - 具有捆绑实现的标准 Java API 的一部分。
  • Java 9 带来了一些小功能和修复.
• Java SE 6 和 Java SE 7
  • 大多数 java.time 功能都向后移植到 Java 6 和 Java 6。 7 ThreeTen-Backport。< /里>
• Android
  • Android 的更高版本（26+）捆绑了 java.time 类的实现。
  • 对于早期的 Android (<26)，该进程称为 API 脱糖带来了 java.time 功能最初并未内置于 Android 中。
    • 如果脱糖无法满足您的需求，ThreeTenABP< /em> 项目适应ThreeTen-Backport（如上所述）到 Android。请参阅如何使用 ThreeTenABP...。

    
    

    
    

  
  

  
  

Answer 3

正如 Jon Skeet 所说的 ：

“使用 Joda Time”几乎总是涉及“如何使用 java.util.Date/Calendar 实现 X？”的任何问题的最佳答案

所以这里（假设您刚刚将所有 new Date() 替换为 new DateTime().toDate()）

//Change to specific time
DateTimeUtils.setCurrentMillisFixed(millis);
//or set the clock to be a difference from system time
DateTimeUtils.setCurrentMillisOffset(millis);
//Reset to system time
DateTimeUtils.setCurrentMillisSystem();

如果您想导入具有接口的库（请参阅下面乔恩的评论），您可以使用 Prevayler's Clock，将提供实现以及标准接口。完整的 jar 只有 96kB，所以它不应该花很多钱......

Answer 4

虽然使用某些 DateFactory 模式看起来不错，但它并不涵盖您无法控制的库 - 想象一下验证注释 @Past 以及依赖于 System.currentTimeMillis 的实现（有这样的）。

这就是为什么我们使用 jmockit 直接模拟系统时间：

import mockit.Mock;
import mockit.MockClass;
...
@MockClass(realClass = System.class)
public static class SystemMock {
    /**
     * Fake current time millis returns value modified by required offset.
     *
     * @return fake "current" millis
     */
    @Mock
    public static long currentTimeMillis() {
        return INIT_MILLIS + offset + millisSinceClassInit();
    }
}

Mockit.setUpMock(SystemMock.class);

因为不可能获得 millis 的原始未模拟值，所以我们使用 Nano 计时器代替 - 这与挂钟无关，但相对时间就足够了：

// runs before the mock is applied
private static final long INIT_MILLIS = System.currentTimeMillis();
private static final long INIT_NANOS = System.nanoTime();

private static long millisSinceClassInit() {
    return (System.nanoTime() - INIT_NANOS) / 1000000;
}

有记录的问题，使用 HotSpot，多次调用后时间会恢复正常 - 这是问题报告： http://code.google.com/p/jmockit/issues/detail?id=43

为了克服这个问题，我们必须打开一个特定的 HotSpot 优化 - 使用此参数运行 JVM -XX:-内联。

虽然这对于生产来说可能并不完美，但它对于测试来说已经足够了，并且对于应用程序来说绝对透明，特别是当 DataFactory 没有商业意义并且只是因为测试而引入时。如果有内置的 JVM 选项在不同的时间运行就好了，可惜没有这样的 hacks 是不可能的。

完整的故事在我的博客文章中：
http://virgo47.wordpress.com/2012/06/22/chang -system-time-in-java/

帖子中提供了完整方便的类 SystemTimeShifter。类可以在您的测试中使用，也可以非常轻松地用作真正的主类之前的第一个主类，以便在不同的时间运行您的应用程序（甚至整个应用程序服务器）。当然，这主要是为了测试目的，而不是用于生产环境。

2014 年 7 月编辑：JMockit 最近发生了很大变化，您必须使用 JMockit 1.0 才能正确使用它（IIRC）。绝对无法升级到界面完全不同的最新版本。我正在考虑只内联必要的东西，但由于我们在新项目中不需要这个东西，所以我根本不开发这个东西。

Answer 5

Powermock 效果很好。只是用它来模拟 System.currentTimeMillis() 。

Answer 6

使用面向方面的编程（AOP，例如 AspectJ）来编织 System 类以返回可以在测试用例中设置的预定义值。

或者编织应用程序类以将对 System.currentTimeMillis() 或 new Date() 的调用重定向到您自己的另一个实用程序类。

然而，编织系统类 (java.lang.*) 有点棘手，您可能需要对 rt.jar 执行离线编织，并使用单独的 JDK/rt.jar 进行测试。

它称为二进制编织，还有特殊的工具 执行系统类的编织并规避一些问题（例如引导虚拟机可能不起作用）

Answer 7

一种在 Java 8 Web 应用程序中使用 EasyMock 覆盖当前系统时间以进行 JUnit 测试的工作方法，无需 Joda Time 和 PowerMock。

以下是您需要做的事情：

在被测试的类中需要做的事情

步骤 1

向被测试的类 MyService 添加一个新的 java.time.Clock 属性，并确保新属性将使用实例化块或构造函数以默认值正确初始化：

import java.time.Clock;
import java.time.LocalDateTime;

public class MyService {
  // (...)
  private Clock clock;
  public Clock getClock() { return clock; }
  public void setClock(Clock newClock) { clock = newClock; }

  public void initDefaultClock() {
    setClock(
      Clock.system(
        Clock.systemDefaultZone().getZone() 
        // You can just as well use
        // java.util.TimeZone.getDefault().toZoneId() instead
      )
    );
  }
  { 
    initDefaultClock(); // initialisation in an instantiation block, but 
                        // it can be done in a constructor just as well
  }
  // (...)
}

步骤 2

将新属性 clock 注入到调用当前日期时间的方法中。例如，在我的例子中，我必须检查 dataase 中存储的日期是否发生在 LocalDateTime.now() 之前，我将其替换为 LocalDateTime.now(clock) >，如下所示：

import java.time.Clock;
import java.time.LocalDateTime;

public class MyService {
  // (...)
  protected void doExecute() {
    LocalDateTime dateToBeCompared = someLogic.whichReturns().aDate().fromDB();
    while (dateToBeCompared.isBefore(LocalDateTime.now(clock))) {
      someOtherLogic();
    }
  }
  // (...) 
}

测试类中需要做什么

步骤 3

在测试类中，创建一个模拟时钟对象，并在调用测试方法 doExecute()，然后立即将其重置回来，如下所示：

import java.time.Clock;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import org.junit.Test;

public class MyServiceTest {
  // (...)
  private int year = 2017;
  private int month = 2;
  private int day = 3;

  @Test
  public void doExecuteTest() throws Exception {
    // (...) EasyMock stuff like mock(..), expect(..), replay(..) and whatnot

    MyService myService = new MyService();
    Clock mockClock =
      Clock.fixed(
        LocalDateTime.of(year, month, day, 0, 0).toInstant(OffsetDateTime.now().getOffset()),
        Clock.systemDefaultZone().getZone() // or java.util.TimeZone.getDefault().toZoneId()
      );
    myService.setClock(mockClock); // set it before calling the tested method

    myService.doExecute(); // calling tested method 

    myService.initDefaultClock(); // reset the clock to default right afterwards with our own previously created method

    // (...) remaining EasyMock stuff: verify(..) and assertEquals(..)
    }
  }

在调试模式下检查它，您将看到 2017 年 2 月 3 日的日期已正确注入到 myService 实例中并用于比较指令，然后已使用 initDefaultClock() 正确重置为当前日期。

Answer 8

在我看来，只有非侵入性的解决方案才能发挥作用。特别是如果您有外部库和大型遗留代码库，则没有可靠的方法来模拟时间。

JMockit ...仅适用于有限数量的 次

Co ...需要将客户端模拟为System.currentTimeMillis()。又是一种侵入性的选择。

由此我只看到提到的 javaagent 或 aop 方法对整个系统是透明的。有人这样做过并且可以指出这样的解决方案吗？

@jarnbjo：您能展示一些 javaagent 代码吗？

Answer 9

这是使用 PowerMockito 的示例。还有一个 new Date() 的示例。
有关模拟系统类的更多详细信息。

@RunWith(PowerMockRunner.class)
@PrepareForTest(LegacyClass.class)
public class SystemTimeTest {
    
    private final Date fakeNow = Date.from(Instant.parse("2010-12-03T10:15:30.00Z"));

    @Before
    public void init() {
        PowerMockito.mockStatic(System.class);
        PowerMockito.when(System.currentTimeMillis()).thenReturn(fakeNow.getTime());
        System.out.println("Fake currentTimeMillis: " + System.currentTimeMillis());
    }

    @Test
    public void legacyClass() {
        new LegacyClass().methodWithCurrentTimeMillis();
    }

}

您正在测试的一些遗留类：

class LegacyClass {

    public void methodWithCurrentTimeMillis() {
        long now = System.currentTimeMillis();
        System.out.println("LegacyClass System.currentTimeMillis() is " + now);
    }

}

控制台输出

Fake currentTimeMillis: 1291371330000
LegacyClass System.currentTimeMillis() is 1291371330000

Answer 10

实际上没有办法直接在虚拟机中执行此操作，但您可以通过编程方式在测试计算机上设置系统时间。大多数（全部？）操作系统都有命令行命令来执行此操作。

Answer 11

如果您运行的是 Linux，则可以使用 libfaketime 的 master 分支，或者在测试提交时 4ce2835。

只需使用您想要模拟 Java 应用程序的时间设置环境变量，然后使用 ld-preloading 运行它：

# bash
export FAKETIME="1985-10-26 01:21:00"
export DONT_FAKE_MONOTONIC=1
LD_PRELOAD=/usr/local/lib/faketime/libfaketimeMT.so.1 java -jar myapp.jar

第二个环境变量对于 Java 应用程序至关重要，否则会冻结。在撰写本文时，它需要 libfaketime 的 master 分支。

如果您想更改 systemd 托管服务的时间，只需将以下内容添加到您的单元文件覆盖中，例如对于elasticsearch，这将是 /etc/systemd/system/elasticsearch.service.d/override.conf ：

[Service]
Environment="FAKETIME=2017-10-31 23:00:00"
Environment="DONT_FAKE_MONOTONIC=1"
Environment="LD_PRELOAD=/usr/local/lib/faketime/libfaketimeMT.so.1"

不要忘记使用 `systemctl daemon-reload 重新加载 systemd

Answer 12

如果您想模拟具有 System.currentTimeMillis() 参数的方法，那么您可以传递 anyLong() 的 Matchers 类作为参数。

PS 我能够使用上述技巧成功运行我的测试用例，只是为了分享有关我使用 PowerMock 和 Mockito 框架的测试的更多详细信息。