亚洲高清毛片一区二区,久久亚洲精品无码av,久久亚洲AV成人出白浆无码国产

paulwong — Tue, 23 Mar 2021 02:30:00 GMT

Excel 在读�?csv 的时候是通过��d��文�g头上�?bom 来识别编码的�Q�这��D��如果我们生成 csv 文�g的��^台输出无 bom 头编码的 csv 文�g�Q�例�?utf-8 �Q�在标准中默认是可以没有 bom 头的�Q�，Excel 只能自动按照默认�~�码��d��Q�不一致就�?x��)出��Cؕ码问题�(sh��)��(ji��n)�?br />
掌握�?ji��n)这点相信�ؕ码已�l�无法阻挡我们前�q�的步伐�?ji��n)�?x��)只需��不�?bom 头编码的 csv 文�g�Q�用文本�~�辑器（工具随意�Q�推�?notepad++ �Q�打开�q��{换�ؓ(f��)�?bom 的编码�Ş式（具体�~�码方式随意�Q�，问题解决�?br />
当然�Q�如果你是像我一��L(f��ng)��码农哥哥�Q�在生成 csv 文�g的时候写�?bom 头更直接点，用户�?x��)感谢你的�?br />
附录�Q�对�?utf-8 �~�码�Q�unicode 标准中是没有 bom 定义的，微��Y在自��q�� utf-8 格式的文本文件之前加上了(ji��n)EF BB BF三个字节作�ؓ(f��)识别此编码的 bom ��_(d��)��q�也解释�?ji��n)��?f��)啥大部分��q��都是 utf-8 �~�码��D��的原�?br />
SPRING BATCH中生成CSV文�g时的解决�Ҏ(gu��)��Q?br />

new FlatFileItemWriterBuilder()
      .name(itemWriterName)
      .resource(outputResource)
      .lineAggregator(lineAggregator)
      .headerCallback(
      h -> {
               System.out.println(header);
               h.write('\uFEFF');//只需加这一�?/span>
               h.write(header);
           }
      )
      .build();

https://stackoverflow.com/questions/48952319/send-csv-file-encoded-in-utf-8-with-bom-in-java

paulwong 2021-03-23 10:30 发表评论

SPRING BATCH中STEP如果没加TRANSACTION MANAGER

paulwong — Mon, 16 Mar 2020 01:43:00 GMT

�q�时发现如果处理��L��_��大时�Q�被处理的ITEMS��L��?x��)少于应该处理的��L��?br />

+------------+--------------+-------------+-----------------+------------------+--------------------+----------------+-----------+-------------------------

-+------------+--------------+-------------+-----------------+------------------+--------------------+----------------+-----------+-------------------------

| 1 | 0 | 1 | 0 | 0 | 0 | 0 | COMPLETED |

| 30006 | 0 | 29947 | 0 | 59 | 0 | 61 | COMPLETED | Waited for 101 results.

如上面的��L��?0006�Q�但COMMIT的��L��?9947�Q�有59个被跌��?ji��n)�?br />
因此需在STEP上加TRANSACTION MANAGER.

https://stackoverflow.com/questions/42803941/spring-batch-incorrect-write-skip-count-issue

paulwong 2020-03-16 09:43 发表评论

使用 Spring Batch 构徏企业�U�批处理应用-2

paulwong — Fri, 06 Mar 2020 05:47:00 GMT

摘要: 前言在本�p�d��文章的第 1 部分�Q�我们搭��Z��(ji��n)一个用��L(f��ng)��贚w��知的批处理��d��。尽��这个简单的应用展现�?Spring Batch 的基本功能，但是它与真实的应用相�ȝ��q�。在实际应用中，我们�?Job 可能必须要包含多�?Step�Q��ؓ(f��)�?ji��n)提高性能�Q�我们可能需要考虑 Job 的�ƈ发问题。Spring Batch 在这些方面又提供�?ji��n)哪些好的特性呢�Q�让我们�l�箋(hu��)。Step Flow通过前文我们已经知道�Q�Step �?.. 阅读全文

paulwong 2020-03-06 13:47 发表评论

使用 Spring Batch 构徏企业�U�批处理应用-1

paulwong — Fri, 06 Mar 2020 05:45:00 GMT

摘要: 引言总述本系列文章旨在通过�C�Z��搭徏以及(qi��ng)�Ҏ(gu��)��介�l�，详细讲述如何利用 Spring Batch 开发企业批处理应用。本�p�d��文章共分��Z��部分�Q�第一部分初步介绍�?ji��n)批处理以�?qi��ng) Spring Batch 的相��x(ch��ng)��念，同时搭徏�?ji��n)一个简单的��Z�� Spring Batch 的批处理应用。第二部分介�l�了(ji��n) Step Flow 以及(qi��ng)�q�发支持。第三部分则主要介绍�?Spring Batch 对�Q务监控的支持。下面让我们�q�入... 阅读全文

paulwong 2020-03-06 13:45 发表评论

配置SPRING BATCH中的JUNIT TEST

paulwong — Mon, 03 Feb 2020 08:47:00 GMT

关键是JobLauncherTestUtils的配�|�：(x��)

@Configuration
    public class BatchTestConfiguration {


        @Bean
        public JobLauncherTestUtils stoppedReportJobLauncherTestUtils(
                JobLauncher stoppedReportJobLauncher
        ) {
            return new JobLauncherTestUtils() {

                @Autowired
                public void setJobLauncher(JobLauncher stoppedReportJobLauncher) {
                    super.setJobLauncher(stoppedReportJobLauncher);
                }

                @Autowired
                public void setJob(Job stoppedReportJob) {
                    super.setJob(stoppedReportJob);
                }

            };
        }
    }

paulwong 2020-02-03 16:47 发表评论

Transform RemoteChunk to remote with json format in Spring Batch

paulwong — Tue, 21 Jan 2020 08:44:00 GMT

