Java Period类代码示例

import org.joda.time.Period; //导入依赖的package包/类
public static String formatDuration(long duration)
{
	// Using Joda Time
	DateTime now = new DateTime(); // Now
	DateTime plus = now.plus(new Duration(duration * 1000));

	// Define and calculate the interval of time
	Interval interval = new Interval(now.getMillis(), plus.getMillis());
	Period period = interval.toPeriod(PeriodType.time());

	// Define the period formatter for pretty printing
	String ampersand = " & ";
	PeriodFormatter pf = new PeriodFormatterBuilder().appendHours().appendSuffix(ds("hour"), ds("hours"))
		.appendSeparator(" ", ampersand).appendMinutes().appendSuffix(ds("minute"), ds("minutes"))
		.appendSeparator(ampersand).appendSeconds().appendSuffix(ds("second"), ds("seconds")).toFormatter();

	return pf.print(period).trim();
}
 

import org.joda.time.Period; //导入依赖的package包/类
@Test
public void testTimeSpanFromPeriod() {
    Period period = new Period()
            .withDays(366)
            .withHours(25)
            .withMinutes(10)
            .withSeconds(70)
            .withMillis(1001);
    TimeSpan timeSpan = new TimeSpan()
            .withDays(366)
            .withHours(25)
            .withMinutes(10)
            .withSeconds(70)
            .withMilliseconds(1001);
    Assert.assertEquals(TimeSpan.fromPeriod(period).toString(), timeSpan.toString());

    period = new Period()
            .withWeeks(12)
            .withDays(366)
            .withHours(25)
            .withMinutes(10)
            .withSeconds(70)
            .withMillis(1001);
    // Days -> 12 * 7 + 366 + 1
    Assert.assertEquals("451.01:11:11.0010000", TimeSpan.fromPeriod(period).toString());
}
 

import org.joda.time.Period; //导入依赖的package包/类
private KubernetesAgentInstances unregisteredAfterTimeout(PluginSettings settings, Agents knownAgents) throws Exception {
    Period period = settings.getAutoRegisterPeriod();
    KubernetesAgentInstances unregisteredInstances = new KubernetesAgentInstances();
    KubernetesClient client = factory.kubernetes(settings);

    for (String instanceName : instances.keySet()) {
        if (knownAgents.containsAgentWithId(instanceName)) {
            continue;
        }
        Pod pod = client.pods().inNamespace(Constants.KUBERNETES_NAMESPACE_KEY).withName(instanceName).get();
        Date createdAt = getSimpleDateFormat().parse(pod.getMetadata().getCreationTimestamp());
        DateTime dateTimeCreated = new DateTime(createdAt);

        if (clock.now().isAfter(dateTimeCreated.plus(period))) {
            unregisteredInstances.register(kubernetesInstanceFactory.fromKubernetesPod(pod));
        }
    }
    return unregisteredInstances;
}
 

import org.joda.time.Period; //导入依赖的package包/类
@Test
public void testShouldTerminateInstancesThatNeverAutoRegistered() throws Exception {
    KubernetesAgentInstances agentInstances = new KubernetesAgentInstances(factory);
    HashMap<String, String> properties = new HashMap<>();
    properties.put("Image", "foo");
    KubernetesInstance container = agentInstances.create(new CreateAgentRequest(null, properties, null, new JobIdentifier(1L)), createSettings(), null);

    agentInstances.clock = new Clock.TestClock().forward(Period.minutes(11));
    PluginRequest pluginRequest = mock(PluginRequest.class);

    objectMetadata.setName(container.name());
    HashMap<String, String> labels = new HashMap<>();
    labels.put(Constants.JOB_ID_LABEL_KEY, "1");
    objectMetadata.setLabels(labels);
    when(pluginRequest.getPluginSettings()).thenReturn(createSettings());
    when(pluginRequest.listAgents()).thenReturn(new Agents());
    verifyNoMoreInteractions(pluginRequest);

    new ServerPingRequestExecutor(agentInstances, pluginRequest).execute();
    assertFalse(agentInstances.instanceExists(container));
}
 

import org.joda.time.Period; //导入依赖的package包/类
private void testParquetReaderHelper(String tableName, Period row1Col1, Period row1Col2,
                                     Period row2Col1, Period row2Col2) throws Exception {

  final String switchReader = "alter session set `store.parquet.use_new_reader` = %s; ";
  final String enableVectorizedReader = String.format(switchReader, true);
  final String disableVectorizedReader = String.format(switchReader, false);
  String query = String.format("select * from %s", tableName);

  testBuilder()
      .sqlQuery(query)
      .unOrdered()
      .optionSettingQueriesForTestQuery(enableVectorizedReader)
      .baselineColumns("col1", "col2")
      .baselineValues(row1Col1, row1Col2)
      .baselineValues(row2Col1, row2Col2)
      .go();

  testBuilder()
      .sqlQuery(query)
      .unOrdered()
      .optionSettingQueriesForTestQuery(disableVectorizedReader)
      .baselineColumns("col1", "col2")
      .baselineValues(row1Col1, row1Col2)
      .baselineValues(row2Col1, row2Col2)
      .go();
}
 

