多线程导数据

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量129 收藏
点赞数
分类专栏： 多线程 文章标签： java mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45820558/article/details/117254285
版权 
package com.zs.job.migration.info.service.jobhandler;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.annotation.XxlJob;
import com.xxl.job.core.log.XxlJobLogger;
import com.zs.job.migration.info.service.DataMapBiz;
import com.zs.job.migration.info.service.PathMapBiz;
import com.zs.job.migration.info.util.DataSourceUtil;
import com.zs.service.flag.api.service.InfoService;
import com.zs.service.info.api.service.column.ColumnService;
import com.zs.service.info.api.service.info.InfoDetailService;
import com.zs.service.info.api.service.subChannel.SubChannelService;
import com.zs.service.info.api.service.text.InfoDetailTextService;
import com.zs.service.mgr.info.api.service.InfoMgrService;
import com.zs.utils.service.snowflake.ISnowflakeWorker;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.config.annotation.DubboReference;
import org.modelmapper.ModelMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

@Slf4j
@Component
public class ShopDataImportXxlJob {
    private static Logger logger = LoggerFactory.getLogger(ShopDataImportXxlJob.class);

    private final String imageUrl = "https://image.21cp.com/";

    @Value("${datasource.url}")
    private String oldUrl;

    @Value("${datasource.username}")
    private String oldUsername;

    @Value("${datasource.password}")
    private String oldPassword;

    @Value("${new.datasource.url}")
    private String newUrl;

    @Value("${new.datasource.username}")
    private String newUsername;

    @Value("${new.datasource.password}")
    private String newPassword;

    @Resource
    private ISnowflakeWorker snowflakeIdWorker;

    @Resource
    private ModelMapper modelMapper;

    @Resource
    private DataMapBiz dataMapBiz;

    @Resource
    private PathMapBiz pathMapBiz;

    /**
    * 方法功能说明 企业相册数据导入
    *
    * @Params
    * @Return
    * @author 张聪
    */
    @XxlJob("shopUserPhotosJobHandler")
    public ReturnT<String> shopUserPhotosJobHandler(String param) throws Exception {
        int state = 0;
        if (!StringUtils.isBlank(param)) {
            state = Integer.parseInt(param);
        }
        XxlJobLogger.log("XXL-JOB,  shopUserPhotosJobHandler start-----");

        DataSource dataSource = DataSourceUtil.getDataSource("zs_main", oldUrl, oldUsername, oldPassword);
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);


