5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.elasticsearch.ElasticSearchHelper; 19 | import org.frameworkset.tran.DataStream; 20 | import org.frameworkset.tran.ExportResultHandler; 21 | import org.frameworkset.tran.config.ImportBuilder; 22 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 23 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 24 | import org.frameworkset.tran.schedule.ImportIncreamentConfig; 25 | import org.frameworkset.tran.task.TaskCommand; 26 | import org.slf4j.Logger; 27 | import org.slf4j.LoggerFactory; 28 | 29 | /** 30 | *
Description:
31 | * 32 | *Copyright (c) 2020
33 | * @Date 2020/5/29 10:45 34 | * @author biaoping.yin 35 | * @version 1.0 36 | */ 37 | public class BigTableDemo { 38 | private static Logger logger = LoggerFactory.getLogger(BigTableDemo.class); 39 | public static void main(String args[]){ 40 | BigTableDemo dbdemo = new BigTableDemo(); 41 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 42 | dbdemo.fullAutoUUIDImportData(dropIndice); 43 | } 44 | /** 45 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 46 | */ 47 | public void fullAutoUUIDImportData(boolean dropIndice){ 48 | ImportBuilder importBuilder = ImportBuilder.newInstance(); 49 | //增量定时任务不要删表，但是可以通过删表来做初始化操作 50 | if(dropIndice) { 51 | try { 52 | //清除测试表,导入的时候回重建表，测试的时候加上为了看测试效果，实际线上环境不要删表 53 | String repsonse = ElasticSearchHelper.getRestClientUtil().dropIndice("bigtable"); 54 | System.out.println(repsonse); 55 | } catch (Exception e) { 56 | } 57 | } 58 | 59 | 60 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 61 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 62 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 63 | // log_id和数据库对应的字段一致,就不需要设置setLastValueColumn信息， 64 | // 但是需要设置setLastValueType告诉工具增量字段的类型 65 | DBInputConfig dbInputConfig = new DBInputConfig(); 66 | dbInputConfig.setSql("select * from bigtable "); 67 | importBuilder.setInputConfig(dbInputConfig); 68 | // importBuilder.setSql("select * from td_sm_log "); 69 | /** 70 | * es相关配置 71 | */ 72 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 73 | elasticsearchOutputConfig 74 | .setIndex("bigtable") ;//必填项 75 | // .setIndexType("bigtable") //es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType 76 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 77 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 78 | importBuilder.setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 79 | .setUseLowcase(false) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 80 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 81 | .setBatchSize(5000); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 82 | 83 | // //定时任务配置， 84 | // importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 85 | //// .setScheduleDate(date) //指定任务开始执行时间：日期 86 | // .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 87 | // .setPeriod(10000L); //每隔period毫秒执行，如果不设置，只执行一次 88 | //定时任务配置结束 89 | // 90 | // //设置任务执行拦截器，可以添加多个 91 | // importBuilder.addCallInterceptor(new CallInterceptor() { 92 | // @Override 93 | // public void preCall(TaskContext taskContext) { 94 | // System.out.println("preCall"); 95 | // } 96 | // 97 | // @Override 98 | // public void afterCall(TaskContext taskContext) { 99 | // System.out.println("afterCall"); 100 | // } 101 | // 102 | // @Override 103 | // public void throwException(TaskContext taskContext, Throwable e) { 104 | // System.out.println("throwException"); 105 | // } 106 | // }).addCallInterceptor(new CallInterceptor() { 107 | // @Override 108 | // public void preCall(TaskContext taskContext) { 109 | // System.out.println("preCall 1"); 110 | // } 111 | // 112 | // @Override 113 | // public void afterCall(TaskContext taskContext) { 114 | // System.out.println("afterCall 1"); 115 | // } 116 | // 117 | // @Override 118 | // public void throwException(TaskContext taskContext, Throwable e) { 119 | // System.out.println("throwException 1"); 120 | // } 121 | // }); 122 | // //设置任务执行拦截器结束，可以添加多个 123 | //增量配置开始 124 | // importBuilder.setLastValueColumn("log_id");//手动指定数字增量查询字段，默认采用上面设置的sql语句中的增量变量名称作为增量查询字段的名称，指定以后就用指定的字段 125 | importBuilder.setFromFirst(true);//setFromfirst(false)，如果作业停了，作业重启后从上次截止位置开始采集数据， 126 | //setFromfirst(true) 如果作业停了，作业重启后，重新开始采集数据 127 | importBuilder.setLastValueStorePath("logtable_import");//记录上次采集的增量字段值的文件路径，作为下次增量（或者重启后）采集数据的起点，不同的任务这个路径要不一样 128 | // importBuilder.setLastValueStoreTableName("logs");//记录上次采集的增量字段值的表，可以不指定，采用默认表名increament_tab 129 | importBuilder.setLastValueType(ImportIncreamentConfig.NUMBER_TYPE);//如果没有指定增量查询字段名称，则需要指定字段类型：ImportIncreamentConfig.NUMBER_TYPE 数字类型 130 | // 或者ImportIncreamentConfig.TIMESTAMP_TYPE 日期类型 131 | //增量配置结束 132 | 133 | //映射和转换配置开始 134 | // /** 135 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 136 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 137 | // */ 138 | // importBuilder.addFieldMapping("document_id","docId") 139 | // .addFieldMapping("docwtime","docwTime") 140 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 141 | // 142 | // 143 | // /** 144 | // * 为每条记录添加额外的字段和值 145 | // * 可以为基本数据类型，也可以是复杂的对象 146 | // */ 147 | // importBuilder.addFieldValue("testF1","f1value"); 148 | // importBuilder.addFieldValue("testInt",0); 149 | // importBuilder.addFieldValue("testDate",new Date()); 150 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 151 | // TestObject testObject = new TestObject(); 152 | // testObject.setId("testid"); 153 | // testObject.setName("jackson"); 154 | // importBuilder.addFieldValue("testObject",testObject); 155 | // 156 | // /** 157 | // * 重新设置es数据结构 158 | // */ 159 | // importBuilder.setDataRefactor(new DataRefactor() { 160 | // public void refactor(Context context) throws Exception { 161 | // CustomObject customObject = new CustomObject(); 162 | // customObject.setAuthor((String)context.getValue("author")); 163 | // customObject.setTitle((String)context.getValue("title")); 164 | // customObject.setSubtitle((String)context.getValue("subtitle")); 165 | // customObject.setIds(new int[]{1,2,3}); 166 | // context.addFieldValue("docInfo",customObject);//如果还需要构建更多的内部对象，可以继续构建 167 | // 168 | // //上述三个属性已经放置到docInfo中，如果无需再放置到索引文档中，可以忽略掉这些属性 169 | // context.addIgnoreFieldMapping("author"); 170 | // context.addIgnoreFieldMapping("title"); 171 | // context.addIgnoreFieldMapping("subtitle"); 172 | // } 173 | // }); 174 | //映射和转换配置结束 175 | 176 | /** 177 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 178 | */ 179 | importBuilder.setParallel(true);//设置为多线程并行批量导入,false串行 180 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 181 | importBuilder.setThreadCount(10);//设置批量导入线程池工作线程数量 182 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 183 | 184 | /** 185 | importBuilder.setEsIdGenerator(new EsIdGenerator() { 186 | //如果指定EsIdGenerator，则根据下面的方法生成文档id， 187 | // 否则根据setEsIdField方法设置的字段值作为文档id， 188 | // 如果默认没有配置EsIdField和如果指定EsIdGenerator，则由es自动生成文档id 189 | 190 | @Override 191 | public Object genId(Context context) throws Exception { 192 | return SimpleStringUtil.getUUID();//返回null，则由es自动生成文档id 193 | } 194 | }); 195 | */ 196 | 197 | //设置数据bulk导入任务结果处理回调函数，对每次bulk任务的结果进行成功和失败反馈，然后针对失败的bulk任务通过error方法进行相应处理 198 | importBuilder.setExportResultHandler(new ExportResultHandler5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.elasticsearch.ElasticSearchHelper; 19 | import org.frameworkset.tran.DataStream; 20 | import org.frameworkset.tran.config.ImportBuilder; 21 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 22 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 23 | import org.frameworkset.tran.schedule.ImportIncreamentConfig; 24 | 25 | /** 26 | *
Description: 同步处理程序，如需调试同步功能，直接运行main方法即可
27 | * 28 | *Copyright (c) 2018
29 | * @Date 2018/10/16 18:58 30 | * @author biaoping.yin 31 | * @version 1.0 32 | */ 33 | public class CMSDocumentImport { 34 | public static void main(String args[]){ 35 | CMSDocumentImport dbdemo = new CMSDocumentImport(); 36 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 37 | dbdemo.scheduleImportData( dropIndice); 38 | } 39 | 40 | /** 41 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 42 | */ 43 | public void scheduleImportData(boolean dropIndice){ 44 | ImportBuilder importBuilder = ImportBuilder.newInstance(); 45 | //增量定时任务不要删表，但是可以通过删表来做初始化操作 46 | if(dropIndice) { 47 | try { 48 | //清除测试表,导入的时候回重建表，测试的时候加上为了看测试效果，实际线上环境不要删表 49 | ElasticSearchHelper.getRestClientUtil().dropIndice("dbclobdemo"); 50 | } catch (Exception e) { 51 | } 52 | } 53 | // importBuilder.setDbAdaptor("org.frameworkset.elasticsearch.imp.DMAdaptor"); 54 | 55 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 56 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 57 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 58 | // log_id和数据库对应的字段一致,就不需要设置setLastValueColumn信息， 59 | // 但是需要设置setLastValueType告诉工具增量字段的类型 60 | DBInputConfig dbInputConfig = new DBInputConfig(); 61 | dbInputConfig.setSql("select * from td_cms_document where document_id > #[document_id]"); 62 | importBuilder.setInputConfig(dbInputConfig); 63 | /** 64 | * es相关配置 65 | */ 66 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 67 | elasticsearchOutputConfig 68 | .setIndex("dbclobdemo") //必填项 69 | .setIndexType("_doc") 70 | .setEsIdField("document_id")//设置文档主键，不设置，则自动产生文档id 71 | .setDebugResponse(false)//设置是否将每次处理的reponse打印到日志文件中，默认false 72 | .setDiscardBulkResponse(true);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false;//es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType 73 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 74 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 75 | importBuilder.setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 76 | .setUseLowcase(true) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 77 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 78 | .setBatchSize(5000); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 79 | 80 | //定时任务配置， 81 | importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 82 | // .setScheduleDate(date) //指定任务开始执行时间：日期 83 | .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 84 | .setPeriod(10000L); //每隔period毫秒执行，如果不设置，只执行一次 85 | //定时任务配置结束 86 | // 87 | // //设置任务执行拦截器，可以添加多个 88 | // importBuilder.addCallInterceptor(new CallInterceptor() { 89 | // @Override 90 | // public void preCall(TaskContext taskContext) { 91 | // System.out.println("preCall"); 92 | // } 93 | // 94 | // @Override 95 | // public void afterCall(TaskContext taskContext) { 96 | // System.out.println("afterCall"); 97 | // } 98 | // 99 | // @Override 100 | // public void throwException(TaskContext taskContext, Throwable e) { 101 | // System.out.println("throwException"); 102 | // } 103 | // }).addCallInterceptor(new CallInterceptor() { 104 | // @Override 105 | // public void preCall(TaskContext taskContext) { 106 | // System.out.println("preCall 1"); 107 | // } 108 | // 109 | // @Override 110 | // public void afterCall(TaskContext taskContext) { 111 | // System.out.println("afterCall 1"); 112 | // } 113 | // 114 | // @Override 115 | // public void throwException(TaskContext taskContext, Throwable e) { 116 | // System.out.println("throwException 1"); 117 | // } 118 | // }); 119 | // //设置任务执行拦截器结束，可以添加多个 120 | //增量配置开始 121 | // importBuilder.setLastValueColumn("log_id");//手动指定数字增量查询字段，默认采用上面设置的sql语句中的增量变量名称作为增量查询字段的名称，指定以后就用指定的字段 122 | importBuilder.setFromFirst(true);//setFromfirst(false)，如果作业停了，作业重启后从上次截止位置开始采集数据， 123 | //setFromfirst(true) 如果作业停了，作业重启后，重新开始采集数据 124 | importBuilder.setLastValueStorePath("cmsdocumenttable_import");//记录上次采集的增量字段值的文件路径，作为下次增量（或者重启后）采集数据的起点，不同的任务这个路径要不一样 125 | // importBuilder.setLastValueStoreTableName("logs");//记录上次采集的增量字段值的表，可以不指定，采用默认表名increament_tab 126 | importBuilder.setLastValueType(ImportIncreamentConfig.NUMBER_TYPE);//如果没有指定增量查询字段名称，则需要指定字段类型：ImportIncreamentConfig.NUMBER_TYPE 数字类型 127 | // 或者ImportIncreamentConfig.TIMESTAMP_TYPE 日期类型 128 | //增量配置结束 129 | 130 | //映射和转换配置开始 131 | // /** 132 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 133 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 134 | // */ 135 | // importBuilder.addFieldMapping("document_id","docId") 136 | // .addFieldMapping("docwtime","docwTime") 137 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 138 | // 139 | // 140 | // /** 141 | // * 为每条记录添加额外的字段和值 142 | // * 可以为基本数据类型，也可以是复杂的对象 143 | // */ 144 | // importBuilder.addFieldValue("testF1","f1value"); 145 | // importBuilder.addFieldValue("testInt",0); 146 | // importBuilder.addFieldValue("testDate",new Date()); 147 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 148 | // TestObject testObject = new TestObject(); 149 | // testObject.setId("testid"); 150 | // testObject.setName("jackson"); 151 | // importBuilder.addFieldValue("testObject",testObject); 152 | // 153 | // /** 154 | // * 重新设置es数据结构 155 | // */ 156 | // importBuilder.setDataRefactor(new DataRefactor() { 157 | // public void refactor(Context context) throws Exception { 158 | // CustomObject customObject = new CustomObject(); 159 | // customObject.setAuthor((String)context.getValue("author")); 160 | // customObject.setTitle((String)context.getValue("title")); 161 | // customObject.setSubtitle((String)context.getValue("subtitle")); 162 | // context.addFieldValue("docInfo",customObject);//如果还需要构建更多的内部对象，可以继续构建 163 | // 164 | // //上述三个属性已经放置到docInfo中，如果无需再放置到索引文档中，可以忽略掉这些属性 165 | // context.addIgnoreFieldMapping("author"); 166 | // context.addIgnoreFieldMapping("title"); 167 | // context.addIgnoreFieldMapping("subtitle"); 168 | // } 169 | // }); 170 | //映射和转换配置结束 171 | 172 | /** 173 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 174 | */ 175 | importBuilder.setParallel(false);//设置为多线程并行批量导入,false串行 176 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 177 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 178 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 179 | 180 | 181 | /** 182 | * 执行数据库表数据导入es操作 183 | */ 184 | DataStream dataStream = importBuilder.builder(); 185 | dataStream.execute();//执行导入操作 186 | 187 | 188 | 189 | } 190 | } 191 | -------------------------------------------------------------------------------- /src/main/java/org/frameworkset/elasticsearch/imp/CustomObject.java: -------------------------------------------------------------------------------- 1 | package org.frameworkset.elasticsearch.imp; 2 | /** 3 | * Copyright 2008 biaoping.yin 4 | *5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | /** 19 | *
Description:
20 | * 21 | *Copyright (c) 2018
22 | * @Date 2018/9/4 10:37 23 | * @author biaoping.yin 24 | * @version 1.0 25 | */ 26 | public class CustomObject { 27 | private String title; 28 | private String subtitle; 29 | private String author; 30 | private int[] ids; 31 | 32 | public String getTitle() { 33 | return title; 34 | } 35 | 36 | public void setTitle(String title) { 37 | this.title = title; 38 | } 39 | 40 | public String getSubtitle() { 41 | return subtitle; 42 | } 43 | 44 | public void setSubtitle(String subtitle) { 45 | this.subtitle = subtitle; 46 | } 47 | 48 | public String getAuthor() { 49 | return author; 50 | } 51 | 52 | public void setAuthor(String author) { 53 | this.author = author; 54 | } 55 | 56 | public int[] getIds() { 57 | return ids; 58 | } 59 | 60 | public void setIds(int[] ids) { 61 | this.ids = ids; 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /src/main/java/org/frameworkset/elasticsearch/imp/DMAdaptor.java: -------------------------------------------------------------------------------- 1 | package org.frameworkset.elasticsearch.imp; 2 | /** 3 | * Copyright 2008 biaoping.yin 4 | *5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import com.frameworkset.orm.adapter.DBOracle; 19 | 20 | /** 21 | *
Description: 达梦数据库adaptor
22 | * 23 | *Copyright (c) 2018
24 | * @Date 2019/4/21 13:28 25 | * @author biaoping.yin 26 | * @version 1.0 27 | */ 28 | public class DMAdaptor extends DBOracle { 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/org/frameworkset/elasticsearch/imp/DbTimestamp.java: -------------------------------------------------------------------------------- 1 | package org.frameworkset.elasticsearch.imp; 2 | /** 3 | * Copyright 2008 biaoping.yin 4 | *5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import com.frameworkset.util.SimpleStringUtil; 19 | import org.frameworkset.elasticsearch.ElasticSearchHelper; 20 | import org.frameworkset.tran.DataRefactor; 21 | import org.frameworkset.tran.DataStream; 22 | import org.frameworkset.tran.EsIdGenerator; 23 | import org.frameworkset.tran.ExportResultHandler; 24 | import org.frameworkset.tran.config.ImportBuilder; 25 | import org.frameworkset.tran.context.Context; 26 | import org.frameworkset.tran.metrics.TaskMetrics; 27 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 28 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 29 | import org.frameworkset.tran.schedule.CallInterceptor; 30 | import org.frameworkset.tran.schedule.ImportIncreamentConfig; 31 | import org.frameworkset.tran.schedule.TaskContext; 32 | import org.frameworkset.tran.task.TaskCommand; 33 | import org.slf4j.Logger; 34 | import org.slf4j.LoggerFactory; 35 | 36 | import java.util.Date; 37 | 38 | /** 39 | *
Description: 基于时间戳db-es增量同步案例，如需调试同步功能，直接运行main方法debug即可 40 | *
41 | *Copyright (c) 2018
42 | * @Date 2018/9/27 20:38 43 | * @author biaoping.yin 44 | * @version 1.0 45 | */ 46 | public class DbTimestamp { 47 | private static Logger logger = LoggerFactory.getLogger(DbTimestamp.class); 48 | public static void main(String args[]){ 49 | DbTimestamp dbdemo = new DbTimestamp(); 50 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 51 | // dbdemo.fullImportData( dropIndice); 52 | // dbdemo.scheduleImportData(dropIndice); 53 | dbdemo.scheduleTimestampImportData(dropIndice); 54 | // dbdemo.scheduleImportData(dropIndice); 55 | // args[1].charAt(0) == args[2].charAt(0); 56 | } 57 | 58 | /** 59 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 60 | */ 61 | public void scheduleTimestampImportData(boolean dropIndice){ 62 | ImportBuilder importBuilder = ImportBuilder.newInstance(); 63 | //增量定时任务不要删表，但是可以通过删表来做初始化操作 64 | if(dropIndice) { 65 | try { 66 | //清除测试表,导入的时候回重建表，测试的时候加上为了看测试效果，实际线上环境不要删表 67 | String repsonse = ElasticSearchHelper.getRestClientUtil().dropIndice("dbtimedemo"); 68 | System.out.println(repsonse); 69 | } catch (Exception e) { 70 | } 71 | } 72 | 73 | 74 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 75 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 76 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 77 | // 需要设置setLastValueColumn信息log_id， 78 | // 通过setLastValueType方法告诉工具增量字段的类型，默认是数字类型 79 | DBInputConfig dbInputConfig = new DBInputConfig(); 80 | dbInputConfig.setDbName("test") 81 | .setSql("select * from td_sm_log where LOG_OPERTIME > #[LOG_OPERTIME]"); 82 | importBuilder.setInputConfig(dbInputConfig); 83 | 84 | /** 85 | * es相关配置 86 | */ 87 | // importBuilder.setTargetElasticsearch("default,test");//同步数据到两个es集群 88 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 89 | elasticsearchOutputConfig.setTargetElasticsearch("test"); 90 | elasticsearchOutputConfig 91 | .setIndex("dbtimedemo") ;//必填项 92 | // .setIndexType("dbdemo") //es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType 93 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 94 | //elasticsearchOutputConfig.setEsIdField("log_id");//设置文档主键，不设置，则自动产生文档id 95 | 96 | elasticsearchOutputConfig.setDebugResponse(false);//设置是否将每次处理的reponse打印到日志文件中，默认false 97 | elasticsearchOutputConfig.setDiscardBulkResponse(false);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false 98 | 99 | elasticsearchOutputConfig.setEsIdGenerator(new EsIdGenerator() { 100 | //如果指定EsIdGenerator，则根据下面的方法生成文档id， 101 | // 否则根据setEsIdField方法设置的字段值作为文档id， 102 | // 如果默认没有配置EsIdField和如果指定EsIdGenerator，则由es自动生成文档id 103 | 104 | @Override 105 | public Object genId(Context context) throws Exception { 106 | return SimpleStringUtil.getUUID();//返回null，则由es自动生成文档id 107 | } 108 | }); 109 | 110 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 111 | 112 | importBuilder.setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 113 | .setUseLowcase(true) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 114 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 115 | .setBatchSize(10); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 116 | 117 | //定时任务配置， 118 | importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 119 | // .setScheduleDate(date) //指定任务开始执行时间：日期 120 | .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 121 | .setPeriod(5000L); //每隔period毫秒执行，如果不设置，只执行一次 122 | //定时任务配置结束 123 | // 124 | // //设置任务执行拦截器，可以添加多个，定时任务每次执行的拦截器 125 | importBuilder.addCallInterceptor(new CallInterceptor() { 126 | @Override 127 | public void preCall(TaskContext taskContext) { 128 | 129 | } 130 | 131 | @Override 132 | public void afterCall(TaskContext taskContext) { 133 | logger.info(taskContext.getJobTaskMetrics().toString()); 134 | } 135 | 136 | @Override 137 | public void throwException(TaskContext taskContext, Throwable e) { 138 | System.out.println("throwException"); 139 | } 140 | }); 141 | // //设置任务执行拦截器结束，可以添加多个 142 | //增量配置开始 143 | // importBuilder.setStatusDbname("test");//设置增量状态数据源名称 144 | importBuilder.setLastValueColumn("LOG_OPERTIME");//手动指定数字增量查询字段，默认采用上面设置的sql语句中的增量变量名称作为增量查询字段的名称，指定以后就用指定的字段 145 | importBuilder.setFromFirst(false);//setFromfirst(false)，如果作业停了，作业重启后从上次截止位置开始采集数据， 146 | // setFromfirst(true) 如果作业停了，作业重启后，重新开始采集数据 147 | importBuilder.setLastValueStorePath("dbtimees_import");//记录上次采集的增量字段值的文件路径，作为下次增量（或者重启后）采集数据的起点，不同的任务这个路径要不一样 148 | importBuilder.setLastValueType(ImportIncreamentConfig.TIMESTAMP_TYPE);//如果没有指定增量查询字段名称，则需要指定字段类型：ImportIncreamentConfig.NUMBER_TYPE 数字类型 149 | // SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); 150 | // try { 151 | // Date date = format.parse("2000-01-01"); 152 | // importBuilder.setLastValue(date);//增量起始值配置 153 | // } 154 | // catch (Exception e){ 155 | // e.printStackTrace(); 156 | // } 157 | // 或者ImportIncreamentConfig.TIMESTAMP_TYPE 日期类型 158 | //增量配置结束 159 | 160 | // 161 | /** 162 | * 重新设置es数据结构 163 | */ 164 | importBuilder.setDataRefactor(new DataRefactor() { 165 | public void refactor(Context context) throws Exception { 166 | // Date date = context.getDateValue("LOG_OPERTIME"); 167 | context.addFieldValue("collecttime",new Date()); 168 | } 169 | }); 170 | //映射和转换配置结束 171 | 172 | /** 173 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 174 | */ 175 | importBuilder.setParallel(true);//设置为多线程并行批量导入,false串行 176 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 177 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 178 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 179 | 180 | importBuilder.setExportResultHandler(new ExportResultHandler5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.tran.DataRefactor; 19 | import org.frameworkset.tran.DataStream; 20 | import org.frameworkset.tran.ExportResultHandler; 21 | import org.frameworkset.tran.config.ImportBuilder; 22 | import org.frameworkset.tran.context.Context; 23 | import org.frameworkset.tran.metrics.TaskMetrics; 24 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 25 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 26 | import org.frameworkset.tran.schedule.CallInterceptor; 27 | import org.frameworkset.tran.schedule.ImportIncreamentConfig; 28 | import org.frameworkset.tran.schedule.TaskContext; 29 | import org.frameworkset.tran.task.TaskCommand; 30 | import org.slf4j.Logger; 31 | import org.slf4j.LoggerFactory; 32 | 33 | import java.util.Date; 34 | 35 | /** 36 | *
Description: 基于数字类型db-es增量同步案例，同步处理程序，如需调试同步功能，直接运行main方法即可 37 | *
38 | *Copyright (c) 2018
39 | * @Date 2018/9/27 20:38 40 | * @author biaoping.yin 41 | * @version 1.0 42 | */ 43 | public class Dbdemo { 44 | private static Logger logger = LoggerFactory.getLogger(Dbdemo.class); 45 | public static void main(String args[]){ 46 | Dbdemo dbdemo = new Dbdemo(); 47 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 48 | // dbdemo.fullImportData( dropIndice); 49 | // dbdemo.scheduleImportData(dropIndice); 50 | dbdemo.scheduleTimestampImportData(dropIndice); 51 | // dbdemo.scheduleImportData(dropIndice); 52 | // args[1].charAt(0) == args[2].charAt(0); 53 | } 54 | 55 | /** 56 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 57 | */ 58 | public void scheduleTimestampImportData(boolean dropIndice){ 59 | ImportBuilder importBuilder = new ImportBuilder() ; 60 | DBInputConfig dbInputConfig = new DBInputConfig(); 61 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 62 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 63 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 64 | // 需要设置setLastValueColumn信息log_id， 65 | // 通过setLastValueType方法告诉工具增量字段的类型，默认是数字类型 66 | 67 | // importBuilder.setSql("select * from td_sm_log where LOG_OPERTIME > #[LOG_OPERTIME]"); 68 | dbInputConfig.setSql("select log_id, log_operuser, op_orgid, oper_module, log_visitorial, log_opertime, log_content, remark1, oper_type, testint " + 69 | "from td_sm_log where log_id > #[log_id]") 70 | .setDbName("test"); 71 | dbInputConfig.setParallelDatarefactor(true); 72 | importBuilder.setInputConfig(dbInputConfig); 73 | 74 | 75 | // importBuilder.addFieldMapping("LOG_CONTENT","message"); 76 | // importBuilder.addIgnoreFieldMapping("remark1"); 77 | // importBuilder.setSql("select * from td_sm_log "); 78 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 79 | elasticsearchOutputConfig.setTargetElasticsearch("default") 80 | .setIndex("dbdemo") 81 | .setEsIdField("log_id")//设置文档主键，不设置，则自动产生文档id 82 | .setDebugResponse(false)//设置是否将每次处理的reponse打印到日志文件中，默认false 83 | .setDiscardBulkResponse(false);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false 84 | /** 85 | elasticsearchOutputConfig.setEsIdGenerator(new EsIdGenerator() { 86 | //如果指定EsIdGenerator，则根据下面的方法生成文档id， 87 | // 否则根据setEsIdField方法设置的字段值作为文档id， 88 | // 如果默认没有配置EsIdField和如果指定EsIdGenerator，则由es自动生成文档id 89 | 90 | @Override 91 | public Object genId(Context context) throws Exception { 92 | return SimpleStringUtil.getUUID();//返回null，则由es自动生成文档id 93 | } 94 | }); 95 | */ 96 | // .setIndexType("dbdemo") ;//es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType; 97 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 98 | /** 99 | * es相关配置 100 | */ 101 | // elasticsearchOutputConfig.setTargetElasticsearch("default,test");//同步数据到两个es集群 102 | 103 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 104 | importBuilder 105 | // 106 | .setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 107 | .setUseLowcase(true) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 108 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 109 | .setBatchSize(10); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 110 | 111 | //定时任务配置， 112 | importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 113 | // .setScheduleDate(date) //指定任务开始执行时间：日期 114 | .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 115 | .setPeriod(5000L); //每隔period毫秒执行，如果不设置，只执行一次 116 | //定时任务配置结束 117 | // 118 | // //设置任务执行拦截器，可以添加多个，定时任务每次执行的拦截器 119 | importBuilder.addCallInterceptor(new CallInterceptor() { 120 | @Override 121 | public void preCall(TaskContext taskContext) { 122 | System.out.println("preCall"); 123 | } 124 | 125 | @Override 126 | public void afterCall(TaskContext taskContext) { 127 | System.out.println("afterCall"); 128 | } 129 | 130 | @Override 131 | public void throwException(TaskContext taskContext, Throwable e) { 132 | System.out.println("throwException"); 133 | } 134 | }); 135 | // //设置任务执行拦截器结束，可以添加多个 136 | //增量配置开始 137 | // importBuilder.setStatusDbname("test");//设置增量状态数据源名称 138 | importBuilder.setLastValueColumn("log_id");//手动指定数字增量查询字段，默认采用上面设置的sql语句中的增量变量名称作为增量查询字段的名称，指定以后就用指定的字段 139 | importBuilder.setFromFirst(true);//setFromfirst(false)，如果作业停了，作业重启后从上次截止位置开始采集数据， 140 | // setFromfirst(true) 如果作业停了，作业重启后，重新开始采集数据 141 | importBuilder.setStatusDbname("logtable"); 142 | importBuilder.setLastValueStorePath("logtable_import");//记录上次采集的增量字段值的文件路径，作为下次增量（或者重启后）采集数据的起点，不同的任务这个路径要不一样 143 | importBuilder.setLastValueStoreTableName("logstable");//记录上次采集的增量字段值的表，可以不指定，采用默认表名increament_tab 144 | importBuilder.setLastValueType(ImportIncreamentConfig.NUMBER_TYPE);//如果没有指定增量查询字段名称，则需要指定字段类型：ImportIncreamentConfig.NUMBER_TYPE 数字类型 145 | // SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); 146 | // try { 147 | // Date date = format.parse("2000-01-01"); 148 | // importBuilder.setLastValue(date);//增量起始值配置 149 | // } 150 | // catch (Exception e){ 151 | // e.printStackTrace(); 152 | // } 153 | // 或者ImportIncreamentConfig.TIMESTAMP_TYPE 日期类型 154 | //增量配置结束 155 | 156 | //映射和转换配置开始 157 | // /** 158 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 159 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 160 | // */ 161 | // importBuilder.addFieldMapping("document_id","docId") 162 | // .addFieldMapping("docwtime","docwTime") 163 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 164 | // 165 | // 166 | // /** 167 | // * 为每条记录添加额外的字段和值 168 | // * 可以为基本数据类型，也可以是复杂的对象 169 | // */ 170 | // importBuilder.addFieldValue("testF1","f1value"); 171 | // importBuilder.addFieldValue("testInt",0); 172 | // importBuilder.addFieldValue("testDate",new Date()); 173 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 174 | // TestObject testObject = new TestObject(); 175 | // testObject.setId("testid"); 176 | // testObject.setName("jackson"); 177 | // importBuilder.addFieldValue("testObject",testObject); 178 | // 179 | /** 180 | * 重新设置es数据结构 181 | */ 182 | importBuilder.setDataRefactor(new DataRefactor() { 183 | public void refactor(Context context) throws Exception { 184 | // Date date = context.getDateValue("LOG_OPERTIME"); 185 | // Date date = context.getDateValue("LOG_OPERTIME"); 186 | // context.addFieldValue("logOpertime",date); 187 | context.addFieldValue("collecttime",new Date()); 188 | } 189 | }); 190 | //映射和转换配置结束 191 | 192 | /** 193 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 194 | */ 195 | importBuilder.setParallel(true);//设置为多线程并行批量导入,false串行 196 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 197 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 198 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 199 | 200 | importBuilder.setExportResultHandler(new ExportResultHandler5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.elasticsearch.ElasticSearchHelper; 19 | import org.frameworkset.tran.DataStream; 20 | import org.frameworkset.tran.config.ImportBuilder; 21 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 22 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 23 | import org.frameworkset.tran.schedule.ImportIncreamentConfig; 24 | 25 | /** 26 | *
Description: 同步处理程序，如需调试同步功能，直接运行main方法即可
27 | * 28 | *Copyright (c) 2018
29 | * @Date 2018/9/27 20:38 30 | * @author biaoping.yin 31 | * @version 1.0 32 | */ 33 | public class DbdemoFromSQLFile { 34 | public static void main(String args[]){ 35 | DbdemoFromSQLFile dbdemo = new DbdemoFromSQLFile(); 36 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 37 | dbdemo.scheduleImportData( dropIndice); 38 | } 39 | 40 | /** 41 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 42 | */ 43 | public void scheduleImportData(boolean dropIndice){ 44 | ImportBuilder importBuilder = ImportBuilder.newInstance(); 45 | //增量定时任务不要删表，但是可以通过删表来做初始化操作 46 | if(dropIndice) { 47 | try { 48 | //清除测试表,导入的时候回重建表，测试的时候加上为了看测试效果，实际线上环境不要删表 49 | ElasticSearchHelper.getRestClientUtil().dropIndice("dbdemo1"); 50 | } catch (Exception e) { 51 | } 52 | } 53 | 54 | 55 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 56 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 57 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 58 | // 需要设置setLastValueColumn信息log_id， 59 | // 通过setLastValueType方法告诉工具增量字段的类型，默认是数字类型 60 | 61 | // importBuilder.setSql("select * from td_sm_log where log_id > #[log_id]"); 62 | // importBuilder.setSql("select * from td_sm_log "); 63 | DBInputConfig dbInputConfig = new DBInputConfig(); 64 | dbInputConfig.setSqlFilepath("sql.xml") 65 | .setSqlName("demoexportFull") 66 | .setJdbcFetchSize(-2147483648) 67 | .setColumnLableUpperCase(false); 68 | importBuilder.setInputConfig(dbInputConfig); 69 | /** 70 | * es相关配置 71 | */ 72 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 73 | elasticsearchOutputConfig 74 | .setIndex("dbdemo1") //必填项 75 | .setEsIdField("log_id")//设置文档主键，不设置，则自动产生文档id 76 | .setDebugResponse(false)//设置是否将每次处理的reponse打印到日志文件中，默认false 77 | .setDiscardBulkResponse(true);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false 78 | 79 | // .setIndexType("dbdemo") //es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType 80 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 81 | importBuilder.setUseJavaName(false) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 82 | // .setUseLowcase(false) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 83 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 84 | .setBatchSize(5000); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 85 | 86 | //定时任务配置， 87 | importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 88 | // .setScheduleDate(date) //指定任务开始执行时间：日期 89 | .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 90 | .setPeriod(10000L); //每隔period毫秒执行，如果不设置，只执行一次 91 | //定时任务配置结束 92 | // 93 | // //设置任务执行拦截器，可以添加多个 94 | // importBuilder.addCallInterceptor(new CallInterceptor() { 95 | // @Override 96 | // public void preCall(TaskContext taskContext) { 97 | // System.out.println("preCall"); 98 | // } 99 | // 100 | // @Override 101 | // public void afterCall(TaskContext taskContext) { 102 | // System.out.println("afterCall"); 103 | // } 104 | // 105 | // @Override 106 | // public void throwException(TaskContext taskContext, Throwable e) { 107 | // System.out.println("throwException"); 108 | // } 109 | // }).addCallInterceptor(new CallInterceptor() { 110 | // @Override 111 | // public void preCall(TaskContext taskContext) { 112 | // System.out.println("preCall 1"); 113 | // } 114 | // 115 | // @Override 116 | // public void afterCall(TaskContext taskContext) { 117 | // System.out.println("afterCall 1"); 118 | // } 119 | // 120 | // @Override 121 | // public void throwException(TaskContext taskContext, Throwable e) { 122 | // System.out.println("throwException 1"); 123 | // } 124 | // }); 125 | // //设置任务执行拦截器结束，可以添加多个 126 | //增量配置开始 127 | // importBuilder.setLastValueColumn("log_id");//手动指定数字增量查询字段，默认采用上面设置的sql语句中的增量变量名称作为增量查询字段的名称，指定以后就用指定的字段 128 | importBuilder.setFromFirst(true);//setFromfirst(false)，如果作业停了，作业重启后从上次截止位置开始采集数据， 129 | //setFromfirst(true) 如果作业停了，作业重启后，重新开始采集数据 130 | importBuilder.setLastValueStorePath("logtable_import1");//记录上次采集的增量字段值的文件路径，作为下次增量（或者重启后）采集数据的起点，不同的任务这个路径要不一样 131 | // importBuilder.setLastValueStoreTableName("logs");//记录上次采集的增量字段值的表，可以不指定，采用默认表名increament_tab 132 | importBuilder.setLastValueType(ImportIncreamentConfig.NUMBER_TYPE);//如果没有指定增量查询字段名称，则需要指定字段类型：ImportIncreamentConfig.NUMBER_TYPE 数字类型 133 | // 或者ImportIncreamentConfig.TIMESTAMP_TYPE 日期类型 134 | //增量配置结束 135 | 136 | //映射和转换配置开始 137 | // /** 138 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 139 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 140 | // */ 141 | // importBuilder.addFieldMapping("document_id","docId") 142 | // .addFieldMapping("docwtime","docwTime") 143 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 144 | // 145 | // 146 | // /** 147 | // * 为每条记录添加额外的字段和值 148 | // * 可以为基本数据类型，也可以是复杂的对象 149 | // */ 150 | // importBuilder.addFieldValue("testF1","f1value"); 151 | // importBuilder.addFieldValue("testInt",0); 152 | // importBuilder.addFieldValue("testDate",new Date()); 153 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 154 | // TestObject testObject = new TestObject(); 155 | // testObject.setId("testid"); 156 | // testObject.setName("jackson"); 157 | // importBuilder.addFieldValue("testObject",testObject); 158 | // 159 | // /** 160 | // * 重新设置es数据结构 161 | // */ 162 | // importBuilder.setDataRefactor(new DataRefactor() { 163 | // public void refactor(Context context) throws Exception { 164 | // CustomObject customObject = new CustomObject(); 165 | // customObject.setAuthor((String)context.getValue("author")); 166 | // customObject.setTitle((String)context.getValue("title")); 167 | // customObject.setSubtitle((String)context.getValue("subtitle")); 168 | // customObject.setIds(new int[]{1,2,3}); 169 | // context.addFieldValue("docInfo",customObject);//如果还需要构建更多的内部对象，可以继续构建 170 | // 171 | // //上述三个属性已经放置到docInfo中，如果无需再放置到索引文档中，可以忽略掉这些属性 172 | // context.addIgnoreFieldMapping("author"); 173 | // context.addIgnoreFieldMapping("title"); 174 | // context.addIgnoreFieldMapping("subtitle"); 175 | // } 176 | // }); 177 | //映射和转换配置结束 178 | 179 | /** 180 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 181 | */ 182 | importBuilder.setParallel(false);//设置为多线程并行批量导入,false串行 183 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 184 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 185 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 186 | 187 | /** 188 | * 执行数据库表数据导入es操作 189 | */ 190 | DataStream dataStream = importBuilder.builder(); 191 | dataStream.execute();//执行导入操作 192 | 193 | 194 | 195 | } 196 | } 197 | -------------------------------------------------------------------------------- /src/main/java/org/frameworkset/elasticsearch/imp/DbdemoFull.java: -------------------------------------------------------------------------------- 1 | package org.frameworkset.elasticsearch.imp; 2 | /** 3 | * Copyright 2008 biaoping.yin 4 | *5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.tran.DataRefactor; 19 | import org.frameworkset.tran.DataStream; 20 | import org.frameworkset.tran.ExportResultHandler; 21 | import org.frameworkset.tran.config.ImportBuilder; 22 | import org.frameworkset.tran.context.Context; 23 | import org.frameworkset.tran.metrics.TaskMetrics; 24 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 25 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 26 | import org.frameworkset.tran.task.TaskCommand; 27 | import org.slf4j.Logger; 28 | import org.slf4j.LoggerFactory; 29 | 30 | import java.util.Date; 31 | 32 | /** 33 | *
Description: 基于数字类型db-es增量同步案例，同步处理程序，如需调试同步功能，直接运行main方法即可 34 | *
35 | *Copyright (c) 2018
36 | * @Date 2018/9/27 20:38 37 | * @author biaoping.yin 38 | * @version 1.0 39 | */ 40 | public class DbdemoFull { 41 | private static Logger logger = LoggerFactory.getLogger(DbdemoFull.class); 42 | public static void main(String args[]){ 43 | DbdemoFull dbdemo = new DbdemoFull(); 44 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 45 | // dbdemo.fullImportData( dropIndice); 46 | // dbdemo.scheduleImportData(dropIndice); 47 | dbdemo.scheduleTimestampImportData(dropIndice); 48 | // dbdemo.scheduleImportData(dropIndice); 49 | // args[1].charAt(0) == args[2].charAt(0); 50 | } 51 | 52 | /** 53 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 54 | */ 55 | public void scheduleTimestampImportData(boolean dropIndice){ 56 | ImportBuilder importBuilder = new ImportBuilder() ; 57 | DBInputConfig dbInputConfig = new DBInputConfig(); 58 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 59 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 60 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 61 | // 需要设置setLastValueColumn信息log_id， 62 | // 通过setLastValueType方法告诉工具增量字段的类型，默认是数字类型 63 | 64 | // importBuilder.setSql("select * from td_sm_log where LOG_OPERTIME > #[LOG_OPERTIME]"); 65 | dbInputConfig.setSql("select * from td_sm_log") 66 | .setDbName("test"); 67 | importBuilder.setInputConfig(dbInputConfig); 68 | 69 | 70 | // importBuilder.addFieldMapping("LOG_CONTENT","message"); 71 | // importBuilder.addIgnoreFieldMapping("remark1"); 72 | // importBuilder.setSql("select * from td_sm_log "); 73 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 74 | elasticsearchOutputConfig.setTargetElasticsearch("default") 75 | .setIndex("dbdemofull") 76 | 77 | .setDebugResponse(false)//设置是否将每次处理的reponse打印到日志文件中，默认false 78 | .setDiscardBulkResponse(false);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false 79 | /** 80 | elasticsearchOutputConfig.setEsIdGenerator(new EsIdGenerator() { 81 | //如果指定EsIdGenerator，则根据下面的方法生成文档id， 82 | // 否则根据setEsIdField方法设置的字段值作为文档id， 83 | // 如果默认没有配置EsIdField和如果指定EsIdGenerator，则由es自动生成文档id 84 | 85 | @Override 86 | public Object genId(Context context) throws Exception { 87 | return SimpleStringUtil.getUUID();//返回null，则由es自动生成文档id 88 | } 89 | }); 90 | */ 91 | // .setIndexType("dbdemo") ;//es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType; 92 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 93 | /** 94 | * es相关配置 95 | */ 96 | // elasticsearchOutputConfig.setTargetElasticsearch("default,test");//同步数据到两个es集群 97 | 98 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 99 | importBuilder 100 | // 101 | .setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 102 | .setUseLowcase(true) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 103 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 104 | .setBatchSize(10); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 105 | 106 | // //设置任务执行拦截器结束，可以添加多个 107 | 108 | 109 | //映射和转换配置开始 110 | // /** 111 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 112 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 113 | // */ 114 | // importBuilder.addFieldMapping("document_id","docId") 115 | // .addFieldMapping("docwtime","docwTime") 116 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 117 | // 118 | // 119 | // /** 120 | // * 为每条记录添加额外的字段和值 121 | // * 可以为基本数据类型，也可以是复杂的对象 122 | // */ 123 | // importBuilder.addFieldValue("testF1","f1value"); 124 | // importBuilder.addFieldValue("testInt",0); 125 | // importBuilder.addFieldValue("testDate",new Date()); 126 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 127 | // TestObject testObject = new TestObject(); 128 | // testObject.setId("testid"); 129 | // testObject.setName("jackson"); 130 | // importBuilder.addFieldValue("testObject",testObject); 131 | // 132 | /** 133 | * 重新设置es数据结构 134 | */ 135 | importBuilder.setDataRefactor(new DataRefactor() { 136 | public void refactor(Context context) throws Exception { 137 | // Date date = context.getDateValue("LOG_OPERTIME"); 138 | context.addFieldValue("collecttime",new Date()); 139 | } 140 | }); 141 | //映射和转换配置结束 142 | 143 | /** 144 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 145 | */ 146 | importBuilder.setParallel(true);//设置为多线程并行批量导入,false串行 147 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 148 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 149 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 150 | 151 | importBuilder.setExportResultHandler(new ExportResultHandler5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import com.frameworkset.orm.adapter.DBMM; 19 | 20 | /** 21 | *
Description: 替换mysql的adaptor为自定义的adaptor演示
22 | * 23 | *Copyright (c) 2018
24 | * @Date 2019/4/21 13:28 25 | * @author biaoping.yin 26 | * @version 1.0 27 | */ 28 | public class DruidAdaptor extends DBMM { 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/org/frameworkset/elasticsearch/imp/NewDbdemoFromSQLFile.java: -------------------------------------------------------------------------------- 1 | package org.frameworkset.elasticsearch.imp; 2 | /** 3 | * Copyright 2008 biaoping.yin 4 | *5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.elasticsearch.ElasticSearchHelper; 19 | import org.frameworkset.elasticsearch.bulk.BulkConfig; 20 | import org.frameworkset.tran.DataStream; 21 | import org.frameworkset.tran.config.ClientOptions; 22 | import org.frameworkset.tran.config.ImportBuilder; 23 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 24 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 25 | import org.frameworkset.tran.schedule.ImportIncreamentConfig; 26 | 27 | /** 28 | *
Description: 同步处理程序，如需调试同步功能，直接运行main方法即可
29 | * 30 | *Copyright (c) 2018
31 | * @Date 2018/9/27 20:38 32 | * @author biaoping.yin 33 | * @version 1.0 34 | */ 35 | public class NewDbdemoFromSQLFile { 36 | public static void main(String args[]){ 37 | NewDbdemoFromSQLFile dbdemo = new NewDbdemoFromSQLFile(); 38 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 39 | dbdemo.scheduleImportData( dropIndice); 40 | } 41 | 42 | /** 43 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 44 | */ 45 | public void scheduleImportData(boolean dropIndice){ 46 | ImportBuilder importBuilder = new ImportBuilder() ; 47 | //增量定时任务不要删表，但是可以通过删表来做初始化操作 48 | if(dropIndice) { 49 | try { 50 | //清除测试表,导入的时候回重建表，测试的时候加上为了看测试效果，实际线上环境不要删表 51 | ElasticSearchHelper.getRestClientUtil().dropIndice("dbdemo1"); 52 | } catch (Exception e) { 53 | } 54 | } 55 | 56 | 57 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 58 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 59 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 60 | // log_id和数据库对应的字段一致,就不需要设置setLastValueColumn信息， 61 | // 但是需要设置setLastValueType告诉工具增量字段的类型 62 | DBInputConfig dbInputConfig = new DBInputConfig(); 63 | // importBuilder.setSql("select * from td_sm_log where log_id > #[log_id]"); 64 | // importBuilder.setSql("select * from td_sm_log "); 65 | dbInputConfig.setSqlFilepath("sql.xml") 66 | .setSqlName("demoexportFull"); 67 | dbInputConfig.setJdbcFetchSize(-2147483648); 68 | dbInputConfig.setColumnLableUpperCase(false); 69 | importBuilder.setInputConfig(dbInputConfig); 70 | 71 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 72 | elasticsearchOutputConfig.setTargetElasticsearch("default").setIndex("dbdemo1"); 73 | ClientOptions clientOptions = new ClientOptions(); 74 | // clientOptions.setPipeline("1"); 75 | clientOptions.setRefresh("true"); 76 | // routing 77 | // (Optional, string) Target the specified primary shard. 78 | clientOptions.setRouting("2"); 79 | clientOptions.setTimeout("50s"); 80 | clientOptions.setWaitForActiveShards(2); 81 | elasticsearchOutputConfig.setClientOptions(clientOptions); 82 | elasticsearchOutputConfig.setEsIdField("log_id");//设置文档主键，不设置，则自动产生文档id 83 | 84 | elasticsearchOutputConfig.setDebugResponse(false);//设置是否将每次处理的reponse打印到日志文件中，默认false 85 | elasticsearchOutputConfig.setDiscardBulkResponse(true);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false 86 | elasticsearchOutputConfig.setFilterPath(BulkConfig.ERROR_FILTER_PATH_ONLY);//指定响应报文只返回错误信息 87 | 88 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 89 | 90 | /** 91 | * es相关配置 92 | */ 93 | importBuilder 94 | // .setIndex("dbdemo1") //必填项 95 | // .setIndexType("dbdemo") //es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType 96 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 97 | .setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 98 | // .setUseLowcase(false) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 99 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 100 | .setBatchSize(5000); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 101 | 102 | //定时任务配置， 103 | importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 104 | // .setScheduleDate(date) //指定任务开始执行时间：日期 105 | .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 106 | .setPeriod(10000L); //每隔period毫秒执行，如果不设置，只执行一次 107 | //定时任务配置结束 108 | // 109 | // //设置任务执行拦截器，可以添加多个 110 | // importBuilder.addCallInterceptor(new CallInterceptor() { 111 | // @Override 112 | // public void preCall(TaskContext taskContext) { 113 | // System.out.println("preCall"); 114 | // } 115 | // 116 | // @Override 117 | // public void afterCall(TaskContext taskContext) { 118 | // System.out.println("afterCall"); 119 | // } 120 | // 121 | // @Override 122 | // public void throwException(TaskContext taskContext, Throwable e) { 123 | // System.out.println("throwException"); 124 | // } 125 | // }).addCallInterceptor(new CallInterceptor() { 126 | // @Override 127 | // public void preCall(TaskContext taskContext) { 128 | // System.out.println("preCall 1"); 129 | // } 130 | // 131 | // @Override 132 | // public void afterCall(TaskContext taskContext) { 133 | // System.out.println("afterCall 1"); 134 | // } 135 | // 136 | // @Override 137 | // public void throwException(TaskContext taskContext, Throwable e) { 138 | // System.out.println("throwException 1"); 139 | // } 140 | // }); 141 | // //设置任务执行拦截器结束，可以添加多个 142 | //增量配置开始 143 | // importBuilder.setLastValueColumn("log_id");//手动指定数字增量查询字段，默认采用上面设置的sql语句中的增量变量名称作为增量查询字段的名称，指定以后就用指定的字段 144 | importBuilder.setFromFirst(true);//setFromfirst(false)，如果作业停了，作业重启后从上次截止位置开始采集数据， 145 | //setFromfirst(true) 如果作业停了，作业重启后，重新开始采集数据 146 | importBuilder.setLastValueStorePath("logtable_import1");//记录上次采集的增量字段值的文件路径，作为下次增量（或者重启后）采集数据的起点，不同的任务这个路径要不一样 147 | // importBuilder.setLastValueStoreTableName("logs");//记录上次采集的增量字段值的表，可以不指定，采用默认表名increament_tab 148 | importBuilder.setLastValueType(ImportIncreamentConfig.NUMBER_TYPE);//如果没有指定增量查询字段名称，则需要指定字段类型：ImportIncreamentConfig.NUMBER_TYPE 数字类型 149 | // 或者ImportIncreamentConfig.TIMESTAMP_TYPE 日期类型 150 | //增量配置结束 151 | 152 | //映射和转换配置开始 153 | // /** 154 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 155 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 156 | // */ 157 | // importBuilder.addFieldMapping("document_id","docId") 158 | // .addFieldMapping("docwtime","docwTime") 159 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 160 | // 161 | // 162 | // /** 163 | // * 为每条记录添加额外的字段和值 164 | // * 可以为基本数据类型，也可以是复杂的对象 165 | // */ 166 | // importBuilder.addFieldValue("testF1","f1value"); 167 | // importBuilder.addFieldValue("testInt",0); 168 | // importBuilder.addFieldValue("testDate",new Date()); 169 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 170 | // TestObject testObject = new TestObject(); 171 | // testObject.setId("testid"); 172 | // testObject.setName("jackson"); 173 | // importBuilder.addFieldValue("testObject",testObject); 174 | // 175 | // /** 176 | // * 重新设置es数据结构 177 | // */ 178 | // importBuilder.setDataRefactor(new DataRefactor() { 179 | // public void refactor(Context context) throws Exception { 180 | // CustomObject customObject = new CustomObject(); 181 | // customObject.setAuthor((String)context.getValue("author")); 182 | // customObject.setTitle((String)context.getValue("title")); 183 | // customObject.setSubtitle((String)context.getValue("subtitle")); 184 | // customObject.setIds(new int[]{1,2,3}); 185 | // context.addFieldValue("docInfo",customObject);//如果还需要构建更多的内部对象，可以继续构建 186 | // 187 | // //上述三个属性已经放置到docInfo中，如果无需再放置到索引文档中，可以忽略掉这些属性 188 | // context.addIgnoreFieldMapping("author"); 189 | // context.addIgnoreFieldMapping("title"); 190 | // context.addIgnoreFieldMapping("subtitle"); 191 | // } 192 | // }); 193 | //映射和转换配置结束 194 | 195 | /** 196 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 197 | */ 198 | importBuilder.setParallel(false);//设置为多线程并行批量导入,false串行 199 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 200 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 201 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 202 | 203 | /** 204 | * 执行数据库表数据导入es操作 205 | */ 206 | DataStream dataStream = importBuilder.builder(); 207 | dataStream.execute();//执行导入操作 208 | 209 | 210 | 211 | } 212 | } 213 | -------------------------------------------------------------------------------- /src/main/java/org/frameworkset/elasticsearch/imp/PostgresDbdemo.java: -------------------------------------------------------------------------------- 1 | package org.frameworkset.elasticsearch.imp; 2 | /** 3 | * Copyright 2008 biaoping.yin 4 | *5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.elasticsearch.ElasticSearchHelper; 19 | import org.frameworkset.tran.DataRefactor; 20 | import org.frameworkset.tran.DataStream; 21 | import org.frameworkset.tran.ExportResultHandler; 22 | import org.frameworkset.tran.config.ImportBuilder; 23 | import org.frameworkset.tran.context.Context; 24 | import org.frameworkset.tran.metrics.TaskMetrics; 25 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 26 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 27 | import org.frameworkset.tran.schedule.CallInterceptor; 28 | import org.frameworkset.tran.schedule.TaskContext; 29 | import org.frameworkset.tran.schedule.timer.TimeUtil; 30 | import org.frameworkset.tran.task.TaskCommand; 31 | import org.slf4j.Logger; 32 | import org.slf4j.LoggerFactory; 33 | 34 | /** 35 | *
Description: 同步处理程序，如需调试同步功能，直接运行main方法即可，定时按特定条件导入数据 36 | *
37 | *Copyright (c) 2018
38 | * @Date 2018/9/27 20:38 39 | * @author biaoping.yin 40 | * @version 1.0 41 | */ 42 | public class PostgresDbdemo { 43 | private static Logger logger = LoggerFactory.getLogger(PostgresDbdemo.class); 44 | public static void main(String args[]){ 45 | PostgresDbdemo dbdemo = new PostgresDbdemo(); 46 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 47 | // dbdemo.fullImportData( dropIndice); 48 | // dbdemo.scheduleImportData(dropIndice); 49 | dbdemo.scheduleTimestampImportData(dropIndice); 50 | // dbdemo.scheduleImportData(dropIndice); 51 | // args[1].charAt(0) == args[2].charAt(0); 52 | } 53 | 54 | /** 55 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 56 | */ 57 | public void scheduleTimestampImportData(boolean dropIndice){ 58 | ImportBuilder importBuilder = new ImportBuilder() ; 59 | //增量定时任务不要删表，但是可以通过删表来做初始化操作 60 | if(dropIndice) { 61 | try { 62 | //清除测试表,导入的时候回重建表，测试的时候加上为了看测试效果，实际线上环境不要删表 63 | String repsonse = ElasticSearchHelper.getRestClientUtil().dropIndice("postgresdbdemo"); 64 | System.out.println(repsonse); 65 | } catch (Exception e) { 66 | } 67 | } 68 | 69 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 70 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 71 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 72 | // log_id和数据库对应的字段一致,就不需要设置setLastValueColumn信息， 73 | // 但是需要设置setLastValueType告诉工具增量字段的类型 74 | DBInputConfig dbInputConfig = new DBInputConfig(); 75 | dbInputConfig.setDbName("postgres"); 76 | dbInputConfig.setJdbcFetchSize(2000); 77 | // importBuilder.setSql("select * from td_sm_log where LOG_OPERTIME > #[LOG_OPERTIME]"); 78 | dbInputConfig.setSql("select * from batchtest1 where optime >= #[start_optime] and optime < #[end_optime]"); 79 | importBuilder.setInputConfig(dbInputConfig); 80 | 81 | importBuilder.addParam("start_optime", TimeUtil.parserDate("yyyy-MM-dd HH:mm:ss","2018-03-21 00:27:21")) 82 | .addParam("end_optime",TimeUtil.parserDate("yyyy-MM-dd HH:mm:ss","2019-12-30 00:27:21")); 83 | // importBuilder.addFieldMapping("LOG_CONTENT","message"); 84 | // importBuilder.addIgnoreFieldMapping("remark1"); 85 | // importBuilder.setSql("select * from td_sm_log "); 86 | /** 87 | * es相关配置 88 | */ 89 | // importBuilder.setTargetElasticsearch("default,test");//同步数据到两个es集群 90 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 91 | elasticsearchOutputConfig.setTargetElasticsearch("test"); 92 | elasticsearchOutputConfig.setIndex("postgresdbdemo"); //必填项 93 | // .setIndexType("dbdemo") //es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType 94 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 95 | 96 | //elasticsearchOutputConfig.setEsIdField("log_id");//设置文档主键，不设置，则自动产生文档id 97 | 98 | elasticsearchOutputConfig.setDebugResponse(false);//设置是否将每次处理的reponse打印到日志文件中，默认false 99 | elasticsearchOutputConfig.setDiscardBulkResponse(false);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false 100 | /** 101 | elasticsearchOutputConfig.setEsIdGenerator(new EsIdGenerator() { 102 | //如果指定EsIdGenerator，则根据下面的方法生成文档id， 103 | // 否则根据setEsIdField方法设置的字段值作为文档id， 104 | // 如果默认没有配置EsIdField和如果指定EsIdGenerator，则由es自动生成文档id 105 | 106 | @Override 107 | public Object genId(Context context) throws Exception { 108 | return SimpleStringUtil.getUUID();//返回null，则由es自动生成文档id 109 | } 110 | }); 111 | */ 112 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 113 | importBuilder.setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 114 | .setUseLowcase(true) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 115 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 116 | .setBatchSize(10); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 117 | 118 | //定时任务配置， 119 | importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 120 | // .setScheduleDate(date) //指定任务开始执行时间：日期 121 | .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 122 | .setPeriod(5000L); //每隔period毫秒执行，如果不设置，只执行一次 123 | //定时任务配置结束 124 | // 125 | // //设置任务执行拦截器，可以添加多个，定时任务每次执行的拦截器 126 | importBuilder.addCallInterceptor(new CallInterceptor() { 127 | @Override 128 | public void preCall(TaskContext taskContext) { 129 | System.out.println("preCall"); 130 | } 131 | 132 | @Override 133 | public void afterCall(TaskContext taskContext) { 134 | System.out.println("afterCall"); 135 | } 136 | 137 | @Override 138 | public void throwException(TaskContext taskContext, Throwable e) { 139 | System.out.println("throwException"); 140 | } 141 | }).addCallInterceptor(new CallInterceptor() { 142 | @Override 143 | public void preCall(TaskContext taskContext) { 144 | System.out.println("preCall 1"); 145 | } 146 | 147 | @Override 148 | public void afterCall(TaskContext taskContext) { 149 | logger.info("afterCall ----------"+taskContext.getJobTaskMetrics().toString()); 150 | } 151 | 152 | @Override 153 | public void throwException(TaskContext taskContext, Throwable e) { 154 | logger.info("afterCall ----------"+taskContext.getJobTaskMetrics().toString(),e); 155 | } 156 | }); 157 | // //设置任务执行拦截器结束，可以添加多个 158 | //增量配置开始 159 | 160 | //映射和转换配置开始 161 | // /** 162 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 163 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 164 | // */ 165 | // importBuilder.addFieldMapping("document_id","docId") 166 | // .addFieldMapping("docwtime","docwTime") 167 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 168 | // 169 | // 170 | // /** 171 | // * 为每条记录添加额外的字段和值 172 | // * 可以为基本数据类型，也可以是复杂的对象 173 | // */ 174 | // importBuilder.addFieldValue("testF1","f1value"); 175 | // importBuilder.addFieldValue("testInt",0); 176 | // importBuilder.addFieldValue("testDate",new Date()); 177 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 178 | // TestObject testObject = new TestObject(); 179 | // testObject.setId("testid"); 180 | // testObject.setName("jackson"); 181 | // importBuilder.addFieldValue("testObject",testObject); 182 | // 183 | /** 184 | * 重新设置es数据结构 185 | */ 186 | importBuilder.setDataRefactor(new DataRefactor() { 187 | public void refactor(Context context) throws Exception { 188 | // Date date = context.getDateValue("LOG_OPERTIME"); 189 | // context.addFieldValue("collecttime",new Date()); 190 | logger.info("refactor"); 191 | } 192 | }); 193 | //映射和转换配置结束 194 | 195 | /** 196 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 197 | */ 198 | importBuilder.setParallel(true);//设置为多线程并行批量导入,false串行 199 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 200 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 201 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 202 | 203 | importBuilder.setExportResultHandler(new ExportResultHandler5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.elasticsearch.ElasticSearchHelper; 19 | import org.frameworkset.tran.DataRefactor; 20 | import org.frameworkset.tran.DataStream; 21 | import org.frameworkset.tran.ExportResultHandler; 22 | import org.frameworkset.tran.config.ImportBuilder; 23 | import org.frameworkset.tran.context.Context; 24 | import org.frameworkset.tran.metrics.TaskMetrics; 25 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 26 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 27 | import org.frameworkset.tran.schedule.CallInterceptor; 28 | import org.frameworkset.tran.schedule.TaskContext; 29 | import org.frameworkset.tran.task.TaskCommand; 30 | import org.slf4j.Logger; 31 | import org.slf4j.LoggerFactory; 32 | 33 | /** 34 | *
Description: 同步处理程序，如需调试同步功能，直接运行main方法即可，定时全量表数据导入 35 | *
36 | *Copyright (c) 2018
37 | * @Date 2018/9/27 20:38 38 | * @author biaoping.yin 39 | * @version 1.0 40 | */ 41 | public class PostgresDefaultDbdemo { 42 | private static Logger logger = LoggerFactory.getLogger(PostgresDefaultDbdemo.class); 43 | public static void main(String args[]){ 44 | PostgresDefaultDbdemo dbdemo = new PostgresDefaultDbdemo(); 45 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 46 | // dbdemo.fullImportData( dropIndice); 47 | // dbdemo.scheduleImportData(dropIndice); 48 | dbdemo.scheduleTimestampImportData(dropIndice); 49 | // dbdemo.scheduleImportData(dropIndice); 50 | // args[1].charAt(0) == args[2].charAt(0); 51 | } 52 | 53 | /** 54 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 55 | */ 56 | public void scheduleTimestampImportData(boolean dropIndice){ 57 | ImportBuilder importBuilder = new ImportBuilder() ; 58 | //增量定时任务不要删表，但是可以通过删表来做初始化操作 59 | if(dropIndice) { 60 | try { 61 | //清除测试表,导入的时候回重建表，测试的时候加上为了看测试效果，实际线上环境不要删表 62 | String repsonse = ElasticSearchHelper.getRestClientUtil().dropIndice("postgresdbdemo"); 63 | System.out.println(repsonse); 64 | } catch (Exception e) { 65 | } 66 | } 67 | 68 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 69 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 70 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 71 | // log_id和数据库对应的字段一致,就不需要设置setLastValueColumn信息， 72 | // 但是需要设置setLastValueType告诉工具增量字段的类型 73 | DBInputConfig dbInputConfig = new DBInputConfig(); 74 | dbInputConfig.setDbName("postgres"); 75 | // importBuilder.setSql("select * from td_sm_log where LOG_OPERTIME > #[LOG_OPERTIME]"); 76 | dbInputConfig.setSql("select * from batchtest1 "); 77 | 78 | importBuilder.setInputConfig(dbInputConfig); 79 | // importBuilder.addFieldMapping("LOG_CONTENT","message"); 80 | // importBuilder.addIgnoreFieldMapping("remark1"); 81 | /** 82 | * es相关配置 83 | */ 84 | // ElasticsearchOutputConfig.setTargetElasticsearch("default,test");//同步数据到两个es集群 85 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 86 | elasticsearchOutputConfig.setTargetElasticsearch("test"); 87 | elasticsearchOutputConfig.setIndex("postgresdbdemo") ;//必填项 88 | // .setIndexType("dbdemo") //es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType 89 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 90 | //elasticsearchOutputConfig.setEsIdField("log_id");//设置文档主键，不设置，则自动产生文档id 91 | 92 | elasticsearchOutputConfig.setDebugResponse(false);//设置是否将每次处理的reponse打印到日志文件中，默认false 93 | elasticsearchOutputConfig.setDiscardBulkResponse(false);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false 94 | /** 95 | elasticsearchOutputConfig.setEsIdGenerator(new EsIdGenerator() { 96 | //如果指定EsIdGenerator，则根据下面的方法生成文档id， 97 | // 否则根据setEsIdField方法设置的字段值作为文档id， 98 | // 如果默认没有配置EsIdField和如果指定EsIdGenerator，则由es自动生成文档id 99 | 100 | @Override 101 | public Object genId(Context context) throws Exception { 102 | return SimpleStringUtil.getUUID();//返回null，则由es自动生成文档id 103 | } 104 | }); 105 | */ 106 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 107 | importBuilder.setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 108 | .setUseLowcase(true) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 109 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 110 | .setBatchSize(10); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 111 | 112 | //定时任务配置， 113 | importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 114 | // .setScheduleDate(date) //指定任务开始执行时间：日期 115 | .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 116 | .setPeriod(5000L); //每隔period毫秒执行，如果不设置，只执行一次 117 | //定时任务配置结束 118 | // 119 | // //设置任务执行拦截器，可以添加多个，定时任务每次执行的拦截器 120 | importBuilder.addCallInterceptor(new CallInterceptor() { 121 | @Override 122 | public void preCall(TaskContext taskContext) { 123 | System.out.println("preCall"); 124 | } 125 | 126 | @Override 127 | public void afterCall(TaskContext taskContext) { 128 | System.out.println("afterCall"); 129 | } 130 | 131 | @Override 132 | public void throwException(TaskContext taskContext, Throwable e) { 133 | System.out.println("throwException"); 134 | } 135 | }).addCallInterceptor(new CallInterceptor() { 136 | @Override 137 | public void preCall(TaskContext taskContext) { 138 | System.out.println("preCall 1"); 139 | } 140 | 141 | @Override 142 | public void afterCall(TaskContext taskContext) { 143 | logger.info("afterCall ----------"+taskContext.getJobTaskMetrics().toString()); 144 | } 145 | 146 | @Override 147 | public void throwException(TaskContext taskContext, Throwable e) { 148 | logger.info("afterCall ----------"+taskContext.getJobTaskMetrics().toString(),e); 149 | } 150 | }); 151 | // //设置任务执行拦截器结束，可以添加多个 152 | //增量配置开始 153 | 154 | //映射和转换配置开始 155 | // /** 156 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 157 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 158 | // */ 159 | // importBuilder.addFieldMapping("document_id","docId") 160 | // .addFieldMapping("docwtime","docwTime") 161 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 162 | // 163 | // 164 | // /** 165 | // * 为每条记录添加额外的字段和值 166 | // * 可以为基本数据类型，也可以是复杂的对象 167 | // */ 168 | // importBuilder.addFieldValue("testF1","f1value"); 169 | // importBuilder.addFieldValue("testInt",0); 170 | // importBuilder.addFieldValue("testDate",new Date()); 171 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 172 | // TestObject testObject = new TestObject(); 173 | // testObject.setId("testid"); 174 | // testObject.setName("jackson"); 175 | // importBuilder.addFieldValue("testObject",testObject); 176 | // 177 | /** 178 | * 重新设置es数据结构 179 | */ 180 | importBuilder.setDataRefactor(new DataRefactor() { 181 | public void refactor(Context context) throws Exception { 182 | // Date date = context.getDateValue("LOG_OPERTIME"); 183 | // context.addFieldValue("collecttime",new Date()); 184 | logger.info("refactor"); 185 | // Date date = context.getDateValue("aaaa","yyyy-MM-dd'T'HH:mm:ss.SSSSSSSSS'Z'"); 186 | } 187 | }); 188 | //映射和转换配置结束 189 | 190 | /** 191 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 192 | */ 193 | importBuilder.setParallel(true);//设置为多线程并行批量导入,false串行 194 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 195 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 196 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 197 | 198 | importBuilder.setExportResultHandler(new ExportResultHandler5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.elasticsearch.ElasticSearchHelper; 19 | import org.frameworkset.tran.DataRefactor; 20 | import org.frameworkset.tran.DataStream; 21 | import org.frameworkset.tran.ExportResultHandler; 22 | import org.frameworkset.tran.config.ImportBuilder; 23 | import org.frameworkset.tran.context.Context; 24 | import org.frameworkset.tran.metrics.TaskMetrics; 25 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 26 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 27 | import org.frameworkset.tran.schedule.CallInterceptor; 28 | import org.frameworkset.tran.schedule.ImportIncreamentConfig; 29 | import org.frameworkset.tran.schedule.TaskContext; 30 | import org.frameworkset.tran.task.TaskCommand; 31 | import org.slf4j.Logger; 32 | import org.slf4j.LoggerFactory; 33 | 34 | /** 35 | *
Description: 同步处理程序，如需调试同步功能，直接运行main方法即可，定时按特定条件导入数据 36 | *
37 | *Copyright (c) 2018
38 | * @Date 2018/9/27 20:38 39 | * @author biaoping.yin 40 | * @version 1.0 41 | */ 42 | public class PostgresIncreaseDbdemo { 43 | private static Logger logger = LoggerFactory.getLogger(PostgresIncreaseDbdemo.class); 44 | public static void main(String args[]){ 45 | PostgresIncreaseDbdemo dbdemo = new PostgresIncreaseDbdemo(); 46 | boolean dropIndice = true;//CommonLauncher.getBooleanAttribute("dropIndice",false);//同时指定了默认值 47 | // dbdemo.fullImportData( dropIndice); 48 | // dbdemo.scheduleImportData(dropIndice); 49 | dbdemo.scheduleTimestampImportData(dropIndice); 50 | // dbdemo.scheduleImportData(dropIndice); 51 | // args[1].charAt(0) == args[2].charAt(0); 52 | } 53 | 54 | /** 55 | * elasticsearch地址和数据库地址都从外部配置文件application.properties中获取，加载数据源配置和es配置 56 | */ 57 | public void scheduleTimestampImportData(boolean dropIndice){ 58 | ImportBuilder importBuilder = new ImportBuilder() ; 59 | //增量定时任务不要删表，但是可以通过删表来做初始化操作 60 | if(dropIndice) { 61 | try { 62 | //清除测试表,导入的时候回重建表，测试的时候加上为了看测试效果，实际线上环境不要删表 63 | String repsonse = ElasticSearchHelper.getRestClientUtil().dropIndice("postgresdbdemo"); 64 | System.out.println(repsonse); 65 | } catch (Exception e) { 66 | } 67 | } 68 | 69 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 70 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 71 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 72 | // log_id和数据库对应的字段一致,就不需要设置setLastValueColumn信息， 73 | // 但是需要设置setLastValueType告诉工具增量字段的类型 74 | DBInputConfig dbInputConfig = new DBInputConfig(); 75 | dbInputConfig.setDbName("postgres"); 76 | dbInputConfig.setJdbcFetchSize(2000); 77 | // importBuilder.setSql("select * from td_sm_log where LOG_OPERTIME > #[LOG_OPERTIME]"); 78 | dbInputConfig.setSql("select * from batchtest1 where optime > #[optime]"); 79 | importBuilder.setInputConfig(dbInputConfig); 80 | 81 | 82 | // importBuilder.addFieldMapping("LOG_CONTENT","message"); 83 | // importBuilder.addIgnoreFieldMapping("remark1"); 84 | // importBuilder.setSql("select * from td_sm_log "); 85 | /** 86 | * es相关配置 87 | */ 88 | // importBuilder.setTargetElasticsearch("default,test");//同步数据到两个es集群 89 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 90 | elasticsearchOutputConfig.setTargetElasticsearch("test"); 91 | elasticsearchOutputConfig.setIndex("postgresdbdemo"); //必填项 92 | // .setIndexType("dbdemo") //es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType 93 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 94 | 95 | //elasticsearchOutputConfig.setEsIdField("log_id");//设置文档主键，不设置，则自动产生文档id 96 | 97 | elasticsearchOutputConfig.setDebugResponse(false);//设置是否将每次处理的reponse打印到日志文件中，默认false 98 | elasticsearchOutputConfig.setDiscardBulkResponse(false);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false 99 | /** 100 | elasticsearchOutputConfig.setEsIdGenerator(new EsIdGenerator() { 101 | //如果指定EsIdGenerator，则根据下面的方法生成文档id， 102 | // 否则根据setEsIdField方法设置的字段值作为文档id， 103 | // 如果默认没有配置EsIdField和如果指定EsIdGenerator，则由es自动生成文档id 104 | 105 | @Override 106 | public Object genId(Context context) throws Exception { 107 | return SimpleStringUtil.getUUID();//返回null，则由es自动生成文档id 108 | } 109 | }); 110 | */ 111 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 112 | importBuilder.setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 113 | .setUseLowcase(true) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 114 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 115 | .setBatchSize(10); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 116 | 117 | //定时任务配置， 118 | importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 119 | // .setScheduleDate(date) //指定任务开始执行时间：日期 120 | .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 121 | .setPeriod(5000L); //每隔period毫秒执行，如果不设置，只执行一次 122 | //定时任务配置结束 123 | // 124 | // //设置任务执行拦截器，可以添加多个，定时任务每次执行的拦截器 125 | importBuilder.addCallInterceptor(new CallInterceptor() { 126 | @Override 127 | public void preCall(TaskContext taskContext) { 128 | System.out.println("preCall 1"); 129 | } 130 | 131 | @Override 132 | public void afterCall(TaskContext taskContext) { 133 | logger.info("afterCall ----------"+taskContext.getJobTaskMetrics().toString()); 134 | } 135 | 136 | @Override 137 | public void throwException(TaskContext taskContext, Throwable e) { 138 | logger.info("afterCall ----------"+taskContext.getJobTaskMetrics().toString(),e); 139 | } 140 | }); 141 | // //设置任务执行拦截器结束，可以添加多个 142 | //增量配置开始 143 | importBuilder.setStatusDbname("postgres");//设置增量状态数据源名称 144 | importBuilder.setLastValueColumn("optime");//手动指定数字增量查询字段，默认采用上面设置的sql语句中的增量变量名称作为增量查询字段的名称，指定以后就用指定的字段 145 | importBuilder.setFromFirst(false);//setFromfirst(false)，如果作业停了，作业重启后从上次截止位置开始采集数据， 146 | // setFromfirst(true) 如果作业停了，作业重启后，重新开始采集数据 147 | importBuilder.setLastValueType(ImportIncreamentConfig.TIMESTAMP_TYPE);//如果没有指定增量查询字段名称，则需要指定字段类型：ImportIncreamentConfig.NUMBER_TYPE 数字类型 148 | // SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); 149 | // try { 150 | // Date date = format.parse("2000-01-01"); 151 | // importBuilder.setLastValue(date);//增量起始值配置 152 | // } 153 | // catch (Exception e){ 154 | // e.printStackTrace(); 155 | // } 156 | // 或者ImportIncreamentConfig.TIMESTAMP_TYPE 日期类型 157 | //增量配置结束 158 | 159 | //映射和转换配置开始 160 | // /** 161 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 162 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 163 | // */ 164 | // importBuilder.addFieldMapping("document_id","docId") 165 | // .addFieldMapping("docwtime","docwTime") 166 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 167 | // 168 | // 169 | // /** 170 | // * 为每条记录添加额外的字段和值 171 | // * 可以为基本数据类型，也可以是复杂的对象 172 | // */ 173 | // importBuilder.addFieldValue("testF1","f1value"); 174 | // importBuilder.addFieldValue("testInt",0); 175 | // importBuilder.addFieldValue("testDate",new Date()); 176 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 177 | // TestObject testObject = new TestObject(); 178 | // testObject.setId("testid"); 179 | // testObject.setName("jackson"); 180 | // importBuilder.addFieldValue("testObject",testObject); 181 | // 182 | /** 183 | * 重新设置es数据结构 184 | */ 185 | importBuilder.setDataRefactor(new DataRefactor() { 186 | public void refactor(Context context) throws Exception { 187 | // Date date = context.getDateValue("LOG_OPERTIME"); 188 | // context.addFieldValue("collecttime",new Date()); 189 | logger.info("refactor"); 190 | } 191 | }); 192 | //映射和转换配置结束 193 | 194 | /** 195 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 196 | */ 197 | importBuilder.setParallel(true);//设置为多线程并行批量导入,false串行 198 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 199 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 200 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 201 | 202 | importBuilder.setExportResultHandler(new ExportResultHandler5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import org.frameworkset.tran.config.ImportBuilder; 19 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 20 | import org.frameworkset.tran.plugin.es.output.ElasticsearchOutputConfig; 21 | import org.frameworkset.tran.schedule.ExternalScheduler; 22 | import org.frameworkset.tran.schedule.ImportIncreamentConfig; 23 | import org.frameworkset.tran.schedule.quartz.AbstractQuartzJobHandler; 24 | import org.slf4j.Logger; 25 | import org.slf4j.LoggerFactory; 26 | 27 | import java.text.SimpleDateFormat; 28 | import java.util.Date; 29 | 30 | /** 31 | *
Description: 使用quartz等外部环境定时运行导入数据，需要调试测试quatz作业同步功能，按如下配置进行操作：
32 | * * * 1.在配置文件中添加quartz作业配置-resources/org/frameworkset/task/quarts-task.xml相关内容 33 | * * *Copyright (c) 2018
58 | * @Date 2019/4/13 13:45 59 | * @author biaoping.yin 60 | * @version 1.0 61 | */ 62 | public class QuartzTimestampImportTask extends AbstractQuartzJobHandler { 63 | private Logger logger = LoggerFactory.getLogger(this.getClass()); 64 | public void init(){ 65 | externalScheduler = new ExternalScheduler(); 66 | externalScheduler.dataStream((Object params)->{ 67 | ImportBuilder importBuilder = new ImportBuilder() ; 68 | // //增量定时任务不要删表，但是可以通过删表来做初始化操作 69 | // if(dropIndice) { 70 | // try { 71 | // //清除测试表,导入的时候回重建表，测试的时候加上为了看测试效果，实际线上环境不要删表 72 | // String repsonse = ElasticSearchHelper.getRestClientUtil().dropIndice("dbdemo"); 73 | // System.out.println(repsonse); 74 | // } catch (Exception e) { 75 | // } 76 | // } 77 | 78 | 79 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 80 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 81 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 82 | // log_id和数据库对应的字段一致,就不需要设置setLastValueColumn信息， 83 | // 但是需要设置setLastValueType告诉工具增量字段的类型 84 | DBInputConfig dbInputConfig = new DBInputConfig(); 85 | dbInputConfig.setSql("select * from td_sm_log where LOG_OPERTIME > #[LOG_OPERTIME]"); 86 | importBuilder.setInputConfig(dbInputConfig); 87 | // importBuilder.addIgnoreFieldMapping("remark1"); 88 | /** 89 | * es相关配置 90 | */ 91 | ElasticsearchOutputConfig elasticsearchOutputConfig = new ElasticsearchOutputConfig(); 92 | elasticsearchOutputConfig 93 | .setIndex("dbdemo"); //必填项 94 | // .setIndexType("dbdemo") //es 7以后的版本不需要设置indexType，es7以前的版本必需设置indexType 95 | // .setRefreshOption("refresh")//可选项，null表示不实时刷新，importBuilder.setRefreshOption("refresh");表示实时刷新 96 | elasticsearchOutputConfig.setEsIdField("log_id");//设置文档主键，不设置，则自动产生文档id 97 | 98 | elasticsearchOutputConfig.setDebugResponse(false);//设置是否将每次处理的reponse打印到日志文件中，默认false 99 | elasticsearchOutputConfig.setDiscardBulkResponse(false);//设置是否需要批量处理的响应报文，不需要设置为false，true为需要，默认false 100 | importBuilder.setOutputConfig(elasticsearchOutputConfig); 101 | 102 | importBuilder.setUseJavaName(true) //可选项,将数据库字段名称转换为java驼峰规范的名称，true转换，false不转换，默认false，例如:doc_id -> docId 103 | .setUseLowcase(false) //可选项，true 列名称转小写，false列名称不转换小写，默认false，只要在UseJavaName为false的情况下，配置才起作用 104 | .setPrintTaskLog(true) //可选项，true 打印任务执行日志（耗时，处理记录数） false 不打印，默认值false 105 | .setBatchSize(10); //可选项,批量导入es的记录数，默认为-1，逐条处理，> 0时批量处理 106 | 107 | 108 | // 109 | // //设置任务执行拦截器，可以添加多个，定时任务每次执行的拦截器 110 | // importBuilder.addCallInterceptor(new CallInterceptor() { 111 | // @Override 112 | // public void preCall(TaskContext taskContext) { 113 | // System.out.println("preCall"); 114 | // } 115 | // 116 | // @Override 117 | // public void afterCall(TaskContext taskContext) { 118 | // System.out.println("afterCall"); 119 | // } 120 | // 121 | // @Override 122 | // public void throwException(TaskContext taskContext, Throwable e) { 123 | // System.out.println("throwException"); 124 | // } 125 | // }).addCallInterceptor(new CallInterceptor() { 126 | // @Override 127 | // public void preCall(TaskContext taskContext) { 128 | // System.out.println("preCall 1"); 129 | // } 130 | // 131 | // @Override 132 | // public void afterCall(TaskContext taskContext) { 133 | // System.out.println("afterCall 1"); 134 | // } 135 | // 136 | // @Override 137 | // public void throwException(TaskContext taskContext, Throwable e) { 138 | // System.out.println("throwException 1"); 139 | // } 140 | // }); 141 | // //设置任务执行拦截器结束，可以添加多个 142 | //增量配置开始 143 | // importBuilder.setLastValueColumn("log_id");//手动指定数字增量查询字段，默认采用上面设置的sql语句中的增量变量名称作为增量查询字段的名称，指定以后就用指定的字段 144 | importBuilder.setFromFirst(true);//setFromfirst(false)，如果作业停了，作业重启后从上次截止位置开始采集数据， 145 | //setFromfirst(true) 如果作业停了，作业重启后，重新开始采集数据 146 | importBuilder.setLastValueStorePath("quartzlogtable_import");//记录上次采集的增量字段值的文件路径，作为下次增量（或者重启后）采集数据的起点，不同的任务这个路径要不一样 147 | // importBuilder.setLastValueStoreTableName("logs");//记录上次采集的增量字段值的表，可以不指定，采用默认表名increament_tab 148 | importBuilder.setLastValueType(ImportIncreamentConfig.TIMESTAMP_TYPE);//如果没有指定增量查询字段名称，则需要指定字段类型：ImportIncreamentConfig.NUMBER_TYPE 数字类型 149 | SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); 150 | try { 151 | Date date = format.parse("2000-01-01"); 152 | importBuilder.setLastValue(date); 153 | } 154 | catch (Exception e){ 155 | e.printStackTrace(); 156 | } 157 | // 或者ImportIncreamentConfig.TIMESTAMP_TYPE 日期类型 158 | //增量配置结束 159 | 160 | //映射和转换配置开始 161 | // /** 162 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 163 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 164 | // */ 165 | // importBuilder.addFieldMapping("document_id","docId") 166 | // .addFieldMapping("docwtime","docwTime") 167 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 168 | // 169 | // 170 | // /** 171 | // * 为每条记录添加额外的字段和值 172 | // * 可以为基本数据类型，也可以是复杂的对象 173 | // */ 174 | // importBuilder.addFieldValue("testF1","f1value"); 175 | // importBuilder.addFieldValue("testInt",0); 176 | // importBuilder.addFieldValue("testDate",new Date()); 177 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 178 | // TestObject testObject = new TestObject(); 179 | // testObject.setId("testid"); 180 | // testObject.setName("jackson"); 181 | // importBuilder.addFieldValue("testObject",testObject); 182 | // 183 | // /** 184 | // * 重新设置es数据结构 185 | // */ 186 | // importBuilder.setDataRefactor(new DataRefactor() { 187 | // public void refactor(Context context) throws Exception { 188 | // CustomObject customObject = new CustomObject(); 189 | // customObject.setAuthor((String)context.getValue("author")); 190 | // customObject.setTitle((String)context.getValue("title")); 191 | // customObject.setSubtitle((String)context.getValue("subtitle")); 192 | // customObject.setIds(new int[]{1,2,3}); 193 | // context.addFieldValue("docInfo",customObject);//如果还需要构建更多的内部对象，可以继续构建 194 | // 195 | // //上述三个属性已经放置到docInfo中，如果无需再放置到索引文档中，可以忽略掉这些属性 196 | // context.addIgnoreFieldMapping("author"); 197 | // context.addIgnoreFieldMapping("title"); 198 | // context.addIgnoreFieldMapping("subtitle"); 199 | // } 200 | // }); 201 | //映射和转换配置结束 202 | 203 | /** 204 | * 内置线程池配置，实现多线程并行数据导入功能，作业完成退出时自动关闭该线程池 205 | */ 206 | importBuilder.setParallel(true);//设置为多线程并行批量导入,false串行 207 | importBuilder.setQueue(10);//设置批量导入线程池等待队列长度 208 | importBuilder.setThreadCount(50);//设置批量导入线程池工作线程数量 209 | importBuilder.setContinueOnError(true);//任务出现异常，是否继续执行作业：true（默认值）继续执行 false 中断作业执行 210 | 211 | return importBuilder; 212 | }); 213 | 214 | } 215 | 216 | 217 | } 218 | -------------------------------------------------------------------------------- /src/main/java/org/frameworkset/elasticsearch/imp/TestMysqlAdaptor.java: -------------------------------------------------------------------------------- 1 | package org.frameworkset.elasticsearch.imp; 2 | /** 3 | * Copyright 2008 biaoping.yin 4 | *5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import com.frameworkset.orm.adapter.DBMM; 19 | 20 | /** 21 | *
Description: 替换mysql的adaptor为自定义的adaptor演示
22 | * 23 | *Copyright (c) 2018
24 | * @Date 2019/4/21 13:28 25 | * @author biaoping.yin 26 | * @version 1.0 27 | */ 28 | public class TestMysqlAdaptor extends DBMM { 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/org/frameworkset/elasticsearch/imp/dummy/DB2DummyDemo.java: -------------------------------------------------------------------------------- 1 | package org.frameworkset.elasticsearch.imp.dummy; 2 | /** 3 | * Copyright 2020 bboss 4 | *5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | *
11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | */ 17 | 18 | import com.frameworkset.util.SimpleStringUtil; 19 | import org.frameworkset.elasticsearch.serial.SerialUtil; 20 | import org.frameworkset.tran.CommonRecord; 21 | import org.frameworkset.tran.DataRefactor; 22 | import org.frameworkset.tran.DataStream; 23 | import org.frameworkset.tran.config.ImportBuilder; 24 | import org.frameworkset.tran.context.Context; 25 | import org.frameworkset.tran.plugin.db.input.DBInputConfig; 26 | import org.frameworkset.tran.plugin.dummy.output.DummyOutputConfig; 27 | import org.frameworkset.tran.schedule.CallInterceptor; 28 | import org.frameworkset.tran.schedule.ImportIncreamentConfig; 29 | import org.frameworkset.tran.schedule.TaskContext; 30 | import org.frameworkset.tran.util.RecordGenerator; 31 | 32 | import java.io.Writer; 33 | import java.text.DateFormat; 34 | import java.util.Date; 35 | 36 | /** 37 | *
Description:
38 | * 39 | *Copyright (c) 2020
40 | * @Date 2021/5/26 9:44 41 | * @author biaoping.yin 42 | * @version 1.0 43 | */ 44 | public class DB2DummyDemo { 45 | public static void main(String[] args){ 46 | ImportBuilder importBuilder = new ImportBuilder(); 47 | importBuilder.setBatchSize(1000).setFetchSize(5000); 48 | 49 | 50 | //指定导入数据的sql语句，必填项，可以设置自己的提取逻辑， 51 | // 设置增量变量log_id，增量变量名称#[log_id]可以多次出现在sql语句的不同位置中，例如： 52 | // select * from td_sm_log where log_id > #[log_id] and parent_id = #[log_id] 53 | // 需要设置setLastValueColumn信息log_id， 54 | // 通过setLastValueType方法告诉工具增量字段的类型，默认是数字类型 55 | // importBuilder.setSqlName("insertSQLnew"); //指定将es文档数据同步到数据库的sql语句名称，配置在dsl2ndSqlFile.xml中 56 | DummyOutputConfig dummyOutputConfig = new DummyOutputConfig(); 57 | dummyOutputConfig.setRecordGenerator(new RecordGenerator() { 58 | @Override 59 | public void buildRecord(TaskContext taskContext, CommonRecord record, Writer builder) throws Exception{ 60 | SimpleStringUtil.object2json(record.getDatas(),builder); 61 | 62 | } 63 | }).setPrintRecord(true); 64 | 65 | importBuilder.setOutputConfig(dummyOutputConfig); 66 | 67 | DBInputConfig dbInputConfig = new DBInputConfig(); 68 | dbInputConfig.setSql("select * from td_sm_log where log_id > #[log_id]"); 69 | importBuilder.setInputConfig(dbInputConfig); 70 | //定时任务配置， 71 | importBuilder.setFixedRate(false)//参考jdk timer task文档对fixedRate的说明 72 | // .setScheduleDate(date) //指定任务开始执行时间：日期 73 | .setDeyLay(1000L) // 任务延迟执行deylay毫秒后执行 74 | .setPeriod(10000L); //每隔period毫秒执行，如果不设置，只执行一次 75 | //定时任务配置结束 76 | 77 | //设置任务执行拦截器，可以添加多个 78 | importBuilder.addCallInterceptor(new CallInterceptor() { 79 | @Override 80 | public void preCall(TaskContext taskContext) { 81 | System.out.println("preCall"); 82 | } 83 | 84 | @Override 85 | public void afterCall(TaskContext taskContext) { 86 | System.out.println("afterCall"); 87 | } 88 | 89 | @Override 90 | public void throwException(TaskContext taskContext, Throwable e) { 91 | System.out.println("throwException"); 92 | } 93 | }); 94 | // //设置任务执行拦截器结束，可以添加多个 95 | //增量配置开始 96 | importBuilder.setLastValueColumn("log_id");//手动指定数字增量查询字段，默认采用上面设置的sql语句中的增量变量名称作为增量查询字段的名称，指定以后就用指定的字段 97 | importBuilder.setFromFirst(true);//setFromfirst(false)，如果作业停了，作业重启后从上次截止位置开始采集数据， 98 | // setFromfirst(true) 如果作业停了，作业重启后，重新开始采集数据 99 | importBuilder.setLastValueStorePath("dummydbtable_import");//记录上次采集的增量字段值的文件路径，作为下次增量（或者重启后）采集数据的起点，不同的任务这个路径要不一样 100 | importBuilder.setLastValueType(ImportIncreamentConfig.NUMBER_TYPE);//如果没有指定增量查询字段名称，则需要指定字段类型：ImportIncreamentConfig.NUMBER_TYPE 数字类型 101 | //增量配置结束 102 | 103 | //映射和转换配置开始 104 | // /** 105 | // * db-es mapping 表字段名称到es 文档字段的映射：比如document_id -> docId 106 | // * 可以配置mapping，也可以不配置，默认基于java 驼峰规则进行db field-es field的映射和转换 107 | // */ 108 | // importBuilder.addFieldMapping("document_id","docId") 109 | // .addFieldMapping("docwtime","docwTime") 110 | // .addIgnoreFieldMapping("channel_id");//添加忽略字段 111 | // 112 | // 113 | // /** 114 | // * 为每条记录添加额外的字段和值 115 | // * 可以为基本数据类型，也可以是复杂的对象 116 | // */ 117 | // importBuilder.addFieldValue("testF1","f1value"); 118 | // importBuilder.addFieldValue("testInt",0); 119 | // importBuilder.addFieldValue("testDate",new Date()); 120 | // importBuilder.addFieldValue("testFormateDate","yyyy-MM-dd HH",new Date()); 121 | // TestObject testObject = new TestObject(); 122 | // testObject.setId("testid"); 123 | // testObject.setName("jackson"); 124 | // importBuilder.addFieldValue("testObject",testObject); 125 | importBuilder.addFieldValue("author","张无忌"); 126 | // importBuilder.addFieldMapping("operModule","OPER_MODULE"); 127 | // importBuilder.addFieldMapping("logContent","LOG_CONTENT"); 128 | // importBuilder.addFieldMapping("logOperuser","LOG_OPERUSER"); 129 | 130 | 131 | /** 132 | * 重新设置es数据结构 133 | */ 134 | importBuilder.setDataRefactor(new DataRefactor() { 135 | public void refactor(Context context) throws Exception { 136 | //可以根据条件定义是否丢弃当前记录 137 | //context.setDrop(true);return; 138 | // if(s.incrementAndGet() % 2 == 0) { 139 | // context.setDrop(true); 140 | // return; 141 | // } 142 | 143 | 144 | context.addFieldValue("author","duoduo");//将会覆盖全局设置的author变量 145 | context.addFieldValue("title","解放"); 146 | context.addFieldValue("subtitle","小康"); 147 | 148 | // context.addIgnoreFieldMapping("title"); 149 | //上述三个属性已经放置到docInfo中，如果无需再放置到索引文档中，可以忽略掉这些属性 150 | // context.addIgnoreFieldMapping("author"); 151 | 152 | // //修改字段名称title为新名称newTitle，并且修改字段的值 153 | // context.newName2ndData("title","newTitle",(String)context.getValue("title")+" append new Value"); 154 | context.addIgnoreFieldMapping("subtitle"); 155 | /** 156 | * 获取ip对应的运营商和区域信息 157 | */ 158 | 159 | DateFormat dateFormat = SerialUtil.getDateFormateMeta().toDateFormat(); 160 | Date optime = context.getDateValue("LOG_OPERTIME",dateFormat); 161 | context.addFieldValue("logOpertime",optime); 162 | 163 | /** 164 | //关联查询数据,单值查询 165 | Map headdata = SQLExecutor.queryObjectWithDBName(Map.class,"test", 166 | "select * from head where billid = ? and othercondition= ?", 167 | context.getIntegerValue("billid"),"otherconditionvalue");//多个条件用逗号分隔追加 168 | //将headdata中的数据,调用addFieldValue方法将数据加入当前es文档，具体如何构建文档数据结构根据需求定 169 | context.addFieldValue("headdata",headdata); 170 | //关联查询数据,多值查询 171 | List