Java Joda类代码示例

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
/**
 * Read from a stream.
 */
public RangeQueryBuilder(StreamInput in) throws IOException {
    super(in);
    fieldName = in.readString();
    from = in.readGenericValue();
    to = in.readGenericValue();
    includeLower = in.readBoolean();
    includeUpper = in.readBoolean();
    timeZone = in.readOptionalTimeZone();
    String formatString = in.readOptionalString();
    if (formatString != null) {
        format = Joda.forPattern(formatString);
    }
    if (in.getVersion().onOrAfter(Version.V_5_2_0_UNRELEASED)) {
        String relationString = in.readOptionalString();
        if (relationString != null) {
            relation = ShapeRelation.getRelationByName(relationString);
        }
    }
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
public void testThatEpochsCanBeParsed() {
    boolean parseMilliSeconds = randomBoolean();

    // epoch: 1433144433655 => date: Mon Jun  1 09:40:33.655 CEST 2015
    FormatDateTimeFormatter formatter = Joda.forPattern(parseMilliSeconds ? "epoch_millis" : "epoch_second");
    DateTime dateTime = formatter.parser().parseDateTime(parseMilliSeconds ? "1433144433655" : "1433144433");

    assertThat(dateTime.getYear(), is(2015));
    assertThat(dateTime.getDayOfMonth(), is(1));
    assertThat(dateTime.getMonthOfYear(), is(6));
    assertThat(dateTime.getHourOfDay(), is(7)); // utc timezone, +2 offset due to CEST
    assertThat(dateTime.getMinuteOfHour(), is(40));
    assertThat(dateTime.getSecondOfMinute(), is(33));

    if (parseMilliSeconds) {
        assertThat(dateTime.getMillisOfSecond(), is(655));
    } else {
        assertThat(dateTime.getMillisOfSecond(), is(0));
    }
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
public void testThatEpochTimePrinterWorks() {
    StringBuffer buffer = new StringBuffer();
    LocalDateTime now = LocalDateTime.now();

    Joda.EpochTimePrinter epochTimePrinter = new Joda.EpochTimePrinter(false);
    epochTimePrinter.printTo(buffer, now, Locale.ROOT);
    assertThat(buffer.length(), is(10));
    // only check the last digit, as seconds go from 0-99 in the unix timestamp and don't stop at 60
    assertThat(buffer.toString(), endsWith(String.valueOf(now.getSecondOfMinute() % 10)));

    buffer = new StringBuffer();
    Joda.EpochTimePrinter epochMilliSecondTimePrinter = new Joda.EpochTimePrinter(true);
    epochMilliSecondTimePrinter.printTo(buffer, now, Locale.ROOT);
    assertThat(buffer.length(), is(13));
    assertThat(buffer.toString(), endsWith(String.valueOf(now.getMillisOfSecond())));
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
public void testThatEpochParserIsIdempotent() {
    FormatDateTimeFormatter formatter = Joda.forPattern("epoch_millis");
    DateTime dateTime = formatter.parser().parseDateTime("1234567890123");
    assertThat(dateTime.getMillis(), is(1234567890123L));
    dateTime = formatter.printer().parseDateTime("1234567890456");
    assertThat(dateTime.getMillis(), is(1234567890456L));
    dateTime = formatter.parser().parseDateTime("1234567890789");
    assertThat(dateTime.getMillis(), is(1234567890789L));
    dateTime = formatter.parser().parseDateTime("1234567890123456789");
    assertThat(dateTime.getMillis(), is(1234567890123456789L));

    FormatDateTimeFormatter secondsFormatter = Joda.forPattern("epoch_second");
    DateTime secondsDateTime = secondsFormatter.parser().parseDateTime("1234567890");
    assertThat(secondsDateTime.getMillis(), is(1234567890000L));
    secondsDateTime = secondsFormatter.printer().parseDateTime("1234567890");
    assertThat(secondsDateTime.getMillis(), is(1234567890000L));
    secondsDateTime = secondsFormatter.parser().parseDateTime("1234567890");
    assertThat(secondsDateTime.getMillis(), is(1234567890000L));
    secondsDateTime = secondsFormatter.parser().parseDateTime("1234567890123456");
    assertThat(secondsDateTime.getMillis(), is(1234567890123456000L));
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
@Test
public void test_process_object() throws IllegalAccessException, NoSuchFieldException, IOException {
    Tweet tweet = getRandomTweet();

    String tweetJson = objectProcessor.toJsonString(tweet);

    logger.info("Generated JSON: {}", tweetJson);

    Tweet tweetFromJson = objectProcessor.fromJsonString(tweetJson, Tweet.class);

    Map<String, Object> tweetMap = jsonToMap(tweetJson);

    checkTweetEquals(tweetFromJson, tweet);
    // test custom date serializer/deserializer
    assertThat((String) tweetMap.get("tweetDate"), equalTo(Joda.forPattern("basic_date").printer().print(new DateTime(tweet.getTweetDate()))));
    assertThat((String) tweetMap.get("tweetDatetime"), equalTo(Joda.forPattern("yyyy/MM/dd HH:mm:ss").printer().print(new DateTime(tweet.getTweetDate()))));
    assertThat(((List<String>) tweetMap.get("specialDates")), hasSize(tweet.getSpecialDates().size()));
    assertThat(((List<String>) tweetMap.get("specialDates")).get(0), equalTo(Joda.forPattern("basic_date_time_no_millis").printer().print(new DateTime(tweet.getSpecialDates().get(0)))));
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
@Override
public DocValueFormat docValueFormat(@Nullable String format, DateTimeZone timeZone) {
    FormatDateTimeFormatter dateTimeFormatter = this.dateTimeFormatter;
    if (format != null) {
        dateTimeFormatter = Joda.forPattern(format);
    }
    if (timeZone == null) {
        timeZone = DateTimeZone.UTC;
    }
    return new DocValueFormat.DateTime(dateTimeFormatter, timeZone);
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
@Override
public java.lang.Long valueOf(String value, String fmt) {
    FormatDateTimeFormatter f = formatter;
    if (fmt != null) {
        f = Joda.forPattern(fmt);
    }
    return f.parser().parseDateTime(value).getMillis();
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
/**
 * Convert an extended bounds in parsed for into one in unparsed form.
 */
public static ExtendedBounds unparsed(ExtendedBounds template) {
    // It'd probably be better to randomize the formatter
    FormatDateTimeFormatter formatter = Joda.forPattern("dateOptionalTime");
    String minAsStr = template.getMin() == null ? null : formatter.printer().print(new Instant(template.getMin()));
    String maxAsStr = template.getMax() == null ? null : formatter.printer().print(new Instant(template.getMax()));
    return new ExtendedBounds(minAsStr, maxAsStr);
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
public void testParseAndValidate() {
    long now = randomLong();
    Settings indexSettings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1).build();
    SearchContext context = mock(SearchContext.class);
    QueryShardContext qsc = new QueryShardContext(0,
            new IndexSettings(IndexMetaData.builder("foo").settings(indexSettings).build(), indexSettings), null, null, null, null,
            null, xContentRegistry(), null, null, () -> now);
    when(context.getQueryShardContext()).thenReturn(qsc);
    FormatDateTimeFormatter formatter = Joda.forPattern("dateOptionalTime");
    DocValueFormat format = new DocValueFormat.DateTime(formatter, DateTimeZone.UTC);

    ExtendedBounds expected = randomParsedExtendedBounds();
    ExtendedBounds parsed = unparsed(expected).parseAndValidate("test", context, format);
    // parsed won't *equal* expected because equal includes the String parts
    assertEquals(expected.getMin(), parsed.getMin());
    assertEquals(expected.getMax(), parsed.getMax());

    parsed = new ExtendedBounds("now", null).parseAndValidate("test", context, format);
    assertEquals(now, (long) parsed.getMin());
    assertNull(parsed.getMax());

    parsed = new ExtendedBounds(null, "now").parseAndValidate("test", context, format);
    assertNull(parsed.getMin());
    assertEquals(now, (long) parsed.getMax());

    SearchParseException e = expectThrows(SearchParseException.class,
            () -> new ExtendedBounds(100L, 90L).parseAndValidate("test", context, format));
    assertEquals("[extended_bounds.min][100] cannot be greater than [extended_bounds.max][90] for histogram aggregation [test]",
            e.getMessage());

    e = expectThrows(SearchParseException.class,
            () -> unparsed(new ExtendedBounds(100L, 90L)).parseAndValidate("test", context, format));
    assertEquals("[extended_bounds.min][100] cannot be greater than [extended_bounds.max][90] for histogram aggregation [test]",
            e.getMessage());
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
public void testIsoVsCustom() {
    DateTimeFormatter formatter = ISODateTimeFormat.dateOptionalTimeParser().withZone(DateTimeZone.UTC);
    long millis = formatter.parseMillis("1970-01-01T00:00:00");
    assertThat(millis, equalTo(0L));

    formatter = DateTimeFormat.forPattern("yyyy/MM/dd HH:mm:ss").withZone(DateTimeZone.UTC);
    millis = formatter.parseMillis("1970/01/01 00:00:00");
    assertThat(millis, equalTo(0L));

    FormatDateTimeFormatter formatter2 = Joda.forPattern("yyyy/MM/dd HH:mm:ss");
    millis = formatter2.parser().parseMillis("1970/01/01 00:00:00");
    assertThat(millis, equalTo(0L));
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
public void testSlashInFormat() {
    FormatDateTimeFormatter formatter = Joda.forPattern("MM/yyyy");
    formatter.parser().parseMillis("01/2001");

    formatter = Joda.forPattern("yyyy/MM/dd HH:mm:ss");
    long millis = formatter.parser().parseMillis("1970/01/01 00:00:00");
    formatter.printer().print(millis);

    try {
        millis = formatter.parser().parseMillis("1970/01/01");
        fail();
    } catch (IllegalArgumentException e) {
        // it really can't parse this one
    }
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
public void testMultipleDifferentFormats() {
    FormatDateTimeFormatter formatter = Joda.forPattern("yyyy/MM/dd HH:mm:ss||yyyy/MM/dd");
    String input = "1970/01/01 00:00:00";
    long millis = formatter.parser().parseMillis(input);
    assertThat(input, is(formatter.printer().print(millis)));

    Joda.forPattern("yyyy/MM/dd HH:mm:ss||yyyy/MM/dd||dateOptionalTime");
    Joda.forPattern("dateOptionalTime||yyyy/MM/dd HH:mm:ss||yyyy/MM/dd");
    Joda.forPattern("yyyy/MM/dd HH:mm:ss||dateOptionalTime||yyyy/MM/dd");
    Joda.forPattern("date_time||date_time_no_millis");
    Joda.forPattern(" date_time || date_time_no_millis");
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
private void expectInvalidPattern(String pattern, String errorMessage) {
    try {
        Joda.forPattern(pattern);
        fail("Pattern " + pattern + " should have thrown an exception but did not");
    } catch (IllegalArgumentException e) {
        assertThat(e.getMessage(), containsString(errorMessage));
    }
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
public void testThatNegativeEpochsCanBeParsed() {
    // problem: negative epochs can be arbitrary in size...
    boolean parseMilliSeconds = randomBoolean();
    FormatDateTimeFormatter formatter = Joda.forPattern(parseMilliSeconds ? "epoch_millis" : "epoch_second");
    DateTime dateTime = formatter.parser().parseDateTime("-10000");

    assertThat(dateTime.getYear(), is(1969));
    assertThat(dateTime.getMonthOfYear(), is(12));
    assertThat(dateTime.getDayOfMonth(), is(31));
    if (parseMilliSeconds) {
        assertThat(dateTime.getHourOfDay(), is(23)); // utc timezone, +2 offset due to CEST
        assertThat(dateTime.getMinuteOfHour(), is(59));
        assertThat(dateTime.getSecondOfMinute(), is(50));
    } else {
        assertThat(dateTime.getHourOfDay(), is(21)); // utc timezone, +2 offset due to CEST
        assertThat(dateTime.getMinuteOfHour(), is(13));
        assertThat(dateTime.getSecondOfMinute(), is(20));
    }

    // every negative epoch must be parsed, no matter if exact the size or bigger
    if (parseMilliSeconds) {
        formatter.parser().parseDateTime("-100000000");
        formatter.parser().parseDateTime("-999999999999");
        formatter.parser().parseDateTime("-1234567890123");
        formatter.parser().parseDateTime("-1234567890123456789");
    } else {
        formatter.parser().parseDateTime("-100000000");
        formatter.parser().parseDateTime("-1234567890");
        formatter.parser().parseDateTime("-1234567890123456");
    }
}
 

import org.elasticsearch.common.joda.Joda; //导入依赖的package包/类
public void testForInvalidDatesInEpochSecond() {
    FormatDateTimeFormatter formatter = Joda.forPattern("epoch_second");
    try {
        formatter.parser().parseDateTime(randomFrom("invalid date", "12345678901234567", "12345678901234567890"));
        fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
        assertThat(e.getMessage(), containsString("Invalid format"));
    }
}