Spring Batch Remote Chunk模式下，�q�程执行JOB�Ӟ��传输的对象是ChunkRequest/ChunkResponse�Q�无法�{成JSON格式传输�?br />
注意此处使用的是SPRING JACKSON�Q�而不是JACKSON。一般是在SPRING INTEGRATIONA框架下�{的�?br />
需要自定义Transformer�Q?br />
JsonToChunkRequestTransformer.java

package com.frandorado.springbatchawsintegrationslave.transformer;

import java.io.IOException;
import java.util.Collection;
import java.util.Map;
import java.util.stream.IntStream;

import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.integration.chunk.ChunkRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.integration.aws.support.AwsHeaders;
import org.springframework.integration.json.JsonToObjectTransformer;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

import com.amazonaws.services.sqs.AmazonSQSAsync;
import com.fasterxml.jackson.databind.ObjectMapper;

@Component
public class JsonToChunkRequestTransformer extends JsonToObjectTransformer {

    private static final String MESSAGE_GROUP_ID_HEADER = "message-group-id";

    @Autowired
    AmazonSQSAsync amazonSQSAsync;

    @Override
    protected Object doTransform(Message message) throws Exception {
        // ACK
        ack(message);

        return this.getMessageBuilderFactory().withPayload(buildChunkRequest(message)).setHeader(MESSAGE_GROUP_ID_HEADER, "unique").build();
    }

    private ChunkRequest buildChunkRequest(Message message) throws IOException {
        Map map = new ObjectMapper().readValue(message.getPayload().toString(), Map.class);
        Map stepContributionMap = (Map) map.get("stepContribution");
        Map exitStatusMap = (Map) stepContributionMap.get("exitStatus");

        StepContribution stepContribution = new StepContribution(new StepExecution("null", null));
        ExitStatus exitStatus = new ExitStatus((String) exitStatusMap.get("exitCode"), (String) exitStatusMap.get("exitDescription"));

        IntStream.range(0, (Integer) stepContributionMap.get("readCount")).forEach(e -> stepContribution.incrementReadCount());
        stepContribution.incrementWriteCount((Integer) stepContributionMap.get("writeCount"));
        stepContribution.incrementFilterCount((Integer) stepContributionMap.get("filterCount"));
        stepContribution.incrementReadSkipCount((Integer) stepContributionMap.get("readSkipCount"));
        IntStream.range(0, (Integer) stepContributionMap.get("writeSkipCount")).forEach(e -> stepContribution.incrementWriteSkipCount());
        IntStream.range(0, (Integer) stepContributionMap.get("processSkipCount"))
                .forEach(e -> stepContribution.incrementProcessSkipCount());
        stepContribution.setExitStatus(exitStatus);

        return new ChunkRequest((Integer) map.get("sequence"), (Collection) map.get("items"), (Integer) map.get("jobId"), stepContribution);
    }

    private void ack(Message message) {
        String receiptHandle = message.getHeaders().get(AwsHeaders.RECEIPT_HANDLE, String.class);
        String queue = message.getHeaders().get(AwsHeaders.QUEUE, String.class);
        String queueUrl = amazonSQSAsync.getQueueUrl(queue).getQueueUrl();

        amazonSQSAsync.deleteMessage(queueUrl, receiptHandle);
    }
}

JsonToChunkResponseTransformer.java

package com.frandorado.springbatchawsintegrationmaster.transformer;

import java.io.IOException;
import java.util.Map;

import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.integration.chunk.ChunkResponse;
import org.springframework.integration.json.JsonToObjectTransformer;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

import com.fasterxml.jackson.databind.ObjectMapper;

@Component
public class JsonToChunkResponseTransformer extends JsonToObjectTransformer {

    @Override
    protected Object doTransform(Message message) throws Exception {
        return buildChunkResponse(message);
    }

    private ChunkResponse buildChunkResponse(Message message) throws IOException {
        Map map = new ObjectMapper().readValue(message.getPayload().toString(), Map.class);

        Integer jobId = (Integer) map.get("jobId");
        Integer sequence = (Integer) map.get("sequence");
        String messageContent = (String) map.get("message");
        Boolean status = (Boolean) map.get("successful");

        StepContribution stepContribution = new StepContribution(new StepExecution("-", null));

        return new ChunkResponse(status, sequence, Long.valueOf(jobId), stepContribution, messageContent);
    }
}

�q�有一�U�方式，��是如果�W�三�c�M��支持转JSON�Q�即代码里没有JACKSON的注解，可以采用MIXIN的方式：(x��)

StepExecutionJacksonMixIn.java

package org.springframework.cloud.dataflow.rest.client.support;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.batch.core.StepExecution;

/**
* Jackson MixIn for {@link StepExecution} de-serialization.
*
* @author Gunnar Hillert
* @since 1.0
*/
@JsonIgnoreProperties({ "jobExecution", "jobParameters", "jobExecutionId", "skipCount", "summary" })
public abstract class StepExecutionJacksonMixIn {

    @JsonCreator
    StepExecutionJacksonMixIn(@JsonProperty("stepName") String stepName) {
    }

}

在配�|�文件中注册才能使用�Q?br />

JacksonConfiguration.java

import java.util.Locale;
import java.util.TimeZone;

import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobInstance;
import org.springframework.batch.core.JobParameter;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.item.ExecutionContext;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.support.json.Jackson2JsonObjectMapper;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.novacredit.bmb.batchmonitor.springbatch.common.batch.jackson.ISO8601DateFormatWithMilliSeconds;
import com.novacredit.bmb.batchmonitor.springbatch.common.batch.jackson.mixin.ExecutionContextJacksonMixIn;
import com.novacredit.bmb.batchmonitor.springbatch.common.batch.jackson.mixin.ExitStatusJacksonMixIn;
import com.novacredit.bmb.batchmonitor.springbatch.common.batch.jackson.mixin.JobExecutionJacksonMixIn;
import com.novacredit.bmb.batchmonitor.springbatch.common.batch.jackson.mixin.JobInstanceJacksonMixIn;
import com.novacredit.bmb.batchmonitor.springbatch.common.batch.jackson.mixin.JobParameterJacksonMixIn;
import com.novacredit.bmb.batchmonitor.springbatch.common.batch.jackson.mixin.JobParametersJacksonMixIn;
import com.novacredit.bmb.batchmonitor.springbatch.common.batch.jackson.mixin.StepExecutionJacksonMixIn;

@Configuration
public class JacksonConfiguration {

    @Bean
    public Jackson2JsonObjectMapper jackson2JsonObjectMapper(ObjectMapper objectMapper) {
        return new Jackson2JsonObjectMapper(objectMapper);
    }

    @Bean
    public Jackson2ObjectMapperBuilderCustomizer dataflowObjectMapperBuilderCustomizer() {
        return (builder) -> {
            builder.dateFormat(new ISO8601DateFormatWithMilliSeconds(TimeZone.getDefault(), Locale.getDefault(), true));
            // apply SCDF Batch Mixins to
            // ignore the JobExecution in StepExecution to prevent infinite loop.
            // https://github.com/spring-projects/spring-hateoas/issues/333
            builder.mixIn(StepExecution.class, StepExecutionJacksonMixIn.class);
            builder.mixIn(ExecutionContext.class, ExecutionContextJacksonMixIn.class);
            builder.mixIn(JobExecution.class, JobExecutionJacksonMixIn.class);
            builder.mixIn(JobParameters.class, JobParametersJacksonMixIn.class);
            builder.mixIn(JobParameter.class, JobParameterJacksonMixIn.class);
            builder.mixIn(JobInstance.class, JobInstanceJacksonMixIn.class);
//            builder.mixIn(StepExecutionHistory.class, StepExecutionHistoryJacksonMixIn.class);
            builder.mixIn(ExecutionContext.class, ExecutionContextJacksonMixIn.class);
            builder.mixIn(ExitStatus.class, ExitStatusJacksonMixIn.class);
//            objectMapper.setDateFormat(new ISO8601DateFormatWithMilliSeconds());
            builder.modules(new JavaTimeModule(), new Jdk8Module());
        };
    }
}

@Bean
    public IntegrationFlow flow4Contribution(
            ConnectionFactory connectionFactory,
            JobProperties jobProperties,
            Jackson2JsonObjectMapper jackson2JsonObjectMapper
    ) {
        return IntegrationFlows
                    .from(request4ContributionMaster())
                    .enrichHeaders(headerEnricherConfigurer())
                    .transform(Transformers.toJson(jackson2JsonObjectMapper))
                    .handle(jmsOutboundGateway4Contribution(connectionFactory, jobProperties))
                    .transform(Transformers.fromJson(StepExecution.class, jackson2JsonObjectMapper))
                    .channel(replies4ContributionMaster(null))
                    .get();
    }

https://github.com/spring-cloud/spring-cloud-dataflow/tree/master/spring-cloud-dataflow-rest-client/src/main/java/org/springframework/cloud/dataflow/rest/client/support

https://frandorado.github.io/spring/2019/07/29/spring-batch-aws-series-introduction.html

https://github.com/frandorado/spring-projects/tree/master/spring-batch-aws-integration/spring-batch-aws-integration-master/src/main/java/com/frandorado/springbatchawsintegrationmaster/transformer

https://github.com/frandorado/spring-projects/tree/master/spring-batch-aws-integration/spring-batch-aws-integration-slave/src/main/java/com/frandorado/springbatchawsintegrationslave/transformer

paulwong 2020-01-21 16:44 发表评论

Spring Batch JUnit test for multiple jobs

paulwong — Wed, 31 Jul 2019 02:48:00 GMT

https://stackoverflow.com/questions/34217101/spring-batch-junit-test-for-multiple-jobs

@Configuration
public class TestBatchConfiguration implements MergedBeanDefinitionPostProcessor {

    @Autowired
    @Qualifier("JobA")
    private Job job;

    @Bean(name="jtestl")
    public JobLauncherTestUtils jobLauncherTestUtils() {
        JobLauncherTestUtils jobLauncherTestUtils = new JobLauncherTestUtils();
        jobLauncherTestUtils.setJob(job);
        return jobLauncherTestUtils;
    }

    /**
     * https://stackoverflow.com/questions/22416140/autowire-setter-override-with-java-config
     * This is needed to inject the correct job into JobLauncherTestUtils
     */
    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
        if(beanName.equals("jtestl")) {
            beanDefinition.getPropertyValues().add("job", getMyBeanFirstAImpl());
        }
    }

    private Object getMyBeanFirstAImpl() {
        return job;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

paulwong 2019-07-31 10:48 发表评论

SPRING BATCH & SPRING INTEGRATION TUTORIAL

paulwong — Thu, 18 Jul 2019 05:21:00 GMT

Spring JMS Integration Gateway Example 12 minute read

A detailed step-by-step tutorial on how to connect to a JMS broker using a Spring Integration Gateway and Spring Boot.

Spring JMS Artemis Example 6 minute read

A detailed step-by-step tutorial on how to connect to Apache ActiveMQ Artemis using Spring JMS and Spring Boot.

Spring JMS Topic Example 5 minute read

A detailed step-by-step tutorial on how to publish/subscribe to a JMS topic using Spring JMS and Spring Boot.

Spring JMS Integration Example12 minute read

A detailed step-by-step tutorial on how to connect to an ActiveMQ JMS broker using Spring Integration and Spring Boot.

Spring JMS Listener Example 7 minute read

A detailed step-by-step tutorial on how a Spring JMS listener works in combination with Spring Boot.

Spring JMS JmsTemplate Example 7 minute read

A detailed step-by-step tutorial on how to use JmsTemplate in combination with Spring JMS and Spring Boot.

Spring JMS Message Selector Example 5 minute read

A detailed step-by-step tutorial on how to implement a message selector using Spring JMS and Spring Boot.

Spring JMS Message Converter Example5 minute read

A detailed step-by-step tutorial on how to implement a message converter using Spring JMS and Spring Boot.

Spring Batch Admin Example 11 minute read

A detailed step-by-step tutorial on how to use a Spring Boot admin UI to manage Spring Batch jobs.

Spring Batch Tasklet Example 7 minute read

A detailed step-by-step tutorial on how to implement a Spring Batch Tasklet using Spring Boot.

Spring Batch Example 11 minute read

A detailed step-by-step tutorial on how to implement a Hello World Spring Batch job using Spring Boot.

paulwong 2019-07-18 13:21 发表评论

paulwong — Tue, 16 Jul 2019 06:38:00 GMT

SPRING BATCH remote chunking模式下，如果要同一旉��处理多个文�g�Q�按DEMO的默认配�|�，是会(x��)报错的，�q�是�׃��多个文�g的处理的MASTER方，是用同一个QUEUE名，�q�样SLAVE中处理多个JOB INSTANCE�Ӟ��?x��)返回不同的JOB-INSTANCE-ID�Q�导致报错�?br />
�q�时需更改SPRING BATCH使用SPRING INTEGRATION的模式中的GATEWAY�l��g�?br />
GATEWAY�l��g是工作在REQUEST/RESPONSE模式下，卛_��一个MESSAGE到某一QUEUE�Ӟ��要从REPLY QUEUE�{�到CONSUMER�q�回�l�果�Ӟ��才往(xi��n)下��(h��)�l��?br />
OUTBOUND GATEWAY�Q�从某一CHANNEL获取MESSAGE�Q�发往(xi��n)REQUEST QUEUE�Q�从REPLY QUEUE�{�到CONSUMER�q�回�l�果�Q�将此MESSAGE发往(xi��n)下一CHANNEL�?br />
INBOUND GATEWAY�Q�从某一QUEUE获取MESSAGE�Q�发往(xi��n)某一REQUEST CHANNEL�Q�从REPLY CHANNEL�{�到�q�回�l�果�Q�将此MESSAGE发往(xi��n)下一QUEUE�?br />
详情参见此文�Q?a target="_blank">https://blog.csdn.net/alexlau8/article/details/78056064�?br />

    <int:channel id="MasterRequestChannel">
        <int:dispatcher task-executor="RequestPublishExecutor"/>
    int:channel>
    <task:executor id="RequestPublishExecutor" pool-size="5-10" queue-capacity="0"/>

    <int:channel id="MasterReplyChannel"/>

    <int-jms:outbound-gateway
        connection-factory="connectionFactory"
        correlation-key="JMSCorrelationID"
        request-channel="MasterRequestChannel"
        request-destination-name="RequestQueue"
        receive-timeout="30000"
        reply-channel="MasterReplyChannel"
        reply-destination-name="ReplyQueue"
        async="true">
        <int-jms:reply-listener />
    int-jms:outbound-gateway>


    <int:channel id="SlaveRequestChannel"/>

    <int:channel id="SlaveReplyChannel"/>

    <int-jms:inbound-gateway
        connection-factory="connectionFactory"
        correlation-key="JMSCorrelationID"
        request-channel="SlaveRequestChannel"
        request-destination-name="RequestQueue"
        reply-channel="SlaveReplyChannel"
        default-reply-queue-name="ReplyQueue"/>

MASTER配置

package com.paul.testspringbatch.config.master;

import javax.jms.ConnectionFactory;

import org.springframework.beans.factory.config.CustomScopeConfigurer;
//import org.springframework.batch.core.configuration.annotation.StepScope;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.context.annotation.Scope;
import org.springframework.context.support.SimpleThreadScope;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.integration.config.EnableIntegration;
import org.springframework.integration.dsl.IntegrationFlow;
import org.springframework.integration.dsl.IntegrationFlows;
import org.springframework.integration.jms.JmsOutboundGateway;

import com.paul.testspringbatch.common.constant.IntegrationConstant;

@Configuration
@EnableIntegration
@Profile("batch-master")
public class IntegrationMasterConfiguration {

//    @Value("${broker.url}")
//    private String brokerUrl;

//    @Bean
//    public ActiveMQConnectionFactory connectionFactory() {
//        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
//        connectionFactory.setBrokerURL(this.brokerUrl);
//        connectionFactory.setTrustAllPackages(true);
//        return connectionFactory;
//    }

    /*
     * Configure outbound flow (requests going to workers)
     */
    @Bean
//    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public DirectChannel requests() {
        return new DirectChannel();
    }

//    @Bean
//    public IntegrationFlow outboundFlow(ConnectionFactory connectionFactory) {
//        return IntegrationFlows
//                .from(requests())
//                .handle(Jms.outboundAdapter(connectionFactory).destination(IntegrationConstant.MASTER_REQUEST_DESTINATION))
//                .get();
//    }

     @Bean
     public CustomScopeConfigurer customScopeConfigurer() {
         CustomScopeConfigurer customScopeConfigurer = new CustomScopeConfigurer();
         customScopeConfigurer.addScope("thread", new SimpleThreadScope());
         return customScopeConfigurer;
     }

//     @Bean
//     public static BeanFactoryPostProcessor beanFactoryPostProcessor() {
//         return new BeanFactoryPostProcessor() {
//
//             @Override
//             public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
//                    beanFactory.registerScope("thread", new SimpleThreadScope());
//                }
//              };
//     }

    /*
     * Configure inbound flow (replies coming from workers)
     */
    @Bean
    @Scope(value = "thread"/* , proxyMode = ScopedProxyMode.NO */)
//    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public QueueChannel replies() {
        return new QueueChannel();
    }

//    @Bean
//    public IntegrationFlow inboundFlow(ConnectionFactory connectionFactory) {
//        return IntegrationFlows
//                .from(Jms.messageDrivenChannelAdapter(connectionFactory).destination(IntegrationConstant.MASTER_REPLY_DESTINATION))
//                .channel(replies())
//                .get();
//    }

    @Bean
    public JmsOutboundGateway jmsOutboundGateway(ConnectionFactory connectionFactory) {
        JmsOutboundGateway jmsOutboundGateway = new JmsOutboundGateway();
        jmsOutboundGateway.setConnectionFactory(connectionFactory);
        jmsOutboundGateway.setRequestDestinationName(IntegrationConstant.MASTER_REQUEST_DESTINATION);//2. send the message to this destination
        jmsOutboundGateway.setRequiresReply(true);
        jmsOutboundGateway.setCorrelationKey(IntegrationConstant.JMS_CORRELATION_KEY);//3. let the broker filter the message
        jmsOutboundGateway.setAsync(true);//must be async, so that JMS_CORRELATION_KEY work
        jmsOutboundGateway.setUseReplyContainer(true);
        jmsOutboundGateway.setReplyDestinationName(IntegrationConstant.MASTER_REPLY_DESTINATION);//4. waiting the response from this destination
        jmsOutboundGateway.setReceiveTimeout(30_000);
        return jmsOutboundGateway;
    }

    @Bean
    public IntegrationFlow jmsOutboundGatewayFlow(ConnectionFactory connectionFactory) {
        return IntegrationFlows
                        .from(requests())//1. receive message from this channel
                        .handle(jmsOutboundGateway(connectionFactory))
                        .channel(replies())//5. send back the response to this channel
                        .get();
    }

}

SLAVE配置�Q?br />

package com.paul.testspringbatch.config.slave;

import javax.jms.ConnectionFactory;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.config.EnableIntegration;
import org.springframework.integration.dsl.IntegrationFlow;
import org.springframework.integration.dsl.IntegrationFlows;
import org.springframework.integration.jms.dsl.Jms;

import com.paul.testspringbatch.common.constant.IntegrationConstant;

@Configuration
@EnableIntegration
@Profile("batch-slave")
public class IntegrationSlaveConfiguration {


    /*
     * Configure inbound flow (requests coming from the master)
     */
    @Bean
    public DirectChannel requests() {
        return new DirectChannel();
    }

//    @Bean
//    public IntegrationFlow inboundFlow(ConnectionFactory connectionFactory) {
//        return IntegrationFlows
//                .from(Jms.messageDrivenChannelAdapter(connectionFactory).destination("requests"))
//                .channel(requests())
//                .get();
//    }

    /*
     * Configure outbound flow (replies going to the master)
     */
    @Bean
    public DirectChannel replies() {
        return new DirectChannel();
    }

//    @Bean
//    public IntegrationFlow outboundFlow(ConnectionFactory connectionFactory) {
//        return IntegrationFlows
//                .from(replies())
//                .handle(Jms.outboundAdapter(connectionFactory).destination("replies"))
//                .get();
//    }

    @Bean
    public IntegrationFlow inboundGatewayFlow(ConnectionFactory connectionFactory) {
        return IntegrationFlows
                    .from(Jms
                            .inboundGateway(connectionFactory)
                            .destination(IntegrationConstant.SLAVE_HANDLE_MASTER_REQUEST_DESTINATION)//1. receive message from this channel.
                            .correlationKey(IntegrationConstant.JMS_CORRELATION_KEY)//2. let the broker filter the message
                            .requestChannel(requests())//3. send the message to this channel
                            .replyChannel(replies())//4. waitting the result from this channel
                            .defaultReplyQueueName(IntegrationConstant.SLAVE_RETURN_RESULT_DESTINATION)//5.send back the result to this destination to the master.
                            )
                    .get();
    }

}

paulwong 2019-07-16 14:38 发表评论

STEP范围内的ROUTER

paulwong — Thu, 11 Jul 2019 03:45:00 GMT

在SPRING BATCH中，通常ROUTER是针对STEP的，但是如果在一个STEP中有多个WRITER�Q�每个WRITER是写不同文�g的，因此需要一个STEP内的ROUTER�Q�以便能ROUTE��C��同的WRITER中�?br />

https://gist.github.com/benas/bfe2be7386b99ce496425fac9ff35fb8

paulwong 2019-07-11 11:45 发表评论

动态改变SPRING BATCH �?CHUNKSIZE

paulwong — Tue, 02 Jul 2019 03:13:00 GMT

在SPRING BATCH REMOTE CHUNKING的模式下�Q?br />SPRING BATCH ��L��件时�Q�是按一行一行来��d��数据�Q�再按CHUNKSIZE提交到REMOTE操作�Q�有时要整合当前行和下几行，再决定CHUNKSIZE�Q�以便相关的数据能在�q�程同一个PROCESSOR中按��序�q�行处理�Q�因为相关的数据被拆成几个CHUNK来处理的话，��有可能不按��序来处理。这样就需要动态调整CHUNKSIZE�?br />
参照如下�Q?br /> https://stackoverflow.com/questions/37390602/spring-batch-custom-completion-policy-for-dynamic-chunk-size

�q�结合SingleItemPeekableItemReader�Q�装饰者，允许查看下一条数据，真正的操作委托给代理�Q��?img src ="http://www.tkk7.com/paulwong/aggbug/434011.html" width = "1" height = "1" />

paulwong 2019-07-02 11:13 发表评论

Spring batch 的高�U�特�?-监听�Q�异常处理，事务

paulwong — Wed, 12 Jun 2019 09:03:00 GMT

https://my.oschina.net/u/2600078/blog/909346

paulwong 2019-06-12 17:03 发表评论

SPRING BOOT BATCH资源

paulwong — Tue, 07 May 2019 09:07:00 GMT

Spring Boot下Spring Batch入门实例

https://www.jianshu.com/p/305192ea4cb1

SPRING BATCH + QUARTZ
https://examples.javacodegeeks.com/enterprise-java/spring/batch/quartz-spring-batch-example/
https://blog.kingbbode.com/posts/spring-batch-quartz

Spring Batch Tutorial: Batch Processing Made Easy with Spring
https://www.toptal.com/spring/spring-batch-tutorial

paulwong 2019-05-07 17:07 发表评论

如何提高�~�码质量

paulwong — Fri, 14 Dec 2012 03:57:00 GMT

问题

一般程序员都会(x��)发现�q�样的问题，需求拿�?ji��n)，�~�码写完�?ji��n)，�~�译也通过�?ji��n)，�q�行也没报错�Q�就以�ؓ(f��)�E�序OK�?ji��n)，但到��试人员那里�Q�一�q�行��试用例�Q�就发现漏了(ji��n)�q�个那个的，产生�?ji��n)所谓的质量问题�?/div>