import org.joda.time.Period; //导入依赖的package包/类
/**
 * Set dictionary value  {"0": "P123DT22H14M12.011S", "1": "P5DT1H0M0S"}.
 *
 * @param arrayBody the Map<String, Period> value
 * @throws IllegalArgumentException thrown if parameters fail the validation
 * @return the {@link ServiceResponse} object if successful.
 */
public Observable<ServiceResponse<Void>> putDurationValidWithServiceResponseAsync(Map<String, Period> arrayBody) {
    if (arrayBody == null) {
        throw new IllegalArgumentException("Parameter arrayBody is required and cannot be null.");
    }
    Validator.validate(arrayBody);
    return service.putDurationValid(arrayBody)
        .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
            @Override
            public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                try {
                    ServiceResponse<Void> clientResponse = putDurationValidDelegate(response);
                    return Observable.just(clientResponse);
                } catch (Throwable t) {
                    return Observable.error(t);
                }
            }
        });
}
 

import org.joda.time.Period; //导入依赖的package包/类
private MarathonAgentInstances unregisteredAfterTimeout(PluginSettings settings, Agents knownAgents) throws Exception {
    MarathonAgentInstances unregisteredContainers = new MarathonAgentInstances();
    if (settings == null) {
        return unregisteredContainers;
    }
    Period period = settings.getAutoRegisterPeriod();

    for (MarathonInstance instance: instances.values()) {
        if (knownAgents.containsAgentWithId(instance.name())) {
            continue;
        }

        DateTime dateTimeCreated = new DateTime(instance.createdAt());

        if (clock.now().isAfter(dateTimeCreated.plus(period))) {
            unregisteredContainers.register(instance);
        }
    }
    return unregisteredContainers;
}
 

import org.joda.time.Period; //导入依赖的package包/类
/**
 * Formats a period similar to Oracle INTERVAL DAY TO SECOND data type.<br>
 * For example, the string "-001 18:25:16.766" defines an interval of - 1 day 18 hours 25 minutes 16 seconds and 766 milliseconds
 */
public static String formatIntervalDay(final Period p) {
  long millis = p.getDays() * (long) DateUtility.daysToStandardMillis + DateUtility.millisFromPeriod(p);

  boolean neg = false;
  if (millis < 0) {
    millis = -millis;
    neg = true;
  }

  final int days = (int) (millis / DateUtility.daysToStandardMillis);
  millis = millis % DateUtility.daysToStandardMillis;

  final int hours  = (int) (millis / DateUtility.hoursToMillis);
  millis     = millis % DateUtility.hoursToMillis;

  final int minutes = (int) (millis / DateUtility.minutesToMillis);
  millis      = millis % DateUtility.minutesToMillis;

  final int seconds = (int) (millis / DateUtility.secondsToMillis);
  millis      = millis % DateUtility.secondsToMillis;

  return String.format("%c%03d %02d:%02d:%02d.%03d", neg ? '-':'+', days, hours, minutes, seconds, millis);
}
 

import org.joda.time.Period; //导入依赖的package包/类
/**
 * Set array value  ['P123DT22H14M12.011S', 'P5DT1H0M0S'].
 *
 * @param arrayBody the List<Period> value
 * @throws IllegalArgumentException thrown if parameters fail the validation
 * @return the {@link ServiceResponse} object if successful.
 */
public Observable<ServiceResponse<Void>> putDurationValidWithServiceResponseAsync(List<Period> arrayBody) {
    if (arrayBody == null) {
        throw new IllegalArgumentException("Parameter arrayBody is required and cannot be null.");
    }
    Validator.validate(arrayBody);
    return service.putDurationValid(arrayBody)
        .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
            @Override
            public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                try {
                    ServiceResponse<Void> clientResponse = putDurationValidDelegate(response);
                    return Observable.just(clientResponse);
                } catch (Throwable t) {
                    return Observable.error(t);
                }
            }
        });
}
 

