定时任务+设计模式+线程池实现数据同步

已于 2024-03-29 17:08:41 修改
阅读量349 收藏 3
点赞数 5
文章标签： 设计模式
于 2024-03-29 16:55:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43513370/article/details/137149327
版权

概述：

        本文章目的在于实现数据同步，这个数据指的是不同系统，不同数据库之间的数据同步。

流程：

        先用文字描述，后面用图片补充

两个系统一个是商品系统，一个是订单系统，在订单系统里面，调用定时任务，拉取商品系统里的商品数据。

代码：

        订单系统定时任务

@Component
public class SyncDataQuartz {

    @Resource
    private TOmsSyncConfigService tOmsSyncConfigService;

    /**
     * @Description 同步PRD数据（全量）
     **/
    public void syncPrdDataFull(){
        // syncType '同步方式 0：全量，1：增量'
        tOmsSyncConfigService.syncPrdDataBySyncType(0);
    }

    /**
     * @Description 同步PRD数据（增量）
     **/
    public void syncPrdDataIncr(){
        // syncType '同步方式 0：全量，1：增量'
        tOmsSyncConfigService.syncPrdDataBySyncType(1);
    }

}

        数据同步配置表service

public interface TOmsSyncConfigService extends IService<TOmsSyncConfigEntity> {
    
    /**
     * @Description 根据同步方式同步Prd数据
     * @Param [syncType]
     **/
    void syncPrdDataBySyncType(int syncType);

    /**
     * @Description 根据Code同步数据
     * @Param [code]
     **/
    void syncDataByCode(String code);

    /**
     * @Description 请求PRD同步
     * @Param [tOmsSyncConfigEntity]
     **/
    ResponseEntity<String> syncPrdRequest(TOmsSyncConfigEntity tOmsSyncConfigEntity);

    /**
     * @Description 调用存储过程
     * @Param [procName,procParams]
     **/
    void callProc(String procName, LinkedHashMap procParams);

    /**
     * @Description 从PRD同步数据
     * @Param [tOmsSyncConfigEntity, syncDataPrd2OmsTemplate]
     **/
    boolean syncDataByPrd(TOmsSyncConfigEntity tOmsSyncConfigEntity, SyncDataPrd2OmsTemplate syncDataPrd2OmsTemplate);

    void callMergeProc(List<Integer> list) ;

    List<TCrmCustomerSyncTempEntity> selectCustomerFromCrm();
}

        同步配置表

public class TOmsSyncConfigEntity implements Serializable {
    private static final long serialVersionUID = 1L;

    @TableId(type = IdType.AUTO)
    @ApiModelProperty(value = "主键")
    private Long id;

    @ApiModelProperty(value = "唯一标识")
    private String code;

    @ApiModelProperty(value = "同步方式 0：全量，1：增量")
    private Integer syncType;

    @ApiModelProperty(value = "最新一次更新时间")
    private String latestSyncTime;

    @ApiModelProperty(value = "同步identity")
    private String syncIdentity;

    @ApiModelProperty(value = "是否开启")
    private Integer isEnable;

    @ApiModelProperty(value = "描述")
    private String description;

    @ApiModelProperty(value = "存储过程名称")
    private String procName;

    @ApiModelProperty(value = "请求url")
    private String requestUrl;

    @ApiModelProperty(value = "创建人id 创建人唯一标识")
    private String createBy;

    @ApiModelProperty(value = "创建时间 创建时间")
    private Date createTime;

    @ApiModelProperty(value = "修改人id 修改人唯一标识")
    private String updateBy;

    @ApiModelProperty(value = "修改时间 修改时间")
    private Date updateTime;

    @ApiModelProperty(value = "状态 默认：0  0=有效 1=无效")
    private Integer status;

    @ApiModelProperty(value = "同步页码")
    @TableField(exist = false)
    private int syncPageNo;

    @ApiModelProperty(value = "同步页大小")
    @TableField(exist = false)
    private int syncPageSize;

    @ApiModelProperty(value = "最大流水号（工厂同步使用）")
    @TableField(exist = false)
    private int maxSerialNumber;

    public String printSyncInfo() {
        return "同步页码：" + this.syncPageNo + "；同步页大小：" + this.syncPageSize +
                "；同步Code：" + this.code + "；同步存储过程名称：" + this.procName +
                "；最新一次更新时间：" + this.latestSyncTime + "；描述：" + this.description;
    }
}

        实现类