原因

�q�通常是由于程序员?sh��)��拿到需求，��马上想要几个CLASS�Q�然后就开始编码了(ji��n)�?/div>

解决�Ҏ(gu��)��

拿到需求后�Q�先惛_��概会(x��)用到哪些OBJECT�Q�即SERVICE�Q�DAO之类�?/li>
设计��Z��(x��)遇到哪些场景
设计出分别在�q�些场景中，那些OBJECT合作的流�E�图
�~�码

举例

需求：(x��)有一�pȝ��?x��)在每天的某个时间点�Q�在某个文�g夹内�Q�导��Z��个一定格式名�U�的文�g�Q�现在要求程序实现在文�g生成后，��d��q�个文�g�Q�抽取某些内容后�Q�再生成另一文�g�Q�通过SFTP发走�?/div>

�Ҏ(gu��)��Q?/div>

�?x��)用到排�E�器�Q�控制器�Q�SPRING BATCH JOB
有这几种场景�Q�没有发现文件时�Q�发��C��(ji��n)文�g后正常处理，控制器和SPRING BATCH JOB出现错误时等
处理��程�Q�控制器没有发现文�g后，通知排程器��(h��)�l�下一�ơ��@环；控制器发现文件后�Q�通知SPRING BATCH JOB处理�Q�然后通知控制器退出；控制器出现错误或SPRING BATCH JOB出现错误后，控制器通知排程器退出�?/li>
�Ҏ(gu��)��q�几�U�场景设计程序结构，�~�码
�~�写单元��试用例

