springbatch实操Demo

最新推荐文章于 2024-07-20 17:06:53 发布
最新推荐文章于 2024-07-20 17:06:53 发布
阅读量597 收藏
点赞数 1
分类专栏： java SpringBatch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40250122/article/details/116862234
版权
本文档深入剖析了AbsExportBatchJob类及其子类ExportBatchRunJob，展示了如何通过Spring Batch进行雅典娜行为数据和ESales行为数据的批量同步处理，包括读取、处理和写入操作。
摘要由CSDN通过智能技术生成 
/*
 * Copyright yangjunxiong 2021 Wicrenet, Inc. All rights reserved.
 */
package com.aegonthtf.fate.service.batch;

import com.aegonthtf.fate.constant.BatchConvertEnum;
import com.aegonthtf.fate.constant.CommonConstant;
import com.aegonthtf.fate.dto.JobBehaviorParamesDto;
import com.aegonthtf.fate.util.exception.SZException;
import com.alibaba.fastjson.JSON;
import org.joda.time.LocalDateTime;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.Async;

/**
 * 【 抽象执行者 】
 *
 * @author yangjunxiong
 * @date 2021/5/14 15:55
 **/
@Configuration
public abstract class AbsExportBatchJob {
    @Autowired
    public  JobLauncher        jobLauncher;       //执行器
    @Autowired
    private JobBuilderFactory  jobBuilderFactory; //创建job的对象
    @Autowired
    private StepBuilderFactory stepBuilderFactory; //创建step的对象

    public JobBuilderFactory getJobBuilderFactory() {
        return this.jobBuilderFactory;
    }

    public StepBuilderFactory getStepBuilderFactory() {
        return this.stepBuilderFactory;
    }