public class TOmsSyncConfigServiceImpl extends ServiceImpl<TOmsSyncConfigMapper, TOmsSyncConfigEntity> implements TOmsSyncConfigService {

    @Resource
    private TOmsSyncConfigService tOmsSyncConfigService;

    @Resource
    private TOmsSyncLogService tOmsSyncLogService;

    @Override
    public void syncPrdDataBySyncType(int syncType) {

        // 拿到所有启用的数据同步配置信息
        LambdaQueryWrapper<TOmsSyncConfigEntity> qw1 = new LambdaQueryWrapper<>();
        qw1.eq(TOmsSyncConfigEntity::getIsEnable, true);
        qw1.eq(TOmsSyncConfigEntity::getSyncType, syncType);
        qw1.eq(TOmsSyncConfigEntity::getStatus, 0);
        List<TOmsSyncConfigEntity> syncConfigEntities = this.baseMapper.selectList(qw1);

        // 使用策略工厂 + 线程池调用同步方法
        syncConfigEntities.stream().forEach(syncConfigEntity -> {
            SyncDataHandler syncDataHandler = SyncDataHandlerFactory.getInstance().getHandlerByType(syncConfigEntity.getCode());
            if (syncDataHandler != null) {
                SyncDataThreadPoolUtil.addTask(new SyncDataThreadPoolUtil.SyncDataTask(syncConfigEntity.getDescription()) {
                    @Override
                    public void run() {
                        syncDataHandler.syncData(syncConfigEntity);
                    }
                });
            }
        });

    }

@Override
    public boolean syncDataByPrd(TOmsSyncConfigEntity tOmsSyncConfigEntity, SyncDataPrd2OmsTemplate syncDataPrd2OmsTemplate) {
        // 声明批次ID
        String batchId = UuidUtils.getUUID();
        // 记录同步日志
        TOmsSyncLogEntity syncLogEntity = new TOmsSyncLogEntity();
        syncLogEntity.setSyncIdentity(tOmsSyncConfigEntity.getSyncIdentity());
        syncLogEntity.setSyncTime(new Date());
        syncLogEntity.setSyncBatchId(batchId);
        tOmsSyncLogService.save(syncLogEntity);

        try {
            // 以2000为批次做数据同步
            tOmsSyncConfigEntity.setSyncPageNo(0);
            tOmsSyncConfigEntity.setSyncPageSize(2000);
            int syncCount = 0; // 同步总数量
            int resultCount = 0; // 单次同步数量

            String currentDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(DateUtils.getDate());
            do {
                ResponseEntity<String> responseEntity = null;

                long timeMillisStart = System.currentTimeMillis();
                // 如果调用失败，重试请求，最多5次
                int retryCount = 5;
                while (retryCount != 0) {
                    tOmsSyncConfigEntity.setSyncPageNo(tOmsSyncConfigEntity.getSyncPageNo() + 1);
                    try {
                        // 调用同步接口
                        responseEntity = tOmsSyncConfigService.syncPrdRequest(tOmsSyncConfigEntity);
                        log.info("responseEntity:{}", responseEntity.getBody());
                    } catch (Exception e) {
                        log.error(tOmsSyncConfigEntity.getDescription() + "同步失败，第" + (5 - retryCount + 1) + "次请求,错误信息：" + e.toString());
                        // 休眠五秒，再次请求
                        Thread.sleep(1000 * 5);
                        retryCount--;
                        continue;
                    }
                    retryCount = 0;
                }
                long timeMillisEnd = System.currentTimeMillis();
                log.info("请求PRD耗时：{}", timeMillisEnd - timeMillisStart);

                if (responseEntity == null) {
                    throw new JeecgBootException("同步失败");
                }

                // BatchSave临时表
                ObjectMapper mapper = new ObjectMapper();
                Result result = mapper.readValue(responseEntity.getBody(), Result.class);

                List<LinkedHashMap<String, Object>> resultList = (List<LinkedHashMap<String, Object>>) result.getResult();

                if (resultList != null) {
                    // 模板方法模式调用同步Handler
                    syncDataPrd2OmsTemplate.saveBatchSyncTemp(resultList, batchId);
                }

                resultCount = resultList != null ? resultList.size() : 0;

                syncCount += resultCount;
            } while (resultCount == tOmsSyncConfigEntity.getSyncPageSize()); // 如拿满批次数据，再次请求


            // 更新同步总量
            syncLogEntity.setSyncCount(syncCount);
            tOmsSyncLogService.updateById(syncLogEntity);

            // 声明调用参数
            LinkedHashMap<String, Object> procParams = new LinkedHashMap();
            procParams.put("syncBatchId", batchId);
            procParams.put("syncLogId", syncLogEntity.getId());
            // 调用Proc增量更新OMS数据
            tOmsSyncConfigService.callProc(tOmsSyncConfigEntity.getProcName(), procParams);

            // 获取日志实体
            syncLogEntity = tOmsSyncLogService.getById(syncLogEntity.getId());

            // 回写上一次更新时间
            tOmsSyncConfigEntity.setLatestSyncTime(currentDate);
            tOmsSyncConfigService.updateById(tOmsSyncConfigEntity);
            // 回写同步状态
            syncLogEntity.setSyncResult(1);
            syncLogEntity.setSyncDetails("同步成功");
            tOmsSyncLogService.updateById(syncLogEntity);
        } catch (Exception e) {
            syncLogEntity.setSyncResult(0);
            syncLogEntity.setSyncDetails(e.getMessage());
            tOmsSyncLogService.updateById(syncLogEntity);
            log.error(e.toString());
            return false;
        }
        return true;
    }

}

        数据同步工厂