paulwong 2012-12-14 11:57 发表评论

SPRING BATCH 错误通知机制

paulwong — Sat, 17 Nov 2012 13:42:00 GMT

摘要: �q�行SPRING BATCH JOB 的时候，有可能出错，如果能有相关的错误处理机�Ӟ��则这些错误就能及(qi��ng)时得到处理�? SPRING BATCH 提供�?ji��n)监听器�Q�可配置在JOB执行完后�Q�或执行JOB前，要执行的�Ҏ(gu��)��? JOB的定义及(qi��ng)BEAN的配�|�文�Ӟ��(x��) Code highlighting produced by Actipro CodeHighlighter (... 阅读全文

paulwong 2012-11-17 21:42 发表评论

SPRING BATCH ��试

paulwong — Sat, 10 Nov 2012 09:25:00 GMT

SPRING BATCH 柯以��试的内容：(x��)JOB, STEP, INTEMPROCESSOR, ITEMREADER, ITEMWRITER�?

JOB, STEP属于功能��试�Q�黑盒）(j��)的范��_(d��)��INTEMPROCESSOR, ITEMREADER, ITEMWRITER属于单元��试�Q�白盒）(j��)的范畴�?/div>

/*
* Copyright 2006-2007 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 example;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;

import java.util.Date;
import java.util.concurrent.Callable;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.item.ExecutionContext;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemStream;
import org.springframework.batch.item.NonTransientResourceException;
import org.springframework.batch.item.ParseException;
import org.springframework.batch.item.UnexpectedInputException;
import org.springframework.batch.test.JobLauncherTestUtils;
import org.springframework.batch.test.MetaDataInstanceFactory;
import org.springframework.batch.test.StepScopeTestExecutionListener;
import org.springframework.batch.test.StepScopeTestUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;

@ContextConfiguration(locations = { "/test-context.xml",
        "classpath:/META-INF/spring/batch/hello-tasklet-context.xml",
        "classpath:/META-INF/spring/batch/jdbc-job-context.xml",
        "classpath:/META-INF/spring/integration/hello-integration-context.xml"})
@RunWith(SpringJUnit4ClassRunner.class)
//��试ITEMREADER/ITEMPROCESSOR/ITEMWRITER时用�?/span>
@TestExecutionListeners( { DependencyInjectionTestExecutionListener.class,
    StepScopeTestExecutionListener.class })
public class HelloTaskletTests {

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private Job helloWorldJob;

    @Autowired
    private JobLauncherTestUtils jobLauncherTestUtils;//��试JOB/STEP的入�?/span>

    @Autowired
    private ItemReader xmlReader;

    public void testLaunchJobWithJobLauncher() throws Exception {
        JobExecution jobExecution = jobLauncher.run(helloWorldJob, new JobParameters());
        assertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());
    }

    /**
     * Create a unique job instance and check it's execution completes
     * successfully - uses the convenience methods provided by the testing
     * superclass.
     */
    @Test
    public void testLaunchJob() throws Exception {

        JobExecution jobExecution = jobLauncherTestUtils.launchJob(jobLauncherTestUtils.getUniqueJobParameters());
        assertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());
    }

    public void testIntegration()
    {
        while(true)
        {

        }
    }

    /**
     * ��试某个STEP
     */
    @Test
    public void testSomeStep()
    {
        JobExecution jobExecution = jobLauncherTestUtils.
                launchStep("xmlFileReadAndWriterStep",getJobParameters());
        assertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());
    }

    /**
     * ��试READER的方�?�Ӟ��所需的方�?br />     * @return
     */
    public StepExecution getStepExecution() {
        StepExecution execution = MetaDataInstanceFactory
                .createStepExecution(getJobParameters());
        return execution;
    }

    /**
     * ��试READER的方�?
     * @throws Exception
     */
    @Test
    @DirtiesContext
    public void testReader() throws Exception {
        int count = StepScopeTestUtils.doInStepScope(getStepExecution(),
                new Callable() {
                    @Override
                    public Integer call() throws Exception {
                        int count = 0;
                        try {
                            ((ItemStream) xmlReader)
                                    .open(new ExecutionContext());
                            while (xmlReader.read() != null) {
                                count++;
                            }
                            return count;
                        } finally {
                            ((ItemStream) xmlReader).close();
                        }
                    }
                });
        assertEquals(3, count);
    }

    /**
     * ��试READER的方�?
     * @throws UnexpectedInputException
     * @throws ParseException
     * @throws NonTransientResourceException
     * @throws Exception
     */
    @Test
    @DirtiesContext
    public void testReader2() throws UnexpectedInputException, ParseException, NonTransientResourceException, Exception
    {
        assertNotNull(xmlReader.read());
    }

    /**
     * ��试READER的方�?�Ӟ��必须加的�Ҏ(gu��)��
     */
    @Before
    public void setUp() {
        ((ItemStream) xmlReader).open(new ExecutionContext());
    }

    /**
     *
     * @return
     */
    private JobParameters getJobParameters() {

        String inputFile = "/Users/paul/Documents/PAUL/DOWNLOAD/SOFTWARE/DEVELOP/"
                + "SPRING BATCH/spring-batch-2.1.9.RELEASE/samples/"
                + "spring-batch-simple-cli/file/trades1.xml";

        String outputFile = "/Users/paul/Documents/PAUL/DOWNLOAD/SOFTWARE/DEVELOP/"
                + "SPRING BATCH/spring-batch-2.1.9.RELEASE/samples/"
                + "spring-batch-simple-cli/file/output/out.xml";

        JobParameters jobParameters = new JobParametersBuilder()
                .addString("input.file.path", inputFile)
                .addString("output.file.path", outputFile)
                .addDate("date", new Date()).toJobParameters();

        return jobParameters;
    }

}

