`
8366
  • 浏览: 813350 次
  • 性别: Icon_minigender_1
  • 来自: 西安
社区版块
存档分类
最新评论

公司一大牛写的一个自动任务框架

框架EJBBeanSQL配置管理 
阅读更多

有一种人，徘徊在牛a和牛c之间。。。

 

 在工作中经常有业务是异步的：

1.用户办了一个订单，填写了一个反馈，当订单竣工的时候要发短信通知客户，说你办理的业务现在成功了

2.用户定购了一个账单，要每个月都要给用用户发送 上月用户账单内容到指定的 邮箱 或者 手机

3.有些统计的内容 需要每天计算 插到数据库里

 

等等，这都需要有个自动任务来管理，定时执行这些任务，并且统一管理。

 

公司一牛人写了一个自动任务的框架，可以定时帮助我们执行一些任务，并且由一张表（neb_trigger）统一管理,在工作中我们就是使用的 这个自动任务的框架 来完成 某些异步业务 或者定时任务的

 

 

我们项目的架构 是前台的action调用 后台的ejb ，因此自动任务 写在ejb里，大致的原理如下：

 

1.首先 自动任务（Trigger）维护着 一张表 （netb_trigger）,她根据表中任务的信息，来执行业务方法（利用反射），表中有个字段是 业务方法的实现类的

 

2.定义了一个接口 TriggerTask ，只有一个方法 doTask（），何使用到自动任务的 业务都需要实现这个接口

 

3.Trigger 是一个会话bean ，其实现方法只有 一个业务方法 runTask（），它会调用 TriggerTask 接口中的runTask（）方法 利用反射来执行 业务方法

 

4.为了对 netb_trigger 进行 添加，修改，删除 自动任务，又写了一个 TriggerManage类，这个类是用来供Action层来添加删除和修改自动任务的，其中有个方法

 public static String addTask(
   String taskDesc,
   String clazz,
   String inParam,
   String cycle,
   String cycleLimit,
   String dayLimit,
   String hourLimit) throws Exception

 

自动任务将 利用 传递的clazz 来 反射调用业务方法

 

目标：通过 一个main方法去 掉部署在jboss的ejb的自动任务，然他去定时执行执行业务方法

 

为了让大家能使用到这个自动任务框架 我一步一步 让这个自动任务跑起来！！flow me,let's go！！

 

首要条件：需要有jboss ，hibernate，mysql 环境

 

步骤1：建立 自动任务状态表，以及对应的实体

任务表：netb_trigger

Sql代码 复制代码
  1. CREATE TABLE `netb_trigger` (              
  2.                 `ID` char(255) NOT NULL,                 
  3.                 `TASKDESC` char(255) DEFAULT NULL,       
  4.                 `STATE` int(10) DEFAULT NULL,            
  5.                 `CLAZZ` char(255) DEFAULT NULL,          
  6.                 `INPARAM` char(255) DEFAULT NULL,        
  7.                 `CYCLE` char(255) DEFAULT NULL,          
  8.                 `CYCLELIMIT` char(255) DEFAULT NULL,     
  9.                 `DAYLIMIT` char(255) DEFAULT NULL,       
  10.                 `HOURLIMIT` char(255) DEFAULT NULL,      
  11.                 `CREATETIME` datetime DEFAULT NULL,      
  12.                 `LASTTIME` datetime DEFAULT NULL,        
  13.                 PRIMARY KEY (`ID`)                       
  14.               ) ENGINE=InnoDB DEFAULT CHARSET=gbk        
CREATE TABLE `netb_trigger` (           
                `ID` char(255) NOT NULL,              
                `TASKDESC` char(255) DEFAULT NULL,    
                `STATE` int(10) DEFAULT NULL,         
                `CLAZZ` char(255) DEFAULT NULL,       
                `INPARAM` char(255) DEFAULT NULL,     
                `CYCLE` char(255) DEFAULT NULL,       
                `CYCLELIMIT` char(255) DEFAULT NULL,  
                `DAYLIMIT` char(255) DEFAULT NULL,    
                `HOURLIMIT` char(255) DEFAULT NULL,   
                `CREATETIME` datetime DEFAULT NULL,   
                `LASTTIME` datetime DEFAULT NULL,     
                PRIMARY KEY (`ID`)                    
              ) ENGINE=InnoDB DEFAULT CHARSET=gbk

 

 实体Tirgger

 

Java代码 复制代码
  1. package cn.com.xinli.netb.entitys;   
  2.   
  3. import java.io.Serializable;   
  4. import java.sql.Timestamp;   
  5.   
  6. /**  
  7.  *  触发任务表  
  8.  * @author diaoyf  
  9.  *  
  10.  */  
  11. public class Trigger implements Serializable   
  12. {   
  13.     public static final long serialVersionUID = 1;   
  14.        
  15.     /** id */  
  16.     private String id;   
  17.        
  18.     /** 触发任务描述 */  
  19.     private String taskDesc;   
  20.        
  21.     /** 触发状态 0：允许触发 1：取消触发 */  
  22.     private int state;   
  23.        
  24.     /**  
  25.      * 回调对象的包、类路径名  
  26.      * 触发管理器根据此包、类路径名，通过反射机制实例化对象  
  27.      */  
  28.     private String clazz;   
  29.     /** 回调方法输入参数 */  
  30.     private String inParam;   
  31.   
  32.     /**  
  33.      * 触发周期  
  34.      * <li>atonce 表示一次(由小时触发器管理)</li>  
  35.      * <li>min 表示每分</li>  
  36.      * <li>hour 表示每小时</li>  
  37.      * <li>day 表示每天</li>  
  38.      * <li>month 表示每月</li>  
  39.      * <li>3month 表示每季度</li>  
  40.      * <li>year 表示每年</li>  
  41.      */  
  42.     private String cycle;   
  43.        
  44.     /**  
  45.      *  触发时间限制  
  46.      *  格式"2007/10/2 8:15:28-2007/10/3 18:15:30"，表示任务存在时间  
  47.      *  格式"-", 表示无触发时间限制  
  48.      *    
  49.      */  
  50.     private String cycleLimit;    
  51.     /**  
  52.      * 触发日期限制  
  53.      * 如月账单反馈限制在每月10~15日(包括15日)，dayLimit设置格式为"10-15"；  
  54.      * 如限制在每月10日，设置格式为"10-10";  
  55.      * 如果没有日期限制，设置格式为"-"  
  56.      * 如果起始日期大于终止日期，如"25-10"，表示当月25日到下月10日  
  57.      */  
  58.     private String dayLimit;    
  59.     /**  
  60.      * 触发时间限制，时间规则最小"00:00"，最大"23:59"  
  61.      * 如邮件反馈限制在每天8~17时(8:00~17:59)，hourLimit设置格式为"8:00-17:59"；  
  62.      * 如限制在12时(12:00~12:59)，设置格式为"12:00-12:59".  
  63.      * 如果没有时间限制，设置格式为"-"  
  64.      * 如果起始日期大于终止日期，如"23:00-8:59"，表示当日23:00到下一日8:59  
  65.      */  
  66.     private String hourLimit;   
  67.        
  68.     /** 触发任务创建时间 */  
  69.     private Timestamp createTime;   
  70.     /** 最后一次触发时间 */  
  71.     private Timestamp lastTime;   
  72.        
  73.        
  74.     public String getId()   
  75.     {   
  76.         return id;   
  77.     }   
  78.     public void setId(String id)   
  79.     {   
  80.         this.id = id;   
  81.     }   
  82.     public String getTaskDesc()   
  83.     {   
  84.         return taskDesc;   
  85.     }   
  86.     public void setTaskDesc(String taskDesc)   
  87.     {   
  88.         this.taskDesc = taskDesc;   
  89.     }   
  90.     public int getState()   
  91.     {   
  92.         return state;   
  93.     }   
  94.     public void setState(int state)   
  95.     {   
  96.         this.state = state;   
  97.     }   
  98.     public String getClazz()   
  99.     {   
  100.         return clazz;   
  101.     }   
  102.     public void setClazz(String clazz)   
  103.     {   
  104.         this.clazz = clazz;   
  105.     }   
  106.     public String getInParam()   
  107.     {   
  108.         return inParam;   
  109.     }   
  110.     public void setInParam(String inParam)   
  111.     {   
  112.         this.inParam = inParam;   
  113.     }   
  114.     public String getCycle()   
  115.     {   
  116.         return cycle;   
  117.     }   
  118.     public void setCycle(String cycle)   
  119.     {   
  120.         this.cycle = cycle;   
  121.     }   
  122.     public String getCycleLimit()   
  123.     {   
  124.         return cycleLimit;   
  125.     }   
  126.     public void setCycleLimit(String cycleLimit)   
  127.     {   
  128.         this.cycleLimit = cycleLimit;   
  129.     }   
  130.     public String getDayLimit()   
  131.     {   
  132.         return dayLimit;   
  133.     }   
  134.     public void setDayLimit(String dayLimit)   
  135.     {   
  136.         this.dayLimit = dayLimit;   
  137.     }   
  138.     public String getHourLimit()   
  139.     {   
  140.         return hourLimit;   
  141.     }   
  142.     public void setHourLimit(String hourLimit)   
  143.     {   
  144.         this.hourLimit = hourLimit;   
  145.     }   
  146.     public Timestamp getCreateTime()   
  147.     {   
  148.         return createTime;   
  149.     }   
  150.     public void setCreateTime(Timestamp createTime)   
  151.     {   
  152.         this.createTime = createTime;   
  153.     }   
  154.     public Timestamp getLastTime()   
  155.     {   
  156.         return lastTime;   
  157.     }   
  158.     public void setLastTime(Timestamp lastTime)   
  159.     {   
  160.         this.lastTime = lastTime;   
  161.     }   
  162.        
  163.   
  164.   
  165. }  
package cn.com.xinli.netb.entitys;

import java.io.Serializable;
import java.sql.Timestamp;

/**
 *  触发任务表
 * @author diaoyf
 *
 */
public class Trigger implements Serializable
{
	public static final long serialVersionUID = 1;
	
	/** id */
	private String id;
	
	/** 触发任务描述 */
	private String taskDesc;
	
	/** 触发状态 0：允许触发 1：取消触发 */
	private int state;
	
	/**
	 * 回调对象的包、类路径名
	 * 触发管理器根据此包、类路径名，通过反射机制实例化对象
	 */
	private String clazz;
	/** 回调方法输入参数 */
	private String inParam;

	/**
	 * 触发周期
	 * <li>atonce 表示一次(由小时触发器管理)</li>
	 * <li>min 表示每分</li>
	 * <li>hour 表示每小时</li>
	 * <li>day 表示每天</li>
	 * <li>month 表示每月</li>
	 * <li>3month 表示每季度</li>
	 * <li>year 表示每年</li>
	 */
	private String cycle;
	
	/**
	 *  触发时间限制
	 *  格式"2007/10/2 8:15:28-2007/10/3 18:15:30"，表示任务存在时间
	 *  格式"-", 表示无触发时间限制
	 *  
	 */
	private String cycleLimit; 
	/**
	 * 触发日期限制
	 * 如月账单反馈限制在每月10~15日(包括15日)，dayLimit设置格式为"10-15"；
	 * 如限制在每月10日，设置格式为"10-10";
	 * 如果没有日期限制，设置格式为"-"
	 * 如果起始日期大于终止日期，如"25-10"，表示当月25日到下月10日
	 */
	private String dayLimit; 
	/**
	 * 触发时间限制，时间规则最小"00:00"，最大"23:59"
	 * 如邮件反馈限制在每天8~17时(8:00~17:59)，hourLimit设置格式为"8:00-17:59"；
	 * 如限制在12时(12:00~12:59)，设置格式为"12:00-12:59".
	 * 如果没有时间限制，设置格式为"-"
	 * 如果起始日期大于终止日期，如"23:00-8:59"，表示当日23:00到下一日8:59
	 */
	private String hourLimit;
	
	/** 触发任务创建时间 */
	private Timestamp createTime;
	/** 最后一次触发时间 */
	private Timestamp lastTime;
	
	
	public String getId()
	{
		return id;
	}
	public void setId(String id)
	{
		this.id = id;
	}
	public String getTaskDesc()
	{
		return taskDesc;
	}
	public void setTaskDesc(String taskDesc)
	{
		this.taskDesc = taskDesc;
	}
	public int getState()
	{
		return state;
	}
	public void setState(int state)
	{
		this.state = state;
	}
	public String getClazz()
	{
		return clazz;
	}
	public void setClazz(String clazz)
	{
		this.clazz = clazz;
	}
	public String getInParam()
	{
		return inParam;
	}
	public void setInParam(String inParam)
	{
		this.inParam = inParam;
	}
	public String getCycle()
	{
		return cycle;
	}
	public void setCycle(String cycle)
	{
		this.cycle = cycle;
	}
	public String getCycleLimit()
	{
		return cycleLimit;
	}
	public void setCycleLimit(String cycleLimit)
	{
		this.cycleLimit = cycleLimit;
	}
	public String getDayLimit()
	{
		return dayLimit;
	}
	public void setDayLimit(String dayLimit)
	{
		this.dayLimit = dayLimit;
	}
	public String getHourLimit()
	{
		return hourLimit;
	}
	public void setHourLimit(String hourLimit)
	{
		this.hourLimit = hourLimit;
	}
	public Timestamp getCreateTime()
	{
		return createTime;
	}
	public void setCreateTime(Timestamp createTime)
	{
		this.createTime = createTime;
	}
	public Timestamp getLastTime()
	{
		return lastTime;
	}
	public void setLastTime(Timestamp lastTime)
	{
		this.lastTime = lastTime;
	}
	


}

 

 

 

 

步骤2：建立 trigger ejb 的本地接口和远程接口，Bean实现

 

TriggerBean.java

 

Java代码 复制代码
  1. package cn.com.xinli.netb.ejb.trigger.service;   
  2.   
  3. import java.rmi.RemoteException;   
  4. import java.util.Date;   
  5.   
  6. import javax.ejb.SessionBean;   
  7.   
  8. import org.apache.log4j.Logger;   
  9.   
  10. import cn.com.xinli.netb.ejb.trigger.TriggerTask;   
  11.   
  12. public class TriggerBean implements SessionBean   
  13. {   
  14.     static Logger log = Logger.getLogger(TriggerBean.class);   
  15.        
  16.     private javax.ejb.SessionContext m_ctx = null;   
  17.   
  18.     /**  
  19.      * Sets the session context. Required by EJB spec.  
  20.      *   
  21.      * @param ctx  
  22.      *            A SessionContext object.  
  23.      */  
  24.     public void setSessionContext(javax.ejb.SessionContext ctx)    
  25.     {   
  26.         m_ctx = ctx;   
  27.     }   
  28.   
  29.     /**  
  30.      * Creates a bean. Required by EJB spec.  
  31.      *   
  32.      * @exception throws  
  33.      *                CreateException.  
  34.      */  
  35.     public void ejbCreate() throws javax.ejb.EJBException,   
  36.             javax.ejb.CreateException    
  37.     {   
  38.     }   
  39.   
  40.     /**  
  41.      * Removes the bean. Required by EJB spec.  
  42.      */  
  43.     public void ejbRemove()    
  44.     {   
  45.     }   
  46.   
  47.     /**  
  48.      * Loads the state of the bean from secondary storage. Required by EJB spec.  
  49.      */  
  50.     public void ejbActivate()    
  51.     {   
  52.     }   
  53.   
  54.     /**  
  55.      * Serializes the state of the bean to secondary storage. Required by EJB  
  56.      * spec.  
  57.      */  
  58.     public void ejbPassivate()    
  59.     {   
  60.     }   
  61.        
  62.     // ------------------------------------------   
  63.     // 业务方法   
  64.     // ------------------------------------------   
  65.     public String runTask(String triggerId, String clazz, String inParam) throws RemoteException   
  66.     {   
  67.         TriggerTask task = null;   
  68.         try  
  69.         {   
  70.             task = (TriggerTask)Class.forName(clazz).newInstance();   
  71.         }   
  72.         catch (Exception e)   
  73.         {   
  74.             log.error("反射调用触发任务类异常", e);   
  75.             throw new RemoteException("反射调用触发任务类异常");   
  76.         }   
  77.            
  78.         log.info("调用触发实现类，类名:" + clazz + ",参数:" + inParam + ",调用时间:" + new Date());   
  79.            
  80.         //回调任务类，并得到运行结果   
  81.         return task.doTask(triggerId, inParam);   
  82.     }   
  83. }  
package cn.com.xinli.netb.ejb.trigger.service;

import java.rmi.RemoteException;
import java.util.Date;

import javax.ejb.SessionBean;

import org.apache.log4j.Logger;

import cn.com.xinli.netb.ejb.trigger.TriggerTask;

public class TriggerBean implements SessionBean
{
	static Logger log = Logger.getLogger(TriggerBean.class);
	
	private javax.ejb.SessionContext m_ctx = null;

	/**
	 * Sets the session context. Required by EJB spec.
	 * 
	 * @param ctx
	 *            A SessionContext object.
	 */
	public void setSessionContext(javax.ejb.SessionContext ctx) 
	{
		m_ctx = ctx;
	}

	/**
	 * Creates a bean. Required by EJB spec.
	 * 
	 * @exception throws
	 *                CreateException.
	 */
	public void ejbCreate() throws javax.ejb.EJBException,
			javax.ejb.CreateException 
	{
	}

	/**
	 * Removes the bean. Required by EJB spec.
	 */
	public void ejbRemove() 
	{
	}

	/**
	 * Loads the state of the bean from secondary storage. Required by EJB spec.
	 */
	public void ejbActivate() 
	{
	}

	/**
	 * Serializes the state of the bean to secondary storage. Required by EJB
	 * spec.
	 */
	public void ejbPassivate() 
	{
	}
	
	// ------------------------------------------
	// 业务方法
	// ------------------------------------------
	public String runTask(String triggerId, String clazz, String inParam) throws RemoteException
	{
		TriggerTask task = null;
		try
		{
			task = (TriggerTask)Class.forName(clazz).newInstance();
		}
		catch (Exception e)
		{
			log.error("反射调用触发任务类异常", e);
			throw new RemoteException("反射调用触发任务类异常");
		}
		
		log.info("调用触发实现类，类名:" + clazz + ",参数:" + inParam + ",调用时间:" + new Date());
		
		//回调任务类，并得到运行结果
		return task.doTask(triggerId, inParam);
	}
}

 

 TriggerHome.java

 

Java代码 复制代码
  1. package cn.com.xinli.netb.ejb.trigger.service;   
  2.   
  3. import javax.ejb.EJBHome;   
  4.   
  5. public interface TriggerHome extends EJBHome   
  6. {   
  7.     TriggerRemote create() throws java.rmi.RemoteException, javax.ejb.CreateException;    
  8. }  
package cn.com.xinli.netb.ejb.trigger.service;

import javax.ejb.EJBHome;

public interface TriggerHome extends EJBHome
{
	TriggerRemote create() throws java.rmi.RemoteException, javax.ejb.CreateException; 
}

 

TriggerRemote.java 

 

Java代码 复制代码
  1. package cn.com.xinli.netb.ejb.trigger.service;   
  2.   
  3. import java.rmi.RemoteException;   
  4.   
  5. import javax.ejb.EJBObject;   
  6.   
  7. public interface TriggerRemote extends EJBObject   
  8. {   
  9.     /**  
  10.      * 调用反馈任务  
  11.      * @param triggerId 任务ID  
  12.      * @param clazz 反射类名  
  13.      * @param inParam 运行参数  
  14.      * @return  
  15.      *  <li>00: 成功，触发管理器将从触发表中取消此任务</li>  
  16.      *  <li>01: 失败，并触发管理器将从触发表中取消此任务</li>  
  17.      *  <li>10: 成功，触发管理器在触发表中保持此任务</li>  
  18.      *  <li>11: 失败，触发管理器在触发表中保持此任务</li>  
  19.      * @throws RemoteException  
  20.      */  
  21.     public String runTask(String triggerId, String clazz, String inParam) throws RemoteException;   
  22. }  
package cn.com.xinli.netb.ejb.trigger.service;

import java.rmi.RemoteException;

import javax.ejb.EJBObject;

public interface TriggerRemote extends EJBObject
{
	/**
	 * 调用反馈任务
	 * @param triggerId 任务ID
	 * @param clazz 反射类名
	 * @param inParam 运行参数
	 * @return
	 * 	<li>00: 成功，触发管理器将从触发表中取消此任务</li>
	 * 	<li>01: 失败，并触发管理器将从触发表中取消此任务</li>
	 * 	<li>10: 成功，触发管理器在触发表中保持此任务</li>
	 * 	<li>11: 失败，触发管理器在触发表中保持此任务</li>
	 * @throws RemoteException
	 */
	public String runTask(String triggerId, String clazz, String inParam) throws RemoteException;
}

 

 

步骤3：建立 TriggerManage ，用来操作 自动任务

Java代码 
package cn.com.xinli.netb.ejb.trigger;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.Timestamp;

import org.apache.log4j.Logger;
import org.hibernate.Session;

import cn.com.xinli.netb.ejb.common.HibernateUtil;
import cn.com.xinli.netb.entitys.Trigger;

/**
 * 触发任务管理
 * @author diaoyf
 *
 */
public class TriggerManage
{
	private static Logger log = Logger.getLogger(TriggerManage.class);
	

	
	/**
	 * 增加触发任务
	 * @param taskDesc 任务描述
	 * @param clazz 
	 * 		回调对象的包、类路径名。
	 * 		触发管理器根据此包、类路径名，通过反射机制实例化对象
	 * @param inParam
	 * 		回调方法输入参数
	 * @param cycle
	 * 		触发周期
	 * 	<li>atonce 表示一次(由小时触发器管理)</li>
	 * 	<li>min 表示每分</li>
	 * 	<li>hour 表示每小时</li>
	 * 	<li>day 表示每天</li>
	 * 	<li>week 表示每周</li>
	 * 	<li>month 表示每月</li>
	 * 	<li>3month 表示每季度</li>
	 * 	<li>year 表示每年</li>
	 * @param cycleLimit
	 * 		触发时间限制。
	 *  	<li>格式"2007/10/2 8:15:28-2007/10/3 18:15:30"，表示任务存在时间;</li>
	 *  	<li>格式"-", 表示无触发时间限制。</li>
	 * @param dayLimit
	 * 		触发日期限制。
	 * 		<li>如月账单反馈限制在每月10~15日(包括15日)，dayLimit设置格式为"10-15"；</li>
	 * 		<li>如限制在每月10日，设置格式为"10-10";</li>
	 * 		<li>如果没有日期限制，设置格式为"-";</li>
	 * 		<li>如果起始日期大于终止日期，如"25-10"，表示当月25日到下月10日。</li>
	 * 		<li>周触发任务: "w-1"表示周日发送、"w-2"表示周1发送、..."w-7"表示周6发送</li>
	 * @param hourLimit
	 * 		触发时间限制，时间规则最小"00:00"，最大"23:59"。</li>
	 * 		<li>如邮件反馈限制在每天8~17时(8:00-17:59)，hourLimit设置格式为"8:00-17:59"；</li>
	 * 		<li>如限制在12时(12:00-12:59)，设置格式为"12:00-12:59";</li>
	 * 		<li>如果没有时间限制，设置格式为"-";</li>
	 * 		<li>如果起始日期大于终止日期，如"23:00-8:59"，表示当日23:00到下一日8:59。</li>
	 * @return 触发ID
	 * @throws Exception
	 */
	public static String addTask(
			String taskDesc,
			String clazz,
			String inParam,
			String cycle,
			String cycleLimit,
			String dayLimit,
			String hourLimit) throws Exception
	{
		Trigger trigger = new Trigger();
		trigger.setTaskDesc(taskDesc);
		trigger.setState(0);
		trigger.setClazz(clazz);
		trigger.setInParam(inParam);
		trigger.setCycle(cycle);
		trigger.setCycleLimit(cycleLimit);
		trigger.setHourLimit(hourLimit);
		trigger.setDayLimit(dayLimit);
		trigger.setCreateTime(new Timestamp(System.currentTimeMillis()));
		trigger.setLastTime(new Timestamp(0)); //默认1970年
		
		return addTask(trigger);
	}
	
	
	
	

	/**
	 * 增加触发任务
	 * @param trigger
	 * @throws Exception
	 */
	static String addTask(Trigger trigger) throws Exception
	{
		Session session = null;
		try 
		{
			session = HibernateUtil.getSession();
			
			//事物
//			Transaction tran = session.beginTransaction();

			session.save(trigger);
			session.flush();
			
//			tran.commit();
			
			return trigger.getId();
		} 
		catch (Exception e) 
		{
			log.error("获取Session异常", e);
			e.printStackTrace();
			throw new Exception("获取Session异常");
		} 
		finally
		{
			HibernateUtil.closeSession(session);
		}


	}
	

	
	/**
	 *  置触发任务为1（取消）
	 * @param trigger
	 */
	static void cancelTask(Trigger trigger)throws Exception
	{
		
		Session session = null;
		try
		{
			session = HibernateUtil.getSession();
			
			//修改状态标志, 1:取消
			trigger.setState(1);
			
			//事物
//			Transaction tran = session.beginTransaction();

			session.update(trigger);
			
//			tran.commit();
		}
		catch (Exception e)
		{
			log.error("置触发任务为1（取消）失败", e);
			throw new Exception("置触发任务为1（取消）失败");
		}
		finally
		{
			HibernateUtil.closeSession(session);
		}

	}
	
	/**
	 *  置触发任务为1（取消）
	 * @param trigger
	 */
	public static void cancelTask(String triggerId) throws Exception
	{
//		Session session = null;
		Connection conn = null;
		PreparedStatement prepStmt = null;
		try 
		{
//			session = HibernateUtil.currentSession();
			conn = HibernateUtil.getConnection();
			
//			conn.setAutoCommit(false);
			
			String sql = "UPDATE NETB_TRIGGER SET state = ? WHERE id = ?";
			prepStmt = conn.prepareStatement(sql);
			prepStmt.setInt(1, 1);
			prepStmt.setString(2, triggerId);
			
			prepStmt.execute();
			
//			conn.commit();
		} 
		catch (Exception e) 
		{
//			conn.rollback();
			log.error("置任务状态为1（取消）时，数据库操作异常", e);
			throw new Exception("置任务状态为1（取消）时，数据库操作异常");
		} 
		finally 
		{
			try
			{
				conn.close();
			}
			catch (Exception e)
			{
				
			}
		}
	}
	
	public static void updateTask(  String triggerId,
									String taskDesc,
									String clazz,
									String inParam,
									String cycle,
									String cycleLimit,
									String dayLimit,
									String hourLimit) throws Exception
	{
		Connection conn = null;
		PreparedStatement prepStmt = null;
		try 
		{
//			session = HibernateUtil.currentSession();
			conn = HibernateUtil.getConnection();
			
//			conn.setAutoCommit(false);
			
			String sql = "UPDATE NETB_TRIGGER SET taskDesc = ? ,clazz=?,inParam=?," +
					                            "cycle=?,cycleLimit=?,dayLimit=? and hourLimit=?"+
			                                    "WHERE id = ?";
			prepStmt = conn.prepareStatement(sql);
			prepStmt.setString(1, taskDesc);
			prepStmt.setString(2, clazz);
			prepStmt.setString(3, inParam);
			prepStmt.setString(4, cycle);
			prepStmt.setString(5, cycleLimit);
			prepStmt.setString(6, dayLimit);
			prepStmt.setString(7, hourLimit);
			prepStmt.setString(8, triggerId);
			prepStmt.execute();
			
//			conn.commit();
		} 
		catch (Exception e) 
		{
//			conn.rollback();
			log.error("置任务状态为1（取消）时，数据库操作异常", e);
			throw new Exception("置任务状态为1（取消）时，数据库操作异常");
		} 
		finally 
		{
			try
			{
				conn.close();
			}
			catch (Exception e)
			{
				
			}
		}
	}
	public static void main(String[] args) throws Exception
	{
		TriggerManage tm=new TriggerManage();
		Trigger trigger=new Trigger();
		trigger.setTaskDesc("测试2");
		System.out.println(tm.addTask(trigger));;
		
	}
}
 

步骤4：在ejb层建立 测试的业务方法，供自动任务调用

package cn.com.xinli.netb.ejb.trigger;
import org.apache.log4j.Logger;
import cn.com.xinli.netb.ejb.trigger.TriggerTask;

/**
 * 自动任务测试任务
 * 
 * @author huxl
 * 2008/9/23
 */
public class TriggerTaskTest implements TriggerTask 
{

    static Logger log = Logger.getLogger(TriggerTaskTest.class);
    public  String doTask(String triggerId, String inParam) 
    {
    	
    	log.info("自动任务测试任务开始执行");
    	log.info("triggerId："+triggerId);
    	log.info("inParam："+inParam);
    	return "10"; //成功继续保持此业务
    }
}

 

步骤5：自动任务框架，主要有两个线程，分钟线程 和小时线程 不停的去扫描数据库找到满足触发条件的任务，利用发射机制去执行，代码见附件。
如何使用这个自动任务框架 ：
 
     1.讲ejb TriggerEJB 项目打成jar包放在jboss下
2.配置 TriggerThread 项目的 数据库配置文件
3.手工插入一条任务
 
 
4.启动 TriggerThread  中的Main ，观察我们插入的分钟任务的执行，看日志
TriggerThread 框架的日志：
0    [main] INFO  Main(34) - DB_URL:jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
0    [main] INFO  Main(35) - DB_USER:root
16   [main] INFO  Main(36) - DB_PASSWD:12345678
16   [main] INFO  Main(37) - EJB_URL:jnp://127.0.0.1:1099
16   [Thread-0] INFO  TriggerHourThread(22) - 小时任务线程运行....
16   [Thread-1] INFO  TriggerMinThread(20) - 分钟任务线程运行....
609  [Thread-1] INFO  TriggerMinThread(38) - 运行触发任务
703  [Thread-1] INFO  TriggerMinThread(77) - sql:SELECT * FROM NETB_TRIGGER  WHERE 	state = ? AND 	cycle = ?  ORDER BY  	createTime
719  [Thread-1] INFO  TriggerMinThread(99) - 准备处理分钟任务：id=2003
719  [Thread-1] INFO  TriggerMinThread(130) - 开始处理分钟任务
719  [Thread-1] INFO  TriggerMinThread(149) - 上次触发时间：2009-08-01 18:00:32.0
750  [Thread-1] INFO  TriggerMinThread(150) - 当前时间：2009-08-01 18:15:04
750  [Thread-1] INFO  TriggerMinThread(157) - 分钟任务,id=2003距离上次触发已超过1分钟
781  [Thread-1] INFO  EJBHomeFactory(72) - EJB Home缓存中没有TriggerHome，创建之。
1094 [Thread-1] INFO  EJBHomeFactory(76) - 在JNDI中查询到了“Trigger”
1094 [Thread-1] INFO  EJBHomeFactory(79) - 成功获得远程Home对象，并存入缓存
1094 [Thread-1] INFO  Ejb(51) - 从Home工厂获取到了“TriggerHome”
1187 [Thread-1] INFO  Ejb(55) - 通过home成功获得remote对象
1203 [Thread-1] INFO  TriggerMinThread(162) - 分钟任务,id=2003返回值:10
 
jboss的日志
s_4_0_4_GA date=200605151000)] Started in 21s:578ms
18:15:05,062 INFO  [TriggerBean] 调用触发实现类，类名:cn.com.xinli.netb.ejb.trig
ger.TriggerTaskTest,参数:00,调用时间:Sat Aug 01 18:15:05 CST 2009
18:15:05,062 INFO  [TriggerTaskTest] 自动任务测试任务开始执行
18:15:05,062 INFO  [TriggerTaskTest] triggerId：2003
18:15:05,062 INFO  [TriggerTaskTest] inParam：00
 
OK！！
分享到：
| vsftpd FTP服务器架设
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    签到 —— 一个自动签到框架

    【签到——一个自动签到框架】是一个基于Python 2.7开发的自动化工具，它设计用于简化日常的在线签到任务，如社区论坛、学习平台或其他需要定期签到的网站。这个框架允许用户通过编写特定的签到脚本，实现自动化签到...

    Jmeter接口自动化测试框架

    Ant是一个基于Java的构建工具，它能够自动化地执行各种任务。下载Ant并安装，下载地址为http://ant.apache.org/。安装完成后，需要配置Ant环境变量。 第三步：配置Jmeter和Ant环境变量 在安装Jmeter和Ant后，需要...

    Python-一个电脑桌面自动化操作框架

    总结来说，Python的桌面自动化框架是一个强大的工具，它简化了与计算机桌面环境的交互，为开发者提供了极大的便利。"self-driving-desktop-master"这个项目可能是实现此类功能的一个实例，通过学习和使用，可以提升...

    Spring 框架自带定时任务和Quartz定时任务

    TimerTask是一个抽象类，我们需要创建它的一个子类，并重写run方法来执行定时任务的具体内容。使用这种方式，程序可以按照一定的频率执行，但这种方式是单线程的，所以不适合执行复杂的、高频率的定时任务。 接着是...

    轻量级定时任务框架.zip

    本框架以ZIP压缩包的形式提供，名为"轻量级定时任务框架.zip"，其中包含的核心组件是Quartz，这是一个广为使用的开源作业调度库，能够与Java应用程序无缝集成，实现灵活的定时任务调度。 Quartz框架的基本概念包括...

    RF自动化框架

    射频（RF）自动化框架是现代信息技术领域中的一个重要概念，特别是在软件测试自动化中。射频，全称为Radio Frequency，指的是处于300千赫兹（kHz）至30吉赫兹（GHz）之间的电磁频率，这个频段的电波能够以无线方式...

    WEB自动化测试框架文档.doc

    【文档标题】：“WEB自动化测试框架文档.doc” ...总的来说，这个WEB自动化测试框架文档提供了全面的测试策略，从设计测试用例到执行、结果分析，覆盖了自动化测试的各个方面，旨在提升整个软件开发过程的效率和质量。

    Spring整合任务调度框架Quartz

    在 Java 领域中，Quartz 是一个非常流行的任务调度框架，而 Spring 是一个非常流行的 Java 框架。在本文中，我们将详细介绍如何将 Spring 整合任务调度框架 Quartz，从而实现任务调度的自动化。 一、使用配置文件...

    深度学习作业-基于pytorch框架python实现AI自动写诗完整源码+代码注释.zip

    自动写诗，使用tang.npz，使用深度学习框架Pytorch，最终实现一个可以自动写诗的程序。本实验的目的如下： 理解和掌握循环神经网络概念及在深度学习框架中的实现 掌握使用深度学习框架进行文本生成任务的基本流程：...

    基于thinkphp框架的定时器（定时执行任务）

    ThinkPHP框架，作为一个广泛使用的PHP开发框架，提供了实现定时任务的能力。本篇将详细介绍如何在ThinkPHP中设置和使用定时器来定时执行任务。 一、定时任务的概念与作用 定时任务，也称为Cron Job，在服务器环境...

    fitnesse自动化框架

    Fitnesse自动化框架是一款强大的开源测试工具，专为软件开发团队设计，以支持各种协议和编程语言。这个框架的核心理念是实现测试代码与业务逻辑的分离，使得非程序员也能参与到测试过程中，提升整个项目的协作效率。...

    Web自动化测试框架搭建

    总结来说，Web自动化测试框架搭建是一个涉及多个层次和技术组件的过程，通过合理的设计和实施，可以极大地提升测试的效率和质量。同时，结合持续集成，可以确保项目的稳定性和可靠性，为软件开发带来显著的效益。

    [Bugku-AWD专版]一款用于AWD比赛中的自动化攻击框架.zip

    【Bugku-AWD专版】是一款专为AWD（Attack With Defense）比赛设计的自动化攻击框架，它旨在帮助参赛者更高效地进行攻防对抗。这个框架的核心目标是简化比赛过程中对目标系统的攻击策略和自动化执行，使得参赛者能够...

    QD [v20240210] —— HTTP请求定时任务自动执行框架

    QD [v20240210] 是一个基于JavaScript编写的高效且灵活的HTTP请求定时任务自动执行框架。这个框架旨在帮助开发者实现定时执行HTTP请求的任务，以满足各种自动化需求，如数据抓取、系统监控、API测试等场景。它将HTTP...

    基于thinkphp5框架的定时执行任务

    在PHP开发领域，ThinkPHP5框架是一个非常流行的开源框架，它提供了丰富的功能和优秀的性能，使得开发者能够快速构建Web应用。本篇文章将深入探讨如何在ThinkPHP5框架中实现定时执行任务，即“基于thinkphp5框架的...

    自动化测试框架工具

    首先，Selenium是一个广泛使用的Web自动化测试框架，支持多种浏览器和编程语言。通过WebDriver接口，我们可以控制浏览器的行为，模拟用户操作，例如点击按钮、填写表单和导航页面。理解Selenium的工作原理和如何配置...

    taskPHP基于php开发的定时计划任务框架,多进程实现任务的分配和运行

    `taskPHP`是一个专为PHP设计的定时计划任务框架，它允许开发者创建、管理和执行周期性任务，从而实现自动化的工作流程。这个框架的一大亮点是其多进程实现，能够有效地分配和运行任务，提高任务执行效率。 ### 1. ...

    furion内置的定时任务使用学习，动态添加定时任务代码

    `HomeController.cs` 可能包含了一个控制器，用于展示或者管理定时任务。通过HTTP请求，用户可以触发任务的动态添加、删除或修改。在控制器中，我们可以调用Furion提供的API，如`BackgroundJob.Enqueue`来添加一次性...

Magicbox
Global site tag (gtag.js) - Google Analytics