public class SyncDataHandlerFactory {
    private static Map<String, SyncDataHandler> syncDataMapHandlerMap = Maps.newConcurrentMap();

    private static class SyncDataFactoryHolder {
        private static final SyncDataHandlerFactory INSTANCE = new SyncDataHandlerFactory();
    }

    private SyncDataHandlerFactory(){}

    public static SyncDataHandlerFactory getInstance() {
        return SyncDataFactoryHolder.INSTANCE;
    }

    /**
     * @Description 根据类型获取handler
     * @Date 9:35 2023/4/25
     * @Param [type]
     * @return org.jeecg.modules.omsnew.sync.handler.SyncDataHandler
     **/
    public SyncDataHandler getHandlerByType(String type) {
        return syncDataMapHandlerMap.get(type);
    }

    /**
     * @return void
     * @Description 注册handler处理类
     * @Date 9:35 2023/4/25
     * @Param [type, syncDataHandler]
     **/
    public void register(String type, SyncDataHandler syncDataHandler) {
        //参数判空
        if (type == null || syncDataHandler == null) {
            return;
        }
        syncDataMapHandlerMap.put(type, syncDataHandler);
    }


}

        数据同步公共接口

public interface SyncDataHandler {

    /**
     * @return java.lang.Boolean
     * @Description 同步数据公用接口
     * @Date 10:42 2023/4/25
     * @Param [tOmsSyncConfigEntity]
     **/
    Boolean syncData(TOmsSyncConfigEntity tOmsSyncConfigEntity);

}

        数据同步线程池

public class SyncDataThreadPoolUtil {

    static ThreadPoolExecutor poolExecutor;
    static int addErrorCount = 0;

    static class MyRejectPolicy implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            if (r instanceof SyncDataThread) {
                addErrorCount++;
                SyncDataThread syncDataThread = (SyncDataThread) r;
                log.info(addErrorCount + ":拒绝处理任务: 内容:" + syncDataThread.task.description);
            }
        }
    }

    static {
        ThreadFactory factory = new CustomizableThreadFactory("sync-data-pool-");
        poolExecutor = new ThreadPoolExecutor(40,
                40,
                60L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(500), factory, new MyRejectPolicy());
    }

    static class SyncDataThread<T> extends Thread {
        SyncDataTask task;

        public SyncDataThread(SyncDataTask task) {
            this.task = task;
        }

        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();
            long threadId = Thread.currentThread().getId();
            int size = poolExecutor.getQueue().size();
            int activeCount = poolExecutor.getActiveCount();
            System.out.printf("线程名:%s 线程id:%s 剩余:%s 活跃线程:%s\r\n", threadName, threadId, size, activeCount);
            task.run();
        }
    }

    public static abstract class SyncDataTask {
        String description;

        public abstract void run();

        public SyncDataTask(String description) {
            this.description = description;
        }
    }

    public static <T> void addTask(SyncDataTask task) {
        poolExecutor.execute(new SyncDataThread<T>(task));
    }

}

        具体的产品表的策略