    //异步执行者
    @Async("behaviorTaskExecutor")
    public void asyncStart(JobBehaviorParamesDto jobParameters, BatchConvertEnum batchConvertEnum) {
        try {
            jobLauncher.run(this.itemReaderFromDBJob(jobParameters.getStaratDateTime(), batchConvertEnum),
                    new JobParametersBuilder()
                            .addString(CommonConstant.JOB_PARAMETERS, JSON.toJSONString(jobParameters))//job全局参数
                            .toJobParameters());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //启动器
    public Job itemReaderFromDBJob(LocalDateTime staratDateTime, BatchConvertEnum batchConvertEnum) {
        switch (batchConvertEnum) {
            case ATH_ACT_EXPORT:
                return this.athActExportSub(staratDateTime, batchConvertEnum);
            case ESALES_ACT_EXPORT:
                return this.esalesActExportSub(staratDateTime, batchConvertEnum);
            case TU_D_SUBMISSION_DAILY:
                break;
            case APOLLO_ACT_EXPORT:
                break;
        }
        throw new SZException("该Job启动器不存在!");
    }

    //【  ATH_ACT_EXPORT表数据批量同步处理(雅典娜 Athena2_0 的行为记录表) 】
    protected abstract Job athActExportSub(LocalDateTime staratDateTime, BatchConvertEnum batchConvertEnum);

    //【  ESALES_ACT_EXPORT表数据批量同步处理(在线销售系统 ESales 的行为记录表) 】
    protected abstract Job esalesActExportSub(LocalDateTime staratDateTime, BatchConvertEnum batchConvertEnum);

}

/*
 * Copyright yangjunxiong 2021 Wicrenet, Inc. All rights reserved.
 */
package com.aegonthtf.fate.service.batch;

import com.aegonthtf.fate.constant.BatchConvertEnum;
import com.aegonthtf.fate.constant.CommonConstant;
import com.aegonthtf.fate.entity.behavior.AthActExport;
import com.aegonthtf.fate.entity.behavior.EsalesActExport;
import com.aegonthtf.fate.entity.user.FateSalesAct;
import com.aegonthtf.fate.service.batch.listener.StartJobExecutionListener;
import com.aegonthtf.fate.service.batch.processor.AthActExportItemProcessor;
import com.aegonthtf.fate.service.batch.processor.EsalesActExportItemProcessor;
import com.aegonthtf.fate.service.batch.reader.AthActExportReader;
import com.aegonthtf.fate.service.batch.reader.EaalesActExportReader;
import com.aegonthtf.fate.service.batch.writer.FateSalesActWriter;
import org.joda.time.LocalDateTime;
import org.springframework.batch.core.Job;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 【 具体的Job 】
 *
 * @author yangjunxiong
 * @date 2021/5/14 15:55
 **/
@Component
public class ExportBatchRunJob extends AbsExportBatchJob {
    @Autowired
    private StartJobExecutionListener    startJobExecutionListener;
    @Autowired
    private AthActExportReader           athActExportReader;
    @Autowired
    private AthActExportItemProcessor    athActExportItemProcessor;
    @Autowired
    private EaalesActExportReader        eaalesActExportReader;
    @Autowired
    private EsalesActExportItemProcessor esalesActExportItemProcessor;
    @Autowired
    private FateSalesActWriter           fateSalesActWriter;

    //【  ATH_ACT_EXPORT表数据批量同步处理(雅典娜 Athena2_0 的行为记录表) 】
    @Override
    protected Job athActExportSub(LocalDateTime staratDateTime, BatchConvertEnum batchConvertEnum) {
        String date = staratDateTime.toString(CommonConstant.yyyyMMddHHmmss);
        return this.getJobBuilderFactory().get(batchConvertEnum.getiTableName() + ":Job" + ":" + date)
                .start(this.getStepBuilderFactory().get(batchConvertEnum.getiTableName() + ":Step" + date)
                        .<AthActExport, FateSalesAct>chunk(CommonConstant.BEHAVIOR_BATCH_SIZE)
                        .reader(athActExportReader.itemReaderFromDB(CommonConstant.NULL))
                        .processor(athActExportItemProcessor)
                        .writer(fateSalesActWriter.writer())
                        .build()
                )
                .listener(startJobExecutionListener)
                .build();
    }

    //【  ESALES_ACT_EXPORT表数据批量同步处理(在线销售系统 ESales 的行为记录表) 】
    @Override
    protected Job esalesActExportSub(LocalDateTime staratDateTime, BatchConvertEnum batchConvertEnum) {
        String date = staratDateTime.toString(CommonConstant.yyyyMMddHHmmss);
        return this.getJobBuilderFactory().get(batchConvertEnum.getiTableName() + ":Job" + ":" + date)
                .start(this.getStepBuilderFactory().get(batchConvertEnum.getiTableName() + ":Step" + date)
                        .<EsalesActExport, FateSalesAct>chunk(CommonConstant.BEHAVIOR_BATCH_SIZE)
                        .reader(eaalesActExportReader.itemReaderFromDB(CommonConstant.NULL))
                        .processor(esalesActExportItemProcessor)
                        .writer(fateSalesActWriter.writer())
                        .build()
                )
                .listener(startJobExecutionListener)
                .build();
    }

}

/*
 * Copyright 2021 Wicrenet, Inc. All rights reserved.
 */
package com.aegonthtf.fate.service.batch.listener;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobExecutionListener;
import org.springframework.batch.core.JobInstance;
import org.springframework.stereotype.Component;

/**
 * 【 监听 job 开始结束】
 *
 * @author yangjunxiong
 * @date 2021/5/14 16:46
 **/
@Component
public class StartJobExecutionListener implements JobExecutionListener {

    private static final Logger logger = LoggerFactory.getLogger(StartJobExecutionListener.class);

    @Override
    public void beforeJob(JobExecution jobExecution) {
        JobInstance jobInstance = jobExecution.getJobInstance();
        logger.info("job 开始, JOB_INSTANCE_ID={},JOB_EXECUTION_ID={}, jobName={}, parameters={}", jobInstance.getId(), jobExecution.getId(), jobInstance.getJobName(), jobExecution.getJobParameters());
    }

    @Override
    public void afterJob(JobExecution jobExecution) {
        JobInstance jobInstance = jobExecution.getJobInstance();
        logger.info("job 结束, JOB_INSTANCE_ID={},JOB_EXECUTION_ID={}, jobName={}, parameters={}", jobInstance.getId(), jobExecution.getId(), jobInstance.getJobName(), jobExecution.getJobParameters());
    }

}

/*
 * Copyright 2021 Wicrenet, Inc. All rights reserved.
 */
package com.aegonthtf.fate.service.batch.reader;

import com.aegonthtf.fate.constant.BatchConvertEnum;
import com.aegonthtf.fate.constant.CommonConstant;
import com.aegonthtf.fate.constant.EventTypeEnum;
import com.aegonthtf.fate.dto.JobBehaviorParamesDto;
import com.aegonthtf.fate.entity.behavior.AthActExport;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.ImmutableMap;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.springframework.batch.core.configuration.annotation.StepScope;
import org.springframework.batch.item.database.JdbcPagingItemReader;
import org.springframework.batch.item.database.Order;
import org.springframework.batch.item.database.PagingQueryProvider;
import org.springframework.batch.item.database.builder.JdbcPagingItemReaderBuilder;
import org.springframework.batch.item.database.support.MySqlPagingQueryProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;
import java.util.Date;

/**
 * 【批量读 雅典娜 Athena2_0 的行为记录表】
 *
 * @author yangjunxiong
 * Created on 2021/5/15 13:39
 */
@Configuration
public class AthActExportReader {

    @Autowired
    @Qualifier("ThirdDataSource")
    private       DataSource       dataSource;
    private final BatchConvertEnum batchConvertEnum = BatchConvertEnum.ATH_ACT_EXPORT;//ATH_ACT_EXPORT表里有E1,E2,E3,E7

    @Bean
    @StepScope
    public JdbcPagingItemReader<AthActExport> itemReaderFromDB(@Value("#{jobParameters[jobParameters]}") String jobParameters) {
        JobBehaviorParamesDto paramesDto = JSON.parseObject(jobParameters, JobBehaviorParamesDto.class);
        ImmutablePair<Date, Date> createTime = EventTypeEnum.getCreateTime(paramesDto.getStaratDateTime());
        return new JdbcPagingItemReaderBuilder<AthActExport>()
                .dataSource(dataSource)
                .name(batchConvertEnum.getiTableName())
                .fetchSize(CommonConstant.BEHAVIOR_BATCH_SIZE)
                .parameterValues(ImmutableMap.of(
                        "delFlag", CommonConstant._1,
                        "startTime", createTime.left,
                        "endTime", createTime.right
                ))
                .pageSize(CommonConstant.BEHAVIOR_BATCH_SIZE)
                .rowMapper((resultSet, i) -> {
                            AthActExport entity = new AthActExport();
                            entity.setId(resultSet.getInt(CommonConstant._1));            //ID
                            entity.setInfoKind(resultSet.getString(CommonConstant._2));   //INFO_KIND
                            entity.setEventType(resultSet.getString(CommonConstant._3));  //EVENT_TYPE
                            entity.setTransId(resultSet.getString(CommonConstant._4));    //TRANS_ID
                            entity.setTransDate(resultSet.getString(CommonConstant._5));  //TRANS_DATE   （YYYYMMDD）
                            entity.setTransTime(resultSet.getDate(CommonConstant._6));    //TRANS_TIME    (datetime)
                            entity.setAgentCode(resultSet.getString(CommonConstant._7));  //AGENT_CODE
                            entity.setAgentName(resultSet.getString(CommonConstant._8));  //AGENT_NAME
                            entity.setCustOpenid(resultSet.getString(CommonConstant._9)); //CUST_OPENID
                            entity.setOpenTime(resultSet.getDate(CommonConstant._10));    //OPEN_TIME     (datetime)
                            entity.setSubTime(resultSet.getDate(CommonConstant._11));     //SUB_TIME      (datetime)
                            entity.setAthId(resultSet.getString(CommonConstant._12));     //ATH_ID
                            entity.setCustName(resultSet.getString(CommonConstant._13));  //CUST_NAME
                            entity.setCustPhone(resultSet.getString(CommonConstant._14)); //CUST_PHONE
                            entity.setCustGender(resultSet.getString(CommonConstant._15));//CUST_GENDER
                            entity.setInfoTitle(resultSet.getString(CommonConstant._16)); //INFO_TITLE
                            entity.setInfoSource(resultSet.getString(CommonConstant._17));//INFO_SOURCE
                            entity.setCreatetime(resultSet.getDate(CommonConstant._18));  //CREATETIME
                            entity.setCreater(resultSet.getString(CommonConstant._19));   //CREATER
                            entity.setUpdatetime(resultSet.getDate(CommonConstant._20));  //UPDATETIME
                            entity.setDelFlag(resultSet.getString(CommonConstant._21));   //DEL_FLAG
                            return entity;
                        }
                )
                .queryProvider(articleProvider())
                .build();
    }

    private PagingQueryProvider articleProvider() {
        MySqlPagingQueryProvider provider = new MySqlPagingQueryProvider();
        provider.setSelectClause("ID, INFO_KIND, EVENT_TYPE, TRANS_ID, TRANS_DATE, TRANS_TIME, AGENT_CODE, AGENT_NAME, CUST_OPENID, OPEN_TIME, SUB_TIME, ATH_ID, CUST_NAME, CUST_PHONE, CUST_GENDER, INFO_TITLE, INFO_SOURCE, CREATETIME, CREATER, UPDATETIME, DEL_FLAG");
        provider.setFromClause("FROM " + batchConvertEnum.getiTableName());//ATH_ACT_EXPORT表里有E1,E2,E3,E7
//        provider.setWhereClause("event_occurred_time >= :startTime AND event_occurred_time < :stopTime");
        provider.setWhereClause("DEL_FLAG = :delFlag AND CREATETIME >= :startTime AND CREATETIME < :endTime");
        provider.setSortKeys(ImmutableMap.of("ID", Order.ASCENDING));
        return provider;
    }
}


/*
 * Copyright 2021 Wicrenet, Inc. All rights reserved.
 */
package com.aegonthtf.fate.service.batch.reader;

import com.aegonthtf.fate.constant.BatchConvertEnum;
import com.aegonthtf.fate.constant.CommonConstant;
import com.aegonthtf.fate.constant.EventTypeEnum;
import com.aegonthtf.fate.dto.JobBehaviorParamesDto;
import com.aegonthtf.fate.entity.behavior.EsalesActExport;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.ImmutableMap;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.springframework.batch.core.configuration.annotation.StepScope;
import org.springframework.batch.item.database.JdbcPagingItemReader;
import org.springframework.batch.item.database.Order;
import org.springframework.batch.item.database.PagingQueryProvider;
import org.springframework.batch.item.database.builder.JdbcPagingItemReaderBuilder;
import org.springframework.batch.item.database.support.MySqlPagingQueryProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;
import java.util.Date;

/**
 * 【 批量读 在线销售系统 ESales 的行为记录表】
 *
 * @author yangjunxiong
 * Created on 2021/5/15 13:43
 */
@Configuration
public class EaalesActExportReader {
    @Autowired
    @Qualifier("ThirdDataSource")
    private       DataSource       dataSource;
    private final BatchConvertEnum batchConvertEnum = BatchConvertEnum.ESALES_ACT_EXPORT;//ESALES_ACT_EXPORT表里有E1,E2

    @Bean
    @StepScope
    public JdbcPagingItemReader<EsalesActExport> itemReaderFromDB(@Value("#{jobParameters[jobParameters]}") String jobParameters) {
        JobBehaviorParamesDto paramesDto = JSON.parseObject(jobParameters, JobBehaviorParamesDto.class);
        //时间逻辑处理
        ImmutablePair<Date, Date> createTime = EventTypeEnum.getCreateTime(paramesDto.getStaratDateTime());
        return new JdbcPagingItemReaderBuilder<EsalesActExport>()
                .dataSource(dataSource)
                .name(batchConvertEnum.getiTableName())
                .fetchSize(CommonConstant.BEHAVIOR_BATCH_SIZE)
                .parameterValues(ImmutableMap.of(
                        "delFlag", CommonConstant._1,
                        "startTime", createTime.left,
                        "endTime", createTime.right
                ))
                .pageSize(CommonConstant.BEHAVIOR_BATCH_SIZE)
                .rowMapper((resultSet, i) -> {
                            EsalesActExport entity = new EsalesActExport();
                            entity.setId(resultSet.getInt(CommonConstant._1));            //ID
                            entity.setInfoKind(resultSet.getString(CommonConstant._2));   //INFO_KIND
                            entity.setEventType(resultSet.getString(CommonConstant._3));  //EVENT_TYPE
                            entity.setTransId(resultSet.getString(CommonConstant._4));    //TRANS_ID
                            entity.setTransDate(resultSet.getString(CommonConstant._5));  //TRANS_DATE   （YYYYMMDD）
                            entity.setTransTime(resultSet.getDate(CommonConstant._6));    //TRANS_TIME    (datetime)
                            entity.setAgentCode(resultSet.getString(CommonConstant._7));  //AGENT_CODE
                            entity.setAgentName(resultSet.getString(CommonConstant._8));  //AGENT_NAME
                            entity.setAgentOpenid(resultSet.getString(CommonConstant._9));//AGENT_OPENID
                            entity.setCustOpenid(resultSet.getString(CommonConstant._10)); //CUST_OPENID
                            entity.setOpenTime(resultSet.getDate(CommonConstant._11));    //OPEN_TIME     (datetime)
                            entity.setInfoTitle(resultSet.getString(CommonConstant._12)); //INFO_TITLE
                            entity.setInfoSource(resultSet.getString(CommonConstant._13));//INFO_SOURCE
                            entity.setCreatetime(resultSet.getDate(CommonConstant._14));  //CREATETIME
                            entity.setCreater(resultSet.getString(CommonConstant._15));   //CREATER
                            entity.setUpdatetime(resultSet.getDate(CommonConstant._16));  //UPDATETIME
                            entity.setDelFlag(resultSet.getString(CommonConstant._17));   //DEL_FLAG
                            return entity;
                        }
                )
                .queryProvider(articleProvider())
                .build();
    }

    private PagingQueryProvider articleProvider() {
        MySqlPagingQueryProvider provider = new MySqlPagingQueryProvider();
        provider.setSelectClause("ID, INFO_KIND, EVENT_TYPE, TRANS_ID, TRANS_DATE, TRANS_TIME, AGENT_CODE, AGENT_NAME, CUST_OPENID, OPEN_TIME, SUB_TIME, ATH_ID, CUST_NAME, CUST_PHONE, CUST_GENDER, INFO_TITLE, INFO_SOURCE, CREATETIME, CREATER, UPDATETIME, DEL_FLAG");
        provider.setFromClause("FROM " + batchConvertEnum.getiTableName());//ESALES_ACT_EXPORT表里有E1,E2
        provider.setWhereClause("DEL_FLAG = :delFlag AND CREATETIME >= :startTime AND CREATETIME < :endTime");
        provider.setSortKeys(ImmutableMap.of("ID", Order.ASCENDING));
        return provider;
    }
}


package com.aegonthtf.fate.service.batch.processor;///*

import cn.com.common.util.util.StringUtils;
import com.aegonthtf.fate.constant.CommonConstant;
import com.aegonthtf.fate.constant.EventTypeEnum;
import com.aegonthtf.fate.dto.JobBehaviorParamesDto;
import com.aegonthtf.fate.entity.behavior.AthActExport;
import com.aegonthtf.fate.entity.user.FateSalesAct;
import com.alibaba.fastjson.JSON;
import org.joda.time.LocalDateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.annotation.BeforeStep;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.stereotype.Component;

import java.util.Objects;
import java.util.Optional;

/**
 * 【 数据清洗 】
 *
 * @author yangjunxiong
 * @date 2021/5/14 16:46
 **/
@Component
public class AthActExportItemProcessor implements ItemProcessor<AthActExport, FateSalesAct> {
    private static final Logger logger = LoggerFactory.getLogger(AthActExportItemProcessor.class);

    JobParameters jobParameters;

    //获取job入参
    @BeforeStep
    public void beforeStep(final StepExecution stepExecution) {
        jobParameters = stepExecution.getJobParameters();
        logger.info("jobParameters: {}", jobParameters);
    }

    @Override
    public FateSalesAct process(AthActExport item) throws Exception {
        JobBehaviorParamesDto paramesDto = JSON.parseObject(jobParameters.getString(CommonConstant.JOB_PARAMETERS), JobBehaviorParamesDto.class);
        if (Objects.isNull(item) || StringUtils.isBlank(item.getEventType())) {
            return null;
        }
        EventTypeEnum eventTypeEnum = EventTypeEnum.toByCode(item.getEventType());
        if (eventTypeEnum == null) {
            return null;
        }
        FateSalesAct entity = new FateSalesAct();
        //共有参数处理
        Optional.ofNullable(item.getInfoKind()).ifPresent(entity::setInfoKind); //消息分类	INFO_KIND
        Optional.ofNullable(item.getEventType()).ifPresent(entity::setEventType); //事件类型	EVENT_TYPE
        Optional.ofNullable(item.getAgentCode()).ifPresent(entity::setAgentCode); //代理人工号	AGENT_CODE
        Optional.ofNullable(item.getAgentName()).ifPresent(entity::setAgentName); //代理人姓名	AGENT_NAME
        Optional.ofNullable(item.getInfoTitle()).ifPresent(entity::setInfoTitle); //消息标题	INFO_TITLE
        Optional.ofNullable(item.getInfoSource()).ifPresent(entity::setInfoSource); //消息来源	INFO_SOURCE
        Optional.ofNullable(item.getCreatetime()).ifPresent(entity::setCreatetime); //创建时间	CREATETIME
        Optional.ofNullable(item.getCreater()).ifPresent(entity::setCreater); //创建人	CREATER
        Optional.ofNullable(item.getDelFlag()).ifPresent(entity::setDelFlag); //删除标记	DEL_FLAG
        Optional.ofNullable(paramesDto.getStaratDateTime())
                .map(LocalDateTime::toDate)
                .ifPresent(entity::setUpdatatime);//更新时间	UPDATETIME * 使用批量里时间
        //私有参数处理
        switch (eventTypeEnum) {
            case E1:
                Optional.ofNullable(item.getTransId()).ifPresent(entity::setTransId); //转发ID	TRANS_ID
                Optional.ofNullable(item.getTransDate()).ifPresent(entity::setTransDate); //转发日期	TRANS_DATE（YYYYMMDD）
                Optional.ofNullable(item.getTransTime()).ifPresent(entity::setTransTime); //转发时间	TRANS_TIME(datetime)
                break;
            case E2:
                Optional.ofNullable(item.getTransId()).ifPresent(entity::setTransId); //转发ID	TRANS_ID
                Optional.ofNullable(item.getTransDate()).ifPresent(entity::setTransDate); //转发日期	TRANS_DATE（YYYYMMDD）
                Optional.ofNullable(item.getTransTime()).ifPresent(entity::setTransTime); //转发时间	TRANS_TIME(datetime)
                Optional.ofNullable(item.getCustOpenid()).ifPresent(entity::setCustOpenid); //客户openID	CUST_OPENID
                Optional.ofNullable(item.getOpenTime()).ifPresent(entity::setOpenTime); //打开时间	OPEN_TIME(datetime)
                break;
            case E3:
                Optional.ofNullable(item.getTransId()).ifPresent(entity::setTransId); //转发ID	TRANS_ID
                Optional.ofNullable(item.getTransDate()).ifPresent(entity::setTransDate); //转发日期	TRANS_DATE（YYYYMMDD）
                Optional.ofNullable(item.getTransTime()).ifPresent(entity::setTransTime); //转发时间	TRANS_TIME(datetime)
                Optional.ofNullable(item.getCustOpenid()).ifPresent(entity::setCustOpenid); //客户openID	CUST_OPENID
                Optional.ofNullable(item.getOpenTime()).ifPresent(entity::setOpenTime); //打开时间	OPEN_TIME(datetime)
                Optional.ofNullable(item.getSubTime()).ifPresent(entity::setSubTime); //提交时间	SUB_TIME(datetime)
                Optional.ofNullable(item.getCustName()).ifPresent(entity::setCustName); //客户姓名	CUST_NAME
                Optional.ofNullable(item.getCustPhone()).ifPresent(entity::setCustPhone); //客户手机号	CUST_PHONE
                Optional.ofNullable(item.getCustGender()).ifPresent(entity::setCustGender); //客户性别	CUST_GENDER
                break;
            case E7:
                Optional.ofNullable(item.getCustOpenid()).ifPresent(entity::setCustOpenid); //客户openID	CUST_OPENID
                Optional.ofNullable(item.getSubTime()).ifPresent(entity::setSubTime); //提交时间	SUB_TIME(datetime)
                Optional.ofNullable(item.getAthId()).ifPresent(entity::setAthId);
                Optional.ofNullable(item.getCustName()).ifPresent(entity::setCustName); //客户姓名	CUST_NAME
                Optional.ofNullable(item.getCustPhone()).ifPresent(entity::setCustPhone); //客户手机号	CUST_PHONE
                break;
            default:
                return null;
        }
        return entity;
    }
}


package com.aegonthtf.fate.service.batch.processor;///*

import cn.com.common.util.util.StringUtils;
import com.aegonthtf.fate.constant.CommonConstant;
import com.aegonthtf.fate.constant.EventTypeEnum;
import com.aegonthtf.fate.dto.JobBehaviorParamesDto;
import com.aegonthtf.fate.entity.behavior.EsalesActExport;
import com.aegonthtf.fate.entity.user.FateSalesAct;
import com.alibaba.fastjson.JSON;
import org.joda.time.LocalDateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.annotation.BeforeStep;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.stereotype.Component;

import java.util.Objects;
import java.util.Optional;

/**
 * 【 数据清洗 】
 *
 * @author yangjunxiong
 * @date 2021/5/14 16:46
 **/
@Component
public class EsalesActExportItemProcessor implements ItemProcessor<EsalesActExport, FateSalesAct> {
    private static final Logger logger = LoggerFactory.getLogger(EsalesActExportItemProcessor.class);

    JobParameters jobParameters;

    //获取job入参
    @BeforeStep
    public void beforeStep(final StepExecution stepExecution) {
        jobParameters = stepExecution.getJobParameters();
        logger.info("jobParameters: {}", jobParameters);
    }

    @Override
    public FateSalesAct process(EsalesActExport item) throws Exception {
        JobBehaviorParamesDto paramesDto = JSON.parseObject(jobParameters.getString(CommonConstant.JOB_PARAMETERS), JobBehaviorParamesDto.class);
        if (Objects.isNull(item) || StringUtils.isBlank(item.getEventType())) {
            return null;
        }
        EventTypeEnum eventTypeEnum = EventTypeEnum.toByCode(item.getEventType());
        if (eventTypeEnum == null) {
            return null;
        }
        FateSalesAct entity = new FateSalesAct();
        //共有参数处理
        Optional.ofNullable(item.getInfoKind()).ifPresent(entity::setInfoKind); //消息分类	INFO_KIND
        Optional.ofNullable(item.getEventType()).ifPresent(entity::setEventType); //事件类型	EVENT_TYPE
        Optional.ofNullable(item.getAgentCode()).ifPresent(entity::setAgentCode); //代理人工号	AGENT_CODE
        Optional.ofNullable(item.getAgentName()).ifPresent(entity::setAgentName); //代理人姓名	AGENT_NAME
        Optional.ofNullable(item.getInfoTitle()).ifPresent(entity::setInfoTitle); //消息标题	INFO_TITLE
        Optional.ofNullable(item.getInfoSource()).ifPresent(entity::setInfoSource); //消息来源	INFO_SOURCE
        Optional.ofNullable(item.getCreatetime()).ifPresent(entity::setCreatetime); //创建时间	CREATETIME
        Optional.ofNullable(item.getCreater()).ifPresent(entity::setCreater); //创建人	CREATER
        Optional.ofNullable(item.getDelFlag()).ifPresent(entity::setDelFlag); //删除标记	DEL_FLAG
        Optional.ofNullable(paramesDto.getStaratDateTime())
                .map(LocalDateTime::toDate)
                .ifPresent(entity::setUpdatatime);//更新时间	UPDATETIME * 使用批量里时间
        //私有参数处理
        switch (eventTypeEnum) {
            case E1:
                Optional.ofNullable(item.getTransId()).ifPresent(entity::setTransId); //转发ID	TRANS_ID
                Optional.ofNullable(item.getTransDate()).ifPresent(entity::setTransDate); //转发日期	TRANS_DATE（YYYYMMDD）
                Optional.ofNullable(item.getTransTime()).ifPresent(entity::setTransTime); //转发时间	TRANS_TIME(datetime)
                break;
            case E2:
                Optional.ofNullable(item.getTransId()).ifPresent(entity::setTransId); //转发ID	TRANS_ID
                Optional.ofNullable(item.getTransDate()).ifPresent(entity::setTransDate); //转发日期	TRANS_DATE（YYYYMMDD）
                Optional.ofNullable(item.getTransTime()).ifPresent(entity::setTransTime); //转发时间	TRANS_TIME(datetime)
                Optional.ofNullable(item.getCustOpenid()).ifPresent(entity::setCustOpenid); //客户openID	CUST_OPENID
                Optional.ofNullable(item.getOpenTime()).ifPresent(entity::setOpenTime); //打开时间	OPEN_TIME(datetime)
                break;
            default:
                return null;
        }
        return entity;
    }
}


/*
 * Copyright 2021 Wicrenet, Inc. All rights reserved.
 */
package com.aegonthtf.fate.service.batch.writer;

import com.aegonthtf.fate.entity.user.FateSalesAct;
import org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

/**
 * 【 批量写 销售行为持久化 】
 *
 * @author yangjunxiong
 * Created on 2021/5/15 10:14
 */
@Configuration
public class FateSalesActWriter {
    @Autowired
    @Qualifier("primaryDataSource")
    private DataSource dataSource;

    @Bean
    public JdbcBatchItemWriter<FateSalesAct> writer() {
        JdbcBatchItemWriter<FateSalesAct> writer = new JdbcBatchItemWriter<>();
        writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<>());
        writer.setSql("INSERT INTO fate_sales_act (ID, INFO_KIND, INFO_SOURCE, INFO_TITLE, EVENT_TYPE, TRANS_ID, TRANS_DATE, TRANS_TIME, AGENT_CODE, AGENT_NAME, AGENT_OPENID, CUST_OPENID, OPEN_DATE, OPEN_TIME, SUB_DATE, SUB_TIME, ATH_ID, SIS_ID, CUST_ID, CUST_NAME, CUST_PHONE, CUST_GENDER, CUST_AGE, CUST_OPR, CUST_EMAIL, RISK_NAME, FATE_APE, PAY_TIME, FATE_FYP, CREATEDATE, CREATETIME, CREATER, UPDATATIME, DEL_FLAG, POLICY_NO) VALUES (" +
                ":id          ,\n" +
                ":infoKind    ,\n" +
                ":infoSource  ,\n" +
                ":infoTitle   ,\n" +
                ":eventType   ,\n" +
                ":transId     ,\n" +
                ":transDate   ,\n" +
                ":transTime   ,\n" +
                ":agentCode   ,\n" +
                ":agentName   ,\n" +
                ":agentOpenid ,\n" +
                ":custOpenid  ,\n" +
                ":openDate    ,\n" +
                ":openTime    ,\n" +
                ":subDate     ,\n" +
                ":subTime     ,\n" +
                ":athId       ,\n" +
                ":sisId       ,\n" +
                ":custId      ,\n" +
                ":custName    ,\n" +
                ":custPhone   ,\n" +
                ":custGender  ,\n" +
                ":custAge     ,\n" +
                ":custOpr     ,\n" +
                ":custEmail   ,\n" +
                ":riskName    ,\n" +
                ":fateApe     ,\n" +
                ":payTime     ,\n" +
                ":fateFyp     ,\n" +
                ":createdate  ,\n" +
                ":createtime  ,\n" +
                ":creater     ,\n" +
                ":updatatime,\n" +
                ":delFlag,\n" +
                ":policyNo\n)");
        writer.setDataSource(dataSource);
        return writer;
    }
}


/*
 * Copyright yangjunxiong 2021 Wicrenet, Inc. All rights reserved.
 */
package com.aegonthtf.fate.constant;

import com.aegonthtf.fate.util.verify.Asserts;

import java.util.Arrays;
import java.util.stream.Collectors;

/**
 * 【 表處理轉換映射 】
 *
 * @author yangjunxiong
 * Created on 2021/5/14 18:10
 */
public enum BatchConvertEnum {

