合并--9.22

web_backend_develope
wu ming 9 years ago
commit 983a2ce749

@ -17,6 +17,7 @@ jdbc.mysql.password=root
gather-user-name=system gather-user-name=system
# 密码 # 密码
gather-user-password=oracle gather-user-password=oracle
# #
gather-port=1521 gather-port=1521
# #
@ -40,10 +41,10 @@ jdbc.minEvictableIdleTimeMillis=300000
# #
#============================================================================================================== #==============================================================================================================
table-suffix=_20152016 table-suffix=_20152016
extract-log-localtion=/home/log/ extract-log-localtion=D:\\log\\
gather-tablespace-name=TS_TTSSS gather-tablespace-name=TS_TTSSS
gather-tablespace-path= gather-tablespace-path=/opt/oracle/app/oradata/orcl/
gather-table-user-password= gather-table-user-password=1
kubeMasterUrl=http://192.168.0.110:8080/ kubeMasterUrl=http://192.168.0.110:8080/
collect-user-name=system collect-user-name=system
collect-password=oracle collect-password=oracle

@ -45,6 +45,7 @@ public class BaseController {
System.out.println("URI"+request.getRequestURI()); System.out.println("URI"+request.getRequestURI());
request.setAttribute("ex", ex); request.setAttribute("ex", ex);
System.err.println("BaseController --exp " + ex); System.err.println("BaseController --exp " + ex);
new CustomException("base_code_", ex);
// 根据不同错误转向不同页面 // 根据不同错误转向不同页面
if(ex instanceof CustomException) { if(ex instanceof CustomException) {
CustomException cuse = (CustomException) ex; CustomException cuse = (CustomException) ex;

@ -27,8 +27,11 @@ public class Custom4exception {
public final static String threadVolume_Thread_Except = "3001001002"; public final static String threadVolume_Thread_Except = "3001001002";
/** /**
* * ---
*/ */
public final static String threadVolume_Oracle_Except = "3002001002"; public final static String threadVolume_Oracle_Except = "3002001002";
/** * SQL执行错误 */
public final static String OracleSQL_Except = "3002001002";
} }

@ -44,7 +44,6 @@ public class CustomException extends Exception {
public CustomException(String code,Exception e,Object... obj) { public CustomException(String code,Exception e,Object... obj) {
super(code); super(code);
StringBuffer sbuf= new StringBuffer(); StringBuffer sbuf= new StringBuffer();
sbuf.append(msg);
this.code = code; this.code = code;
sbuf.append(code); sbuf.append(code);
sbuf.append("\r\n"); sbuf.append("\r\n");
@ -56,6 +55,8 @@ public class CustomException extends Exception {
} }
// 记录原始的异常 // 记录原始的异常
if (null != e) { if (null != e) {
sbuf.append(e.getMessage());
sbuf.append("\r\n");
StackTraceElement[] array = e.getStackTrace(); StackTraceElement[] array = e.getStackTrace();
cause = e.getCause(); cause = e.getCause();
for (StackTraceElement stackTraceElement : array) { for (StackTraceElement stackTraceElement : array) {
@ -68,6 +69,7 @@ public class CustomException extends Exception {
Object[] array = obj; Object[] array = obj;
sbuf.append("Object[] size : "); sbuf.append("Object[] size : ");
sbuf.append(array.length); sbuf.append(array.length);
sbuf.append("\r\n");
int forSize = 0; int forSize = 0;
if (Constant.CustomException_log_object_size < array.length) { if (Constant.CustomException_log_object_size < array.length) {
forSize = Constant.CustomException_log_object_size; forSize = Constant.CustomException_log_object_size;

@ -0,0 +1,4 @@
3001001001=ThreadVolume\u7C7B\u67E5\u8BE2 volume\u5F02\u5E38
3001001002=ThreadVolume\u7C7B\u7EBF\u7A0B\u4F11\u7720\u5F02\u5E38
3002001002= \u62BD\u53D6\u6C47\u603B--\u7684-\u83B7\u53D6\u62BD\u53D6\u52A8\u4F5C\u5F02\u5E38
3002001002=SQL\u6267\u884C\u9519\u8BEF

@ -99,6 +99,14 @@ PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"
LIMIT #{limit} LIMIT #{limit}
</if> </if>
</select> </select>
<!-- 获取数据符合筛选条件的全部记录信息 -->
<select id="findAll" resultMap="getEntityByText">
SELECT
id,regionalism_code,city_name,district_name,system_code,system_name,data_type,data_version,submitted_batch,data_path,data_charset,collection_time,collector_name,collector_contacts,extract_status,data_year,start_year,end_year,volume_ip,volume_path
FROM data_details
ORDER BY data_details.id
</select>
<!-- 获取数据符合筛选条件的总记录条数 --> <!-- 获取数据符合筛选条件的总记录条数 -->
<select id="getLimitedDataCount" resultType="java.lang.Integer" <select id="getLimitedDataCount" resultType="java.lang.Integer"
@ -245,5 +253,17 @@ PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"
</foreach> </foreach>
and remove ='0' and remove ='0'
</update> </update>
<update id="updateExtract" parameterType="com.platform.entities.DataInfoEntity">
UPDATE
data_info
set extract_status = #{extractStatus}
<where>
regionalism_code = #{regionalismCode}
AND system_code = #{systemCode}
AND data_version = #{dataVersion}
AND remove ='0'
</where>
</update>
</mapper> </mapper>

@ -1,327 +1,278 @@
package com.platform.controller; package com.platform.controller;
import java.io.UnsupportedEncodingException; import java.io.UnsupportedEncodingException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import javax.annotation.Resource; import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import net.sf.json.JSONObject; import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.commons.lang.StringUtils; import org.springframework.stereotype.Controller;
import org.apache.log4j.Logger; import org.springframework.ui.ModelMap;
import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.ui.ModelMap; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody; import com.base.BaseController;
import com.platform.entities.DataInfoEntity;
import com.base.BaseController; import com.platform.entities.DataInfoEntityMoveTmp;
import com.platform.entities.DataInfoEntity; import com.platform.entities.GatherOracleInfo;
import com.platform.entities.DataInfoEntityMoveTmp; import com.platform.entities.PagerOptions;
import com.platform.entities.FolderNode; import com.platform.entities.VolumeEntity;
import com.platform.entities.GatherOracleInfo; import com.platform.entities.oracleForm;
import com.platform.entities.PagerOptions; import com.platform.entities.volumeMoveForm;
import com.platform.entities.VolumeEntity; import com.platform.service.DataInfoService;
import com.platform.entities.oracleForm; import com.platform.service.ICodeService;
import com.platform.entities.volumeMoveForm; import com.platform.service.IGfsService;
import com.platform.service.DataInfoService; import com.platform.service.IMoveDataService;
import com.platform.service.ICodeService; import com.platform.service.IMySqlService;
import com.platform.service.IGfsService; import com.platform.service.IOracleExtractService;
import com.platform.service.IMoveDataService; import com.platform.service.OracleStatusService;
import com.platform.service.IMySqlService; import com.platform.utils.Configs;
import com.platform.service.IOracleExtractService; import com.platform.utils.UtilsHelper;
import com.platform.service.OracleStatusService;
import com.platform.utils.Bean2MapUtils; @Controller
import com.platform.utils.Configs; public class DataModelController extends BaseController{
import com.platform.utils.UtilsHelper;
public static Logger log = Logger.getLogger(DataModelController.class);
@Controller
public class DataModelController extends BaseController{ @Resource(name = "dataInfoService")
private DataInfoService dfs;
public static Logger log = Logger.getLogger(DataModelController.class);
@Resource(name = "gfsService")
@Resource(name = "dataInfoService") private IGfsService gfsService;
private DataInfoService dfs;
@Resource(name = "mySqlService")
@Resource(name = "gfsService") private IMySqlService mySqlService;
private IGfsService gfsService;
@Resource(name = "OracleExtract")
@Resource(name = "mySqlService") private IOracleExtractService OracleExtract;
private IMySqlService mySqlService;
@Resource(name = "moveDataService")
@Resource(name = "OracleExtract") private IMoveDataService moveDataService;
private IOracleExtractService OracleExtract;
@Resource(name = "codeService")
@Resource(name = "moveDataService") private ICodeService codeService;
private IMoveDataService moveDataService;
public void setDfsImp(DataInfoService dfs) {
@Resource(name = "codeService") this.dfs = dfs;
private ICodeService codeService; }
public void setDfsImp(DataInfoService dfs) { @RequestMapping("/data.json")
this.dfs = dfs; @ResponseBody
} public ModelMap getAllDataToJson(HttpServletRequest res,
HttpServletResponse req) throws UnsupportedEncodingException {
@RequestMapping("/data.json") res.setCharacterEncoding("UTF-8");
@ResponseBody Map<String, String[]> paramMap = res.getParameterMap();
public ModelMap getAllDataToJson(HttpServletRequest res, Set<String> keySet = paramMap.keySet();
HttpServletResponse req) throws UnsupportedEncodingException { Map<String, String> params = new HashMap<String, String>();
res.setCharacterEncoding("UTF-8"); StringBuffer sb = new StringBuffer().append("当前的请求参数:{");
Map<String, String[]> paramMap = res.getParameterMap(); for (String str : keySet) {
Set<String> keySet = paramMap.keySet(); String value = paramMap.get(str)[0];
Map<String, String> params = new HashMap<String, String>(); if (StringUtils.isNotEmpty(value)) {
StringBuffer sb = new StringBuffer().append("当前的请求参数:{"); params.put(str, value);
for (String str : keySet) { sb.append(str).append(":").append(value).append(",");
String value = paramMap.get(str)[0]; } else {
if (StringUtils.isNotEmpty(value)) { sb.append(str).append(":").append("null").append(",");
params.put(str, value); }
sb.append(str).append(":").append(value).append(","); }
} else { Configs.CONSOLE_LOGGER.info(sb.deleteCharAt(sb.length() - 1)
sb.append(str).append(":").append("null").append(","); .append("}").toString());
} PagerOptions pagerOptions = (PagerOptions) UtilsHelper
} .newObjAndSetAttrsByClass(PagerOptions.class, params);
Configs.CONSOLE_LOGGER.info(sb.deleteCharAt(sb.length() - 1)
.append("}").toString()); return dfs.getPagerTableData(pagerOptions);
PagerOptions pagerOptions = (PagerOptions) UtilsHelper }
.newObjAndSetAttrsByClass(PagerOptions.class, params);
@RequestMapping(value="/delete/data", method= RequestMethod.POST)
return dfs.getPagerTableData(pagerOptions); public void deleteData(HttpServletRequest res, HttpServletResponse req) throws Exception {
} res.setCharacterEncoding("UTF-8");
Map<String, String[]> paramMap = res.getParameterMap();
@RequestMapping(value="/delete/data", method= RequestMethod.POST) String[] data = paramMap.get("data");
public void deleteData(HttpServletRequest res, HttpServletResponse req) throws Exception { dfs.deleteData(data);
res.setCharacterEncoding("UTF-8"); req.setStatus(200);
Map<String, String[]> paramMap = res.getParameterMap(); }
String[] data = paramMap.get("data");
dfs.deleteData(data); @RequestMapping("/connectOracle")
req.setStatus(200); public void connectOracle(HttpServletRequest res, HttpServletResponse req) throws UnsupportedEncodingException {
} res.setCharacterEncoding("UTF-8");
Map<String, String[]> paramMap = res.getParameterMap();
@RequestMapping("/connectOracle") String[] oraclesName = paramMap.get("oracleName");
public void connectOracle(HttpServletRequest res, HttpServletResponse req) throws UnsupportedEncodingException { if (oraclesName != null)
res.setCharacterEncoding("UTF-8"); for (String rcName : oraclesName) {
Map<String, String[]> paramMap = res.getParameterMap(); Configs.CONSOLE_LOGGER.info("连接成功\t" + rcName);
String[] oraclesName = paramMap.get("oracleName"); new OracleStatusService().connectToOracle(rcName);
if (oraclesName != null) }
for (String rcName : oraclesName) { req.setStatus(200);
Configs.CONSOLE_LOGGER.info("执行连接\t" + rcName); }
new OracleStatusService().connectToOracle(rcName);
} @RequestMapping("/cancelOracleConection")
req.setStatus(200); public void cancelOracleConnection(HttpServletRequest res,
} HttpServletResponse req) throws UnsupportedEncodingException {
res.setCharacterEncoding("UTF-8");
@RequestMapping("/cancelOracleConection") Map<String, String[]> paramMap = res.getParameterMap();
public void cancelOracleConnection(HttpServletRequest res, String[] oraclesName = paramMap.get("oracleName");
HttpServletResponse req) throws UnsupportedEncodingException { String operate = paramMap.get("operation")[0];
res.setCharacterEncoding("UTF-8"); if (null != oraclesName) {
Map<String, String[]> paramMap = res.getParameterMap(); for (String rcName : oraclesName) {
String[] oraclesName = paramMap.get("oracleName"); Configs.CONSOLE_LOGGER.info("取消连接:\t" + rcName);
String operate = paramMap.get("operation")[0]; new OracleStatusService().cancelToOracle(rcName, operate);
if (null != oraclesName) { }
for (String rcName : oraclesName) { }
Configs.CONSOLE_LOGGER.info("取消连接:\t" + rcName); req.setStatus(200);
new OracleStatusService().cancelToOracle(rcName, operate); }
}
} @RequestMapping(value="/oracle/{name}/extract", method= RequestMethod.POST)
req.setStatus(200); public void oracleExtract(HttpServletRequest res,
} HttpServletResponse req,@RequestBody oracleForm form) throws Exception {
Configs.CONSOLE_LOGGER.error("/oracle/{name}/extract");
@RequestMapping(value="/oracle/{name}/extract", method= RequestMethod.POST) res.setCharacterEncoding("UTF-8");
public void oracleExtract(HttpServletRequest res, if (null != form.getInneed() && form.getInneed().size() > 0) {
HttpServletResponse req,@RequestBody oracleForm form) throws Exception { OracleExtract.extractOracle(form.getName(), form.getInneed(), form.getTarget());
res.setCharacterEncoding("UTF-8"); }
if (null != form.getInneed() && form.getInneed().size() > 0) { req.setStatus(200);
OracleExtract.extractOracle(form.getName(), form.getInneed(), form.getTarget()); }
} // public void oracleExtract(HttpServletRequest res,
req.setStatus(200); // HttpServletResponse req, String name, @RequestBody GatherOracleInfo gather, @RequestBody List<OracleConnectorParams> collectOracles)
} // throws Exception {
// public void oracleExtract(HttpServletRequest res, //// res.setCharacterEncoding("UTF-8");
// HttpServletResponse req, String name, @RequestBody GatherOracleInfo gather, @RequestBody List<OracleConnectorParams> collectOracles) // log.debug("------extract-------");
// throws Exception { //// Map<String, String[]> paramMap = res.getParameterMap();
//// res.setCharacterEncoding("UTF-8"); //// log.debug(paramMap);
// log.debug("------extract-------"); //// //汇总库 对象信息--带有tableName-
//// Map<String, String[]> paramMap = res.getParameterMap(); //// String[] nodes = paramMap.get("target");
//// log.debug(paramMap); //// Map map = null;
//// //汇总库 对象信息--带有tableName- //// for (String string : nodes) {
//// String[] nodes = paramMap.get("target"); //// JSONObject jsonobject = JSONObject.fromObject(string);
//// Map map = null; //// map = jsonobject;
//// for (String string : nodes) { //// System.out.println(map);
//// JSONObject jsonobject = JSONObject.fromObject(string); //// }
//// map = jsonobject; ////
//// System.out.println(map); //// // 采集库对象--(多个采集库抽取到1个汇总库的1个tableName下)
//// } //// String[] inneed = paramMap.get("inneed");
//// //// List<Map<String, String>> colleclist = new ArrayList<Map<String,String>>();
//// // 采集库对象--(多个采集库抽取到1个汇总库的1个tableName下) //// for (String string : nodes) {
//// String[] inneed = paramMap.get("inneed"); //// JSONObject jsonobject = JSONObject.fromObject(string);
//// List<Map<String, String>> colleclist = new ArrayList<Map<String,String>>(); //// Map inneedMap = jsonobject;
//// for (String string : nodes) { //// colleclist.add(inneedMap);
//// JSONObject jsonobject = JSONObject.fromObject(string); //// }
//// Map inneedMap = jsonobject; // OracleExtract.extractOracle(name, collectOracles, gather);
//// colleclist.add(inneedMap); // }
//// }
// OracleExtract.extractOracle(name, collectOracles, gather); @RequestMapping(value="/volume/list", method= RequestMethod.POST)
// } @ResponseBody
public List<VolumeEntity> volumeList() throws Exception {
@RequestMapping(value="/volume/list", method= RequestMethod.POST) log.debug("-----/volume/list------");
@ResponseBody List<VolumeEntity> result = gfsService.getAllVolumes();
public List<VolumeEntity> volumeList() throws Exception { return result;
log.debug("-----/volume/list------"); }
List<VolumeEntity> result = gfsService.getAllVolumes();
return result; @RequestMapping(value = "/volume/{name}/move", method= RequestMethod.POST)
} @ResponseBody
public void volumeMove(HttpServletRequest res, HttpServletResponse req,@RequestBody volumeMoveForm form) throws Exception {
@RequestMapping(value = "/volume/{name}/move", method= RequestMethod.POST) List<DataInfoEntity> datas = new ArrayList<DataInfoEntity>();
@ResponseBody List<DataInfoEntity> selectItems = form.getSelectItems();
public void volumeMove(HttpServletRequest res, HttpServletResponse req,@RequestBody volumeMoveForm form) throws Exception { if (null == selectItems) {
// res.setCharacterEncoding("UTF-8"); req.setStatus(200);
// System.out.println("get Request"); return;
// Map<String, String[]> paramMap = res.getParameterMap(); }
//// System.out.println(paramMap); datas.addAll(selectItems);
// String[] nodes = paramMap.get("selectNode");
// Map map = null; System.out.println("------/volume/{name}/move--------");
// for (String string : nodes) { if (datas.size() >0) {
// System.out.println(string); moveDataService.moveData(datas, form.getSelectNode());
// JSONObject jsonobject = JSONObject.fromObject(string); }
// map = jsonobject; req.setStatus(200);
// } }
// String dstVolume = (String) map.get("volume");
@RequestMapping(value="/oracle/list", method= RequestMethod.POST)
// List<String> listItemPath = new ArrayList<String>(); @ResponseBody
// String[] items = paramMap.get("selectItems"); public List<GatherOracleInfo> oracleList() throws Exception {
// System.out.println("selectItems"); log.debug("----------getOracleInfo-----------------------");
List<DataInfoEntity> datas = new ArrayList<DataInfoEntity>(); List<GatherOracleInfo> result = mySqlService.findAllMySql();
// List<String> srcVolumes = new ArrayList<String>(); return result;
// for (String string : items) { }
// System.out.println(string);
// JSONObject jsobj = JSONObject.fromObject(string); @RequestMapping(value="/oracle/{id}/delete", method= RequestMethod.POST)
// Map itemmap = jsobj; public void oracleDelete(HttpServletRequest req, HttpServletResponse res, @PathVariable String id) throws Exception {
// DataInfoEntity data = (DataInfoEntity) Bean2MapUtils.convertMap(DataInfoEntity.class, itemmap); log.debug("----------deleteOracleInfo----------------");
// datas.add(data); Integer num = Integer.valueOf(id);
// } Integer result = mySqlService.deleteMySql(num);
List<DataInfoEntity> selectItems = form.getSelectItems(); log.info("oracleDelete : " + result);
if (null == selectItems) { res.setStatus(200);
req.setStatus(200); }
return;
} @RequestMapping(value="/oracle/{id}/insert", method= RequestMethod.POST)
datas.addAll(selectItems); @ResponseBody
public void oracleInsert(HttpServletRequest res, HttpServletResponse req, @PathVariable String id, @RequestBody GatherOracleInfo oracle) throws Exception {
System.out.println("------/volume/{name}/move--------"); log.debug("----------insertOracleInfo----------------");
if (datas.size() >0) { oracle.setId(Integer.valueOf(id));
moveDataService.moveData(datas, form.getSelectNode()); mySqlService.insertOracle(oracle);
} req.setStatus(200);
req.setStatus(200); }
}
// public Object volumeMove(HttpServletRequest res, HttpServletResponse req, String name, @RequestMapping(value="/oracle/{id}/update", method= RequestMethod.POST)
// @RequestBody FolderNode selectNode, @RequestBody List<DataInfoEntity> selectItems) throws Exception { @ResponseBody
// log.debug("-----/volume/{name}/move------"); public void oracleUpdate(HttpServletRequest res, HttpServletResponse req, @PathVariable("id") String id, @RequestBody GatherOracleInfo oracle) throws Exception {
//// Map<String, String[]> paramMap = res.getParameterMap(); log.debug("----------updateOracleInfo-----------------------");
//// System.out.println(paramMap); log.debug(oracle);
// Map<String, String[]> paramMap = res.getParameterMap(); mySqlService.updateOracle(oracle);
// log.debug(paramMap); req.setStatus(200);
// //汇总库 对象信息--带有tableName- }
// String[] nodes = (String[]) paramMap.get("selectNode");
// Map map = null; @RequestMapping(value="/task/transfer/list", method= RequestMethod.POST)
// JSONObject jsonobject = JSONObject.fromObject(string); @ResponseBody
// map = jsonobject; public Object taskTransferList() throws Exception {
// log.debug("----------/task/transfer/list-----------------------");
// List<DataInfoEntityMoveTmp> result = moveDataService.findAll();
// log.debug(selectItems); return result;
// log.debug(selectNode); }
// boolean result = false ;
// if (selectItems.size() >0) { @RequestMapping(value="/task/transfer/{id}/delete", method= RequestMethod.POST)
// result = moveDataService.moveData(selectItems, selectNode.getPath()); @ResponseBody
// } public Object taskTransferDelete(HttpServletRequest res, HttpServletResponse req, @PathVariable String id) throws Exception {
// return result; log.debug("----------/task/transfer/{id}/delete-----------------------");
// } DataInfoEntityMoveTmp move = new DataInfoEntityMoveTmp();
move.setId(Integer.valueOf(id));
@RequestMapping(value="/oracle/list", method= RequestMethod.POST) int result = moveDataService.delete(move );
@ResponseBody req.setStatus(200);
public List<GatherOracleInfo> oracleList() throws Exception { return result;
log.debug("----------getOracleInfo-----------------------"); }
List<GatherOracleInfo> result = mySqlService.findAllMySql();
return result; @RequestMapping(value="/task/transfer/save", method= RequestMethod.POST)
} @ResponseBody
public Object taskTransferSave(HttpServletRequest res, HttpServletResponse req, @RequestBody DataInfoEntity move) throws Exception {
@RequestMapping(value="/oracle/{id}/delete", method= RequestMethod.POST) log.debug("---------/task/transfer/save-----------------------");
public void oracleDelete(HttpServletRequest req, HttpServletResponse res, @PathVariable String id) throws Exception { int result = dfs.save(move);
log.debug("----------deleteOracleInfo----------------"); req.setStatus(200);
Integer num = Integer.valueOf(id); return result;
Integer result = mySqlService.deleteMySql(num); }
log.info("oracleDelete : " + result);
res.setStatus(200); @RequestMapping(value="/code/list", method= RequestMethod.POST)
} @ResponseBody
public Object findCodeList() throws Exception {
@RequestMapping(value="/oracle/{id}/insert", method= RequestMethod.POST) log.debug("---------/findSystemCode-----------------------");
@ResponseBody Map<String, Object> result = codeService.findAll();
public void oracleInsert(HttpServletRequest res, HttpServletResponse req, @PathVariable String id, @RequestBody GatherOracleInfo oracle) throws Exception { return result;
log.debug("----------insertOracleInfo----------------"); }
oracle.setId(Integer.valueOf(id));
mySqlService.insertOracle(oracle); @RequestMapping(value = "/oracle/extract/log", method= RequestMethod.POST )
req.setStatus(200); @ResponseBody
} public Object getExtractLog(@RequestParam("rcName") String name, HttpServletRequest res, HttpServletResponse req){
log.info("---------/oracle/extract/log-------------------");
@RequestMapping(value="/oracle/{id}/update", method= RequestMethod.POST) StringBuilder sb = new StringBuilder();
@ResponseBody sb.append("查看相应日志").append("\n").append("看到了");
public void oracleUpdate(HttpServletRequest res, HttpServletResponse req, @PathVariable("id") String id, @RequestBody GatherOracleInfo oracle) throws Exception { Map<String, String> log = new HashMap<>();
log.debug("----------updateOracleInfo-----------------------"); log.put(name, sb.toString());
log.debug(oracle); return log;
mySqlService.updateOracle(oracle); }
req.setStatus(200); }
}
@RequestMapping(value="/task/transfer/list", method= RequestMethod.POST)
@ResponseBody
public Object taskTransferList() throws Exception {
log.debug("----------/task/transfer/list-----------------------");
List<DataInfoEntityMoveTmp> result = moveDataService.findAll();
return result;
}
@RequestMapping(value="/task/transfer/{id}/delete", method= RequestMethod.POST)
@ResponseBody
public Object taskTransferDelete(HttpServletRequest res, HttpServletResponse req, @PathVariable String id) throws Exception {
log.debug("----------/task/transfer/{id}/delete-----------------------");
DataInfoEntityMoveTmp move = new DataInfoEntityMoveTmp();
move.setId(Integer.valueOf(id));
int result = moveDataService.delete(move );
req.setStatus(200);
return result;
}
@RequestMapping(value="/task/transfer/save", method= RequestMethod.POST)
@ResponseBody
public Object taskTransferSave(HttpServletRequest res, HttpServletResponse req, @RequestBody DataInfoEntity move) throws Exception {
log.debug("---------/task/transfer/save-----------------------");
int result = dfs.save(move);
req.setStatus(200);
return result;
}
@RequestMapping(value="/code/list", method= RequestMethod.POST)
@ResponseBody
public Object findCodeList() throws Exception {
log.debug("---------/findSystemCode-----------------------");
Map<String, Object> result = codeService.findAll();
return result;
}
@RequestMapping(value = "/oracle/extract/log", method= RequestMethod.POST )
@ResponseBody
public Object getExtractLog(@RequestParam("rcName") String name, HttpServletRequest res, HttpServletResponse req){
log.info("---------/oracle/extract/log-------------------");
StringBuilder sb = new StringBuilder();
sb.append("查看相应日志").append("\n").append("看到了");
Map<String, String> log = new HashMap<>();
log.put(name, sb.toString());
return log;
}
}

@ -20,8 +20,12 @@ public interface DataInfoDao {
List<String> getIdIsExist(List<Integer> list)throws Exception; List<String> getIdIsExist(List<Integer> list)throws Exception;
List<DataInfoEntity> findAll()throws Exception;
int removes(List<Integer> list)throws Exception; int removes(List<Integer> list)throws Exception;
int save(DataInfoEntity data) throws Exception; int save(DataInfoEntity data) throws Exception;
int updateExtract(DataInfoEntity data) throws Exception;
} }

@ -1,9 +1,8 @@
package com.platform.entities; package com.platform.entities;
import java.util.List;
public class PagerOptions { public class PagerOptions {
private Integer currentPageNum; //当前页码 private Integer currentPageNum = 1; //当前页码
private String dataType; //数据类型 private String dataType; //数据类型

@ -1,37 +1,55 @@
package com.platform.entities; package com.platform.entities;
import java.util.List; import java.util.List;
public class oracleForm { public class oracleForm {
private GatherOracleInfo target; private GatherOracleInfo target;
private List<OracleConnectorParams> inneed; private List<OracleConnectorParams> inneed;
private String name; private String name;
public GatherOracleInfo getTarget() { /**
return target; * @return the totalOracle
} */
public GatherOracleInfo getTarget() {
public void setTarget(GatherOracleInfo target) { return target;
this.target = target; }
}
/**
public List<OracleConnectorParams> getInneed() { * @param totalOracle the totalOracle to set
return inneed; */
} public void setTarget(GatherOracleInfo target) {
this.target = target;
public void setInneed(List<OracleConnectorParams> inneed) { }
this.inneed = inneed;
} /**
* @return the collOracle
public String getName() { */
return name; public List<OracleConnectorParams> getInneed() {
} return inneed;
}
public void setName(String name) {
this.name = name; /**
} * @param collOracle the collOracle to set
*/
} public void setInneed(List<OracleConnectorParams> inneed) {
this.inneed = inneed;
}
/**
* @return the totalOracleName
*/
public String getName() {
return name;
}
/**
* @param totalOracleName the totalOracleName to set
*/
public void setName(String name) {
this.name = name;
}
}

@ -1,90 +1,90 @@
package com.platform.oracle; package com.platform.oracle;
import java.sql.Connection; import java.sql.Connection;
import java.sql.DriverManager; import java.sql.DriverManager;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.SQLException; import java.sql.SQLException;
import java.sql.Statement; import java.sql.Statement;
import com.platform.utils.Configs; import com.base.Custom4exception;
import com.base.CustomException;
public class OracleConnector { import com.platform.utils.Configs;
static {
try { public class OracleConnector {
Class.forName("oracle.jdbc.driver.OracleDriver"); static {
Configs.CONSOLE_LOGGER.info("Oracle驱动加载成功"); try {
} catch (ClassNotFoundException e) { Class.forName("oracle.jdbc.driver.OracleDriver");
// TODO Auto-generated catch block Configs.CONSOLE_LOGGER.info("Oracle驱动加载成功");
Configs.CONSOLE_LOGGER.error(e.getMessage()); } catch (ClassNotFoundException e) {
} // TODO Auto-generated catch block
} new CustomException(Custom4exception.OracleSQL_Except, e);
}
public static Connection ConnectionBuilder(String url, String user, }
String password) {
Connection conn = null; public synchronized static Connection ConnectionBuilder(String url, String user,
try { String password) {
conn = DriverManager.getConnection(url, user, password); Connection conn = null;
} catch (SQLException e) { try {
Configs.CONSOLE_LOGGER.info("创建oracle连接失败: [" + e.getMessage() conn = DriverManager.getConnection(url, user, password);
+ "]"); } catch (SQLException e) {
} new CustomException(Custom4exception.OracleSQL_Except, e);
return conn; Configs.CONSOLE_LOGGER.info("创建oracle连接失败: [" + e.getMessage() + "]");
} }
return conn;
public static boolean canConnect(String url, String user, String password) { }
return (null != ConnectionBuilder(url, user, password));
} public synchronized static boolean canConnect(String url, String user, String password) {
return (null != ConnectionBuilder(url, user, password));
public static ResultSet getSQLExecResultSet(Connection conn, String sql) { }
ResultSet resultSet = null;
try { public synchronized static ResultSet getSQLExecResultSet(Connection conn, String sql) {
Statement statement = conn ResultSet resultSet = null;
.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, try {
ResultSet.CONCUR_UPDATABLE); Statement statement = conn
resultSet = statement.executeQuery(sql); .createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
} catch (SQLException e) { ResultSet.CONCUR_UPDATABLE);
Configs.CONSOLE_LOGGER.error(e.getMessage()); resultSet = statement.executeQuery(sql);
} } catch (SQLException e) {
return resultSet; new CustomException(Custom4exception.OracleSQL_Except, e);
} }
return resultSet;
public static ResultSet getSQLExecResultSet(String url, String user, }
String password, String sql) {
return getSQLExecResultSet(ConnectionBuilder(url, user, password), sql); public synchronized static ResultSet getSQLExecResultSet(String url, String user,
} String password, String sql) {
return getSQLExecResultSet(ConnectionBuilder(url, user, password), sql);
/** }
* oracle
* /**
* @param conn * oracle
* @param sql *
* @return * @param conn
*/ * @param sql
public static boolean execOracleSQL(Connection conn, String sql) { * @return
boolean flag = false; */
try { public synchronized static boolean execOracleSQL(Connection conn, String sql) {
Statement statement = conn.createStatement(); boolean flag = false;
//ResultSet set = statement.execute(sql); try {
flag = true; Statement statement = conn.createStatement();
} catch (SQLException e) { statement.execute(sql);
// TODO Auto-generated catch block flag = true;
Configs.CONSOLE_LOGGER.error(e.getMessage()); } catch (SQLException e) {
flag = false; // TODO Auto-generated catch block
} new CustomException(Custom4exception.OracleSQL_Except, e);
return flag; }
} return flag;
}
public static boolean execUpdateOracleSQL(Connection conn, String sql) {
boolean flag = false; public synchronized static boolean execUpdateOracleSQL(Connection conn, String sql) {
try { boolean flag = false;
Statement statement = conn.createStatement(); try {
statement.execute(sql); Statement statement = conn.createStatement();
flag = true; if(statement.executeUpdate(sql) > 0)
} catch (SQLException e) { flag = true;
// TODO Auto-generated catch block } catch (SQLException e) {
Configs.CONSOLE_LOGGER.error(e.getMessage()); // TODO Auto-generated catch block
flag = false; new CustomException(Custom4exception.OracleSQL_Except, e, sql);
} }
return flag; return flag;
} }
} }

@ -1,179 +1,187 @@
package com.platform.service; package com.platform.service;
import java.sql.Connection; import java.sql.Connection;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.SQLException; import java.sql.SQLException;
import com.base.Custom4exception; import com.base.Custom4exception;
import com.base.CustomException; import com.base.CustomException;
import com.platform.entities.GatherOracleInfo; import com.platform.entities.GatherOracleInfo;
import com.platform.entities.OracleConnectorParams; import com.platform.entities.OracleConnectorParams;
import com.platform.oracle.OracleConnector; import com.platform.oracle.OracleConnector;
import com.platform.utils.Configs; import com.platform.utils.Configs;
import com.platform.utils.FileOperateHelper; import com.platform.utils.FileOperateHelper;
public class OracleExtractHelper { public class OracleExtractHelper {
/**
* dblink /**
* * dblink
* @param conn *
* @param linkName * @param conn
* dblink * @param linkName
* @return * dblink
*/ * @return
private boolean hasSameNameDBLink(Connection conn, String linkName) { */
boolean flag = false; private boolean hasSameNameDBLink(Connection conn, String linkName) {
String sql = "SELECT * FROM ALL_DB_LINKS WHERE DB_LINK='" + linkName +"'"; boolean flag = false;
ResultSet rSet = OracleConnector.getSQLExecResultSet(conn, sql); String sql = "SELECT * FROM ALL_DB_LINKS WHERE DB_LINK='" + linkName+"'";
try { ResultSet rSet = null;
rSet.last(); try {
if (rSet.getRow() > 0) rSet = OracleConnector.getSQLExecResultSet(conn, sql);
flag = true; rSet.last();
} catch (Exception e) { if (rSet.getRow() > 0)
// TODO Auto-generated catch block flag = true;
Configs.CONSOLE_LOGGER.info(e.getMessage()); } catch (Exception e) {
} // TODO Auto-generated catch block
return flag; e.printStackTrace();
} new CustomException(Custom4exception.threadVolume_Oracle_Except, e, rSet);
}
/** return flag;
* dblink }
*
* @param conn /**
* @param oc * dblink
* dblink *
*/ * @param conn
public void createDBLink(Connection conn, OracleConnectorParams oc) { * @param oc
String linkName = "LinkTo" + oc.getName(); * dblink
String sql = "CREATE PUBLIC DATABASE LINK " */
+ linkName public void createDBLink(Connection conn, OracleConnectorParams oc) {
+ " CONNECT TO " String linkName = "LINKTO" + oc.getName();
+ oc.getUser() String sql = "CREATE PUBLIC DATABASE LINK "
+ " IDENTIFIED BY " + linkName
+ oc.getPassword() + " CONNECT TO "
+ " USING \'(DESCRIPTION =(ADDRESS_LIST =(ADDRESS = (PROTOCOL = TCP)(HOST = " + oc.getUser()
+ oc.getIp() + ")(PORT = " + oc.getPort() + " IDENTIFIED BY "
+ ")))(CONNECT_DATA =(SERVICE_NAME =" + oc.getDatabaseName() + oc.getPassword()
+ ")))\'"; + " USING \'(DESCRIPTION =(ADDRESS_LIST =(ADDRESS = (PROTOCOL = TCP)(HOST = "
if (null != oc) { + oc.getIp() + ")(PORT = " + oc.getPort()
if (hasSameNameDBLink(conn, linkName)) { // 如果dblink已经存在,先删除dblink在创建dblink + ")))(CONNECT_DATA =(SERVICE_NAME =" + oc.getDatabaseName()
String deleteSql = "DROP PUBLIC DATABASE LINK " + ")))\'";
+ linkName; if (null != oc) {
FileOperateHelper if (hasSameNameDBLink(conn, linkName)) { // 如果dblink已经存在,先删除dblink在创建dblink
.fileWrite( String deleteSql = "DROP PUBLIC DATABASE LINK "
Configs.EXTRACT_LOG_LOCALTION + oc.getName(), + linkName;
deleteSql+"\r\n"); FileOperateHelper
if (OracleConnector.execOracleSQL(conn, deleteSql)) { .fileWrite(
FileOperateHelper.fileWrite(Configs.EXTRACT_LOG_LOCALTION Configs.EXTRACT_LOG_LOCALTION + oc.getName(),
+ oc.getName(), sql+"\r\n"); deleteSql+"\r\n");
OracleConnector.execOracleSQL(conn, sql); if (OracleConnector.execOracleSQL(conn, deleteSql)) {
} else { FileOperateHelper.fileWrite(Configs.EXTRACT_LOG_LOCALTION
Configs.CONSOLE_LOGGER.error("删除已有的DBLink失败,无法创建新的DBLink!"); + oc.getName(), sql+"\r\n");
FileOperateHelper.fileWrite(Configs.EXTRACT_LOG_LOCALTION OracleConnector.execOracleSQL(conn, sql);
+ oc.getName(), "删除已有的DBLink失败,无法创建新的DBLink!"+"\r\n"); } else {
} Configs.CONSOLE_LOGGER.error("删除已有的DBLink失败,无法创建新的DBLink!");
FileOperateHelper.fileWrite(Configs.EXTRACT_LOG_LOCALTION
} else { + oc.getName(), "删除已有的DBLink失败,无法创建新的DBLink!"+"\r\n");
// 否则创建dblink }
System.out.println("dblin不存在");
OracleConnector.execOracleSQL(conn, sql); } else {
Configs.CONSOLE_LOGGER.error("创建DBLink!"); // 否则创建dblink
FileOperateHelper.fileWrite( OracleConnector.execOracleSQL(conn, sql);
Configs.EXTRACT_LOG_LOCALTION + oc.getName(), sql); FileOperateHelper.fileWrite(
} Configs.EXTRACT_LOG_LOCALTION + oc.getName(), sql);
} }
} }
}
/**
* /**
* *
* @param conn *
* @param oc * @param conn
* @return * @param oc
*/ * @return
public boolean createTableSpace(Connection conn, GatherOracleInfo oc) { */
String tmpSql = "select TABLESPACE_NAME from dba_tablespaces where TABLESPACE_NAME = '" public boolean createTableSpace(Connection conn, GatherOracleInfo oc) {
+ Configs.GATHER_TABLESPACE_NAME + "'"; String tmpSql = "select TABLESPACE_NAME from dba_tablespaces where TABLESPACE_NAME = '"
if (OracleConnector.execOracleSQL(conn, tmpSql)) { + oc.getTableName() + "'";
FileOperateHelper if (OracleConnector.execUpdateOracleSQL(conn, tmpSql)) {
.fileWrite( FileOperateHelper
Configs.EXTRACT_LOG_LOCALTION + oc.getName(), .fileWrite(
tmpSql+"\r\n"); Configs.EXTRACT_LOG_LOCALTION + oc.getName(),
return true; tmpSql+"\r\n");
} else { return true;
String sql = "create tablespace " + Configs.GATHER_TABLESPACE_NAME } else {
+ " datafile '" + Configs.GATHER_TABLESPACE_PATH String sql = "create tablespace " + oc.getTableName()
+ Configs.GATHER_TABLESPACE_NAME + ".dbf" + " datafile '" + Configs.GATHER_TABLESPACE_PATH
+ "' size 512M autoextend on next 512M maxsize unlimited"; + oc.getTableName() + ".dbf"
FileOperateHelper + "' size 512M autoextend on next 512M maxsize unlimited";
.fileWrite( FileOperateHelper
Configs.EXTRACT_LOG_LOCALTION + oc.getName(), .fileWrite(
sql+"\r\n"); Configs.EXTRACT_LOG_LOCALTION + oc.getName(),
return OracleConnector.execOracleSQL(conn, sql); sql+"\r\n");
} return OracleConnector.execOracleSQL(conn, sql);
} }
}
/**
* /**
* *
* @param conn *
* @param oc * @param conn
*/ * @param oc
public void createUser(Connection conn, GatherOracleInfo oc) { */
String strTUser = oc.getName() + Configs.TABLE_SUFFIX; public void createUser(Connection conn, OracleConnectorParams oc, GatherOracleInfo totalOracle) {
String sql = "Create user " + strTUser + " default tablespace " String strTUser = oc.getName() + totalOracle.getSuffix();
+ Configs.GATHER_TABLESPACE_NAME + " identified by " String sql = "Create user " + strTUser + " default tablespace "
+ Configs.GATHER_TABLE_PASSWORD; + totalOracle.getTableName() + " identified by "
String grantSql = "grant connect, resource, dba to " + strTUser; + Configs.GATHER_TABLE_PASSWORD;
String grantSql = "grant connect, resource, dba to " + strTUser;
OracleConnector.execOracleSQL(conn, sql);
FileOperateHelper OracleConnector.execOracleSQL(conn, sql);
.fileWrite( FileOperateHelper
Configs.EXTRACT_LOG_LOCALTION + oc.getName(), .fileWrite(
sql+"\r\n"); Configs.EXTRACT_LOG_LOCALTION + oc.getName(),
sql+"\r\n");
OracleConnector.execOracleSQL(conn, grantSql);
FileOperateHelper OracleConnector.execOracleSQL(conn, grantSql);
.fileWrite( FileOperateHelper
Configs.EXTRACT_LOG_LOCALTION + oc.getName(), .fileWrite(
grantSql+"\r\n"); Configs.EXTRACT_LOG_LOCALTION + oc.getName(),
} grantSql+"\r\n");
}
/**
* /**
* *
* @param conn *
* @param oc * @param conn
*/ * @param oc
public void extractColleDB(Connection conn, OracleConnectorParams oc) { */
String strTUser = oc.getName() + Configs.TABLE_SUFFIX; public void extractColleDB(Connection conn, OracleConnectorParams oc) {
String sql = "SELECT 'create table " String strTUser = oc.getName() + Configs.TABLE_SUFFIX;
+ strTUser String sql = "SELECT 'create table "
+ ".J'|| substr(t.OWNER||'_'||t.TABLE_NAME,0,29)||' as select * from '||t.OWNER||'.'||t.TABLE_NAME||" + strTUser
+ "'@linkTo" + ".J'|| substr(t.OWNER||'_'||t.TABLE_NAME,0,29)||' as select * from '||t.OWNER||'.'||t.TABLE_NAME||"
+ oc.getName() + "'@LINKTO"
+ ";' FROM dba_tables@linkTo" + oc.getName()
+ oc.getName() + ";' FROM dba_tables@LINKTO"
+ " t WHERE t.TABLESPACE_NAME NOT IN ('SYSTEM','SYSAUX')" + oc.getName()
+ " and t.owner||t.table_name not in (select owner||table_name from dba_tables@linkTo" + " t WHERE t.TABLESPACE_NAME NOT IN ('SYSTEM','SYSAUX')"
+ oc.getName() + " where 'data_type'='CLOB')"; + " and t.owner||t.table_name not in (select owner||table_name from dba_tables@LINKTO"
ResultSet rsSet = OracleConnector.getSQLExecResultSet(conn, sql); + oc.getName() + " where 'data_type'='CLOB')";
FileOperateHelper ResultSet rsSet = OracleConnector.getSQLExecResultSet(conn, sql);
.fileWrite( FileOperateHelper
Configs.EXTRACT_LOG_LOCALTION + oc.getName(), .fileWrite(
sql+"\r\n"); Configs.EXTRACT_LOG_LOCALTION + oc.getName(),
try { sql+"\r\n");
while (rsSet.next()) { try {
String resultSql = rsSet.getString(0); while (rsSet.next()) {
OracleConnector.execOracleSQL(conn, resultSql); try {
FileOperateHelper rsSet.getRow();
.fileWrite( String resultSql = rsSet.getString(1);
Configs.EXTRACT_LOG_LOCALTION + oc.getName(), OracleConnector.execUpdateOracleSQL(conn, resultSql);
resultSql+"\r\n"); FileOperateHelper
} .fileWrite(
} catch (SQLException e) { Configs.EXTRACT_LOG_LOCALTION + oc.getName(),
new CustomException(Custom4exception.threadVolume_Oracle_Except, e); resultSql+"\r\n");
}
} catch (SQLException e) {
} new CustomException(Custom4exception.threadVolume_Oracle_Except, e, rsSet.getString(1));
} }
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

@ -1,24 +1,29 @@
package com.platform.service.impl; package com.platform.service.impl;
import java.sql.Connection; import java.sql.Connection;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import com.base.Custom4exception;
import com.base.CustomException;
import com.platform.dao.DataInfoDao;
import com.platform.entities.DataInfoEntity;
import com.platform.entities.GatherOracleInfo; import com.platform.entities.GatherOracleInfo;
import com.platform.entities.OracleConnectorParams; import com.platform.entities.OracleConnectorParams;
import com.platform.kubernetes.SimpleKubeClient; import com.platform.kubernetes.SimpleKubeClient;
import com.platform.oracle.OracleConnector; import com.platform.oracle.OracleConnector;
import com.platform.service.IOracleExtractService; import com.platform.service.IOracleExtractService;
import com.platform.service.OracleExtractHelper; import com.platform.service.OracleExtractHelper;
import com.platform.utils.Bean2MapUtils;
import com.platform.utils.Configs;
import com.platform.utils.Constant; import com.platform.utils.Constant;
@Service(value = "OracleExtract") @Service(value = "OracleExtract")
public class OracleExtractServiceImpl implements IOracleExtractService { public class OracleExtractServiceImpl implements IOracleExtractService {
@Resource(name = "dataInfoDao")
private DataInfoDao dataInfoDao;
/** /**
* kubernetes client * kubernetes client
*/ */
@ -26,90 +31,100 @@ public class OracleExtractServiceImpl implements IOracleExtractService {
/** /**
* *
*/ */
private OracleExtractHelper oracleExtract = new OracleExtractHelper(); private OracleExtractHelper oracleExtract = new OracleExtractHelper();
/** /**
* *
*/ */
private OracleConnector connect = new OracleConnector(); private OracleConnector connect = new OracleConnector();
@Override @Override
public boolean extractOracle(String name, List<OracleConnectorParams> dataInfolist, public boolean extractOracle(String name,
List<OracleConnectorParams> dataInfolist,
GatherOracleInfo oracleConnect) throws Exception { GatherOracleInfo oracleConnect) throws Exception {
boolean isSuccess = false; boolean isSuccess = false;
try{ try {
//map转 bean(汇总库信息-带tableName的) // map转 bean(汇总库信息-带tableName的)
GatherOracleInfo oracleModel = oracleConnect; GatherOracleInfo oracleModel = oracleConnect;
//采集库连接参数 // 采集库连接参数
List<OracleConnectorParams> datainfos = dataInfolist; List<OracleConnectorParams> datainfos = dataInfolist;
Connection conn = OracleConnector.ConnectionBuilder(
Connection conn = OracleConnector.ConnectionBuilder("jdbc:oracle:thin:@" + oracleModel.getIp() + ":" + oracleModel.getPort() + ":" "jdbc:oracle:thin:@" + oracleModel.getIp() + ":"
+ oracleModel.getDatabaseName(), oracleModel.getUser(), oracleModel.getPassword()); + oracleModel.getPort() + ":"
+ oracleModel.getDatabaseName(),
for (OracleConnectorParams collectOracle : datainfos) { oracleModel.getUser(), oracleModel.getPassword());
/**
* oracle for (OracleConnectorParams collectOracle : datainfos) {
*/ String[] str = collectOracle.getName().split("-");
//client.updateOrAddReplicasLabelById(collectOracle.getName(), "isExtract", "1"); //更新oracle汇总状态0标示为未汇总1标示汇总中2标示汇总完成 if (str.length == 3) {
String cmd = "kubectl label --overwrite rc " + collectOracle.getName() + " isExtract=1"; DataInfoEntity data = new DataInfoEntity();
Constant.ganymedSSH.execCmdWaitAcquiescent(cmd); data.setRegionalismCode(str[0]);
/** data.setSystemCode(Integer.valueOf(str[1]));
* data-infoextract1; data.setDataVersion(Integer.valueOf(str[2]));
*/ data.setExtractStatus(1);
System.out.println("标签更新成功"); dataInfoDao.updateExtract(data);
collectOracle.setName(collectOracle.getName().replace("-", "_")); collectOracle.setName("J"
oracleExtract.createDBLink(conn, collectOracle); //创建dblink + collectOracle.getName().replace("-", "_"));
System.out.println("创建dblink成功"); // client.updateOrAddReplicasLabelById(collectOracle.getName(),
oracleExtract.createTableSpace(conn, oracleModel); //创建表空间 // "isExtract", "1"); //更新oracle汇总状态0标示为未汇总1标示汇总中2标示汇总完成
System.out.println("创建表空间成功"); String cmd = "kubectl label --overwrite rc "
oracleExtract.createUser(conn, oracleModel);//创建用户并授权 + collectOracle.getName() + " isExtract=1";
System.out.println("用户授权成功"); Constant.ganymedSSH.execCmdWaitAcquiescent(cmd);
oracleExtract.extractColleDB(conn, collectOracle);//执行抽取 oracleExtract.createDBLink(conn, collectOracle); // 创建dblink
System.out.println("执行抽取成功"); oracleExtract.createTableSpace(conn, oracleModel); // 创建表空间
//client.updateOrAddReplicasLabelById(collectOracle.getName(), "isExtract", "1"); //更新oracle汇总状态0标示为未汇总1标示汇总中2标示汇总完成 oracleExtract.createUser(conn, collectOracle, oracleModel);// 创建用户并授权
oracleExtract.extractColleDB(conn, collectOracle);// 执行抽取
cmd = "kubectl label --overwrite rc " + collectOracle.getName() + " isExtract=1"; // client.updateOrAddReplicasLabelById(collectOracle.getName(),
Constant.ganymedSSH.execCmdWaitAcquiescent(cmd); // "isExtract", "1"); //更新oracle汇总状态0标示为未汇总1标示汇总中2标示汇总完成
/** cmd = "kubectl label --overwrite rc "
* data-infoextract2; + collectOracle.getName() + " isExtract=1";
*/ Constant.ganymedSSH.execCmdWaitAcquiescent(cmd);
data.setExtractStatus(2);
dataInfoDao.updateExtract(data);
}
} }
isSuccess = true; isSuccess = true;
}catch(Exception e){ } catch (Exception e) {
Configs.CONSOLE_LOGGER.error(e.getMessage()); new CustomException(Custom4exception.OracleSQL_Except, e);
} }
return false; return isSuccess;
} }
// @Override // @Override
// public boolean extractOracle(String name, List<OracleConnectorParams> dataInfos, GatherOracleInfo oracleConnect) throws Exception { // public boolean extractOracle(String name, List<OracleConnectorParams>
// boolean isSuccess = false; // dataInfos, GatherOracleInfo oracleConnect) throws Exception {
// try{ // boolean isSuccess = false;
// //map转 bean(汇总库信息-带tableName的) // try{
//// GatherOracleInfo oracleModel = (GatherOracleInfo) Bean2MapUtils.convertMap(GatherOracleInfo.class, oracleConnect); // //map转 bean(汇总库信息-带tableName的)
// // // GatherOracleInfo oracleModel = (GatherOracleInfo)
// //采集库连接参数 // Bean2MapUtils.convertMap(GatherOracleInfo.class, oracleConnect);
//// List<OracleConnectorParams> datainfos = new ArrayList<OracleConnectorParams>(); //
//// for (Map<String, String> map : dataInfoMap) { // //采集库连接参数
//// OracleConnectorParams dataInfoEntity = (OracleConnectorParams) Bean2MapUtils.convertMap(OracleConnectorParams.class, oracleConnect); // // List<OracleConnectorParams> datainfos = new
//// datainfos.add(dataInfoEntity); // ArrayList<OracleConnectorParams>();
//// } // // for (Map<String, String> map : dataInfoMap) {
// // // OracleConnectorParams dataInfoEntity = (OracleConnectorParams)
// Connection conn = OracleConnector.ConnectionBuilder("jdbc:oracle:thin:@" + oracleConnect.getIp() + ":" + oracleConnect.getPort() + "/" // Bean2MapUtils.convertMap(OracleConnectorParams.class, oracleConnect);
// + oracleConnect.getDatabaseName(), oracleConnect.getUser(), oracleConnect.getPassword()); // // datainfos.add(dataInfoEntity);
// // // }
// for (OracleConnectorParams collectOracle : dataInfos) { //
// // Connection conn = OracleConnector.ConnectionBuilder("jdbc:oracle:thin:@"
// oracleExtract.createDBLink(conn, collectOracle); // + oracleConnect.getIp() + ":" + oracleConnect.getPort() + "/"
// oracleExtract.createTableSpace(conn, oracleConnect); // + oracleConnect.getDatabaseName(), oracleConnect.getUser(),
// oracleExtract.createUser(conn, oracleConnect); // oracleConnect.getPassword());
// oracleExtract.extractColleDB(conn, collectOracle); //
// } // for (OracleConnectorParams collectOracle : dataInfos) {
// isSuccess = true; //
// }catch(Exception e){ // oracleExtract.createDBLink(conn, collectOracle);
// // oracleExtract.createTableSpace(conn, oracleConnect);
// } // oracleExtract.createUser(conn, oracleConnect);
// return false; // oracleExtract.extractColleDB(conn, collectOracle);
// } // }
// isSuccess = true;
// }catch(Exception e){
//
// }
// return false;
// }
} }

@ -1,52 +1,52 @@
package com.platform.utils; package com.platform.utils;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
public class Configs { public class Configs {
/** 全局自定义异常--编码 */ /** 全局自定义异常--编码 */
public static final String GLOBAL_EXP_CUSTOM = "3001001001"; public static final String GLOBAL_EXP_CUSTOM = "3001001001";
/** 全局非自定义异常--编码 */ /** 全局非自定义异常--编码 */
public static final String GLOBAL_EXP_NOT_CUSTOM = "3001001002"; public static final String GLOBAL_EXP_NOT_CUSTOM = "3001001002";
public static final String CONFIG_LOCALTION = "WebContent/WEB-INF/config/config.properties"; public static final String CONFIG_LOCALTION = "WebContent/WEB-INF/config/config.properties";
public static final Logger CONSOLE_LOGGER = Logger.getLogger("console"); public static final Logger CONSOLE_LOGGER = Logger.getLogger("console");
public static final Logger DAILY_ROLLING_LOGGER = Logger public static final Logger DAILY_ROLLING_LOGGER = Logger
.getLogger("dailyRollingFile"); .getLogger("dailyRollingFile");
public static final Logger DAILY_LOGGER = Logger.getLogger("railyFile"); public static final Logger DAILY_LOGGER = Logger.getLogger("railyFile");
public static final Logger LOGGER = Logger.getLogger(Configs.class); public static final Logger LOGGER = Logger.getLogger(Configs.class);
public static String KUBE_MASTER_URL = "http://192.168.0.110:8080/"; // kubernetes集群的maser public static String KUBE_MASTER_URL = "http://192.168.0.110:8080/"; // kubernetes集群的maser
// URl // URl
public static int ORACLE_DEFAULT_PORT = 1521; // oracle的默认端口号 public static int ORACLE_DEFAULT_PORT = 1521; // oracle的默认端口号
public static String COLLECT_USER_NAME = "system"; //采集统一的登入用户名 public static String COLLECT_USER_NAME = "system"; //采集统一的登入用户名
public static String COLLECT_PASSWORD = "oracle"; //采集统一的登入密码 public static String COLLECT_PASSWORD = "oracle"; //采集统一的登入密码
public static String COLLECT_SERVICE_NAME = "orcl"; //采集库统一的服务名 public static String COLLECT_SERVICE_NAME = "orcl"; //采集库统一的服务名
public static String GATHER_PORT ="1521"; //汇总库的端口号 public static String GATHER_PORT ="1521"; //汇总库的端口号
public static String GATHER_USER_NAME = "system"; //汇总库的登入用户名 public static String GATHER_USER_NAME = "system"; //汇总库的登入用户名
public static String GATHER_USER_PASSWORD = "1"; //汇总库的登入密码 public static String GATHER_USER_PASSWORD = "1"; //汇总库的登入密码
public static String GATHER_SERVICE_NAME = "orcl"; //汇总库的服务名 public static String GATHER_SERVICE_NAME = "orcl"; //汇总库的服务名
public static String TABLE_SUFFIX = "_20152016"; //汇总库汇总表的后缀名 public static String TABLE_SUFFIX = "_20152016"; //汇总库汇总表的后缀名
public static String EXTRACT_LOG_LOCALTION = "D:\\log"; //数据汇总日志保存位置 public static String EXTRACT_LOG_LOCALTION = "D:\\log"; //数据汇总日志保存位置
public static String GATHER_TABLESPACE_NAME=""; //表空间名 public static String GATHER_TABLESPACE_NAME=""; //表空间名
public static String GATHER_TABLESPACE_PATH=""; //表空间路径 public static String GATHER_TABLESPACE_PATH=""; //表空间路径
public static String GATHER_TABLE_PASSWORD=""; //登入密码 public static String GATHER_TABLE_PASSWORD="1"; //登入密码
} }

@ -0,0 +1,16 @@
package com.platform.test;
import com.platform.utils.Configs;
import com.platform.utils.FileOperateHelper;
public class TestWriteFile {
public static void main(String[] args) {
FileOperateHelper
.fileWrite(
Configs.EXTRACT_LOG_LOCALTION +"\\test.log",
"Hello! \r\n");
System.out.println("Hello!");
}
}
Loading…
Cancel
Save