程序博客网 > 微商小视频制作软件

定时任务-quartz的使用，实现可页面化管理 标签： quartz

来源：互联网 发布：微商小视频制作软件 编辑：程序博客网 时间：2024/04/29 18:26
定时任务-quartz的使用，实现可页面化管理
使用spring+quartz实现定时任务的页面化管理。主要特点：
1.时间表达式等信息配置在数据库中，从而实现页面化管理。
2.可以手动执行或者停止单个任务，也可以使一个任务加入或者移出自动运行列表。

下面开始介绍用法，在这之前先说明框架的版本。spring3.2.4+quartz1.6.0
一.配置文件
只需要在spring的配置文件中加入：
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <bean id="scheduler"  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">    
  2.     </bean>  
  3.     <bean id="jobManager"  class="com.temobi.quartz.JobManager">    
  4.     </bean>   

说明：scheduler对象是spring管理定时任务的对象。
jobManager是我们自定义加载定时任务列表的对象，此对象加载所有任务列表后，将他们加入到自动运行列表。
二.jobManager代码：
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. public class JobManager implements InitializingBean  {  
  2.     private static final Log log = LogFactory.getLog(JobManager.class);  
  3.     @Autowired  
  4.     TaskJobService taskJobService;  
  5.     @Autowired  
  6.     QuartzManager quartzManager;  
  7.     @Override  
  8.     public void afterPropertiesSet() throws Exception {  
  9.         loadAllJob();  
  10.     }  
  11.     private void loadAllJob(){  
  12.         List<TaskJob> list =taskJobService.getTaskList();  
  13.         quartzManager.enableCronSchedule(list);  
  14.     }  
  15.       
  16. }  