    TU_D_SUBMISSION_DAILY(0, "tu_d_submission_daily", "fate_sales_act", null),
    ATH_ACT_EXPORT(1, "ath_act_export", "fate_sales_act", InfoSourceEnum.Athena2_0),
    ESALES_ACT_EXPORT(2, "esales_act_export", "fate_sales_act", InfoSourceEnum.ESales),
    APOLLO_ACT_EXPORT(3, "apollo_act_export", "fate_sales_act", InfoSourceEnum.Apollo);

    private final int            value;      //消息类型
    private final String         iTableName; //批处理读取的表名称
    private final String         oTableName; //批处理写入的表名称
    private final InfoSourceEnum infoSourceEnum;    //讀取文件系統

    static {
        //验证【value】必须是唯一的
        int size = Arrays.stream(BatchConvertEnum.values()).map(BatchConvertEnum::getValue).collect(Collectors.toSet()).size();
        Asserts.state(size == BatchConvertEnum.values().length, "BatchConvertEnum.value 重复定义");
    }

    BatchConvertEnum(int value, String iTableName, String oTableName, InfoSourceEnum infoSourceEnum) {
        this.value = value;
        this.iTableName = iTableName;
        this.oTableName = oTableName;
        this.infoSourceEnum = infoSourceEnum;
    }

