实时批量推送数据 亿级数据插入

最新推荐文章于 2022-09-01 11:05:32 发布
最新推荐文章于 2022-09-01 11:05:32 发布
阅读量448 收藏
点赞数 1
分类专栏： java 文章标签： java 开发语言 后端
wudl
本文链接：https://blog.csdn.net/wudonglianga/article/details/122098297
版权

1. 场景：

通过Jmeter 调用接口 将数据 添加到队列中然后， 再消费队列， 批量插入数据库
在这里插入图片描述

2. 代码

项目结构

在这里插入图片描述

类：ApplicationQueue

package com.wudl.queue.config;


import com.wudl.queue.domain.User;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @author ：wudl
 * @date ：Created in 2021-12-12 22:08
 * @description：
 * @modified By：
 * @version: 1.0
 */

public class ApplicationQueue {
    //队列大小
    static final int QUEUE_MAX_SIZE = 1000;

    static BlockingQueue<User> blockingQueue = new LinkedBlockingQueue<User>(Integer.MAX_VALUE);

    /**
     * 私有的默认构造子，保证外界无法直接实例化
     */
    private ApplicationQueue() {
    }

    ;

    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class SingletonHolder {
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static ApplicationQueue queue = new ApplicationQueue();
    }

    //单例队列
    public static ApplicationQueue getMailQueue() {
        return SingletonHolder.queue;
    }

    //生产入队
    public void produce(User mail) throws InterruptedException {
        blockingQueue.put(mail);
    }

    //消费出队
    public User consume() throws InterruptedException {
        return blockingQueue.take();
    }

    // 获取队列大小
    public int size() {
        return blockingQueue.size();
    }
}

线程MyAppThreadFactory

package com.wudl.queue.config;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author ：wudl
 * @date ：Created in 2021-12-12 22:49
 * @description：
 * @modified By：
 * @version: 1.0
 */

public class MyAppThreadFactory {
    /**
     * 线程池执行器 Executors 首选的线程池
     * ExecutorService executorService=Executors.newCachedThreadPool();
     */
    public static ExecutorService myCachedThreadPool= new ThreadPoolExecutor(0, Integer.MAX_VALUE,
            60L, TimeUnit.MILLISECONDS,
            new SynchronousQueue<Runnable>());
}

消费者

package com.wudl.queue.config;

import com.wudl.queue.domain.User;
import com.wudl.queue.service.UserService;
import lombok.Synchronized;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

/**
 * @author ：wudl
 * @date ：Created in 2021-12-12 22:26
 * @description：
 * @modified By：
 * @version: 1.0
 */

@EnableScheduling   // 1.开启定时任务
@EnableAsync        // 2.开启多线程
@Component
public class UserConsume  {

    @Autowired
    UserService userService;

