Java Trigger类代码示例

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    if (!enabled) {
        logger.debug("skip : {}", task);

        return null;
    }

    ScheduledFuture<?> future = instance.schedule(task, trigger);
    String runnableKey = findRunnableKey(task);

    if (Boolean.FALSE.equals(skipMap.get(runnableKey))) {
        future.cancel(true);
    }

    return future;
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    ScheduledFuture scheduledFuture = null;
    try {
        TaskDefine taskDefine = resolveTaskName(task);
        if (taskDefine.getType().equals(TaskDefine.TYPE_SPRING_TASK)) {
            super.schedule(task, trigger);
            LOGGER.debug(":添加本地任务[" + taskDefine.stringKey() + "]");
        } else {
            String cronEx = trigger.toString();
            int index = cronEx.indexOf(":");
            if (index >= 0) {
                cronEx = cronEx.substring(index + 1);
                taskDefine.setCronExpression(cronEx.trim());
            }
            scheduleTask.addTask(taskDefine);
            scheduledFuture = super.schedule(taskWrapper(task), trigger);
            LOGGER.debug(currenScheduleServer.getUuid() + ":自动向集群注册任务[" + taskDefine.stringKey() + "]");
        }
    } catch (Exception e) {
        LOGGER.error("update task error", e);
    }
    return scheduledFuture;
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldRunTokenRenewal() {

	when(clientAuthentication.login()).thenReturn(
			LoginToken.renewable("login".toCharArray(), Duration.ofSeconds(5)));

	ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);

	sessionManager.getSessionToken();
	verify(taskScheduler).schedule(runnableCaptor.capture(), any(Trigger.class));

	runnableCaptor.getValue().run();

	verify(restOperations).postForObject(
			eq("auth/token/renew-self"),
			eq(new HttpEntity<Object>(VaultHttpHeaders.from(LoginToken.renewable(
					"login", 5)))), any(Class.class));
	verify(clientAuthentication, times(1)).login();
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldReScheduleTokenRenewalAfterSuccessfulRenewal() {

	when(clientAuthentication.login()).thenReturn(
			LoginToken.renewable("login".toCharArray(), Duration.ofSeconds(5)));
	when(restOperations.postForObject(anyString(), any(), eq(VaultResponse.class)))
			.thenReturn(
					fromToken(LoginToken.of("foo".toCharArray(),
							Duration.ofSeconds(10))));

	ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);

	sessionManager.getSessionToken();
	verify(taskScheduler).schedule(runnableCaptor.capture(), any(Trigger.class));

	runnableCaptor.getValue().run();

	verify(taskScheduler, times(2)).schedule(any(Runnable.class), any(Trigger.class));
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldNotScheduleRenewalIfRenewalTtlExceedsThreshold() {

	when(clientAuthentication.login()).thenReturn(
			LoginToken.renewable("login".toCharArray(), Duration.ofSeconds(5)));
	when(restOperations.postForObject(anyString(), any(), eq(VaultResponse.class)))
			.thenReturn(
					fromToken(LoginToken.of("foo".toCharArray(),
							Duration.ofSeconds(2))));

	ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);

	sessionManager.getSessionToken();
	verify(taskScheduler).schedule(runnableCaptor.capture(), any(Trigger.class));

	runnableCaptor.getValue().run();

	verify(taskScheduler, times(1)).schedule(any(Runnable.class), any(Trigger.class));
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldReLoginIfRenewalTtlExceedsThreshold() {

	when(clientAuthentication.login()).thenReturn(
			LoginToken.renewable("login".toCharArray(), Duration.ofSeconds(5)),
			LoginToken.renewable("bar".toCharArray(), Duration.ofSeconds(5)));
	when(restOperations.postForObject(anyString(), any(), eq(VaultResponse.class)))
			.thenReturn(
					fromToken(LoginToken.of("foo".toCharArray(),
							Duration.ofSeconds(2))));

	ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
	sessionManager.getSessionToken();
	verify(taskScheduler).schedule(runnableCaptor.capture(), any(Trigger.class));
	runnableCaptor.getValue().run();

	assertThat(sessionManager.getSessionToken()).isEqualTo(
			LoginToken.renewable("bar".toCharArray(), Duration.ofSeconds(5)));

	verify(clientAuthentication, times(2)).login();
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldUseTaskScheduler() {

	sessionManager = new LifecycleAwareSessionManager(clientAuthentication,
			taskScheduler, restOperations);

	when(clientAuthentication.login()).thenReturn(
			LoginToken.renewable("login".toCharArray(), Duration.ofSeconds(5)));

	ArgumentCaptor<Trigger> triggerCaptor = ArgumentCaptor.forClass(Trigger.class);

	sessionManager.getSessionToken();
	verify(taskScheduler).schedule(any(Runnable.class), triggerCaptor.capture());

	assertThat(triggerCaptor.getValue().nextExecutionTime(null)).isNotNull();
	assertThat(triggerCaptor.getValue().nextExecutionTime(null)).isNull();
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldNotReScheduleTokenRenewalAfterFailedRenewal() {

	when(clientAuthentication.login()).thenReturn(
			LoginToken.renewable("login".toCharArray(), Duration.ofSeconds(5)));
	when(
			restOperations.postForObject(anyString(), any(),
					ArgumentMatchers.<Class> any())).thenThrow(
			new HttpServerErrorException(HttpStatus.INTERNAL_SERVER_ERROR));

	ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);

	sessionManager.getSessionToken();
	verify(taskScheduler).schedule(runnableCaptor.capture(), any(Trigger.class));

	runnableCaptor.getValue().run();

	verify(taskScheduler, times(1)).schedule(any(Runnable.class), any(Trigger.class));
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldNotScheduleRenewalIfRenewalTtlExceedsThreshold() {

	mockToken(LoginToken.renewable("login".toCharArray(), Duration.ofSeconds(5)));
	when(responseSpec.bodyToMono(VaultResponse.class)).thenReturn(
			Mono.just(fromToken(LoginToken.of("foo".toCharArray(),
					Duration.ofSeconds(2)))));

	ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);

	sessionManager.getSessionToken().as(StepVerifier::create).expectNextCount(1)
			.verifyComplete();
	verify(taskScheduler).schedule(runnableCaptor.capture(), any(Trigger.class));

	runnableCaptor.getValue().run();

	verify(taskScheduler, times(1)).schedule(any(Runnable.class), any(Trigger.class));
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldRenewLease() {

	prepareRenewal();
	when(vaultOperations.doWithSession(any(RestOperationsCallback.class)))
			.thenReturn(getResponseEntity("new_lease", true, 70, HttpStatus.OK));

	secretLeaseContainer.start();

	ArgumentCaptor<Runnable> captor = ArgumentCaptor.forClass(Runnable.class);
	verify(taskScheduler).schedule(captor.capture(), any(Trigger.class));

	captor.getValue().run();
	verifyZeroInteractions(scheduledFuture);
	verify(taskScheduler, times(2)).schedule(captor.capture(), any(Trigger.class));
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldNotRenewExpiringLease() {

	prepareRenewal();
	when(vaultOperations.doWithSession(any(RestOperationsCallback.class)))
			.thenReturn(getResponseEntity("new_lease", true, 5, HttpStatus.OK));

	secretLeaseContainer.start();

	ArgumentCaptor<Runnable> captor = ArgumentCaptor.forClass(Runnable.class);
	verify(taskScheduler).schedule(captor.capture(), any(Trigger.class));

	captor.getValue().run();
	verifyZeroInteractions(scheduledFuture);
	verify(taskScheduler, times(1)).schedule(captor.capture(), any(Trigger.class));
	verify(leaseListenerAdapter).onLeaseEvent(any(SecretLeaseCreatedEvent.class));
	verify(leaseListenerAdapter).onLeaseEvent(any(SecretLeaseExpiredEvent.class));
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldPublishRenewalErrors() {

	prepareRenewal();
	when(vaultOperations.doWithSession(any(RestOperationsCallback.class))).thenThrow(
			new HttpClientErrorException(HttpStatus.I_AM_A_TEAPOT));

	secretLeaseContainer.start();

	ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
	verify(taskScheduler).schedule(runnableCaptor.capture(), any(Trigger.class));

	runnableCaptor.getValue().run();

	verify(leaseListenerAdapter).onLeaseEvent(any(SecretLeaseCreatedEvent.class));
	verify(leaseListenerAdapter).onLeaseError(captor.capture(),
			any(VaultException.class));
	verifyNoMoreInteractions(leaseListenerAdapter);

	SecretLeaseEvent leaseEvent = captor.getValue();

	assertThat(leaseEvent.getSource()).isEqualTo(requestedSecret);
	assertThat(leaseEvent.getLease()).isNotNull();
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldRequestRotatingGenericSecrets() {

	when(taskScheduler.schedule(any(Runnable.class), any(Trigger.class))).thenReturn(
			scheduledFuture);

	when(vaultOperations.read(rotatingGenericSecret.getPath())).thenReturn(
			createGenericSecrets());

	secretLeaseContainer.addRequestedSecret(rotatingGenericSecret);
	secretLeaseContainer.start();

	verify(leaseListenerAdapter).onLeaseEvent(captor.capture());

	SecretLeaseCreatedEvent leaseCreatedEvent = (SecretLeaseCreatedEvent) captor
			.getValue();

	assertThat(leaseCreatedEvent.getSource()).isEqualTo(rotatingGenericSecret);
	assertThat(leaseCreatedEvent.getLease()).isNotNull();
	assertThat(leaseCreatedEvent.getSecrets()).containsKey("key");
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
	JobKey jobKey = new JobKey(pollingEndpointBeanName);

	if (!scheduler.checkExists(jobKey)) {
		JobDetail jobDetail = JobBuilder.newJob(PollingEndpointQuartzBridgeJob.class)
				.withIdentity(jobKey)
				.storeDurably()
				.build();

		JobDataMap jobDataMap = new JobDataMap();
		jobDataMap.put(PollingEndpointQuartzBridgeJob.POLLING_ENDPOINT_BEAN_NAME_KEY, pollingEndpointBeanName);
		jobDataMap.put(PollingEndpointQuartzBridgeJob.TRIGGER_BEAN_NAME_KEY, triggerBeanName);

		org.quartz.Trigger trigger = TriggerBuilder.newTrigger()
				.withIdentity(pollingEndpointBeanName)
				.withSchedule(scheduleBuilder)
				.forJob(jobDetail)
				.usingJobData(jobDataMap)
				.build();

		scheduler.scheduleJob(jobDetail, trigger);
	}
}
 

import org.springframework.scheduling.Trigger; //导入依赖的package包/类
@Test
public void shouldBuildTriggers() {
	
	String[] expressions = new String[]{ 
			"fixed-rate:100",
			"fixed-delay:100",
			"fixed-rate:10,fixed-delay:10",
			"0 0 * 14 3 ?",
			"timerange:10:00:00->12:00:00->(fixed-rate:100)"
	};
	
	TriggerBuilder triggerBuilder = new TriggerBuilder();
	for (String expression : expressions) {
		Trigger trigger = triggerBuilder.build(expression);
		TriggerContext triggerContext = new SimpleTriggerContext();
		trigger.nextExecutionTime(triggerContext);
	}
	
}