参考例子：(x��)

http://code.google.com/p/springbatch-in-action/source/browse/trunk/sbia/ch15/src/test/java/com/manning/sbia/ch15/batch/integration/?r=128#integration%2Fjob

SPRING-BATCH TEST

https://src.springframework.org/svn/spring-batch/trunk/spring-batch-core-tests/src/test/java/org/springframework/batch/core/test/

paulwong 2012-11-10 17:25 发表评论

SRING INTEGRATION + BATCH

paulwong — Sun, 21 Oct 2012 09:23:00 GMT

摘要: 场景�Q�由SPRING INTEGRATION�?0�U�监控数据库中的POLL表，如果有符合条件的记录�Q�则启动JDBC JOB�Q�此JOB要做的也是和数据库交互的动作�Q�如用JDBCITEMREADER��d��数据库记录，用JDBCITEMWRITER写记录进数据�?�? SPRING INTEGRATION与SPRING BATCH JOB交互的点是JOBPARAMETERS�Q�即以KEY-V... 阅读全文

paulwong 2012-10-21 17:23 发表评论

SPRING BATCH �q�行机制

paulwong — Sat, 20 Oct 2012 03:57:00 GMT

JOB的XML配置相当于命令模式中的一个命令，每次�q�行�Q�会(x��)生成一个JOB INSTANCE�Q�同时也�?x��)生成一个JOB EXCETION�Q�JOB INSTANCE表示有一个JOB�Q�JOB EXECUTION表示�q�行�W�一�ơ尝试。失败运行的JOB再次�q�行�Ӟ��只生成一个JOB EXCETION�Q�表�C��行的�W�二�ơ尝试。当SPRING BATCH JOB引擎接到�q�行��h��Ӟ��有以下几�U�情况：(x��)@import url(http://www.tkk7.com/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css);

判断此JOB以前是否有运行过�Q�判断依据：(x��)�Ҏ(gu��)��JOB NAME和JOB PARAMETERS信息去这两张表查找，如找到记录，则是有运行过�Q�如��定有则引擎退出�ƈ提示�?br />
判断是否有重复运行的JOB�Q�如果没�Q�查找此JOB上次�q�行的情况，如果有FAIL的情况，则重��C��上次��p�|的地方运行��(h��)�l�运行，判断�Ҏ(gu��)��Q�根据JOB INSTANCE兌��的JOB EXECUTION查找是否有状态�ؓ(f��)FAIL的记录，如有则是�Q�就新徏一个JOB EXECUTION表示�q�行�W�二�ơ尝试，同时又生成关于新JOB的JOB EXECUTION。上�ơ的JOB�q�行完后�Q�再�q�行此次新JOB。判断上�ơ失败的STEP的依据：(x��)查找对应的JOB EXECUTON的STEP EXECUTON状态�ؓ(f��)FAIL的STEP卛_��Q�会(x��)从此步骤开始运行，而不是从�W�一步开始运行�?br />

参考文档：(x��)

http://static.springsource.org/spring-batch/reference/html/domain.html#domainJobInstance

paulwong 2012-10-20 11:57 发表评论

SPRING INTEGRATION + SPRING BATCH

paulwong — Mon, 15 Oct 2012 16:11:00 GMT

摘要: SPRING INTEGRATION的强��Ҏ(gu��)��事�g驱动�Q�但捕获之后�Q�要做的事是触发一个类的方法，对于要处理大数据量的文�g�Q�就没有办法�?ji��n)，如读�?w条记录，然后插入数据库。而这个正是SPRING BATCH的强��Ҏ(gu��)��在，因此有必要将此两个框架整合�v来用�? 场景�Q�盯着一个文件夹�Q�如果一有文�Ӟ��此文件可能非常大的，则启动一个BATCH JOB来处理�? 文�g拉取器，监控文�g夹一有新... 阅读全文

