精华内容
下载资源
问答
  • 最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。 最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。
  • java springboot框架实现定时批处理,更新DB字段内容,更新成功后微信短信推送消息给用户
  • 本课程通过讲解Spring Batch的基础知识点以及一些实际的项目示例让大家熟悉如何使用Spring Batch进行大批量数据的同步、处理及转换等。
  • "batch word count" ) ; } public static class Tockenizer implements FlatMapFunction < String , Tuple2 < String , Integer > > { @Override public void flatMap ( String value ,...

    上篇:第 1 节 滑动窗口单词计数(Scala实现)


    准备文件:
    自己在d盘下D:\input\file文件下创建a.txt文本
    在这里插入图片描述
    其中a.txt文本下编辑的的内容为:

    hadoop
    flume
    spark
    hive
    flink
    

    具体代码实现:

    package xuwei.tech;
    
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.java.ExecutionEnvironment;
    import org.apache.flink.api.java.operators.AggregateOperator;
    import org.apache.flink.api.java.operators.DataSource;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.util.Collector;
    
    
    /**
     * 用java实现批处理
     *
     */
    public class BatchWordCountJava {
        public static void main(String[] args)throws Exception {
            //获取flink的运行环境
            ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
            //获取文件的内容
            String inputpath="D:\\input\\file";
            String outPut="D:\\input\\result";
            //获取文件的内容
           DataSource<String> text = env.readTextFile(inputpath);
           AggregateOperator<Tuple2<String, Integer>> counts = text.flatMap(new Tockenizer()).groupBy(0).sum(1);
           counts.writeAsCsv(outPut,"\n"," ");
           env.execute("batch word count");
        }
        public static class Tockenizer implements FlatMapFunction<String, Tuple2<String,Integer>>{
    
            @Override
            public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception {
                 String[] tokens = value.toLowerCase().split("\\W+");
                 for (String token:tokens){
                     if(token.length()>0){
                      out.collect(new Tuple2<String, Integer>(token,1));
                     }
                 }
    
            }
        }
    }
    
    

    运行程序,控制台打印信息:
    在这里插入图片描述
    生成文件数据
    在这里插入图片描述
    发现,数据还做了一个排序
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Batch批量处理sql语句提高效率 package jdbc.batch; import org.junit.jupiter.api.Test; import java.io.FileInputStream; import java.sql.Connection; import java.sql.DriverManager; import java.sql....

    使用之前,需要在连接数据库的url加入 ?rewriteBatchedStatements=true 设置支持批量处理
    在这里插入图片描述

    Batch批量处理sql语句提高效率
    在这里插入图片描述
    在这里插入图片描述

    package jdbc.batch;
    
    import org.junit.jupiter.api.Test;
    
    import java.io.FileInputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    import java.util.Properties;
    
    /**
     *          使用批量处理的机制 一次行执行多条语句
     */
    public class Batch_ {
        @Test
        public void Batch() throws Exception{
            Connection connection =null;
            PreparedStatement preparedStatement =null;
            try {
                Properties properties = new Properties();
                properties.load(new FileInputStream("src/jdbc/db.properties"));
                String user = properties.getProperty("user");
                String password = properties.getProperty("password");
                String url = properties.getProperty("url");
                String driver = properties.getProperty("driver");
                Class.forName(driver);
                connection = DriverManager.getConnection(url, user, password);
                System.out.println("开始执行");
                String sql = "insert into `admin` values (null ,?,?)";
                preparedStatement = connection.prepareStatement(sql);
                long start = System.currentTimeMillis();//开始时间
                for (int i = 0; i < 5000; i++) {
                    preparedStatement.setString(1,"jack"+i);
                    preparedStatement.setString(2,"123");
                    //将sql语句加入到批量处理包中
                    preparedStatement.addBatch();
                    //如果有 1000 条记录时,在执行批量操作
                    if ((i+1)%1000 == 0){//因为i时从0 开始,所以当 i=999 记录时有1000条数据了
                        preparedStatement.executeBatch();
                        //一把清空
                        preparedStatement.clearBatch();
                    }
                }
                long end = System.currentTimeMillis();//结束 时间
                System.out.println("批量处理时间 " + (end-start));
            }  finally {
                if (connection != null) {
                    try {
                        connection.close();
                    } catch (SQLException throwables) {
                        throwables.printStackTrace();
                    }
                }
                if (preparedStatement != null);{
                    try {
                        preparedStatement.close();
                    } catch (SQLException throwables) {
                        throwables.printStackTrace();
                    }
                }
            }
    
        }
    
    }
    
    

    结果5000条sql语句打包处理时间还是很快的1s不到
    在这里插入图片描述

    详细的可以看bilibili 韩老师的讲解
    https://www.bilibili.com/video/BV1zv41157NC?p=19

    展开全文
  • java -- 批量处理图片

    千次阅读 2017-08-16 09:44:01
    用python 写好了 老大说不行,服务器环境不让加,只能用java在写一个 辛辛苦苦花了2个小时,才写出来, io 这一块也学习了学习 代码分享出来。 需求: 一个文件下面有很多子目录,要把这个文件下面的所有图片都整合...


    用python 写好了 老大说不行,服务器环境不让加,只能用java在写一个

    辛辛苦苦花了2个小时,才写出来, io 这一块也学习了学习 代码分享出来。

    需求:
    一个文件下面有很多子目录,要把这个文件下面的所有图片都整合到一个文件里面
    这个文件只能放1W张,默认名字为20170816001 
    年月日编号001
    超过1W张 照片放到第二个文件里面 也就是 002
    20170816002

      全局变量↓
       static Long i=0L;
       static String path2="F:\\img3";//全局复制路劲 修改
       static String wenjianjia="20170816001";
       程序入口↓
       public static void main(String[] args) throws IOException {
    		  String path="F:\\img";//源路径
    		  getFileList(path);
       }
      读取文件的方法↓
       public static void getFileList(String path) throws IOException {
    	  
    	  String path3 = path2 +"\\"+ wenjianjia;//新建文件夹路径
    	  File file2 = new File(path3);
    	  if(file2==null || !file2.isDirectory()){//判断文件夹是否存在
    		  file2.mkdir();//创建
    	  }
          File srcFile=new File(path);//需要复制的文件的源路径
          
          String srcPath=srcFile.getAbsolutePath();//获得源路径
          File[] str=srcFile.listFiles();//获取所有文件
          
          for (File file : str) {
        	  if (file.isDirectory()) { // 判断是文件还是文件夹
                  getFileList(file.getAbsolutePath()); // 获取文件绝对路径
              } else if (file.getName().endsWith("jpg")||file.getName().endsWith("tif")||file.getName().endsWith("tiff")||file.getName().endsWith("jpeg")||file.getName().endsWith("png")||file.getName().endsWith("gif")) { // 判断文件名是否以.avi结尾
                    File aimFile=new File(path2 +"\\"+ wenjianjia);//复制后的文件的目标路径
                    String aimPath=aimFile.getAbsolutePath();//获得目标路径
                    
                    File oldFile=new File(srcPath+"\\"+file.getName()); //需要复制的文件
                    File newFile=new File(aimPath+"\\"+file.getName().replace(".", "_"+(i++)+"."));//复制后的文件
                    if (i==10) {//判断文件中文件个数
                    	Long wenjianjia2 = (Long.parseLong(wenjianjia)+ 1);//强转文件名
                    	wenjianjia=String.valueOf(wenjianjia2);
                    	//判断创建文件的位数
                    	String path4 = path2 +"\\"+ wenjianjia;//新建文件夹路径
    	              	  File file3 = new File(path4);
    	              	  if(file3==null || !file3.isDirectory()){
    	              		  file3.mkdir();
    	              	  }
                    	i=0L;//初始化文件个数
    				}
                    //创建流对象
                    DataInputStream dis=new DataInputStream(new FileInputStream(oldFile));
                    DataOutputStream dos=new DataOutputStream(new FileOutputStream(newFile));
                   
                    int temp;
                    //读写数据
                    while((temp=dis.read())!=-1){//读数据
                       dos.write(temp);//把读到的数据写入到Temp文件中
                    }
                   
                    //关闭流
                    dis.close();
                    dos.close();
                  
                  System.out.println("文件已提取成功!");
                  
              } else {
                  continue;
              }
    
    }

    注释非常全了把 ,自己试着改一改,就可以用了

    当然实在不行看不懂,可以直接来我的github 拿源码(这保证拿下来就能用)


    github  :   https://github.com/252334666/python--Batch-pictures

    展开全文
  • Hibernate完全以面向对象的方式来操作数据库,当程序里以面向对象的方式操作持久化对象时,将被自动转换为对数据库的操作。...为了面对这种批量处理的场景,Hibernate提供了批量处理的解决方案。下面分别
  • Java-Spring-Batch-Job 它是什么? “ Spring Batch提供了可重用的功能,这些功能对于处理大量记录至关重要,包括日志记录/跟踪,事务管理,作业处理统计信息,作业重新启动,跳过和资源管理。它还提供了更高级的...
  • Java批量操作优化

    2020-02-27 18:52:30
    批量获取 开发中,有时候难免需要用到类似findAll()方法,或者说获取...这时候可以采用批量取的方式,比如batchSize为500。 /** * 批量获取任务,删除任务 */ private void cleanTask() { List<String&g...

    批量获取

    开发中,有时候难免需要用到类似findAll()方法,或者说获取表中所有数据。但是当这个量很大时,一次性从数据库中加载到内存中,明显不理智。这时候可以采用批量取的方式,比如batchSize为500。

        /**
         * 批量获取任务,删除任务
         */
        private void cleanTask() {
    
            List<String> projectIds = getAllProjectIds();
    
            if (isNotEmpty(projectIds)) {
    
                int skip = 0;
    
                List<TaskVO> res = null;
    
                do {
                    res = taskService.findAll(skip, batchSize);
    
                    if (res == null || res.isEmpty()) {
                        break;
                    }
    
                    deleteBatchTask(projectIds, res);
    
                    skip = skip + batchSize;
    
                } while (res.size() == batchSize);
            }
        }

    批量删除

    在执行删除操作时,通常我们会foreach遍历着删,但是遍历一次就是与数据库的一次交互。更常见地,每一次删除时,还会有很多相关的级联删除操作,这样更加拉低了页面的相应。有几个地方可以优化:比如采用线程池来执行整个的批量删除操作;比如可以先做假删除,在夜深人静时采用定时任务来删除;再比如,采用批量删除,也就是in语句。这里主要说的也是第三种,但是如果采用in进行批量删除,也需要注意,不能过分信任in的批量,如果数据量过大,一次性in上万条,数据库也扛不住,此时就可以对in再进行批量。

    // 批量删除任务
    Functional.batchExec(taskIds, delIds -> taskDAO.deleteTaskTrue(delIds), batchSize);    
    
        /**
         * 批量删除(真删除)
         *
         * @param taskIds 任务ids
         */
        public void deleteTaskTrue(List<String> taskIds) {
            createDelete().where().in("_id", taskIds).delete();
        }
    public class Functional {
        /**
         * 将集合按指定分批大小进行分批操作
         *
         * @param src
         * @param function
         * @param batchSize
         * @param <K>
         */
        public static <K> void batchExec(List<K> src, Consumer<List<K>> function, int batchSize) {
    
            if (src == null || src.isEmpty()) {
                return;
            }
    
            if (batchSize <= 0) {
                batchSize = 1;
            }
    
            int loopTimes;
    
            if (src.size() % batchSize == 0) {
                loopTimes = src.size() / batchSize;
            } else {
                loopTimes = src.size() / batchSize + 1;
            }
    
            for (int i = 0; i < loopTimes; i++) {
    
                List<K> subList;
    
                if (i == src.size() / batchSize) {
                    subList = src.subList(i * batchSize, src.size());
                } else {
                    subList = src.subList(i * batchSize, (i + 1) * batchSize);
                }
    
                function.accept(subList);
            }
        }
    
        /**
         * 正序排序
         *
         * @param src
         * @param field
         */
        public static void ascSort(List src, String field) {
            sort(src, field, 1);
        }
    
        /**
         * 逆序排序
         *
         * @param src
         * @param field
         */
        public static void descSort(List src, String field) {
            sort(src, field, -1);
        }
    
        private static void sort(List src, String field, int direction) {
    
            if (ValidateUtil.isEmpty(src)) {
                return;
            }
    
            Collections.sort(src, new Comparator<Object>() {
    
                @Override
                public int compare(Object o1, Object o2) {
                    Object value1 = BeanUtil.pojo.getProperty(o1, field);
                    Object value2 = BeanUtil.pojo.getProperty(o2, field);
                    if (value1 != null && value2 != null) {
                        if (value1 instanceof Long) {
                            return ((Long) value1).compareTo((Long) value2) * direction;
                        }
    
                        if (value1 instanceof Integer) {
                            return ((Integer) value1).compareTo((Integer) value2) * direction;
                        }
    
                        if (value1 instanceof Double) {
                            return ((Double) value1).compareTo((Double) value2) * direction;
                        }
    
                        if (value1 instanceof BigDecimal) {
                            return ((BigDecimal) value1).compareTo((BigDecimal) value2) * direction;
                        }
    
                        if (value1 instanceof Date) {
                            return ((Date) value1).compareTo((Date) value2) * direction;
                        }
    
                        if (value1 instanceof String) {
                            return ((String) value1).compareTo((String) value2) * direction;
                        }
                    }
                    return 0;
                }
            });
        }
    
        /**
         * 除重
         *
         * @param src
         * @param <K>
         * @return
         */
        public static <K> List<K> distinct(List<K> src) {
            if (ValidateUtil.isEmpty(src)) {
                return src;
            }
            return new ArrayList<K>(src.stream().collect(Collectors.toSet()));
        }
    }

     

    展开全文
  • java batch批量

    千次阅读 2018-09-18 20:11:58
    String upSql = "update T_D_AC_TRADE_DEP set n_sett_money_due = ? where c_iden_sub = ? "; pst2 = conn.prepareStatement(upSql); while (rs.next()) { Cktz ck = (Cktz)rsTools....
  • Java中大量数据批量处理方式

    万次阅读 2018-05-18 11:11:44
    在订单中心处理订单,总会遇到大批量订单处理的业务,下面就将如何大批量处理数据来提高效率做一个总结; 代码设计:在dao层写批量新增的方法。以及实现dao的实现类,在service调用这个dao就可以了,不过最终走的...
  • 简易批处理Java:trade_mark... 从数据源开始按顺序读取记录,在管道中对其进行处理,然后将其批量写入数据接收器: 该框架提供了Record和Batch API,以一致的方式抽象数据格式并处理记录,而与数据源/接收器类型无关。
  • mybatis-plus_batch_insert:mybatis_plus添加批量插入
  • Spring batch批量处理框架最佳实践

    千次阅读 2020-04-17 23:46:52
    spring batch精选,一文吃透spring batch批量处理框架 前言碎语 批处理是企业级业务系统不可或缺的一部分,spring batch是一个轻量级的综合性批处理框架,可用于开发企业信息系统中那些至关重要的数据批量处理...
  • ok,接下来使用多线程批量处理。 ok,测试 输出结果 老司机开车,飙车有炫酷。多么迷人的idea。放张图镇镇场面。 看题: 备注:学生类 与 地址类 为一对一,学生类 与 电子产品类 为一对多。 要求: ...
  • 您的应用程序中没有足够的堆空间来同时处理它们,因此您想一次“批量处理”它们,每次处理1,000个。 解决方案 使用Aerospike scanAll()方法扫描整个名称空间或名称空间并进行设置。 每条记录一次从一个缓冲队列中...
  • 互联网时代的一个特性是大数据量,面对海量的数据我们...批量任务的处理、系统间的数据同步、历史任务优化等,都可以采用 Spring Batch,让我们一起来窥探批任务处理框架——Spring Batch 吧。 主要内容如下: Spri...
  • 1、准备参数 private  List[]>  preparParam (IDataList ret) {   // 准备入参   List[]> paramList =  new  ArrayList() ; ....batchUpdate(sql ,  params) ; }
  • Java批处理教程

    千次阅读 2020-06-05 04:25:39
    在当今世界,互联网已经改变了我们的生活方式,其主要原因之一是大多数日常琐事都使用互联网。 这导致可用于处理的大量数据。... 批处理是对批量数据执行的,无需人工干预,并且可以长时间运行。 它可...
  • JAVA框架

    千次阅读 2019-10-15 10:42:43
    JAVA框架SpringSpringMVCSpringBootDubboMavenRedisMybatis Spring SpringMVC SpringBoot Dubbo Maven Redis Mybatis
  • spring batch精选,一文吃透spring batch批量处理框架 前言碎语 批处理是企业级业务系统不可或缺的一部分,spring batch是一个轻量级的综合性批处理框架,可用于开发企业信息系统中那些至关重要的数据批量处理业务....
  • 10万+IT人都在关注的图片批量压缩上传方案(完整案例+代码) 背景需求:为了客户端访问图片资源时,加载图片更流畅,体验更好,通常不会直接用原图路径,需要根据不同的场景显示不同规格的缩略图,根据商品关键属性,...
  • MySQL使用Batch批量处理

    千次阅读 2017-03-20 14:42:56
    使用MySQL的Batch批量处理, JDBC驱动版本需要5.1.13或以上 测试使用的JDBC驱动版本:mysql-connector-java-5.1.30-bin 测试表结构如下: CREATE TABLE test (  id int(11) DEFAULT N
  • 设计的话, 是在dao层写批量新增的方法,以及实现类dao的实现类, 在service调用这个dao就可以了! 不过最终走的还是单个只不过是集合的遍历, 所以不用再mapper.xml里面配置方法。 IReconBankOrderCpsBatchDao...
  • java数据库批量插入数据

    千次阅读 2019-12-26 12:10:52
    常见问题 批量处理无法生效 1、rewriteBatchedStatements=true 代码演示 1普通插入方式 10万条数据,耗时15秒 private String url = "jdbc:mysql://localhost:3306/test01"; private String user = "root"; private...
  • java 批量打印工具

    千次阅读 2018-08-16 20:56:00
    本来觉得应该是很简单的事,想想下载一个批量打印工具就搞定了啊,网络上找啊找,要么是病毒,要么是没给钱,有打印限制(一次10张),我晕,这玩意这么简单的事,想想就伤,整天大数据,人工智能的吹着,这TMD的...
  • java 三种批量插入效率比较

    千次阅读 2020-01-19 18:22:49
    批量插入 传统循环插入 Mybatis foreach插入 jdbc批量插入 1、传统循环插入,代码如下 long time = System.currentTimeMillis(); for (int i = 0;... studentMapper.batchInsert("ORDER_NO:" + i); ...
  • java快速批量insert数据

    万次阅读 2016-01-31 15:36:04
    最开始使用最简单的java的for循环语句不停的add对象,但是发现这个效率太低,要插入几百万数据估计得一天,于是在网上找了下,找到一篇直接使用jdbc直接插入数据的,拿下来试了下发现性能虽然比new对象好,但是效率...
  • mybatis在使用批量更新时mysql和oracle有一些差别,记录下以免下次忘记

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,900
精华内容 11,960
关键字:

java批量处理batch

java 订阅