说明：
1.实现spring中InitializingBean接口，并覆盖afterPropertiesSet方法，则该方法会在应用启动的时候而且其他servlet执行完成之后执行，此处用来加载所有定时任务，并加入定时任务自动运行列表。
2.quartzManager是我们自定义的定时任务管理类，用来实现我们文章开头说的功能。
三.QuartzManager代码
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. @Controller  
  2. public class QuartzManager {  
  3.     @Autowired  
  4.     Scheduler scheduler;  
  5.       
  6.     private static final Log log = LogFactory.getLog(QuartzManager.class);  
  7.     public void enableCronSchedule(List<TaskJob> list) {  
  8.         for(TaskJob task : list){  
  9.             SchedulingJob job = new SchedulingJob();  
  10.             job.setJobId(task.getId());  
  11.             job.setJobName(task.getJobName());  
  12.             //job.setMemos(task.getNote());  
  13.             job.setCronExpression(task.getJobCronExpression());  
  14.             try{  
  15.             String  className=  task.getJobClass().trim();  
  16.                 Class clazz = Class.forName(className);  
  17.                 job.setStateFulljobExecuteClass(clazz);  
  18.             }catch(Exception e){  
  19.                 e.printStackTrace();  
  20.                 continue;  
  21.             }  
  22.             JobDataMap paramsMap = new JobDataMap();  
  23.             paramsMap.put("jobName", task.getJobName());  
  24.   
  25.             if(task.getParamsKey1()!=null && task.getParamsValue1()!=null){  
  26.                 paramsMap.put(task.getParamsKey1(), task.getParamsValue1());  
  27.             }  
  28.             if(task.getParamsKey2()!=null && task.getParamsValue2()!=null){  
  29.                 paramsMap.put(task.getParamsKey2(), task.getParamsValue2());  
  30.             }  
  31.             if(task.getParamsKey3()!=null && task.getParamsValue3()!=null){  
  32.                 paramsMap.put(task.getParamsKey3(), task.getParamsValue3());  
  33.             }  
  34.             enableCronSchedule(job, paramsMap, true);  
  35.               
  36.             log.info("系统结束初始化任务："+task.getId()+":"+task.getJobName()+":"+task.getJobId());  
  37.         }  
  38.     }  
  39.     /** 
  40.      * 启动一个自定义的job 
  41.      *  
  42.      * @param schedulingJob 
  43.      *            自定义的job 
  44.      * @param paramsMap 
  45.      *            传递给job执行的数据 
  46.      * @param isStateFull 
  47.      *            是否是一个同步定时任务，true：同步，false：异步 
  48.      * @return 成功则返回true，否则返回false 
  49.      */  
  50.     public boolean enableCronSchedule(SchedulingJob schedulingJob, JobDataMap paramsMap, boolean isStateFull) {  
  51.         if (schedulingJob == null) {  
  52.             return false;  
  53.         }  
  54.         try {  
  55.             //scheduler = (Scheduler) ApplicationHelper.getBean("scheduler");  
  56.             CronTrigger trigger = (CronTrigger) scheduler.getTrigger(schedulingJob.getTriggerName(),  
  57.                     schedulingJob.getJobGroup());  
  58.             if (null == trigger) {// 如果不存在该trigger则创建一个  
  59.                 JobDetail jobDetail = null;  
  60.                 if (isStateFull) {  
  61.                     jobDetail = new JobDetail(schedulingJob.getJobId(), schedulingJob.getJobGroup(),  
  62.                             schedulingJob.getStateFulljobExecuteClass());  
  63.                 } else {  
  64.                     jobDetail = new JobDetail(schedulingJob.getJobId(), schedulingJob.getJobGroup(),  
  65.                             schedulingJob.getJobExecuteClass());  
  66.                 }  
  67.                 jobDetail.setJobDataMap(paramsMap);  
  68.                 trigger = new CronTrigger(schedulingJob.getTriggerName(), schedulingJob.getJobGroup(),  
  69.                         schedulingJob.getCronExpression());  
  70.                 scheduler.scheduleJob(jobDetail, trigger);  
  71.             } else {  
  72.                 // Trigger已存在，那么更新相应的定时设置  
  73.                 trigger.setCronExpression(schedulingJob.getCronExpression());  
  74.                 scheduler.rescheduleJob(trigger.getName(), trigger.getGroup(), trigger);  
  75.             }  
  76.         } catch (Exception e) {  
  77.             e.printStackTrace();  
  78.             return false;  
  79.         }  
  80.         return true;  
  81.     }  
  82.   
  83.     /** 
  84.      * 禁用一个job 
  85.      *  
  86.      * @param jobId 
  87.      *            需要被禁用的job的ID 
  88.      * @param jobGroupId 
  89.      *            需要被警用的jobGroupId 
  90.      * @return 成功则返回true，否则返回false 
  91.      */  
  92.     public boolean disableSchedule(String jobId) {  
  93.         if (jobId.equals("")) {  
  94.             return false;  
  95.         }  
  96.         try {  
  97.             String jobGroupId="DEFAULT";  
  98.             Trigger trigger = getJobTrigger(jobId, jobGroupId);  
  99.             if (null != trigger) {  
  100.                 scheduler.deleteJob(jobId, jobGroupId);  
  101.             }  
  102.         } catch (SchedulerException e) {  
  103.             e.printStackTrace();  
  104.             return false;  
  105.         }  
  106.         return true;  
  107.     }  
  108.   
  109.     /** 
  110.      * 得到job的详细信息 
  111.      *  
  112.      * @param jobId 
  113.      *            job的ID 
  114.      * @param jobGroupId 
  115.      *            job的组ID 
  116.      * @return job的详细信息,如果job不存在则返回null 
  117.      */  
  118.     public JobDetail getJobDetail(String jobId, String jobGroupId) {  
  119.         if (jobId.equals("") || jobGroupId.equals("") || null == jobId || jobGroupId == null) {  
  120.             return null;  
  121.         }  
  122.         try {  
  123.             return scheduler.getJobDetail(jobId, jobGroupId);  
  124.         } catch (SchedulerException e) {  
  125.             e.printStackTrace();  
  126.             return null;  
  127.         }  
  128.     }  
  129.   
  130.     /** 
  131.      * 得到job对应的Trigger 
  132.      *  
  133.      * @param jobId 
  134.      *            job的ID 
  135.      * @param jobGroupId 
  136.      *            job的组ID 
  137.      * @return job的Trigger,如果Trigger不存在则返回null 
  138.      */  
  139.     public Trigger getJobTrigger(String jobId, String jobGroupId) {  
  140.         if (jobId.equals("") || jobGroupId.equals("") || null == jobId || jobGroupId == null) {  
  141.             return null;  
  142.         }  
  143.         try {  
  144.             return scheduler.getTrigger(jobId + "Trigger", jobGroupId);  
  145.         } catch (SchedulerException e) {  
  146.             e.printStackTrace();  
  147.             return null;  
  148.         }  
  149.     }  
  150.   
  151. }  