    public static BatchConvertEnum toByValue(int value) {
        for (BatchConvertEnum item : BatchConvertEnum.values()) {
            if (item.value == value) {
                return item;
            }
        }
        throw new IllegalStateException("枚举类型转换失败");
    }

    public int getValue() {
        return value;
    }

    public String getiTableName() {
        return iTableName;
    }

    public String getoTableName() {
        return oTableName;
    }

    public InfoSourceEnum getInfoSourceEnum() {
        return infoSourceEnum;
    }
}


/*
 * Copyright yangjunxiong 2021 Wicrenet, Inc. All rights reserved.
 */
package com.aegonthtf.fate.constant;

import com.aegonthtf.fate.dto.JobBehaviorParamesDto;
import com.aegonthtf.fate.util.JodaTimeUtils;
import com.aegonthtf.fate.util.verify.Asserts;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.joda.time.LocalDateTime;

import java.util.Arrays;
import java.util.Date;
import java.util.stream.Collectors;

/**
 * 【事件枚举】
 *
 * @author yangjunxiong
 * Created on 2021/5/13 13:24
 */
public enum EventTypeEnum {
    /**
     * 事件类型	查询类型	操作内容	表名称
     * E1		营销员转发页面链接
     * E2		客户打开页面
     * E3		客户留资后提交
     * E4		营销员增加准客户信息
     * E5		拜访行程记录约访动作
     * E6		拜访行程记录初次拜访动作
     * E7		风险报告完成
     * E8		建议书制作完成
     * E9		营销员补全客户信息
     * E10		拜访行程记录需求分析动作
     * E11		营销员分享建议书链接
     * E12		客户打开建议书链接
     * E13		拜访行程记录呈现建议书动作
     * E14		投保完成
     * E15		营销员转发页面链接
     * E16		准增员打开页面
     * E17		准增员留资后提交
     * E18		营销员增加准增员信息
     * E19		行程记录初次面谈
     * E20		准增员信息补全
     * E22		CC测评报告生成
     * E23		行程记录吸引面谈
     * E25		营销员发送面试邀请链接
     * E25		准增员打开邀请链接
     * E26		营销员增加面试结论
     * E27		准增员进入新人班
     * E28		行程记录甄选面谈
     * E29		行程记录可行性面谈
     * E30		行程记录成长性面谈
     * E31		行程记录承诺面谈
     * E32		准增员完成签约
     * SEL_VISIT	0	约访	FATE_ENUM
     * SEL_VISIT	1	拜访未谈及保险	FATE_ENUM
     * SEL_VISIT	2	面对面需求分析	FATE_ENUM
     * SEL_VISIT	3	呈现纸质建议书	FATE_ENUM
     * SEL_VISIT	4	递送保单	FATE_ENUM
     * SEL_VISIT	5	其他客户服务	FATE_ENUM
     * SEL_VISIT	6	初次面谈	FATE_ENUM
     * SEL_VISIT	7	吸引面谈	FATE_ENUM
     * SEL_VISIT	8	甄选测评	FATE_ENUM
     * SEL_VISIT	9	可行性面谈	FATE_ENUM
     * SEL_VISIT	10	成长性面谈	FATE_ENUM
     * SEL_VISIT	11	承诺面谈	FATE_ENUM
     **/