paulwong 2012-10-16 00:11 发表评论

Quartz 中的��d��开始、暂停和�l�箋(hu��)

paulwong — Sat, 13 Oct 2012 08:18:00 GMT

摘要: �W�一个TASK:Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->package com.paul.springbatchtest.tasklet;import org.quartz.SchedulerException;public class Tas... 阅读全文

paulwong 2012-10-13 16:18 发表评论

paulwong — Fri, 12 Oct 2012 02:51:00 GMT

Spring3.0以后�Q�自己已�l�完全支持更加精��的旉��Q�而不需要Quartz�Q�Quartz是一个开放源码项目，专注于�Q务调度器�Q�提供了(ji��n)极�ؓ(f��)�q�泛的特性如持久化�Q务，集群和分布式��d��{�。Spring对Quartz的集成与其对JDK Timer的集成在��d��、触发器和调度计划的声明式配�|�方面等都非常相伹{�?�Q�的支持�Q�当然后面我们也�?x��)用Quartz实现��d��的调度�?br />
Spring3.0同样也��用cron表达式。与Quartz不同的是�Q�Spring3.0不支持年�Q�而Quartz支持�q�。但�q�点好象�q�不是非帔R��要�?

cron表达式：(x��)�Q�是用空格分开的时间字�D�，不��用年�?

*(�U?-59)
*(分钟0-59)
*(��时0-23)
*(日期1-31)
*(月䆾1-12或是JAN-DEC)
*(星期1-7或是SUN-SAT)

�C�Z��Q?nbsp;
*/5  * * * * 6-7  :: 每个�?到周日，每隔5�U�钟执行一�ơ�?br />
*/1 * * 7-9 1-2 1-7 :: 1月到2月中�?号到9��P��且必��要满��周一到周日，每隔1�U�钟执行一�ơ�?nbsp;

*/1 * * 7-9 1,5 1-7  :: 注意里面�?/span>,(逗号)�Q�只�?月和5月的7�?��P��且必��要满��周一到周日，每一�U�钟执行一�ơ�?nbsp;

*/1 17-59 * 7-9 1,5 1-7 :: 只解�?7-59,是指从第17分钟到第59分钟�Q�在指定的时间内�Q�每一�U�种执行一��?nbsp;

* 17-59 * 7-9 1,5 1-7  :: 此代码的功能与上面完全相同。如果不写秒即�ؓ(f��)每一�U�执行一�ơ�?nbsp;

59 19-23 * 7-9 1,5 1-7  :: 19�?23分的�?9�U�钟时只执行一�ơ�?nbsp;

59 19,26 * 7-9 1,5 1-7  :: 注意里面�?/span>,(逗号)�Q�是指只�?9分或�?6分的56�U�钟时执行一�ơ�?nbsp;

* * 16-23 7-9 1,5 1-7  :: 定义每天�?6点到23�Ҏ(gu��)��一�U�钟执行一�ơ�?nbsp;

59 59 23 * * 1-5  :: 定义每周1到周5,晚上23:59:59�U�只执行一�ơ�?br />�q�个相当用有。可以工作时间每天给用户发邮件�?nbsp;

在Spring3.0中引用了(ji��n)新的命名�I�间-task�Q?
task:scheduler 用于定义一个ThreadPoolTaskScheduler,�q�可以指定线�E�池的大��，
即pool-size.所有�Q务队列都��会(x��)在指定大��的�U�程池中�q�行�Q?

定义如下�Q?br />

<bean id="one" class="cn.itcast.schedule.One">
<property name="task" value="A">property>
bean>

<bean id="two" class="cn.itcast.schedule.One">
<property name="task" value="B">property>
bean>

<bean id="three" class="cn.itcast.schedule.One">
<property name="task" value="C">property>
bean>


<task:scheduler id="sch" pool-size="2"/>


<task:scheduled-tasks scheduler="sch">

     <task:scheduled ref="one" method="doSomeThing"  fixed-delay="#{1000*3}"/>
       <task:scheduled ref="two" method="doSomeThing"  fixed-delay="#{1000*3}"/>
       <task:scheduled ref="three" method="doSomeThing"  fixed-delay="#{1000*3}"/>
task:scheduled-tasks>

<bean id="work" class="cn.itcast.schedule.Two"/>

<task:scheduler id="sendMail"/>

<task:scheduled-tasks scheduler="sendMail">

     <task:scheduled ref="work" method="work" cron="1 37 19 8 1 *"/>
task:scheduled-tasks>

定义好之后，正常启动容器卛_��Q�只有条件符合，即会(x��)按要求执行�Q务�?

paulwong 2012-10-12 10:51 发表评论

SPRING BATCH SCREN

paulwong — Thu, 11 Oct 2012 10:10:00 GMT

SCENARIO 1:
A job runs at a specific period in the day at a specific interval (e.g. between 1am - 3am at 15 minute intervals) . When it completes with a specific status, it stops (and does not run after 15 minutes) and does not get triggered again until the next day again at 1am, and at the same time, it triggers all dependent jobs.

SCENARIO 2:
A job is scheduled to run at a specific time of day. It continues to run at regular intervals until a condition is met, after which it stops running. It will then start running the next day at the scheduled time and process repeats.

Reference:

spring+quartz 动态�Q务方�?/div>

http://www.iteye.com/topic/704646

Quartz+Spring 自定义作业调度（作业在DB中配�|�）(j��)

http://www.tkk7.com/jnbzwm/archive/2010/09/06/331239.html

Quartz在Spring中动态设�|�cronExpression�Q�spring讄��动态定时�Q务）(j��)

http://blog.sina.com.cn/s/blog_4f925fc30100u81j.html

Quartz实现Java调度操作

http://blog.sina.com.cn/s/blog_4f925fc30100u7yd.html

Sping 中配�|�Quartz�Q�SchedulerFactoryBean不能自动启动

http://www.iteye.com/problems/15283

paulwong 2012-10-11 18:10 发表评论

SPRING BATCH ADMIN安装实录

paulwong — Sun, 23 Sep 2012 11:36:00 GMT

下蝲
从云端下载文�Ӟ��(x��)http://s3.amazonaws.com/dist.springframework.org/release/BATCHADM/spring-batch-admin-1.2.1.RELEASE.zip
更改JOBREPOSITRY的数据库
支持从启动JVM时传参数�Q�即如果启动JVM时传�?DENVIRONMENT=mysql��|��则读取batch-mysql.properties文�g�Q�如未传��|��则默认读batch-hsql.properties文�g�Q�如找不到此文�g�Q�才��d��batch-default.properties文�g�Q�因此将batch-mysql.properties�{�删除，只保留default文�g�Q�里面放数据库驱动程序等信息是开发环境时的首选做法。相关的properties文�g可去http://www.springsource.org/download/community中下载。顺便将JDK�Ҏ(gu��)��1.6�Q�SPRING-BATCH的版本改成最新的2.1.8�?br />
生成WAR�?nbsp;
先用MAVEN安装PARENT包，再安装ADMIN包�?br />
部��v
打开TOMCAT�Q�将WAR包丢�q�去卛_��Q�如果要在ECLIPSE中调试，��此两个PROJECT 导入到ECLIPSE中，安装RUN-JETTY-RUN插�g�Q�即可在ECLIPSE中启动JETTY�Q�而MAVEN��目不用�Ҏ(gu��)��ECLIPSE的WEB��目�Q�推荐！
讉K��|�址�Q�http://localhost:8080/spring-batch-admin-sample�?br />
部��vJOB
��job的spring配置文�g和相关class如itemreader�{�打成jar包，攑ֈ�META-INF/spring/batch/jobs/下，则会(x��)自动昄��到UI中�?br />
<点击下蝲修改后的控制�?/a>> <点击下蝲例子>

paulwong 2012-09-23 19:36 发表评论

SPRING BATCH 资源

paulwong — Thu, 20 Sep 2012 05:25:00 GMT

http://www.cnblogs.com/gulvzhe/archive/2011/11/06/2238125.html

http://www.ibm.com/developerworks/cn/java/j-lo-springbatch1/

单元��试例子
http://code.google.com/p/springbatchhanson/

单元��试STEP

http://code.google.com/p/springbatch-in-action/source/browse/trunk/sbia/ch15/src/test/java/com/manning/sbia/ch15/batch/integration/step/StatisticStepTest.java?r=128&spec=svn243

Spring Batch In Action例子

http://code.google.com/p/springbatch-in-action/

Pro Spring Batch例子
http://www.apress.com/9781430234524

Spring Batch官方例子
http://www.springsource.org/download/community

Spring Batch �?Sample�Q�固定长格式文�g��d��Q?�?
http://mowengaobo.iteye.com/blog/1522137

SPRING BATCH REFERENCE

http://static.springsource.org/spring-batch/reference/html/index.html

paulwong 2012-09-20 13:25 发表评论

spring batch基本概念

paulwong — Tue, 18 Sep 2012 16:19:00 GMT

如果要读一堆的文本文�g到数据库,则可以��用SPRIN BATCH�?br />
��L��E�：(x��)
由JobRunner启动Job�Q�Job启动Step�Q�Step启动TaskLet�Q�TaskLet启动Chunk�Q�Chunk启动ItemRader/ItemProcessor/ItemWriter�?br />
Step之间可以讑֮��程�Q�即在Step间放一个Decision�Q�在上一步放一个Listener�Q�根据条件把某变量值放到Context中，Decision�Ҏ(gu��)��此值决定下一步是哪个�?br />
DefaultLineMapper�Q�将STRING转成MAP

DelimitedLineTokenizer�Q�将行以豆号分割出来攑ֈ�LIST

BeanWrapperFieldSetMapper�Q�将MAP转成VO

FlatFileItemWriter�Q�输出到文�g

DelimitedLineAggregator�Q�对象�{字符�?br />
自定义TaskLet�Q�如果�Q务不是读或写那种,��新增自定义�c�d��成所需工作

http://www.cnblogs.com/gulvzhe/archive/2011/11/06/2238125.html

http://www.ibm.com/developerworks/cn/java/j-lo-springbatch1/

http://www.visa4uk.fco.gov.uk/Welcome.htm

paulwong 2012-09-19 00:19 发表评论