精华内容
下载资源
问答
  • Java与XML实现数据抽取

    2009-11-24 15:21:23
    长期以来,软件成本居高不下的一个重要原因就是缺乏高质量可复用的组件。为此,本文介绍了一个许多应用系统都可能用到的组件———数据...它将Java 与XML 技术相结合,实现数据抽取,生成了XML 数据文件的图形化工具。
  • 主要介绍了基于Java8 Stream API实现数据抽取收集,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java定时实现数据抽取

    千次阅读 2019-08-20 16:45:09
    https://www.cnblogs.com/niudaxianren/p/11077578.html

    https://www.cnblogs.com/niudaxianren/p/11077578.html

    展开全文
  • 通过调用kettle的API接口,实现将一个库的数据转移到另一个数据库中。附件中同时提供了抽取需要的jar包
  • 本程序可以实现抽取随机号码或者抽取出场顺序 详情请看注释。 import java.util.Arrays; import java.util.Scanner; /***  *   * @author 陈钊 本程序可以实现抽取幸运数字和抽取出场顺序  */ ...


    本程序可以实现抽取随机号码或者抽取出场顺序

    详情请看注释。


    import java.util.Arrays;

    import java.util.Scanner;
    /***
     * 
     * @author 陈钊 本程序可以实现抽取幸运数字和抽取出场顺序
     */
    public class Drawing {


    public static void main(String[] args) {

    // TODO Auto-generated method stub


    Scanner sc = new Scanner(System.in);
    System.out.println("Please input the number you need to draw:");
    int k = sc.nextInt();
    System.out.println("Please input the number you can draw:");
    int n = sc.nextInt();
    int temp_n = n;//store n represent :when n==k,this is a problem focus
    //on sequence of drawing numbers.
    if (k > n) {
    System.out.println("K can not more than N!");
    System.exit(-1);
    }

    // 初始化抽取数组
    int[] numbers = new int[n];
    for (int i = 0; i < n; i++) {
    numbers[i] = i + 1;
    }
    int[] result = new int[k];
    for (int i = 0; i < k; i++) {
    // produce a number between 0~n-1
    int r = (int) (Math.random() * n);
    result[i] = numbers[r];
    // move the last element to the random location,
    // in case drawing the same number
    numbers[r] = numbers[n - 1];
    n--;
    }
    //假设n与k相等就是抽取出场顺序
    if (temp_n != k) {
    Arrays.sort(result);
    }
    System.out.println("Result as following:"+Arrays.toString(result));
    for (int a : result) {
    System.out.println(a);
    }
    }
    }
    展开全文
  • 数据抽取穿透调用的穿透接口,下面是收据的抽取和插入过程:线程类public class MyThread extends Thread{ private Statement stmt = null; private Connection conn = null; private Connection conn1 = null;...

    数据抽取穿透调用的穿透接口,下面是收据的抽取和插入过程:

    1. 线程类
    public class MyThread extends Thread{
    	
    	private Statement stmt = null;
    	private Connection conn = null;
    	private Connection conn1 = null;
    	private ResultSet rs = null;
    	private PreparedStatement ps = null;
    	private PreparedStatement ps1 = null;
    	private boolean flag;
    	private boolean flag1;
    	private Integer start;
    	private Integer end;
    	public static final String MYSQLDRIVER = "com.mysql.jdbc.Driver";
    	public static final String URL = "localhost";
    	public static final String USER = "inteloc";
    	public static final String PASSWORD = "123456";
    	
    	@Autowired
    	private ExtractDataService service;
    	
    	
    	//查询数据条数
    	public ThreadParams division(){  
    		JdbcUtil util = new JdbcUtil();
    		ThreadParams params = new ThreadParams();
            //获取要导入的总的数据条数  
            String sql="SELECT COUNT(*) FROM (SELECT\n" +
            		"	J.GC_NO,\n" +
            		"	J.SUMPQ,\n" +
            		"	K.CONTRACT_CAP,\n" +
            		"	D.GC_ID,\n" +
            		"	D.CITY_CODE,\n" +
            		"	D.COUNTY_CODE,\n" +
            		"	D.PROVINCE_CODE,\n" +
            		"	D.POS_X,\n" +
            		"	D.POS_Y\n" +
            		"FROM\n" +
            		"	(\n" +
            		"		SELECT\n" +
            		"			T.GC_NO GC_NO,\n" +
            		"			SUM(T.T_GRA_PQ) SUMPQ\n" +
            		"		FROM\n" +
            		"			TABLEC T\n" +
            		"		GROUP BY\n" +
            		"			T.GC_NO\n" +
            		"	) J,\n" +
            		"	TABLEA K,\n" +
            		"	TABLEB D\n" +
            		"WHERE\n" +
            		"	J.GC_NO = K.GC_NO\n" +
            		"AND K.GC_ID = D.GCA_ID)";  
            try {  
            	conn = util.getConection
    					("oracle.jdbc.driver.OracleDriver",
    					"localhost", 
    					"scott", 
    					"TIGER");
            	stmt = conn.createStatement();
    			rs = stmt.executeQuery(sql);
                  
                while(rs.next()){  
                System.out.println("总记录条数:"+rs.getInt(1));  
                params.setSum(rs.getInt(1));  
                }  
                Integer sum = params.getSum();
                //每30000条记录作为一个分割点  
                if(sum>=30000){  
                    params.setN(sum/30000);  
                    params.setResidue(sum%30000);  
                }else{  
                	params.setResidue(sum);
                }  
                  
                System.out.println(params.getN()+"  "+params.getResidue());  
                  
            } catch (SQLException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
            return params;
              
        }  
    
    	public ArrayList<ExtractDataEntity> getAll(){  
    		ArrayList<ExtractDataEntity> allEntity;
    		ExtractDataEntity entity;
    		JdbcUtil util = new JdbcUtil();
            String sql1="SELECT ROW_NUMBER() OVER(ORDER BY gcId) AS rowNum,\n" +
            		"	J.GC_NO gcNo,\n" +
            		"	J.SUMPQ sumq,\n" +
            		"	K.CONTRACT_CAP contractCap,\n" +
            		"	D.GC_ID gcId,\n" +
    //        		"	D.CITY_CODE cityCode,\n" +
            		"	D.COUNTY_CODE countyCode,\n" +
    //        		"	D.PROVINCE_CODE provinceCode,\n" +
    //        		"	D.POS_X posX,\n" +
    //        		"	D.POS_Y posY\n" +
            		"FROM\n" +
            		"	(\n" +
            		"		SELECT\n" +
            		"			T.GC_NO GC_NO,\n" +
            		"			SUM(T.T_GRA_PQ) SUMPQ\n" +
            		"		FROM\n" +
            		"			tableC T\n" +
            		"		GROUP BY\n" +
            		"			T.GC_NO\n" +
            		"	) J,\n" +
            		"	tableA K,\n" +
            		"	tableB D\n" +
            		"WHERE\n" +
            		"	J.GC_NO = K.GC_NO\n" +
            		"AND K.GC_ID = D.GCA_ID AND rowNum BETWEEN "+start+" AND "+end+"";// where rowNum between "+start+" and "+end;  
    //        Connection conn = null;
    //        Statement stmt = null;
    //        ResultSet rs = null;
            try {  
                System.out.println("正在获取数据...");  
                allEntity=new ArrayList();  
                conn = util.getConection
    					("oracle.jdbc.driver.OracleDriver",
    					"localhost", 
    					"scott", 
    					"TIGER");
            	stmt = conn.createStatement();
    			rs = stmt.executeQuery(sql1);
                while(rs.next()){  
                	entity = new ExtractDataEntity();  
                	entity.setGcNo(rs.getString("gcNo"));  
                	entity.settGraPq(rs.getString("sumq"));  
                	entity.setContractCap(rs.getString("contractCap"));  
                	entity.setGcId(rs.getString("gcId"));  
    //            	entity.setCityCode(rs.getString("cityCode"));  
                	entity.setCountyCode(rs.getString("countyCode"));  
    //            	entity.setProvinceCode(rs.getString("provinceCode"));  
    //                entity.setPosX(rs.getString("posX"));  
    //                entity.setPosY(rs.getString("posY"));  
                    allEntity.add(entity);  
                  System.out.println(entity.getGcNo());  
                }  
                System.out.println("成功获取oracle数据库数据!");  
                return allEntity;  
                  
            } catch (SQLException e) {  
                // TODO Auto-generated catch block  
                System.out.println("获取oracle数据库数据发送异常!");  
                e.printStackTrace();  
            }  
            try {  
                rs.close();  
                stmt.close();  
            } catch (SQLException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
            return null;  
        }  
    	
    	public MyThread(int start,int end) {  
            this.end=end;   
            this.start=start;  
            JdbcUtil util = new JdbcUtil();
            System.out.println("处理掉余数");  
              try {  
                      
                    System.out.println("--------"+Thread.currentThread().getName()+"------------");  
                    System.out.println("加载oracle驱动...");  
                    conn = util.getConection("oracle.jdbc.driver.OracleDriver",
        					"localhost", 
        					"scott", 
        					"TIGER");
                    stmt = conn.createStatement();  
                    System.out.println("连接oracle数据库成功!!");  
                      
                    System.out.println("加载mysql驱动.....");  
                    Class.forName(MYSQLDRIVER);  
                    conn1 = DriverManager.getConnection(URL,USER,PASSWORD);  
                    stmt = conn1.createStatement();  
                    // 关闭事务自动提交  
                    conn1.setAutoCommit(false);  
                    System.out.println("连接mysql数据库成功!!");  
                      
                } catch (Exception e) {  
                    e.printStackTrace();      
                }  
            // TODO Auto-generated constructor stub  
        }
    	
    	
    //	@TargetDataSource(name = "inteloc")
    //	@Scheduled
    	public void inputProjectInfo(ArrayList<ExtractDataEntity> list){  
    		String sql1="insert into tableB(PROJ_ID,CITY_ID,CACP) values (?,?,?)";  
    		try {  
                ps = conn.prepareStatement(sql1);  
                System.out.println("-------------------------等待写入数据条数: "+list.size());  
                for(int i=0;i<list.size();i++){  
                    ps.setString(1, list.get(i).getGcId());  
                    ps.setString(2, list.get(i).getCountyCode());  
                    ps.setString(3, list.get(i).getContractCap());  
                    //插入命令列表  
                    ps.addBatch();  
                    ps.executeUpdate();  
                }  
                ps.executeBatch();  
                conn.commit();  
                  
                ps.close();  
                conn.close();  
                this.flag=false;  
                System.out.println(Thread.currentThread().getName()+"--->OK");  
            } catch (SQLException e) {  
                // TODO Auto-generated catch block  
                System.out.println("向mysql中更新数据时发生异常!");  
                e.printStackTrace();      
            }  
        }  
    	
    	public void inputProjy(ArrayList<ExtractDataEntity> list){
    		String sql1="insert into tableB (ID,PROJ_ID,ENERGY) values (?,?,?)";  
    		try {  
                ps = conn1.prepareStatement(sql1);  
                System.out.println("-------------------------等待写入数据条数: "+list.size());  
                for(int i=0;i<list.size();i++){  
                	 ps.setString(1, list.get(i).getGcId());  
                     ps.setString(2, list.get(i).getGcId());  
                     ps.setString(3, list.get(i).gettGraPq());  
                    //插入命令列表  
                    ps.addBatch();  
                    ps.executeUpdate();  
                }  
                ps.executeBatch();  
                conn1.commit();  
                  
                ps.close();  
                conn1.close();  
                this.flag1=false;  
                System.out.println(Thread.currentThread().getName()+"--->OK");  
            } catch (SQLException e) {  
                // TODO Auto-generated catch block  
                System.out.println("向mysql中更新数据时发生异常!");  
                e.printStackTrace();      
            }  
    	}
    	
    	
    	@Override
    	public void run() {  
            // TODO Auto-generated method stub  
      
            while(true&&flag){  
            	
                this.inputProjectInfo(getAll());  
            }  
            while(true&&flag1){  
            	
                this.inputProjy(getAll());  
            }  
        }  

    2、接口实现类

    public class ExtractDataImple implements ExtractDataService {
    	public void dataMethod() {
    		MyThread thread;
    		ThreadParams division = new MyThread(0,0).division();
    		if(division.getN()<1) {//数据条数小于30000单线程处理  
    			thread = new MyThread(1, division.getSum());
    			Thread t1=new Thread(thread);  
    			t1.start();
    		}else {//大于3000条执行n个线程
    			for(int i=1;i<=division.getN();i++) {
    				new Thread(new MyThread(i)).start();
    			}
    			try {
    				Thread.sleep(1);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			thread = new MyThread(division.getN()*3000+1, division.getResidue());
    			Thread thr = new Thread(thread);
    			thr.start();
    			
    		}
    	}
    }


    展开全文
  • JAVA集成kettle实现数据自动化抽取清洗功能老样子,第一步,环境搭建,jar包准备:一、下载Jar包二、准备测试代码三、运行测试代码,查看运行情况 老样子,第一步,环境搭建,jar包准备: 由于Maven中央仓库以及...

    老样子,第一步,环境搭建,jar包准备:

    由于Maven中央仓库以及好多私有仓库对于kettle的环境jar包未做更新,导致直接去通过maven中央仓库来下载kettle的相关jar包可能有点不全面,这里介绍第二种方式,手动引入第三方的jar包。分为两种情况:
    1.直接把jar包放入项目根目录下的lib文件夹,然后BuilePath,add jar。。。(基本操作,不过多赘述,不会的可以去百度如何引入第三方jar包到自己项目)。
    2.今天主要介绍第二种,将下载的第三方jar包打入自己的maven本地仓库,然后配置maven,自动引入。

    一、下载Jar包

    1.所需要的Jar列表在这里插入图片描述
    2.将mvn放进本次仓库,引入的脚本和配置信息:
    在这里插入图片描述
    3、下载地址:点击 这里下载“Kettle运行jar及其mvn脚本及配置文件”
    说明:下载文件里面包括kettle运行需要的jar包以及将Jar打入本地仓库的脚本以及pom的配置文件,直接可以拿来用。
    以上工作完成:

    二、准备测试代码

    1、kettle的测试代码

    public class KettleManager {
        /**
         * @param jobFile
         * @throws KettleException
         */
        public static void runJob(String jobFile) throws KettleException{
            KettleEnvironment.init();
            JobMeta jm = new JobMeta(jobFile,null);
            Job job = new Job(null,jm);
            job.setVariable("dateNow", "2019-05-14");
            job.start();
            job.waitUntilFinished();
        }
        
        
        public static void runTrans(String transFile) throws KettleException{
        	System.out.println("runTrans run ...");
            KettleEnvironment.init();
            TransMeta tm = new TransMeta(transFile);
            Trans trans = new Trans(tm);
            trans.setVariable("dateNow", "2019-05-14");
            trans.execute(null);
            trans.waitUntilFinished();
            System.out.println("runTrans end ...");
        }  
    }
    

    因为本人开发的是一套自动化功能,所以接上篇,测试直接使用配置的定时器自动化来测试点击这里查看 Quartz定时器的动态配置

    2 定时器测试代码:

    public class FirstJob implements Job {  
    
        private static Logger _log = LoggerFactory.getLogger(FirstJob.class);  
    
        public FirstJob() {  
    
        }  
    
        public void execute(JobExecutionContext context)  
            throws JobExecutionException {  
        	try {
        		_log.error("Hello Job执行时间: " + new Date());  
            	String transFile = "G:\\kettle_work\\scjzfp\\ly\\cs.ktr";
    			KettleManager.runTrans(transFile);
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
        }  
    }  
    

    三、运行测试代码,查看运行情况

    程序运行后台界面:
    在这里插入图片描述
    查看数据库,数据未遗漏,全部抽取完成。
    至此基于Quartz的Kettle自动化抽取,清洗数据功能Demo全部完成。
    若下载文件或者脚本有疑问,请加QQ:1010206529 ,说明情况。

    展开全文
  • 最近做了点Hbase抽取权重的业务,也是第一次做吧,所以记录下来,仅供参考。代码已经注释,如果有问题,可以留言提问。package com.#data.uaa; import java.io.IOException; import java.util.ArrayList; import ...
  • Java实现从数据库抽取数据到Xml

    千次阅读 2006-12-31 11:37:00
    %@page contentType="text/...charset=GBK"%> 用JDOM实现数据库到XML的转换 %@page import="org.jdom.*"%> %@page import="org.jdom.output.*"%> %@page import="java.*"%> %@page import="java.sql.*"%> Stri
  • 原文转自:轻样知生 - 手把手教你使用Kettle JAVA API进行数据抽取 - Tylili Kettle作为一款优秀的数据抽取程序,因为高效稳定的性能,一直被广大使用者所喜爱,并且还在国内广受好评。因为其本身使用纯JAVA编写...
  • java实现抽取json文件指定字段值

    千次阅读 2020-09-10 16:28:41
    使用场景 我有一个5000条数据的json文件,每条数据包含地名、该地的...抽取json指定字段值 json文件格式 { "type": "FeatureCollection", "features": [{ "type": "Feature", "geometry": { "type": "Po
  • java中的线程控制程序从一个数据库中定时自动抽取数据到另一个数据库,实现数据库的同步。代码很详细。 用java中的线程控制程序从一个数据库中定时自动抽取数据到另一个数据库,实现数据库的同步。代码很详细。
  • 基于mysql binlog实现的增量数据抽取

    千次阅读 2019-09-26 21:27:05
    但是实际生产中数据往往都是数仓的构建都是基于数据库的改变做的。Oracle和Sql server都有基于CDC的数据仓库构建方案。而mysql目前已知的方案就是基于binlog来构建数仓。也可以结合binlog和前文所讲的flink做一些...
  • 随机抽取工具java

    2020-02-21 22:09:53
    随机抽取工具使用Java实现,从excel文件中导入学生数据,输入要随机抽取的学生数,即可随机抽取需要的学生数
  • ETL基于RPC服务数据抽取实现分析与实践 RPC服务指标数据抽取,根据服务指标参数抽取数据装载至数仓。 RPC(Remote Procedure Call)—远程过程调用,它是一种通过网络从远程计算机程序上请求服务,而不需要了解...
  • Java爬虫(三)--数据抽取

    千次阅读 2017-08-28 17:14:18
    1、当你有一个HTML文档要从中提取数据,并了解这个HTML文档的结构,应该怎么获取html数据?...3、当在解析获得一个Document实例对象,并查找到一些元素之后,你希望取得在这些元素中的数据,应该怎么做?
  • Java实现mysql、hive、hbase数据库元数据操作数据库元数据mysql的元数据hive的元数据hbase的元数据Java获取元数据Java获取mysql的元数据Java获取hive的元数据Java获取hbase的元数据 数据库元数据数据(Metadata)是...
  • 利用JavaCV实现将视频以帧方式抽取

    千次阅读 2018-03-01 12:01:26
    使用前: 在用JavaCV实现以帧方式抽取视频的前, 我们需要先从bytedeco/javacv下载第三方的压缩包, 解压后按自己的需求往自己的IDE ( * IDEA / Eclipse * ) 导入解压缩包下JAR文件; 接下来就以代码方式来说明如何...
  • HtmlExtractor是一个Java实现的基于模板的网页结构化信息精准抽取组件,本身并不包含爬虫功能,但可被爬虫或其他程序调用以便更精准地对网页结构化信息进行抽取。   HtmlExtractor是为大规模分布式环境设计...
  • JDBC实现从Hive抽取数据导入Oracle

    千次阅读 2017-11-23 17:53:35
    1、在宁波大数据实验环境测试通过了JDBC实现从Hive抽取数据导入Oracle功能。 2、通过查看其它项目的数据库访问配置,知道了云平台上的oracle配置。 3、获取hive的jdbc访问配置。但是无人知道,说保密不告知。 ...
  • Java实现Redis过期数据清除

    千次阅读 2020-04-01 17:22:16
    定期删除设置一个时间间隔,每个时间段都会检测是否有键过期,定期随机抽取键检查和删除. 1.2 惰性删除 被动删除 惰性删除不会在键过期是立即删除,而是当外部获取这个键时删除. 1.3 定时删除 主动删除 ...
  • 数据结构与算法】之跳表(Java实现)---第九篇

    万次阅读 多人点赞 2018-10-30 17:35:10
    博主秋招提前批已拿百度、字节跳动、拼多多、顺丰等公司的offer,可加微信:pcwl_Java一起交流秋招面试经验,可获得博主的秋招简历和复习笔记。 说明:跳表是一种不太常用的数据结构,很多书籍上甚至都没有提及过...
  • 在之前的一篇文章中介绍到如何用Kettle从MySQL...本文进一步介绍如何利用Kettle的定时任务机制结合Linux自带的Cronjob实现从Oracle数据库到Trafodion数据库的定时数据抽取。 首先,需要利用Kettle的Spoon工具创建相
  • java随机抽取-练习

    千次阅读 2019-06-06 12:44:58
    import java.awt.BorderLayout; import java.awt.Font; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.BufferedInputStream; import java.io.Buffered...
  • java随机抽取系统

    2013-11-27 12:55:55
    本程序支持excel数据导入数据源,同时支持导出excel
  • ETL数据抽取工具包

    2018-01-21 00:12:32
    在用于ETL工具进行数据抽取的郭晨各种更通长会出现一个初始化方法在单元测试时可以完美运行单一旦加载到服务器上的时候就会出现异常,一般情况下就是少少这个jar包。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,566
精华内容 30,626
关键字:

java实现数据抽取

java 订阅