下面列出了怎么用org.springframework.core.task.SyncTaskExecutor的API类实例代码及写法，或者点击链接到github查看源代码。
@SuppressWarnings("ConstantConditions")
private void logExecutorWarning() {
if (taskExecutorWarning && logger.isWarnEnabled()) {
synchronized (DEFAULT_TASK_EXECUTOR) {
AsyncTaskExecutor executor = this.taskExecutor;
if (taskExecutorWarning &&
(executor instanceof SimpleAsyncTaskExecutor || executor instanceof SyncTaskExecutor)) {
String executorTypeName = executor.getClass().getSimpleName();
logger.warn("\n!!!\n" +
"An Executor is required to handle java.util.concurrent.Callable return values.\n" +
"Please, configure a TaskExecutor in the MVC config under \"async support\".\n" +
"The " + executorTypeName + " currently in use is not suitable under load.\n" +
"-------------------------------\n" +
"Request URI: '" + formatRequestUri() + "'\n" +
"!!!");
taskExecutorWarning = false;
}
}
}
}
@SuppressWarnings("ConstantConditions")
private void logExecutorWarning() {
if (taskExecutorWarning && logger.isWarnEnabled()) {
synchronized (DEFAULT_TASK_EXECUTOR) {
AsyncTaskExecutor executor = this.taskExecutor;
if (taskExecutorWarning &&
(executor instanceof SimpleAsyncTaskExecutor || executor instanceof SyncTaskExecutor)) {
String executorTypeName = executor.getClass().getSimpleName();
logger.warn("\n!!!\n" +
"An Executor is required to handle java.util.concurrent.Callable return values.\n" +
"Please, configure a TaskExecutor in the MVC config under \"async support\".\n" +
"The " + executorTypeName + " currently in use is not suitable under load.\n" +
"-------------------------------\n" +
"Request URI: '" + formatRequestUri() + "'\n" +
"!!!");
taskExecutorWarning = false;
}
}
}
}
@Test
void contentLength_withExistingResource_returnsContentLengthOfObjectMetaData()
throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
ObjectMetadata objectMetadata = new ObjectMetadata();
objectMetadata.setContentLength(1234L);
when(amazonS3.getObjectMetadata(any(GetObjectMetadataRequest.class)))
.thenReturn(objectMetadata);
// Act
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Assert
assertThat(simpleStorageResource.contentLength()).isEqualTo(1234L);
}
@Test
void lastModified_withExistingResource_returnsLastModifiedDateOfResource()
throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
ObjectMetadata objectMetadata = new ObjectMetadata();
Date lastModified = new Date();
objectMetadata.setLastModified(lastModified);
when(amazonS3.getObjectMetadata(any(GetObjectMetadataRequest.class)))
.thenReturn(objectMetadata);
// Act
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Assert
assertThat(simpleStorageResource.lastModified())
.isEqualTo(lastModified.getTime());
}
@Test
void getInputStream_existingObject_returnsInputStreamWithContent() throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
ObjectMetadata objectMetadata = mock(ObjectMetadata.class);
when(amazonS3.getObjectMetadata(any(GetObjectMetadataRequest.class)))
.thenReturn(objectMetadata);
S3Object s3Object = new S3Object();
s3Object.setObjectMetadata(objectMetadata);
s3Object.setObjectContent(new ByteArrayInputStream(new byte[] { 42 }));
when(amazonS3.getObject(any(GetObjectRequest.class))).thenReturn(s3Object);
// Act
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Assert
assertThat(simpleStorageResource.exists()).isTrue();
assertThat(simpleStorageResource.getInputStream().read()).isEqualTo(42);
}
@Test
void getDescription_withoutObjectMetaData_returnsDescriptiveDescription()
throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
// Act
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"1", "2", new SyncTaskExecutor());
String description = simpleStorageResource.getDescription();
// Assert
assertThat(description.contains("bucket")).isTrue();
assertThat(description.contains("object")).isTrue();
assertThat(description.contains("1")).isTrue();
assertThat(description.contains("2")).isTrue();
}
@Test
void createRelative_existingObject_returnsRelativeCreatedFile() throws IOException {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
when(amazonS3.getObjectMetadata(any(GetObjectMetadataRequest.class)))
.thenReturn(new ObjectMetadata());
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Act
SimpleStorageResource subObject = simpleStorageResource
.createRelative("subObject");
// Assert
assertThat(subObject.getFilename()).isEqualTo("object/subObject");
}
@Test
void createResourceLoader_withoutExecutorSettings_executorConfigured() {
// Arrange
this.context = new AnnotationConfigApplicationContext();
this.context.register(ContextResourceLoaderAutoConfiguration.class);
// Act
this.context.refresh();
// Assert
SimpleStorageProtocolResolver simpleStorageProtocolResolver = (SimpleStorageProtocolResolver) this.context
.getProtocolResolvers().iterator().next();
SyncTaskExecutor taskExecutor = (SyncTaskExecutor) ReflectionTestUtils
.getField(simpleStorageProtocolResolver, "taskExecutor");
assertThat(taskExecutor).isNotNull();
}
protected MachineConfiguration<S, E> getStateMachineConfiguration() {
StateMachineConfigurationBuilder<S, E> configurationBuilder =
new StateMachineConfigurationBuilder<>(ObjectPostProcessor.QUIESCENT_POSTPROCESSOR, true);
StateMachineStateBuilder<S, E> stateBuilder =
new StateMachineStateBuilder<>(ObjectPostProcessor.QUIESCENT_POSTPROCESSOR, true);
StateMachineTransitionBuilder<S, E> transitionBuilder =
new StateMachineTransitionBuilder<>(ObjectPostProcessor.QUIESCENT_POSTPROCESSOR, true);
StateMachineListener<S, E> listener =
new StateMachineListenerAdapter<>() {
@Override
public void stateChanged(State<S, E> from, State<S, E> to) {
LOGGER.debug("state changed from {} to {}", from, to);
}
@Override
public void eventNotAccepted(Message<E> event) {
LOGGER.error("{} not accepted event: {}", getClass().getSimpleName(), event);
}
};
return new MachineConfiguration<>(configurationBuilder, stateBuilder, transitionBuilder, listener, new SyncTaskExecutor());
}
@Before
public void setup() throws Exception {
underTest = spy(new TestAction());
underTest.setFailureEvent(Event.FAILURE);
MockitoAnnotations.initMocks(this);
BDDMockito.given(flow.getFlowId()).willReturn(FLOW_ID);
BDDMockito.given(runningFlows.get(anyString())).willReturn(flow);
StateMachineConfigurationBuilder<State, Event> configurationBuilder =
new StateMachineConfigurationBuilder<>(ObjectPostProcessor.QUIESCENT_POSTPROCESSOR, true);
configurationBuilder.setTaskExecutor(new SyncTaskExecutor());
StateMachineStateBuilder<State, Event> stateBuilder =
new StateMachineStateBuilder<>(ObjectPostProcessor.QUIESCENT_POSTPROCESSOR, true);
stateBuilder.withStates().initial(State.INIT).state(State.DOING, underTest, null);
StateMachineTransitionBuilder<State, Event> transitionBuilder =
new StateMachineTransitionBuilder<>(ObjectPostProcessor.QUIESCENT_POSTPROCESSOR, true);
transitionBuilder.withExternal().source(State.INIT).target(State.DOING).event(Event.DOIT);
stateMachine = new ObjectStateMachineFactory<>(configurationBuilder.build(), transitionBuilder.build(), stateBuilder.build()).getStateMachine();
stateMachine.start();
when(tracer.buildSpan(anyString())).thenReturn(spanBuilder);
when(spanBuilder.addReference(anyString(), any())).thenReturn(spanBuilder);
when(spanBuilder.ignoreActiveSpan()).thenReturn(spanBuilder);
when(spanBuilder.start()).thenReturn(span);
when(tracer.activateSpan(span)).thenReturn(scope);
when(span.context()).thenReturn(spanContext);
}
@Override
protected MachineConfiguration<State, Event> getStateMachineConfiguration() {
StateMachineConfigurationBuilder<State, Event> configurationBuilder =
new StateMachineConfigurationBuilder<>(ObjectPostProcessor.QUIESCENT_POSTPROCESSOR, true);
StateMachineStateBuilder<State, Event> stateBuilder =
new StateMachineStateBuilder<>(ObjectPostProcessor.QUIESCENT_POSTPROCESSOR, true);
StateMachineTransitionBuilder<State, Event> transitionBuilder =
new StateMachineTransitionBuilder<>(ObjectPostProcessor.QUIESCENT_POSTPROCESSOR, true);
StateMachineListener<State, Event> listener =
new StateMachineListenerAdapter<State, Event>() {
@Override
public void eventNotAccepted(Message<Event> event) {
throw new NotAcceptedException();
}
};
return new MachineConfiguration<>(configurationBuilder, stateBuilder, transitionBuilder, listener,
new SyncTaskExecutor());
}
ReactiveTypeHandler(ReactiveAdapterRegistry registry, TaskExecutor executor, ContentNegotiationManager manager) {
Assert.notNull(registry, "ReactiveAdapterRegistry is required");
Assert.notNull(executor, "TaskExecutor is required");
Assert.notNull(manager, "ContentNegotiationManager is required");
this.adapterRegistry = registry;
this.taskExecutor = executor;
this.contentNegotiationManager = manager;
this.taskExecutorWarning =
(executor instanceof SimpleAsyncTaskExecutor || executor instanceof SyncTaskExecutor);
}
@Before
public void setup() throws Exception {
ContentNegotiationManagerFactoryBean factoryBean = new ContentNegotiationManagerFactoryBean();
factoryBean.afterPropertiesSet();
ContentNegotiationManager manager = factoryBean.getObject();
ReactiveAdapterRegistry adapterRegistry = ReactiveAdapterRegistry.getSharedInstance();
this.handler = new ReactiveTypeHandler(adapterRegistry, new SyncTaskExecutor(), manager);
resetRequest();
}
private ListenableFuture<WebSocketSession> connect(RestOperations restTemplate, ClientHttpResponse... responses)
throws Exception {
RestTemplateXhrTransport transport = new RestTemplateXhrTransport(restTemplate);
transport.setTaskExecutor(new SyncTaskExecutor());
SockJsUrlInfo urlInfo = new SockJsUrlInfo(new URI("https://example.com"));
HttpHeaders headers = new HttpHeaders();
headers.add("h-foo", "h-bar");
TransportRequest request = new DefaultTransportRequest(urlInfo, headers, headers,
transport, TransportType.XHR, CODEC);
return transport.connect(request, this.webSocketHandler);
}
ReactiveTypeHandler(ReactiveAdapterRegistry registry, TaskExecutor executor, ContentNegotiationManager manager) {
Assert.notNull(registry, "ReactiveAdapterRegistry is required");
Assert.notNull(executor, "TaskExecutor is required");
Assert.notNull(manager, "ContentNegotiationManager is required");
this.reactiveRegistry = registry;
this.taskExecutor = executor;
this.taskExecutorWarning = executor instanceof SimpleAsyncTaskExecutor || executor instanceof SyncTaskExecutor;
this.contentNegotiationManager = manager;
}
@Before
public void setup() throws Exception {
ContentNegotiationManagerFactoryBean factoryBean = new ContentNegotiationManagerFactoryBean();
factoryBean.afterPropertiesSet();
ContentNegotiationManager manager = factoryBean.getObject();
ReactiveAdapterRegistry adapterRegistry = ReactiveAdapterRegistry.getSharedInstance();
this.handler = new ReactiveTypeHandler(adapterRegistry, new SyncTaskExecutor(), manager);
resetRequest();
}
private ListenableFuture<WebSocketSession> connect(RestOperations restTemplate, ClientHttpResponse... responses)
throws Exception {
RestTemplateXhrTransport transport = new RestTemplateXhrTransport(restTemplate);
transport.setTaskExecutor(new SyncTaskExecutor());
SockJsUrlInfo urlInfo = new SockJsUrlInfo(new URI("http://example.com"));
HttpHeaders headers = new HttpHeaders();
headers.add("h-foo", "h-bar");
TransportRequest request = new DefaultTransportRequest(urlInfo, headers, headers,
transport, TransportType.XHR, CODEC);
return transport.connect(request, this.webSocketHandler);
}
private Connector configureConnectorToReturnDifferentThreadPoolImplementation() {
Connector mockConnector = mock(Connector.class);
ProtocolHandler mockProtocolHandler = mock(ProtocolHandler.class);
when(mockConnector.getProtocolHandler()).thenReturn(mockProtocolHandler);
when(mockProtocolHandler.getExecutor()).thenReturn(new SyncTaskExecutor());
return mockConnector;
}
public AdHocStarter(JobLocator jobLocator, JobRepository jobRepository, JobPropertyResolvers jobPropertyResolvers,
@Value("${com.github.chrisgleissner.springbatchrest.addUniqueJobParameter:true}") boolean addUniqueJobParameter,
JobRegistry jobRegistry) {
this.jobLocator = jobLocator;
asyncJobLauncher = jobLauncher(new SimpleAsyncTaskExecutor(), jobRepository);
syncJobLauncher = jobLauncher(new SyncTaskExecutor(), jobRepository);
this.jobPropertyResolvers = jobPropertyResolvers;
this.addUniqueJobParameter = addUniqueJobParameter;
this.jobRegistry = jobRegistry;
log.info("Adding unique job parameter: {}", addUniqueJobParameter);
}
private ListenableFuture<WebSocketSession> connect(RestOperations restTemplate, ClientHttpResponse... responses)
throws Exception {
RestTemplateXhrTransport transport = new RestTemplateXhrTransport(restTemplate);
transport.setTaskExecutor(new SyncTaskExecutor());
SockJsUrlInfo urlInfo = new SockJsUrlInfo(new URI("http://example.com"));
HttpHeaders headers = new HttpHeaders();
headers.add("h-foo", "h-bar");
TransportRequest request = new DefaultTransportRequest(urlInfo, headers, headers,
transport, TransportType.XHR, CODEC);
return transport.connect(request, this.webSocketHandler);
}
@Override
public JobLauncher getJobLauncher() {
SimpleJobLauncher launcher = new SimpleJobLauncher();
launcher.setJobRepository(this.jobRepository);
launcher.setTaskExecutor(new SyncTaskExecutor());
return launcher;
}
@Test
public void testSingleThreaded() throws Exception {
respondSuccess(NUMBER_OF_EMPLOYEES);
setExecutor(new SyncTaskExecutor());
jobExecution = jobLauncher.run(job, jobParams);
printExecutionTime("SingleThreaded", jobExecution);
}
@Test
void exists_withExistingObjectMetadata_returnsTrue() throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
when(amazonS3.getObjectMetadata(any(GetObjectMetadataRequest.class)))
.thenReturn(new ObjectMetadata());
// Act
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Assert
assertThat(simpleStorageResource.exists()).isTrue();
}
@Test
void exists_withoutExistingObjectMetadata_returnsFalse() throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
when(amazonS3.getObjectMetadata(any(GetObjectMetadataRequest.class)))
.thenReturn(null);
// Act
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Act
assertThat(simpleStorageResource.exists()).isFalse();
}
@Test
void contentLength_fileDoesNotExists_reportsError() throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
when(amazonS3.getObjectMetadata(any(GetObjectMetadataRequest.class)))
.thenReturn(null);
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Assert
assertThatThrownBy(simpleStorageResource::contentLength)
.isInstanceOf(FileNotFoundException.class)
.hasMessageContaining("not found");
}
@Test
void lastModified_fileDoestNotExist_reportsError() throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
when(amazonS3.getObjectMetadata(any(GetObjectMetadataRequest.class)))
.thenReturn(null);
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Assert
assertThatThrownBy(simpleStorageResource::lastModified)
.isInstanceOf(FileNotFoundException.class)
.hasMessageContaining("not found");
}
@Test
void getFileName_existingObject_returnsFileNameWithoutBucketNameFromParameterWithoutActuallyFetchingTheFile()
throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
when(amazonS3.getObjectMetadata(any(GetObjectMetadataRequest.class)))
.thenReturn(null);
// Act
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Assert
assertThat(simpleStorageResource.getFilename()).isEqualTo("object");
}
@Test
void getUrl_existingObject_returnsUrlWithS3Scheme() throws Exception {
AmazonS3Client amazonS3 = mock(AmazonS3Client.class);
// Act
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucket", "object", new SyncTaskExecutor());
// Assert
assertThat(simpleStorageResource.getS3Uri())
.isEqualTo(new URI("s3://bucket/object"));
}
@Test
void writeFile_forNewFile_writesFileContent() throws Exception {
// Arrange
AmazonS3 amazonS3 = mock(AmazonS3.class);
SimpleStorageResource simpleStorageResource = new SimpleStorageResource(amazonS3,
"bucketName", "objectName", new SyncTaskExecutor());
String messageContext = "myFileContent";
when(amazonS3.putObject(eq("bucketName"), eq("objectName"),
any(InputStream.class), any(ObjectMetadata.class)))
.thenAnswer((Answer<PutObjectResult>) invocation -> {
assertThat(invocation.getArguments()[0])
.isEqualTo("bucketName");
assertThat(invocation.getArguments()[1])
.isEqualTo("objectName");
byte[] content = new byte[messageContext.length()];
assertThat(((InputStream) invocation.getArguments()[2])
.read(content)).isEqualTo(content.length);
assertThat(new String(content)).isEqualTo(messageContext);
return new PutObjectResult();
});
OutputStream outputStream = simpleStorageResource.getOutputStream();
// Act
outputStream.write(messageContext.getBytes());
outputStream.flush();
outputStream.close();
// Assert
}
@Test
void getUri_encodes_objectName() throws Exception {
AmazonS3 s3 = mock(AmazonS3.class);
when(s3.getRegion()).thenReturn(Region.US_West_2);
SimpleStorageResource resource = new SimpleStorageResource(s3, "bucketName",
"some/[objectName]", new SyncTaskExecutor());
assertThat(resource.getURI()).isEqualTo(new URI(
"https://s3.us-west-2.amazonaws.com/bucketName/some%2F%5BobjectName%5D"));
}