import org.joda.time.Period; //导入依赖的package包/类
@Override
public void refreshAll(PluginRequest pluginRequest) throws Exception {
    if (refreshed) {
        if (refreshedTime == null) {
            setRefreshed(false);
        } else {
            if (refreshedTime.isBefore(new DateTime().minus(new Period("PT10M")))) {
                setRefreshed(false);
            }
        }
    }
    if (!refreshed) {
        PluginSettings settings = pluginRequest.getPluginSettings();
        List<MarathonInstance> marathonInstanceList = marathon(settings).getGoAgents(settings);
        for (MarathonInstance instance: marathonInstanceList) {
             register(instance);
        }
        LOG.debug("Instances found: " + marathonInstanceList.toString());
        setRefreshedTime(new DateTime());
        setRefreshed(true);
    }
}
 

import org.joda.time.Period; //导入依赖的package包/类
/**
 * Decide when the job should start run in first time
 * @return Seconds for the Job to start
 */
public int getDelay() {
  try {
    JobRunInfo lastRun = jobInfoStore.getLatestRun(this.identifier);

    if (lastRun != null && lastRun.isSucceed()) {
      Period
          period =
          new Period(new DateTime(lastRun.getStartTime()), DateTime.now(DateTimeZone.UTC));
      if (period.toStandardSeconds().getSeconds() < this.interval) {
        return (int) (this.interval - period.toStandardSeconds().getSeconds());
      }
    }
  } catch (Exception ex) {
    logger.error(ExceptionUtils.getRootCauseMessage(ex));
    logger.error(ExceptionUtils.getFullStackTrace(ex));
  }

  return random.nextInt(Configuration.getProperties().getInt("job_random_delay", 60));
}
 

import org.joda.time.Period; //导入依赖的package包/类
/**
 * Get a positive duration value.
 *
 * @throws IllegalArgumentException thrown if parameters fail the validation
 * @return the observable to the Period object
 */
public Observable<ServiceResponse<Period>> getPositiveDurationWithServiceResponseAsync() {
    return service.getPositiveDuration()
        .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Period>>>() {
            @Override
            public Observable<ServiceResponse<Period>> call(Response<ResponseBody> response) {
                try {
                    ServiceResponse<Period> clientResponse = getPositiveDurationDelegate(response);
                    return Observable.just(clientResponse);
                } catch (Throwable t) {
                    return Observable.error(t);
                }
            }
        });
}
 

import org.joda.time.Period; //导入依赖的package包/类
@Override
public Period defaultMessageTtlDuration() {
    if (this.inner().defaultMessageTimeToLive() == null) {
        return null;
    }
    TimeSpan timeSpan = TimeSpan.parse(this.inner().defaultMessageTimeToLive());
    return new Period()
            .withDays(timeSpan.days())
            .withHours(timeSpan.hours())
            .withMinutes(timeSpan.minutes())
            .withSeconds(timeSpan.seconds())
            .withMillis(timeSpan.milliseconds());
}
 

import org.joda.time.Period; //导入依赖的package包/类
/**
 * Executes the actual shutdown once one of the shutdown handlers has
 * accepted the shutdown request
 * 
 * @param response
 *            Tells the caller some metrics
 */
private void shutdownExecution(final HttpServerResponse response) {
	final JsonObject goodby = new JsonObject();
	goodby.put("Goodby", "It was a pleasure doing business with you");
	goodby.put("StartDate", Utils.getDateString(this.startDate));
	goodby.put("EndDate", Utils.getDateString(new Date()));
	final Duration dur = new Duration(new DateTime(this.startDate), new DateTime());
	goodby.put("Duration", PeriodFormat.getDefault().print(new Period(dur)));
	response.putHeader(Constants.CONTENT_HEADER, Constants.CONTENT_TYPE_JSON).setStatusCode(202)
			.end(goodby.encodePrettily());
	try {
		Future<Void> shutdownFuture = Future.future();
		shutdownFuture.setHandler(fResult -> {
			if (fResult.failed()) {
				this.logger.fatal(fResult.cause());
				System.exit(-1);
			}
			this.logger.info("Good by!");
			this.getVertx().close(handler -> {
				if (handler.failed()) {
					this.logger.fatal(handler.cause());
				}
				System.exit(0);
			});
		});
		this.shutDownVerticles(shutdownFuture);
	} catch (Exception e) {
		this.logger.fatal(e.getMessage(), e);
	}
}
 

import org.joda.time.Period; //导入依赖的package包/类
/**
 * Get duration array value ['P123DT22H14M12.011S', 'P5DT1H0M0S'].
 *
 * @throws IllegalArgumentException thrown if parameters fail the validation
 * @return the observable to the List<Period> object
 */
public Observable<List<Period>> getDurationValidAsync() {
    return getDurationValidWithServiceResponseAsync().map(new Func1<ServiceResponse<List<Period>>, List<Period>>() {
        @Override
        public List<Period> call(ServiceResponse<List<Period>> response) {
            return response.body();
        }
    });
}