public class SyncPrdProductHandler extends SyncDataPrd2OmsTemplate implements SyncDataHandler, InitializingBean {

    @Resource
    private TOmsSyncConfigService tOmsSyncConfigService;

    @Resource
    private TPrdProductSyncTempService tPrdProductSyncTempService;

    @Override
    public Boolean syncData(TOmsSyncConfigEntity tOmsSyncConfigEntity) {
        return tOmsSyncConfigService.syncDataByPrd(tOmsSyncConfigEntity, this);
    }

    @Override
    public void afterPropertiesSet() {
        SyncDataHandlerFactory.getInstance().register(SyncDataTypeEnum.PRD_PRODUCT.getCode(), this);
    }

    @Override
    public void saveBatchSyncTemp(List<LinkedHashMap<String, Object>> resultList, String batchId) {
        long timeMillisStart = System.currentTimeMillis();
        // 将批次ID插入每条记录
        List<TPrdProductSyncTempEntity> batchSaveList = new ArrayList<>();
        for (LinkedHashMap<String, Object> temp : resultList) {
            TPrdProductSyncTempEntity tPrdProductSyncTempEntity = JSON.parseObject(JSON.toJSONString(temp), TPrdProductSyncTempEntity.class);
            tPrdProductSyncTempEntity.setSyncBatchId(batchId);
            batchSaveList.add(tPrdProductSyncTempEntity);
        }
        long timeMillisEnd = System.currentTimeMillis();
        tPrdProductSyncTempService.saveBatch(batchSaveList);
        log.info("产品数据 batchSave耗时：{}", timeMillisEnd - timeMillisStart);
    }
}

          同步表的模版方法

public abstract class SyncDataPrd2OmsTemplate {

    /**
     * @Description 批量保存同步临时数据
     * @Date 9:39 2023/4/28
     * @Param [resultList, batchId]
     * @return void
     **/
    public abstract void saveBatchSyncTemp(List<LinkedHashMap<String, Object>> resultList, String batchId);

}

        同步枚举类

package org.jeecg.modules.omsnew.sync.enumutils;

/**
 * @ClassName SyncDataTypeEnum
 * @Description 同步数据类型枚举
 * @Author LiQin.Huang
 * @Date 2023/4/25 9:42
 * @Version 1.0
 */
public enum SyncDataTypeEnum {

