Java认证辅导关于tomcat监控器和定时器

会计考友 · 发表于 2012-8-4 12:44:44

Java认证辅导关于tomcat监控器和定时器
tomcat监控器和定时器
package cn.yicha.timer;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Timer;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.apache.log4j.Logger;
import cn.yicha.ask.AskBaidu.AskBaidu_Inti;
import cn.yicha.common.*;
//import jp.yicha.video.action.IndexAction;
public class MainTimerListener implements ServletContextListener {
//public static final Logger logger = Logger.getLogger（MainTimerListener.class.getName（））;
private static Logger logger = Logger.getLogger（MainTimerListener.class）;
private Timer timer = null;
public void contextInitialized（ServletContextEvent event） {
try{
// 在这里初始化监听器，在tomcat启动的时候监听器启动，可以在这里实现定时器功能
Const.load（）;
int startHour = Integer.parseInt（Const.TimerStart）;
int periodHour = Integer.parseInt（Const.TimerPeriod）;
//renyy add method
AskBaidu_Inti.askinit（）;
//renyy add method
Calendar c = Calendar.getInstance（）;
c.add（Calendar.DATE，1）;
c.set（Calendar.HOUR_OF_DAY，startHour）;
c.set（Calendar.MINUTE，0）;
c.set（Calendar.SECOND，0）;
c.set（Calendar.MILLISECOND，0）;
Date start = c.getTime（）;
// long delay = start.getTime（） - System.currentTimeMillis（）;//tomcat启动后间隔1000毫秒启动
long period = periodHour * 60 * 60 * 1000; //间隔
//long period = 10000;
// long period = 1000*60*10;
SimpleDateFormat sdf = new SimpleDateFormat（“yyyy-MM-dd hh:mm:ss”）;
timer = new Timer（true）;
logger.info（“Listener Start--》 Time：”+sdf.format（new Date（）））;
System.out.println（“开始时间：”+start+“间隔时间：”+period）;
Calendar cal = Calendar.getInstance（）;
Date t = cal.getTime（）;
if（cal.get（Calendar.HOUR_OF_DAY）》 5）{
cal.set（Calendar.HOUR_OF_DAY， 6）;
cal.set（Calendar.MINUTE， 0）;
cal.set（Calendar.SECOND， 0）;
cal.set（Calendar.MILLISECOND， 0）;
t = new Date（cal.getTimeInMillis（）+24*60*60*1000L）;
}
else{
cal.set（Calendar.HOUR_OF_DAY， 6）;
cal.set（Calendar.MINUTE， 0）;
cal.set（Calendar.SECOND， 0）;
cal.set（Calendar.MILLISECOND， 0）;
t = cal.getTime（）;
}

timer.schedule（new MainTask（）， t， 24*60*60*1000L）;// 调用MainTask
timer.schedule（new AskBaiduTask（）， new Date（）， 60*1000L）;
//debug
//timer.schedule（new MainTask（）， 1*60*1000， 1*60*1000）;// 调用MainTask
logger.info（“Listener End--》 Time：”+sdf.format（new Date（）））;
}catch（Exception e）{
logger.error（“Listener Error+++++++++++++++++++++++++++++++++：”， e）;
e.printStackTrace（）;
}
}
public void contextDestroyed（ServletContextEvent event） {//在这里关闭监听器，所以在这里销毁定时器。
//renyy add method
AskBaidu_Inti.saveQueue（）;
//renyy add method
timer.cancel（）;
logger.info（“Listener destroy！”）;
}
}
package cn.yicha.timer;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimerTask;
import org.apache.log4j.Logger;
import cn.yicha.ask.expert.Candidate;
import cn.yicha.ask.user.Db;
import cn.yicha.common.Const;
public class MainTask extends TimerTask {
public static final Logger logger = Logger.getLogger（MainTask.class.getName（））;
private static boolean isRunning = false;//任务正在执行标志，以避免重复执行
public MainTask（） {
}
/**
* 自动评选专家
* @param db
*/
private void assessExpert（Db db） {
backData（db）;
Candidate candidate = new Candidate（）;
candidate.update（）;
}
/**
* 备份专家表到XML文件
* @param db
*/
private void backData（Db db） {
StringBuffer sql = new StringBuffer（）;
sql.append（“SELECT e.id，e.user_id，e.nick_name，c.name，e.add_time，e.answer，e.best_answer，e.level，e.fast_answer ”）
.append（“ FROM t_qa_expert AS e LEFT JOIN t_qa_question_category AS c ON e.cate_id=c.id ” ）
.append（“WHERE e.state=0 ORDER BY e.cate_id ，e.answer DESC ，e.best_answer DESC ”）;
ResultSet rs = db.executeQuery（sql.toString（））;
File backFile = getBackFile（）;
BufferedWriter output = null;
try {
output = new BufferedWriter（new FileWriter（backFile））;
while（rs.next（））{
StringBuffer readLine=new StringBuffer（）;
readLine.append（ rs.getString（1）+“\t”）
.append（rs.getString（2）+“\t”）
.append（rs.getString（3）+“\t”）
.append（rs.getString（4）+“\t”）
.append（rs.getString（5）+“\t”）
.append（rs.getString（6）+“\t”）
.append（rs.getString（7）+“\t”）
.append（rs.getString（8）+“\t”）
.append（rs.getString（9）+“\t\n”）;
output.write（readLine.toString（））;
}
output.close（）;
} catch （IOException e1） {
e1.printStackTrace（）;
} catch （SQLException e） {
e.printStackTrace（）;
}finally{
try {
if（output ！= null）{
output.close（）;
}
} catch （IOException e） {
e.printStackTrace（）;
}
}
}

private File getBackFile（） {
Calendar cal = Calendar.getInstance（）;
int year = cal.get（Calendar.YEAR）;
int month = cal.get（Calendar.MONTH）;
return new File（Const.ExpertBackFilePath+“ExpertBackFile”+year+month+“.txt”）;
}
public void run（） {
//Calendar c = Calendar.getInstance（）;
//System.out.println（“123456789”）;
try{
if （！isRunning） {
isRunning = true;
SimpleDateFormat sdf = new SimpleDateFormat（“yyyy-MM-dd HH:mm:ss”）;
System.out.println（“Task start--》Time：”+sdf.format（new Date（）））;
logger.info（“Task start--》Time：”+sdf.format（new Date（）））;
String start = getStartOfMonth（）;
String end = getEndOfMonth（）;
logger.info（“Task start--》Time：” + start + “ end：” + end）;
Db db=Db.getSelf（）;
if（isOneDay（））{
assessExpert（db）;
}
String sql=“”;
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=0 and b.verify=‘10’ and answer_time between ‘2008-11-01 00:00:00’ and ‘2009-01-31 11:59:59’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set answer=ee.sum1”;
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=0 and b.verify=‘10’ and answer_time between ‘” + start +“’ and ‘” + end +“’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set answer=ee.sum1”;
db.executeUpdate（sql）;
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=1 and b.verify=‘10’ and answer_time between ‘” + start +“’ and ‘” + end +“’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set answer=ee.sum1”;
db.executeUpdate（sql）;
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=0 and b.is_best=‘1’ and b.verify=‘10’ and answer_time between ‘2008-11-01 00:00:00’ and ‘2009-01-31 11:59:59’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set best_answer=ee.sum1”;
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=0 and b.is_best=‘1’ and b.verify=‘10’ and answer_time between ‘” + start +“’ and ‘” + end +“’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set best_answer=ee.sum1”;
db.executeUpdate（sql）;
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=1 and b.is_best=‘1’ and b.verify=‘10’ and answer_time between ‘” + start +“’ and ‘” + end +“’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set best_answer=ee.sum1”;
db.executeUpdate（sql）;
/*
* 五分中内回答数
*/
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=0 and b.isfast=‘1’ and b.verify=‘10’ and answer_time between ‘” + start +“’ and ‘” + end +“’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set fast_answer=ee.sum1”;
db.executeUpdate（sql）;
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=1 and b.isfast=‘1’ and b.verify=‘10’ and answer_time between ‘” + start +“’ and ‘” + end +“’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set fast_answer=ee.sum1”;
db.executeUpdate（sql）;
/*
* 专家团统计更新
*/
sql=“UPDATE t_qa_expert_group d LEFT JOIN ”
+“ （SELECT pid AS cate_id，CAST（SUM（IF（fastNum IS NULL，0，fastNum））/SUM（IF（allNum IS NULL ，0，allNum））*100 AS DECIMAL（4，2）） AS quick_percent FROM ”
+“ （SELECT category ，COUNT（*） AS allNum FROM t_qa_question WHERE ask_time BETWEEN ‘” + start +“’ and ‘” + end +“’ GROUP BY category） a ”
+“ LEFT JOIN ”
+“ （SELECT category，COUNT（*） AS fastNum FROM t_qa_question WHERE ask_time BETWEEN ‘” + start +“’ and ‘” + end +“’ AND first_answer_time-ask_time《300 GROUP BY category） b ”
+“ ON a.category = b.category ”
+“ LEFT JOIN ”
+“ （SELECT id，IF（parent_id IS NULL ，id，parent_id） AS pid FROM t_qa_question_category） c ”
+“ ON a.category =c.id ”
+“ GROUP BY c.pid）e ”
+“ ON d.cate_id=e.cate_id ”
+“ SET d.up_down= IF（（e.quick_percent-d.quick_percent）=0，0，IF（（e.quick_percent-d.quick_percent）》0，1，-1））， ”
+“ d.quick_percent = IF（e.quick_percent IS NULL ，0，e.quick_percent）”;
db.executeUpdate（sql）;
db.close（）;
/*
if （Const.VideoListDailySorterEnable.equals（“true”））{
TimesMap.setSortList（）;
}
if （Const.AlbumSorterEnable.equals（“true”））{
AlbumUtil.initRecommendAlbum（）;
}
if （Const.VideoIndexOptimizeAutorun.equals（“true”））{
（new OptIndexServlet（））.optimizeIndex（）;
}
*/
AutoMature.JudgeMature（）;
AutoMature.updateVote（）;
isRunning = false;
logger.info（“Task end--》Time：”+sdf.format（new Date（）））;
} else {
logger.info（“one Task is running”）;
}
}catch（Exception e）{
logger.error（“Task error++++++++++++++++++++++”+e）;
e.printStackTrace（）;
}
}
/**
* 获取上月的开始时间
* @return
*/
public static String getStartOfMonth（）{
Calendar cal = Calendar.getInstance（）;
//cal.add（Calendar.MONTH， 0）;
cal.set（Calendar.DAY_OF_MONTH， cal.getMinimum（Calendar.DAY_OF_MONTH））;
cal.set（Calendar.HOUR_OF_DAY， cal.getMinimum（Calendar.HOUR_OF_DAY））;
cal.set（Calendar.MINUTE， cal.getMinimum（Calendar.MINUTE））;
cal.set（Calendar.SECOND， cal.getMinimum（Calendar.SECOND））;
cal.set（Calendar.MILLISECOND， cal.getMinimum（Calendar.MILLISECOND））;
return date2str（cal.getTime（）， TODAY_STRING_DATE）;
}
/**
* 获取上月的结束时间
* @return
*/
public static String getEndOfMonth（）{
Calendar cal = Calendar.getInstance（）;
cal.add（Calendar.MONTH， 1）;
cal.set（Calendar.DAY_OF_MONTH， 1）;
cal.set（Calendar.HOUR_OF_DAY， cal.getMaximum（Calendar.HOUR_OF_DAY））;
cal.set（Calendar.MINUTE， cal.getMaximum（Calendar.MINUTE））;
cal.set（Calendar.SECOND， cal.getMaximum（Calendar.SECOND））;
cal.set（Calendar.MILLISECOND， cal.getMaximum（Calendar.MILLISECOND））;
cal.add（Calendar.DAY_OF_MONTH， -1）;
return date2str（cal.getTime（）， TODAY_STRING_DATE）;
}

public final static String TODAY_STRING_DATE = “yyyy-MM-dd HH:mm:ss”;
public static String date2str（final Date date， final String pattern） { //date to string
SimpleDateFormat sf = new SimpleDateFormat（pattern）;
return sf.format（date）;
}
/**
* 判断是否是每月的1号
* @return
*/
public static boolean isOneDay（）{
Calendar cal = Calendar.getInstance（）;
return cal.get（Calendar.DAY_OF_MONTH） ==1;
}
public static void main（String argv［］）{
System.out.println（MainTask.isOneDay（））;
Db db=Db.getSelf（）;
MainTask mt = new MainTask（）;
mt.backData（db）;
/*System.out.println（getEndOfMonth（））;
System.out.println（getStartOfMonth（））;
String start = getStartOfMonth（）;
String end = getEndOfMonth（）;
String sql = null;
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=0 and b.verify=‘10’ and answer_time between ‘” + start +“’ and ‘” + end +“’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set answer=ee.sum1”;
System.out.println（sql）;
sql=“ update t_qa_expert aa join （select a.id，count（*） sum1 from t_qa_expert a join t_qa_answer b on a.user_id=b.user_id where a.state=0 and b.is_best=‘1’ and b.verify=‘10’ and answer_time between ‘” + start +“’ and ‘” + end +“’ and b.question_id in （select c.question_id from t_qa_question c，t_qa_question_category d where c.category=d.id and （d.parent_id=a.cate_id or d.id=a.cate_id）） group by a.user_id，a.cate_id ） ee on aa.id=ee.id set best_answer=ee.sum1”;
System.out.println（sql）;*/
}
}
package cn.yicha.timer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimerTask;
import org.apache.log4j.Logger;
import cn.yicha.ask.question.CheckAskBean;
import cn.yicha.ask.user.Db;
public class AskBaiduTask extends TimerTask{
public static final Logger logger = Logger.getLogger（AskBaiduTask.class.getName（））;
private static boolean isRunning = false;//任务正在执行标志，以避免重复执行
@Override
public void run（） {
// TODO Auto-generated method stub
try{
if （！isRunning） {
isRunning = true;
SimpleDateFormat sdf = new SimpleDateFormat（“yyyy-MM-dd HH:mm:ss”）;
logger.info（“任义勇Task start--》Time：”+sdf.format（new Date（）））;
CheckAskBean chb = new CheckAskBean（）;
chb.opration（）;
isRunning = false;
logger.info（“任义勇Task end--》Time：”+sdf.format（new Date（））+isRunning）;
} else {
logger.info（“任义勇one Task is running”+isRunning）;
}
}catch（Exception e）{
logger.error（“Task error++++++++++++++++++++++”+e）;
e.printStackTrace（）;
}
}
}

		自动登录	找回密码
密码			立即注册

[专业语言] Java认证辅导关于tomcat监控器和定时器