        DataSource dataSourceBanner = DataSourceUtil.getDataSource("zs_shop", newUrl, newUsername, newPassword);
        JdbcTemplate jdbcTemplateBanner = new JdbcTemplate(dataSourceBanner);
        AtomicInteger count = new AtomicInteger(0);
        if (state == 1) {
            long onceCount = 100L;
            int threadTotal = 50;
            int acount = jdbcTemplate.queryForObject("select count(1) from (SELECT g.ENTERPRICE_UUID,g.`NAME`,GROUP_CONCAT(g.DOWNLOAD_URL) FROM(SELECT p.`NAME`,p.ENTERPRICE_UUID ,a.DOWNLOAD_URL FROM zs_fl_photos p LEFT JOIN zs_fl_attachment a ON  p.UUID = a.RELEVANCE_UUID AND p.PHOTO_TYPE = a.RELEVANCE_TYPE WHERE a.ATTACHMENT_TYPE = '0' AND p.ENTERPRICE_UUID is NOT NULL ) g GROUP BY g.`NAME`  )h", Integer.class);
            XxlJobLogger.log("shopUserPhotosJobHandler++++++++++++zonggong+++++++++"+acount);

            long startCount = acount / onceCount;
            final Semaphore semaphore = new Semaphore(threadTotal);
            ExecutorService exec = Executors.newCachedThreadPool();
            for (int i = 0; i <= startCount; i++) {
                long endCount = i + 1;
                long startIndex = i * onceCount;

                exec.execute(() -> {
                    //进行一次批量操作
                    try {
                        semaphore.acquire();
                        String selectSql = " SELECT g.ENTERPRICE_UUID,g.`NAME` TITLE ,GROUP_CONCAT(g.DOWNLOAD_URL) imageUrl FROM(SELECT p.`NAME`,p.ENTERPRICE_UUID ,a.DOWNLOAD_URL FROM zs_fl_photos p LEFT JOIN zs_fl_attachment a ON  p.UUID = a.RELEVANCE_UUID AND p.PHOTO_TYPE = a.RELEVANCE_TYPE " +
                                " WHERE a.ATTACHMENT_TYPE = '0' AND p.ENTERPRICE_UUID is NOT NULL) g GROUP BY g.`NAME` " +
                                " LIMIT "+startIndex +","+onceCount;
                        List<Map<String, Object>> list = jdbcTemplate.queryForList(selectSql);
                        Vector<Map<String, Object>> vector = new Vector<Map<String, Object>>();
                        vector.addAll(list);
                        List<Object[]> args = new ArrayList<Object[]>();
                        for (Map<String, Object> map : vector) {
                            long sid = snowflakeIdWorker.nextId();
                            String userId = map.get("ENTERPRICE_UUID").toString();
                            Long userSid = dataMapBiz.uuidMapSid(userId);
                            String photoName = map.get("TITLE").toString();
                            String imageUrl = map.get("imageUrl").toString();
                            String[] split = imageUrl.split(",");
                            List<String> imageList = Arrays.stream(split).collect(Collectors.toList());
//                            List<String> imageList = JSONArray.parseArray(imageUrl, String.class);
                            List<String> collect = imageList.stream().map(f -> {
                                try {
                                    String imageUrlNew = pathMapBiz.oldPathMapNewPath("uc", "shop", f.toString(), "", "");
                                    return imageUrlNew;
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                                    return f;
                            }).collect(Collectors.toList());
                            int imageType = 0;
                            args.add(new Object[]{sid,userSid,photoName, JSON.toJSONString(collect)});
                        }
                        jdbcTemplateBanner.batchUpdate("insert into shop_user_photo (sid,user_sid,photo_name,photo_img_url)" +
                                " values (?,?,?,?)",args);
                        int size = args.size();
                        count.addAndGet(size);
                        semaphore.release();
                    } catch (Exception e) {
                        log.error("exception", e);
                    }
                });
            }
            exec.shutdown();
            try {
                while (true) {
                    if (exec.isTerminated()) {
                        XxlJobLogger.log("-------------shopUserPhotosJobHandler-------complete-------------");
                        XxlJobLogger.log(String.valueOf(count.get()));
                        break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return ReturnT.SUCCESS;
    }
    /**
    * 方法功能说明 banner图 导入
    *
    * @Params
    * @Return
    * @author 张聪
    */
    @XxlJob("shopBannerJobHandler")
    public ReturnT<String> shopBannerJobHandler(String param) throws Exception {
        int state = 0;
        if (!StringUtils.isBlank(param)) {
            state = Integer.parseInt(param);
        }
        XxlJobLogger.log("XXL-JOB, 栏目 shopBannerJobHandler start-----");

        DataSource dataSource = DataSourceUtil.getDataSource("zs_main", oldUrl, oldUsername, oldPassword);
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);


        DataSource dataSourceBanner = DataSourceUtil.getDataSource("zs_shop", newUrl, newUsername, newPassword);
        JdbcTemplate jdbcTemplateBanner = new JdbcTemplate(dataSourceBanner);
        AtomicInteger count = new AtomicInteger(0);
        if (state == 1) {
            long onceCount = 1000L;
            int threadTotal = 100;
            int acount = jdbcTemplate.queryForObject("SELECT count(1) FROM (SELECT r.USER_ID,b.TITLE,b.IMAGE FROM zs_shop_banner b LEFT JOIN zs_uup_user_to_role r ON r.CORP_ID = b.CORP_ID WHERE b.IS_DELETE = '0' AND r.ROLE_ID = '001' )g", Integer.class);
            XxlJobLogger.log("shopIntroductioJobHandler++zonggong+++++++++++++++++++"+acount);

            long startCount = acount / onceCount;
            final Semaphore semaphore = new Semaphore(threadTotal);
            ExecutorService exec = Executors.newCachedThreadPool();
            for (int i = 0; i <= startCount; i++) {
                long endCount = i + 1;
                long startIndex = i * onceCount;
                exec.execute(() -> {
                    //进行一次批量操作
                    try {
                        semaphore.acquire();
                        String selectSql = " SELECT b.CORP_ID,b.TITLE,b.IMAGE FROM zs_shop_banner b LEFT JOIN zs_uup_user_to_role r ON r.CORP_ID = b.CORP_ID WHERE b.IS_DELETE = '0' AND " +
                                " r.ROLE_ID = '001' LIMIT "+startIndex +","+onceCount;
                        List<Map<String, Object>> list = jdbcTemplate.queryForList(selectSql);
                        Vector<Map<String, Object>> vector = new Vector<Map<String, Object>>();
                        vector.addAll(list);
                        List<Object[]> args = new ArrayList<Object[]>();
                        for (Map<String, Object> map : vector) {
                            long sid = snowflakeIdWorker.nextId();
                            String userId = map.get("CORP_ID").toString();
                            Long userSid = dataMapBiz.uuidMapSid(userId);
                            String advertisingName = map.get("TITLE").toString();
                            String imageUrl = map.get("IMAGE").toString();
                            String imageUrlNew = pathMapBiz.oldPathMapNewPath("uc", "shop", imageUrl, "", "");

                            int imageType = 0;
                            args.add(new Object[]{sid,userSid,"zs",imageType,advertisingName,imageUrlNew});
                        }
                        jdbcTemplateBanner.batchUpdate("insert into shop_user_advertising (sid,user_sid,user_group_type,image_type,advertising_name,advertising_img_url)" +
                                " values (?,?,?,?,?,?)",args);
                        int size = args.size();
                        count.addAndGet(size);
                        semaphore.release();
                    } catch (Exception e) {
                        log.error("exception", e);
                    }
                });

            }
            exec.shutdown();
            try {
                while (true) {
                    if (exec.isTerminated()) {
                        XxlJobLogger.log("-------------shopBannerJobHandler----complete----------------");
                        XxlJobLogger.log(String.valueOf(count.get()));
                        break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return ReturnT.SUCCESS;
    }
    /**
    * 方法功能说明 商铺企业简介导入
    *
    * @Params
    * @Return
    * @author 张聪
    */
    @XxlJob("shopIntroductioJobHandler")
    public ReturnT<String> shopIntroductioJobHandler(String param) throws Exception {
        int state = 0;
        if (!StringUtils.isBlank(param)) {
            state = Integer.parseInt(param);
        }
        XxlJobLogger.log("XXL-JOB, 栏目企业简介 shopIntroductioJobHandler start-----");

        DataSource dataSource = DataSourceUtil.getDataSource("zs_main", oldUrl, oldUsername, oldPassword);
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        DataSource dataSourceBanner = DataSourceUtil.getDataSource("zs_shop", newUrl, newUsername, newPassword);
        JdbcTemplate jdbcTemplateBanner = new JdbcTemplate(dataSourceBanner);
        AtomicInteger count = new AtomicInteger(0);
        if (state == 1) {
            //阈值调大数据库连接容易lost
            long onceCount = 100L;
            int threadTotal = 50;
            int acount = jdbcTemplate.queryForObject("SELECT count(1) FROM zs_shop_config b LEFT JOIN zs_uup_user_to_role r ON r.CORP_ID = b.CORP_ID WHERE b.IS_DELETE = '0' AND r.ROLE_ID = '001' AND ISNULL( b.ENTERPRICE_PROFILE ) = 0 AND LENGTH( trim( b.ENTERPRICE_PROFILE ) ) > 0", Integer.class);
//            int acount = 10;
            XxlJobLogger.log("shopIntroductioJobHandler++++++++zonggong+++++++++++++"+acount);
            long startCount = acount / onceCount;
            final Semaphore semaphore = new Semaphore(threadTotal);
            ExecutorService exec = Executors.newCachedThreadPool();
            for (int i = 0; i <= startCount; i++) {
                long endCount = i + 1;
                long startIndex = i * onceCount;
                exec.execute(() -> {
                    //进行一次批量操作
                    try {
                        semaphore.acquire();
                        XxlJobLogger.log(startIndex+"+++++++++++++++++");
                        //ORDER BY r.USER_ID 不能指定orderBy 否则会很慢
                        String selectSql = "SELECT b.CORP_ID,b.ENTERPRICE_PROFILE FROM zs_shop_config b LEFT JOIN zs_uup_user_to_role r ON r.CORP_ID = b.CORP_ID WHERE b.IS_DELETE = '0' AND r.ROLE_ID = '001' AND ISNULL( b.ENTERPRICE_PROFILE ) = 0 AND LENGTH( trim( b.ENTERPRICE_PROFILE ) ) > 0  " +
                                "  LIMIT "+startIndex +","+onceCount;
                        List<Map<String, Object>> list = jdbcTemplate.queryForList(selectSql);
                        if(list!=null&&list.size()>0){
                        Vector<Map<String, Object>> vector = new Vector<Map<String, Object>>();
                        vector.addAll(list);
                        List<Object[]> args = new ArrayList<Object[]>();
                        List<Object[]> argsText = new ArrayList<Object[]>();
                        for (Map<String, Object> map : vector) {
                            long sid = snowflakeIdWorker.nextId();
                            String userId = map.get("CORP_ID").toString();
                            Long userSid = dataMapBiz.uuidMapSid(userId);
                            String content = map.get("ENTERPRICE_PROFILE").toString();
                            args.add(new Object[]{sid,userSid});
                            argsText.add(new Object[]{sid,content});
                        }
                        jdbcTemplateBanner.batchUpdate("insert into shop_user_introduction (sid,user_sid)" +
                                " values (?,?)",args);
                        jdbcTemplateBanner.batchUpdate("insert into shop_user_introduction_text (shop_user_introduction_sid,content)" +
                                " values (?,?)",argsText);
                        int size = args.size();
                        count.addAndGet(size);
                        }else{
                            XxlJobLogger.log("sql shibai"+selectSql);
                        }
                        XxlJobLogger.log(count.get()+"____________________________________________");
                        semaphore.release();
                    } catch (Exception e) {
                        log.error("exception", e);
                    }
                });

            }
            exec.shutdown();
            try {
                while (true) {
                    if (exec.isTerminated()) {
                        XxlJobLogger.log("-------------shopIntroductioJobHandler插入完成个数为--------------------");
                        XxlJobLogger.log(String.valueOf(count.get()));
                        break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return ReturnT.SUCCESS;
    }

}

执笔忘语
关注
专栏目录
多线程以JDBC的方式返回海量数据
02-05
适合多线程，jdbc的方式获取数据
sqlserver数据导入mysql五:多线程导数据脚本(读取前面拆分的表名进行数据导入)
直到世界的尽头
04-09 1641
#!/usr/bin/perl use Encode; use Encode::CN; use DBI; use Switch; use strict; use Net::HandlerSocket; use threads; use Time::HiRes 'time'; # my $source_name = 'sqldb'; # my $source_user_name = 'zoe
ModelMapper在SpringBoot中使用自定义配置
fxtxz2的专栏
05-10 693
场景 有时候DTO与Model之间不一定是完全匹配上的，这个时候ModelMapper就不知道怎么处理，就需要我们手动处理两层之间的字段映射了。 解决 pom.xml <properties> <modelmapper.version>3.1.0</modelmapper.version> </properties> ... <dependencies> <dependency> <groupId>
spring 中Mapper为什么不用注入，而且mapper用resource注解来进行依赖注入？【记录】
单枪匹码
05-08 1668
springboot已经把所有mapper全部注入到ioc容器中去了，注入的类型是mapperFactoryBean这个工厂bean，它的 id就是mapper接口的小写； 在依赖注入mapper类型的时候，不能用 byType注入，因为mapper的Type是mapperFactoryBean与Mapper接口类型不匹配，只能byName注入； 所以选择@Resource注入，如果不指定name或type，那么@Resource默认按照byName注入，此时的name就是字段的变量名，不是类型的小写，所.
多线程应用：数据库百万级数据导入Excel表格
weixin_47255175的博客
04-09 2872
ThreadPool+CountDownLatch+POI 实现百万数据从DB到Excel，轻松搞定
Java多线程批量数据导入的方法详解
08-25
Java多线程批量数据导入的方法详解 在数据处理中，遇到大量数据导入时，为了提高处理的速度，可以选择使用多线程来批量处理这些处理。常见的场景有大文件导入数据库、数据同步等。在这些场景中，数据导入的过程可以...
多线程导入excel 数据
01-04
在Java编程中，多线程导入Excel数据是一项常见的任务，特别是在大数据处理和高并发场景下。这个场景通常涉及到性能优化和资源管理，以确保系统稳定性和数据一致性。下面将详细阐述多线程导入Excel数据的核心知识点。...
利用Java多线程技术导入数据到Elasticsearch的方法步骤
08-25
在实现多线程导入数据的过程中，会涉及到一系列的技术组件，包括但不限于： - **maven依赖**：为了运行示例代码，需要在项目的pom.xml文件中添加相关的依赖，如mysql-connector-java、elasticsearch、lombok和...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
easyexcel多线程导入数据
05-30
easyexcel是一个基于POI封装的Java处理Excel工具，它提供了多种方式来读写Excel文件，其中包括多线程导入数据。下面是easyexcel多线程导入数据的简单介绍： 1. 配置多线程读取 通过在读取Excel文件时设置读取参数来...
java jdbc导出数据库大量数据
犹达斯的博客
11-04 6775
背景 java 导出数据库数据，在数据量比较大的情况下，如果全部将数据读到内存中再执行写文件，很容易遇到内存溢出；为了避免内存溢出的问题，可以尝试两种方式： 分页查询，每页写一次文件 使用游标的方式，边读边写 分页的方式，当数据量较大的情况下，需要花费一些建立数据库连接的消耗，也不是很推荐，所以可以尝试使用游标的方式； 数据准备 BEGIN FOR i IN 1..2000000 LOOP...
多线程读取数据库
wisdom_get233的博客
08-29 2309
方法一（第一天的小测试） 连接数据库 package com.xinyuan.ms.service; import java.sql.*; import java.util.*; public class ThreadToMysql extends Thread { Integer cid; Integer num; // Integer page; public ThreadToMysql(Integer cid,Integer num){ this.c
poi实现多线程大数据导出
qq_35705176的博客
11-09 1720
Java多线程导出
EasyExcel 如何导出大量数据 和 并发测试大量数据导出
Lazy
06-16 6321
easyExcel解析
Java多线程导出Excel表格， 100w数据量
weixin_46475802的博客
06-26 9194
多线程导出海量数据Excel
Java多线程Jdbc查询_JDBC多线程查询结果汇总
weixin_36212959的博客
02-13 1019
假设单线程查询SQL耗时1S，那么开启两个线程查询SQL理想情况下也是1S多点才对，机器是4核，但是目前结果近乎2倍显然有异；暂且不考虑从线程池获取连接，任务线程核心代码如下：@Overridepublic void run() {long s = System.currentTimeMillis();System.out.println(Thread.currentThread().getNam...
java 多线程 数据同步_java（多线程）实现高性能数据同步
weixin_42486913的博客
02-21 773
首 先在代码与生产库间建立一个Connection，将读取到的数据放在ResultSet对象，然后再与开发库建立一个Connection。从 ResultSet取出数据后通过TestConnection插入到开发库，以此来实现Copy。代码写完后运行程序，速度太慢了，一秒钟只能Copy 一千条数据，生产库上有上亿条数据，按照这个速度同步完要到猴年马月呀,用PreparedStatement批处理速...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 545
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 413
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值