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

Question

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

一点背景：

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

不幸的是，很多遗留代码调用了诸如new Date() 或Calendar.getInstance() 之类的函数，它们最终都会调用System.currentTimeMillis。

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

所以我的问题是：

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

Answer 1

tl;博士

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

是的。

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

Clock在java.time

对于可插入时钟替换问题，我们有一个新的解决方案，以方便使用 faux 日期时间值进行测试。 Java 8 中的 java.time package 包含一个抽象类 java.time.Clock，具有明确的目的：

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

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

改变节奏

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

默认的Clock 报告的时间更新频率与Java 8 中的milliseconds 和Java 9 中的nanoseconds 一样好（取决于您的硬件）。您可以要求以不同的粒度报告真实的当前时刻。

• tickSeconds - 整秒递增
• tickMinutes - 整分钟增量
• tick - 通过传递的 Duration 参数递增。

假时钟

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

• fixed - 将单个不变（非递增）时刻报告为当前时刻。
• offset - 报告当前时刻，但被传递的 Duration 参数移动。

例如，锁定今年最早的圣诞节的第一刻。换句话说，当Santa and his reindeer make their first stop。现在最早的时区似乎是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 小时前的wall-clock time，即 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[太平洋/Kiritimati]

见live code in IdeOne.com。

真实时间，不同时区

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

您可以指定 UTC 为默认时区。

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

您可以指定任何特定的时区。以continent/region 的格式指定proper time zone name，例如America/Montreal、Africa/Casablanca 或Pacific/Auckland。切勿使用 3-4 个字母的缩写，例如 EST 或 IST，因为它们不是真正的时区，没有标准化，甚至不是唯一的（！）。

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

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

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

运行此代码进行比较。请注意，它们都报告同一时刻，时间轴上的同一点。它们仅在wall-clock time 上有所不同；换句话说，三种方式来表达同一件事，三种方式来展示同一时刻。

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[America/Los_Angeles]

根据定义，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() 返回的实现。这是您未指定Clock 时使用的实现。在pre-release Java 9 source code for Instant.now 中亲自查看。

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

OffsetDateTime.now 和 ZonedDateTime.now 的默认 Clock 是 Clock.systemDefaultZone()。见source code。

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

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

---

关于java.time

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

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

Joda-Time 项目现在位于maintenance mode，建议迁移到java.time 类。

您可以直接与您的数据库交换 java.time 对象。使用符合JDBC 4.2 或更高版本的JDBC driver。不需要字符串，不需要java.sql.* 类。 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 功能在ThreeTen-Backport 中向后移植到 Java 6 和 7。
• Android
  • java.time 类的更高版本的 Android (26+) 捆绑实现。
  • 对于早期的 Android (API desugaring 的进程带来了最初未内置于 Android 中的 subset of the java.time 功能。
    • 如果脱糖不能满足您的需求，ThreeTenABP 项目会将ThreeTen-Backport（如上所述）适配到 Android。见How to use ThreeTenABP…。

Answer 2

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

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

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

（根据需要等）

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

Answer 3

这是一个使用 PowerMockito 的示例。还有一个new Date() 的例子。
有关mocking system classes 的更多详细信息。

@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 4

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

这是你需要做的：

被测类需要做什么

步骤 1

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

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
  }
  // (...)
}

第二步

将新属性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();
    }
  }
  // (...) 
}

测试类需要做什么

第三步

在测试类中，在调用测试方法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 5

作为said by 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();

如果您想导入具有接口的库（请参阅下面 Jon 的评论），您可以使用 Prevayler's Clock，它将提供实现以及标准接口。完整的 jar 文件只有 96kB，所以它不应该破坏银行...

Answer 6

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

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

PowerMock & Co ...需要将clients 模拟为 System.currentTimeMillis()。又是一种侵入性选择。

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

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

Answer 7

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

Answer 8

如果你运行的是 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 托管服务的时间，只需将以下内容添加到您的单元文件覆盖中，例如对于弹性搜索，这将是 /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 9

虽然使用一些 DateFactory 模式看起来不错，但它并不涵盖您无法控制的库 - 想象一下 Validation annotation @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 timer 代替 - 这与挂钟无关，但在这里相对时间就足够了：

// 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 优化 - 使用这个参数 -XX:-Inline 运行 JVM。

虽然这对于生产来说可能并不完美，但它对于测试来说还不错，而且对于应用程序绝对透明，尤其是当 DataFactory 没有商业意义并且仅仅因为测试而引入时。如果有内置的 JVM 选项可以在不同的时间运行，那就太好了，可惜没有这样的 hack 是不可能的。

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

帖子中提供了完整的便捷类 SystemTimeShifter。类可以在你的测试中使用，或者它可以很容易地用作你真正的主类之前的第一个主类，以便在不同的时间运行你的应用程序（甚至整个应用服务器）。当然，这主要是为了测试目的，而不是为了生产环境。

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

Answer 10

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

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

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

它被称为二进制编织，还有专门的tools 来执行系统类的编织并规避一些问题（例如，引导 VM 可能不起作用）

Answer 11

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

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

Answer 12

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