    List<User> list = new LinkedList<>();
    int number = 0;
    public synchronized   void run() throws Exception {


        while (true) {
            User consume = null;
            try {
                consume = ApplicationQueue.getMailQueue().consume();

                FileWriter fw = new FileWriter("D:\\tmp\\CCCC.txt", true);
                BufferedWriter bw = new BufferedWriter(fw);

                bw.append("消费-->");
                bw.write(consume.toString() + "\r\n ");
                bw.close();
                fw.close();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        list.add(consume);
        if (list.size() >=10)
        {

            List<User> strsSync = Collections.synchronizedList(list);


            userService.insertBatch(strsSync);
            System.out.println(list.size());
            list.clear();
        }
        }
    }

    private static String lock = "";
    @Synchronized
    @Scheduled(fixedDelay = 100)  //间隔1秒
    public void cleanRankListJobExecute() throws Exception {

        User  consume = ApplicationQueue.getMailQueue().consume();

        MyAppThreadFactory.myCachedThreadPool.execute(()->
        {

        });
        try {
            synchronized (lock){
                run();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

接口

package com.wudl.queue.controller;

import com.wudl.queue.domain.User;
import com.wudl.queue.service.UserService;
import com.wudl.queue.service.impl.UserServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;

/**
 * @author ：wudl
 * @date ：Created in 2021-12-12 20:49
 * @description：控制层
 * @modified By：
 * @version: 1.0
 */

@RestController
public class UserController {

//    @Autowired
//    Producer  producer;

    private static String lock = "";
    @Autowired
    UserService userService;
    int i = 0;



    @GetMapping("/user/findall")
    public List<User> findall() throws Exception {


        List<User> all = userService.findAll();

        return all;


    }

    @GetMapping("/user/addUser")
    public String addUser() throws Exception {

        User u = new User();
        u.setId(9);
        u.setUserNo("100014");
        u.setUserName("myhdfs");

        userService.addUser(u);

        return "success";


    }

    @GetMapping("/user/insertBatch")
    public String insertBatch() throws Exception {
        i++;

        User u = new User();
        u.setId(9);
        u.setUserNo("100014"+i);
        u.setUserName("myFlink"+i);
        userService.insertBatchTow(u);
            FileWriter fw = new FileWriter("D:\\tmp\\x.txt", true);
            BufferedWriter bw = new BufferedWriter(fw);

            bw.append("消费-->"+i);
            bw.write(u.toString() + "\r\n ");
            bw.close();
            fw.close();
        return "success";


    }
}

实体类

package com.wudl.queue.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author ：wudl
 * @date ：Created in 2021-12-22 22:50
 * @description：
 * @modified By：
 * @version: 1.0
 */

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private Integer id;
    private String userName;
    private String userNo;
}

持久层

package com.wudl.queue.mapper;

import com.wudl.queue.domain.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * @author ：wudl
 * @date ：Created in 2021-12-22 22:51
 * @description：
 * @modified By：
 * @version: 1.0
 */
@Mapper
public interface UserMapper
{

     /**
      * 查询所有
      * @return
      */
     List<User> findAll();

     void addUser(User user);

    void  insertBatch(List<User> list);

}

接口实现

package com.wudl.queue.service.impl;

import com.wudl.queue.config.ApplicationQueue;
import com.wudl.queue.domain.User;
import com.wudl.queue.mapper.UserMapper;
import com.wudl.queue.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author ：wudl
 * @date ：Created in 2021-12-12 22:12
 * @description：
 * @modified By：
 * @version: 1.0
 */

@Service
public class UserServiceImpl implements UserService {


    @Autowired
    UserMapper userMapper;

//    @Override
//    public void sendQueue(User user) throws Exception {
//        MailQueue.getMailQueue().produce(user);
//
//    }

    @Override
    public List<User> findAll() {
        return userMapper.findAll();
    }

    @Override
    public void addUser(User user) {
        userMapper.addUser(user);
    }

    @Override
    public void insertBatch(List<User> list) {

        userMapper.insertBatch(list);
    }

    @Override
    public void insertBatchTow(User list) throws InterruptedException {

        ApplicationQueue.getMailQueue().produce(list);
//        userMapper.insertBatch(list);
    }


}

接口

package com.wudl.queue.service;


import com.wudl.queue.domain.User;

import java.util.List;

/**
 * @author ：wudl
 * @date ：Created in 2021-12-12 22:11
 * @description：
 * @modified By：
 * @version: 1.0
 */

public interface UserService {
//    public void sendQueue(User user) throws Exception;


    public List<User>  findAll();

    void addUser(User user);
    void insertBatch(List<User> list);
    void insertBatchTow(User list) throws InterruptedException;


}


package com.wudl.queue.utils;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @author ：wudl
 * @date ：Created in 2021-12-12 21:47
 * @description：
 * @modified By：
 * @version: 1.0
 */

public class BlockingQueueMessage {
    public static BlockingQueue<String> queue = new LinkedBlockingQueue<>(5);
}


<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wudl.queue.mapper.UserMapper">
    <select id="findAll" resultType="com.wudl.queue.domain.User">
        select * from user
    </select>

    <insert id="addUser" parameterType="com.wudl.queue.domain.User">

        INSERT INTO user (id,userNo,userName) VALUE(#{id},#{userNo},#{userName})
    </insert>

    <!-- 批量插入 -->
    <insert id ="insertBatch" parameterType="java.util.List" >

        insert into user
        (userNo,userName)
        values
        <foreach collection ="list" item="u" index= "index" separator =",">
            (
             #{u.userNo},
            #{u.userName}
            )
        </foreach >
    </insert >
</mapper>

spring:
  datasource:
    #数据源基本配置
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.1.180:3306/test?serverTimezone=UTC
    type: com.alibaba.druid.pool.DruidDataSource
  #数据源其他配置
  druid:
    #配置初始化大小、最小、最大线程数
    initialSize: 5
    minIdle: 5
    #CPU核数+1，也可以大些但不要超过20，数据库加锁时连接过多性能下降
    maxActive: 20
    #最大等待时间，内网：800，外网：1200（三次握手1s）
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    #配置一个连接在池中最大空间时间，单位是毫秒
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1
    testWhileIdle: true
    #设置从连接池获取连接时是否检查连接有效性，true检查，false不检查
    testOnBorrow: true
    #设置从连接池归还连接时是否检查连接有效性，true检查，false不检查
    testOnReturn: true
    #可以支持PSCache（提升写入、查询效率）
    poolPreparedStatements: true
    #配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,log4j
    #保持长连接
    keepAlive: true
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500


#整合mybatis
mybatis:
  #配置别名
  type-aliases-package: com.wudl.queue.domain
  #配置 xml 文件映射  classpath: = resources   /=当前项目下
  mapper-locations: classpath:mapper/*.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>wudl-LinkedBlockingQueue</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
<!--        <dependency>-->
<!--            <groupId>org.springframework.boot</groupId>-->
<!--            <artifactId>spring-boot-starter</artifactId>-->
<!--        </dependency>-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>


        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
    </build>
</project>

插入结果：100万数据 一条没有丢

在这里插入图片描述

wudl5566
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
大量数据写入的方案
qq_33409840的博客
03-18 407
大量数据写入的方案
SpringBoot 整合 Mybatis
QWQAWAA的博客
12-03 1318
导入依赖 pom.xml <!--开启SpringBoot jdbc--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> .
亿级数据如何分钟级别写入缓存？
诸葛子房的博客
06-27 782
1.背景在做用户画像的过程中经常会遇到，需要将用户数据入缓存的需求，提供给线上服务进行调用，因为最终加工的画像数据普遍会存储在离线表(Hive)或者一些其他存储中(HDFS、Doris 等等)但是这类数据存储的特点非常明显适合一些内部运营系统做数据分析，但是用来做线上系统的高QPS、低延迟的服务，显然是不能满足的。因此就必须将画像数据写入到redis 这种类似的分布式缓存当中。那么如此大量的数据(亿级)，如何能更快地写入到缓存当中呢？2.系统架构设计(1)利用Spark rdd 多分区的方式来进行并行写入缓
闲鱼java系统_闲鱼亿级账户数据迁移的方法
weixin_39620252的博客
02-26 234
1.背景随着闲鱼用户快速增长，运营活动越来越趋于精细和个性化，运营会根据用户偏好为其投放合适的活动，如下图所示在闲鱼首页商品展示时，会在商品的列表中插入活动Banner，通过这些活动banner引导用户进入到相应活动会场，实现会场导流。闲鱼投放系统负责闲鱼运营活动的配置、管理、投放。主要解决了以下几个问题1.配置环境隔离问题，根据开发规范，任何线上业务必须先进行线下环境发布，测试验证通过后再发布上...
MySQL快速插入亿级数据
downdawn
10-18 2807
MySQL快速插入亿级数据 前言 通常我们会有这样的需求：构造数据，大批量插入数据库，以供后续处理。如果是几万几十万的数据那还好说，但如果是上千万上亿的数据，那么我们对速度的追求就更加迫切。 这里我们利用Python来操作MySQL（或者PostgreSQL），采取多进程多协程的方式，实现大批量数据快速插入。 数据库配置 # 查看bulk_insert_buffer_size大小，默认是8M SH...
kettle同步数据库所有的表数据到其他库.rar
03-01
Kettle，全称为Pentaho Data Integration（PDI），是一款强大的ETL（Extract, Transform, Load）工具，常用于数据整合、数据清洗和数据迁移等任务。本示例中的"Kettle同步数据库所有的表数据到其他库.rar"是一个具体...
高中学生成绩管理系统,包含成绩数据分析
最新发布
06-24
8. 家校沟通：系统可以集成通知功能，将成绩更新或重要消息及时推送给家长，促进家校沟通。 9. 预测模型：利用机器学习技术，如线性回归、决策树等，预测未来成绩，为教学策略调整提供参考。 10. 性能优化：为了...
将Excel数据导入android数据库DB文件
02-28
这将把Excel文件中的数据批量插入到SQLite数据库中。 5. **同步到Android设备**: 将修改后的.db文件通过adb命令或者Android Studio的Device File Explorer重新推送到Android设备的对应目录。 6. **在Android应用中...
mysql-oracle数据同步
09-12
4. **使用中间件**：例如阿里云DataHub、Debezium等，它们可以捕获MySQL的变更事件，通过消息传递机制推送到Oracle。 描述中提到的"同时修改mysql数据表标识"可能是指自增主键。在MySQL中，我们通常使用`AUTO_...
oraclemysql数据传输
08-28
5. **数据批理插值**：批理插值是指在大数据量下进行数据插入操作时，一次性处理多条记录，而非一条一条地插入。这样可以大大提高效率，减少数据库系统的负担。 6. **挑战与注意事项**： - **数据类型兼容性**：...
数据推送示例
04-15
数据推送示例说明 （1）项目目标：日志实时展现 （2）实现过程：后台模拟生成动态日志，前端将日志实时展现在页面 （3）客户端所用技术：html5 websocket, 服务器端技术：spring websocket (spring 4.0版以上支持) (4) tomcat7 jdk7 maven
java批量推送_java de Iphone批量推送代码
weixin_33642448的博客
03-02 414
/*** apple批量的推送方法* @param tokens iphone手机获取的token* @param content 推送消息的内容* @param count 应用图标上小红圈上的数值* @param goal 目标服务器 true：正式 false：测试* @parm List 返回发送失败的tokens*/public List ApnsSend(List tokenLi...
多线程实现批量推送数据
weixin_43076660的博客
02-16 1147
1 .采用ThreadPoolExecutor构造方法创建线程池 @Service public class PushProcessServiceImpl implements PushProcessService { @Autowired private PushUtil pushUtil; @Autowired private PushProcessMapper pushProcessMapper; private final static Logger log
数据迁移经验总结——亿级别多表异构的数据迁移工作
waj89757的专栏
08-28 4782
由于系统改版，最近两个月在做数据迁移工作，由于业务的特殊，基本将数据迁移所能踩的坑都踩了一遍，决定好好做个总结。
从百万到亿级，得物触达策略平台是如何做的？
SmartCodeTech的博客
09-01 2322
触达策略这几个字听起来比较抽象，刚开始听到并不能直接理解。简要描述下，触达策略的核心是任务。首先配置任务，任务下有策略，策略下有行为，行为可以发送push推送、发放优惠券、发送消息盒子、发送短信等。然后等到任务执行时间，执行任务下所有行为。...
利用JAVA向Mysql插入一亿数量级数据—效率测评
duan18888的博客
05-20 1783
利用JAVA向Mysql插入一亿数量级数据—效率测评 这几天研究mysql优化中查询效率时，发现测试的数据太少（10万级别），利用 EXPLAIN 比较不同的 SQL 语句，不能够得到比较有效的测评数据，大多模棱两可，不敢通过这些数据下定论。 所以通过随机生成人的姓名、年龄、性别、电话、email、地址 ，向mysql数据库大量插入数据，便于用大量的数据测试 SQL 语句优化效率。、在生成过程中发现使用不同的方法，效率天差万别。 1、先上Mysql数据库，随机生成的人员数据图。分别是ID、姓名、性.
java 迁移百万条数据_数据库快速迁移10亿级数据
weixin_34768234的博客
03-07 1464
数据库快速迁移10亿级数据菜菜呀，咱们业务BJKJ有个表数据需要做迁移程序员主力 Y总现在有多少数据？菜菜大约21亿吧，2017年以前的数据没有业务意义了，给你半天时间把这个事搞定，绩效给你A程序员主力 Y总有绩效奖金吗？菜菜钱的事你去问X总，我当家不管钱程序员主力 Y总...........菜菜问题分析经过几分钟的排查，数据库情况如下：1.数据库采用Sqlserver 2008 R2，单表数据...
SpringBoot使用异步线程池实现生产环境批量数据推送
xiangyangsanren的专栏
01-30 771
这里以我工作中使用过的一个案例来做描述，我所在公司是医疗行业，敏感数据需要上报到某监管平台，所以有一个定时任务在流量较小时（一般是凌晨后）执行上报行为。但特殊时期会存在一定要在工作时间大批量上报数据的情况，且要求短时间内就要完成，此时就考虑写一个专门的异步上报接口手动执行，利用线程池上报，极大提高了速度。
[Spring]Druid连接池+JdbcTemplate增删改查+批量增删改查
qq_37837753的博客
06-17 391
Maven + Spring + Druild连接池 + JdbcTemplate
mysql 百万级数据批量插入
05-14
MySQL是一种流行的关系型数据库，对于批量插入数据，有以下几种方法： 1. 使用LOAD DATA INFILE命令：该命令可以将数据从一个文件中加载到表中。这种方法是最快的插入大量数据的方式，因为它跳过了大部分数据校验和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值