说明：
1.主要方法有三个，启动一个任务，禁用一个任务，启动多个任务。启动即加入自动运行列表，禁用即移出自动运行列表。
2.TaskJob是一个任务对象，和数据库表结构相对应，后面给出数据库设计。
3.程序中有类似，
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. paramsMap.put(task.getParamsKey1(), task.getParamsValue1());  
这样的代码，意思是假如你：如果你在数据库的ParamsKey1值为"username",ParamsValue1的值为"zhangsang".那么你在具体的job中给定变量名为"username"的变量并给出set/get方法，就可以得到值"zhangsang",此功能适用于给定时任务配置固定参数，并且参数名字随便你定。我们这里给了三个备用的，你也可以扩展，步骤就是数据库加一个字段，在上面的程序中paramsMap放入这个字段，当然你也可以不用参数。你数据库没有配置任何值，表示该定时任务没有固定参数。
4.SchedulingJob是一个定时任务执行参数的bean。即 将Taskjob对象的值经过处理转换成SchedulingJob对象，然后用SchedulingJob对象的值调用定时任务的API。
SchedulingJob对象主要做的事就是，TriggerName和JobGroup分别给出默认值。根据className生成StateFulljobExecuteClass的Class对象。
四。SchedulingJob代码：
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. public class SchedulingJob {  
  2.     public static final int JS_ENABLED = 0; // 任务启用状态  
  3.     public static final int JS_DISABLED = 1; // 任务禁用状态  
  4.     public static final int JS_DELETE = 2; // 任务已删除状态  
  5.   
  6.     private String jobId; // 任务的Id，一般为所定义Bean的ID  
  7.     private String jobName; // 任务的描述  
  8.     private String jobGroup; // 任务所属组的名称  
  9.     private int jobStatus; // 任务的状态，0：启用；1：禁用；2：已删除  
  10.     private String cronExpression; // 定时任务运行时间表达式  
  11.     private String memos; // 任务描述  
  12.     private Class<?> stateFulljobExecuteClass;//同步的执行类，需要从StatefulMethodInvokingJob继承  
  13.     private Class<?> jobExecuteClass;//异步的执行类，需要从MethodInvokingJob继承  
  14.       /** 
  15.        * 得到该job的Trigger名字 
  16.        * @return 
  17.        */  
  18.      public String getTriggerName() {  
  19.             return this.getJobId() + "Trigger";  
  20.      }  
  21.     public String getJobId() {  
  22.         return jobId;  
  23.     }  
  24.     public void setJobId(String jobId) {  
  25.         this.jobId = jobId;  
  26.     }  
  27.     public String getJobName() {  
  28.         return jobName;  
  29.     }  
  30.     public void setJobName(String jobName) {  
  31.         this.jobName = jobName;  
  32.     }  
  33.     public String getJobGroup() {  
  34.         if(jobGroup==null){  
  35.             jobGroup = Scheduler.DEFAULT_GROUP;  
  36.         }  
  37.         return jobGroup;  
  38.     }  
  39.     public void setJobGroup(String jobGroup) {  
  40.         this.jobGroup = jobGroup;  
  41.     }  
  42.     public int getJobStatus() {  
  43.         return jobStatus;  
  44.     }  
  45.     public void setJobStatus(int jobStatus) {  
  46.         this.jobStatus = jobStatus;  
  47.     }  
  48.     public String getCronExpression() {  
  49.         return cronExpression;  
  50.     }  
  51.     public void setCronExpression(String cronExpression) {  
  52.         this.cronExpression = cronExpression;  
  53.     }  
  54.     public String getMemos() {  
  55.         return memos;  
  56.     }  
  57.     public void setMemos(String memos) {  
  58.         this.memos = memos;  
  59.     }  
  60.     public Class<?> getStateFulljobExecuteClass() {  
  61.         return stateFulljobExecuteClass;  
  62.     }  
  63.     public void setStateFulljobExecuteClass(Class<?> stateFulljobExecuteClass) {  
  64.         this.stateFulljobExecuteClass = stateFulljobExecuteClass;  
  65.     }  
  66.     public Class<?> getJobExecuteClass() {  
  67.         return jobExecuteClass;  
  68.     }  
  69.     public void setJobExecuteClass(Class<?> jobExecuteClass) {  
  70.         this.jobExecuteClass = jobExecuteClass;  
  71.     }  
  72.     public static int getJS_ENABLED() {  
  73.         return JS_ENABLED;  
  74.     }  
  75.     public static int getJS_DISABLED() {  
  76.         return JS_DISABLED;  
  77.     }  
  78.     public static int getJS_DELETE() {  
  79.         return JS_DELETE;  
  80.     }  
  81.   
  82. }  