    PRD_ATTRIBUTE_PRODUCT_ELEMENT("syncPrdAttributeProductElement", "", "同步PRD元素大类"),
    PRD_PURITY("syncPrdPurity", "", "OMS同步PRD成色"),
    PRD_CHANNEL_COMMODITY("syncPrdChannelCommodity", "", "OMS同步PRD渠道商品"),
    PRD_FITTINGS("syncPrdFittings", "", "OMS同步PRD配件"),
    PRD_COUNTER("syncPrdCounter", "", "OMS同步PRD柜台"),
    PRD_CONFIG_SHADING("syncPrdConfigShading", "", "OMS同步PRD底纹"),
    PRD_CONFIG_LATHES_CARVED_FLOWERS("syncPrdConfigLathesCarvedFlowers", "", "OMS同步PRD车花款"),
    PRD_CONFIG_FINISHING_CRAFTSMANSHIP("syncPrdConfigFinishingCraftsmanship", "", "OMS同步PRD饰面工艺"),
    PRD_CONFIG_BRAND_NETWORK("syncPrdConfigBrandNetwork", "", "OMS同步PRD品牌展厅关系"),
    PRD_CONFIG_BRAND("syncPrdConfigBrand", "", "OMS同步PRD品牌"),
    PRD_CONFIG_ATTRIBUTE_CATEGORY("syncPrdConfigAttributeCategory", "", "OMS同步PRD五级分类"),
    PRD_CONFIG_ADDITIONAL_COST("syncPrdConfigAdditionalCost", "", "OMS同步PRD附加工费"),
    PRD_PRODUCT("syncPrdProduct", "", "OMS同步PRD产品数据"),
    PRD_COMMODITY("syncPrdCommodity", "", "OMS同步PRD商品数据"),
    PRD_SPECIFICATION_COMMODITY("syncPrdSpecificationCommodity", "", "OMS同步PRD规格关联数据"),
    PRD_COMMODITY_FITTINGS("syncPrdCommodityFittings", "", "OMS同步PRD配件关联数据"),
    PRD_SUPPLIER_COMMODITY("syncPrdSupplierCommodity", "", "OMS同步PRD供应商关联数据"),
    PRD_SPECIFICATION_ATTRIBUTE("syncPrdSpecificationAttribute", "", "OMS同步PRD商品规格数据"),
    PRD_SUPPLIER_PRODUCTION_NETWORK("syncPrdSupplierProductionNetwork", "", "OMS同步PRD供应商商数据"),
    PRD_COMMODITY_SALE_NETWORK("syncPrdCommoditySaleNetwork", "", "OMS同步PRD商品销售渠道数据"),
    PRD_CONFIG_SALE_NETWORK("syncPrdConfigSaleNetwork", "", "OMS同步PRD销售渠道数据"),
    PRD_CONFIG_PRODUCTION_NETWORK("syncPrdConfigProductionNetwork", "", "OMS同步PRD生产工厂"),
    PRD_SUIT_COMMODITY("syncPrdSuitCommodity", "", "OMS同步PRD套装商品中间表"),
    PRD_FACTORY_INFORMATION("syncPrdFactoryInformation", "", "OMS同步PRD工厂信息维护临时表"),
    FACTORY_CPCCDH("syncFactorySjdcdh", "", "OMS同步工厂素金调出单数据"),
    FACTORY_CPCCDB("syncFactorySjdcdb", "", "OMS同步工厂素金调出单明细数据"),

    CRM_CUSTOMER("syncCrmCustomer", "", "OMS同步CRM客户");





    private String code;

    private String identity;

    private String description;

    SyncDataTypeEnum(String code, String identity, String description) {
        this.code = code;
        this.identity = identity;
        this.description = description;
    }

    public String getCode() {
        return code;
    }

    public String getIdentity() {
        return identity;
    }

    public String getDescription() {
        return description;
    }
}

