JOB:
/**
* 同步警情json 到t_alarm。如果服务器down掉几天，会遗漏期间的数据
* @author wj
* @date 2016-12-30
*
*/
public class AlarmJob implements Job {
public static AtomicReference<Date> maxBjsj ;
static{
if(CacheUtils.get(Contants.jq_maxDateCache, Contants.jq_maxDate_key) == null){
maxBjsj = new AtomicReference<Date>();
}else{
maxBjsj = (AtomicReference<Date>)CacheUtils.get(Contants.jq_maxDateCache, Contants.jq_maxDate_key);
}
}
public static int count = 0;
//可以缓存到内存
// @Cacheable(value="sysCache" )
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
String url = Contants.alarm_url+DateUtils.getDate("yyyyMMdd");
try {
long t1 = System.currentTimeMillis(); // 排序前取得当前时间
if(new HttpClient().get(url,maxBjsj,Contants.TYPE_JQ)){
long t2 = System.currentTimeMillis(); // 排序后取得当前时间
Calendar c = Calendar.getInstance();
c.setTimeInMillis(t2 - t1);
System.out.println("----第"+ ++count +"次 同步结束----"+"耗时: " + c.get(Calendar.MINUTE) + "分 "
+ c.get(Calendar.SECOND) + "秒 " + c.get(Calendar.MILLISECOND)
+ " 毫秒");
}
//
} catch (Exception e) {
e.printStackTrace();
}
}
}
httpclient:
public boolean get(String url ,AtomicReference<Date> maxBjsj,String type) throws Exception{
CloseableHttpClient httpclient = HttpClients.createDefault();
try {
// 创建httpget.
HttpGet httpget = new HttpGet(url);
// httpget.setParams(params);
System.out.println("\n-----------------------");
logger.debug("executing request " + httpget.getURI());
// 执行get请求.
CloseableHttpResponse response = httpclient.execute(httpget);
try {
// 获取响应实体
HttpEntity entity = response.getEntity();
// 打印响应状态
logger.info(response.getStatusLine().toString());
if(200==(response.getStatusLine().getStatusCode())){
if (entity != null) {
String s = EntityUtils.toString(entity, "UTF-8");
// 打印响应内容长度
logger.debug("Response content length: " + entity.getContentLength());
// 打印响应内容
logger.debug("Response content: " + s);
Map<String,List<Map<String,Object> >> map = FastJsonUtil.stringToCollect(s);
List<Map<String,Object> > data = map.get("data");
data = getCurrentDateData(data, type);
if( maxBjsj.get()==null ){ //只会执行第一次,如果缓存里没有值
// maxBjsj = new AtomicReference<Date>(getBJSJDate(data.get(0))) ;
maxBjsj.set(getBJSJDate(data.get(0),type));
}else{
data = filterDateGt(maxBjsj.get(), data,type);
}
List<Map<String,Object> > listWithoutDup = data;
String jobName = "";
String cacheName = "";
String cacheKeyName = "";
if(Contants.TYPE_JQ.equals(type)){
//去重 ，获取下一次最大日期
listWithoutDup = withoutDuplicate(data, "JQBH",maxBjsj,type); //警情去重
jobName="警情";
cacheName=Contants.jq_maxDateCache;
cacheKeyName=Contants.jq_maxDate_key;
}else if(Contants.TYPE_DPZD.equals(type)){ //没有主键，无法去重
setMaxDate(data, maxBjsj,type);
jobName="调派中队";
cacheName=Contants.dpzd_maxDateCache;
cacheKeyName=Contants.dpzd_maxDate_key;
}else if(Contants.TYPE_DPCL.equals(type)){
setMaxDate(data, maxBjsj,type);
jobName="调派车辆";
cacheName=Contants.dpcl_maxDateCache;
cacheKeyName=Contants.dpcl_maxDate_key;
}else{
throw new RuntimeException("不应该到这");
}
boolean ret = true;
if(!CollectionUtils.isEmpty(listWithoutDup)){
for(Map<String,Object> cur: listWithoutDup){
try{
BeanMapper.setAndPersist(cur,type); //如果这里报错，因为已经在上面有了最大日期，下一次JOB、数据就为空除非有新数据
}catch (org.springframework.dao.DuplicateKeyException e){ // 过滤掉之前日期，不应该到这
// maxBjsj.set(null); //清空最大日期，让下一次JOB继续插入(下一次数据也许会变)
logger.error(e.getMessage()+"--duplicate: "+(String)cur.get("JQBH"));
ret = false;
}
}
if(ret)
logger.info("-------------【"+jobName+"】成功导入"+listWithoutDup.size() +"条数据-----------------------");
}else{
logger.info("-------------【"+jobName+"】没有最新数据-----------------------");
ret= false;
}
// 可以比较一下缓存里的日期和这里的最大日期。不如直接put;比较还得get再比较，然后再put
//将最大日期缓存磁盘(用于防止server关闭)。如果没有关闭，最大日期值 依然在外面静态变量里
CacheUtils.put(cacheName, cacheKeyName,maxBjsj);
//看看有没有持久化成功
org.springframework.util.Assert.isTrue(comparDate(((AtomicReference<Date>)CacheUtils.get(cacheName, cacheKeyName)).get(), maxBjsj.get())==0 ,"缓存日期和刚才日应该相等");
CacheUtils.flush(cacheName);
return ret;
}
}else {
logger.warn("------请求["+url+"]错误："+response.getStatusLine().toString());// HTTP/1.1 404 Not Found
return false;
}
} finally {
response.close();
}
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (ParseException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}catch (SQLIntegrityConstraintViolationException e) {
logger.error("--------------主键冲突异常："+e.getMessage()+"-----------------------");
} finally {
// 关闭连接,释放资源
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return false;
}
其他私有辅助方法：
/**
* 去重,如果重复，只保留第一个。并获得最大日期
* @author wj
* @param list
* @param key 要去重的map的key
* @return
*/
private List<Map<String,Object>> withoutDuplicate(List<Map<String,Object>> list,String key,AtomicReference<Date> maxBjsj,String type){
if(!CollectionUtils.isEmpty(list)){
List<Map<String,Object>> tmpList=new ArrayList<Map<String,Object>>();
Set<Object> keysSet = new HashSet<Object>();
for(Map<String,Object> map : list){
Object keys = map.get(key);
int beforeSize = keysSet.size();
keysSet.add(keys);
int afterSize = keysSet.size();
if(afterSize == beforeSize + 1){
tmpList.add(map);
Date date = getBJSJDate(map,type);
if(comparDate(date, maxBjsj.get())==1){
// if(date>maxBjsj){
// maxBjsj = new AtomicReference<Date>(date) ;
maxBjsj.set(date);
}
}
}
return tmpList;
}
return null;
}
private void setMaxDate(List<Map<String,Object>> list,AtomicReference<Date> maxBjsj,String type){
if(!CollectionUtils.isEmpty(list)){
for(Map<String,Object> map : list){
Date date = getBJSJDate(map,type);
if(comparDate(date, maxBjsj.get())==1){
maxBjsj.set(date);
}
}
}
}
/**
* 查询日期大于{@code date} 的数据
* @param date
* @param list
* @return
*/
private List<Map<String,Object>> filterDateGt(Date date ,List<Map<String,Object>> list,String type){
if(!CollectionUtils.isEmpty(list)){
List<Map<String,Object>> tmpList=new ArrayList<Map<String,Object>>();
for(Map<String,Object> map : list){
Date date1 = getBJSJDate(map,type);
if(comparDate(date1, date) == 1){
tmpList.add(map);
}
}
return tmpList;
}
return null;
}
private Date getBJSJDate(Map<String,Object> map,String type){
String BJSJ ="";
if(Contants.TYPE_JQ.equals(type)){
BJSJ = (String)map.get("BJSJ");//报警时间 --是否对应到 ALARM_TIME
}else if(Contants.TYPE_DPZD.equals(type)){
BJSJ = (String)map.get("DPSJ");
}else if(Contants.TYPE_DPCL.equals(type)){//
BJSJ = (String)map.get("DPSJ");
}else{
throw new RuntimeException("不应该到这");
}
try {
Date BJSJDate = DateUtils.parseDate(BJSJ, "yyyy/MM/dd HH:mm:ss.SSS");//2016/12/29 13:56:22.000
return BJSJDate;
} catch (java.text.ParseException e) {
e.printStackTrace();
}
return null;
}
public static int comparDate(Date DATE1, Date DATE2) {
try {
if(DATE1 ==null && DATE2==null){
return 0;
}else if(DATE1 ==null || DATE2==null){
throw new Exception();
}
if (DATE1.getTime() > DATE2.getTime()) {
// System.out.println("dt1 在dt2前");
return 1;
} else if (DATE1.getTime() < DATE2.getTime()) {
// System.out.println("dt1在dt2后");
return -1;
} else {
return 0;
}
} catch (Exception exception) {
exception.printStackTrace();
}
return 0;
}
public static List<Map<String,Object> > getCurrentDateData(List<Map<String,Object> > list,String type) throws java.text.ParseException{
if(!CollectionUtils.isEmpty(list)){
List<Map<String,Object>> tmpList=new ArrayList<Map<String,Object>>();
for(Map<String,Object> map : list){
if(Contants.TYPE_JQ.equals(type)){
String BJSJ = (String)map.get("BJSJ");//报警时间 --是否对应到 ALARM_TIME
Date BJSJDate = DateUtils.parseDate(BJSJ, "yyyy/MM/dd HH:mm:ss.SSS"); //2016/12/29 13:56:22.000
BJSJ = DateUtils.formatDate(BJSJDate);
if(BJSJ.equals(DateUtils.getDate("yyyy-MM-dd"))){
tmpList.add(map);
}
}else if(Contants.TYPE_DPZD.equals(type)){
String DPSJ = (String)map.get("DPSJ");
Date DPSJDate = DateUtils.parseDate(DPSJ, "yyyy/MM/dd HH:mm:ss.SSS"); //2016/12/29 13:56:22.000
DPSJ = DateUtils.formatDate(DPSJDate);
if(DPSJ.equals(DateUtils.getDate("yyyy-MM-dd"))){
tmpList.add(map);
}
}else if(Contants.TYPE_DPCL.equals(type)){
String DPSJ = (String)map.get("DPSJ");
Date DPSJDate = DateUtils.parseDate(DPSJ, "yyyy/MM/dd HH:mm:ss.SSS"); //2017/01/01 08:44:31.000
DPSJ = DateUtils.formatDate(DPSJDate);
if(DPSJ.equals(DateUtils.getDate("yyyy-MM-dd"))){
tmpList.add(map);
}
}else{
throw new RuntimeException("不应该到这");
}
}
return tmpList;
}
return null;
}
用到ehcache缓存最大时间到磁盘，缓存可以看我另一篇博客
相关推荐
实现把job持久化数据库，里面有具体的说明文档 Quartz 1 1 通过quartz创建持久化定时执行任务 3 1.1 首先创建一个基本的web工程，所需jar包 3 1.2 Quartz配置文件quartz.properties 4 1.3 创建job 6 1.3.1 实现org....
python基于51job数据可视化图表展示源码，基于51job工作招聘数据可视化图表展示 web 数据挖掘，ECharts可视化。python基于51job数据可视化图表展示源码，基于51job工作招聘数据可视化图表展示 web 数据挖掘，ECharts...
Quartz定时任务持久化数据表 ，mysql数据库，方便动态配置定时任务，各字段都有注释，简单的crud即可使用
Oracle 定时删除数据 并释放空间 ，创建存储过程并使用job完成。
数据源：基于51job招聘网站爬取的数据 51job招聘网 二、数据分析目标 全国各省的平均月薪情况、岗位分别情况 学历需求情况 工作经验与岗位数量相关情况 福利待遇情况 相关岗位描述 三、数据价值 1.有相关岗位需求的...
Quartz.net 任务调度数据库持久化和集群；持久化能保证实例重启后job不丢失、 集群能均衡服务器压力和解决单点问题
oracle的job定时,henyouyongde ziliao
这个文件包含了xxl-job的定时调度中心源码、执行器demo源码，需要的可以下载。
Oracle Job定时任务
mysql的定时job的一个简单应用，采用mysql存储过程的调用方式执行任务。该任务中涉及到使用游标来完成多个update执行过程。
Quartz.NET+TopSelf 实现定时服务，支持Job持久化和集群，异常重启 介绍:https://blog.csdn.net/qq_27559331/article/details/105067550 如果你觉得对你有用，麻烦你给个好评!
实现在Windows 下进行 Talend ESB 数据抽取的定时任务。
Quartz.NET+TopSelf 实现定时服务，支持Job持久化和集群，异常重启 介绍:https://blog.csdn.net/qq_27559331/article/details/105067550 如果你觉得对你有用，麻烦你给个好评!
爬取51job网站实现数据可视化实验报告书.doc 计算机专业，软件工程专业，通信工程大学生课程设计 自己大三的时候写的 适合大家做课程设计，写毕业设计也可以参考 基于可视化的课程设计
本项目是一个web可视化项目，采用python+echarts+mysql+flask等技术。
plsql创建存储过程并创建job定时任务执行-详细笔记文档总结
Oracle JOB 定时任务 定时执行存储过程
某招聘网站51job就业数据爬取数据据分析，pyecharts数据可视化 该资源是一份Python爬虫实战指南，内容涵盖数据采集、处理和分析的全过程。通过该资源，读者可以了解Python爬虫的基本原理、常用库和工具，学习如何...