五。具体JOB实现
只要继承QuartzJobBean类，覆盖executeInternal方法即可。在job中可能通过get方法的方式得到jobDetail对象中JobDataMap(详见QuartzManager类)中同名参数值。示例代码。
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. @Controller  
  2. public class ContentJob extends QuartzJobBean{  
  3.     @Autowired  
  4.     TaskJobService taskJobService;  
  5.     private String  beginDate;  
  6.     private String  endDate;  
  7.       
  8.     /** 
  9.      * 手动执行任务 
  10.      * @param request 
  11.      */  
  12.     @RequestMapping("/contentJobManual.do")  
  13.     public void manual(HttpServletRequest request) {  
  14.         String startDate=request.getParameter("startDate");  
  15.         String endDate=request.getParameter("endDate");  
  16.         TaskJobService taskJobService = (TaskJobService) ApplicationHelper.getBean("taskJobService");  
  17.         Map<String, String> param = new HashMap<String, String>();  
  18.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");  
  19.         String today=sdf.format(new Date());  
  20.         if(StringUtils.isEmpty(startDate)){  
  21.             param.put("beginDate", today);   
  22.         }else{  
  23.             param.put("beginDate", startDate);   
  24.         }  
  25.         if(StringUtils.isEmpty(endDate)){  
  26.             param.put("endDate", today);   
  27.         }else{  
  28.             param.put("endDate", endDate);   
  29.         }  
  30.         taskJobService.callStatisticContent(param);  
  31.     }  
  32.       
  33.     @Override  
  34.     public void executeInternal(JobExecutionContext context) {  
  35.         TaskJobService taskJobService = (TaskJobService) ApplicationHelper.getBean("taskJobService");  
  36.         Map<String, String> param = new HashMap<String, String>();  
  37.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");  
  38.         String today=sdf.format(new Date());  
  39.         if(StringUtils.isEmpty(beginDate)){  
  40.             param.put("beginDate", today);   
  41.         }else{  
  42.             param.put("beginDate", beginDate);   
  43.         }  
  44.         if(StringUtils.isEmpty(endDate)){  
  45.             param.put("endDate", today);   
  46.         }else{  
  47.             param.put("endDate", endDate);   
  48.         }  
  49.         taskJobService.callStatisticContent(param);  
  50.     }  
  51.       
  52.     public String getBeginDate() {  
  53.         return beginDate;  
  54.     }  
  55.   
  56.     public void setBeginDate(String beginDate) {  
  57.         this.beginDate = beginDate;  
  58.     }  
  59.   
  60.     public String getEndDate() {  
  61.         return endDate;  
  62.     }  
  63.     public void setEndDate(String endDate) {  
  64.         this.endDate = endDate;  
  65.     }  

六。手动执行一个任务。可以将该job类声明成一个@Controller。另外写一个方法如上例中的manual方法。
扩展：目前还不能将自动运行的方法和手动执行的方法（即executeInternal方法和manual方法）写成一个。因为自动运行的方法不是一个action类，它不在web环境中，是通过反射实现的。如果把executeInternal这个方法强行配置成具有web功能的方法（即类上面加@Controller，方法上面加@RequestMapping("/contentJobManual.do")）也是不行的，因为该方法没有HttpServletRequest对象，获取不了参数。除非你的定时任务没有参数。当然你也不能修改该方法的参数类型，因为他是覆盖QuartzJobBean的方法。
七。数据库设计。
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. ID  VARCHAR2(60)    N                 
  2. JOB_CLASS   VARCHAR2(255)   N             
  3. JOB_NAME    VARCHAR2(60)    N             
  4. JOB_CRON_EXPRESSION VARCHAR2(60)    N         
  5. JOB_SERVICE_BEAN    VARCHAR2(60)    Y             
  6. PARAMS_KEY1 VARCHAR2(60)    Y             
  7. PARAMS_VALUE1   VARCHAR2(60)    Y             
  8. PARAMS_KEY2 VARCHAR2(60)    Y             
  9. PARAMS_VALUE2   VARCHAR2(60)    Y             
  10. PARAMS_KEY3 VARCHAR2(60)    Y             
  11. PARAMS_VALUE3   VARCHAR2(60)    Y             
  12. NOTE    VARCHAR2(255)   Y             
  13. JOB_STATUS  VARCHAR2(1) Y             
  14. UPDATETIME  DATE    Y             
  15. JOB_AUTORUN VARCHAR2(1) Y  
  16. JOB_GROUP   VARCHAR2(60)    Y             

说明：JOB_STATUS表示是否有效任务，JOB_AUTORUN表示是否自动运行，JOB_SERVICE_BEAN表示手动执行的请求URL，JOB_CLASS表示JOB类的全路径，JOB_GROUP表示任务属于哪个组，方便对任务的分组管理（批量启动，禁止等），区别于quartz的API所要求的同名参数，其实也可以把这个值传给API。其它字段比较好理解。该表对应的bean是taskjob。
八。页面管理。
主要功能是将一个任务加入或者移出自动运行队列（通过quartzManager对象）。和任务的增删查改。示例代码如下：
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. @Controller  
  2. public class TaskJobAction{  
  3.     private static final Log log = LogFactory.getLog(TaskJobAction.class);  
  4.     @Autowired  
  5.     TaskJobService taskJobService;  
  6.     @Autowired  
  7.     QuartzManager quartzManager;  
  8.       
  9.     @RequestMapping("/enableTask.do")  
  10.     public void enableTask(HttpServletRequest request, HttpServletResponse response) throws IOException {  
  11.         String parameterStr="";  
  12.         parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);  
  13.         parameterStr = StringUtils.trim(parameterStr);  
  14.         parameterStr =URLDecoder.decode(parameterStr,"utf-8");  
  15.         Map<String, String> p = JsonUtil.getParameterMap(parameterStr);  
  16.         String id=p.get("id");  
  17.         if(!StringUtils.isEmpty(id)){  
  18.             TaskJob task=taskJobService.getTaskById(id);  
  19.             List<TaskJob> list=new ArrayList<TaskJob>();  
  20.             list.add(task);  
  21.             quartzManager.enableCronSchedule(list);  
  22.               
  23.             task.setJobEnabled("Y");  
  24.             taskJobService.update(task);//将任务设置成自动运行状态  
  25.         }  
  26.               
  27.     }  
  28.     @RequestMapping("/disableTask.do")  
  29.     public void disableTask(HttpServletRequest request, HttpServletResponse response) throws IOException {  
  30.         String parameterStr="";  
  31.         parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);  
  32.         parameterStr = StringUtils.trim(parameterStr);  
  33.         parameterStr =URLDecoder.decode(parameterStr,"utf-8");  
  34.         Map<String, String> p = JsonUtil.getParameterMap(parameterStr);  
  35.         String id=p.get("id");  
  36.         if(!StringUtils.isEmpty(id)){  
  37.             TaskJob task=taskJobService.getTaskById(id);  
  38.             quartzManager.disableSchedule(task.getJobId());  
  39.               
  40.             task.setJobEnabled("N");  
  41.             taskJobService.update(task);//将任务设置成非运行状态  
  42.         }  
  43.               
  44.     }  
  45.     @RequestMapping("/add.do")  
  46.     public void add(HttpServletRequest request, HttpServletResponse response) throws IOException {  
  47.         String parameterStr="";  
  48.             parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);  
  49.             parameterStr = StringUtils.trim(parameterStr);  
  50.             Map<String, String> p = JsonUtil.getParameterMap(parameterStr);  
  51.             String jobjson=p.get("jobjson");  
  52.             jobjson=URLDecoder.decode(jobjson,"utf-8");  
  53.             TaskJob task=JsonUtil.toObject(jobjson, TaskJob.class);  
  54.             String jobName=URLDecoder.decode(task.getJobName(),"utf-8");  
  55.             task.setJobName(jobName);  
  56.             if(!StringUtils.isEmpty(jobjson)){  
  57.                 taskJobService.insert(task);  
  58.             }  
  59.               
  60.     }  
  61.       
  62.     @RequestMapping("/update.do")  
  63.     public void update(HttpServletRequest request, HttpServletResponse response) throws IOException {  
  64.         String parameterStr="";  
  65.             parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);  
  66.             parameterStr = StringUtils.trim(parameterStr);  
  67.             Map<String, String> p = JsonUtil.getParameterMap(parameterStr);  
  68.             String jobjson=p.get("jobjson");  
  69.             jobjson=URLDecoder.decode(jobjson,"utf-8");  
  70.             TaskJob task=JsonUtil.toObject(jobjson, TaskJob.class);  
  71.             String jobName=URLDecoder.decode(task.getJobName(),"utf-8");  
  72.             task.setJobName(jobName);  
  73.             if(!StringUtils.isEmpty(jobjson)){  
  74.                 taskJobService.update(task);  
  75.             }  
  76.               
  77.     }  
  78.       
  79.     @RequestMapping("/delete.do")  
  80.     public void delete(HttpServletRequest request, HttpServletResponse response) throws IOException {  
  81.         String parameterStr="";  
  82.             parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);  
  83.             parameterStr = StringUtils.trim(parameterStr);  
  84.             parameterStr =URLDecoder.decode(parameterStr,"utf-8");  
  85.             Map<String, String> p = JsonUtil.getParameterMap(parameterStr);  
  86.             String idStr=p.get("idStr");  
  87.             if(!StringUtils.isEmpty(idStr)){  
  88.                 taskJobService.delete(idStr);  
  89.             }  
  90.               
  91.     }  
  92.     @ResponseBody  
  93.     @RequestMapping("/taskList.do")  
  94.     public RecordResultBean list(HttpServletRequest request, HttpServletResponse response,@RequestParam("pageSize") int pageSize,  
  95.             @RequestParam("startIndex") int startIndex) throws IOException {  
  96.         int pageNum=startIndex/pageSize+1;  
  97.         String startDate=request.getParameter("startDate");  
  98.         String endDate=request.getParameter("endDate");  
  99.         String jobName=request.getParameter("jobName");  
  100.         if (!StringUtils.isEmpty(jobName)) {  
  101.             jobName=URLDecoder.decode(jobName, "UTF-8");  
  102.             jobName=URLDecoder.decode(jobName, "UTF-8");  
  103.         }  
  104.         RecordResultBean resultBean = new RecordResultBean();  
  105.         try {  
  106.               
  107.             Pager pager = new Pager(pageNum, pageSize);  
  108.             Map<String, Object> map = new HashMap<String, Object>();  
  109.             map.put("jobName",jobName);  
  110.             pager.setKeys(map);  
  111.             pager = taskJobService.findPage(pager);  
  112.             if (pager == null || pager.getTotalCount() == 0) {  
  113.                 resultBean.setResult(false);  
  114.   
  115.             } else {  
  116.                 resultBean.setResult(true);  
  117.                 resultBean.setBean(pager);  
  118.             }  
  119.               
  120.         }catch(Exception ex) {  
  121.             log.warn(JDKStackTrace.getJDKStrack(ex));  
  122.         }  
  123.           
  124.         return resultBean;  
  125.     }  
