Add builders to simplify remote partitioning setup
Resolves BATCH-2687 * use hard coded constants in docs * change visibility of method `beanFactory` to public in builders
This commit is contained in:
Mahmoud Ben Hassine
committed by
Michael Minella
Michael Minella
parent
9f2b752f3f
commit
39676a45c4
@@ -15,9 +15,12 @@
|
||||
*/
|
||||
package org.springframework.batch.integration.config.annotation;
|
||||
|
||||
import org.springframework.batch.core.explore.JobExplorer;
|
||||
import org.springframework.batch.core.repository.JobRepository;
|
||||
import org.springframework.batch.integration.chunk.RemoteChunkingMasterStepBuilderFactory;
|
||||
import org.springframework.batch.integration.chunk.RemoteChunkingWorkerBuilder;
|
||||
import org.springframework.batch.integration.partition.RemotePartitioningMasterStepBuilderFactory;
|
||||
import org.springframework.batch.integration.partition.RemotePartitioningWorkerStepBuilderFactory;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
@@ -32,6 +35,8 @@ import org.springframework.transaction.PlatformTransactionManager;
|
||||
@Configuration
|
||||
public class BatchIntegrationConfiguration {
|
||||
|
||||
private JobExplorer jobExplorer;
|
||||
|
||||
private JobRepository jobRepository;
|
||||
|
||||
private PlatformTransactionManager transactionManager;
|
||||
@@ -39,9 +44,11 @@ public class BatchIntegrationConfiguration {
|
||||
@Autowired
|
||||
public BatchIntegrationConfiguration(
|
||||
JobRepository jobRepository,
|
||||
JobExplorer jobExplorer,
|
||||
PlatformTransactionManager transactionManager) {
|
||||
|
||||
this.jobRepository = jobRepository;
|
||||
this.jobExplorer = jobExplorer;
|
||||
this.transactionManager = transactionManager;
|
||||
}
|
||||
|
||||
@@ -56,4 +63,16 @@ public class BatchIntegrationConfiguration {
|
||||
return new RemoteChunkingWorkerBuilder<>();
|
||||
}
|
||||
|
||||
@Bean
|
||||
public RemotePartitioningMasterStepBuilderFactory remotePartitioningMasterStepBuilderFactory() {
|
||||
return new RemotePartitioningMasterStepBuilderFactory(this.jobRepository,
|
||||
this.jobExplorer, this.transactionManager);
|
||||
}
|
||||
|
||||
@Bean
|
||||
public RemotePartitioningWorkerStepBuilderFactory remotePartitioningWorkerStepBuilderFactory() {
|
||||
return new RemotePartitioningWorkerStepBuilderFactory(this.jobRepository,
|
||||
this.jobExplorer, this.transactionManager);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -23,24 +23,33 @@ import java.lang.annotation.Target;
|
||||
|
||||
import org.springframework.batch.integration.chunk.RemoteChunkingWorkerBuilder;
|
||||
import org.springframework.batch.integration.chunk.RemoteChunkingMasterStepBuilderFactory;
|
||||
import org.springframework.batch.integration.partition.RemotePartitioningMasterStepBuilderFactory;
|
||||
import org.springframework.batch.integration.partition.RemotePartitioningWorkerStepBuilderFactory;
|
||||
import org.springframework.context.annotation.Import;
|
||||
import org.springframework.integration.config.EnableIntegration;
|
||||
|
||||
/**
|
||||
* Enable Spring Batch Integration features and provide a base configuration for
|
||||
* setting up remote chunking infrastructure beans.
|
||||
* setting up remote chunking or partitioning infrastructure beans.
|
||||
*
|
||||
* By adding this annotation on a {@link org.springframework.context.annotation.Configuration}
|
||||
* class, it will be possible to autowire the following beans:
|
||||
*
|
||||
* <ul>
|
||||
* <li>{@link RemoteChunkingMasterStepBuilderFactory}:
|
||||
* used to create a master step by automatically setting up the job repository
|
||||
* and transaction manager.</li>
|
||||
* used to create a master step of a remote chunking setup by automatically
|
||||
* setting the job repository and transaction manager.</li>
|
||||
* <li>{@link RemoteChunkingWorkerBuilder}: used to create the integration
|
||||
* flow on the worker side.</li>
|
||||
* flow on the worker side of a remote chunking setup.</li>
|
||||
* <li>{@link RemotePartitioningMasterStepBuilderFactory}: used to create
|
||||
* a master step of a remote partitioning setup by automatically setting
|
||||
* the job repository, job explorer, bean factory and transaction manager.</li>
|
||||
* <li>{@link RemotePartitioningWorkerStepBuilderFactory}: used to create
|
||||
* a worker step of a remote partitioning setup by automatically setting
|
||||
* the job repository, job explorer, bean factory and transaction manager.</li>
|
||||
* </ul>
|
||||
*
|
||||
* For example:
|
||||
* For remote chunking, an example of a configuration class would be:
|
||||
*
|
||||
* <pre class="code">
|
||||
* @Configuration
|
||||
@@ -75,15 +84,60 @@ import org.springframework.context.annotation.Import;
|
||||
* .build();
|
||||
* }
|
||||
*
|
||||
* // Middleware beans omitted
|
||||
*
|
||||
* }
|
||||
* </pre>
|
||||
*
|
||||
* For remote partitioning, an example of a configuration class would be:
|
||||
*
|
||||
* <pre class="code">
|
||||
* @Configuration
|
||||
* @EnableBatchIntegration
|
||||
* @EnableBatchProcessing
|
||||
* public class RemotePartitioningAppConfig {
|
||||
*
|
||||
* @Autowired
|
||||
* private RemotePartitioningMasterStepBuilderFactory masterStepBuilderFactory;
|
||||
*
|
||||
* @Autowired
|
||||
* private RemotePartitioningWorkerStepBuilderFactory workerStepBuilderFactory;
|
||||
*
|
||||
* @Bean
|
||||
* public Step masterStep() {
|
||||
* return this.masterStepBuilderFactory
|
||||
* .get("masterStep")
|
||||
* .partitioner("workerStep", partitioner())
|
||||
* .gridSize(10)
|
||||
* .outputChannel(outgoingRequestsToWorkers())
|
||||
* .inputChannel(incomingRepliesFromWorkers())
|
||||
* .build();
|
||||
* }
|
||||
*
|
||||
* @Bean
|
||||
* public Step workerStep() {
|
||||
* return this.workerStepBuilderFactory
|
||||
* .get("workerStep")
|
||||
* .inputChannel(incomingRequestsFromMaster())
|
||||
* .outputChannel(outgoingRepliesToMaster())
|
||||
* .chunk(100)
|
||||
* .reader(itemReader())
|
||||
* .processor(itemProcessor())
|
||||
* .writer(itemWriter())
|
||||
* .build();
|
||||
* }
|
||||
*
|
||||
* // Middleware beans omitted
|
||||
*
|
||||
* }
|
||||
* </pre>
|
||||
* @since 4.1
|
||||
* @author Mahmoud Ben Hassine
|
||||
*/
|
||||
@Target(ElementType.TYPE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Documented
|
||||
@EnableIntegration
|
||||
@Import(BatchIntegrationConfiguration.class)
|
||||
public @interface EnableBatchIntegration {
|
||||
}
|
||||
|
||||
@@ -0,0 +1,297 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.batch.integration.partition;
|
||||
|
||||
import org.springframework.batch.core.Step;
|
||||
import org.springframework.batch.core.StepExecutionListener;
|
||||
import org.springframework.batch.core.explore.JobExplorer;
|
||||
import org.springframework.batch.core.partition.PartitionHandler;
|
||||
import org.springframework.batch.core.partition.StepExecutionSplitter;
|
||||
import org.springframework.batch.core.partition.support.Partitioner;
|
||||
import org.springframework.batch.core.partition.support.StepExecutionAggregator;
|
||||
import org.springframework.batch.core.repository.JobRepository;
|
||||
import org.springframework.batch.core.step.builder.PartitionStepBuilder;
|
||||
import org.springframework.batch.core.step.builder.StepBuilder;
|
||||
import org.springframework.beans.factory.BeanCreationException;
|
||||
import org.springframework.beans.factory.BeanFactory;
|
||||
import org.springframework.integration.channel.QueueChannel;
|
||||
import org.springframework.integration.core.MessagingTemplate;
|
||||
import org.springframework.integration.dsl.IntegrationFlows;
|
||||
import org.springframework.integration.dsl.StandardIntegrationFlow;
|
||||
import org.springframework.integration.dsl.context.IntegrationFlowContext;
|
||||
import org.springframework.messaging.MessageChannel;
|
||||
import org.springframework.messaging.PollableChannel;
|
||||
import org.springframework.transaction.PlatformTransactionManager;
|
||||
import org.springframework.util.Assert;
|
||||
|
||||
/**
|
||||
* Builder for a master step in a remote partitioning setup. This builder creates and
|
||||
* sets a {@link MessageChannelPartitionHandler} on the master step.
|
||||
*
|
||||
* <p>If no {@code messagingTemplate} is provided through
|
||||
* {@link RemotePartitioningMasterStepBuilder#messagingTemplate(MessagingTemplate)},
|
||||
* this builder will create one. The {@code outputChannel} set with
|
||||
* {@link RemotePartitioningMasterStepBuilder#outputChannel(MessageChannel)} will be
|
||||
* used as a default channel of the messaging template and will <strong>override any default
|
||||
* channel already set on the messaging template</strong>.
|
||||
*
|
||||
* @since 4.1
|
||||
* @author Mahmoud Ben Hassine
|
||||
*/
|
||||
public class RemotePartitioningMasterStepBuilder extends PartitionStepBuilder {
|
||||
|
||||
private static final long DEFAULT_POLL_INTERVAL = 10000L;
|
||||
private static final long DEFAULT_TIMEOUT = -1L;
|
||||
|
||||
private MessagingTemplate messagingTemplate;
|
||||
private MessageChannel inputChannel;
|
||||
private MessageChannel outputChannel;
|
||||
private JobExplorer jobExplorer;
|
||||
private BeanFactory beanFactory;
|
||||
private long pollInterval = DEFAULT_POLL_INTERVAL;
|
||||
private long timeout = DEFAULT_TIMEOUT;
|
||||
|
||||
/**
|
||||
* Create a new {@link RemotePartitioningMasterStepBuilder}.
|
||||
* @param stepName name of the master step
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilder(String stepName) {
|
||||
super(new StepBuilder(stepName));
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the input channel on which replies from workers will be received.
|
||||
* @param inputChannel the input channel
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilder inputChannel(MessageChannel inputChannel) {
|
||||
Assert.notNull(inputChannel, "inputChannel must not be null");
|
||||
this.inputChannel = inputChannel;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the output channel on which requests to workers will be sent.
|
||||
* The output channel will be set as a default channel on the provided
|
||||
* {@link MessagingTemplate} trough
|
||||
* {@link RemotePartitioningMasterStepBuilder#messagingTemplate(MessagingTemplate)}
|
||||
* (or the one created by this builder if no messaging template is provided).
|
||||
* @param outputChannel the output channel.
|
||||
* @return this builder instance for fluent chaining
|
||||
*
|
||||
* @see RemotePartitioningMasterStepBuilder#messagingTemplate(MessagingTemplate)
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilder outputChannel(MessageChannel outputChannel) {
|
||||
Assert.notNull(outputChannel, "outputChannel must not be null");
|
||||
this.outputChannel = outputChannel;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the {@link MessagingTemplate} to use to send data to workers.
|
||||
* <p><strong>The default destination of the messaging template will be
|
||||
* overridden by the output channel provided through
|
||||
* {@link RemotePartitioningMasterStepBuilder#outputChannel(MessageChannel)}</strong>.</p>
|
||||
*
|
||||
* @param messagingTemplate the messaging template to use
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilder messagingTemplate(MessagingTemplate messagingTemplate) {
|
||||
Assert.notNull(messagingTemplate, "messagingTemplate must not be null");
|
||||
this.messagingTemplate = messagingTemplate;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the job explorer.
|
||||
* @param jobExplorer the job explorer to use.
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilder jobExplorer(JobExplorer jobExplorer) {
|
||||
Assert.notNull(jobExplorer, "jobExplorer must not be null");
|
||||
this.jobExplorer = jobExplorer;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* How often to poll the job repository for the status of the workers. Defaults to 10 seconds.
|
||||
* @param pollInterval the poll interval value in milliseconds
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilder pollInterval(long pollInterval) {
|
||||
Assert.isTrue(pollInterval > 0, "The poll interval must be greater than zero");
|
||||
this.pollInterval = pollInterval;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* When using job repository polling, the time limit to wait. Defaults to -1 (no timeout).
|
||||
* @param timeout the timeout value in milliseconds
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilder timeout(long timeout) {
|
||||
this.timeout = timeout;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the bean factory.
|
||||
* @param beanFactory the bean factory to use
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilder beanFactory(BeanFactory beanFactory) {
|
||||
this.beanFactory = beanFactory;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Step build() {
|
||||
Assert.notNull(this.outputChannel, "An outputChannel must be provided");
|
||||
|
||||
// configure messaging template
|
||||
if (this.messagingTemplate == null) {
|
||||
this.messagingTemplate = new MessagingTemplate();
|
||||
}
|
||||
this.messagingTemplate.setDefaultChannel(this.outputChannel);
|
||||
|
||||
// Configure the partition handler
|
||||
final MessageChannelPartitionHandler partitionHandler = new MessageChannelPartitionHandler();
|
||||
partitionHandler.setStepName(getStepName());
|
||||
partitionHandler.setGridSize(getGridSize());
|
||||
partitionHandler.setMessagingOperations(this.messagingTemplate);
|
||||
|
||||
if (isPolling()) {
|
||||
partitionHandler.setJobExplorer(this.jobExplorer);
|
||||
partitionHandler.setPollInterval(this.pollInterval);
|
||||
partitionHandler.setTimeout(this.timeout);
|
||||
}
|
||||
else {
|
||||
PollableChannel replies = new QueueChannel();
|
||||
partitionHandler.setReplyChannel(replies);
|
||||
StandardIntegrationFlow standardIntegrationFlow = IntegrationFlows
|
||||
.from(this.inputChannel)
|
||||
.aggregate(aggregatorSpec -> aggregatorSpec.processor(partitionHandler))
|
||||
.channel(replies)
|
||||
.get();
|
||||
IntegrationFlowContext integrationFlowContext = this.beanFactory.getBean(IntegrationFlowContext.class);
|
||||
integrationFlowContext.registration(standardIntegrationFlow)
|
||||
.autoStartup(false)
|
||||
.register();
|
||||
}
|
||||
|
||||
try {
|
||||
partitionHandler.afterPropertiesSet();
|
||||
super.partitionHandler(partitionHandler);
|
||||
}
|
||||
catch (Exception e) {
|
||||
throw new BeanCreationException("Unable to create a master step for remote partitioning", e);
|
||||
}
|
||||
|
||||
return super.build();
|
||||
}
|
||||
|
||||
private boolean isPolling() {
|
||||
return this.inputChannel == null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder repository(JobRepository jobRepository) {
|
||||
super.repository(jobRepository);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder transactionManager(PlatformTransactionManager transactionManager) {
|
||||
super.transactionManager(transactionManager);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder partitioner(String slaveStepName, Partitioner partitioner) {
|
||||
super.partitioner(slaveStepName, partitioner);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder gridSize(int gridSize) {
|
||||
super.gridSize(gridSize);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder step(Step step) {
|
||||
super.step(step);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder splitter(StepExecutionSplitter splitter) {
|
||||
super.splitter(splitter);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder aggregator(StepExecutionAggregator aggregator) {
|
||||
super.aggregator(aggregator);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder startLimit(int startLimit) {
|
||||
super.startLimit(startLimit);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder listener(Object listener) {
|
||||
super.listener(listener);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder listener(StepExecutionListener listener) {
|
||||
super.listener(listener);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder allowStartIfComplete(boolean allowStartIfComplete) {
|
||||
super.allowStartIfComplete(allowStartIfComplete);
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method will throw a {@link UnsupportedOperationException} since
|
||||
* the partition handler of the master step will be automatically set to an
|
||||
* instance of {@link MessageChannelPartitionHandler}.
|
||||
*
|
||||
* When building a master step for remote partitioning using this builder,
|
||||
* no partition handler must be provided.
|
||||
*
|
||||
* @param partitionHandler a partition handler
|
||||
* @return this builder instance for fluent chaining
|
||||
* @throws UnsupportedOperationException if a partition handler is provided
|
||||
*/
|
||||
@Override
|
||||
public RemotePartitioningMasterStepBuilder partitionHandler(PartitionHandler partitionHandler) throws UnsupportedOperationException {
|
||||
throw new UnsupportedOperationException("When configuring a master step " +
|
||||
"for remote partitioning using the RemotePartitioningMasterStepBuilder, " +
|
||||
"the partition handler will be automatically set to an instance " +
|
||||
"of MessageChannelPartitionHandler. The partition handler must " +
|
||||
"not be provided in this case.");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.batch.integration.partition;
|
||||
|
||||
import org.springframework.batch.core.explore.JobExplorer;
|
||||
import org.springframework.batch.core.repository.JobRepository;
|
||||
import org.springframework.beans.BeansException;
|
||||
import org.springframework.beans.factory.BeanFactory;
|
||||
import org.springframework.beans.factory.BeanFactoryAware;
|
||||
import org.springframework.transaction.PlatformTransactionManager;
|
||||
|
||||
/**
|
||||
* Convenient factory for a {@link RemotePartitioningMasterStepBuilder} which sets
|
||||
* the {@link JobRepository}, {@link JobExplorer}, {@link BeanFactory} and
|
||||
* {@link PlatformTransactionManager} automatically.
|
||||
*
|
||||
* @since 4.1
|
||||
* @author Mahmoud Ben Hassine
|
||||
*/
|
||||
public class RemotePartitioningMasterStepBuilderFactory implements BeanFactoryAware {
|
||||
|
||||
private BeanFactory beanFactory;
|
||||
final private JobExplorer jobExplorer;
|
||||
final private JobRepository jobRepository;
|
||||
final private PlatformTransactionManager transactionManager;
|
||||
|
||||
|
||||
/**
|
||||
* Create a new {@link RemotePartitioningMasterStepBuilderFactory}.
|
||||
* @param jobRepository the job repository to use
|
||||
* @param jobExplorer the job explorer to use
|
||||
* @param transactionManager the transaction manager to use
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilderFactory(JobRepository jobRepository,
|
||||
JobExplorer jobExplorer, PlatformTransactionManager transactionManager) {
|
||||
|
||||
this.jobRepository = jobRepository;
|
||||
this.jobExplorer = jobExplorer;
|
||||
this.transactionManager = transactionManager;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
|
||||
this.beanFactory = beanFactory;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a {@link RemotePartitioningMasterStepBuilder} and initializes its job
|
||||
* repository, job explorer, bean factory and transaction manager.
|
||||
* @param name the name of the step
|
||||
* @return a {@link RemotePartitioningMasterStepBuilder}
|
||||
*/
|
||||
public RemotePartitioningMasterStepBuilder get(String name) {
|
||||
return new RemotePartitioningMasterStepBuilder(name)
|
||||
.repository(this.jobRepository)
|
||||
.jobExplorer(this.jobExplorer)
|
||||
.beanFactory(this.beanFactory)
|
||||
.transactionManager(this.transactionManager);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,258 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.batch.integration.partition;
|
||||
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
|
||||
import org.springframework.batch.core.Job;
|
||||
import org.springframework.batch.core.Step;
|
||||
import org.springframework.batch.core.StepExecutionListener;
|
||||
import org.springframework.batch.core.explore.JobExplorer;
|
||||
import org.springframework.batch.core.job.flow.Flow;
|
||||
import org.springframework.batch.core.partition.support.Partitioner;
|
||||
import org.springframework.batch.core.repository.JobRepository;
|
||||
import org.springframework.batch.core.step.StepLocator;
|
||||
import org.springframework.batch.core.step.builder.FlowStepBuilder;
|
||||
import org.springframework.batch.core.step.builder.JobStepBuilder;
|
||||
import org.springframework.batch.core.step.builder.PartitionStepBuilder;
|
||||
import org.springframework.batch.core.step.builder.SimpleStepBuilder;
|
||||
import org.springframework.batch.core.step.builder.StepBuilder;
|
||||
import org.springframework.batch.core.step.builder.TaskletStepBuilder;
|
||||
import org.springframework.batch.core.step.tasklet.Tasklet;
|
||||
import org.springframework.batch.repeat.CompletionPolicy;
|
||||
import org.springframework.beans.factory.BeanFactory;
|
||||
import org.springframework.integration.channel.NullChannel;
|
||||
import org.springframework.integration.dsl.IntegrationFlow;
|
||||
import org.springframework.integration.dsl.IntegrationFlows;
|
||||
import org.springframework.integration.dsl.StandardIntegrationFlow;
|
||||
import org.springframework.integration.dsl.context.IntegrationFlowContext;
|
||||
import org.springframework.messaging.MessageChannel;
|
||||
import org.springframework.transaction.PlatformTransactionManager;
|
||||
import org.springframework.util.Assert;
|
||||
|
||||
/**
|
||||
* Builder for a worker step in a remote partitioning setup. This builder
|
||||
* creates an {@link IntegrationFlow} that:
|
||||
*
|
||||
* <ul>
|
||||
* <li>listens to {@link StepExecutionRequest}s coming from the master
|
||||
* on the input channel</li>
|
||||
* <li>invokes the {@link StepExecutionRequestHandler} to execute the worker
|
||||
* step for each incoming request. The worker step is located using the provided
|
||||
* {@link StepLocator}. If no {@link StepLocator} is provided, a {@link BeanFactoryStepLocator}
|
||||
* configured with the current {@link BeanFactory} will be used
|
||||
* <li>replies to the master on the output channel (when the master step is
|
||||
* configured to aggregate replies from workers). If no output channel
|
||||
* is provided, a {@link NullChannel} will be used (assuming the master side
|
||||
* is configured to poll the job repository for workers status)</li>
|
||||
* </ul>
|
||||
*
|
||||
* @since 4.1
|
||||
* @author Mahmoud Ben Hassine
|
||||
*/
|
||||
public class RemotePartitioningWorkerStepBuilder extends StepBuilder {
|
||||
|
||||
private static final String SERVICE_ACTIVATOR_METHOD_NAME = "handle";
|
||||
private static final Log logger = LogFactory.getLog(RemotePartitioningWorkerStepBuilder.class);
|
||||
|
||||
private MessageChannel inputChannel;
|
||||
private MessageChannel outputChannel;
|
||||
private JobExplorer jobExplorer;
|
||||
private StepLocator stepLocator;
|
||||
private BeanFactory beanFactory;
|
||||
|
||||
/**
|
||||
* Initialize a step builder for a step with the given name.
|
||||
* @param name the name of the step
|
||||
*/
|
||||
public RemotePartitioningWorkerStepBuilder(String name) {
|
||||
super(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the input channel on which step execution requests sent by the master
|
||||
* are received.
|
||||
* @param inputChannel the input channel
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningWorkerStepBuilder inputChannel(MessageChannel inputChannel) {
|
||||
Assert.notNull(inputChannel, "inputChannel must not be null");
|
||||
this.inputChannel = inputChannel;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the output channel on which replies will be sent to the master step.
|
||||
* @param outputChannel the input channel
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningWorkerStepBuilder outputChannel(MessageChannel outputChannel) {
|
||||
Assert.notNull(outputChannel, "outputChannel must not be null");
|
||||
this.outputChannel = outputChannel;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the job explorer.
|
||||
* @param jobExplorer the job explorer to use
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningWorkerStepBuilder jobExplorer(JobExplorer jobExplorer) {
|
||||
Assert.notNull(jobExplorer, "jobExplorer must not be null");
|
||||
this.jobExplorer = jobExplorer;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the step locator used to locate the worker step to execute.
|
||||
* @param stepLocator the step locator to use
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningWorkerStepBuilder stepLocator(StepLocator stepLocator) {
|
||||
Assert.notNull(stepLocator, "stepLocator must not be null");
|
||||
this.stepLocator = stepLocator;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the bean factory.
|
||||
* @param beanFactory the bean factory
|
||||
* @return this builder instance for fluent chaining
|
||||
*/
|
||||
public RemotePartitioningWorkerStepBuilder beanFactory(BeanFactory beanFactory) {
|
||||
Assert.notNull(beanFactory, "beanFactory must not be null");
|
||||
this.beanFactory = beanFactory;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningWorkerStepBuilder repository(JobRepository jobRepository) {
|
||||
super.repository(jobRepository);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningWorkerStepBuilder transactionManager(PlatformTransactionManager transactionManager) {
|
||||
super.transactionManager(transactionManager);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningWorkerStepBuilder startLimit(int startLimit) {
|
||||
super.startLimit(startLimit);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningWorkerStepBuilder listener(Object listener) {
|
||||
super.listener(listener);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningWorkerStepBuilder listener(StepExecutionListener listener) {
|
||||
super.listener(listener);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RemotePartitioningWorkerStepBuilder allowStartIfComplete(boolean allowStartIfComplete) {
|
||||
super.allowStartIfComplete(allowStartIfComplete);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public TaskletStepBuilder tasklet(Tasklet tasklet) {
|
||||
configureWorkerIntegrationFlow();
|
||||
return super.tasklet(tasklet);
|
||||
}
|
||||
|
||||
@Override
|
||||
public <I, O> SimpleStepBuilder<I, O> chunk(int chunkSize) {
|
||||
configureWorkerIntegrationFlow();
|
||||
return super.chunk(chunkSize);
|
||||
}
|
||||
|
||||
@Override
|
||||
public <I, O> SimpleStepBuilder<I, O> chunk(CompletionPolicy completionPolicy) {
|
||||
configureWorkerIntegrationFlow();
|
||||
return super.chunk(completionPolicy);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PartitionStepBuilder partitioner(String stepName, Partitioner partitioner) {
|
||||
configureWorkerIntegrationFlow();
|
||||
return super.partitioner(stepName, partitioner);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PartitionStepBuilder partitioner(Step step) {
|
||||
configureWorkerIntegrationFlow();
|
||||
return super.partitioner(step);
|
||||
}
|
||||
|
||||
@Override
|
||||
public JobStepBuilder job(Job job) {
|
||||
configureWorkerIntegrationFlow();
|
||||
return super.job(job);
|
||||
}
|
||||
|
||||
@Override
|
||||
public FlowStepBuilder flow(Flow flow) {
|
||||
configureWorkerIntegrationFlow();
|
||||
return super.flow(flow);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an {@link IntegrationFlow} with a {@link StepExecutionRequestHandler}
|
||||
* configured as a service activator listening to the input channel and replying
|
||||
* on the output channel.
|
||||
*/
|
||||
private void configureWorkerIntegrationFlow() {
|
||||
Assert.notNull(this.inputChannel, "An InputChannel must be provided");
|
||||
Assert.notNull(this.jobExplorer, "A JobExplorer must be provided");
|
||||
|
||||
if (this.stepLocator == null) {
|
||||
BeanFactoryStepLocator beanFactoryStepLocator = new BeanFactoryStepLocator();
|
||||
beanFactoryStepLocator.setBeanFactory(this.beanFactory);
|
||||
this.stepLocator = beanFactoryStepLocator;
|
||||
}
|
||||
if (this.outputChannel == null) {
|
||||
if (logger.isDebugEnabled()) {
|
||||
logger.debug("The output channel is set to a NullChannel. " +
|
||||
"The master step must poll the job repository for workers status.");
|
||||
}
|
||||
this.outputChannel = new NullChannel();
|
||||
}
|
||||
|
||||
StepExecutionRequestHandler stepExecutionRequestHandler = new StepExecutionRequestHandler();
|
||||
stepExecutionRequestHandler.setJobExplorer(this.jobExplorer);
|
||||
stepExecutionRequestHandler.setStepLocator(this.stepLocator);
|
||||
|
||||
StandardIntegrationFlow standardIntegrationFlow = IntegrationFlows
|
||||
.from(this.inputChannel)
|
||||
.handle(stepExecutionRequestHandler, SERVICE_ACTIVATOR_METHOD_NAME)
|
||||
.channel(this.outputChannel)
|
||||
.get();
|
||||
IntegrationFlowContext integrationFlowContext = this.beanFactory.getBean(IntegrationFlowContext.class);
|
||||
integrationFlowContext.registration(standardIntegrationFlow)
|
||||
.autoStartup(false)
|
||||
.register();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.batch.integration.partition;
|
||||
|
||||
import org.springframework.batch.core.explore.JobExplorer;
|
||||
import org.springframework.batch.core.repository.JobRepository;
|
||||
import org.springframework.beans.BeansException;
|
||||
import org.springframework.beans.factory.BeanFactory;
|
||||
import org.springframework.beans.factory.BeanFactoryAware;
|
||||
import org.springframework.transaction.PlatformTransactionManager;
|
||||
|
||||
/**
|
||||
* Convenient factory for a {@link RemotePartitioningWorkerStepBuilder} which sets
|
||||
* the {@link JobRepository}, {@link JobExplorer}, {@link BeanFactory} and
|
||||
* {@link PlatformTransactionManager} automatically.
|
||||
*
|
||||
* @since 4.1
|
||||
* @author Mahmoud Ben Hassine
|
||||
*/
|
||||
public class RemotePartitioningWorkerStepBuilderFactory implements BeanFactoryAware {
|
||||
|
||||
private BeanFactory beanFactory;
|
||||
final private JobExplorer jobExplorer;
|
||||
final private JobRepository jobRepository;
|
||||
final private PlatformTransactionManager transactionManager;
|
||||
|
||||
|
||||
/**
|
||||
* Create a new {@link RemotePartitioningWorkerStepBuilderFactory}.
|
||||
* @param jobRepository the job repository to use
|
||||
* @param jobExplorer the job explorer to use
|
||||
* @param transactionManager the transaction manager to use
|
||||
*/
|
||||
public RemotePartitioningWorkerStepBuilderFactory(JobRepository jobRepository,
|
||||
JobExplorer jobExplorer,
|
||||
PlatformTransactionManager transactionManager) {
|
||||
|
||||
this.jobExplorer = jobExplorer;
|
||||
this.jobRepository = jobRepository;
|
||||
this.transactionManager = transactionManager;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
|
||||
this.beanFactory = beanFactory;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a {@link RemotePartitioningWorkerStepBuilder} and initializes its job
|
||||
* repository, job explorer, bean factory and transaction manager.
|
||||
* @param name the name of the step
|
||||
* @return a {@link RemotePartitioningWorkerStepBuilder}
|
||||
*/
|
||||
public RemotePartitioningWorkerStepBuilder get(String name) {
|
||||
return new RemotePartitioningWorkerStepBuilder(name)
|
||||
.repository(this.jobRepository)
|
||||
.jobExplorer(this.jobExplorer)
|
||||
.beanFactory(this.beanFactory)
|
||||
.transactionManager(this.transactionManager);
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user