    E1(1, "E1", "", InfoSourceEnum.Athena2_0,  "营销员转发页面链接"),
    E2(2, "E2", "", InfoSourceEnum.Athena2_0,  "客户打开页面"),
    E3(3, "E3", "", InfoSourceEnum.Athena2_0,  "客户留资后提交"),
    //    E4(4, "E4", "", "营销员增加准客户信息", "ATH_ACT_EXPORT"),
    //    E5(5, "E5", ""),
//    E6(6, "E6", ""),
    E7(7, "E7", "", InfoSourceEnum.Athena2_0,  "风险报告完成"),
    //    E8(8, "E8", "", "建议书完成", ""),
    E14(14, "E14", "", InfoSourceEnum.Athena2_0,  "投保完成"),
    E32(32, "E32", "", InfoSourceEnum.Athena2_0,  "准增员完成签约"),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
//    E(, "E", ""),
    ;
    private final int            value;      //事件类型
    private final String         code;       //事件code
    private final String         select;     //查询类型
    private final InfoSourceEnum infoSource; //系统
    private final String         declare;    //注释

    static {
        //验证【value】必须是唯一的
        int size = Arrays.stream(EventTypeEnum.values()).map(EventTypeEnum::getValue).collect(Collectors.toSet()).size();
        Asserts.state(size == EventTypeEnum.values().length, "EventTypeEnum.value 重复定义");
    }