0 0
微商小视频制作软件 微商小视频制作软件
原创粉丝点击
热门IT博客
js字符串函数表js字符串函数表
盖德穆勒数据盖德穆勒数据
windows 包管理工具
爱问软件下载
淘宝网店效果图ps
js实现多图上传
大学生软件实训基地
tp 访客网络
淘宝物流重量什么意思
ie浏览器不能登陆淘宝
时代创联的网络商学院
淘宝三钻店铺多少钱
驱动精灵 网络打印机
linux挂载iso镜像 yum
域名邮箱怎么弄
java编程思想电子书
甜甜的 周杰伦 知乎
苹果手机商城软件
三次元教学编程视频
高斯混合模型em算法
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 建筑钢结构公司哪家好 建筑工程施工总承包 建筑施工工艺 建筑科学研究院 建筑材料有哪些 建筑工程资质 建筑模板厂家直销 建筑承包工程公司 土木建筑工程 建筑施工公司资质 建筑钢结构施工 著名建筑介绍 装配式建筑生产厂家 建筑模板工厂 建筑高级工程师 工程建筑公司 建筑模板哪里好 建筑工程承包公司 钢结构建筑施工 装配式建筑厂家 建筑工程有限公司经营范围 建筑公司设计 建筑设计资质 民用建筑节能评估 关于建筑方面的书籍 高层建筑模板工程 建筑工程个人简历 建筑工地施工 建筑资质多少钱 建筑施工公司 建筑工程施工三级资质 上海建筑设计 建筑工程承包 深圳建筑设计公司 建筑施工总承包资质标准 建筑资质怎么办 建筑钢结构工程技术 建筑单位资质 市政建筑资质 装配式建筑设计 建筑施工资质等级

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里