胡萝卜、
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线程池c++实现
08-03
3. **线程池的设计模式** - **生产者消费者模式**：任务的提交者是生产者，线程是消费者。生产者将任务放入队列，消费者从队列中取出并执行任务。 - **有限容量策略**：线程池可以设定最大线程数量，当达到上限时...
多线程定时任务邮件服务
07-17
实现这样的服务时，设计模式的应用也很关键。例如，单例模式可用于创建定时任务服务的唯一实例，工厂模式可简化邮件服务对象的创建，观察者模式可用于监听数据库变化并触发邮件发送等。 7. **测试与调试**： 在...
【Java 基础篇】Java多线程编程详解：线程创建、同步、线程池与性能优化
繁依Fanyi的博客
09-20 654
在计算机科学领域，线程是指在一个进程内部执行的独立单元。一个进程可以包含多个线程，每个线程都有自己的执行路径，可以独立运行。线程是操作系统进行任务调度和分配的基本单位，它允许我们实现并发执行，使得程序能够更高效地利用计算机资源。
线程的同步 线程池
NuanShuTT的博客
09-16 1437
什么是线程的同步？ 多个线程操作同一个资源的时候回出现资源争夺问题，这就需要线程的同步。 线程的同步要对同一个对象进行，不同对象无法进行线程同步。 线程同步其实就是一种等待机制, 多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用。 实现线程同步的三种方式 synchronized实现线程同步 同一个进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问是的正确性，在访问时加入了锁机制synchronized，当一个
使用Ruoyi的定时任务组件结合XxlCrawler进行数据增量同步实战-以中国地震台网为例
最新发布
夜郎King的博客
05-04 5651
本文需要使用XxlCrawler组件对中国地震外网的地震信息进行增量同步。在第一次全量获取数据后，后面在系统运行过程当中，不需要人工干预，我们采用自动任务的方式，将信息抓取的过程完全有程序来完成。
SpringBoot操作异步线程池，纯编程干货，一看就会！
weixin_63692154的博客
04-30 129
在异步方法上加入@Async注解。在yml文件中加入如下配置。
接口设计与优化
殇的不悔
11-23 1275
之前 见过一个生产问题，就是http调用不设置超时时间，最后响应方进程假死，请求一直占着 线程不释放，拖垮线程池。，这个跟我们公司的数据库同步机制有关，并发情况下，因为优先保证同步，所以并行的插入变成串行啦，就很耗时。示例中我用到了 executor，表示自定义的线程池，为了防止高并发场景下，出现线程过多的问题。参数中传入了 2000 个用户的 id，远程调用接口，会发现该用户。结果非常让人满意，我们的接口耗时，又减少了接近一半！瞬时间的高并发，可能会打垮你的系统。的话，可以考虑先用文件的方式保存，或者。
SpringBoot 定时任务实现数据同步方法，springmvc实战项目
m0_60607562的博客
03-22 818
蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。2912247)]
基于C++实现的HTTP服务器改进版源码+项目使用说明+详细注释.zip
09-21
**②基于信号和管道的定时事件处理**：建立监听数据集（新连接会加入一个数据集和时间结点，新信息读入会读取数据集并修改时间结点），基于sigaction形式实现对信号和信号处理函数的绑定，信号处理函数向管道发送...
线程池+多服务启动程序
10-22
线程池和多服务启动程序是并发编程和系统设计中的重要概念，特别是在大规模并发和高效资源管理的应用场景中。在本文中，我们将深入探讨这两个核心主题，并结合...这种设计模式在现代企业级应用和云计算平台中非常常见。
java多线程设计模式详解.rar
06-06
线程池可以控制并发级别，处理定时任务，以及优雅地关闭线程。 5. **读写锁模式**：在多读少写的情景下，`ReentrantReadWriteLock`提供了一种高效的同步策略。读取操作可以并行进行，而写入操作则独占资源，提高了...
SpringBoot 定时任务实现数据同步方法
2401_83601703的博客
04-03 1253
private String pointId;/***/private String name;/***/private String value;/***/private String code;/***/private Date createTime;}HTTP请求代理工具类===========import lombok.extern.slf4j.Slf4j;import org.apache.http.Consts;import org.apache.http.HttpEntity;import o
线程同步的三种方式
qq_45453784的博客
04-13 7320
线程同步的三种方式：解决了多线程操作的安全问题。
C#定时任务调度之企业项目实战
09-28
本课程内容源于我实际开发中的项目，基于Quartz.NET（开源的作业调度框架）实现的定时任务调度执行项目，已经在生成环境上运行了近3年的时间，经历了公司2个双十一和2个周年庆，非常稳定，实际项目过程中遇到的问题，我也在课程对其解决方案进行介绍，并重头到尾的搭建和实操项目，非常适合于初中级开发人员。
sqlserver 定时任务同步数据
小灰~的博客
09-07 5594
1. 打开 Sql server Management Studio Sql server Management Studio 微软提供了专门操作SQLServer数据库的工具：SQL Server Management Studio， 管理工具的版本最好比数据库的版本大，比如数据库用的是SQLServer2012的，管理工具也用2012版 或者更高版本的。 如果没有请自行下载 2. 通过管理工具连接数据库 若失败，请检查地址，用户名以及密码 3. 创建测试数据（测试用，可忽略..
Java批量数据采用线程池分批同步处理
坐观垂钓者
10-20 2278
第一步：申明线程池 public ExecutorService taskExecutor = new ThreadPoolExecutor(6, Integer.MAX_VALUE, 0, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>()); 第二步：分批处理数据 // 每批次数量 Integer batchCount = 100;Integer start = 0; // 结尾 List list=new ArrayLis.
编写静态多数据源代码并做定时任务实现数据库数据同步
weixin_44735933的博客
02-22 1487
首先我们在SpringBoot的配置文件中将两个数据源配置出来 server: port: 8083 spring: datasource: remote : driver-class-name: com.mysql.cj.jdbc.Driver jdbc-url: jdbc:mysql://21.33.322.22/greer?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serv
"Java多线程设计模式及线程的创建、同步与机制
Java多线程设计模式是一种在Java语言中实现多线程的方法，通过这种方法可以提高程序的并发性和性能。其中包括线程的创建和启动、线程的同步、wait/notify/sleep机制和Worker Pattern等。 首先，线程的创建和启动是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值