    EventTypeEnum(int value, String code, String select, InfoSourceEnum infoSource, String declare) {
        this.value = value;
        this.code = code;
        this.select = select;
        this.infoSource = infoSource;
        this.declare = declare;
    }

    public static EventTypeEnum toByValue(int value) {
        for (EventTypeEnum item : EventTypeEnum.values()) {
            if (item.value == value) {
                return item;
            }
        }
        throw new IllegalStateException("枚举类型转换失败");
    }

    public static EventTypeEnum toByCode(String code) {
        for (EventTypeEnum item : EventTypeEnum.values()) {
            if (item.code.equals(code)) {
                return item;
            }
        }
        return null;
    }

    public int getValue() {
        return value;
    }

    public String getCode() {
        return code;
    }

    public String getDeclare() {
        return declare;
    }

    public String getSelect() {
        return select;
    }

    public InfoSourceEnum getInfoSource() {
        return infoSource;
    }


    //获取job运行参数
    public JobBehaviorParamesDto getJobparames(LocalDateTime staratDateTime) {
        JobBehaviorParamesDto paramesDto = new JobBehaviorParamesDto();
        // TODO yangjunxiong 2021/5/14 11:32 

        return paramesDto;
    }

    /**
     * 【 获取用户行为数据跑批起至时间逻辑 】
     *
     * @param staratDateTime
     * @return org.apache.commons.lang3.tuple.ImmutablePair<java.util.Date, java.util.Date> 左边开始时间 右边结束时间
     * @author yangjunxiong
     * @date 2021/5/14 17:38
     **/
    public static ImmutablePair<Date, Date> getCreateTime(LocalDateTime staratDateTime) {
        Asserts.notNull(staratDateTime, "staratDateTime不能为空！");
        Date startTime;
        Date endTime;
        if (CommonConstant.ZERO.equals(staratDateTime.toString("H"))) {
            //特殊处理获取前天的时间范围
            endTime = JodaTimeUtils.maxTime(staratDateTime.minusDays(CommonConstant._1).toLocalDate()).toDate();
            startTime = new LocalDateTime(endTime).minusHours(CommonConstant._1).plusSeconds(CommonConstant._1).toDate();
        }else {
            startTime = JodaTimeUtils.toDate(staratDateTime.minusHours(CommonConstant._1).toString(CommonConstant.yyyy_MM_dd_HH));
            endTime = JodaTimeUtils.toDate(staratDateTime.toString(CommonConstant.yyyy_MM_dd_HH));
        }
        return ImmutablePair.of(startTime, endTime);
    }

}


package com.aegonthtf.fate.constant;

/**
 * @description 常量
 */
public class CommonConstant {
    /**
     * Swagger的Controller的包扫描路径
     */
    public static final String BASE_CONTROLLER_PACKAGE = "com.aegonthtf.fate.controller";
    public static final String N                       = "N";
    public static final String Y                       = "Y";
    public static final String LIMIT1                  = "LIMIT 1";
    public static final String ZERO                    = "0";
    public static final int    BATCH_SIZE              = 1000;
    public static final int    BEHAVIOR_BATCH_SIZE     = 500;
    public static final String NULL                    = null;
    public static final String CREATERBATCH            = "batch";
    public static final String JOB_PARAMETERS          = "jobParameters";
    public static       String yyyyMMdd                = "yyyyMMdd";
    public static       String yyyyMM                  = "yyyyMM";
    public static       String yyyy_MM_dd              = "yyyy-MM-dd";
    public static       String yyyyMMddHHmmss          = "yyyyMMddHHmmss";
    public static       String yyyy_MM_dd_HH           = "yyyyMMddHH";
    public static       String HHmm                    = "HHmm";
    public static       String AGENT_STATUS_ACTIVE     = "Active";
    public static final int    _1                      = 1;
    public static final int    _2                      = 2;
    public static final int    _3                      = 3;
    public static final int    _4                      = 4;
    public static final int    _5                      = 5;
    public static final int    _6                      = 6;
    public static final int    _7                      = 7;
    public static final int    _8                      = 8;
    public static final int    _9                      = 9;
    public static final int    _10                     = 10;
    public static final int    _11                     = 11;
    public static final int    _12                     = 12;
    public static final int    _13                     = 13;
    public static final int    _14                     = 14;
    public static final int    _15                     = 15;
    public static final int    _16                     = 16;
    public static final int    _17                     = 17;
    public static final int    _18                     = 18;
    public static final int    _19                     = 19;
    public static final int    _20                     = 20;
    public static final int    _21                     = 21;
    public static final int    _22                     = 22;
    public static final int    _23                     = 23;
    public static final int    _24                     = 24;
    public static final int    _25                     = 25;
    public static final int    _26                     = 26;
    public static final int    _27                     = 27;
    public static final int    _28                     = 28;
    public static final int    _29                     = 29;
    public static final int    _30                     = 30;
    public static final int    _31                     = 31;
    public static final int    _32                     = 32;
    public static final int    _33                     = 33;
    public static final int    _34                     = 34;
    public static final int    _35                     = 35;
    public static final int    _36                     = 36;
    public static final int    _37                     = 37;
    public static final int    _38                     = 38;
    public static final int    _39                     = 39;
    public static final int    _40                     = 40;
    public static final int    _41                     = 41;
    public static final int    _42                     = 42;
    public static final int    _43                     = 43;
    public static final int    _44                     = 44;
    public static final int    _45                     = 45;
    public static final int    _46                     = 46;
    public static final int    _47                     = 47;
    public static final int    _48                     = 48;
    public static final int    _49                     = 49;
    public static final int    _50                     = 50;
}
Young--
关注
专栏目录
spring batch 学习多种场景练习demo项目源码
11-09
spring batch 学习多种场景练习demo项目源码，包括: 1.读取文件--处理--写入文件; 2.读取文件--处理--写入数据库 ; 3.读数据库--处理--写入数据库; 4.读数据库--处理--写入文件; 文件类型包括：CSV,TXT,JSON,XML; 数据库读写操作包括：JDBC 游标,JDBC分页,JDBC存储过程； Hibernate 游标，Hibernate分页，ibatis分页，jpa分页。
spring batch之二 一个简单的spring batch的例子.
idler_bm的专栏
11-01 8903
在实际工作中我们可能需要快速的实现一个spring batch
Spring Boot集成Spring Batch快速入门Demo
最新发布
HBLOG
07-20 1710
Spring Batch 是一个轻量级的开源框架，它提供了一种简单的方式来处理大量的数据。它基于Spring框架，提供了一套批处理框架，可以处理各种类型的批处理任务，如ETL、数据导入/导出、报表生成等。Spring Batch提供了一些重要的概念，如Job、Step、ItemReader、ItemProcessor、ItemWriter等，这些概念可以帮助我们构建可重用的批处理应用程序。
spring batch demo
06-14
Spring Batch批处理框架demo，详细介绍java批处理框架spring batch demo
【SpringBoot系列】最详细demo-- Spring Batch批处理
wufaqidong1的博客
07-18 3968
先用一个图让你有一个大概印象，这个东西是什么JobRepository是用户注册Job的容器，就是存储数据的地方，可以看做是一个数据库的接口，在任务执行的时候需要通过它来记录任务状态等等信息。JobLauncher是任务启动器，通过它来启动任务，可以看做是程序的入口。Job代表着一个具体的任务。Step代表着一个具体的步骤，一个Job可以包含多个Step（想象把大象放进冰箱这个任务需要多少个步骤你就明白了）。Item就是输出->处理->输出，一个完整Step流程。...
spring-batch批处理框架介绍及demo
lewenson的博客
09-03 2397
最近在项目中，有批处理的相关需求。最终选定技术框架为spring-batch批处理框架，在此专栏中为大家分享spring-batch的基础知识与项目遇到的一些实际问题的解决方案。
Spring-batch Demo
06-20
Spring Batch流程介绍： 每个Batch都会包含一个Job。Job就像一个容器，这个容器里装了若干Step，Batch中实际干活的也就是这些Step，至于Step干什么活，无外乎读取数据，处理数据，然后将这些数据存储起来(IconvItemReader用来读取数据，IconvItemProcessor用来处理数据，IconvItemWriter用来写数据) 。JobLaunch用来启动Job，JobRepository是上述处理提供的一种持久化机制，它为JobLauncher，Job，和Step实例提供CRUD操作。 外部控制器调用JobLauncher启动一个Job，Job调用自己的Step去实现对数据的操作，Step处理完成后，再将处理结果一步步返回给上一层，这就是Batch处理实现的一个简单流程。
学会Spring Batch 批处理框架，效率翻倍，上班轻松又快乐
王不困的博客
04-18 1215
Spring Batch 是一个轻量级、全面的批处理框架，旨在支持开发对企业系统的日常操作至关重要的健壮的批处理应用程序。Spring Batch 建立在人们期望的 Spring Framework 特性（生产力、基于 POJO 的开发方法和一般易用性）的基础上，同时使开发人员可以在必要时轻松访问和使用更高级的企业服务。Spring Batch 不是一个调度框架。在商业和开源领域都有许多优秀的企业调度程序（例如 Quartz、Tivoli、Control-M 等）。
GAN代码实操(github代码实操)
wanfuchun的博客
09-10 2683
备注：下载github程序并运行，本人是小白一枚。这也是本人第一次运行ＧＡＮ程序。在这里仅仅将自己的代码实操过程分享出来。附件的tf.subtract()和tf.multiply()函数相对于github有所改动，不然版本配不上会出错。这里附上github源代码链接：https://github.com/Shicoder/DeepLearning_Demo#deeplearning_demo #运...
spring赌上未来的一击：WebFlux性能实测
Cr1556648487的博客
09-08 1363
我们始终都在不遗余力的追求如何开发一个高并发、低延迟的接口。通过本文实操以及linux服务器下长时间的压测，可以验证的是我们可以使用WebFlux来替代SpringMVC，从而获取更好的性能，更高的并发。如果你还和我一样，对WebFlux还一知半解，那么从今天起开始学习起来吧。
springbatch DEMO
09-14
springbatch 文件写入DB， 需要自己创建一个users表 /* SQLyog Professional v10.51 MySQL - 5.5.28-log ********************************************************************* */ /*!40101 SET NAMES utf8 */; create table `users` ( `id` int (6), `user_login` varchar (150), `user_pass` varchar (150), `age` int (6) ); insert into `users` (`id`, `user_login`, `user_pass`, `age`) values('1','123','13','13');
Spring-batch Demo.zip
07-16
Spring-batch Demo.zip Spring-batch Demo.zip Spring-batch Demo.zip
spring-batch-demo.rar
05-30
一个SpringBatch的入门案例，SpringBatch是spring体系下的一个轻量级的批处理框架，使用简单方便，是非常优秀的一个批处理框架。如果你的工作中涉及到了批处理作业，可以考虑使用SpringBatch框架，本案例有详细的注释说明，请查看。
springBoot+springBatch批量处理数据demo
02-29
最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。 最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。
springboot整合sharding-jdbc实现分库分表详解
congge
05-21 6750
springboot整合sharding-jdbc实现分库分表详解
springcloud+nacos+seata分布式事务搭建
blowbob_666的博客
11-06 3794
使用docker部署seata服务端集成springcloud项目实现高可用的分布式事务 本来以为可以面向百度，结果面向百度没一个好使的教程，这里萌新两天时间里踩了无数的坑，终于整理出来了一套适合自己的分布式事务功能。先顶上自己的分布式项目，有空再研究最新版要怎么配置。最近萌新也在找工作，坐标深圳，欢迎大佬们一起交流。 官方文档 http://seata.io/zh-cn/docs/ops/deploy-ha.html 1. 基础准备 docker环境 mysql nacos 2. 基础表建立 为seata
SpringBatch-Demo1
tiantiantbtb的博客
03-24 585
SpringBatch:就是将数据分批次进行处理的过程。比如：银行对账逻辑，跨系统数据同步等。Sping Batch 是一个轻量级的、完善的的批处理框架，旨在帮助企业建立健壮、高效的批处理应用。Spring Batch 是Spring的一个子项目，基于Spring框架为基础的开发的框架Spring Batch 提供大量可重用的组件，比如：日志，追踪，事务，任务作业统计，任务重启，跳过，重复，资源管理等。
springbatch读bat文件demo
06-05
下面是一个 Spring Batch 读取 bat 文件的 demo： 1. 首先需要在 pom.xml 文件中添加 Spring Batch 的依赖： ``` <groupId>org.springframework.batch <artifactId>spring-batch-core <version>4.3.1 ``` 2....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值